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) 2007-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: #ifndef BOOST_UNITS_QUANTITY_HPP
Chris@16: #define BOOST_UNITS_QUANTITY_HPP
Chris@16: 
Chris@16: #include <algorithm>
Chris@16: 
Chris@16: #include <boost/config.hpp>
Chris@16: #include <boost/static_assert.hpp>
Chris@16: #include <boost/mpl/bool.hpp>
Chris@16: #include <boost/mpl/and.hpp>
Chris@16: #include <boost/mpl/not.hpp>
Chris@16: #include <boost/mpl/or.hpp>
Chris@16: #include <boost/mpl/assert.hpp>
Chris@16: #include <boost/utility/enable_if.hpp>
Chris@16: #include <boost/type_traits/is_arithmetic.hpp>
Chris@16: #include <boost/type_traits/is_convertible.hpp>
Chris@16: #include <boost/type_traits/is_integral.hpp>
Chris@16: #include <boost/type_traits/is_same.hpp>
Chris@16: 
Chris@16: #include <boost/units/conversion.hpp>
Chris@16: #include <boost/units/dimensionless_type.hpp>
Chris@16: #include <boost/units/homogeneous_system.hpp>
Chris@16: #include <boost/units/operators.hpp>
Chris@16: #include <boost/units/static_rational.hpp>
Chris@16: #include <boost/units/units_fwd.hpp>
Chris@16: #include <boost/units/detail/dimensionless_unit.hpp>
Chris@16: 
Chris@16: namespace boost {
Chris@16: 
Chris@16: namespace units {
Chris@16: 
Chris@16: namespace detail {
Chris@16: 
Chris@16: template<class T, class Enable = void>
Chris@16: struct is_base_unit : mpl::false_ {};
Chris@16: 
Chris@16: template<class T>
Chris@16: struct is_base_unit<T, typename T::boost_units_is_base_unit_type> : mpl::true_ {};
Chris@16: 
Chris@16: template<class Source, class Destination>
Chris@16: struct is_narrowing_conversion_impl : mpl::bool_<(sizeof(Source) > sizeof(Destination))> {};
Chris@16: 
Chris@16: template<class Source, class Destination>
Chris@16: struct is_non_narrowing_conversion :
Chris@16:     mpl::and_<
Chris@16:         boost::is_convertible<Source, Destination>,
Chris@16:         mpl::not_<
Chris@16:             mpl::and_<
Chris@16:                 boost::is_arithmetic<Source>,
Chris@16:                 boost::is_arithmetic<Destination>,
Chris@16:                 mpl::or_<
Chris@16:                     mpl::and_<
Chris@16:                         is_integral<Destination>,
Chris@16:                         mpl::not_<is_integral<Source> >
Chris@16:                     >,
Chris@16:                     is_narrowing_conversion_impl<Source, Destination>
Chris@16:                 >
Chris@16:             >
Chris@16:         >
Chris@16:     >
Chris@16: {};
Chris@16: 
Chris@16: template<>
Chris@16: struct is_non_narrowing_conversion<long double, double> : mpl::false_ {};
Chris@16: 
Chris@16: // msvc 7.1 needs extra disambiguation
Chris@16: template<class T, class U>
Chris@16: struct disable_if_is_same
Chris@16: {
Chris@16:     typedef void type;
Chris@16: };
Chris@16: 
Chris@16: template<class T>
Chris@16: struct disable_if_is_same<T, T> {};
Chris@16: 
Chris@16: }
Chris@16:  
Chris@16: /// class declaration
Chris@101: template<class Unit,class Y>
Chris@16: class quantity
Chris@16: {
Chris@16:         // base units are not the same as units.
Chris@16:         BOOST_MPL_ASSERT_NOT((detail::is_base_unit<Unit>));
Chris@16:         enum { force_instantiation_of_unit = sizeof(Unit) };
Chris@16:         typedef void (quantity::*unspecified_null_pointer_constant_type)(int*******);
Chris@16:     public:
Chris@16:         typedef quantity<Unit,Y>                        this_type;
Chris@16:         
Chris@16:         typedef Y                                       value_type;
Chris@16:         typedef Unit        unit_type;
Chris@16:  
Chris@16:         quantity() : val_() 
Chris@16:         { 
Chris@16:             BOOST_UNITS_CHECK_LAYOUT_COMPATIBILITY(this_type, Y);
Chris@16:         }
Chris@16: 
Chris@16:         quantity(unspecified_null_pointer_constant_type) : val_() 
Chris@16:         { 
Chris@16:             BOOST_UNITS_CHECK_LAYOUT_COMPATIBILITY(this_type, Y);
Chris@16:         }
Chris@16:         
Chris@16:         quantity(const this_type& source) : val_(source.val_) 
Chris@16:         {
Chris@16:             BOOST_UNITS_CHECK_LAYOUT_COMPATIBILITY(this_type, Y);
Chris@16:         }
Chris@16:         
Chris@16:         // Need to make sure that the destructor of
Chris@16:         // Unit which contains the checking is instantiated,
Chris@16:         // on sun.
Chris@16:         #ifdef __SUNPRO_CC
Chris@16:         ~quantity() {
Chris@16:             unit_type force_unit_instantiation;
Chris@16:         }
Chris@16:         #endif
Chris@16:         
Chris@16:         //~quantity() { }
Chris@16:         
Chris@16:         this_type& operator=(const this_type& source) 
Chris@16:         { 
Chris@16:              val_ = source.val_; 
Chris@16:              
Chris@16:              return *this; 
Chris@16:         }
Chris@16: 
Chris@16:         #ifndef BOOST_NO_SFINAE
Chris@16: 
Chris@16:         /// implicit conversion between value types is allowed if allowed for value types themselves
Chris@16:         template<class YY>
Chris@16:         quantity(const quantity<Unit,YY>& source,
Chris@16:             typename boost::enable_if<detail::is_non_narrowing_conversion<YY, Y> >::type* = 0) :
Chris@16:             val_(source.value())
Chris@16:         { 
Chris@16:             BOOST_UNITS_CHECK_LAYOUT_COMPATIBILITY(this_type, Y);
Chris@16:         }
Chris@16: 
Chris@16:         /// implicit conversion between value types is not allowed if not allowed for value types themselves
Chris@16:         template<class YY>
Chris@16:         explicit quantity(const quantity<Unit,YY>& source,
Chris@16:             typename boost::disable_if<detail::is_non_narrowing_conversion<YY, Y> >::type* = 0) :
Chris@16:             val_(static_cast<Y>(source.value()))
Chris@16:         { 
Chris@16:             BOOST_UNITS_CHECK_LAYOUT_COMPATIBILITY(this_type, Y);
Chris@16:         }
Chris@16: 
Chris@16:         #else
Chris@16: 
Chris@16:         /// implicit conversion between value types is allowed if allowed for value types themselves
Chris@16:         template<class YY>
Chris@16:         quantity(const quantity<Unit,YY>& source) :
Chris@16:             val_(source.value())
Chris@16:         { 
Chris@16:             BOOST_UNITS_CHECK_LAYOUT_COMPATIBILITY(this_type, Y);
Chris@16:             BOOST_STATIC_ASSERT((boost::is_convertible<YY, Y>::value == true));
Chris@16:         }
Chris@16: 
Chris@16:         #endif
Chris@16:         
Chris@16:         /// implicit assignment between value types is allowed if allowed for value types themselves
Chris@16:         template<class YY>
Chris@16:         this_type& operator=(const quantity<Unit,YY>& source)
Chris@16:         {
Chris@16:             BOOST_STATIC_ASSERT((boost::is_convertible<YY, Y>::value == true));
Chris@16: 
Chris@16:             *this = this_type(source);
Chris@16:             
Chris@16:             return *this;
Chris@16:         }
Chris@16: 
Chris@16:         #ifndef BOOST_NO_SFINAE
Chris@16: 
Chris@16:         /// explicit conversion between different unit systems is allowed if implicit conversion is disallowed
Chris@16:         template<class Unit2,class YY> 
Chris@16:         explicit
Chris@16:         quantity(const quantity<Unit2,YY>& source, 
Chris@16:                  typename boost::disable_if<
Chris@16:                     mpl::and_<
Chris@16:                         //is_implicitly_convertible should be undefined when the
Chris@16:                         //units are not convertible at all
Chris@16:                         typename is_implicitly_convertible<Unit2,Unit>::type,
Chris@16:                         detail::is_non_narrowing_conversion<YY, Y>
Chris@16:                     >,
Chris@16:                     typename detail::disable_if_is_same<Unit, Unit2>::type
Chris@16:                  >::type* = 0)
Chris@16:              : val_(conversion_helper<quantity<Unit2,YY>,this_type>::convert(source).value())
Chris@16:         {
Chris@16:             BOOST_UNITS_CHECK_LAYOUT_COMPATIBILITY(this_type, Y);
Chris@16:             BOOST_STATIC_ASSERT((boost::is_convertible<YY,Y>::value == true));
Chris@16:         }
Chris@16: 
Chris@16:         /// implicit conversion between different unit systems is allowed if each fundamental dimension is implicitly convertible
Chris@16:         template<class Unit2,class YY> 
Chris@16:         quantity(const quantity<Unit2,YY>& source, 
Chris@16:                  typename boost::enable_if<
Chris@16:                      mpl::and_<
Chris@16:                          typename is_implicitly_convertible<Unit2,Unit>::type,
Chris@16:                          detail::is_non_narrowing_conversion<YY, Y>
Chris@16:                      >,
Chris@16:                      typename detail::disable_if_is_same<Unit, Unit2>::type
Chris@16:                  >::type* = 0)
Chris@16:              : val_(conversion_helper<quantity<Unit2,YY>,this_type>::convert(source).value())
Chris@16:         {
Chris@16:             BOOST_UNITS_CHECK_LAYOUT_COMPATIBILITY(this_type, Y);
Chris@16:             BOOST_STATIC_ASSERT((boost::is_convertible<YY,Y>::value == true));
Chris@16:         }
Chris@16: 
Chris@16:         #else
Chris@16: 
Chris@16:         /// without SFINAE we can't distinguish between explicit and implicit conversions so 
Chris@16:         /// the conversion is always explicit
Chris@16:         template<class Unit2,class YY> 
Chris@16:         explicit quantity(const quantity<Unit2,YY>& source)
Chris@16:              : val_(conversion_helper<quantity<Unit2,YY>,this_type>::convert(source).value())
Chris@16:         {
Chris@16:             BOOST_UNITS_CHECK_LAYOUT_COMPATIBILITY(this_type, Y);
Chris@16:             BOOST_STATIC_ASSERT((boost::is_convertible<YY,Y>::value == true));
Chris@16:         }
Chris@16: 
Chris@16:         #endif
Chris@16:         
Chris@16:         /// implicit assignment between different unit systems is allowed if each fundamental dimension is implicitly convertible 
Chris@16:         template<class Unit2,class YY>
Chris@16:         this_type& operator=(const quantity<Unit2,YY>& source)
Chris@16:         {
Chris@16:             
Chris@16:             BOOST_STATIC_ASSERT((is_implicitly_convertible<Unit2,unit_type>::value == true));
Chris@16:             BOOST_STATIC_ASSERT((boost::is_convertible<YY,Y>::value == true));
Chris@16:             
Chris@16:             *this = this_type(source);
Chris@16:             
Chris@16:             return *this;
Chris@16:         }
Chris@16: 
Chris@16:         const value_type& value() const                     { return val_; }                        ///< constant accessor to value
Chris@16:         
Chris@16:         ///< can add a quantity of the same type if add_typeof_helper<value_type,value_type>::type is convertible to value_type
Chris@16:         template<class Unit2, class YY>
Chris@16:         this_type& operator+=(const quantity<Unit2, YY>& source)
Chris@16:         {
Chris@16:             BOOST_STATIC_ASSERT((boost::is_same<typename add_typeof_helper<Unit, Unit2>::type, Unit>::value));
Chris@16:             val_ += source.value();
Chris@16:             return *this;
Chris@16:         }  
Chris@16: 
Chris@16:         ///< can subtract a quantity of the same type if subtract_typeof_helper<value_type,value_type>::type is convertible to value_type
Chris@16:         template<class Unit2, class YY>
Chris@16:         this_type& operator-=(const quantity<Unit2, YY>& source)
Chris@16:         {
Chris@16:             BOOST_STATIC_ASSERT((boost::is_same<typename subtract_typeof_helper<Unit, Unit2>::type, Unit>::value));
Chris@16:             val_ -= source.value();
Chris@16:             return *this;
Chris@16:         }  
Chris@16: 
Chris@16:         template<class Unit2, class YY>
Chris@16:         this_type& operator*=(const quantity<Unit2, YY>& source)
Chris@16:         {
Chris@16:             BOOST_STATIC_ASSERT((boost::is_same<typename multiply_typeof_helper<Unit, Unit2>::type, Unit>::value));
Chris@16:             val_ *= source.value();
Chris@16:             return *this;
Chris@16:         }  
Chris@16:         
Chris@16:         template<class Unit2, class YY>
Chris@16:         this_type& operator/=(const quantity<Unit2, YY>& source)
Chris@16:         {
Chris@16:             BOOST_STATIC_ASSERT((boost::is_same<typename divide_typeof_helper<Unit, Unit2>::type, Unit>::value));
Chris@16:             val_ /= source.value();
Chris@16:             return *this;
Chris@16:         }
Chris@16: 
Chris@16:         ///< can multiply a quantity by a scalar value_type if multiply_typeof_helper<value_type,value_type>::type is convertible to value_type
Chris@16:         this_type& operator*=(const value_type& source) { val_ *= source; return *this; }
Chris@16:         ///< can divide a quantity by a scalar value_type if divide_typeof_helper<value_type,value_type>::type is convertible to value_type
Chris@16:         this_type& operator/=(const value_type& source) { val_ /= source; return *this; }
Chris@16:     
Chris@16:         /// Construct quantity directly from @c value_type (potentially dangerous).
Chris@16:         static this_type from_value(const value_type& val)  { return this_type(val, 0); }
Chris@16: 
Chris@16:     protected:
Chris@16:         explicit quantity(const value_type& val, int) : val_(val) { }
Chris@16:         
Chris@16:     private:
Chris@16:         value_type    val_;
Chris@16: };
Chris@16: 
Chris@16: /// Specialization for dimensionless quantities. Implicit conversions between 
Chris@16: /// unit systems are allowed because all dimensionless quantities are equivalent.
Chris@16: /// Implicit construction and assignment from and conversion to @c value_type is
Chris@16: /// also allowed.
Chris@16: template<class System,class Y>
Chris@16: class quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(System),Y>
Chris@16: {
Chris@16:     public:
Chris@16:         typedef quantity<unit<dimensionless_type,System>,Y>     this_type;
Chris@16:                                    
Chris@16:         typedef Y                                               value_type;
Chris@16:         typedef System                                          system_type;
Chris@16:         typedef dimensionless_type                              dimension_type;
Chris@16:         typedef unit<dimension_type,system_type>                unit_type;
Chris@16:          
Chris@16:         quantity() : val_() 
Chris@16:         {
Chris@16:             BOOST_UNITS_CHECK_LAYOUT_COMPATIBILITY(this_type, Y);
Chris@16:         }
Chris@16:         
Chris@16:         /// construction from raw @c value_type is allowed
Chris@16:         quantity(value_type val) : val_(val) 
Chris@16:         {
Chris@16:             BOOST_UNITS_CHECK_LAYOUT_COMPATIBILITY(this_type, Y);
Chris@16:         } 
Chris@16:                            
Chris@16:         quantity(const this_type& source) : val_(source.val_) 
Chris@16:         {
Chris@16:             BOOST_UNITS_CHECK_LAYOUT_COMPATIBILITY(this_type, Y);
Chris@16:         }
Chris@16:         
Chris@16:         //~quantity() { }
Chris@16:         
Chris@16:         this_type& operator=(const this_type& source) 
Chris@16:         { 
Chris@16:             val_ = source.val_; 
Chris@16:                 
Chris@16:             return *this; 
Chris@16:         }
Chris@16:         
Chris@16:         #ifndef BOOST_NO_SFINAE
Chris@16: 
Chris@16:         /// implicit conversion between value types is allowed if allowed for value types themselves
Chris@16:         template<class YY>
Chris@16:         quantity(const quantity<unit<dimension_type,system_type>,YY>& source,
Chris@16:             typename boost::enable_if<detail::is_non_narrowing_conversion<YY, Y> >::type* = 0) :
Chris@16:             val_(source.value())
Chris@16:         { 
Chris@16:             BOOST_UNITS_CHECK_LAYOUT_COMPATIBILITY(this_type, Y);
Chris@16:         }
Chris@16: 
Chris@16:         /// implicit conversion between value types is not allowed if not allowed for value types themselves
Chris@16:         template<class YY>
Chris@16:         explicit quantity(const quantity<unit<dimension_type,system_type>,YY>& source,
Chris@16:             typename boost::disable_if<detail::is_non_narrowing_conversion<YY, Y> >::type* = 0) :
Chris@16:             val_(static_cast<Y>(source.value()))
Chris@16:         { 
Chris@16:             BOOST_UNITS_CHECK_LAYOUT_COMPATIBILITY(this_type, Y);
Chris@16:         }
Chris@16: 
Chris@16:         #else
Chris@16: 
Chris@16:         /// implicit conversion between value types is allowed if allowed for value types themselves
Chris@16:         template<class YY>
Chris@16:         quantity(const quantity<unit<dimension_type,system_type>,YY>& source) :
Chris@16:             val_(source.value())
Chris@16:         { 
Chris@16:             BOOST_UNITS_CHECK_LAYOUT_COMPATIBILITY(this_type, Y);
Chris@16:             BOOST_STATIC_ASSERT((boost::is_convertible<YY, Y>::value == true));
Chris@16:         }
Chris@16: 
Chris@16:         #endif
Chris@16:         
Chris@16:         /// implicit assignment between value types is allowed if allowed for value types themselves
Chris@16:         template<class YY>
Chris@16:         this_type& operator=(const quantity<unit<dimension_type,system_type>,YY>& source)
Chris@16:         {
Chris@16:             BOOST_STATIC_ASSERT((boost::is_convertible<YY,Y>::value == true));
Chris@16: 
Chris@16:             *this = this_type(source);
Chris@16:             
Chris@16:             return *this;
Chris@16:         }
Chris@16: 
Chris@16:         #if 1
Chris@16: 
Chris@16:         /// implicit conversion between different unit systems is allowed
Chris@16:         template<class System2, class Y2> 
Chris@16:         quantity(const quantity<unit<dimensionless_type, System2>,Y2>& source,
Chris@16:         #ifdef __SUNPRO_CC
Chris@16:             typename boost::enable_if<
Chris@16:                 boost::mpl::and_<
Chris@16:                     detail::is_non_narrowing_conversion<Y2, Y>,
Chris@16:                     detail::is_dimensionless_system<System2>
Chris@16:                 > 
Chris@16:             >::type* = 0
Chris@16:         #else
Chris@16:             typename boost::enable_if<detail::is_non_narrowing_conversion<Y2, Y> >::type* = 0,
Chris@16:             typename detail::disable_if_is_same<System, System2>::type* = 0,
Chris@16:             typename boost::enable_if<detail::is_dimensionless_system<System2> >::type* = 0
Chris@16:         #endif
Chris@16:             ) :
Chris@16:             val_(source.value()) 
Chris@16:         {
Chris@16:             BOOST_UNITS_CHECK_LAYOUT_COMPATIBILITY(this_type, Y);
Chris@16:         }
Chris@16: 
Chris@16:         /// implicit conversion between different unit systems is allowed
Chris@16:         template<class System2, class Y2> 
Chris@16:         explicit quantity(const quantity<unit<dimensionless_type, System2>,Y2>& source,
Chris@16:         #ifdef __SUNPRO_CC
Chris@16:             typename boost::enable_if<
Chris@16:                 boost::mpl::and_<
Chris@16:                     boost::mpl::not_<detail::is_non_narrowing_conversion<Y2, Y> >,
Chris@16:                     detail::is_dimensionless_system<System2>
Chris@16:                 > 
Chris@16:             >::type* = 0
Chris@16:         #else
Chris@16:             typename boost::disable_if<detail::is_non_narrowing_conversion<Y2, Y> >::type* = 0,
Chris@16:             typename detail::disable_if_is_same<System, System2>::type* = 0,
Chris@16:             typename boost::enable_if<detail::is_dimensionless_system<System2> >::type* = 0
Chris@16:         #endif
Chris@16:             ) :
Chris@16:             val_(static_cast<Y>(source.value())) 
Chris@16:         {
Chris@16:             BOOST_UNITS_CHECK_LAYOUT_COMPATIBILITY(this_type, Y);
Chris@16:         }
Chris@16: 
Chris@16:         #else
Chris@16: 
Chris@16:         /// implicit conversion between different unit systems is allowed
Chris@16:         template<class System2, class Y2> 
Chris@16:         quantity(const quantity<unit<dimensionless_type,homogeneous_system<System2> >,Y2>& source) :
Chris@16:             val_(source.value()) 
Chris@16:         {
Chris@16:             BOOST_UNITS_CHECK_LAYOUT_COMPATIBILITY(this_type, Y);
Chris@16:             BOOST_STATIC_ASSERT((boost::is_convertible<Y2, Y>::value == true));
Chris@16:         }
Chris@16: 
Chris@16:         #endif
Chris@16: 
Chris@16:         /// conversion between different unit systems is explicit when
Chris@16:         /// the units are not equivalent.
Chris@16:         template<class System2, class Y2> 
Chris@16:         explicit quantity(const quantity<unit<dimensionless_type, System2>,Y2>& source,
Chris@16:             typename boost::disable_if<detail::is_dimensionless_system<System2> >::type* = 0) :
Chris@16:             val_(conversion_helper<quantity<unit<dimensionless_type, System2>,Y2>, this_type>::convert(source).value()) 
Chris@16:         {
Chris@16:             BOOST_UNITS_CHECK_LAYOUT_COMPATIBILITY(this_type, Y);
Chris@16:         }
Chris@16:         
Chris@16:         #ifndef __SUNPRO_CC
Chris@16: 
Chris@16:         /// implicit assignment between different unit systems is allowed
Chris@16:         template<class System2>
Chris@16:         this_type& operator=(const quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(System2),Y>& source)
Chris@16:         {
Chris@16:             *this = this_type(source);
Chris@16:             
Chris@16:             return *this;
Chris@16:         }
Chris@16:         
Chris@16:         #endif
Chris@16:         
Chris@16:         /// implicit conversion to @c value_type is allowed
Chris@16:         operator value_type() const                         { return val_; }
Chris@16:         
Chris@16:         const value_type& value() const                     { return val_; }                        ///< constant accessor to value
Chris@16:         
Chris@16:         ///< can add a quantity of the same type if add_typeof_helper<value_type,value_type>::type is convertible to value_type
Chris@16:         this_type& operator+=(const this_type& source)      { val_ += source.val_; return *this; }  
Chris@16:         
Chris@16:         ///< can subtract a quantity of the same type if subtract_typeof_helper<value_type,value_type>::type is convertible to value_type
Chris@16:         this_type& operator-=(const this_type& source)      { val_ -= source.val_; return *this; }  
Chris@16:         
Chris@16:         ///< can multiply a quantity by a scalar value_type if multiply_typeof_helper<value_type,value_type>::type is convertible to value_type
Chris@16:         this_type& operator*=(const value_type& val)        { val_ *= val; return *this; }          
Chris@16: 
Chris@16:         ///< can divide a quantity by a scalar value_type if divide_typeof_helper<value_type,value_type>::type is convertible to value_type
Chris@16:         this_type& operator/=(const value_type& val)        { val_ /= val; return *this; }          
Chris@16: 
Chris@16:         /// Construct quantity directly from @c value_type.
Chris@16:         static this_type from_value(const value_type& val)  { return this_type(val); }
Chris@16: 
Chris@16:    private:
Chris@16:         value_type    val_;
Chris@16: };
Chris@16: 
Chris@16: #ifdef BOOST_MSVC
Chris@16: // HACK: For some obscure reason msvc 8.0 needs these specializations
Chris@16: template<class System, class T>
Chris@16: class quantity<unit<int, System>, T> {};
Chris@16: template<class T>
Chris@16: class quantity<int, T> {};
Chris@16: #endif
Chris@16: 
Chris@16: } // namespace units
Chris@16: 
Chris@16: } // namespace boost
Chris@16: 
Chris@16: #if BOOST_UNITS_HAS_BOOST_TYPEOF
Chris@16: 
Chris@16: #include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()
Chris@16: 
Chris@16: BOOST_TYPEOF_REGISTER_TEMPLATE(boost::units::quantity, 2)
Chris@16: 
Chris@16: #endif
Chris@16: 
Chris@16: namespace boost {
Chris@16: 
Chris@16: namespace units {
Chris@16: 
Chris@16: namespace detail {
Chris@16: 
Chris@16: /// helper class for quantity_cast
Chris@16: template<class X,class Y> struct quantity_cast_helper;
Chris@16: 
Chris@16: /// specialization for casting to the value type
Chris@16: template<class Y,class X,class Unit>
Chris@16: struct quantity_cast_helper<Y,quantity<Unit,X> >
Chris@16: {
Chris@16:     typedef Y type;
Chris@16:     
Chris@16:     type operator()(quantity<Unit,X>& source)           { return const_cast<X&>(source.value()); }
Chris@16: };
Chris@16: 
Chris@16: /// specialization for casting to the value type
Chris@16: template<class Y,class X,class Unit>
Chris@16: struct quantity_cast_helper<Y,const quantity<Unit,X> >
Chris@16: {
Chris@16:     typedef Y type;
Chris@16:     
Chris@16:     type operator()(const quantity<Unit,X>& source)     { return source.value(); }
Chris@16: };
Chris@16: 
Chris@16: } // namespace detail
Chris@16: 
Chris@16: /// quantity_cast provides mutating access to underlying quantity value_type
Chris@16: template<class X,class Y>
Chris@16: inline 
Chris@16: X
Chris@16: quantity_cast(Y& source)
Chris@16: {
Chris@16:     detail::quantity_cast_helper<X,Y>   qch;
Chris@16:     
Chris@16:     return qch(source);
Chris@16: }
Chris@16: 
Chris@16: template<class X,class Y>
Chris@16: inline 
Chris@16: X
Chris@16: quantity_cast(const Y& source)
Chris@16: {
Chris@16:     detail::quantity_cast_helper<X,const Y>   qch;
Chris@16:     
Chris@16:     return qch(source);
Chris@16: }
Chris@16: 
Chris@16: /// swap quantities
Chris@16: template<class Unit,class Y>
Chris@16: inline void swap(quantity<Unit,Y>& lhs, quantity<Unit,Y>& rhs)
Chris@16: {
Chris@16:     using std::swap;
Chris@16:     swap(quantity_cast<Y&>(lhs),quantity_cast<Y&>(rhs));
Chris@16: }
Chris@16: 
Chris@16: /// specialize unary plus typeof helper
Chris@16: /// INTERNAL ONLY
Chris@16: template<class Unit,class Y>
Chris@16: struct unary_plus_typeof_helper< quantity<Unit,Y> >
Chris@16: {
Chris@16:     typedef typename unary_plus_typeof_helper<Y>::type      value_type;
Chris@16:     typedef typename unary_plus_typeof_helper<Unit>::type   unit_type;
Chris@16:     typedef quantity<unit_type,value_type>                  type;
Chris@16: };
Chris@16: 
Chris@16: /// specialize unary minus typeof helper
Chris@16: /// INTERNAL ONLY
Chris@16: template<class Unit,class Y>
Chris@16: struct unary_minus_typeof_helper< quantity<Unit,Y> >
Chris@16: {
Chris@16:     typedef typename unary_minus_typeof_helper<Y>::type     value_type;
Chris@16:     typedef typename unary_minus_typeof_helper<Unit>::type  unit_type;
Chris@16:     typedef quantity<unit_type,value_type>                  type;
Chris@16: };
Chris@16: 
Chris@16: /// specialize add typeof helper
Chris@16: /// INTERNAL ONLY
Chris@16: template<class Unit1,
Chris@16:          class Unit2,
Chris@16:          class X,
Chris@16:          class Y>
Chris@16: struct add_typeof_helper< quantity<Unit1,X>,quantity<Unit2,Y> >
Chris@16: {
Chris@16:     typedef typename add_typeof_helper<X,Y>::type           value_type;
Chris@16:     typedef typename add_typeof_helper<Unit1,Unit2>::type   unit_type;
Chris@16:     typedef quantity<unit_type,value_type>                  type;
Chris@16: };
Chris@16: 
Chris@16: /// for sun CC we need to invoke SFINAE at
Chris@16: /// the top level, otherwise it will silently
Chris@16: /// return int.
Chris@16: template<class Dim1, class System1,
Chris@16:          class Dim2, class System2,
Chris@16:          class X,
Chris@16:          class Y>
Chris@16: struct add_typeof_helper< quantity<unit<Dim1, System1>,X>,quantity<unit<Dim2, System2>,Y> >
Chris@16: {
Chris@16: };
Chris@16: 
Chris@16: template<class Dim,
Chris@16:          class System,
Chris@16:          class X,
Chris@16:          class Y>
Chris@16: struct add_typeof_helper< quantity<unit<Dim, System>,X>,quantity<unit<Dim, System>,Y> >
Chris@16: {
Chris@16:     typedef typename add_typeof_helper<X,Y>::type  value_type;
Chris@16:     typedef unit<Dim, System>                      unit_type;
Chris@16:     typedef quantity<unit_type,value_type>         type;
Chris@16: };
Chris@16: 
Chris@16: /// specialize subtract typeof helper
Chris@16: /// INTERNAL ONLY
Chris@16: template<class Unit1,
Chris@16:          class Unit2,
Chris@16:          class X,
Chris@16:          class Y>
Chris@16: struct subtract_typeof_helper< quantity<Unit1,X>,quantity<Unit2,Y> >
Chris@16: {
Chris@16:     typedef typename subtract_typeof_helper<X,Y>::type          value_type;
Chris@16:     typedef typename subtract_typeof_helper<Unit1,Unit2>::type  unit_type;
Chris@16:     typedef quantity<unit_type,value_type>                      type;
Chris@16: };
Chris@16: 
Chris@16: // Force adding different units to fail on sun.
Chris@16: template<class Dim1, class System1,
Chris@16:          class Dim2, class System2,
Chris@16:          class X,
Chris@16:          class Y>
Chris@16: struct subtract_typeof_helper< quantity<unit<Dim1, System1>,X>,quantity<unit<Dim2, System2>,Y> >
Chris@16: {
Chris@16: };
Chris@16: 
Chris@16: template<class Dim,
Chris@16:          class System,
Chris@16:          class X,
Chris@16:          class Y>
Chris@16: struct subtract_typeof_helper< quantity<unit<Dim, System>,X>,quantity<unit<Dim, System>,Y> >
Chris@16: {
Chris@16:     typedef typename subtract_typeof_helper<X,Y>::type  value_type;
Chris@16:     typedef unit<Dim, System>                           unit_type;
Chris@16:     typedef quantity<unit_type,value_type>              type;
Chris@16: };
Chris@16: 
Chris@16: /// scalar times unit typeof helper
Chris@16: /// INTERNAL ONLY
Chris@16: template<class System,
Chris@16:          class Dim,
Chris@16:          class X>
Chris@16: struct multiply_typeof_helper< X,unit<Dim,System> >
Chris@16: {
Chris@16:     typedef X                               value_type;
Chris@16:     typedef unit<Dim,System>                unit_type;
Chris@16:     typedef quantity<unit_type,value_type>  type;
Chris@16: };
Chris@16: 
Chris@16: /// unit times scalar typeof helper
Chris@16: /// INTERNAL ONLY
Chris@16: template<class System,
Chris@16:          class Dim,
Chris@16:          class X>
Chris@16: struct multiply_typeof_helper< unit<Dim,System>,X >
Chris@16: {
Chris@16:     typedef X                               value_type;
Chris@16:     typedef unit<Dim,System>                unit_type;
Chris@16:     typedef quantity<unit_type,value_type>  type;
Chris@16: };
Chris@16: 
Chris@16: /// scalar times quantity typeof helper
Chris@16: /// INTERNAL ONLY
Chris@16: template<class Unit,
Chris@16:          class X,
Chris@16:          class Y>
Chris@16: struct multiply_typeof_helper< X,quantity<Unit,Y> >
Chris@16: {
Chris@16:     typedef typename multiply_typeof_helper<X,Y>::type  value_type;
Chris@16:     typedef Unit                                        unit_type;
Chris@16:     typedef quantity<unit_type,value_type>              type;
Chris@16: };
Chris@16: 
Chris@16: /// disambiguate
Chris@16: /// INTERNAL ONLY
Chris@16: template<class Unit,
Chris@16:          class Y>
Chris@16: struct multiply_typeof_helper< one,quantity<Unit,Y> >
Chris@16: {
Chris@16:     typedef quantity<Unit,Y> type;
Chris@16: };
Chris@16: 
Chris@16: /// quantity times scalar typeof helper
Chris@16: /// INTERNAL ONLY
Chris@16: template<class Unit,
Chris@16:          class X,
Chris@16:          class Y>
Chris@16: struct multiply_typeof_helper< quantity<Unit,X>,Y >
Chris@16: {
Chris@16:     typedef typename multiply_typeof_helper<X,Y>::type  value_type;
Chris@16:     typedef Unit                                        unit_type;
Chris@16:     typedef quantity<unit_type,value_type>              type;
Chris@16: };
Chris@16: 
Chris@16: /// disambiguate
Chris@16: /// INTERNAL ONLY
Chris@16: template<class Unit,
Chris@16:          class X>
Chris@16: struct multiply_typeof_helper< quantity<Unit,X>,one >
Chris@16: {
Chris@16:     typedef quantity<Unit,X> type;
Chris@16: };
Chris@16: 
Chris@16: /// unit times quantity typeof helper
Chris@16: /// INTERNAL ONLY
Chris@16: template<class Unit,
Chris@16:          class System,
Chris@16:          class Dim,
Chris@16:          class X>
Chris@16: struct multiply_typeof_helper< unit<Dim,System>,quantity<Unit,X> >
Chris@16: {
Chris@16:     typedef X                                                               value_type;
Chris@16:     typedef typename multiply_typeof_helper< unit<Dim,System>,Unit >::type  unit_type;
Chris@16:     typedef quantity<unit_type,value_type>                                  type;
Chris@16: };
Chris@16: 
Chris@16: /// quantity times unit typeof helper
Chris@16: /// INTERNAL ONLY
Chris@16: template<class Unit,
Chris@16:          class System,
Chris@16:          class Dim,
Chris@16:          class X>
Chris@16: struct multiply_typeof_helper< quantity<Unit,X>,unit<Dim,System> >
Chris@16: {
Chris@16:     typedef X                                                               value_type;
Chris@16:     typedef typename multiply_typeof_helper< Unit,unit<Dim,System> >::type  unit_type;
Chris@16:     typedef quantity<unit_type,value_type>                                  type;
Chris@16: };
Chris@16: 
Chris@16: /// quantity times quantity typeof helper
Chris@16: /// INTERNAL ONLY
Chris@16: template<class Unit1,
Chris@16:          class Unit2,
Chris@16:          class X,
Chris@16:          class Y>
Chris@16: struct multiply_typeof_helper< quantity<Unit1,X>,quantity<Unit2,Y> >
Chris@16: {
Chris@16:     typedef typename multiply_typeof_helper<X,Y>::type          value_type;
Chris@16:     typedef typename multiply_typeof_helper<Unit1,Unit2>::type  unit_type;
Chris@16:     typedef quantity<unit_type,value_type>                      type;
Chris@16: };
Chris@16: 
Chris@16: /// scalar divided by unit typeof helper
Chris@16: /// INTERNAL ONLY
Chris@16: template<class System,
Chris@16:          class Dim,
Chris@16:          class X>
Chris@16: struct divide_typeof_helper< X,unit<Dim,System> >
Chris@16: {
Chris@16:     typedef X                                                                           value_type;
Chris@16:     typedef typename power_typeof_helper< unit<Dim,System>,static_rational<-1> >::type  unit_type;
Chris@16:     typedef quantity<unit_type,value_type>                                              type;
Chris@16: };
Chris@16: 
Chris@16: /// unit divided by scalar typeof helper
Chris@16: /// INTERNAL ONLY
Chris@16: template<class System,
Chris@16:          class Dim,
Chris@16:          class X>
Chris@16: struct divide_typeof_helper< unit<Dim,System>,X >
Chris@16: {
Chris@16:     typedef typename divide_typeof_helper<X,X>::type    value_type;
Chris@16:     typedef unit<Dim,System>                            unit_type;
Chris@16:     typedef quantity<unit_type,value_type>              type;
Chris@16: };
Chris@16: 
Chris@16: /// scalar divided by quantity typeof helper
Chris@16: /// INTERNAL ONLY
Chris@16: template<class Unit,
Chris@16:          class X,
Chris@16:          class Y>
Chris@16: struct divide_typeof_helper< X,quantity<Unit,Y> >
Chris@16: {
Chris@16:     typedef typename divide_typeof_helper<X,Y>::type                        value_type;
Chris@16:     typedef typename power_typeof_helper< Unit,static_rational<-1> >::type  unit_type;
Chris@16:     typedef quantity<unit_type,value_type>                                  type;
Chris@16: };
Chris@16: 
Chris@16: /// disambiguate
Chris@16: /// INTERNAL ONLY
Chris@16: template<class Unit,
Chris@16:          class Y>
Chris@16: struct divide_typeof_helper< one,quantity<Unit,Y> >
Chris@16: {
Chris@16:     typedef quantity<Unit,Y> type;
Chris@16: };
Chris@16: 
Chris@16: /// quantity divided by scalar typeof helper
Chris@16: /// INTERNAL ONLY
Chris@16: template<class Unit,
Chris@16:          class X,
Chris@16:          class Y>
Chris@16: struct divide_typeof_helper< quantity<Unit,X>,Y >
Chris@16: {
Chris@16:     typedef typename divide_typeof_helper<X,Y>::type    value_type;
Chris@16:     typedef Unit                                        unit_type;
Chris@16:     typedef quantity<unit_type,value_type>              type;
Chris@16: };
Chris@16: 
Chris@16: /// disambiguate
Chris@16: /// INTERNAL ONLY
Chris@16: template<class Unit,
Chris@16:          class X>
Chris@16: struct divide_typeof_helper< quantity<Unit,X>,one >
Chris@16: {
Chris@16:     typedef quantity<Unit,X> type;
Chris@16: };
Chris@16: 
Chris@16: /// unit divided by quantity typeof helper
Chris@16: /// INTERNAL ONLY
Chris@16: template<class Unit,
Chris@16:          class System,
Chris@16:          class Dim,
Chris@16:          class X>
Chris@16: struct divide_typeof_helper< unit<Dim,System>,quantity<Unit,X> >
Chris@16: {
Chris@16:     typedef typename divide_typeof_helper<X,X>::type                        value_type;
Chris@16:     typedef typename divide_typeof_helper< unit<Dim,System>,Unit >::type    unit_type;
Chris@16:     typedef quantity<unit_type,value_type>                                  type;
Chris@16: };
Chris@16: 
Chris@16: /// quantity divided by unit typeof helper
Chris@16: /// INTERNAL ONLY
Chris@16: template<class Unit,
Chris@16:          class System,
Chris@16:          class Dim,
Chris@16:          class X>
Chris@16: struct divide_typeof_helper< quantity<Unit,X>,unit<Dim,System> >
Chris@16: {
Chris@16:     typedef X                                                               value_type;
Chris@16:     typedef typename divide_typeof_helper< Unit,unit<Dim,System> >::type    unit_type;
Chris@16:     typedef quantity<unit_type,value_type>                                  type;
Chris@16: };
Chris@16: 
Chris@16: /// quantity divided by quantity typeof helper
Chris@16: /// INTERNAL ONLY
Chris@16: template<class Unit1,
Chris@16:          class Unit2,
Chris@16:          class X,
Chris@16:          class Y>
Chris@16: struct divide_typeof_helper< quantity<Unit1,X>,quantity<Unit2,Y> >
Chris@16: {
Chris@16:     typedef typename divide_typeof_helper<X,Y>::type            value_type;
Chris@16:     typedef typename divide_typeof_helper<Unit1,Unit2>::type    unit_type;
Chris@16:     typedef quantity<unit_type,value_type>                      type;
Chris@16: };
Chris@16: 
Chris@16: /// specialize power typeof helper
Chris@16: /// INTERNAL ONLY
Chris@16: template<class Unit,long N,long D,class Y> 
Chris@16: struct power_typeof_helper< quantity<Unit,Y>,static_rational<N,D> >                
Chris@16: { 
Chris@16:     typedef typename power_typeof_helper<Y,static_rational<N,D> >::type     value_type;
Chris@16:     typedef typename power_typeof_helper<Unit,static_rational<N,D> >::type  unit_type;
Chris@16:     typedef quantity<unit_type,value_type>                                  type; 
Chris@16:     
Chris@16:     static type value(const quantity<Unit,Y>& x)  
Chris@16:     { 
Chris@16:         return type::from_value(power_typeof_helper<Y,static_rational<N,D> >::value(x.value()));
Chris@16:     }
Chris@16: };
Chris@16: 
Chris@16: /// specialize root typeof helper
Chris@16: /// INTERNAL ONLY
Chris@16: template<class Unit,long N,long D,class Y> 
Chris@16: struct root_typeof_helper< quantity<Unit,Y>,static_rational<N,D> >                
Chris@16: { 
Chris@16:     typedef typename root_typeof_helper<Y,static_rational<N,D> >::type      value_type;
Chris@16:     typedef typename root_typeof_helper<Unit,static_rational<N,D> >::type   unit_type;
Chris@16:     typedef quantity<unit_type,value_type>                                  type;
Chris@16:     
Chris@16:     static type value(const quantity<Unit,Y>& x)  
Chris@16:     { 
Chris@16:         return type::from_value(root_typeof_helper<Y,static_rational<N,D> >::value(x.value()));
Chris@16:     }
Chris@16: };
Chris@16: 
Chris@16: /// runtime unit times scalar
Chris@16: /// INTERNAL ONLY
Chris@16: template<class System,
Chris@16:          class Dim,
Chris@16:          class Y>
Chris@16: inline
Chris@16: typename multiply_typeof_helper< unit<Dim,System>,Y >::type
Chris@16: operator*(const unit<Dim,System>&,const Y& rhs)
Chris@16: {
Chris@16:     typedef typename multiply_typeof_helper< unit<Dim,System>,Y >::type type;
Chris@16:     
Chris@16:     return type::from_value(rhs);
Chris@16: }
Chris@16: 
Chris@16: /// runtime unit divided by scalar
Chris@16: template<class System,
Chris@16:          class Dim,
Chris@16:          class Y>
Chris@16: inline
Chris@16: typename divide_typeof_helper< unit<Dim,System>,Y >::type
Chris@16: operator/(const unit<Dim,System>&,const Y& rhs)
Chris@16: {
Chris@16:     typedef typename divide_typeof_helper<unit<Dim,System>,Y>::type type;
Chris@16:     
Chris@16:     return type::from_value(Y(1)/rhs);
Chris@16: }
Chris@16: 
Chris@16: /// runtime scalar times unit
Chris@16: template<class System,
Chris@16:          class Dim,
Chris@16:          class Y>
Chris@16: inline
Chris@16: typename multiply_typeof_helper< Y,unit<Dim,System> >::type
Chris@16: operator*(const Y& lhs,const unit<Dim,System>&)
Chris@16: {
Chris@16:     typedef typename multiply_typeof_helper< Y,unit<Dim,System> >::type type;
Chris@16:     
Chris@16:     return type::from_value(lhs);
Chris@16: }
Chris@16: 
Chris@16: /// runtime scalar divided by unit
Chris@16: template<class System,
Chris@16:          class Dim,
Chris@16:          class Y>
Chris@16: inline
Chris@16: typename divide_typeof_helper< Y,unit<Dim,System> >::type
Chris@16: operator/(const Y& lhs,const unit<Dim,System>&)
Chris@16: {
Chris@16:     typedef typename divide_typeof_helper< Y,unit<Dim,System> >::type   type;
Chris@16:     
Chris@16:     return type::from_value(lhs);
Chris@16: }
Chris@16: 
Chris@16: ///// runtime quantity times scalar
Chris@16: //template<class Unit,
Chris@16: //         class X,
Chris@16: //         class Y>
Chris@16: //inline
Chris@16: //typename multiply_typeof_helper< quantity<Unit,X>,Y >::type
Chris@16: //operator*(const quantity<Unit,X>& lhs,const Y& rhs)
Chris@16: //{
Chris@16: //    typedef typename multiply_typeof_helper< quantity<Unit,X>,Y >::type type;
Chris@16: //    
Chris@16: //    return type::from_value(lhs.value()*rhs);
Chris@16: //}
Chris@16: //
Chris@16: ///// runtime scalar times quantity
Chris@16: //template<class Unit,
Chris@16: //         class X,
Chris@16: //         class Y>
Chris@16: //inline
Chris@16: //typename multiply_typeof_helper< X,quantity<Unit,Y> >::type
Chris@16: //operator*(const X& lhs,const quantity<Unit,Y>& rhs)
Chris@16: //{
Chris@16: //    typedef typename multiply_typeof_helper< X,quantity<Unit,Y> >::type type;
Chris@16: //    
Chris@16: //    return type::from_value(lhs*rhs.value());
Chris@16: //}
Chris@16: 
Chris@16: /// runtime quantity times scalar
Chris@16: template<class Unit,
Chris@16:          class X>
Chris@16: inline
Chris@16: typename multiply_typeof_helper< quantity<Unit,X>,X >::type
Chris@16: operator*(const quantity<Unit,X>& lhs,const X& rhs)
Chris@16: {
Chris@16:     typedef typename multiply_typeof_helper< quantity<Unit,X>,X >::type type;
Chris@16:     
Chris@16:     return type::from_value(lhs.value()*rhs);
Chris@16: }
Chris@16: 
Chris@16: /// runtime scalar times quantity
Chris@16: template<class Unit,
Chris@16:          class X>
Chris@16: inline
Chris@16: typename multiply_typeof_helper< X,quantity<Unit,X> >::type
Chris@16: operator*(const X& lhs,const quantity<Unit,X>& rhs)
Chris@16: {
Chris@16:     typedef typename multiply_typeof_helper< X,quantity<Unit,X> >::type type;
Chris@16:     
Chris@16:     return type::from_value(lhs*rhs.value());
Chris@16: }
Chris@16: 
Chris@16: ///// runtime quantity divided by scalar
Chris@16: //template<class Unit,
Chris@16: //         class X,
Chris@16: //         class Y>
Chris@16: //inline
Chris@16: //typename divide_typeof_helper< quantity<Unit,X>,Y >::type
Chris@16: //operator/(const quantity<Unit,X>& lhs,const Y& rhs)
Chris@16: //{
Chris@16: //    typedef typename divide_typeof_helper< quantity<Unit,X>,Y >::type   type;
Chris@16: //    
Chris@16: //    return type::from_value(lhs.value()/rhs);
Chris@16: //}
Chris@16: //
Chris@16: ///// runtime scalar divided by quantity
Chris@16: //template<class Unit,
Chris@16: //         class X,
Chris@16: //         class Y>
Chris@16: //inline
Chris@16: //typename divide_typeof_helper< X,quantity<Unit,Y> >::type
Chris@16: //operator/(const X& lhs,const quantity<Unit,Y>& rhs)
Chris@16: //{
Chris@16: //    typedef typename divide_typeof_helper< X,quantity<Unit,Y> >::type   type;
Chris@16: //    
Chris@16: //    return type::from_value(lhs/rhs.value());
Chris@16: //}
Chris@16: 
Chris@16: /// runtime quantity divided by scalar
Chris@16: template<class Unit,
Chris@16:          class X>
Chris@16: inline
Chris@16: typename divide_typeof_helper< quantity<Unit,X>,X >::type
Chris@16: operator/(const quantity<Unit,X>& lhs,const X& rhs)
Chris@16: {
Chris@16:     typedef typename divide_typeof_helper< quantity<Unit,X>,X >::type   type;
Chris@16:     
Chris@16:     return type::from_value(lhs.value()/rhs);
Chris@16: }
Chris@16: 
Chris@16: /// runtime scalar divided by quantity
Chris@16: template<class Unit,
Chris@16:          class X>
Chris@16: inline
Chris@16: typename divide_typeof_helper< X,quantity<Unit,X> >::type
Chris@16: operator/(const X& lhs,const quantity<Unit,X>& rhs)
Chris@16: {
Chris@16:     typedef typename divide_typeof_helper< X,quantity<Unit,X> >::type   type;
Chris@16:     
Chris@16:     return type::from_value(lhs/rhs.value());
Chris@16: }
Chris@16: 
Chris@16: /// runtime unit times quantity
Chris@16: template<class System1,
Chris@16:          class Dim1,
Chris@16:          class Unit2,
Chris@16:          class Y>
Chris@16: inline
Chris@16: typename multiply_typeof_helper< unit<Dim1,System1>,quantity<Unit2,Y> >::type
Chris@16: operator*(const unit<Dim1,System1>&,const quantity<Unit2,Y>& rhs)
Chris@16: {
Chris@16:     typedef typename multiply_typeof_helper< unit<Dim1,System1>,quantity<Unit2,Y> >::type  type;
Chris@16:     
Chris@16:     return type::from_value(rhs.value());
Chris@16: }
Chris@16: 
Chris@16: /// runtime unit divided by quantity
Chris@16: template<class System1,
Chris@16:          class Dim1,
Chris@16:          class Unit2,
Chris@16:          class Y>
Chris@16: inline
Chris@16: typename divide_typeof_helper< unit<Dim1,System1>,quantity<Unit2,Y> >::type
Chris@16: operator/(const unit<Dim1,System1>&,const quantity<Unit2,Y>& rhs)
Chris@16: {
Chris@16:     typedef typename divide_typeof_helper< unit<Dim1,System1>,quantity<Unit2,Y> >::type    type;
Chris@16:     
Chris@16:     return type::from_value(Y(1)/rhs.value());
Chris@16: }
Chris@16: 
Chris@16: /// runtime quantity times unit
Chris@16: template<class Unit1,
Chris@16:          class System2,
Chris@16:          class Dim2,
Chris@16:          class Y>
Chris@16: inline
Chris@16: typename multiply_typeof_helper< quantity<Unit1,Y>,unit<Dim2,System2> >::type
Chris@16: operator*(const quantity<Unit1,Y>& lhs,const unit<Dim2,System2>&)
Chris@16: {
Chris@16:     typedef typename multiply_typeof_helper< quantity<Unit1,Y>,unit<Dim2,System2> >::type  type;
Chris@16:     
Chris@16:     return type::from_value(lhs.value());
Chris@16: }
Chris@16: 
Chris@16: /// runtime quantity divided by unit
Chris@16: template<class Unit1,
Chris@16:          class System2,
Chris@16:          class Dim2,
Chris@16:          class Y>
Chris@16: inline
Chris@16: typename divide_typeof_helper< quantity<Unit1,Y>,unit<Dim2,System2> >::type
Chris@16: operator/(const quantity<Unit1,Y>& lhs,const unit<Dim2,System2>&)
Chris@16: {
Chris@16:     typedef typename divide_typeof_helper< quantity<Unit1,Y>,unit<Dim2,System2> >::type    type;
Chris@16:     
Chris@16:     return type::from_value(lhs.value());
Chris@16: }
Chris@16: 
Chris@16: /// runtime unary plus quantity
Chris@16: template<class Unit,class Y>
Chris@16: typename unary_plus_typeof_helper< quantity<Unit,Y> >::type
Chris@16: operator+(const quantity<Unit,Y>& val)
Chris@16: { 
Chris@16:     typedef typename unary_plus_typeof_helper< quantity<Unit,Y> >::type     type;
Chris@16:     
Chris@16:     return type::from_value(+val.value());
Chris@16: }
Chris@16: 
Chris@16: /// runtime unary minus quantity
Chris@16: template<class Unit,class Y>
Chris@16: typename unary_minus_typeof_helper< quantity<Unit,Y> >::type
Chris@16: operator-(const quantity<Unit,Y>& val)
Chris@16: { 
Chris@16:     typedef typename unary_minus_typeof_helper< quantity<Unit,Y> >::type    type;
Chris@16:     
Chris@16:     return type::from_value(-val.value());
Chris@16: }
Chris@16: 
Chris@16: /// runtime quantity plus quantity
Chris@16: template<class Unit1,
Chris@16:          class Unit2,
Chris@16:          class X,
Chris@16:          class Y>
Chris@16: inline
Chris@16: typename add_typeof_helper< quantity<Unit1,X>,quantity<Unit2,Y> >::type
Chris@16: operator+(const quantity<Unit1,X>& lhs,
Chris@16:           const quantity<Unit2,Y>& rhs)
Chris@16: {
Chris@16:     typedef typename add_typeof_helper< quantity<Unit1,X>,quantity<Unit2,Y> >::type     type;
Chris@16:     
Chris@16:     return type::from_value(lhs.value()+rhs.value());
Chris@16: }
Chris@16: 
Chris@16: /// runtime quantity minus quantity
Chris@16: template<class Unit1,
Chris@16:          class Unit2,
Chris@16:          class X,
Chris@16:          class Y>
Chris@16: inline
Chris@16: typename subtract_typeof_helper< quantity<Unit1,X>,quantity<Unit2,Y> >::type
Chris@16: operator-(const quantity<Unit1,X>& lhs,
Chris@16:           const quantity<Unit2,Y>& rhs)
Chris@16: {
Chris@16:     typedef typename subtract_typeof_helper< quantity<Unit1,X>,quantity<Unit2,Y> >::type    type;
Chris@16:     
Chris@16:     return type::from_value(lhs.value()-rhs.value());
Chris@16: }
Chris@16: 
Chris@16: /// runtime quantity times quantity
Chris@16: template<class Unit1,
Chris@16:          class Unit2,
Chris@16:          class X,
Chris@16:          class Y>
Chris@16: inline
Chris@16: typename multiply_typeof_helper< quantity<Unit1,X>,quantity<Unit2,Y> >::type
Chris@16: operator*(const quantity<Unit1,X>& lhs,
Chris@16:           const quantity<Unit2,Y>& rhs)
Chris@16: {
Chris@16:     typedef typename multiply_typeof_helper< quantity<Unit1,X>,
Chris@16:                                              quantity<Unit2,Y> >::type type;
Chris@16:     
Chris@16:     return type::from_value(lhs.value()*rhs.value());
Chris@16: }
Chris@16: 
Chris@16: /// runtime quantity divided by quantity
Chris@16: template<class Unit1,
Chris@16:          class Unit2,
Chris@16:          class X,
Chris@16:          class Y>
Chris@16: inline
Chris@16: typename divide_typeof_helper< quantity<Unit1,X>,quantity<Unit2,Y> >::type
Chris@16: operator/(const quantity<Unit1,X>& lhs,
Chris@16:           const quantity<Unit2,Y>& rhs)
Chris@16: {
Chris@16:     typedef typename divide_typeof_helper< quantity<Unit1,X>,
Chris@16:                                            quantity<Unit2,Y> >::type   type;
Chris@16:     
Chris@16:     return type::from_value(lhs.value()/rhs.value());
Chris@16: }
Chris@16: 
Chris@16: /// runtime operator==
Chris@16: template<class Unit,
Chris@16:          class X,
Chris@16:          class Y>
Chris@16: inline
Chris@16: bool 
Chris@16: operator==(const quantity<Unit,X>& val1,
Chris@16:            const quantity<Unit,Y>& val2)
Chris@16: {
Chris@16:     return val1.value() == val2.value();
Chris@16: }
Chris@16: 
Chris@16: /// runtime operator!=
Chris@16: template<class Unit,
Chris@16:          class X,
Chris@16:          class Y>
Chris@16: inline
Chris@16: bool 
Chris@16: operator!=(const quantity<Unit,X>& val1,
Chris@16:            const quantity<Unit,Y>& val2)
Chris@16: {
Chris@16:     return val1.value() != val2.value();
Chris@16: }
Chris@16: 
Chris@16: /// runtime operator<
Chris@16: template<class Unit,
Chris@16:          class X,
Chris@16:          class Y>
Chris@16: inline
Chris@16: bool 
Chris@16: operator<(const quantity<Unit,X>& val1,
Chris@16:           const quantity<Unit,Y>& val2)
Chris@16: {
Chris@16:     return val1.value() < val2.value();
Chris@16: }
Chris@16: 
Chris@16: /// runtime operator<=
Chris@16: template<class Unit,
Chris@16:          class X,
Chris@16:          class Y>
Chris@16: inline
Chris@16: bool 
Chris@16: operator<=(const quantity<Unit,X>& val1,
Chris@16:            const quantity<Unit,Y>& val2)
Chris@16: {
Chris@16:     return val1.value() <= val2.value();
Chris@16: }
Chris@16: 
Chris@16: /// runtime operator>
Chris@16: template<class Unit,
Chris@16:          class X,
Chris@16:          class Y>
Chris@16: inline
Chris@16: bool 
Chris@16: operator>(const quantity<Unit,X>& val1,
Chris@16:           const quantity<Unit,Y>& val2)
Chris@16: {
Chris@16:     return val1.value() > val2.value();
Chris@16: }
Chris@16: 
Chris@16: /// runtime operator>=
Chris@16: template<class Unit,
Chris@16:          class X,
Chris@16:          class Y>
Chris@16: inline
Chris@16: bool 
Chris@16: operator>=(const quantity<Unit,X>& val1,
Chris@16:            const quantity<Unit,Y>& val2)
Chris@16: {
Chris@16:     return val1.value() >= val2.value();
Chris@16: }
Chris@16: 
Chris@16: } // namespace units
Chris@16: 
Chris@16: } // namespace boost
Chris@16: 
Chris@16: #endif // BOOST_UNITS_QUANTITY_HPP