| // 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) |
| |
| // $Id: lambda.hpp 27 2008-06-16 14:50:58Z maehne $ |
| |
| #ifndef BOOST_UNITS_LAMBDA_HPP |
| #define BOOST_UNITS_LAMBDA_HPP |
| |
| |
| //////////////////////////////////////////////////////////////////////// |
| /// |
| /// \file lambda.hpp |
| /// |
| /// \brief Definitions to ease the usage of Boost.Units' quantity, |
| /// unit, and absolute types in functors created with the |
| /// Boost.Lambda library. |
| /// |
| /// \author Torsten Maehne |
| /// \date 2008-06-16 |
| /// |
| /// Boost.Lambda's return type deduction system is extented to make |
| /// use of Boost.Units' typeof_helper trait classes for Boost.Units' |
| /// quantity, absolute, and unit template classes. |
| /// |
| //////////////////////////////////////////////////////////////////////// |
| |
| |
| #include <boost/lambda/lambda.hpp> |
| #include <boost/units/units_fwd.hpp> |
| #include <boost/units/detail/dimensionless_unit.hpp> |
| #include <boost/units/operators.hpp> |
| |
| namespace boost { |
| |
| namespace lambda { |
| |
| /// Partial specialization of return type trait for action |
| /// unit<Dim, System> * Y. |
| template<typename System, typename Dim, typename Y> |
| struct plain_return_type_2<arithmetic_action<multiply_action>, |
| boost::units::unit<Dim, System>, |
| Y > { |
| typedef typename boost::units::multiply_typeof_helper< |
| boost::units::unit<Dim, System>, Y >::type type; |
| }; |
| |
| } // namespace lambda |
| |
| namespace units { |
| |
| template<typename System, typename Dim, typename Arg> |
| struct multiply_typeof_helper<boost::units::unit<Dim, System>, boost::lambda::lambda_functor<Arg> > { |
| typedef boost::lambda::lambda_functor< |
| boost::lambda::lambda_functor_base< |
| boost::lambda::arithmetic_action<boost::lambda::multiply_action>, |
| tuple<typename boost::lambda::const_copy_argument<const boost::units::unit<Dim, System> >::type, boost::lambda::lambda_functor<Arg> > |
| > |
| > type; |
| }; |
| |
| /// Disambiguating overload for action |
| /// unit<Dim, System> * lambda_functor<Arg> |
| /// based on \<boost/lambda/detail/operators.hpp\>. |
| template<typename System, typename Dim, typename Arg> |
| inline const typename multiply_typeof_helper<boost::units::unit<Dim, System>, boost::lambda::lambda_functor<Arg> >::type |
| operator*(const boost::units::unit<Dim, System>& a, |
| const boost::lambda::lambda_functor<Arg>& b) { |
| return typename multiply_typeof_helper<boost::units::unit<Dim, System>, boost::lambda::lambda_functor<Arg> >::type::inherited |
| (tuple<typename boost::lambda::const_copy_argument<const boost::units::unit<Dim, System> >::type, |
| boost::lambda::lambda_functor<Arg> > |
| (a, b)); |
| } |
| |
| } // namespace units |
| |
| namespace lambda { |
| |
| /// Partial specialization of return type trait for action |
| /// unit<Dim, System> / Y. |
| template<typename System, typename Dim, typename Y> |
| struct plain_return_type_2<arithmetic_action<divide_action>, |
| boost::units::unit<Dim, System>, |
| Y > { |
| typedef typename boost::units::divide_typeof_helper< |
| boost::units::unit<Dim, System>, Y >::type type; |
| }; |
| |
| } // namespace lambda |
| |
| namespace units { |
| |
| template<typename System, typename Dim, typename Arg> |
| struct divide_typeof_helper<boost::units::unit<Dim, System>, boost::lambda::lambda_functor<Arg> > { |
| typedef boost::lambda::lambda_functor< |
| boost::lambda::lambda_functor_base< |
| boost::lambda::arithmetic_action<boost::lambda::divide_action>, |
| tuple<typename boost::lambda::const_copy_argument<const boost::units::unit<Dim, System> >::type, boost::lambda::lambda_functor<Arg> > |
| > |
| > type; |
| }; |
| |
| /// Disambiguating overload for action |
| /// unit<Dim, System> / lambda_functor<Arg> |
| /// based on \<boost/lambda/detail/operators.hpp\>. |
| template<typename System, typename Dim, typename Arg> |
| inline const typename divide_typeof_helper<boost::units::unit<Dim, System>, boost::lambda::lambda_functor<Arg> >::type |
| operator/(const boost::units::unit<Dim, System>& a, |
| const boost::lambda::lambda_functor<Arg>& b) { |
| return typename divide_typeof_helper<boost::units::unit<Dim, System>, boost::lambda::lambda_functor<Arg> >::type::inherited |
| (tuple<typename boost::lambda::const_copy_argument<const boost::units::unit<Dim, System> >::type, |
| boost::lambda::lambda_functor<Arg> > |
| (a, b)); |
| } |
| |
| } // namespace units |
| |
| namespace lambda { |
| |
| /// Partial specialization of return type trait for action |
| /// Y * unit<Dim, System>. |
| template<typename System, typename Dim, typename Y> |
| struct plain_return_type_2<arithmetic_action<multiply_action>, |
| Y, |
| boost::units::unit<Dim, System> > { |
| typedef typename boost::units::multiply_typeof_helper< |
| Y, boost::units::unit<Dim, System> >::type type; |
| }; |
| |
| } // namespace lambda |
| |
| namespace units { |
| |
| template<typename System, typename Dim, typename Arg> |
| struct multiply_typeof_helper<boost::lambda::lambda_functor<Arg>, boost::units::unit<Dim, System> > { |
| typedef boost::lambda::lambda_functor< |
| boost::lambda::lambda_functor_base< |
| boost::lambda::arithmetic_action<boost::lambda::multiply_action>, |
| tuple<boost::lambda::lambda_functor<Arg>, typename boost::lambda::const_copy_argument<const boost::units::unit<Dim, System> >::type> |
| > |
| > type; |
| }; |
| |
| /// Disambiguating overload for action |
| /// lambda_functor<Arg> * unit<Dim, System> |
| /// based on \<boost/lambda/detail/operators.hpp\>. |
| template<typename System, typename Dim, typename Arg> |
| inline const typename multiply_typeof_helper<boost::lambda::lambda_functor<Arg>, boost::units::unit<Dim, System> >::type |
| operator*(const boost::lambda::lambda_functor<Arg>& a, |
| const boost::units::unit<Dim, System>& b) { |
| return typename multiply_typeof_helper<boost::lambda::lambda_functor<Arg>, boost::units::unit<Dim, System> >::type::inherited |
| (tuple<boost::lambda::lambda_functor<Arg>, |
| typename boost::lambda::const_copy_argument<const boost::units::unit<Dim, System> >::type> |
| (a, b)); |
| } |
| |
| } // namespace units |
| |
| namespace lambda { |
| |
| /// Partial specialization of return type trait for action |
| /// Y / unit<Dim, System>. |
| template<typename System, typename Dim, typename Y> |
| struct plain_return_type_2<arithmetic_action<divide_action>, |
| Y, |
| boost::units::unit<Dim, System> > { |
| typedef typename boost::units::divide_typeof_helper< |
| Y, boost::units::unit<Dim, System> >::type type; |
| }; |
| |
| } // namespace lambda |
| |
| namespace units { |
| |
| template<typename System, typename Dim, typename Arg> |
| struct divide_typeof_helper<boost::lambda::lambda_functor<Arg>, boost::units::unit<Dim, System> > { |
| typedef boost::lambda::lambda_functor< |
| boost::lambda::lambda_functor_base< |
| boost::lambda::arithmetic_action<boost::lambda::divide_action>, |
| tuple<boost::lambda::lambda_functor<Arg>, typename boost::lambda::const_copy_argument<const boost::units::unit<Dim, System> >::type> |
| > |
| > type; |
| }; |
| |
| /// Disambiguating overload for action |
| /// lambda_functor<Arg> / unit<Dim, System> |
| /// based on \<boost/lambda/detail/operators.hpp\>. |
| template<typename System, typename Dim, typename Arg> |
| inline const typename divide_typeof_helper<boost::lambda::lambda_functor<Arg>, boost::units::unit<Dim, System> >::type |
| operator/(const boost::lambda::lambda_functor<Arg>& a, |
| const boost::units::unit<Dim, System>& b) { |
| return typename divide_typeof_helper<boost::lambda::lambda_functor<Arg>, boost::units::unit<Dim, System> >::type::inherited |
| (tuple<boost::lambda::lambda_functor<Arg>, |
| typename boost::lambda::const_copy_argument<const boost::units::unit<Dim, System> >::type> |
| (a, b)); |
| } |
| |
| } // namespace units |
| |
| namespace lambda { |
| |
| /// Partial specialization of return type trait for action |
| /// quantity<Unit, X> * X. |
| template<typename Unit, typename X> |
| struct plain_return_type_2<arithmetic_action<multiply_action>, |
| boost::units::quantity<Unit, X>, |
| X> { |
| typedef typename boost::units::multiply_typeof_helper< |
| boost::units::quantity<Unit, X>, X>::type type; |
| }; |
| |
| /// Partial specialization of return type trait for action |
| /// X * quantity<Unit, X>. |
| template<typename Unit, typename X> |
| struct plain_return_type_2<arithmetic_action<multiply_action>, |
| X, |
| boost::units::quantity<Unit, X> > { |
| typedef typename boost::units::multiply_typeof_helper< |
| X, boost::units::quantity<Unit, X> >::type type; |
| }; |
| |
| /// Partial specialization of return type trait for action |
| /// quantity<Unit, X> / X. |
| template<typename Unit, typename X> |
| struct plain_return_type_2<arithmetic_action<divide_action>, |
| boost::units::quantity<Unit, X>, |
| X> { |
| typedef typename boost::units::divide_typeof_helper< |
| boost::units::quantity<Unit, X>, X>::type type; |
| }; |
| |
| /// Partial specialization of return type trait for action |
| /// X / quantity<Unit, X>. |
| template<typename Unit, typename X> |
| struct plain_return_type_2<arithmetic_action<divide_action>, |
| X, |
| boost::units::quantity<Unit, X> > { |
| typedef typename boost::units::divide_typeof_helper< |
| X, boost::units::quantity<Unit, X> >::type type; |
| }; |
| |
| /// Partial specialization of return type trait for action |
| /// unit<Dim1, System1> * quantity<Unit2, Y>. |
| template<typename System1, typename Dim1, typename Unit2, typename Y> |
| struct plain_return_type_2<arithmetic_action<multiply_action>, |
| boost::units::unit<Dim1, System1>, |
| boost::units::quantity<Unit2, Y> > { |
| typedef typename boost::units::multiply_typeof_helper< |
| boost::units::unit<Dim1, System1>, |
| boost::units::quantity<Unit2, Y> >::type type; |
| }; |
| |
| /// Partial specialization of return type trait for action |
| /// unit<Dim1, System1> / quantity<Unit2, Y>. |
| template<typename System1, typename Dim1, typename Unit2, typename Y> |
| struct plain_return_type_2<arithmetic_action<divide_action>, |
| boost::units::unit<Dim1, System1>, |
| boost::units::quantity<Unit2, Y> > { |
| typedef typename boost::units::divide_typeof_helper< |
| boost::units::unit<Dim1, System1>, |
| boost::units::quantity<Unit2, Y> >::type type; |
| }; |
| |
| /// Partial specialization of return type trait for action |
| /// quantity<Unit1, Y> * unit<Dim2, System2>. |
| template<typename Unit1, typename Y, typename System2, typename Dim2> |
| struct plain_return_type_2<arithmetic_action<multiply_action>, |
| boost::units::quantity<Unit1, Y>, |
| boost::units::unit<Dim2, System2> > { |
| typedef typename boost::units::multiply_typeof_helper< |
| boost::units::quantity<Unit1, Y>, |
| boost::units::unit<Dim2, System2> >::type type; |
| }; |
| |
| /// Partial specialization of return type trait for action |
| /// quantity<Unit1, Y> / unit<Dim2, System2>. |
| template<typename Unit1, typename Y, typename System2, typename Dim2> |
| struct plain_return_type_2<arithmetic_action<divide_action>, |
| boost::units::quantity<Unit1, Y>, |
| boost::units::unit<Dim2, System2> > { |
| typedef typename boost::units::divide_typeof_helper< |
| boost::units::quantity<Unit1, Y>, |
| boost::units::unit<Dim2, System2> >::type type; |
| }; |
| |
| /// Partial specialization of return type trait for action |
| /// +quantity<Unit, Y>. |
| template<typename Unit, typename Y> |
| struct plain_return_type_1<unary_arithmetic_action<plus_action>, |
| boost::units::quantity<Unit, Y> > { |
| typedef typename boost::units::unary_plus_typeof_helper< |
| boost::units::quantity<Unit, Y> >::type type; |
| }; |
| |
| /// Partial specialization of return type trait for action |
| /// -quantity<Unit, Y>. |
| template<typename Unit, typename Y> |
| struct plain_return_type_1<unary_arithmetic_action<minus_action>, |
| boost::units::quantity<Unit, Y> > { |
| typedef typename boost::units::unary_minus_typeof_helper< |
| boost::units::quantity<Unit, Y> >::type type; |
| }; |
| |
| /// Partial specialization of return type trait for action |
| /// quantity<Unit1, X> + quantity<Unit2, Y>. |
| template<typename Unit1, typename X, typename Unit2, typename Y> |
| struct plain_return_type_2<arithmetic_action<plus_action>, |
| boost::units::quantity<Unit1, X>, |
| boost::units::quantity<Unit2, Y> > { |
| typedef typename boost::units::add_typeof_helper< |
| boost::units::quantity<Unit1, X>, |
| boost::units::quantity<Unit2, Y> >::type type; |
| }; |
| |
| /// Partial specialization of return type trait for action |
| /// quantity<dimensionless, X> + Y. |
| template<typename System, typename X, typename Y> |
| struct plain_return_type_2<arithmetic_action<plus_action>, |
| boost::units::quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(System), X>, |
| Y> { |
| typedef typename boost::units::add_typeof_helper< |
| boost::units::quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(System), X>, |
| Y>::type type; |
| }; |
| |
| /// Partial specialization of return type trait for action |
| /// X + quantity<dimensionless, Y>. |
| template<typename System, typename X, typename Y> |
| struct plain_return_type_2<arithmetic_action<plus_action>, |
| X, |
| boost::units::quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(System), Y> > { |
| typedef typename boost::units::add_typeof_helper< |
| X, |
| boost::units::quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(System), Y> >::type type; |
| }; |
| |
| /// Partial specialization of return type trait for action |
| /// quantity<Unit1, X> - quantity<Unit2, Y>. |
| template<typename Unit1, typename X, typename Unit2, typename Y> |
| struct plain_return_type_2<arithmetic_action<minus_action>, |
| boost::units::quantity<Unit1, X>, |
| boost::units::quantity<Unit2, Y> > { |
| typedef typename boost::units::subtract_typeof_helper< |
| boost::units::quantity<Unit1, X>, |
| boost::units::quantity<Unit2, Y> >::type type; |
| }; |
| |
| /// Partial specialization of return type trait for action |
| /// quantity<dimensionless, X> - Y. |
| template<typename System, typename X, typename Y> |
| struct plain_return_type_2<arithmetic_action<minus_action>, |
| boost::units::quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(System), X>, |
| Y> { |
| typedef typename boost::units::subtract_typeof_helper< |
| boost::units::quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(System), X>, |
| Y>::type type; |
| }; |
| |
| /// Partial specialization of return type trait for action |
| /// X - quantity<dimensionless, Y>. |
| template<typename System, typename X, typename Y> |
| struct plain_return_type_2<arithmetic_action<minus_action>, |
| X, |
| boost::units::quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(System), Y> > { |
| typedef typename boost::units::subtract_typeof_helper< |
| X, |
| boost::units::quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(System), Y> >::type type; |
| }; |
| |
| /// Partial specialization of return type trait for action |
| /// quantity<Unit1, X> * quantity<Unit2, Y>. |
| template<typename Unit1, typename X, typename Unit2, typename Y> |
| struct plain_return_type_2<arithmetic_action<multiply_action>, |
| boost::units::quantity<Unit1, X>, |
| boost::units::quantity<Unit2, Y> > { |
| typedef typename boost::units::multiply_typeof_helper< |
| boost::units::quantity<Unit1, X>, |
| boost::units::quantity<Unit2, Y> >::type type; |
| }; |
| |
| /// Partial specialization of return type trait for action |
| /// quantity<Unit1, X> / quantity<Unit2, Y>. |
| template<typename Unit1, typename X, typename Unit2, typename Y> |
| struct plain_return_type_2<arithmetic_action<divide_action>, |
| boost::units::quantity<Unit1, X>, |
| boost::units::quantity<Unit2, Y> > { |
| typedef typename boost::units::divide_typeof_helper< |
| boost::units::quantity<Unit1, X>, |
| boost::units::quantity<Unit2, Y> >::type type; |
| }; |
| |
| |
| //////////////////////////////////////////////////////////////////////// |
| // Partial specialization of Boost.Lambda's trait classes for all |
| // operators overloaded in <boost/units/unit.hpp> |
| //////////////////////////////////////////////////////////////////////// |
| |
| /// Partial specialization of return type trait for action |
| /// +unit<Dim, System>. |
| template<typename Dim, typename System> |
| struct plain_return_type_1<unary_arithmetic_action<plus_action>, |
| boost::units::unit<Dim, System> > { |
| typedef typename boost::units::unary_plus_typeof_helper< |
| boost::units::unit<Dim, System> >::type type; |
| }; |
| |
| /// Partial specialization of return type trait for action |
| /// -unit<Dim, System>. |
| template<typename Dim, typename System> |
| struct plain_return_type_1<unary_arithmetic_action<minus_action>, |
| boost::units::unit<Dim, System> > { |
| typedef typename boost::units::unary_minus_typeof_helper< |
| boost::units::unit<Dim, System> >::type type; |
| }; |
| |
| /// Partial specialization of return type trait for action |
| /// unit<Dim1, System1> + unit<Dim2, System2>. |
| template<typename Dim1, typename Dim2, typename System1, typename System2> |
| struct plain_return_type_2<arithmetic_action<plus_action>, |
| boost::units::unit<Dim1, System1>, |
| boost::units::unit<Dim2, System2> > { |
| typedef typename boost::units::add_typeof_helper< |
| boost::units::unit<Dim1, System1>, |
| boost::units::unit<Dim2, System2> >::type type; |
| }; |
| |
| /// Partial specialization of return type trait for action |
| /// unit<Dim1, System1> - unit<Dim2, System2>. |
| template<typename Dim1, typename Dim2, typename System1, typename System2> |
| struct plain_return_type_2<arithmetic_action<minus_action>, |
| boost::units::unit<Dim1, System1>, |
| boost::units::unit<Dim2, System2> > { |
| typedef typename boost::units::subtract_typeof_helper< |
| boost::units::unit<Dim1, System1>, |
| boost::units::unit<Dim2, System2> >::type type; |
| }; |
| |
| /// Partial specialization of return type trait for action |
| /// unit<Dim1, System1> * unit<Dim2, System2>. |
| template<typename Dim1, typename Dim2, typename System1, typename System2> |
| struct plain_return_type_2<arithmetic_action<multiply_action>, |
| boost::units::unit<Dim1, System1>, |
| boost::units::unit<Dim2, System2> > { |
| typedef typename boost::units::multiply_typeof_helper< |
| boost::units::unit<Dim1, System1>, |
| boost::units::unit<Dim2, System2> >::type type; |
| }; |
| |
| /// Partial specialization of return type trait for action |
| /// unit<Dim1, System1> / unit<Dim2, System2>. |
| template<typename Dim1, typename Dim2, typename System1, typename System2> |
| struct plain_return_type_2<arithmetic_action<divide_action>, |
| boost::units::unit<Dim1, System1>, |
| boost::units::unit<Dim2, System2> > { |
| typedef typename boost::units::divide_typeof_helper< |
| boost::units::unit<Dim1, System1>, |
| boost::units::unit<Dim2, System2> >::type type; |
| }; |
| |
| |
| //////////////////////////////////////////////////////////////////////// |
| // Partial specialization of Boost.Lambda's trait classes for all |
| // operators overloaded in <boost/units/absolute.hpp> |
| //////////////////////////////////////////////////////////////////////// |
| |
| |
| /// Partial specialization of return type trait for action |
| /// absolute<Y> + Y. |
| template<typename Y> |
| struct plain_return_type_2<arithmetic_action<plus_action>, |
| boost::units::absolute<Y>, |
| Y> { |
| typedef typename boost::units::absolute<Y> type; |
| }; |
| |
| /// Partial specialization of return type trait for action |
| /// Y + absolute<Y>. |
| template<typename Y> |
| struct plain_return_type_2<arithmetic_action<plus_action>, |
| Y, |
| boost::units::absolute<Y> > { |
| typedef typename boost::units::absolute<Y> type; |
| }; |
| |
| /// Partial specialization of return type trait for action |
| /// absolute<Y> - Y. |
| template<typename Y> |
| struct plain_return_type_2<arithmetic_action<minus_action>, |
| boost::units::absolute<Y>, |
| Y> { |
| typedef typename boost::units::absolute<Y> type; |
| }; |
| |
| /// Partial specialization of return type trait for action |
| /// absolute<Y> - absolute<Y>. |
| template<typename Y> |
| struct plain_return_type_2<arithmetic_action<minus_action>, |
| boost::units::absolute<Y>, |
| boost::units::absolute<Y> > { |
| typedef Y type; |
| }; |
| |
| /// Partial specialization of return type trait for action |
| /// T * absolute<unit<D, S> >. |
| template<typename D, typename S, typename T> |
| struct plain_return_type_2<arithmetic_action<multiply_action>, |
| T, |
| boost::units::absolute<boost::units::unit<D, S> > > { |
| typedef typename boost::units::quantity< |
| boost::units::absolute<boost::units::unit<D, S> >, T> type; |
| }; |
| |
| } // namespace lambda |
| |
| namespace units { |
| |
| template<typename System, typename Dim, typename Arg> |
| struct multiply_typeof_helper<boost::lambda::lambda_functor<Arg>, boost::units::absolute<boost::units::unit<Dim, System> > > { |
| typedef boost::lambda::lambda_functor< |
| boost::lambda::lambda_functor_base< |
| boost::lambda::arithmetic_action<boost::lambda::multiply_action>, |
| tuple<boost::lambda::lambda_functor<Arg>, |
| typename boost::lambda::const_copy_argument<const boost::units::absolute<boost::units::unit<Dim, System> > >::type> |
| > |
| > type; |
| }; |
| |
| /// Disambiguating overload for action |
| /// lambda_functor<Arg> * absolute<unit<Dim, System> > |
| /// based on \<boost/lambda/detail/operators.hpp\>. |
| template<typename System, typename Dim, typename Arg> |
| inline const typename multiply_typeof_helper<boost::lambda::lambda_functor<Arg>, boost::units::absolute<boost::units::unit<Dim, System> > >::type |
| operator*(const boost::lambda::lambda_functor<Arg>& a, |
| const boost::units::absolute<boost::units::unit<Dim, System> >& b) { |
| return typename multiply_typeof_helper<boost::lambda::lambda_functor<Arg>, boost::units::absolute<boost::units::unit<Dim, System> > >::type::inherited |
| (tuple<boost::lambda::lambda_functor<Arg>, |
| typename boost::lambda::const_copy_argument<const boost::units::absolute<boost::units::unit<Dim, System> > >::type> |
| (a, b)); |
| } |
| |
| } // namespace units |
| |
| namespace lambda { |
| |
| /// Partial specialization of return type trait for action |
| /// absolute<unit<D, S> > * T. |
| template<typename D, typename S, typename T> |
| struct plain_return_type_2<arithmetic_action<multiply_action>, |
| boost::units::absolute<boost::units::unit<D, S> >, |
| T> { |
| typedef typename boost::units::quantity< |
| boost::units::absolute<boost::units::unit<D, S> >, T> type; |
| }; |
| |
| } // namespace lambda |
| |
| namespace units { |
| |
| template<typename System, typename Dim, typename Arg> |
| struct multiply_typeof_helper<boost::units::absolute<boost::units::unit<Dim, System> >, boost::lambda::lambda_functor<Arg> > { |
| typedef boost::lambda::lambda_functor< |
| boost::lambda::lambda_functor_base< |
| boost::lambda::arithmetic_action<boost::lambda::multiply_action>, |
| tuple<typename boost::lambda::const_copy_argument<const boost::units::absolute<boost::units::unit<Dim, System> > >::type, |
| boost::lambda::lambda_functor<Arg> > |
| > |
| > type; |
| }; |
| |
| /// Disambiguating overload for action |
| /// absolute<unit<Dim, System> > * lambda_functor<Arg> |
| /// based on \<boost/lambda/detail/operators.hpp\>. |
| template<typename System, typename Dim, typename Arg> |
| inline const typename multiply_typeof_helper<boost::units::absolute<boost::units::unit<Dim, System> >, boost::lambda::lambda_functor<Arg> >::type |
| operator*(const boost::units::absolute<boost::units::unit<Dim, System> >& a, |
| const boost::lambda::lambda_functor<Arg>& b) { |
| return typename multiply_typeof_helper<boost::units::absolute<boost::units::unit<Dim, System> >, boost::lambda::lambda_functor<Arg> >::type::inherited |
| (tuple<typename boost::lambda::const_copy_argument<const boost::units::absolute<boost::units::unit<Dim, System> > >::type, |
| boost::lambda::lambda_functor<Arg> > |
| (a, b)); |
| } |
| |
| } // namespace units |
| |
| } // namespace boost |
| |
| #endif // BOOST_UNITS_LAMBDA_HPP |