[Boost-commit] svn:boost r39017 - in sandbox/units: boost/units libs/units/test

From: steven_at_[hidden]
Date: 2007-08-27 15:57:18

Author: steven_watanabe
Date: 2007-08-27 15:57:18 EDT (Mon, 27 Aug 2007)
New Revision: 39017
URL: http://svn.boost.org/trac/boost/changeset/39017

Log:
Made BOOST_UNITS_DEFAULT_CONVERSION support scaling and made conversions work when only some base_units use it
Text files modified: 
   sandbox/units/boost/units/conversion.hpp                  |    81 +++++++++++++++++++++++++++++---------- 
   sandbox/units/libs/units/test/test_default_conversion.cpp |    35 +++++++++++++---                        
   2 files changed, 88 insertions(+), 28 deletions(-)

Modified: sandbox/units/boost/units/conversion.hpp
==============================================================================
--- sandbox/units/boost/units/conversion.hpp	(original)
+++ sandbox/units/boost/units/conversion.hpp	2007-08-27 15:57:18 EDT (Mon, 27 Aug 2007)
@@ -80,8 +80,47 @@
 /// INTERNAL ONLY
 struct undefined_base_unit_converter_base {};
 
+/// INTERNAL ONLY
+struct no_default_conversion {};
+
+/// INTERNAL ONLY
 template<class BaseUnit>
-struct get_default_conversion;
+struct unscaled_get_default_conversion : no_default_conversion {};
+
+/// INTERNAL ONLY
+template<bool is_defined>
+struct unscaled_get_default_conversion_impl;
+
+/// INTERNAL ONLY
+template<>
+struct unscaled_get_default_conversion_impl<true>
+{
+    template<class T>
+    struct apply
+    {
+        typedef typename unscaled_get_default_conversion<typename unscale<T>::type>::type type;
+    };
+};
+
+/// INTERNAL ONLY
+template<>
+struct unscaled_get_default_conversion_impl<false>
+{
+    template<class T>
+    struct apply
+    {
+        typedef typename T::unit_type type;
+    };
+};
+
+/// INTERNAL ONLY
+template<class BaseUnit>
+struct get_default_conversion
+{
+    typedef typename unscaled_get_default_conversion_impl<
+        !boost::is_base_and_derived<no_default_conversion, unscaled_get_default_conversion<typename unscale<BaseUnit>::type> >::value
+    >::template apply<BaseUnit>::type type;
+};
 
 /// INTERNAL ONLY
 template<class Source, class Destination>
@@ -412,16 +451,16 @@
 /// no direct conversion is available.
 /// Source is a base unit.  Dest is any unit with the
 /// same dimensions.
-#define BOOST_UNITS_DEFAULT_CONVERSION(Source, Dest)\
-    namespace boost {\
-    namespace units {\
-    template<>\
-    struct get_default_conversion<Source>\
-    {\
-        typedef Dest type;\
-    };\
-    }\
-    }\
+#define BOOST_UNITS_DEFAULT_CONVERSION(Source, Dest)                \
+    namespace boost {                                               \
+    namespace units {                                               \
+    template<>                                                      \
+    struct unscaled_get_default_conversion<unscale<Source>::type>   \
+    {                                                               \
+        typedef Dest type;                                          \
+    };                                                              \
+    }                                                               \
+    }                                                               \
     void boost_units_require_semicolon()
 
 /// Specifies the default conversion to be applied when
@@ -429,16 +468,16 @@
 /// Params is a PP Sequence of template arguments.
 /// Source is a base unit.  Dest is any unit with the
 /// same dimensions.
