From: boost_at_[hidden]
Date: 2007-10-18 20:23:24
Author: matthiasschabel
Date: 2007-10-18 20:23:24 EDT (Thu, 18 Oct 2007)
New Revision: 40168
URL: http://svn.boost.org/trac/boost/changeset/40168
Log:
start moving internal code to implementation headers
Added:
sandbox/units/boost/units/detail/absolute_impl.hpp (contents, props changed)
sandbox/units/boost/units/detail/conversion_impl.hpp (contents, props changed)
sandbox/units/boost/units/detail/implicit_conversion.hpp (contents, props changed)
Removed:
sandbox/units/boost/units/implicit_conversion.hpp
Added: sandbox/units/boost/units/detail/absolute_impl.hpp
==============================================================================
--- (empty file)
+++ sandbox/units/boost/units/detail/absolute_impl.hpp 2007-10-18 20:23:24 EDT (Thu, 18 Oct 2007)
@@ -0,0 +1,110 @@
+// 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_ABSOLUTE_IMPL_HPP
+#define BOOST_UNITS_ABSOLUTE_IMPL_HPP
+
+#include <iosfwd>
+
+#include <boost/type_traits/is_base_and_derived.hpp>
+
+#include <boost/units/config.hpp>
+#include <boost/units/conversion.hpp>
+#include <boost/units/heterogeneous_system.hpp>
+#include <boost/units/units_fwd.hpp>
+
+namespace boost {
+
+namespace units {
+
+/// INTERNAL ONLY
+template<class D, class S>
+struct reduce_unit<absolute<unit<D, S> > >
+{
+ typedef absolute<typename reduce_unit<unit<D, S> >::type> type;
+};
+
+namespace detail {
+
+struct undefined_affine_conversion_base { };
+
+} // namespace detail
+
+/// INTERNAL ONLY
+template<class From, class To>
+struct affine_conversion_helper : detail::undefined_affine_conversion_base { };
+
+namespace detail {
+
+template<bool IsDefined, bool ReverseIsDefined>
+struct affine_conversion_impl;
+
+template<bool ReverseIsDefined>
+struct affine_conversion_impl<true, ReverseIsDefined>
+{
+ template<class Unit1, class Unit2, class T0, class T1>
+ struct apply {
+ static T1 value(const T0& t0)
+ {
+ return(
+ t0 *
+ conversion_factor(Unit1(), Unit2()) +
+ affine_conversion_helper<typename reduce_unit<Unit1>::type, typename reduce_unit<Unit2>::type>::value());
+ }
+ };
+};
+
+template<>
+struct affine_conversion_impl<false, true>
+{
+ template<class Unit1, class Unit2, class T0, class T1>
+ struct apply
+ {
+ static T1 value(const T0& t0)
+ {
+ return(
+ (t0 - affine_conversion_helper<typename reduce_unit<Unit2>::type, typename reduce_unit<Unit1>::type>::value()) *
+ conversion_factor(Unit1(), Unit2()));
+ }
+ };
+};
+
+} // namespace detail
+
+/// INTERNAL ONLY
+template<class Unit1, class T1, class Unit2, class T2>
+struct conversion_helper<quantity<absolute<Unit1>, T1>, quantity<absolute<Unit2>, T2> >
+{
+ typedef quantity<absolute<Unit1>, T1> from_quantity_type;
+ typedef quantity<absolute<Unit2>, T2> to_quantity_type;
+ static to_quantity_type convert(const from_quantity_type& source)
+ {
+ return(
+ to_quantity_type::from_value(
+ detail::affine_conversion_impl<
+ !boost::is_base_and_derived<
+ detail::undefined_affine_conversion_base,
+ affine_conversion_helper<typename reduce_unit<Unit1>::type, typename reduce_unit<Unit2>::type>
+ >::value,
+ !boost::is_base_and_derived<
+ detail::undefined_affine_conversion_base,
+ affine_conversion_helper<typename reduce_unit<Unit2>::type, typename reduce_unit<Unit1>::type>
+ >::value
+ >::template apply<Unit1, Unit2, T1, T2>::value(source.value())
+ )
+ );
+ }
+};
+
+} // namespace units
+
+} // namespace boost
+
+#endif // BOOST_UNITS_ABSOLUTE_IMPL_HPP
Added: sandbox/units/boost/units/detail/conversion_impl.hpp
==============================================================================
--- (empty file)
+++ sandbox/units/boost/units/detail/conversion_impl.hpp 2007-10-18 20:23:24 EDT (Thu, 18 Oct 2007)
@@ -0,0 +1,548 @@
+// 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_CONVERSION_IMPL_HPP
+#define BOOST_UNITS_CONVERSION_IMPL_HPP
+
+#include <boost/mpl/bool.hpp>
+#include <boost/mpl/size.hpp>
+#include <boost/mpl/begin.hpp>
+#include <boost/mpl/next.hpp>
+#include <boost/mpl/deref.hpp>
+#include <boost/mpl/divides.hpp>
+#include <boost/preprocessor/seq/enum.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/is_base_and_derived.hpp>
+
+#include <boost/units/dimension_list.hpp>
+#include <boost/units/heterogeneous_system.hpp>
+#include <boost/units/homogeneous_system.hpp>
+#include <boost/units/scaled_base_unit.hpp>
+#include <boost/units/static_rational.hpp>
+#include <boost/units/units_fwd.hpp>
+#include <boost/units/detail/heterogeneous_conversion.hpp>
+#include <boost/units/detail/one.hpp>
+#include <boost/units/detail/static_rational_power.hpp>
+
+#include <boost/units/units_fwd.hpp>
+
+namespace boost {
+
+namespace units {
+
+namespace detail {
+
+template<class Source, class Dest>
+struct conversion_factor_helper;
+
+template<class Source, class Dest>
+struct call_base_unit_converter;
+
+}
+
+/// INTERNAL ONLY
+struct undefined_base_unit_converter_base { };
+
+/// INTERNAL ONLY
+struct no_default_conversion { };
+
+/// INTERNAL ONLY
+template<class BaseUnit>
+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>
+struct select_base_unit_converter
+{
+ typedef Source source_type;
+ typedef Destination destination_type;
+};
+
+/// INTERNAL ONLY
+template<class Source, class Dest>
+struct base_unit_converter_base : undefined_base_unit_converter_base { };
+
+/// INTERNAL ONLY
+template<class Source>
+struct base_unit_converter_base<Source, BOOST_UNITS_MAKE_HETEROGENEOUS_UNIT(Source, typename Source::dimension_type)>
+{
+ typedef one type;
+ static type value() {
+ return(one());
+ }
+};
+
+/// INTERNAL ONLY
+template<class Source, class Dest>
+struct base_unit_converter : base_unit_converter_base<Source, Dest> { };
+
+namespace detail {
+
+template<bool is_defined>
+struct do_call_base_unit_converter_impl;
+
+template<>
+struct do_call_base_unit_converter_impl<true>
+{
+ template<class Source, class Dest>
+ struct apply : base_unit_converter<Source, Dest> { };
+};
+
+template<>
+struct do_call_base_unit_converter_impl<false>
+{
+ template<class Source, class Dest>
+ struct apply {
+ typedef select_base_unit_converter<typename unscale<Source>::type, typename unscale<Dest>::type> selector;
+ typedef typename selector::source_type source_type;
+ typedef typename selector::destination_type destination_type;
+ typedef base_unit_converter<source_type, destination_type> converter;
+ typedef typename mpl::divides<typename get_scale_list<Source>::type, typename get_scale_list<source_type>::type>::type source_factor;
+ typedef typename mpl::divides<typename get_scale_list<Dest>::type, typename get_scale_list<destination_type>::type>::type destination_factor;
+ typedef typename mpl::divides<source_factor, destination_factor>::type factor;
+ typedef eval_scale_list<factor> eval_factor;
+ typedef typename multiply_typeof_helper<typename converter::type, typename eval_factor::type>::type type;
+ static type value()
+ {
+ return(converter::value() * eval_factor::value());
+ }
+ };
+};
+
+template<class Source, class Dest>
+struct do_call_base_unit_converter :
+ do_call_base_unit_converter_impl<
+ !boost::is_base_and_derived<
+ undefined_base_unit_converter_base,
+ base_unit_converter<Source, Dest>
+ >::value
+ >::template apply<Source, Dest> {};
+
+template<bool forward_is_defined, bool reverse_is_defined>
+struct call_base_unit_converter_base_unit_impl;
+
+template<>
+struct call_base_unit_converter_base_unit_impl<true, true>
+{
+ template<class Source, class Dest>
+ struct apply : do_call_base_unit_converter<Source, typename Dest::unit_type>
+ {
+ };
+};
+
+template<>
+struct call_base_unit_converter_base_unit_impl<true, false>
+{
+ template<class Source, class Dest>
+ struct apply : do_call_base_unit_converter<Source, typename Dest::unit_type>
+ {
+ };
+};
+
+template<>
+struct call_base_unit_converter_base_unit_impl<false, true>
+{
+ template<class Source, class Dest>
+ struct apply
+ {
+ typedef do_call_base_unit_converter<Dest, typename Source::unit_type> converter;
+ typedef typename divide_typeof_helper<one, typename converter::type>::type type;
+ static type value() {
+ return(one() / converter::value());
+ }
+ };
+};
+
+template<>
+struct call_base_unit_converter_base_unit_impl<false, false>
+{
+ template<class Source, class Dest>
+ struct apply
+ {
+ typedef typename get_default_conversion<Source>::type new_source;
+ typedef typename get_default_conversion<Dest>::type new_dest;
+ typedef call_base_unit_converter<Source, new_source> start;
+ typedef detail::conversion_factor_helper<
+ new_source,
+ new_dest
+ > conversion;
+ typedef call_base_unit_converter<Dest, new_dest> end;
+ typedef typename divide_typeof_helper<
+ typename multiply_typeof_helper<
+ typename start::type,
+ typename conversion::type
+ >::type,
+ typename end::type
+ >::type type;
+ static type value() {
+ return(start::value() * conversion::value() / end::value());
+ }
+ };
+};
+
+template<int N>
+struct get_default_conversion_impl
+{
+ template<class Begin>
+ struct apply
+ {
+ typedef typename mpl::deref<Begin>::type source_pair;
+ typedef typename source_pair::value_type exponent;
+ typedef typename source_pair::tag_type source;
+ typedef typename get_default_conversion<source>::type new_source;
+ typedef typename get_default_conversion_impl<N-1>::template apply<typename mpl::next<Begin>::type> next_iteration;
+ typedef typename multiply_typeof_helper<typename power_dimof_helper<new_source, exponent>::type, typename next_iteration::unit_type>::type unit_type;
+ typedef call_base_unit_converter<source, new_source> conversion;
+ typedef typename multiply_typeof_helper<typename conversion::type, typename next_iteration::type>::type type;
+ static type value() {
+ return(static_rational_power<exponent>(conversion::value()) * next_iteration::value());
+ }
+ };
+};
+
+template<>
+struct get_default_conversion_impl<0>
+{
+ template<class Begin>
+ struct apply
+ {
+ typedef unit<dimensionless_type, heterogeneous_system<heterogeneous_system_pair<dimensionless_type, dimensionless_type> > > unit_type;
+ typedef one type;
+ static type value() {
+ return(type());
+ }
+ };
+};
+
+template<bool is_defined>
+struct call_base_unit_converter_impl;
+
+template<>
+struct call_base_unit_converter_impl<true>
+{
+ template<class Source, class Dest>
+ struct apply : do_call_base_unit_converter<Source, Dest>
+ {
+ };
+};
+
+template<>
+struct call_base_unit_converter_impl<false>
+{
+ template<class Source, class Dest>
+ struct apply {
+ typedef typename get_default_conversion<Source>::type new_source;
+ typedef typename Dest::system_type::type system_list;
+ typedef typename get_default_conversion_impl<mpl::size<system_list>::value>::template apply<typename mpl::begin<system_list>::type> impl;
+ typedef typename impl::unit_type new_dest;
+ typedef call_base_unit_converter<Source, new_source> start;
+ typedef conversion_factor_helper<new_source, new_dest> conversion;
+ typedef typename divide_typeof_helper<
+ typename multiply_typeof_helper<
+ typename start::type,
+ typename conversion::type
+ >::type,
+ typename impl::type
+ >::type type;
+ static type value() {
+ return(start::value() * conversion::value() / impl::value());
+ }
+ };
+};
+
+template<class Source, class Dest>
+struct base_unit_converter_scaled_is_undefined :
+ boost::is_base_and_derived<
+ undefined_base_unit_converter_base,
+ base_unit_converter<typename unscale<Source>::type, typename unscale<Dest>::type>
+ > {};
+
+template<class Source, class Dest>
+struct base_unit_converter_is_undefined :
+ mpl::and_<
+ boost::is_base_and_derived<
+ undefined_base_unit_converter_base,
+ base_unit_converter<Source, Dest>
+ >,
+ base_unit_converter_scaled_is_undefined<Source, Dest>
+ > {};
+
+template<class Source, class Dest>
+struct call_base_unit_converter : call_base_unit_converter_impl<!base_unit_converter_is_undefined<Source, Dest>::value>::template apply<Source, Dest>
+{
+};
+
+template<class Source, class Dest>
+struct call_base_unit_converter<Source, BOOST_UNITS_MAKE_HETEROGENEOUS_UNIT(Dest, typename Source::dimension_type)> :
+ call_base_unit_converter_base_unit_impl<
+ !base_unit_converter_is_undefined<Source, typename Dest::unit_type>::value,
+ !base_unit_converter_is_undefined<Dest, typename Source::unit_type>::value
+ >::template apply<Source, Dest>
+{
+};
+
+template<int N>
+struct conversion_impl
+{
+ template<class Begin, class DestinationSystem>
+ struct apply
+ {
+ typedef typename conversion_impl<N-1>::template apply<
+ typename mpl::next<Begin>::type,
+ DestinationSystem
+ > next_iteration;
+ typedef typename mpl::deref<Begin>::type unit_pair;
+ typedef typename unit_pair::tag_type unit;
+ typedef typename unit::dimension_type dimensions;
+ typedef typename reduce_unit<units::unit<dimensions, DestinationSystem> >::type reduced_unit;
+ typedef detail::call_base_unit_converter<unit, reduced_unit> converter;
+ typedef typename multiply_typeof_helper<typename converter::type, typename next_iteration::type>::type type;
+ static type value() { return(static_rational_power<typename unit_pair::value_type>(converter::value()) * next_iteration::value()); }
+ };
+};
+
+template<>
+struct conversion_impl<0>
+{
+ template<class Begin, class DestinationSystem>
+ struct apply
+ {
+ typedef one type;
+ static type value() { return(one()); }
+ };
+};
+
+} // namespace detail
+
+/// conversions between homogeneous systems are defined
+/// INTERNAL ONLY
+template<class D, class L1, class T1, class L2, class T2>
+struct conversion_helper<quantity<unit<D, homogeneous_system<L1> >, T1>, quantity<unit<D, homogeneous_system<L2> >, T2> >
+{
+ /// INTERNAL ONLY
+ typedef quantity<unit<D, homogeneous_system<L2> >, T2> destination_type;
+ /// INTERNAL ONLY
+ typedef typename reduce_unit<unit<D, homogeneous_system<L1> > >::type source_unit;
+ /// INTERNAL ONLY
+ typedef typename source_unit::system_type::type unit_list;
+ static destination_type convert(const quantity<unit<D, homogeneous_system<L1> >, T1>& source)
+ {
+ return(destination_type::from_value(source.value() *
+ detail::conversion_impl<mpl::size<unit_list>::value>::template apply<
+ typename mpl::begin<unit_list>::type,
+ homogeneous_system<L2>
+ >::value()
+ ));
+ }
+};
+
+/// conversions between heterogeneous systems and homogeneous systems are defined
+/// INTERNAL ONLY
+template<class D, class L1, class T1, class L2, class T2>
+struct conversion_helper<quantity<unit<D, heterogeneous_system<L1> >, T1>, quantity<unit<D, homogeneous_system<L2> >, T2> >
+{
+ /// INTERNAL ONLY
+ typedef quantity<unit<D, homogeneous_system<L2> >, T2> destination_type;
+ static destination_type convert(const quantity<unit<D, heterogeneous_system<L1> >, T1>& source)
+ {
+ return(destination_type::from_value(source.value() *
+ detail::conversion_impl<mpl::size<typename L1::type>::value>::template apply<
+ typename mpl::begin<typename L1::type>::type,
+ homogeneous_system<L2>
+ >::value()
+ ));
+ }
+};
+
+// There is no simple algorithm for doing this conversion
+// other than just defining it as the reverse of the
+// heterogeneous->homogeneous case
+/// conversions between heterogeneous systems and homogeneous systems are defined
+/// INTERNAL ONLY
+template<class D, class L1, class T1, class L2, class T2>
+struct conversion_helper<quantity<unit<D, homogeneous_system<L1> >, T1>, quantity<unit<D, heterogeneous_system<L2> >, T2> >
+{
+ /// INTERNAL ONLY
+ typedef quantity<unit<D, heterogeneous_system<L2> >, T2> destination_type;
+ static destination_type convert(const quantity<unit<D, homogeneous_system<L1> >, T1>& source)
+ {
+ return(destination_type::from_value(source.value() /
+ detail::conversion_impl<mpl::size<typename L2::type>::value>::template apply<
+ typename mpl::begin<typename L2::type>::type,
+ homogeneous_system<L1>
+ >::value()
+ ));
+ }
+};
+
+/// Requires that all possible conversions
+/// between base units are defined.
+/// INTERNAL ONLY
+template<class D, class S1, class T1, class S2, class T2>
+struct conversion_helper<quantity<unit<D, heterogeneous_system<S1> >, T1>, quantity<unit<D, heterogeneous_system<S2> >, T2> >
+{
+ /// INTERNAL ONLY
+ typedef quantity<unit<D, heterogeneous_system<S1> >, T1> source_type;
+ /// INTERNAL ONLY
+ typedef quantity<unit<D, heterogeneous_system<S2> >, T2> destination_type;
+ /// INTERNAL ONLY
+ typedef typename detail::extract_base_units<mpl::size<typename S1::type>::value>::template apply<
+ typename mpl::begin<typename S1::type>::type,
+ mpl::list0<>
+ >::type from_base_units;
+ /// INTERNAL ONLY
+ typedef typename detail::extract_base_units<mpl::size<typename S2::type>::value>::template apply<
+ typename mpl::begin<typename S2::type>::type,
+ from_base_units
+ >::type all_base_units;
+ /// INTERNAL ONLY
+ typedef typename detail::make_homogeneous_system<all_base_units>::type system;
+ static destination_type convert(const source_type& source)
+ {
+ return(destination_type::from_value(source.value() *
+ (detail::conversion_impl<mpl::size<typename S1::type>::value>::template apply<
+ typename mpl::begin<typename S1::type>::type,
+ system
+ >::value() /
+ detail::conversion_impl<mpl::size<typename S2::type>::value>::template apply<
+ typename mpl::begin<typename S2::type>::type,
+ system
+ >::value()
+ )
+ ));
+ }
+};
+
+namespace detail {
+
+template<class Source, class Dest>
+struct conversion_factor_helper;
+
+template<class D, class L1, class L2>
+struct conversion_factor_helper<unit<D, homogeneous_system<L1> >, unit<D, homogeneous_system<L2> > >
+{
+ typedef typename reduce_unit<unit<D, homogeneous_system<L1> > >::type source_unit;
+ typedef typename source_unit::system_type::type unit_list;
+ typedef typename detail::conversion_impl<mpl::size<unit_list>::value>::template apply<
+ typename mpl::begin<unit_list>::type,
+ homogeneous_system<L2>
+ > impl;
+ typedef typename impl::type type;
+ static type value()
+ {
+ return(impl::value());
+ }
+};
+
+template<class D, class L1, class L2>
+struct conversion_factor_helper<unit<D, heterogeneous_system<L1> >, unit<D, homogeneous_system<L2> > >
+{
+ typedef typename detail::conversion_impl<mpl::size<typename L1::type>::value>::template apply<
+ typename mpl::begin<typename L1::type>::type,
+ homogeneous_system<L2>
+ > impl;
+ typedef typename impl::type type;
+ static type value()
+ {
+ return(impl::value());
+ }
+};
+
+// There is no simple algorithm for doing this conversion
+// other than just defining it as the reverse of the
+// heterogeneous->homogeneous case
+template<class D, class L1, class L2>
+struct conversion_factor_helper<unit<D, homogeneous_system<L1> >, unit<D, heterogeneous_system<L2> > >
+{
+ typedef typename detail::conversion_impl<mpl::size<typename L2::type>::value>::template apply<
+ typename mpl::begin<typename L2::type>::type,
+ homogeneous_system<L1>
+ > impl;
+ typedef typename impl::type type;
+ static type value()
+ {
+ return(one() / impl::value());
+ }
+};
+
+/// Requires that all possible conversions
+/// between base units are defined.
+template<class D, class S1, class S2>
+struct conversion_factor_helper<unit<D, heterogeneous_system<S1> >, unit<D, heterogeneous_system<S2> > >
+{
+ /// INTERNAL ONLY
+ typedef typename detail::extract_base_units<mpl::size<typename S1::type>::value>::template apply<
+ typename mpl::begin<typename S1::type>::type,
+ mpl::list0<>
+ >::type from_base_units;
+ /// INTERNAL ONLY
+ typedef typename detail::extract_base_units<mpl::size<typename S2::type>::value>::template apply<
+ typename mpl::begin<typename S2::type>::type,
+ from_base_units
+ >::type all_base_units;
+ /// INTERNAL ONLY
+ typedef typename detail::make_homogeneous_system<all_base_units>::type system;
+ typedef typename detail::conversion_impl<mpl::size<typename S1::type>::value>::template apply<
+ typename mpl::begin<typename S1::type>::type,
+ system
+ > conversion1;
+ typedef typename detail::conversion_impl<mpl::size<typename S2::type>::value>::template apply<
+ typename mpl::begin<typename S2::type>::type,
+ system
+ > conversion2;
+ typedef typename divide_typeof_helper<typename conversion1::type, typename conversion2::type>::type type;
+ static type value()
+ {
+ return(conversion1::value() / conversion2::value());
+ }
+};
+
+} // namespace detail
+
+} // namespace units
+
+} // namespace boost
+
+#endif // BOOST_UNITS_CONVERSION_IMPL_HPP
Added: sandbox/units/boost/units/detail/implicit_conversion.hpp
==============================================================================
--- (empty file)
+++ sandbox/units/boost/units/detail/implicit_conversion.hpp 2007-10-18 20:23:24 EDT (Thu, 18 Oct 2007)
@@ -0,0 +1,119 @@
+/// 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_IMPLICIT_CONVERSION_HPP
+#define BOOST_UNITS_IMPLICIT_CONVERSION_HPP
+
+#include <boost/mpl/begin.hpp>
+#include <boost/mpl/size.hpp>
+#include <boost/mpl/next.hpp>
+#include <boost/mpl/deref.hpp>
+#include <boost/mpl/bool.hpp>
+
+#include <boost/units/operators.hpp>
+#include <boost/units/heterogeneous_system.hpp>
+#include <boost/units/units_fwd.hpp>
+
+namespace boost {
+
+namespace units {
+
+namespace detail {
+
+template<int N>
+struct implicit_conversion_impl;
+
+template<class From, class To>
+struct base_unit_is_implicitly_convertible : mpl::false_ {};
+
+template<class From>
+struct base_unit_is_implicitly_convertible<From, BOOST_UNITS_MAKE_HETEROGENEOUS_UNIT(From, typename From::dimension_type)> : mpl::true_ {};
+
+template<bool condition>
+struct implicit_conversion_func;
+
+template<>
+struct implicit_conversion_func<true>
+{
+ template<int N, class Begin, class System>
+ struct apply
+ {
+ enum { value = implicit_conversion_impl<N-1>::template apply<typename mpl::next<Begin>::type, System>::value};
+ };
+};
+
+template<>
+struct implicit_conversion_func<false>
+{
+ template<int N, class Begin, class System>
+ struct apply
+ {
+ enum { value = false };
+ };
+};
+
+template<int N>
+struct implicit_conversion_impl
+{
+ template<class Begin, class System>
+ struct apply
+ {
+ typedef typename mpl::deref<Begin>::type::tag_type current;
+ typedef typename reduce_unit<unit<typename current::dimension_type, System> >::type target_unit;
+ enum { value = (implicit_conversion_func<base_unit_is_implicitly_convertible<current, target_unit>::value>::template apply<N, Begin, System>::value) };
+ };
+};
+
+template<>
+struct implicit_conversion_impl<0>
+{
+ template<class Begin, class System>
+ struct apply
+ {
+ enum { value = true };
+ };
+};
+
+template<class From, class To>
+struct unit_is_implicitly_convertible {
+ typedef typename reduce_unit<From>::type::system_type::type list;
+ typedef mpl::bool_<(implicit_conversion_impl<mpl::size<list>::value>::template apply<typename mpl::begin<list>::type, typename To::system_type>::value)> type;
+};
+
+} // namespace detail
+
+#define BOOST_UNITS_IMPLICIT_CONVERSION(From, To) \
+ namespace boost { \
+ namespace units { \
+ namespace detail { \
+ template<> \
+ struct base_unit_is_implicitly_convertible<From, To> : mpl::true_ {}; \
+ } \
+ } \
+ }
+
+#define BOOST_UNITS_BASE_IMPLICIT_CONVERSION(From, To) \
+ namespace boost { \
+ namespace units { \
+ namespace detail { \
+ template<> \
+ struct base_unit_is_implicitly_convertible< \
+ From, \
+ BOOST_UNITS_MAKE_HETEROGENEOUS_UNIT(To, From::dimension_type) \
+ > : mpl::true_ {}; \
+ } \
+ } \
+ }
+
+} // namespace units
+
+} // namespace boost
+
+#endif // BOOST_UNITS_IMPLICIT_CONVERSION_HPP
Deleted: sandbox/units/boost/units/implicit_conversion.hpp
==============================================================================
--- sandbox/units/boost/units/implicit_conversion.hpp 2007-10-18 20:23:24 EDT (Thu, 18 Oct 2007)
+++ (empty file)
@@ -1,119 +0,0 @@
-/// 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_UNIT_IMPL_HPP
-#define BOOST_UNITS_UNIT_IMPL_HPP
-
-#include <boost/mpl/begin.hpp>
-#include <boost/mpl/size.hpp>
-#include <boost/mpl/next.hpp>
-#include <boost/mpl/deref.hpp>
-#include <boost/mpl/bool.hpp>
-
-#include <boost/units/operators.hpp>
-#include <boost/units/heterogeneous_system.hpp>
-#include <boost/units/units_fwd.hpp>
-
-namespace boost {
-
-namespace units {
-
-namespace detail {
-
-template<int N>
-struct implicit_conversion_impl;
-
-template<class From, class To>
-struct base_unit_is_implicitly_convertible : mpl::false_ {};
-
-template<class From>
-struct base_unit_is_implicitly_convertible<From, BOOST_UNITS_MAKE_HETEROGENEOUS_UNIT(From, typename From::dimension_type)> : mpl::true_ {};
-
-template<bool condition>
-struct implicit_conversion_func;
-
-template<>
-struct implicit_conversion_func<true>
-{
- template<int N, class Begin, class System>
- struct apply
- {
- enum { value = implicit_conversion_impl<N-1>::template apply<typename mpl::next<Begin>::type, System>::value};
- };
-};
-
-template<>
-struct implicit_conversion_func<false>
-{
- template<int N, class Begin, class System>
- struct apply
- {
- enum { value = false };
- };
-};
-
-template<int N>
-struct implicit_conversion_impl
-{
- template<class Begin, class System>
- struct apply
- {
- typedef typename mpl::deref<Begin>::type::tag_type current;
- typedef typename reduce_unit<unit<typename current::dimension_type, System> >::type target_unit;
- enum { value = (implicit_conversion_func<base_unit_is_implicitly_convertible<current, target_unit>::value>::template apply<N, Begin, System>::value) };
- };
-};
-
-template<>
-struct implicit_conversion_impl<0>
-{
- template<class Begin, class System>
- struct apply
- {
- enum { value = true };
- };
-};
-
-template<class From, class To>
-struct unit_is_implicitly_convertible {
- typedef typename reduce_unit<From>::type::system_type::type list;
- typedef mpl::bool_<(implicit_conversion_impl<mpl::size<list>::value>::template apply<typename mpl::begin<list>::type, typename To::system_type>::value)> type;
-};
-
-} // namespace detail
-
-#define BOOST_UNITS_IMPLICIT_CONVERSION(From, To) \
- namespace boost { \
- namespace units { \
- namespace detail { \
- template<> \
- struct base_unit_is_implicitly_convertible<From, To> : mpl::true_ {}; \
- } \
- } \
- }
-
-#define BOOST_UNITS_BASE_IMPLICIT_CONVERSION(From, To) \
- namespace boost { \
- namespace units { \
- namespace detail { \
- template<> \
- struct base_unit_is_implicitly_convertible< \
- From, \
- BOOST_UNITS_MAKE_HETEROGENEOUS_UNIT(To, From::dimension_type) \
- > : mpl::true_ {}; \
- } \
- } \
- }
-
-} // namespace units
-
-} // namespace boost
-
-#endif // BOOST_UNITS_UNIT_IMPL_HPP