// (c) Copyright Fernando Luis Cacciola Carballal 2000-2004 | |
// Use, modification, and distribution is subject to 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) | |
// See library home page at http://www.boost.org/libs/numeric/conversion | |
// | |
// Contact the author at: fernando_cacciola@hotmail.com | |
// | |
#ifndef BOOST_NUMERIC_CONVERSION_DETAIL_CONVERTER_FLC_12NOV2002_HPP | |
#define BOOST_NUMERIC_CONVERSION_DETAIL_CONVERTER_FLC_12NOV2002_HPP | |
#include <functional> | |
#include "boost/numeric/conversion/detail/meta.hpp" | |
#include "boost/numeric/conversion/detail/conversion_traits.hpp" | |
#include "boost/numeric/conversion/bounds.hpp" | |
#include "boost/type_traits/is_same.hpp" | |
#include "boost/mpl/integral_c.hpp" | |
namespace boost { namespace numeric { namespace convdetail | |
{ | |
// Integral Constants representing rounding modes | |
typedef mpl::integral_c<std::float_round_style, std::round_toward_zero> round2zero_c ; | |
typedef mpl::integral_c<std::float_round_style, std::round_to_nearest> round2nearest_c ; | |
typedef mpl::integral_c<std::float_round_style, std::round_toward_infinity> round2inf_c ; | |
typedef mpl::integral_c<std::float_round_style, std::round_toward_neg_infinity> round2neg_inf_c ; | |
// Metafunction: | |
// | |
// for_round_style<RoundStyle,RoundToZero,RoundToNearest,RoundToInf,RoundToNegInf>::type | |
// | |
// {RoundStyle} Integral Constant specifying a round style as declared above. | |
// {RoundToZero,RoundToNearest,RoundToInf,RoundToNegInf} arbitrary types. | |
// | |
// Selects one of the 4 types according to the value of RoundStyle. | |
// | |
template<class RoundStyle,class RoundToZero,class RoundToNearest,class RoundToInf,class RoundToNegInf> | |
struct for_round_style | |
{ | |
typedef ct_switch4<RoundStyle | |
, round2zero_c, round2nearest_c, round2inf_c // round2neg_inf_c | |
, RoundToZero , RoundToNearest , RoundToInf , RoundToNegInf | |
> selector ; | |
typedef typename selector::type type ; | |
} ; | |
//-------------------------------------------------------------------------- | |
// Range Checking Logic. | |
// | |
// The range checking logic is built up by combining 1 or 2 predicates. | |
// Each predicate is encapsulated in a template class and exposes | |
// the static member function 'apply'. | |
// | |
//-------------------------------------------------------------------------- | |
// Because a particular logic can combine either 1 or two predicates, the following | |
// tags are used to allow the predicate applier to receive 2 preds, but optimize away | |
// one of them if it is 'non-applicable' | |
struct non_applicable { typedef mpl::false_ do_apply ; } ; | |
struct applicable { typedef mpl::true_ do_apply ; } ; | |
//-------------------------------------------------------------------------- | |
// | |
// Range Checking Logic implementations. | |
// | |
// The following classes, collectivelly named 'Predicates', are instantiated within | |
// the corresponding range checkers. | |
// Their static member function 'apply' is called to perform the actual range checking logic. | |
//-------------------------------------------------------------------------- | |
// s < Lowest(T) ? cNegOverflow : cInRange | |
// | |
template<class Traits> | |
struct LT_LoT : applicable | |
{ | |
typedef typename Traits::target_type T ; | |
typedef typename Traits::source_type S ; | |
typedef typename Traits::argument_type argument_type ; | |
static range_check_result apply ( argument_type s ) | |
{ | |
return s < static_cast<S>(bounds<T>::lowest()) ? cNegOverflow : cInRange ; | |
} | |
} ; | |
// s < 0 ? cNegOverflow : cInRange | |
// | |
template<class Traits> | |
struct LT_Zero : applicable | |
{ | |
typedef typename Traits::source_type S ; | |
typedef typename Traits::argument_type argument_type ; | |
static range_check_result apply ( argument_type s ) | |
{ | |
return s < static_cast<S>(0) ? cNegOverflow : cInRange ; | |
} | |
} ; | |
// s <= Lowest(T)-1 ? cNegOverflow : cInRange | |
// | |
template<class Traits> | |
struct LE_PrevLoT : applicable | |
{ | |
typedef typename Traits::target_type T ; | |
typedef typename Traits::source_type S ; | |
typedef typename Traits::argument_type argument_type ; | |
static range_check_result apply ( argument_type s ) | |
{ | |
return s <= static_cast<S>(bounds<T>::lowest()) - static_cast<S>(1.0) | |
? cNegOverflow : cInRange ; | |
} | |
} ; | |
// s < Lowest(T)-0.5 ? cNegOverflow : cInRange | |
// | |
template<class Traits> | |
struct LT_HalfPrevLoT : applicable | |
{ | |
typedef typename Traits::target_type T ; | |
typedef typename Traits::source_type S ; | |
typedef typename Traits::argument_type argument_type ; | |
static range_check_result apply ( argument_type s ) | |
{ | |
return s < static_cast<S>(bounds<T>::lowest()) - static_cast<S>(0.5) | |
? cNegOverflow : cInRange ; | |
} | |
} ; | |
// s > Highest(T) ? cPosOverflow : cInRange | |
// | |
template<class Traits> | |
struct GT_HiT : applicable | |
{ | |
typedef typename Traits::target_type T ; | |
typedef typename Traits::source_type S ; | |
typedef typename Traits::argument_type argument_type ; | |
static range_check_result apply ( argument_type s ) | |
{ | |
return s > static_cast<S>(bounds<T>::highest()) | |
? cPosOverflow : cInRange ; | |
} | |
} ; | |
// s >= Lowest(T) + 1 ? cPosOverflow : cInRange | |
// | |
template<class Traits> | |
struct GE_SuccHiT : applicable | |
{ | |
typedef typename Traits::target_type T ; | |
typedef typename Traits::source_type S ; | |
typedef typename Traits::argument_type argument_type ; | |
static range_check_result apply ( argument_type s ) | |
{ | |
return s >= static_cast<S>(bounds<T>::highest()) + static_cast<S>(1.0) | |
? cPosOverflow : cInRange ; | |
} | |
} ; | |
// s >= Lowest(T) + 0.5 ? cPosgOverflow : cInRange | |
// | |
template<class Traits> | |
struct GT_HalfSuccHiT : applicable | |
{ | |
typedef typename Traits::target_type T ; | |
typedef typename Traits::source_type S ; | |
typedef typename Traits::argument_type argument_type ; | |
static range_check_result apply ( argument_type s ) | |
{ | |
return s >= static_cast<S>(bounds<T>::highest()) + static_cast<S>(0.5) | |
? cPosOverflow : cInRange ; | |
} | |
} ; | |
//-------------------------------------------------------------------------- | |
// | |
// Predicate Combiner. | |
// | |
// This helper classes are used to possibly combine the range checking logic | |
// individually performed by the predicates | |
// | |
//-------------------------------------------------------------------------- | |
// Applies both predicates: first 'PredA', and if it equals 'cInRange', 'PredB' | |
template<class PredA, class PredB> | |
struct applyBoth | |
{ | |
typedef typename PredA::argument_type argument_type ; | |
static range_check_result apply ( argument_type s ) | |
{ | |
range_check_result r = PredA::apply(s) ; | |
if ( r == cInRange ) | |
r = PredB::apply(s); | |
return r ; | |
} | |
} ; | |
template<class PredA, class PredB> | |
struct combine | |
{ | |
typedef applyBoth<PredA,PredB> Both ; | |
typedef void NNone ; // 'None' is defined as a macro in (/usr/X11R6/include/X11/X.h) | |
typedef typename PredA::do_apply do_applyA ; | |
typedef typename PredB::do_apply do_applyB ; | |
typedef typename for_both<do_applyA, do_applyB, Both, PredA, PredB, NNone>::type type ; | |
} ; | |
//-------------------------------------------------------------------------- | |
// Range Checker classes. | |
// | |
// The following classes are VISIBLE base classes of the user-level converter<> class. | |
// They supply the optimized 'out_of_range()' and 'validate_range()' static member functions | |
// visible in the user interface. | |
// | |
//-------------------------------------------------------------------------- | |
// Dummy range checker. | |
template<class Traits> | |
struct dummy_range_checker | |
{ | |
typedef typename Traits::argument_type argument_type ; | |
static range_check_result out_of_range ( argument_type ) { return cInRange ; } | |
static void validate_range ( argument_type ) {} | |
} ; | |
// Generic range checker. | |
// | |
// All the range checking logic for all possible combinations of source and target | |
// can be arranged in terms of one or two predicates, which test overflow on both neg/pos 'sides' | |
// of the ranges. | |
// | |
// These predicates are given here as IsNegOverflow and IsPosOverflow. | |
// | |
template<class Traits, class IsNegOverflow, class IsPosOverflow, class OverflowHandler> | |
struct generic_range_checker | |
{ | |
typedef OverflowHandler overflow_handler ; | |
typedef typename Traits::argument_type argument_type ; | |
static range_check_result out_of_range ( argument_type s ) | |
{ | |
typedef typename combine<IsNegOverflow,IsPosOverflow>::type Predicate ; | |
return Predicate::apply(s); | |
} | |
static void validate_range ( argument_type s ) | |
{ OverflowHandler()( out_of_range(s) ) ; } | |
} ; | |
//-------------------------------------------------------------------------- | |
// | |
// Selectors for the optimized Range Checker class. | |
// | |
//-------------------------------------------------------------------------- | |
template<class Traits,class OverflowHandler> | |
struct GetRC_Sig2Sig_or_Unsig2Unsig | |
{ | |
typedef dummy_range_checker<Traits> Dummy ; | |
typedef LT_LoT<Traits> Pred1 ; | |
typedef GT_HiT<Traits> Pred2 ; | |
typedef generic_range_checker<Traits,Pred1,Pred2,OverflowHandler> Normal ; | |
typedef typename Traits::subranged subranged ; | |
typedef typename mpl::if_<subranged,Normal,Dummy>::type type ; | |
} ; | |
template<class Traits, class OverflowHandler> | |
struct GetRC_Sig2Unsig | |
{ | |
typedef LT_Zero<Traits> Pred1 ; | |
typedef GT_HiT <Traits> Pred2 ; | |
typedef generic_range_checker<Traits,Pred1,Pred2,OverflowHandler> ChoiceA ; | |
typedef generic_range_checker<Traits,Pred1,non_applicable,OverflowHandler> ChoiceB ; | |
typedef typename Traits::target_type T ; | |
typedef typename Traits::source_type S ; | |
typedef typename subranged_Unsig2Sig<S,T>::type oposite_subranged ; | |
typedef typename mpl::not_<oposite_subranged>::type positively_subranged ; | |
typedef typename mpl::if_<positively_subranged,ChoiceA,ChoiceB>::type type ; | |
} ; | |
template<class Traits, class OverflowHandler> | |
struct GetRC_Unsig2Sig | |
{ | |
typedef GT_HiT<Traits> Pred1 ; | |
typedef generic_range_checker<Traits,non_applicable,Pred1,OverflowHandler> type ; | |
} ; | |
template<class Traits,class OverflowHandler> | |
struct GetRC_Int2Int | |
{ | |
typedef GetRC_Sig2Sig_or_Unsig2Unsig<Traits,OverflowHandler> Sig2SigQ ; | |
typedef GetRC_Sig2Unsig <Traits,OverflowHandler> Sig2UnsigQ ; | |
typedef GetRC_Unsig2Sig <Traits,OverflowHandler> Unsig2SigQ ; | |
typedef Sig2SigQ Unsig2UnsigQ ; | |
typedef typename Traits::sign_mixture sign_mixture ; | |
typedef typename | |
for_sign_mixture<sign_mixture,Sig2SigQ,Sig2UnsigQ,Unsig2SigQ,Unsig2UnsigQ>::type | |
selector ; | |
typedef typename selector::type type ; | |
} ; | |
template<class Traits> | |
struct GetRC_Int2Float | |
{ | |
typedef dummy_range_checker<Traits> type ; | |
} ; | |
template<class Traits, class OverflowHandler, class Float2IntRounder> | |
struct GetRC_Float2Int | |
{ | |
typedef LE_PrevLoT <Traits> Pred1 ; | |
typedef GE_SuccHiT <Traits> Pred2 ; | |
typedef LT_HalfPrevLoT<Traits> Pred3 ; | |
typedef GT_HalfSuccHiT<Traits> Pred4 ; | |
typedef GT_HiT <Traits> Pred5 ; | |
typedef LT_LoT <Traits> Pred6 ; | |
typedef generic_range_checker<Traits,Pred1,Pred2,OverflowHandler> ToZero ; | |
typedef generic_range_checker<Traits,Pred3,Pred4,OverflowHandler> ToNearest ; | |
typedef generic_range_checker<Traits,Pred1,Pred5,OverflowHandler> ToInf ; | |
typedef generic_range_checker<Traits,Pred6,Pred2,OverflowHandler> ToNegInf ; | |
typedef typename Float2IntRounder::round_style round_style ; | |
typedef typename for_round_style<round_style,ToZero,ToNearest,ToInf,ToNegInf>::type type ; | |
} ; | |
template<class Traits, class OverflowHandler> | |
struct GetRC_Float2Float | |
{ | |
typedef dummy_range_checker<Traits> Dummy ; | |
typedef LT_LoT<Traits> Pred1 ; | |
typedef GT_HiT<Traits> Pred2 ; | |
typedef generic_range_checker<Traits,Pred1,Pred2,OverflowHandler> Normal ; | |
typedef typename Traits::subranged subranged ; | |
typedef typename mpl::if_<subranged,Normal,Dummy>::type type ; | |
} ; | |
template<class Traits, class OverflowHandler, class Float2IntRounder> | |
struct GetRC_BuiltIn2BuiltIn | |
{ | |
typedef GetRC_Int2Int<Traits,OverflowHandler> Int2IntQ ; | |
typedef GetRC_Int2Float<Traits> Int2FloatQ ; | |
typedef GetRC_Float2Int<Traits,OverflowHandler,Float2IntRounder> Float2IntQ ; | |
typedef GetRC_Float2Float<Traits,OverflowHandler> Float2FloatQ ; | |
typedef typename Traits::int_float_mixture int_float_mixture ; | |
typedef typename for_int_float_mixture<int_float_mixture, Int2IntQ, Int2FloatQ, Float2IntQ, Float2FloatQ>::type selector ; | |
typedef typename selector::type type ; | |
} ; | |
template<class Traits, class OverflowHandler, class Float2IntRounder> | |
struct GetRC | |
{ | |
typedef GetRC_BuiltIn2BuiltIn<Traits,OverflowHandler,Float2IntRounder> BuiltIn2BuiltInQ ; | |
typedef dummy_range_checker<Traits> Dummy ; | |
typedef mpl::identity<Dummy> DummyQ ; | |
typedef typename Traits::udt_builtin_mixture udt_builtin_mixture ; | |
typedef typename for_udt_builtin_mixture<udt_builtin_mixture,BuiltIn2BuiltInQ,DummyQ,DummyQ,DummyQ>::type selector ; | |
typedef typename selector::type type ; | |
} ; | |
//-------------------------------------------------------------------------- | |
// Converter classes. | |
// | |
// The following classes are VISIBLE base classes of the user-level converter<> class. | |
// They supply the optimized 'nearbyint()' and 'convert()' static member functions | |
// visible in the user interface. | |
// | |
//-------------------------------------------------------------------------- | |
// | |
// Trivial Converter : used when (cv-unqualified) T == (cv-unqualified) S | |
// | |
template<class Traits> | |
struct trivial_converter_impl : public std::unary_function< BOOST_DEDUCED_TYPENAME Traits::argument_type | |
,BOOST_DEDUCED_TYPENAME Traits::result_type | |
> | |
,public dummy_range_checker<Traits> | |
{ | |
typedef Traits traits ; | |
typedef typename Traits::source_type source_type ; | |
typedef typename Traits::argument_type argument_type ; | |
typedef typename Traits::result_type result_type ; | |
static result_type low_level_convert ( argument_type s ) { return s ; } | |
static source_type nearbyint ( argument_type s ) { return s ; } | |
static result_type convert ( argument_type s ) { return s ; } | |
} ; | |
// | |
// Rounding Converter : used for float to integral conversions. | |
// | |
template<class Traits,class RangeChecker,class RawConverter,class Float2IntRounder> | |
struct rounding_converter : public std::unary_function< BOOST_DEDUCED_TYPENAME Traits::argument_type | |
,BOOST_DEDUCED_TYPENAME Traits::result_type | |
> | |
,public RangeChecker | |
,public Float2IntRounder | |
,public RawConverter | |
{ | |
typedef RangeChecker RangeCheckerBase ; | |
typedef Float2IntRounder Float2IntRounderBase ; | |
typedef RawConverter RawConverterBase ; | |
typedef Traits traits ; | |
typedef typename Traits::source_type source_type ; | |
typedef typename Traits::argument_type argument_type ; | |
typedef typename Traits::result_type result_type ; | |
static result_type convert ( argument_type s ) | |
{ | |
RangeCheckerBase::validate_range(s); | |
source_type s1 = Float2IntRounderBase::nearbyint(s); | |
return RawConverterBase::low_level_convert(s1); | |
} | |
} ; | |
// | |
// Non-Rounding Converter : used for all other conversions. | |
// | |
template<class Traits,class RangeChecker,class RawConverter> | |
struct non_rounding_converter : public std::unary_function< BOOST_DEDUCED_TYPENAME Traits::argument_type | |
,BOOST_DEDUCED_TYPENAME Traits::result_type | |
> | |
,public RangeChecker | |
,public RawConverter | |
{ | |
typedef RangeChecker RangeCheckerBase ; | |
typedef RawConverter RawConverterBase ; | |
typedef Traits traits ; | |
typedef typename Traits::source_type source_type ; | |
typedef typename Traits::argument_type argument_type ; | |
typedef typename Traits::result_type result_type ; | |
static source_type nearbyint ( argument_type s ) { return s ; } | |
static result_type convert ( argument_type s ) | |
{ | |
RangeCheckerBase::validate_range(s); | |
return RawConverterBase::low_level_convert(s); | |
} | |
} ; | |
//-------------------------------------------------------------------------- | |
// | |
// Selectors for the optimized Converter class. | |
// | |
//-------------------------------------------------------------------------- | |
template<class Traits,class OverflowHandler,class Float2IntRounder,class RawConverter, class UserRangeChecker> | |
struct get_non_trivial_converter | |
{ | |
typedef GetRC<Traits,OverflowHandler,Float2IntRounder> InternalRangeCheckerQ ; | |
typedef is_same<UserRangeChecker,UseInternalRangeChecker> use_internal_RC ; | |
typedef mpl::identity<UserRangeChecker> UserRangeCheckerQ ; | |
typedef typename | |
mpl::eval_if<use_internal_RC,InternalRangeCheckerQ,UserRangeCheckerQ>::type | |
RangeChecker ; | |
typedef non_rounding_converter<Traits,RangeChecker,RawConverter> NonRounding ; | |
typedef rounding_converter<Traits,RangeChecker,RawConverter,Float2IntRounder> Rounding ; | |
typedef mpl::identity<NonRounding> NonRoundingQ ; | |
typedef mpl::identity<Rounding> RoundingQ ; | |
typedef typename Traits::int_float_mixture int_float_mixture ; | |
typedef typename | |
for_int_float_mixture<int_float_mixture, NonRoundingQ, NonRoundingQ, RoundingQ, NonRoundingQ>::type | |
selector ; | |
typedef typename selector::type type ; | |
} ; | |
template< class Traits | |
,class OverflowHandler | |
,class Float2IntRounder | |
,class RawConverter | |
,class UserRangeChecker | |
> | |
struct get_converter_impl | |
{ | |
#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT( 0x0561 ) ) | |
// bcc55 prefers sometimes template parameters to be explicit local types. | |
// (notice that is is illegal to reuse the names like this) | |
typedef Traits Traits ; | |
typedef OverflowHandler OverflowHandler ; | |
typedef Float2IntRounder Float2IntRounder ; | |
typedef RawConverter RawConverter ; | |
typedef UserRangeChecker UserRangeChecker ; | |
#endif | |
typedef trivial_converter_impl<Traits> Trivial ; | |
typedef mpl::identity <Trivial> TrivialQ ; | |
typedef get_non_trivial_converter< Traits | |
,OverflowHandler | |
,Float2IntRounder | |
,RawConverter | |
,UserRangeChecker | |
> NonTrivialQ ; | |
typedef typename Traits::trivial trivial ; | |
typedef typename mpl::eval_if<trivial,TrivialQ,NonTrivialQ>::type type ; | |
} ; | |
} } } // namespace boost::numeric::convdetail | |
#endif | |