From: steven_watanabe_at_[hidden]
Date: 2007-05-30 15:43:53
Author: steven_watanabe
Date: 2007-05-30 15:43:52 EDT (Wed, 30 May 2007)
New Revision: 4368
URL: http://svn.boost.org/trac/boost/changeset/4368
Log:
Fixed obscure heterogeneous_system bug
Text files modified:
sandbox/units/boost/units/conversion.hpp | 48 ++++++++++++++++++++++++++++
sandbox/units/boost/units/heterogeneous_system.hpp | 66 +++++++++++++++++++++++++++++++++++++++
sandbox/units/boost/units/io.hpp | 12 +++++-
3 files changed, 121 insertions(+), 5 deletions(-)
Modified: sandbox/units/boost/units/conversion.hpp
==============================================================================
--- sandbox/units/boost/units/conversion.hpp (original)
+++ sandbox/units/boost/units/conversion.hpp 2007-05-30 15:43:52 EDT (Wed, 30 May 2007)
@@ -37,12 +37,42 @@
template<class From, class To>
struct conversion_helper;
+#ifdef BOOST_UNITS_DOXYGEN
+
+/// Template for defining conversions between
+/// quanties. This template should be specialized
+/// for every quantity that allows conversions.
+/// For example, if you have a two units
+/// called pair and dozen you would write
+/// @code
+/// namespace boost {
+/// namespace units {
+/// template<class T0, class T1>
+/// struct conversion_helper<quantity<dozen, T0>, quantity<pair, T1> >
+/// {
+/// static quantity<pair, T1> convert(const quantity<dozen, T0>& source)
+/// {
+/// return(quantity<pair, T1>::from_value(6 * source.value()));
+/// }
+/// };
+/// }
+/// }
+/// @endcode
+template<class From, class To>
+struct conversion_helper {
+ static To convert(const From&);
+};
+
+#endif
+
+/// 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 Destination>
struct base_unit_converter {
typedef select_base_unit_converter<typename unscale<Source>::type, typename unscale<Destination>::type> selector;
@@ -59,6 +89,8 @@
}
};
+namespace detail {
+
template<bool try_inverse, bool trivial>
struct inverse_base_unit_converter_impl;
@@ -109,6 +141,9 @@
(boost::is_same<typename Dest::unit_type, typename selector::destination_type>::value) };
};
+}
+
+/// INTERNAL ONLY
template<class Source, class Dest>
struct base_unit_converter<
Source,
@@ -121,7 +156,7 @@
>
>
>
-> : inverse_base_unit_converter_impl<use_inverse_conversion<Source, Dest>::value, boost::is_same<Source, Dest>::value>::template apply<Source, Dest> {
+> : detail::inverse_base_unit_converter_impl<detail::use_inverse_conversion<Source, Dest>::value, boost::is_same<Source, Dest>::value>::template apply<Source, Dest> {
};
#define BOOST_UNITS_DEFINE_CONVERSION(Source, Destination, type_, value_)\
@@ -172,10 +207,14 @@
} // namespace detail
+/// conversions between homogeneous systems are defined
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() *
@@ -187,8 +226,10 @@
}
};
+/// conversions between heterogeneous systems and homogeneous systems are defined
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() *
@@ -203,8 +244,10 @@
// 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
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() /
@@ -264,6 +307,7 @@
}
+/// Find the conversion factor between two units.
template<class FromUnit,class ToUnit>
inline
typename detail::conversion_factor_helper<FromUnit, ToUnit>::type
@@ -272,6 +316,8 @@
return(detail::conversion_factor_helper<FromUnit, ToUnit>::value());
}
+/// Find the conversion factor between two units with an explicit return type.
+/// e.g. conversion_factor<int>(newton, dyne) returns 100000
template<class Y, class FromUnit,class ToUnit>
inline
Y
Modified: sandbox/units/boost/units/heterogeneous_system.hpp
==============================================================================
--- sandbox/units/boost/units/heterogeneous_system.hpp (original)
+++ sandbox/units/boost/units/heterogeneous_system.hpp 2007-05-30 15:43:52 EDT (Wed, 30 May 2007)
@@ -45,18 +45,26 @@
}
+/// INTERNAL ONLY
template<class L, class Dimensions>
struct heterogeneous_system_pair {
typedef L type;
typedef Dimensions dimensions;
};
+/// A system that can represent any possible combination
+/// of units at the expense of not preserving information
+/// about how it was created. Do not create specializations
+/// of this template directly. Instead use reduce_unit and
+/// base_unit<...>::unit_type.
template<class T>
struct heterogeneous_system : T {
};
+/// INTERNAL ONLY
struct heterogeneous_system_dim_tag {};
+/// INTERNAL ONLY
template<class Unit, class Exponent>
struct heterogeneous_system_dim {
typedef heterogeneous_system_dim_tag tag;
@@ -81,6 +89,7 @@
namespace mpl {
+/// INTERNAL ONLY
template<>
struct plus_impl<boost::units::heterogeneous_system_dim_tag, boost::units::heterogeneous_system_dim_tag> {
template<class T0, class T1>
@@ -92,6 +101,7 @@
};
};
+/// INTERNAL ONLY
template<>
struct times_impl<boost::units::heterogeneous_system_dim_tag, boost::units::detail::static_rational_tag> {
template<class T0, class T1>
@@ -103,6 +113,7 @@
};
};
+/// INTERNAL ONLY
template<>
struct negate_impl<boost::units::heterogeneous_system_dim_tag> {
template<class T>
@@ -176,6 +187,7 @@
} // namespace detail
+/// INTERNAL ONLY
template<class S, long N, long D>
struct static_power<heterogeneous_system<S>, static_rational<N,D> > {
typedef heterogeneous_system<
@@ -186,6 +198,7 @@
> type;
};
+/// INTERNAL ONLY
template<class S, long N, long D>
struct static_root<heterogeneous_system<S>, static_rational<N,D> > {
typedef heterogeneous_system<
@@ -196,6 +209,7 @@
> type;
};
+/// Returns a unique type for every unit.
template<class Unit>
struct reduce_unit {
typedef unit<
@@ -209,11 +223,54 @@
namespace detail {
+/// add an instantiation of dim to Sequence.
+template<bool>
+struct push_front_or_add_impl;
+
+template<>
+struct push_front_or_add_impl<true>
+{
+ template<typename Sequence, typename T>
+ struct apply
+ {
+ typedef typename mpl::plus<T, typename mpl::front<Sequence>::type>::type item;
+ typedef typename push_front_if<!is_empty_dim<item>::value>::template apply<
+ typename mpl::pop_front<Sequence>::type,
+ item
+ > type;
+ };
+};
+
+template<>
+struct push_front_or_add_impl<false>
+{
+ template<typename Sequence, typename T>
+ struct apply
+ {
+ typedef typename mpl::push_front<Sequence, T>::type type;
+ };
+};
+
+template<typename Sequence, typename T>
+struct push_front_or_add
+{
+ typedef typename push_front_or_add_impl<boost::is_same<typename T::tag_type, typename mpl::front<Sequence>::type::tag_type>::value>::template apply<
+ Sequence,
+ T
+ >::type type;
+};
+
+template<typename T>
+struct push_front_or_add<dimensionless_type, T>
+{
+ typedef typename mpl::push_front<dimensionless_type, T>::type type;
+};
+
template<int N>
struct unscale_heterogeneous_system_impl {
template<class Begin>
struct apply {
- typedef typename mpl::push_front<
+ typedef typename push_front_or_add<
typename unscale_heterogeneous_system_impl<N-1>::template apply<
typename mpl::next<Begin>::type
>::type,
@@ -232,6 +289,10 @@
}
+/// Unscale all the base units. e.g
+/// km s -> m s
+/// cm km -> m^2
+/// INTERNAL ONLY
template<class T>
struct unscale<heterogeneous_system<T> > {
typedef heterogeneous_system<
@@ -246,6 +307,7 @@
> type;
};
+/// INTERNAL ONLY
template<class Unit, class Exponent>
struct unscale<heterogeneous_system_dim<Unit, Exponent> > {
typedef heterogeneous_system_dim<typename unscale<Unit>::type, Exponent> type;
@@ -276,6 +338,7 @@
} // namespace detail
+/// INTERNAL ONLY
template<class T>
struct get_scale_list<heterogeneous_system<T> > {
typedef typename detail::get_scale_list_of_heterogeneous_system_impl<
@@ -283,6 +346,7 @@
>::template apply<typename T::type>::type type;
};
+/// INTERNAL ONLY
template<class Unit, class Exponent>
struct get_scale_list<heterogeneous_system_dim<Unit, Exponent> > {
typedef typename static_power<typename get_scale_list<Unit>::type, Exponent>::type type;
Modified: sandbox/units/boost/units/io.hpp
==============================================================================
--- sandbox/units/boost/units/io.hpp (original)
+++ sandbox/units/boost/units/io.hpp 2007-05-30 15:43:52 EDT (Wed, 30 May 2007)
@@ -63,13 +63,16 @@
template<class T>
struct heterogeneous_system;
-template<class T>
+/// traits template for unit names
+template<class BaseUnit>
struct base_unit_info {
+ /// The full name of the unit (returns BaseUnit::name() by default)
static std::string name() {
- return(T::name());
+ return(BaseUnit::name());
}
+ /// The symbol for the base unit (Returns BaseUnit::symbol() by default)
static std::string symbol() {
- return(T::symbol());
+ return(BaseUnit::symbol());
}
};
@@ -130,12 +133,14 @@
} // namespace detail
+/// Print an @c unit as a list of base units and exponents e.g "m s^-1"
template<class Char, class Traits, class Dimension, class System>
std::basic_ostream<Char, Traits>& operator<<(std::basic_ostream<Char, Traits>& os, const unit<Dimension, System>&) {
os << typename reduce_unit<unit<Dimension, System> >::type();
return(os);
}
+/// INTERNAL ONLY
template<class Char, class Traits, class Dimension, class System>
std::basic_ostream<Char, Traits>& operator<<(std::basic_ostream<Char, Traits>& os, const unit<Dimension, heterogeneous_system<System> >&) {
detail::print_impl<mpl::size<typename System::type>::value>::template apply<
@@ -144,6 +149,7 @@
return(os);
}
+/// Print a @c quantity. Prints the value followed by the unit
template<class Char, class Traits, class Unit, class T>
std::basic_ostream<Char, Traits>& operator<<(std::basic_ostream<Char, Traits>& os, const quantity<Unit, T>& q) {
os << q.value() << ' ' << Unit();