Chris@16: // Boost.Units - A C++ library for zero-overhead dimensional analysis and
Chris@16: // unit/quantity manipulation and conversion
Chris@16: //
Chris@16: // Copyright (C) 2003-2008 Matthias Christian Schabel
Chris@16: // Copyright (C) 2008 Steven Watanabe
Chris@16: //
Chris@16: // Distributed under the Boost Software License, Version 1.0. (See
Chris@16: // accompanying file LICENSE_1_0.txt or copy at
Chris@16: // http://www.boost.org/LICENSE_1_0.txt)
Chris@16: 
Chris@16: // $Id: lambda.hpp 27 2008-06-16 14:50:58Z maehne $
Chris@16: 
Chris@16: #ifndef BOOST_UNITS_LAMBDA_HPP
Chris@16: #define BOOST_UNITS_LAMBDA_HPP
Chris@16: 
Chris@16: 
Chris@16: ////////////////////////////////////////////////////////////////////////
Chris@16: ///
Chris@16: /// \file lambda.hpp
Chris@16: ///
Chris@16: /// \brief Definitions to ease the usage of Boost.Units' quantity,
Chris@16: ///        unit, and absolute types in functors created with the
Chris@16: ///        Boost.Lambda library.
Chris@16: ///
Chris@16: /// \author Torsten Maehne
Chris@16: /// \date   2008-06-16
Chris@16: ///
Chris@16: /// Boost.Lambda's return type deduction system is extented to make
Chris@16: /// use of Boost.Units' typeof_helper trait classes for Boost.Units'
Chris@16: /// quantity, absolute, and unit template classes.
Chris@16: ///
Chris@16: ////////////////////////////////////////////////////////////////////////
Chris@16: 
Chris@16: 
Chris@16: #include <boost/lambda/lambda.hpp>
Chris@16: #include <boost/units/units_fwd.hpp>
Chris@16: #include <boost/units/detail/dimensionless_unit.hpp>
Chris@16: #include <boost/units/operators.hpp>
Chris@16: 
Chris@16: namespace boost {
Chris@16: 
Chris@16: namespace lambda {
Chris@16: 
Chris@16:     /// Partial specialization of return type trait for action
Chris@16:     /// unit<Dim, System> * Y.
Chris@16:     template<typename System, typename Dim, typename Y>
Chris@16:     struct plain_return_type_2<arithmetic_action<multiply_action>,
Chris@16:                                boost::units::unit<Dim, System>,
Chris@16:                                Y > {
Chris@16:         typedef typename boost::units::multiply_typeof_helper<
Chris@16:             boost::units::unit<Dim, System>, Y >::type type;
Chris@16:     };
Chris@16: 
Chris@16: } // namespace lambda
Chris@16: 
Chris@16: namespace units {
Chris@16: 
Chris@16:     template<typename System, typename Dim, typename Arg>
Chris@16:     struct multiply_typeof_helper<boost::units::unit<Dim, System>, boost::lambda::lambda_functor<Arg> > {
Chris@16:         typedef boost::lambda::lambda_functor<
Chris@16:           boost::lambda::lambda_functor_base<
Chris@16:               boost::lambda::arithmetic_action<boost::lambda::multiply_action>,
Chris@16:               tuple<typename boost::lambda::const_copy_argument<const boost::units::unit<Dim, System> >::type, boost::lambda::lambda_functor<Arg> >
Chris@16:           >
Chris@16:         > type;
Chris@16:     };
Chris@16: 
Chris@16:     /// Disambiguating overload for action
Chris@16:     /// unit<Dim, System> * lambda_functor<Arg>
Chris@16:     /// based on \<boost/lambda/detail/operators.hpp\>.
Chris@16:     template<typename System, typename Dim, typename Arg>
Chris@16:     inline const typename multiply_typeof_helper<boost::units::unit<Dim, System>, boost::lambda::lambda_functor<Arg> >::type
Chris@16:     operator*(const boost::units::unit<Dim, System>& a,
Chris@16:               const boost::lambda::lambda_functor<Arg>& b) {
Chris@16:         return typename multiply_typeof_helper<boost::units::unit<Dim, System>, boost::lambda::lambda_functor<Arg> >::type::inherited
Chris@16:                (tuple<typename boost::lambda::const_copy_argument<const boost::units::unit<Dim, System> >::type,
Chris@16:                       boost::lambda::lambda_functor<Arg> >
Chris@16:                      (a, b));
Chris@16:     }
Chris@16: 
Chris@16: } // namespace units
Chris@16: 
Chris@16: namespace lambda {
Chris@16: 
Chris@16:     /// Partial specialization of return type trait for action
Chris@16:     /// unit<Dim, System> / Y.
Chris@16:     template<typename System, typename Dim, typename Y>
Chris@16:     struct plain_return_type_2<arithmetic_action<divide_action>,
Chris@16:                                boost::units::unit<Dim, System>,
Chris@16:                                Y > {
Chris@16:         typedef typename boost::units::divide_typeof_helper<
Chris@16:             boost::units::unit<Dim, System>, Y >::type type;
Chris@16:     };
Chris@16: 
Chris@16: } // namespace lambda
Chris@16: 
Chris@16: namespace units {
Chris@16: 
Chris@16:     template<typename System, typename Dim, typename Arg>
Chris@16:     struct divide_typeof_helper<boost::units::unit<Dim, System>, boost::lambda::lambda_functor<Arg> > {
Chris@16:         typedef boost::lambda::lambda_functor<
Chris@16:           boost::lambda::lambda_functor_base<
Chris@16:             boost::lambda::arithmetic_action<boost::lambda::divide_action>,
Chris@16:               tuple<typename boost::lambda::const_copy_argument<const boost::units::unit<Dim, System> >::type, boost::lambda::lambda_functor<Arg> >
Chris@16:           >
Chris@16:         > type;
Chris@16:     };
Chris@16: 
Chris@16:     /// Disambiguating overload for action
Chris@16:     /// unit<Dim, System> / lambda_functor<Arg>
Chris@16:     /// based on \<boost/lambda/detail/operators.hpp\>.
Chris@16:     template<typename System, typename Dim, typename Arg>
Chris@16:     inline const typename divide_typeof_helper<boost::units::unit<Dim, System>, boost::lambda::lambda_functor<Arg> >::type
Chris@16:     operator/(const boost::units::unit<Dim, System>& a,
Chris@16:               const boost::lambda::lambda_functor<Arg>& b) {
Chris@16:         return typename divide_typeof_helper<boost::units::unit<Dim, System>, boost::lambda::lambda_functor<Arg> >::type::inherited
Chris@16:                (tuple<typename boost::lambda::const_copy_argument<const boost::units::unit<Dim, System> >::type,
Chris@16:                       boost::lambda::lambda_functor<Arg> >
Chris@16:                      (a, b));
Chris@16:     }
Chris@16: 
Chris@16: } // namespace units
Chris@16: 
Chris@16: namespace lambda {
Chris@16: 
Chris@16:     /// Partial specialization of return type trait for action
Chris@16:     /// Y * unit<Dim, System>.
Chris@16:     template<typename System, typename Dim, typename Y>
Chris@16:     struct plain_return_type_2<arithmetic_action<multiply_action>,
Chris@16:                                Y,
Chris@16:                                boost::units::unit<Dim, System> > {
Chris@16:         typedef typename boost::units::multiply_typeof_helper<
Chris@16:             Y, boost::units::unit<Dim, System> >::type type;
Chris@16:     };
Chris@16: 
Chris@16: } // namespace lambda
Chris@16: 
Chris@16: namespace units {
Chris@16: 
Chris@16:     template<typename System, typename Dim, typename Arg>
Chris@16:     struct multiply_typeof_helper<boost::lambda::lambda_functor<Arg>, boost::units::unit<Dim, System> > {
Chris@16:         typedef boost::lambda::lambda_functor<
Chris@16:           boost::lambda::lambda_functor_base<
Chris@16:             boost::lambda::arithmetic_action<boost::lambda::multiply_action>,
Chris@16:               tuple<boost::lambda::lambda_functor<Arg>, typename boost::lambda::const_copy_argument<const boost::units::unit<Dim, System> >::type>
Chris@16:           >
Chris@16:         > type;
Chris@16:     };
Chris@16: 
Chris@16:     /// Disambiguating overload for action
Chris@16:     /// lambda_functor<Arg> * unit<Dim, System>
Chris@16:     /// based on \<boost/lambda/detail/operators.hpp\>.
Chris@16:     template<typename System, typename Dim, typename Arg>
Chris@16:     inline const typename multiply_typeof_helper<boost::lambda::lambda_functor<Arg>, boost::units::unit<Dim, System> >::type
Chris@16:     operator*(const boost::lambda::lambda_functor<Arg>& a,
Chris@16:               const boost::units::unit<Dim, System>& b) {
Chris@16:         return typename multiply_typeof_helper<boost::lambda::lambda_functor<Arg>, boost::units::unit<Dim, System> >::type::inherited
Chris@16:                (tuple<boost::lambda::lambda_functor<Arg>,
Chris@16:                       typename boost::lambda::const_copy_argument<const boost::units::unit<Dim, System> >::type>
Chris@16:                      (a, b));
Chris@16:     }
Chris@16: 
Chris@16: } // namespace units
Chris@16: 
Chris@16: namespace lambda {
Chris@16: 
Chris@16:     /// Partial specialization of return type trait for action
Chris@16:     /// Y / unit<Dim, System>.
Chris@16:     template<typename System, typename Dim, typename Y>
Chris@16:     struct plain_return_type_2<arithmetic_action<divide_action>,
Chris@16:                                Y,
Chris@16:                                boost::units::unit<Dim, System> > {
Chris@16:         typedef typename boost::units::divide_typeof_helper<
Chris@16:             Y, boost::units::unit<Dim, System> >::type type;
Chris@16:     };
Chris@16: 
Chris@16: } // namespace lambda
Chris@16: 
Chris@16: namespace units {
Chris@16: 
Chris@16:     template<typename System, typename Dim, typename Arg>
Chris@16:     struct divide_typeof_helper<boost::lambda::lambda_functor<Arg>, boost::units::unit<Dim, System> > {
Chris@16:         typedef boost::lambda::lambda_functor<
Chris@16:           boost::lambda::lambda_functor_base<
Chris@16:             boost::lambda::arithmetic_action<boost::lambda::divide_action>,
Chris@16:               tuple<boost::lambda::lambda_functor<Arg>, typename boost::lambda::const_copy_argument<const boost::units::unit<Dim, System> >::type>
Chris@16:           >
Chris@16:         > type;
Chris@16:     };
Chris@16: 
Chris@16:     /// Disambiguating overload for action
Chris@16:     /// lambda_functor<Arg> / unit<Dim, System>
Chris@16:     /// based on \<boost/lambda/detail/operators.hpp\>.
Chris@16:     template<typename System, typename Dim, typename Arg>
Chris@16:     inline const typename divide_typeof_helper<boost::lambda::lambda_functor<Arg>, boost::units::unit<Dim, System> >::type
Chris@16:     operator/(const boost::lambda::lambda_functor<Arg>& a,
Chris@16:               const boost::units::unit<Dim, System>& b) {
Chris@16:         return typename divide_typeof_helper<boost::lambda::lambda_functor<Arg>, boost::units::unit<Dim, System> >::type::inherited
Chris@16:                (tuple<boost::lambda::lambda_functor<Arg>,
Chris@16:                       typename boost::lambda::const_copy_argument<const boost::units::unit<Dim, System> >::type>
Chris@16:                      (a, b));
Chris@16:     }
Chris@16: 
Chris@16: } // namespace units
Chris@16: 
Chris@16: namespace lambda {
Chris@16: 
Chris@16:     /// Partial specialization of return type trait for action
Chris@16:     /// quantity<Unit, X> * X.
Chris@16:     template<typename Unit, typename X>
Chris@16:     struct plain_return_type_2<arithmetic_action<multiply_action>,
Chris@16:                                boost::units::quantity<Unit, X>,
Chris@16:                                X> {
Chris@16:         typedef typename boost::units::multiply_typeof_helper<
Chris@16:             boost::units::quantity<Unit, X>, X>::type type;
Chris@16:     };
Chris@16: 
Chris@16:     /// Partial specialization of return type trait for action
Chris@16:     /// X * quantity<Unit, X>.
Chris@16:     template<typename Unit, typename X>
Chris@16:     struct plain_return_type_2<arithmetic_action<multiply_action>,
Chris@16:                                X,
Chris@16:                                boost::units::quantity<Unit, X> > {
Chris@16:         typedef typename boost::units::multiply_typeof_helper<
Chris@16:             X, boost::units::quantity<Unit, X> >::type type;
Chris@16:     };
Chris@16: 
Chris@16:     /// Partial specialization of return type trait for action
Chris@16:     /// quantity<Unit, X> / X.
Chris@16:     template<typename Unit, typename X>
Chris@16:     struct plain_return_type_2<arithmetic_action<divide_action>,
Chris@16:                                boost::units::quantity<Unit, X>,
Chris@16:                                X> {
Chris@16:         typedef typename boost::units::divide_typeof_helper<
Chris@16:             boost::units::quantity<Unit, X>, X>::type type;
Chris@16:     };
Chris@16: 
Chris@16:     /// Partial specialization of return type trait for action
Chris@16:     /// X / quantity<Unit, X>.
Chris@16:     template<typename Unit, typename X>
Chris@16:     struct plain_return_type_2<arithmetic_action<divide_action>,
Chris@16:                                X,
Chris@16:                                boost::units::quantity<Unit, X> > {
Chris@16:         typedef typename boost::units::divide_typeof_helper<
Chris@16:             X, boost::units::quantity<Unit, X> >::type type;
Chris@16:     };
Chris@16: 
Chris@16:     /// Partial specialization of return type trait for action
Chris@16:     /// unit<Dim1, System1> * quantity<Unit2, Y>.
Chris@16:     template<typename System1, typename Dim1, typename Unit2, typename Y>
Chris@16:     struct plain_return_type_2<arithmetic_action<multiply_action>,
Chris@16:                                boost::units::unit<Dim1, System1>,
Chris@16:                                boost::units::quantity<Unit2, Y> > {
Chris@16:         typedef typename boost::units::multiply_typeof_helper<
Chris@16:             boost::units::unit<Dim1, System1>,
Chris@16:             boost::units::quantity<Unit2, Y> >::type type;
Chris@16:     };
Chris@16: 
Chris@16:     /// Partial specialization of return type trait for action
Chris@16:     /// unit<Dim1, System1> / quantity<Unit2, Y>.
Chris@16:     template<typename System1, typename Dim1, typename Unit2, typename Y>
Chris@16:     struct plain_return_type_2<arithmetic_action<divide_action>,
Chris@16:                                boost::units::unit<Dim1, System1>,
Chris@16:                                boost::units::quantity<Unit2, Y> > {
Chris@16:         typedef typename boost::units::divide_typeof_helper<
Chris@16:             boost::units::unit<Dim1, System1>,
Chris@16:             boost::units::quantity<Unit2, Y> >::type type;
Chris@16:     };
Chris@16: 
Chris@16:     /// Partial specialization of return type trait for action
Chris@16:     /// quantity<Unit1, Y> * unit<Dim2, System2>.
Chris@16:     template<typename Unit1, typename Y, typename System2, typename Dim2>
Chris@16:     struct plain_return_type_2<arithmetic_action<multiply_action>,
Chris@16:                                boost::units::quantity<Unit1, Y>,
Chris@16:                                boost::units::unit<Dim2, System2> > {
Chris@16:         typedef typename boost::units::multiply_typeof_helper<
Chris@16:             boost::units::quantity<Unit1, Y>,
Chris@16:             boost::units::unit<Dim2, System2> >::type type;
Chris@16:     };
Chris@16: 
Chris@16:     /// Partial specialization of return type trait for action
Chris@16:     /// quantity<Unit1, Y> / unit<Dim2, System2>.
Chris@16:     template<typename Unit1, typename Y, typename System2, typename Dim2>
Chris@16:     struct plain_return_type_2<arithmetic_action<divide_action>,
Chris@16:                                boost::units::quantity<Unit1, Y>,
Chris@16:                                boost::units::unit<Dim2, System2> > {
Chris@16:         typedef typename boost::units::divide_typeof_helper<
Chris@16:             boost::units::quantity<Unit1, Y>,
Chris@16:             boost::units::unit<Dim2, System2> >::type type;
Chris@16:     };
Chris@16: 
Chris@16:     /// Partial specialization of return type trait for action
Chris@16:     /// +quantity<Unit, Y>.
Chris@16:     template<typename Unit, typename Y>
Chris@16:     struct plain_return_type_1<unary_arithmetic_action<plus_action>,
Chris@16:                                boost::units::quantity<Unit, Y> > {
Chris@16:         typedef typename boost::units::unary_plus_typeof_helper<
Chris@16:             boost::units::quantity<Unit, Y> >::type type;
Chris@16:     };
Chris@16: 
Chris@16:     /// Partial specialization of return type trait for action
Chris@16:     /// -quantity<Unit, Y>.
Chris@16:     template<typename Unit, typename Y>
Chris@16:     struct plain_return_type_1<unary_arithmetic_action<minus_action>,
Chris@16:                                boost::units::quantity<Unit, Y> > {
Chris@16:         typedef typename boost::units::unary_minus_typeof_helper<
Chris@16:             boost::units::quantity<Unit, Y> >::type type;
Chris@16:     };
Chris@16: 
Chris@16:     /// Partial specialization of return type trait for action
Chris@16:     /// quantity<Unit1, X> + quantity<Unit2, Y>.
Chris@16:     template<typename Unit1, typename X, typename Unit2, typename Y>
Chris@16:     struct plain_return_type_2<arithmetic_action<plus_action>,
Chris@16:                                boost::units::quantity<Unit1, X>,
Chris@16:                                boost::units::quantity<Unit2, Y> > {
Chris@16:         typedef typename boost::units::add_typeof_helper<
Chris@16:             boost::units::quantity<Unit1, X>,
Chris@16:             boost::units::quantity<Unit2, Y> >::type type;
Chris@16:     };
Chris@16: 
Chris@16:     /// Partial specialization of return type trait for action
Chris@16:     /// quantity<dimensionless, X> + Y.
Chris@16:     template<typename System, typename X, typename Y>
Chris@16:     struct plain_return_type_2<arithmetic_action<plus_action>,
Chris@16:                                boost::units::quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(System), X>,
Chris@16:                                Y> {
Chris@16:         typedef typename boost::units::add_typeof_helper<
Chris@16:             boost::units::quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(System), X>,
Chris@16:             Y>::type type;
Chris@16:     };
Chris@16: 
Chris@16:     /// Partial specialization of return type trait for action
Chris@16:     /// X + quantity<dimensionless, Y>.
Chris@16:     template<typename System, typename X, typename Y>
Chris@16:     struct plain_return_type_2<arithmetic_action<plus_action>,
Chris@16:                                X,
Chris@16:                                boost::units::quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(System), Y> > {
Chris@16:         typedef typename boost::units::add_typeof_helper<
Chris@16:             X,
Chris@16:             boost::units::quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(System), Y> >::type type;
Chris@16:     };
Chris@16: 
Chris@16:     /// Partial specialization of return type trait for action
Chris@16:     /// quantity<Unit1, X> - quantity<Unit2, Y>.
Chris@16:     template<typename Unit1, typename X, typename Unit2, typename Y>
Chris@16:     struct plain_return_type_2<arithmetic_action<minus_action>,
Chris@16:                                boost::units::quantity<Unit1, X>,
Chris@16:                                boost::units::quantity<Unit2, Y> > {
Chris@16:         typedef typename boost::units::subtract_typeof_helper<
Chris@16:             boost::units::quantity<Unit1, X>,
Chris@16:             boost::units::quantity<Unit2, Y> >::type type;
Chris@16:     };
Chris@16: 
Chris@16:     /// Partial specialization of return type trait for action
Chris@16:     /// quantity<dimensionless, X> - Y.
Chris@16:     template<typename System, typename X, typename Y>
Chris@16:     struct plain_return_type_2<arithmetic_action<minus_action>,
Chris@16:                                boost::units::quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(System), X>,
Chris@16:                                Y> {
Chris@16:         typedef typename boost::units::subtract_typeof_helper<
Chris@16:             boost::units::quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(System), X>,
Chris@16:             Y>::type type;
Chris@16:     };
Chris@16: 
Chris@16:     /// Partial specialization of return type trait for action
Chris@16:     /// X - quantity<dimensionless, Y>.
Chris@16:     template<typename System, typename X, typename Y>
Chris@16:     struct plain_return_type_2<arithmetic_action<minus_action>,
Chris@16:                                X,
Chris@16:                                boost::units::quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(System), Y> > {
Chris@16:         typedef typename boost::units::subtract_typeof_helper<
Chris@16:             X,
Chris@16:             boost::units::quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(System), Y> >::type type;
Chris@16:     };
Chris@16: 
Chris@16:     /// Partial specialization of return type trait for action
Chris@16:     /// quantity<Unit1, X> * quantity<Unit2, Y>.
Chris@16:     template<typename Unit1, typename X, typename Unit2, typename Y>
Chris@16:     struct plain_return_type_2<arithmetic_action<multiply_action>,
Chris@16:                                boost::units::quantity<Unit1, X>,
Chris@16:                                boost::units::quantity<Unit2, Y> > {
Chris@16:         typedef typename boost::units::multiply_typeof_helper<
Chris@16:             boost::units::quantity<Unit1, X>,
Chris@16:             boost::units::quantity<Unit2, Y> >::type type;
Chris@16:     };
Chris@16: 
Chris@16:     /// Partial specialization of return type trait for action
Chris@16:     /// quantity<Unit1, X> / quantity<Unit2, Y>.
Chris@16:     template<typename Unit1, typename X, typename Unit2, typename Y>
Chris@16:     struct plain_return_type_2<arithmetic_action<divide_action>,
Chris@16:                                boost::units::quantity<Unit1, X>,
Chris@16:                                boost::units::quantity<Unit2, Y> > {
Chris@16:         typedef typename boost::units::divide_typeof_helper<
Chris@16:             boost::units::quantity<Unit1, X>,
Chris@16:             boost::units::quantity<Unit2, Y> >::type type;
Chris@16:     };
Chris@16: 
Chris@16: 
Chris@16:     ////////////////////////////////////////////////////////////////////////
Chris@16:     // Partial specialization of Boost.Lambda's trait classes for all
Chris@16:     // operators overloaded in <boost/units/unit.hpp>
Chris@16:     ////////////////////////////////////////////////////////////////////////
Chris@16: 
Chris@16:     /// Partial specialization of return type trait for action
Chris@16:     /// +unit<Dim, System>.
Chris@16:     template<typename Dim, typename System>
Chris@16:     struct plain_return_type_1<unary_arithmetic_action<plus_action>,
Chris@16:                                boost::units::unit<Dim, System> > {
Chris@16:         typedef typename boost::units::unary_plus_typeof_helper<
Chris@16:             boost::units::unit<Dim, System> >::type type;
Chris@16:     };
Chris@16: 
Chris@16:     /// Partial specialization of return type trait for action
Chris@16:     /// -unit<Dim, System>.
Chris@16:     template<typename Dim, typename System>
Chris@16:     struct plain_return_type_1<unary_arithmetic_action<minus_action>,
Chris@16:                                boost::units::unit<Dim, System> > {
Chris@16:         typedef typename boost::units::unary_minus_typeof_helper<
Chris@16:             boost::units::unit<Dim, System> >::type type;
Chris@16:     };
Chris@16: 
Chris@16:     /// Partial specialization of return type trait for action
Chris@16:     /// unit<Dim1, System1> + unit<Dim2, System2>.
Chris@16:     template<typename Dim1, typename Dim2, typename System1, typename System2>
Chris@16:     struct plain_return_type_2<arithmetic_action<plus_action>,
Chris@16:                                boost::units::unit<Dim1, System1>,
Chris@16:                                boost::units::unit<Dim2, System2> > {
Chris@16:         typedef typename boost::units::add_typeof_helper<
Chris@16:             boost::units::unit<Dim1, System1>,
Chris@16:             boost::units::unit<Dim2, System2> >::type type;
Chris@16:     };
Chris@16: 
Chris@16:     /// Partial specialization of return type trait for action
Chris@16:     /// unit<Dim1, System1> - unit<Dim2, System2>.
Chris@16:     template<typename Dim1, typename Dim2, typename System1, typename System2>
Chris@16:     struct plain_return_type_2<arithmetic_action<minus_action>,
Chris@16:                                boost::units::unit<Dim1, System1>,
Chris@16:                                boost::units::unit<Dim2, System2> > {
Chris@16:         typedef typename boost::units::subtract_typeof_helper<
Chris@16:             boost::units::unit<Dim1, System1>,
Chris@16:             boost::units::unit<Dim2, System2> >::type type;
Chris@16:     };
Chris@16: 
Chris@16:     /// Partial specialization of return type trait for action
Chris@16:     /// unit<Dim1, System1> * unit<Dim2, System2>.
Chris@16:     template<typename Dim1, typename Dim2, typename System1, typename System2>
Chris@16:     struct plain_return_type_2<arithmetic_action<multiply_action>,
Chris@16:                                boost::units::unit<Dim1, System1>,
Chris@16:                                boost::units::unit<Dim2, System2> > {
Chris@16:         typedef typename boost::units::multiply_typeof_helper<
Chris@16:             boost::units::unit<Dim1, System1>,
Chris@16:             boost::units::unit<Dim2, System2> >::type type;
Chris@16:     };
Chris@16: 
Chris@16:     /// Partial specialization of return type trait for action
Chris@16:     /// unit<Dim1, System1> / unit<Dim2, System2>.
Chris@16:     template<typename Dim1, typename Dim2, typename System1, typename System2>
Chris@16:     struct plain_return_type_2<arithmetic_action<divide_action>,
Chris@16:                                boost::units::unit<Dim1, System1>,
Chris@16:                                boost::units::unit<Dim2, System2> > {
Chris@16:         typedef typename boost::units::divide_typeof_helper<
Chris@16:             boost::units::unit<Dim1, System1>,
Chris@16:             boost::units::unit<Dim2, System2> >::type type;
Chris@16:     };
Chris@16: 
Chris@16: 
Chris@16:     ////////////////////////////////////////////////////////////////////////
Chris@16:     // Partial specialization of Boost.Lambda's trait classes for all
Chris@16:     // operators overloaded in <boost/units/absolute.hpp>
Chris@16:     ////////////////////////////////////////////////////////////////////////
Chris@16: 
Chris@16: 
Chris@16:     /// Partial specialization of return type trait for action
Chris@16:     /// absolute<Y> + Y.
Chris@16:     template<typename Y>
Chris@16:     struct plain_return_type_2<arithmetic_action<plus_action>,
Chris@16:                                boost::units::absolute<Y>,
Chris@16:                                Y> {
Chris@16:         typedef typename boost::units::absolute<Y> type;
Chris@16:     };
Chris@16: 
Chris@16:     /// Partial specialization of return type trait for action
Chris@16:     /// Y + absolute<Y>.
Chris@16:     template<typename Y>
Chris@16:     struct plain_return_type_2<arithmetic_action<plus_action>,
Chris@16:                                Y,
Chris@16:                                boost::units::absolute<Y> > {
Chris@16:         typedef typename boost::units::absolute<Y> type;
Chris@16:     };
Chris@16: 
Chris@16:     /// Partial specialization of return type trait for action
Chris@16:     /// absolute<Y> - Y.
Chris@16:     template<typename Y>
Chris@16:     struct plain_return_type_2<arithmetic_action<minus_action>,
Chris@16:                                boost::units::absolute<Y>,
Chris@16:                                Y> {
Chris@16:         typedef typename boost::units::absolute<Y> type;
Chris@16:     };
Chris@16: 
Chris@16:     /// Partial specialization of return type trait for action
Chris@16:     /// absolute<Y> - absolute<Y>.
Chris@16:     template<typename Y>
Chris@16:     struct plain_return_type_2<arithmetic_action<minus_action>,
Chris@16:                                boost::units::absolute<Y>,
Chris@16:                                boost::units::absolute<Y> > {
Chris@16:         typedef Y type;
Chris@16:     };
Chris@16: 
Chris@16:     /// Partial specialization of return type trait for action
Chris@16:     /// T * absolute<unit<D, S> >.
Chris@16:     template<typename D, typename S, typename T>
Chris@16:     struct plain_return_type_2<arithmetic_action<multiply_action>,
Chris@16:                                T,
Chris@16:                                boost::units::absolute<boost::units::unit<D, S> > > {
Chris@16:         typedef typename boost::units::quantity<
Chris@16:             boost::units::absolute<boost::units::unit<D, S> >, T> type;
Chris@16:     };
Chris@16: 
Chris@16: } // namespace lambda
Chris@16: 
Chris@16: namespace units {
Chris@16:     
Chris@16:     template<typename System, typename Dim, typename Arg>
Chris@16:     struct multiply_typeof_helper<boost::lambda::lambda_functor<Arg>, boost::units::absolute<boost::units::unit<Dim, System> > > {
Chris@16:         typedef boost::lambda::lambda_functor<
Chris@16:           boost::lambda::lambda_functor_base<
Chris@16:             boost::lambda::arithmetic_action<boost::lambda::multiply_action>,
Chris@16:               tuple<boost::lambda::lambda_functor<Arg>,
Chris@16:                     typename boost::lambda::const_copy_argument<const boost::units::absolute<boost::units::unit<Dim, System> > >::type>
Chris@16:           >
Chris@16:         > type;
Chris@16:     };
Chris@16: 
Chris@16:     /// Disambiguating overload for action
Chris@16:     /// lambda_functor<Arg> * absolute<unit<Dim, System> >
Chris@16:     /// based on \<boost/lambda/detail/operators.hpp\>.
Chris@16:     template<typename System, typename Dim, typename Arg>
Chris@16:     inline const typename multiply_typeof_helper<boost::lambda::lambda_functor<Arg>, boost::units::absolute<boost::units::unit<Dim, System> > >::type
Chris@16:     operator*(const boost::lambda::lambda_functor<Arg>& a,
Chris@16:               const boost::units::absolute<boost::units::unit<Dim, System> >& b) {
Chris@16:         return typename multiply_typeof_helper<boost::lambda::lambda_functor<Arg>, boost::units::absolute<boost::units::unit<Dim, System> > >::type::inherited
Chris@16:                (tuple<boost::lambda::lambda_functor<Arg>,
Chris@16:                       typename boost::lambda::const_copy_argument<const boost::units::absolute<boost::units::unit<Dim, System> > >::type>
Chris@16:                      (a, b));
Chris@16:     }
Chris@16: 
Chris@16: } // namespace units
Chris@16: 
Chris@16: namespace lambda {
Chris@16: 
Chris@16:     /// Partial specialization of return type trait for action
Chris@16:     /// absolute<unit<D, S> > * T.
Chris@16:     template<typename D, typename S, typename T>
Chris@16:     struct plain_return_type_2<arithmetic_action<multiply_action>,
Chris@16:                                boost::units::absolute<boost::units::unit<D, S> >,
Chris@16:                                T> {
Chris@16:         typedef typename boost::units::quantity<
Chris@16:             boost::units::absolute<boost::units::unit<D, S> >, T> type;
Chris@16:     };
Chris@16: 
Chris@16: } // namespace lambda
Chris@16: 
Chris@16: namespace units {
Chris@16:     
Chris@16:     template<typename System, typename Dim, typename Arg>
Chris@16:     struct multiply_typeof_helper<boost::units::absolute<boost::units::unit<Dim, System> >, boost::lambda::lambda_functor<Arg> > {
Chris@16:         typedef boost::lambda::lambda_functor<
Chris@16:           boost::lambda::lambda_functor_base<
Chris@16:             boost::lambda::arithmetic_action<boost::lambda::multiply_action>,
Chris@16:               tuple<typename boost::lambda::const_copy_argument<const boost::units::absolute<boost::units::unit<Dim, System> > >::type,
Chris@16:                     boost::lambda::lambda_functor<Arg> >
Chris@16:           >
Chris@16:         > type;
Chris@16:     };
Chris@16: 
Chris@16:     /// Disambiguating overload for action
Chris@16:     /// absolute<unit<Dim, System> > * lambda_functor<Arg>
Chris@16:     /// based on \<boost/lambda/detail/operators.hpp\>.
Chris@16:     template<typename System, typename Dim, typename Arg>
Chris@16:     inline const typename multiply_typeof_helper<boost::units::absolute<boost::units::unit<Dim, System> >, boost::lambda::lambda_functor<Arg> >::type
Chris@16:     operator*(const boost::units::absolute<boost::units::unit<Dim, System> >& a,
Chris@16:               const boost::lambda::lambda_functor<Arg>& b) {
Chris@16:         return typename multiply_typeof_helper<boost::units::absolute<boost::units::unit<Dim, System> >, boost::lambda::lambda_functor<Arg> >::type::inherited
Chris@16:                (tuple<typename boost::lambda::const_copy_argument<const boost::units::absolute<boost::units::unit<Dim, System> > >::type,
Chris@16:                       boost::lambda::lambda_functor<Arg> >
Chris@16:                      (a, b));
Chris@16:     }
Chris@16: 
Chris@16: } // namespace units
Chris@16: 
Chris@16: } // namespace boost
Chris@16: 
Chris@16: #endif // BOOST_UNITS_LAMBDA_HPP