BVB Source Codes

mars Show converter_numeric.hpp Source code

Return Download mars: download converter_numeric.hpp Source code - Download mars Source code - Type:.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 mars_boost {} namespace boost = mars_boost; namespace mars_boost { namespace detail {
  40.  
  41. template <class Source >
  42. struct detect_precision_loss
  43. {
  44.     typedef Source source_type;
  45.     typedef mars_boost::numeric::Trunc<Source> Rounder;
  46.     typedef BOOST_DEDUCED_TYPENAME mpl::if_<
  47.         mars_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.         mars_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() ( mars_boost::numeric::range_check_result r ) const BOOST_NOEXCEPT {
  81.         return (r == mars_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 mars_boost::numeric::converter<
  88.             Target,
  89.             Source,
  90.             mars_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 mars_boost::mpl::if_c<
  96.         mars_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 mars_boost::mpl::eval_if_c<
  119.                 mars_boost::is_float<Source>::value,
  120.                 mars_boost::mpl::identity<Source>,
  121.                 mars_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 mars_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 mars_boost::mpl::if_c<
  157.                 mars_boost::is_unsigned<Target>::value &&
  158.                 (mars_boost::is_signed<Source>::value || mars_boost::is_float<Source>::value) &&
  159.                 !(mars_boost::is_same<Source, bool>::value) &&
  160.                 !(mars_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 mars_boost::mpl::if_<
  168.             BOOST_DEDUCED_TYPENAME mars_boost::mpl::and_<
  169.                 mars_boost::is_unsigned<Target>,
  170.                 mars_boost::mpl::or_<
  171.                     mars_boost::is_signed<Source>,
  172.                     mars_boost::is_float<Source>
  173.                 >,
  174.                 mars_boost::mpl::not_<
  175.                     mars_boost::is_same<Source, bool>
  176.                 >,
  177.                 mars_boost::mpl::not_<
  178.                     mars_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 mars_boost::detail
  192.  
  193. #endif // BOOST_LEXICAL_CAST_DETAIL_CONVERTER_NUMERIC_HPP
  194.  
  195.  
downloadconverter_numeric.hpp Source code - Download mars Source code
Related Source Codes/Software:
Hero - Elegant transition library for iOS & tvOS 2017-06-09
deep-photo-styletransfer - Code and data for paper "Deep Photo Style Transfer... 2017-06-09
mastodon - A GNU Social-compatible microblogging server ... 2017-06-09
plyr - A simple HTML5, YouTube and Vimeo player ... 2017-06-08
prepack - Prepack is a partial evaluator for JavaScript. Pre... 2017-06-08
Public-APIs - 2017-06-09
lottie-ios - An iOS library to natively render After Effects ve... 2017-06-09
Awesome-Hacking - A collection of various awesome lists for hackers,... 2017-06-09
algorithms - Minimal examples of data structures and algorithms... 2017-06-10
lectures - Oxford Deep NLP 2017 course 2017-06-10
CRYENGINE - CRYENGINE is a powerful real-time game development... 2017-06-11
postal - 2017-06-11
reactide - Reactide is the first dedicated IDE for React web ... 2017-06-11
rkt - rkt is a pod-native container engine for Linux. It... 2017-06-11
uWebSockets - Tiny WebSockets https://for... 2017-06-11
realworld - TodoMVC for the RealWorld - Exemplary fullstack Me... 2017-06-11
goreplay - GoReplay is an open-source tool for capturing and ... 2017-06-10
pyenv - Simple Python version management 2017-06-10
redux-saga - An alternative side effect model for Redux apps ... 2017-06-10
angular-starter - 2017-06-10

 Back to top