[Boost-commit] svn:boost r39023 - in sandbox/units/boost/units: . detail

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

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

Log:
Specializations for dimensionless_type now handle the special heterogeneous dimensionless unit
Added:
   sandbox/units/boost/units/detail/dimensionless_unit.hpp   (contents, props changed)
Text files modified: 
   sandbox/units/boost/units/quantity.hpp |    28 ++++++++++++++++++----------            
   1 files changed, 18 insertions(+), 10 deletions(-)

Added: sandbox/units/boost/units/detail/dimensionless_unit.hpp
==============================================================================
--- (empty file)
+++ sandbox/units/boost/units/detail/dimensionless_unit.hpp	2007-08-27 18:07:17 EDT (Mon, 27 Aug 2007)
@@ -0,0 +1,49 @@
+// mcs::units - A C++ library for zero-overhead dimensional analysis and 
+// unit/quantity manipulation and conversion
+//
+// Copyright (C) 2003-2007 Matthias Christian Schabel
+// Copyright (C) 2007 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)
+
+#ifndef BOOST_UNITS_DETAIL_DIMENSIONLESS_UNIT_HPP
+#define BOOST_UNITS_DETAIL_DIMENSIONLESS_UNIT_HPP
+
+#include <boost/utility/enable_if.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/units/units_fwd.hpp>
+#include <boost/units/heterogeneous_system.hpp>
+#include <boost/units/homogeneous_system.hpp>
+
+namespace boost {
+namespace units {
+namespace detail {
+
+template<class T>
+struct is_dimensionless_system : boost::mpl::false_ {};
+
+template<class T>
+struct is_dimensionless_system<boost::units::homogeneous_system<T> > : boost::mpl::true_ {};
+
+template<>
+struct is_dimensionless_system<
+   boost::units::heterogeneous_system<
+       boost::units::heterogeneous_system_pair<
+           boost::units::dimensionless_type,
+           boost::units::dimensionless_type
+       >
+   >
+> : boost::mpl::true_ {};
+
+#define BOOST_UNITS_DIMENSIONLESS_UNIT(T)\
+    boost::units::unit<typename boost::enable_if<boost::units::detail::is_dimensionless_system<T>, boost::units::dimensionless_type>::type, T>
+
+#define BOOST_UNITS_HETEROGENEOUS_DIMENSIONLESS_UNIT(T) boost::units::unit<typename boost::disable_if<boost::units::detail::is_dimensionless_system<T>, boost::units::dimensionless_type>::type, T>
+
+}
+}
+}
+
+#endif

Modified: sandbox/units/boost/units/quantity.hpp
==============================================================================
--- sandbox/units/boost/units/quantity.hpp	(original)
+++ sandbox/units/boost/units/quantity.hpp	2007-08-27 18:07:17 EDT (Mon, 27 Aug 2007)
@@ -31,6 +31,7 @@
 #include <boost/units/operators.hpp>
 #include <boost/units/static_rational.hpp>
 #include <boost/units/units_fwd.hpp>
+#include <boost/units/detail/dimensionless_unit.hpp>
 
 namespace boost {
 
@@ -269,11 +270,10 @@
 /// unit systems are allowed because all dimensionless quantities are equivalent.
 /// Implicit construction and assignment from and conversion to @c value_type is
 /// also allowed.
-template<class SystemTag,class Y>
-class quantity<unit<dimensionless_type,homogeneous_system<SystemTag> >,Y>
+template<class System,class Y>
+class quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(System),Y>
 {
     public:
-        typedef homogeneous_system<SystemTag> System;
         typedef quantity<unit<dimensionless_type,System>,Y>     this_type;
                                    
         typedef Y                                               value_type;
@@ -353,9 +353,9 @@
 
         /// implicit conversion between different unit systems is allowed
         template<class System2, class Y2> 
-        quantity(const quantity<unit<dimensionless_type,homogeneous_system<System2> >,Y2>& source,
+        quantity(const quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(System2),Y2>& source,
             typename boost::enable_if<detail::is_non_narrowing_conversion<Y2, Y>,
-			typename detail::disable_if_is_same<SystemTag, System2>::type>::type* = 0) :
+			typename detail::disable_if_is_same<System, System2>::type>::type* = 0) :
             val_(source.value()) 
         {
             BOOST_UNITS_CHECK_LAYOUT_COMPATIBILITY(this_type, Y);
@@ -363,9 +363,9 @@
 
         /// implicit conversion between different unit systems is allowed
         template<class System2, class Y2> 
-        explicit quantity(const quantity<unit<dimensionless_type,homogeneous_system<System2> >,Y2>& source,
+        explicit quantity(const quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(System2),Y2>& source,
             typename boost::disable_if<detail::is_non_narrowing_conversion<Y2, Y>,
-			typename detail::disable_if_is_same<SystemTag, System2>::type>::type* = 0) :
+			typename detail::disable_if_is_same<System, System2>::type>::type* = 0) :
             val_(static_cast<Y>(source.value())) 
         {
             BOOST_UNITS_CHECK_LAYOUT_COMPATIBILITY(this_type, Y);
@@ -387,15 +387,15 @@
         /// conversion between different unit systems is explicit when
         /// the units are not equivalent.
         template<class System2, class Y2> 
-        explicit quantity(const quantity<unit<dimensionless_type,System2>,Y2>& source) :
-            val_(conversion_helper<quantity<unit<dimensionless_type,System2>,Y2>, this_type>::convert(source).value()) 
+        explicit quantity(const quantity<BOOST_UNITS_HETEROGENEOUS_DIMENSIONLESS_UNIT(System2),Y2>& source) :
+            val_(conversion_helper<quantity<BOOST_UNITS_HETEROGENEOUS_DIMENSIONLESS_UNIT(System2),Y2>, this_type>::convert(source).value()) 
         {
             BOOST_UNITS_CHECK_LAYOUT_COMPATIBILITY(this_type, Y);
         }
 
         /// implicit assignment between different unit systems is allowed
         template<class System2>
-        this_type& operator=(const quantity<unit<dimensionless_type,homogeneous_system<System2> >,Y>& source)
+        this_type& operator=(const quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(System2),Y>& source)
         {
             *this = this_type(source);
             
@@ -426,6 +426,14 @@
         value_type    val_;
 };
 
+#ifdef BOOST_MSVC
+// HACK: For some obscure reason msvc 8.0 needs these specializations
+template<class System, class T>
+class quantity<unit<int, System>, T> {};
+template<class T>
+class quantity<int, T> {};
+#endif
+
 } // namespace units
 
 } // namespace boost