-#define BOOST_UNITS_DEFAULT_CONVERSION_TEMPLATE(Params, Source, Dest)\
-    namespace boost {\
-    namespace units {\
-    template<BOOST_PP_SEQ_ENUM(Params)>\
-    struct get_default_conversion<Source>\
-    {\
-        typedef Dest type;\
-    };\
-    }\
-    }\
+#define BOOST_UNITS_DEFAULT_CONVERSION_TEMPLATE(Params, Source, Dest)   \
+    namespace boost {                                                   \
+    namespace units {                                                   \
+    template<BOOST_PP_SEQ_ENUM(Params)>                                 \
+    struct unscaled_get_default_conversion<Source>                      \
+    {                                                                   \
+        typedef Dest type;                                              \
+    };                                                                  \
+    }                                                                   \
+    }                                                                   \
     void boost_units_require_semicolon()
 
 namespace detail {

Modified: sandbox/units/libs/units/test/test_default_conversion.cpp
==============================================================================
--- sandbox/units/libs/units/test/test_default_conversion.cpp	(original)
+++ sandbox/units/libs/units/test/test_default_conversion.cpp	2007-08-27 15:57:18 EDT (Mon, 27 Aug 2007)
@@ -12,29 +12,50 @@
 
 #include <boost/units/base_dimension.hpp>
 #include <boost/units/base_unit.hpp>
+#include <boost/units/scaled_base_unit.hpp>
 #include <boost/units/conversion.hpp>
 #include <boost/units/unit.hpp>
 
-struct dimension_tag : boost::units::base_dimension<dimension_tag, 1> {};
+struct dimension1_tag : boost::units::base_dimension<dimension1_tag, 1> {};
 
-typedef dimension_tag::dimension_type dimension;
+typedef dimension1_tag::dimension_type dimension1;
 
-struct unit1_tag : boost::units::base_unit<unit1_tag, dimension, 1> {}; 
+struct dimension2_tag : boost::units::base_dimension<dimension2_tag, 2> {};
 
-struct unit2_tag : boost::units::base_unit<unit2_tag, dimension, 2> {};
+typedef dimension2_tag::dimension_type dimension2;
 
-struct unit3_tag : boost::units::base_unit<unit3_tag, dimension, 3> {};
+typedef boost::mpl::times<dimension1, dimension2>::type dimension12;
+
+struct unit1_tag : boost::units::base_unit<unit1_tag, dimension1, 1> {}; 
+
+struct unit2_tag : boost::units::base_unit<unit2_tag, dimension1, 2> {};
+
+struct unit3_tag : boost::units::base_unit<unit3_tag, dimension1, 3> {};
+
+struct unit4_tag : boost::units::base_unit<unit4_tag, dimension2, 4> {};
+
+struct unit5_tag : boost::units::base_unit<unit5_tag, dimension12, 5> {};
 
 BOOST_UNITS_DEFINE_BASE_CONVERSION(unit1_tag, unit2_tag, double, 2.0);
 
 BOOST_UNITS_DEFINE_BASE_CONVERSION(unit2_tag, unit3_tag, double, 3.0);
 
+typedef boost::units::multiply_typeof_helper<unit3_tag::unit_type, unit4_tag::unit_type>::type unit34_type;
+BOOST_UNITS_DEFINE_CONVERSION(unit5_tag, unit34_type , double, 5.0);
+
 BOOST_UNITS_DEFAULT_CONVERSION(unit1_tag, unit2_tag::unit_type);
 
 BOOST_UNITS_DEFAULT_CONVERSION(unit3_tag, unit2_tag::unit_type);
 
+BOOST_UNITS_DEFAULT_CONVERSION(unit5_tag, unit34_type);
+
 int test_main(int, char*[]) {
-    double value = boost::units::conversion_factor(unit3_tag::unit_type(), unit1_tag::unit_type());
-    BOOST_CHECK(std::abs(value - 1.0/6.0) < .0000000001);
+    double value1 = boost::units::conversion_factor(unit3_tag::unit_type(), unit1_tag::unit_type());
+    BOOST_CHECK(std::abs(value1 - 1.0/6.0) < .0000000001);
+    double value2 = boost::units::conversion_factor(unit5_tag::unit_type() / unit4_tag::unit_type(), unit1_tag::unit_type());
+    BOOST_CHECK(std::abs(value2 - 5.0/6.0) < .0000000001);
+    typedef boost::units::scaled_base_unit<unit5_tag, boost::units::scale<2, boost::units::static_rational<1> > > scaled_unit5_tag;
+    double value3 = boost::units::conversion_factor(scaled_unit5_tag::unit_type() / unit4_tag::unit_type(), unit1_tag::unit_type());
+    BOOST_CHECK(std::abs(value3 - 10.0/6.0) < .0000000001);
     return(0);
 }