FM / units

/usr/include/boost/units

Name	Size	Mode	Actions
base_units/	-	0755	rm
detail/	-	0755	rm
physical_dimensions/	-	0755	rm
systems/	-	0755	rm
absolute.hpp	5540	0644	edit dl rm
base_dimension.hpp	3692	0644	edit dl rm
base_unit.hpp	4132	0644	edit dl rm
cmath.hpp	20592	0644	edit dl rm
config.hpp	2829	0644	edit dl rm
conversion.hpp	9518	0644	edit dl rm
derived_dimension.hpp	6465	0644	edit dl rm
dim.hpp	4745	0644	edit dl rm
dimension.hpp	4403	0644	edit dl rm
dimensionless_quantity.hpp	995	0644	edit dl rm
dimensionless_type.hpp	1315	0644	edit dl rm
dimensionless_unit.hpp	957	0644	edit dl rm
get_dimension.hpp	1221	0644	edit dl rm
get_system.hpp	1165	0644	edit dl rm
heterogeneous_system.hpp	12258	0644	edit dl rm
homogeneous_system.hpp	2399	0644	edit dl rm
io.hpp	32470	0644	edit dl rm
is_dim.hpp	885	0644	edit dl rm
is_dimensionless.hpp	1107	0644	edit dl rm
is_dimensionless_quantity.hpp	936	0644	edit dl rm
is_dimensionless_unit.hpp	905	0644	edit dl rm
is_dimension_list.hpp	1057	0644	edit dl rm
is_quantity.hpp	916	0644	edit dl rm
is_quantity_of_dimension.hpp	1115	0644	edit dl rm
is_quantity_of_system.hpp	1097	0644	edit dl rm
is_unit.hpp	879	0644	edit dl rm
is_unit_of_dimension.hpp	1138	0644	edit dl rm
is_unit_of_system.hpp	1127	0644	edit dl rm
lambda.hpp	26841	0644	edit dl rm
limits.hpp	4345	0644	edit dl rm
make_scaled_unit.hpp	1817	0644	edit dl rm
make_system.hpp	4914	0644	edit dl rm
operators.hpp	6287	0644	edit dl rm
physical_dimensions.hpp	4532	0644	edit dl rm
pow.hpp	3033	0644	edit dl rm
quantity.hpp	41860	0644	edit dl rm
reduce_unit.hpp	868	0644	edit dl rm
scale.hpp	5062	0644	edit dl rm
scaled_base_unit.hpp	3643	0644	edit dl rm
static_constant.hpp	2425	0644	edit dl rm
static_rational.hpp	10435	0644	edit dl rm
unit.hpp	13449	0644	edit dl rm
units_fwd.hpp	2191	0644	edit dl rm

Edit: /usr/include/boost/units/lambda.hpp (26841B)

// $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

