// -*- c++-mode -*-
//
// Definitions to ease the usage of Boost.Units' quantities in
// functors created with the Boost.Lambda library.
//
// Boost.Lambda's return type deduction system is extented to make use
// of Boost.Units' typeof_helper trait classes for
// boost::units::quantity<U, V>.
//
// Open issues:
//
// - Can some of the partial specializations be dropped?
//
// - Is there a need to add other specializations
//   (e.g, for boost::units::unit<Dim, System, Enable>)?
//
// - Is there a way to work around boost::lambda:bind's limitation
//   concerning the binding of overloaded functions? The required
//   static_cast to the function pointer (referring, e.g., a function
//   from boost/units/cmath.hpp) is tedious.
//
// Copyright (C) 2008 Torsten Maehne
//
// Boost.Units - A C++ library for zero-overhead dimensional analysis and
// unit/quantity manipulation and conversion
//
// Copyright (C) 2003-2008 Matthias Christian Schabel
// Copyright (C) 2008 Steven Watanabe
//
// Distributed under the Boost Software License, Version 1.0. (See
// accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)

#ifndef BOOST_UNITS_LAMBDA_HPP
#define BOOST_UNITS_LAMBDA_HPP

#include <boost/lambda/lambda.hpp>
#include <boost/units/units_fwd.hpp>
#include <boost/units/operators.hpp>

namespace boost {
  namespace lambda {

    // partial specialisation of return type trait for action
    // +quantity<U, V>
    template<typename U, typename V>
    struct plain_return_type_1<unary_arithmetic_action<plus_action>,
			       boost::units::quantity<U, V> > {
      typedef typename
        boost::units::unary_plus_typeof_helper<boost::units::quantity<U, V> >::type
        type;
    };

    // partial specialisation of return type trait for action
    // -quantity<U, V>
    template<typename U, typename V>
    struct plain_return_type_1<unary_arithmetic_action<minus_action>,
			       boost::units::quantity<U, V> > {
      typedef typename
        boost::units::unary_minus_typeof_helper<boost::units::quantity<U, V> >::type
        type;
    };

    // partial specialisation of return type trait for action
    // quantity<U, V> + Y
    template<typename U, typename V, typename Y>
    struct plain_return_type_2<arithmetic_action<plus_action>,
			       boost::units::quantity<U, V>,
			       Y> {
      typedef typename
        boost::units::add_typeof_helper<boost::units::quantity<U, V>, Y>::type
        type;
    };

    // partial specialisation of return type trait for action
    // X + quantity<U, V>
    template<typename X, typename U, typename V>
    struct plain_return_type_2<arithmetic_action<plus_action>,
			       X,
			       boost::units::quantity<U, V> > {
      typedef typename
        boost::units::add_typeof_helper<X, boost::units::quantity<U, V> >::type
        type;
    };

    // partial specialisation of return type trait for action
    // quantity<U1, V1> + quantity<U2, V2>
    template<typename U1, typename V1, typename U2, typename V2>
    struct plain_return_type_2<arithmetic_action<plus_action>,
			       boost::units::quantity<U1, V1>,
			       boost::units::quantity<U2, V2> > {
      typedef typename
        boost::units::add_typeof_helper<boost::units::quantity<U1, V1>,
					boost::units::quantity<U2, V2> >::type
        type;
    };

    // partial specialisation of return type trait for action
    // quantity<U, V> - Y
    template<typename U, typename V, typename Y>
    struct plain_return_type_2<arithmetic_action<minus_action>,
			       boost::units::quantity<U, V>,
			       Y> {
      typedef typename
        boost::units::subtract_typeof_helper<boost::units::quantity<U, V>, Y>::type
        type;
    };

    // partial specialisation of return type trait for action
    // X - quantity<U, V>
    template<typename X, typename U, typename V>
    struct plain_return_type_2<arithmetic_action<minus_action>,
			       X,
			       boost::units::quantity<U, V> > {
      typedef typename
        boost::units::subtract_typeof_helper<X, boost::units::quantity<U, V> >::type
        type;
    };

    // partial specialisation of return type trait for action
    // quantity<U1, V1> - quantity<U2, V2>
    template<typename U1, typename V1, typename U2, typename V2>
    struct plain_return_type_2<arithmetic_action<minus_action>,
			       boost::units::quantity<U1, V1>,
			       boost::units::quantity<U2, V2> > {
      typedef typename
        boost::units::subtract_typeof_helper<boost::units::quantity<U1, V1>,
					     boost::units::quantity<U2, V2> >::type
        type;
    };

    // partial specialisation of return type trait for action
    // quantity<U, V> * Y
    template<typename U, typename V, typename Y>
    struct plain_return_type_2<arithmetic_action<multiply_action>,
			       boost::units::quantity<U, V>,
			       Y> {
      typedef typename
        boost::units::multiply_typeof_helper<boost::units::quantity<U, V>, Y>::type
        type;
    };

    // partial specialisation of return type trait for action
    // X * quantity<U, V>
    template<typename X, typename U, typename V>
    struct plain_return_type_2<arithmetic_action<multiply_action>,
			       X,
			       boost::units::quantity<U, V> > {
      typedef typename
        boost::units::multiply_typeof_helper<X, boost::units::quantity<U, V> >::type
        type;
    };

    // partial specialisation of return type trait for action
    // quantity<U1, V1> * quantity<U2, V2>
    template<typename U1, typename V1, typename U2, typename V2>
    struct plain_return_type_2<arithmetic_action<multiply_action>,
			       boost::units::quantity<U1, V1>,
			       boost::units::quantity<U2, V2> > {
      typedef typename
        boost::units::multiply_typeof_helper<boost::units::quantity<U1, V1>,
					     boost::units::quantity<U2, V2> >::type
        type;
    };

    // partial specialisation of return type trait for action
    // quantity<U, V> / Y
    template<typename U, typename V, typename Y>
    struct plain_return_type_2<arithmetic_action<divide_action>,
			       boost::units::quantity<U, V>,
			       Y> {
      typedef typename
        boost::units::divide_typeof_helper<boost::units::quantity<U, V>, Y>::type
        type;
    };

    // partial specialisation of return type trait for action
    // X / quantity<U, V>
    template<typename X, typename U, typename V>
    struct plain_return_type_2<arithmetic_action<divide_action>,
			       X,
			       boost::units::quantity<U, V> > {
      typedef typename
        boost::units::divide_typeof_helper<X, boost::units::quantity<U, V> >::type
        type;
    };

    // partial specialisation of return type trait for action
    // quantity<U1, V1> / quantity<U2, V2>
    template<typename U1, typename V1, typename U2, typename V2>
    struct plain_return_type_2<arithmetic_action<divide_action>,
			       boost::units::quantity<U1, V1>,
			       boost::units::quantity<U2, V2> > {
      typedef typename
        boost::units::divide_typeof_helper<boost::units::quantity<U1, V1>,
					   boost::units::quantity<U2, V2> >::type
        type;
    };

  }
}

#endif // BOOST_UNITS_LAMBDA_HPP