use 5.008001;
use utf8;
use strict;
use warnings FATAL => 'all';

###########################################################################
###########################################################################

{ package Muldis::DB::Engine::Example::Operators; # module
    our $VERSION = 0.004000;

    use bigint; # this is experimental

    use Carp;

    use Muldis::DB::Engine::Example::PhysType qw(ptBool ptOrder ptInt
        ptBlob ptText ptTuple ptQuasiTuple ptRelation ptQuasiRelation
        ptTypeInvo ptQuasiTypeInvo ptTypeDict ptQuasiTypeDict ptValueDict
        ptQuasiTypeDict);

    my $OPS = { # Hash

###########################################################################

## sys.Core.Universal.Universal ##

'sys.Core.Universal.is_equal' => sub {
    my ($dbms, $ro_args) = @_;
    my ($v1, $v2) = @{$ro_args}{'v1', 'v2'};
    return ptBool({ 'v' => $v1->equal( $v2 ) });
},

'sys.Core.Universal.is_not_equal' => sub {
    my ($dbms, $ro_args) = @_;
    my ($v1, $v2) = @{$ro_args}{'v1', 'v2'};
    return ptBool({ 'v' => !$v1->equal( $v2 ) });
},

'sys.Core.Universal.assign' => sub {
    my ($dbms, $upd_args, $ro_args) = @_;
    my ($target) = @{$upd_args}{'target'};
    my ($v) = @{$ro_args}{'v'};
    $target->store( $v );
    return;
},

## sys.Core.Bool.Bool ##


## sys.Core.Order.Order ##


## sys.Core.Int.Int ##

'sys.Core.Int.sum' => sub {
    my ($dbms, $ro_args) = @_;
    my ($addends) = @{$ro_args}{'addends'};
    my $sum = 0;
    for my $addend (@{$addends->array_from_value_attr()}) {
        $sum += $addend->v();
    }
    return ptInt({ 'v' => $sum });
},

'sys.Core.Int.difference' => sub {
    my ($dbms, $ro_args) = @_;
    my ($minuend, $subtrahend) = @{$ro_args}{'minuend', 'subtrahend'};
    return ptInt({ 'v' => $minuend->v() - $subtrahend->v() });
},

'sys.Core.Int.product' => sub {
    my ($dbms, $ro_args) = @_;
    my ($factors) = @{$ro_args}{'factors'};
    my $product = 1;
    for my $factor (@{$factors->array_from_value_attr()}) {
        $product *= $factor->v();
    }
    return ptInt({ 'v' => $product });
},

'sys.Core.Int.quotient' => sub {
    my ($dbms, $ro_args) = @_;
    my ($dividend, $divisor) = @{$ro_args}{'dividend', 'divisor'};
    my $divisor_v = $divisor->v();
    confess q{sys.Core.Int.quotient(): Arg :$divisor is zero.}
        if $divisor_v == 0;
    my $p5_num = $dividend->v() / $divisor_v;
    my $p5_int
        = int $p5_num == $p5_num ? $p5_num # includes $p5_num == 0
        : $p5_num > 0            ? int $p5_num     # floor(2.3)  ->  2
        :                          int $p5_num - 1 # floor(-2.3) -> -3
        ;
    return ptInt({ 'v' => $p5_int });
},

'sys.Core.Int.remainder' => sub {
    my ($dbms, $ro_args) = @_;
    my ($dividend, $divisor) = @{$ro_args}{'dividend', 'divisor'};
    my $divisor_v = $divisor->v();
    confess q{sys.Core.Int.remainder(): Arg :$divisor is zero.}
        if $divisor_v == 0;
    return ptInt({ 'v' => $dividend->v() % $divisor_v });
},

'sys.Core.Int.abs' => sub {
    my ($dbms, $ro_args) = @_;
    my ($v) = @{$ro_args}{'v'};
    return ptInt({ 'v' => abs $v->v() });
},

'sys.Core.Int.power' => sub {
    my ($dbms, $ro_args) = @_;
    my ($radix, $exponent) = @{$ro_args}{'radix', 'exponent'};
    return ptInt({ 'v' => $radix->v() ** $exponent->v() });
},

## sys.Core.Num.Num ##


## sys.Core.Blob.Blob ##


## sys.Core.Text.Text ##


## sys.Core.Tuple.Tuple ##


## sys.Core.Relation.Relation ##


###########################################################################

    }; # my Hash $OPS

    sub get_ops {
        return $OPS;
    }

} # module Muldis::DB::Engine::Example::Operators

###########################################################################
###########################################################################

1; # Magic true value required at end of a reusable file's code.
__END__

=pod

=encoding utf8

=head1 NAME

Muldis::DB::Engine::Example::Operators -
Implementations of all core Muldis D system-defined operators

=head1 VERSION

This document describes Muldis::DB::Engine::Example::Operators version
0.4.0 for Perl 5.

=head1 DESCRIPTION

This file is used internally by L<Muldis::DB::Engine::Example>; it is not
intended to be used directly in user code.

It provides implementations of all core Muldis D system-defined operators,
and their API is designed to exactly match the operator definitions in
L<Language::MuldisD>.

Specifically, this file implements the core system-defined operators that
all Muldis D implementations must have, which is the selectors for and
general purpose functions and update operators for these data types: Bool,
Order, Int, Num, Text, Blob, Tuple, Relation, and the Cat.* types.

By contrast, the operators specific to the optional data types are
implemented by other files:
L<Muldis::DB::Engine::Example::Operators::Temporal>,
L<Muldis::DB::Engine::Example::Operators::Spatial>.

=head1 BUGS AND LIMITATIONS

The operators declared in this file assume that any user-defined Muldis D
code which could be invoking them has already been validated by the Muldis
D compiler, in so far as compile time validation can be done, and so the
operators in this file only test for invalid input such that couldn't be
expected to be caught at compile time.  For example, it is usually expected
that the compiler will catch attempts to invoke these operators with the
wrong number of arguments, or arguments with the wrong names or data types.
So if the compiler missed something which the runtime doesn't expect to
have to validate, then the Example Engine could have inelegant failures.

=head1 AUTHOR

Darren Duncan (C<perl@DarrenDuncan.net>)

=head1 LICENSE AND COPYRIGHT

This file is part of the Muldis DB framework.

Muldis DB is Copyright © 2002-2007, Darren Duncan.

See the LICENSE AND COPYRIGHT of L<Muldis::DB> for details.

=cut