// 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 #include #include #include namespace boost { namespace lambda { /// Partial specialization of return type trait for action /// unit * Y. template struct plain_return_type_2, boost::units::unit, Y > { typedef typename boost::units::multiply_typeof_helper< boost::units::unit, Y >::type type; }; } // namespace lambda namespace units { template struct multiply_typeof_helper, boost::lambda::lambda_functor > { typedef boost::lambda::lambda_functor< boost::lambda::lambda_functor_base< boost::lambda::arithmetic_action, tuple >::type, boost::lambda::lambda_functor > > > type; }; /// Disambiguating overload for action /// unit * lambda_functor /// based on \. template inline const typename multiply_typeof_helper, boost::lambda::lambda_functor >::type operator*(const boost::units::unit& a, const boost::lambda::lambda_functor& b) { return typename multiply_typeof_helper, boost::lambda::lambda_functor >::type::inherited (tuple >::type, boost::lambda::lambda_functor > (a, b)); } } // namespace units namespace lambda { /// Partial specialization of return type trait for action /// unit / Y. template struct plain_return_type_2, boost::units::unit, Y > { typedef typename boost::units::divide_typeof_helper< boost::units::unit, Y >::type type; }; } // namespace lambda namespace units { template struct divide_typeof_helper, boost::lambda::lambda_functor > { typedef boost::lambda::lambda_functor< boost::lambda::lambda_functor_base< boost::lambda::arithmetic_action, tuple >::type, boost::lambda::lambda_functor > > > type; }; /// Disambiguating overload for action /// unit / lambda_functor /// based on \. template inline const typename divide_typeof_helper, boost::lambda::lambda_functor >::type operator/(const boost::units::unit& a, const boost::lambda::lambda_functor& b) { return typename divide_typeof_helper, boost::lambda::lambda_functor >::type::inherited (tuple >::type, boost::lambda::lambda_functor > (a, b)); } } // namespace units namespace lambda { /// Partial specialization of return type trait for action /// Y * unit. template struct plain_return_type_2, Y, boost::units::unit > { typedef typename boost::units::multiply_typeof_helper< Y, boost::units::unit >::type type; }; } // namespace lambda namespace units { template struct multiply_typeof_helper, boost::units::unit > { typedef boost::lambda::lambda_functor< boost::lambda::lambda_functor_base< boost::lambda::arithmetic_action, tuple, typename boost::lambda::const_copy_argument >::type> > > type; }; /// Disambiguating overload for action /// lambda_functor * unit /// based on \. template inline const typename multiply_typeof_helper, boost::units::unit >::type operator*(const boost::lambda::lambda_functor& a, const boost::units::unit& b) { return typename multiply_typeof_helper, boost::units::unit >::type::inherited (tuple, typename boost::lambda::const_copy_argument >::type> (a, b)); } } // namespace units namespace lambda { /// Partial specialization of return type trait for action /// Y / unit. template struct plain_return_type_2, Y, boost::units::unit > { typedef typename boost::units::divide_typeof_helper< Y, boost::units::unit >::type type; }; } // namespace lambda namespace units { template struct divide_typeof_helper, boost::units::unit > { typedef boost::lambda::lambda_functor< boost::lambda::lambda_functor_base< boost::lambda::arithmetic_action, tuple, typename boost::lambda::const_copy_argument >::type> > > type; }; /// Disambiguating overload for action /// lambda_functor / unit /// based on \. template inline const typename divide_typeof_helper, boost::units::unit >::type operator/(const boost::lambda::lambda_functor& a, const boost::units::unit& b) { return typename divide_typeof_helper, boost::units::unit >::type::inherited (tuple, typename boost::lambda::const_copy_argument >::type> (a, b)); } } // namespace units namespace lambda { /// Partial specialization of return type trait for action /// quantity * X. template struct plain_return_type_2, boost::units::quantity, X> { typedef typename boost::units::multiply_typeof_helper< boost::units::quantity, X>::type type; }; /// Partial specialization of return type trait for action /// X * quantity. template struct plain_return_type_2, X, boost::units::quantity > { typedef typename boost::units::multiply_typeof_helper< X, boost::units::quantity >::type type; }; /// Partial specialization of return type trait for action /// quantity / X. template struct plain_return_type_2, boost::units::quantity, X> { typedef typename boost::units::divide_typeof_helper< boost::units::quantity, X>::type type; }; /// Partial specialization of return type trait for action /// X / quantity. template struct plain_return_type_2, X, boost::units::quantity > { typedef typename boost::units::divide_typeof_helper< X, boost::units::quantity >::type type; }; /// Partial specialization of return type trait for action /// unit * quantity. template struct plain_return_type_2, boost::units::unit, boost::units::quantity > { typedef typename boost::units::multiply_typeof_helper< boost::units::unit, boost::units::quantity >::type type; }; /// Partial specialization of return type trait for action /// unit / quantity. template struct plain_return_type_2, boost::units::unit, boost::units::quantity > { typedef typename boost::units::divide_typeof_helper< boost::units::unit, boost::units::quantity >::type type; }; /// Partial specialization of return type trait for action /// quantity * unit. template struct plain_return_type_2, boost::units::quantity, boost::units::unit > { typedef typename boost::units::multiply_typeof_helper< boost::units::quantity, boost::units::unit >::type type; }; /// Partial specialization of return type trait for action /// quantity / unit. template struct plain_return_type_2, boost::units::quantity, boost::units::unit > { typedef typename boost::units::divide_typeof_helper< boost::units::quantity, boost::units::unit >::type type; }; /// Partial specialization of return type trait for action /// +quantity. template struct plain_return_type_1, boost::units::quantity > { typedef typename boost::units::unary_plus_typeof_helper< boost::units::quantity >::type type; }; /// Partial specialization of return type trait for action /// -quantity. template struct plain_return_type_1, boost::units::quantity > { typedef typename boost::units::unary_minus_typeof_helper< boost::units::quantity >::type type; }; /// Partial specialization of return type trait for action /// quantity + quantity. template struct plain_return_type_2, boost::units::quantity, boost::units::quantity > { typedef typename boost::units::add_typeof_helper< boost::units::quantity, boost::units::quantity >::type type; }; /// Partial specialization of return type trait for action /// quantity + Y. template struct plain_return_type_2, boost::units::quantity, Y> { typedef typename boost::units::add_typeof_helper< boost::units::quantity, Y>::type type; }; /// Partial specialization of return type trait for action /// X + quantity. template struct plain_return_type_2, X, boost::units::quantity > { typedef typename boost::units::add_typeof_helper< X, boost::units::quantity >::type type; }; /// Partial specialization of return type trait for action /// quantity - quantity. template struct plain_return_type_2, boost::units::quantity, boost::units::quantity > { typedef typename boost::units::subtract_typeof_helper< boost::units::quantity, boost::units::quantity >::type type; }; /// Partial specialization of return type trait for action /// quantity - Y. template struct plain_return_type_2, boost::units::quantity, Y> { typedef typename boost::units::subtract_typeof_helper< boost::units::quantity, Y>::type type; }; /// Partial specialization of return type trait for action /// X - quantity. template struct plain_return_type_2, X, boost::units::quantity > { typedef typename boost::units::subtract_typeof_helper< X, boost::units::quantity >::type type; }; /// Partial specialization of return type trait for action /// quantity * quantity. template struct plain_return_type_2, boost::units::quantity, boost::units::quantity > { typedef typename boost::units::multiply_typeof_helper< boost::units::quantity, boost::units::quantity >::type type; }; /// Partial specialization of return type trait for action /// quantity / quantity. template struct plain_return_type_2, boost::units::quantity, boost::units::quantity > { typedef typename boost::units::divide_typeof_helper< boost::units::quantity, boost::units::quantity >::type type; }; //////////////////////////////////////////////////////////////////////// // Partial specialization of Boost.Lambda's trait classes for all // operators overloaded in //////////////////////////////////////////////////////////////////////// /// Partial specialization of return type trait for action /// +unit. template struct plain_return_type_1, boost::units::unit > { typedef typename boost::units::unary_plus_typeof_helper< boost::units::unit >::type type; }; /// Partial specialization of return type trait for action /// -unit. template struct plain_return_type_1, boost::units::unit > { typedef typename boost::units::unary_minus_typeof_helper< boost::units::unit >::type type; }; /// Partial specialization of return type trait for action /// unit + unit. template struct plain_return_type_2, boost::units::unit, boost::units::unit > { typedef typename boost::units::add_typeof_helper< boost::units::unit, boost::units::unit >::type type; }; /// Partial specialization of return type trait for action /// unit - unit. template struct plain_return_type_2, boost::units::unit, boost::units::unit > { typedef typename boost::units::subtract_typeof_helper< boost::units::unit, boost::units::unit >::type type; }; /// Partial specialization of return type trait for action /// unit * unit. template struct plain_return_type_2, boost::units::unit, boost::units::unit > { typedef typename boost::units::multiply_typeof_helper< boost::units::unit, boost::units::unit >::type type; }; /// Partial specialization of return type trait for action /// unit / unit. template struct plain_return_type_2, boost::units::unit, boost::units::unit > { typedef typename boost::units::divide_typeof_helper< boost::units::unit, boost::units::unit >::type type; }; //////////////////////////////////////////////////////////////////////// // Partial specialization of Boost.Lambda's trait classes for all // operators overloaded in //////////////////////////////////////////////////////////////////////// /// Partial specialization of return type trait for action /// absolute + Y. template struct plain_return_type_2, boost::units::absolute, Y> { typedef typename boost::units::absolute type; }; /// Partial specialization of return type trait for action /// Y + absolute. template struct plain_return_type_2, Y, boost::units::absolute > { typedef typename boost::units::absolute type; }; /// Partial specialization of return type trait for action /// absolute - Y. template struct plain_return_type_2, boost::units::absolute, Y> { typedef typename boost::units::absolute type; }; /// Partial specialization of return type trait for action /// absolute - absolute. template struct plain_return_type_2, boost::units::absolute, boost::units::absolute > { typedef Y type; }; /// Partial specialization of return type trait for action /// T * absolute >. template struct plain_return_type_2, T, boost::units::absolute > > { typedef typename boost::units::quantity< boost::units::absolute >, T> type; }; } // namespace lambda namespace units { template struct multiply_typeof_helper, boost::units::absolute > > { typedef boost::lambda::lambda_functor< boost::lambda::lambda_functor_base< boost::lambda::arithmetic_action, tuple, typename boost::lambda::const_copy_argument > >::type> > > type; }; /// Disambiguating overload for action /// lambda_functor * absolute > /// based on \. template inline const typename multiply_typeof_helper, boost::units::absolute > >::type operator*(const boost::lambda::lambda_functor& a, const boost::units::absolute >& b) { return typename multiply_typeof_helper, boost::units::absolute > >::type::inherited (tuple, typename boost::lambda::const_copy_argument > >::type> (a, b)); } } // namespace units namespace lambda { /// Partial specialization of return type trait for action /// absolute > * T. template struct plain_return_type_2, boost::units::absolute >, T> { typedef typename boost::units::quantity< boost::units::absolute >, T> type; }; } // namespace lambda namespace units { template struct multiply_typeof_helper >, boost::lambda::lambda_functor > { typedef boost::lambda::lambda_functor< boost::lambda::lambda_functor_base< boost::lambda::arithmetic_action, tuple > >::type, boost::lambda::lambda_functor > > > type; }; /// Disambiguating overload for action /// absolute > * lambda_functor /// based on \. template inline const typename multiply_typeof_helper >, boost::lambda::lambda_functor >::type operator*(const boost::units::absolute >& a, const boost::lambda::lambda_functor& b) { return typename multiply_typeof_helper >, boost::lambda::lambda_functor >::type::inherited (tuple > >::type, boost::lambda::lambda_functor > (a, b)); } } // namespace units } // namespace boost #endif // BOOST_UNITS_LAMBDA_HPP