// Boost.Units - A C++ library for zero-overhead dimensional analysis and | |
// unit/quantity manipulation and conversion | |
// | |
// Copyright (C) 2003-2008 Matthias Christian Schabel | |
// Copyright (C) 2007-2008 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_CONVERSION_IMPL_HPP | |
#define BOOST_UNITS_DETAIL_CONVERSION_IMPL_HPP | |
#include <boost/mpl/bool.hpp> | |
#include <boost/mpl/and.hpp> | |
#include <boost/mpl/divides.hpp> | |
#include <boost/preprocessor/seq/enum.hpp> | |
#include <boost/type_traits/is_same.hpp> | |
#include <boost/units/heterogeneous_system.hpp> | |
#include <boost/units/homogeneous_system.hpp> | |
#include <boost/units/reduce_unit.hpp> | |
#include <boost/units/static_rational.hpp> | |
#include <boost/units/units_fwd.hpp> | |
#include <boost/units/detail/dimension_list.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/detail/unscale.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 { | |
static const bool is_defined = false; | |
}; | |
/// INTERNAL ONLY | |
struct no_default_conversion { | |
static const bool is_defined = false; | |
}; | |
/// 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< | |
unscaled_get_default_conversion<typename unscale<BaseUnit>::type>::is_defined | |
>::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)> | |
{ | |
static const bool is_defined = true; | |
typedef one type; | |
static type value() { | |
one result; | |
return(result); | |
} | |
}; | |
/// INTERNAL ONLY | |
template<class Source, class Dest> | |
struct base_unit_converter : base_unit_converter_base<Source, Dest> { }; | |
namespace detail { | |
template<class Source, class Dest> | |
struct do_call_base_unit_converter { | |
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<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() { | |
one numerator; | |
return(numerator / converter::value()); | |
} | |
}; | |
}; | |
template<> | |
struct call_base_unit_converter_base_unit_impl<false, false> | |
{ | |
template<class Source, class Dest> | |
struct apply | |
{ | |
typedef typename reduce_unit<typename get_default_conversion<Source>::type>::type new_source; | |
typedef typename reduce_unit<typename get_default_conversion<Dest>::type>::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 Begin::item source_pair; | |
typedef typename source_pair::value_type exponent; | |
typedef typename source_pair::tag_type source; | |
typedef typename reduce_unit<typename get_default_conversion<source>::type>::type new_source; | |
typedef typename get_default_conversion_impl<N-1>::template apply<typename Begin::next> next_iteration; | |
typedef typename multiply_typeof_helper<typename power_typeof_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_impl<dimensionless_type, dimensionless_type, no_scale> > > unit_type; | |
typedef one type; | |
static one value() { | |
one result; | |
return(result); | |
} | |
}; | |
}; | |
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 reduce_unit<typename get_default_conversion<Source>::type>::type new_source; | |
typedef typename Dest::system_type::type system_list; | |
typedef typename get_default_conversion_impl<system_list::size::value>::template apply<system_list> 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()); | |
} | |
}; | |
}; | |
#define BOOST_UNITS_DETAIL_BASE_UNIT_CONVERTER_IS_DEFINED(Source, Dest)\ | |
base_unit_converter<\ | |
typename select_base_unit_converter<typename unscale<Source>::type, typename unscale<Dest>::type>::source_type,\ | |
typename select_base_unit_converter<typename unscale<Source>::type, typename unscale<Dest>::type>::destination_type\ | |
>::is_defined | |
template<class Source, class Dest> | |
struct call_base_unit_converter : call_base_unit_converter_impl<BOOST_UNITS_DETAIL_BASE_UNIT_CONVERTER_IS_DEFINED(Source, Dest)>::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< | |
BOOST_UNITS_DETAIL_BASE_UNIT_CONVERTER_IS_DEFINED(Source, typename Dest::unit_type), | |
BOOST_UNITS_DETAIL_BASE_UNIT_CONVERTER_IS_DEFINED(Dest, typename Source::unit_type) | |
>::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 Begin::next, | |
DestinationSystem | |
> next_iteration; | |
typedef typename Begin::item 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() { one result; return(result); } | |
}; | |
}; | |
} // namespace detail | |
/// forward to conversion_factor (intentionally allowing ADL) | |
/// INTERNAL ONLY | |
template<class Unit1, class T1, class Unit2, class T2> | |
struct conversion_helper<quantity<Unit1, T1>, quantity<Unit2, T2> > | |
{ | |
/// INTERNAL ONLY | |
typedef quantity<Unit2, T2> destination_type; | |
static destination_type convert(const quantity<Unit1, T1>& source) | |
{ | |
Unit1 u1; | |
Unit2 u2; | |
return(destination_type::from_value(static_cast<T2>(source.value() * conversion_factor(u1, u2)))); | |
} | |
}; | |
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> > > | |
: conversion_factor_helper< | |
typename reduce_unit<unit<D, homogeneous_system<L1> > >::type, | |
typename reduce_unit<unit<D, homogeneous_system<L2> > >::type | |
> | |
{ | |
//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<unit_list::size::value>::template apply< | |
// unit_list, | |
// 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> > > | |
: conversion_factor_helper< | |
typename reduce_unit<unit<D, heterogeneous_system<L1> > >::type, | |
typename reduce_unit<unit<D, homogeneous_system<L2> > >::type | |
> | |
{ | |
//typedef typename detail::conversion_impl<L1::type::size::value>::template apply< | |
// typename L1::type, | |
// homogeneous_system<L2> | |
//> impl; | |
//typedef eval_scale_list<typename L1::scale> scale; | |
//typedef typename multiply_typeof_helper<typename impl::type, typename scale::type>::type type; | |
//static type value() | |
//{ | |
// return(impl::value() * scale::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> > > | |
: conversion_factor_helper< | |
typename reduce_unit<unit<D, homogeneous_system<L1> > >::type, | |
typename reduce_unit<unit<D, heterogeneous_system<L2> > >::type | |
> | |
{ | |
//typedef typename detail::conversion_impl<L2::type::size::value>::template apply< | |
// typename L2::type, | |
// homogeneous_system<L1> | |
//> impl; | |
//typedef eval_scale_list<typename L2::scale> scale; | |
//typedef typename multiply_typeof_helper<typename impl::type, typename scale::type>::type type; | |
//static type value() | |
//{ | |
// one numerator; | |
// return(numerator / (impl::value() * scale::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<S1::type::size::value>::template apply< | |
typename S1::type, | |
dimensionless_type | |
>::type from_base_units; | |
/// INTERNAL ONLY | |
typedef typename detail::extract_base_units<S2::type::size::value>::template apply< | |
typename S2::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<S1::type::size::value>::template apply< | |
typename S1::type, | |
system | |
> conversion1; | |
typedef typename detail::conversion_impl<S2::type::size::value>::template apply< | |
typename S2::type, | |
system | |
> conversion2; | |
typedef eval_scale_list<typename mpl::divides<typename S1::scale, typename S2::scale>::type> scale; | |
typedef typename multiply_typeof_helper< | |
typename conversion1::type, | |
typename divide_typeof_helper<typename scale::type, typename conversion2::type>::type | |
>::type type; | |
static type value() | |
{ | |
return(conversion1::value() * (scale::value() / conversion2::value())); | |
} | |
}; | |
} // namespace detail | |
} // namespace units | |
} // namespace boost | |
#endif // BOOST_UNITS_CONVERSION_IMPL_HPP |