#!/usr/bin/env python

"""

Operator support.

Copyright (C) 2010 Paul Boddie <paul@boddie.org.uk>

This program is free software; you can redistribute it and/or modify it under

the terms of the GNU General Public License as published by the Free Software

Foundation; either version 3 of the License, or (at your option) any later

version.

This program is distributed in the hope that it will be useful, but WITHOUT

ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS

FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more

details.

You should have received a copy of the GNU General Public License along with

this program.  If not, see <http://www.gnu.org/licenses/>.

"""

def binary_op(a, b, left_accessor, right_accessor):

    """

    A single parameterised function providing the binary operator mechanism for

    arguments 'a' and 'b' using accessors given as 'left_accessor' and

    'right_accessor' which provide the methods for the operands.

    """

    # First, try and get a method for the left argument, and then call it with

    # the right argument.

    try:

        fn = left_accessor(a)

    except AttributeError:

        pass

    else:

        result = fn(b)

        if result is not NotImplemented:

            return result

    # Otherwise, try and get a method for the right argument, and then call it

    # with the left argument.

    try:

        fn = right_accessor(b)

    except AttributeError:

        pass

    else:

        result = fn(a)

        if result is not NotImplemented:

            return result

    # Where no methods were available, or if neither method could support the

    # operation, raise an exception.

    raise TypeError

# Concrete operator functions.

# These functions defer method lookup by wrapping the attribute access in

# lambda functions. Thus, the appropriate methods are defined locally, but no

# attempt to obtain them is made until the generic function is called.

# NOTE: The compiler should make it possible for these to call the generic

# NOTE: operator implementation with no additional call overhead.

def add(a, b):

    return binary_op(a, b, lambda a: a.__add__, lambda b: b.__radd__)

def and_(a, b):

    return binary_op(a, b, lambda a: a.__and__, lambda b: b.__rand__)

def div(a, b):

    return binary_op(a, b, lambda a: a.__div__, lambda b: b.__rdiv__)

def floordiv(a, b):

    return binary_op(a, b, lambda a: a.__floordiv__, lambda b: b.__rfloordiv__)

def lshift(a, b):

    return binary_op(a, b, lambda a: a.__lshift__, lambda b: b.__rlshift__)

def mod(a, b):

    return binary_op(a, b, lambda a: a.__mod__, lambda b: b.__rmod__)

def mul(a, b):

    return binary_op(a, b, lambda a: a.__mul__, lambda b: b.__rmul__)

def or_(a, b):

    return binary_op(a, b, lambda a: a.__or__, lambda b: b.__ror__)

def pow(a, b):

    return binary_op(a, b, lambda a: a.__pow__, lambda b: b.__rpow__)

def rshift(a, b):

    return binary_op(a, b, lambda a: a.__rshift__, lambda b: b.__rrshift__)

def sub(a, b):

    return binary_op(a, b, lambda a: a.__sub__, lambda b: b.__rsub__)

def xor(a, b):

    return binary_op(a, b, lambda a: a.__xor__, lambda b: b.__rxor__)

# vim: tabstop=4 expandtab shiftwidth=4