ceph/src/boost/libs/lexical_cast/include/boost/lexical_cast/detail/converter_numeric.hpp

   1 // Copyright Kevlin Henney, 2000-2005.
   2 // Copyright Alexander Nasonov, 2006-2010.
   3 // Copyright Antony Polukhin, 2011-2014.
   4 //
   5 // Distributed under the Boost Software License, Version 1.0. (See
   6 // accompanying file LICENSE_1_0.txt or copy at
   7 // http://www.boost.org/LICENSE_1_0.txt)
   8 //
   9 // what:  lexical_cast custom keyword cast
  10 // who:   contributed by Kevlin Henney,
  11 //        enhanced with contributions from Terje Slettebo,
  12 //        with additional fixes and suggestions from Gennaro Prota,
  13 //        Beman Dawes, Dave Abrahams, Daryle Walker, Peter Dimov,
  14 //        Alexander Nasonov, Antony Polukhin, Justin Viiret, Michael Hofmann,
  15 //        Cheng Yang, Matthew Bradbury, David W. Birdsall, Pavel Korzh and other Boosters
  16 // when:  November 2000, March 2003, June 2005, June 2006, March 2011 - 2014
  17
  18 #ifndef BOOST_LEXICAL_CAST_DETAIL_CONVERTER_NUMERIC_HPP
  19 #define BOOST_LEXICAL_CAST_DETAIL_CONVERTER_NUMERIC_HPP
  20
  21 #include <boost/config.hpp>
  22 #ifdef BOOST_HAS_PRAGMA_ONCE
  23 #   pragma once
  24 #endif
  25
  26 #include <boost/limits.hpp>
  27 #include <boost/mpl/eval_if.hpp>
  28 #include <boost/mpl/identity.hpp>
  29 #include <boost/mpl/if.hpp>
  30 #include <boost/type_traits/make_unsigned.hpp>
  31 #include <boost/type_traits/is_signed.hpp>
  32 #include <boost/type_traits/is_integral.hpp>
  33 #include <boost/type_traits/is_arithmetic.hpp>
  34 #include <boost/type_traits/is_base_of.hpp>
  35 #include <boost/type_traits/is_float.hpp>
  36
  37 #include <boost/numeric/conversion/cast.hpp>
  38
  39 namespace boost { namespace detail {
  40
  41 template <class Source >
  42 struct detect_precision_loss
  43 {
  44     typedef Source source_type;
  45     typedef boost::numeric::Trunc<Source> Rounder;
  46     typedef BOOST_DEDUCED_TYPENAME mpl::if_<
  47         boost::is_arithmetic<Source>, Source, Source const&
  48     >::type argument_type ;
  49
  50     static inline source_type nearbyint(argument_type s, bool& is_ok) BOOST_NOEXCEPT {
  51         const source_type near_int = Rounder::nearbyint(s);
  52         if (near_int && is_ok) {
  53             const source_type orig_div_round = s / near_int;
  54             const source_type eps = std::numeric_limits<source_type>::epsilon();
  55
  56             is_ok = !((orig_div_round > 1 ? orig_div_round - 1 : 1 - orig_div_round) > eps);
  57         }
  58
  59         return s;
  60     }
  61
  62     typedef typename Rounder::round_style round_style;
  63 };
  64
  65 template <typename Base, class Source>
  66 struct fake_precision_loss: public Base
  67 {
  68     typedef Source source_type ;
  69     typedef BOOST_DEDUCED_TYPENAME mpl::if_<
  70         boost::is_arithmetic<Source>, Source, Source const&
  71     >::type argument_type ;
  72
  73     static inline source_type nearbyint(argument_type s, bool& /*is_ok*/) BOOST_NOEXCEPT {
  74         return s;
  75     }
  76 };
  77
  78 struct nothrow_overflow_handler
  79 {
  80     inline bool operator() ( boost::numeric::range_check_result r ) const BOOST_NOEXCEPT {
  81         return (r == boost::numeric::cInRange);
  82     }
  83 };
  84
  85 template <typename Target, typename Source>
  86 inline bool noexcept_numeric_convert(const Source& arg, Target& result) BOOST_NOEXCEPT {
  87     typedef boost::numeric::converter<
  88             Target,
  89             Source,
  90             boost::numeric::conversion_traits<Target, Source >,
  91             nothrow_overflow_handler,
  92             detect_precision_loss<Source >
  93     > converter_orig_t;
  94
  95     typedef BOOST_DEDUCED_TYPENAME boost::mpl::if_c<
  96         boost::is_base_of< detect_precision_loss<Source >, converter_orig_t >::value,
  97         converter_orig_t,
  98         fake_precision_loss<converter_orig_t, Source>
  99     >::type converter_t;
 100
 101     bool res = nothrow_overflow_handler()(converter_t::out_of_range(arg));
 102     result = converter_t::low_level_convert(converter_t::nearbyint(arg, res));
 103     return res;
 104 }
 105
 106 template <typename Target, typename Source>
 107 struct lexical_cast_dynamic_num_not_ignoring_minus
 108 {
 109     static inline bool try_convert(const Source &arg, Target& result) BOOST_NOEXCEPT {
 110         return noexcept_numeric_convert<Target, Source >(arg, result);
 111     }
 112 };
 113
 114 template <typename Target, typename Source>
 115 struct lexical_cast_dynamic_num_ignoring_minus
 116 {
 117     static inline bool try_convert(const Source &arg, Target& result) BOOST_NOEXCEPT {
 118         typedef BOOST_DEDUCED_TYPENAME boost::mpl::eval_if_c<
 119                 boost::is_float<Source>::value,
 120                 boost::mpl::identity<Source>,
 121                 boost::make_unsigned<Source>
 122         >::type usource_t;
 123
 124         if (arg < 0) {
 125             const bool res = noexcept_numeric_convert<Target, usource_t>(0u - arg, result);
 126             result = static_cast<Target>(0u - result);
 127             return res;
 128         } else {
 129             return noexcept_numeric_convert<Target, usource_t>(arg, result);
 130         }
 131     }
 132 };
 133
 134 /*
 135  * lexical_cast_dynamic_num follows the rules:
 136  * 1) If Source can be converted to Target without precision loss and
 137  * without overflows, then assign Source to Target and return
 138  *
 139  * 2) If Source is less than 0 and Target is an unsigned integer,
 140  * then negate Source, check the requirements of rule 1) and if
 141  * successful, assign static_casted Source to Target and return
 142  *
 143  * 3) Otherwise throw a bad_lexical_cast exception
 144  *
 145  *
 146  * Rule 2) required because boost::lexical_cast has the behavior of
 147  * stringstream, which uses the rules of scanf for conversions. And
 148  * in the C99 standard for unsigned input value minus sign is
 149  * optional, so if a negative number is read, no errors will arise
 150  * and the result will be the two's complement.
 151  */
 152 template <typename Target, typename Source>
 153 struct dynamic_num_converter_impl
 154 {
 155     static inline bool try_convert(const Source &arg, Target& result) BOOST_NOEXCEPT {
 156         typedef BOOST_DEDUCED_TYPENAME boost::mpl::if_c<
 157                 boost::is_unsigned<Target>::value &&
 158                 (boost::is_signed<Source>::value || boost::is_float<Source>::value) &&
 159                 !(boost::is_same<Source, bool>::value) &&
 160                 !(boost::is_same<Target, bool>::value),
 161             lexical_cast_dynamic_num_ignoring_minus<Target, Source>,
 162             lexical_cast_dynamic_num_not_ignoring_minus<Target, Source>
 163         >::type caster_type;
 164
 165 #if 0
 166
 167         typedef BOOST_DEDUCED_TYPENAME boost::mpl::if_<
 168             BOOST_DEDUCED_TYPENAME boost::mpl::and_<
 169                 boost::is_unsigned<Target>,
 170                 boost::mpl::or_<
 171                     boost::is_signed<Source>,
 172                     boost::is_float<Source>
 173                 >,
 174                 boost::mpl::not_<
 175                     boost::is_same<Source, bool>
 176                 >,
 177                 boost::mpl::not_<
 178                     boost::is_same<Target, bool>
 179                 >
 180             >::type,
 181             lexical_cast_dynamic_num_ignoring_minus<Target, Source>,
 182             lexical_cast_dynamic_num_not_ignoring_minus<Target, Source>
 183         >::type caster_type;
 184
 185 #endif
 186
 187         return caster_type::try_convert(arg, result);
 188     }
 189 };
 190
 191 }} // namespace boost::detail
 192
 193 #endif // BOOST_LEXICAL_CAST_DETAIL_CONVERTER_NUMERIC_HPP
 194