BVB Source Codes

mars Show converter_lexical.hpp Source code

Return Download mars: download converter_lexical.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_LEXICAL_HPP
  19. #define BOOST_LEXICAL_CAST_DETAIL_CONVERTER_LEXICAL_HPP
  20.  
  21. #include <boost/config.hpp>
  22. #ifdef BOOST_HAS_PRAGMA_ONCE
  23. #   pragma once
  24. #endif
  25.  
  26. #if defined(BOOST_NO_STRINGSTREAM) || defined(BOOST_NO_STD_WSTRING)
  27. #define BOOST_LCAST_NO_WCHAR_T
  28. #endif
  29.  
  30. #include <cstddef>
  31. #include <string>
  32. #include <boost/limits.hpp>
  33. #include <boost/mpl/bool.hpp>
  34. #include <boost/mpl/identity.hpp>
  35. #include <boost/mpl/if.hpp>
  36. #include <boost/type_traits/is_integral.hpp>
  37. #include <boost/type_traits/is_float.hpp>
  38. #include <boost/type_traits/has_left_shift.hpp>
  39. #include <boost/type_traits/has_right_shift.hpp>
  40. #include <boost/static_assert.hpp>
  41. #include <boost/detail/lcast_precision.hpp>
  42.  
  43. #include <boost/lexical_cast/detail/widest_char.hpp>
  44. #include <boost/lexical_cast/detail/is_character.hpp>
  45.  
  46. #ifndef BOOST_NO_CXX11_HDR_ARRAY
  47. #include <array>
  48. #endif
  49.  
  50. #include <boost/array.hpp>
  51. #include <boost/range/iterator_range_core.hpp>
  52. #include <boost/container/container_fwd.hpp>
  53.  
  54. #include <boost/lexical_cast/detail/converter_lexical_streams.hpp>
  55.  
  56. namespace mars_boost {} namespace boost = mars_boost; namespace mars_boost {
  57.  
  58.     namespace detail // normalize_single_byte_char<Char>
  59.     {
  60.         // Converts signed/unsigned char to char
  61.         template < class Char >
  62.         struct normalize_single_byte_char
  63.         {
  64.             typedef Char type;
  65.         };
  66.  
  67.         template <>
  68.         struct normalize_single_byte_char< signed char >
  69.         {
  70.             typedef char type;
  71.         };
  72.  
  73.         template <>
  74.         struct normalize_single_byte_char< unsigned char >
  75.         {
  76.             typedef char type;
  77.         };
  78.     }
  79.  
  80.     namespace detail // deduce_character_type_later<T>
  81.     {
  82.         // Helper type, meaning that stram character for T must be deduced
  83.         // at Stage 2 (See deduce_source_char<T> and deduce_target_char<T>)
  84.         template < class T > struct deduce_character_type_later {};
  85.     }
  86.  
  87.     namespace detail // stream_char_common<T>
  88.     {
  89.         // Selectors to choose stream character type (common for Source and Target)
  90.         // Returns one of char, wchar_t, char16_t, char32_t or deduce_character_type_later<T> types
  91.         // Executed on Stage 1 (See deduce_source_char<T> and deduce_target_char<T>)
  92.         template < typename Type >
  93.         struct stream_char_common: public mars_boost::mpl::if_c<
  94.             mars_boost::detail::is_character< Type >::value,
  95.             Type,
  96.             mars_boost::detail::deduce_character_type_later< Type >
  97.         > {};
  98.  
  99.         template < typename Char >
  100.         struct stream_char_common< Char* >: public mars_boost::mpl::if_c<
  101.             mars_boost::detail::is_character< Char >::value,
  102.             Char,
  103.             mars_boost::detail::deduce_character_type_later< Char* >
  104.         > {};
  105.  
  106.         template < typename Char >
  107.         struct stream_char_common< const Char* >: public mars_boost::mpl::if_c<
  108.             mars_boost::detail::is_character< Char >::value,
  109.             Char,
  110.             mars_boost::detail::deduce_character_type_later< const Char* >
  111.         > {};
  112.  
  113.         template < typename Char >
  114.         struct stream_char_common< mars_boost::iterator_range< Char* > >: public mars_boost::mpl::if_c<
  115.             mars_boost::detail::is_character< Char >::value,
  116.             Char,
  117.             mars_boost::detail::deduce_character_type_later< mars_boost::iterator_range< Char* > >
  118.         > {};
  119.    
  120.         template < typename Char >
  121.         struct stream_char_common< mars_boost::iterator_range< const Char* > >: public mars_boost::mpl::if_c<
  122.             mars_boost::detail::is_character< Char >::value,
  123.             Char,
  124.             mars_boost::detail::deduce_character_type_later< mars_boost::iterator_range< const Char* > >
  125.         > {};
  126.  
  127.         template < class Char, class Traits, class Alloc >
  128.         struct stream_char_common< std::basic_string< Char, Traits, Alloc > >
  129.         {
  130.             typedef Char type;
  131.         };
  132.  
  133.         template < class Char, class Traits, class Alloc >
  134.         struct stream_char_common< mars_boost::container::basic_string< Char, Traits, Alloc > >
  135.         {
  136.             typedef Char type;
  137.         };
  138.  
  139.         template < typename Char, std::size_t N >
  140.         struct stream_char_common< mars_boost::array< Char, N > >: public mars_boost::mpl::if_c<
  141.             mars_boost::detail::is_character< Char >::value,
  142.             Char,
  143.             mars_boost::detail::deduce_character_type_later< mars_boost::array< Char, N > >
  144.         > {};
  145.  
  146.         template < typename Char, std::size_t N >
  147.         struct stream_char_common< mars_boost::array< const Char, N > >: public mars_boost::mpl::if_c<
  148.             mars_boost::detail::is_character< Char >::value,
  149.             Char,
  150.             mars_boost::detail::deduce_character_type_later< mars_boost::array< const Char, N > >
  151.         > {};
  152.  
  153. #ifndef BOOST_NO_CXX11_HDR_ARRAY
  154.         template < typename Char, std::size_t N >
  155.         struct stream_char_common< std::array<Char, N > >: public mars_boost::mpl::if_c<
  156.             mars_boost::detail::is_character< Char >::value,
  157.             Char,
  158.             mars_boost::detail::deduce_character_type_later< std::array< Char, N > >
  159.         > {};
  160.  
  161.         template < typename Char, std::size_t N >
  162.         struct stream_char_common< std::array< const Char, N > >: public mars_boost::mpl::if_c<
  163.             mars_boost::detail::is_character< Char >::value,
  164.             Char,
  165.             mars_boost::detail::deduce_character_type_later< std::array< const Char, N > >
  166.         > {};
  167. #endif
  168.  
  169. #ifdef BOOST_HAS_INT128
  170.         template <> struct stream_char_common< mars_boost::int128_type >: public mars_boost::mpl::identity< char > {};
  171.         template <> struct stream_char_common< mars_boost::uint128_type >: public mars_boost::mpl::identity< char > {};
  172. #endif
  173.  
  174. #if !defined(BOOST_LCAST_NO_WCHAR_T) && defined(BOOST_NO_INTRINSIC_WCHAR_T)
  175.         template <>
  176.         struct stream_char_common< wchar_t >
  177.         {
  178.             typedef char type;
  179.         };
  180. #endif
  181.     }
  182.  
  183.     namespace detail // deduce_source_char_impl<T>
  184.     {
  185.         // If type T is `deduce_character_type_later` type, then tries to deduce
  186.         // character type using mars_boost::has_left_shift<T> metafunction.
  187.         // Otherwise supplied type T is a character type, that must be normalized
  188.         // using normalize_single_byte_char<Char>.
  189.         // Executed at Stage 2  (See deduce_source_char<T> and deduce_target_char<T>)
  190.         template < class Char >
  191.         struct deduce_source_char_impl
  192.         {
  193.             typedef BOOST_DEDUCED_TYPENAME mars_boost::detail::normalize_single_byte_char< Char >::type type;
  194.         };
  195.        
  196.         template < class T >
  197.         struct deduce_source_char_impl< deduce_character_type_later< T > >
  198.         {
  199.             typedef mars_boost::has_left_shift< std::basic_ostream< char >, T > result_t;
  200.  
  201. #if defined(BOOST_LCAST_NO_WCHAR_T)
  202.             BOOST_STATIC_ASSERT_MSG((result_t::value),
  203.                 "Source type is not std::ostream`able and std::wostream`s are not supported by your STL implementation");
  204.             typedef char type;
  205. #else
  206.             typedef BOOST_DEDUCED_TYPENAME mars_boost::mpl::if_c<
  207.                 result_t::value, char, wchar_t
  208.             >::type type;
  209.  
  210.             BOOST_STATIC_ASSERT_MSG((result_t::value || mars_boost::has_left_shift< std::basic_ostream< type >, T >::value),
  211.                 "Source type is neither std::ostream`able nor std::wostream`able");
  212. #endif
  213.         };
  214.     }
  215.  
  216.     namespace detail  // deduce_target_char_impl<T>
  217.     {
  218.         // If type T is `deduce_character_type_later` type, then tries to deduce
  219.         // character type using mars_boost::has_right_shift<T> metafunction.
  220.         // Otherwise supplied type T is a character type, that must be normalized
  221.         // using normalize_single_byte_char<Char>.
  222.         // Executed at Stage 2  (See deduce_source_char<T> and deduce_target_char<T>)
  223.         template < class Char >
  224.         struct deduce_target_char_impl
  225.         {
  226.             typedef BOOST_DEDUCED_TYPENAME normalize_single_byte_char< Char >::type type;
  227.         };
  228.        
  229.         template < class T >
  230.         struct deduce_target_char_impl< deduce_character_type_later<T> >
  231.         {
  232.             typedef mars_boost::has_right_shift<std::basic_istream<char>, T > result_t;
  233.  
  234. #if defined(BOOST_LCAST_NO_WCHAR_T)
  235.             BOOST_STATIC_ASSERT_MSG((result_t::value),
  236.                 "Target type is not std::istream`able and std::wistream`s are not supported by your STL implementation");
  237.             typedef char type;
  238. #else
  239.             typedef BOOST_DEDUCED_TYPENAME mars_boost::mpl::if_c<
  240.                 result_t::value, char, wchar_t
  241.             >::type type;
  242.            
  243.             BOOST_STATIC_ASSERT_MSG((result_t::value || mars_boost::has_right_shift<std::basic_istream<wchar_t>, T >::value),
  244.                 "Target type is neither std::istream`able nor std::wistream`able");
  245. #endif
  246.         };
  247.     }
  248.  
  249.     namespace detail  // deduce_target_char<T> and deduce_source_char<T>
  250.     {
  251.         // We deduce stream character types in two stages.
  252.         //
  253.         // Stage 1 is common for Target and Source. At Stage 1 we get
  254.         // non normalized character type (may contain unsigned/signed char)
  255.         // or deduce_character_type_later<T> where T is the original type.
  256.         // Stage 1 is executed by stream_char_common<T>
  257.         //
  258.         // At Stage 2 we normalize character types or try to deduce character
  259.         // type using metafunctions.
  260.         // Stage 2 is executed by deduce_target_char_impl<T> and
  261.         // deduce_source_char_impl<T>
  262.         //
  263.         // deduce_target_char<T> and deduce_source_char<T> functions combine
  264.         // both stages
  265.  
  266.         template < class T >
  267.         struct deduce_target_char
  268.         {
  269.             typedef BOOST_DEDUCED_TYPENAME stream_char_common< T >::type stage1_type;
  270.             typedef BOOST_DEDUCED_TYPENAME deduce_target_char_impl< stage1_type >::type stage2_type;
  271.  
  272.             typedef stage2_type type;
  273.         };
  274.  
  275.         template < class T >
  276.         struct deduce_source_char
  277.         {
  278.             typedef BOOST_DEDUCED_TYPENAME stream_char_common< T >::type stage1_type;
  279.             typedef BOOST_DEDUCED_TYPENAME deduce_source_char_impl< stage1_type >::type stage2_type;
  280.  
  281.             typedef stage2_type type;
  282.         };
  283.     }
  284.  
  285.     namespace detail // extract_char_traits template
  286.     {
  287.         // We are attempting to get char_traits<> from T
  288.         // template parameter. Otherwise we'll be using std::char_traits<Char>
  289.         template < class Char, class T >
  290.         struct extract_char_traits
  291.                 : mars_boost::false_type
  292.         {
  293.             typedef std::char_traits< Char > trait_t;
  294.         };
  295.  
  296.         template < class Char, class Traits, class Alloc >
  297.         struct extract_char_traits< Char, std::basic_string< Char, Traits, Alloc > >
  298.             : mars_boost::true_type
  299.         {
  300.             typedef Traits trait_t;
  301.         };
  302.  
  303.         template < class Char, class Traits, class Alloc>
  304.         struct extract_char_traits< Char, mars_boost::container::basic_string< Char, Traits, Alloc > >
  305.             : mars_boost::true_type
  306.         {
  307.             typedef Traits trait_t;
  308.         };
  309.     }
  310.  
  311.     namespace detail // array_to_pointer_decay<T>
  312.     {
  313.         template<class T>
  314.         struct array_to_pointer_decay
  315.         {
  316.             typedef T type;
  317.         };
  318.  
  319.         template<class T, std::size_t N>
  320.         struct array_to_pointer_decay<T[N]>
  321.         {
  322.             typedef const T * type;
  323.         };
  324.     }
  325.    
  326.     namespace detail // lcast_src_length
  327.     {
  328.         // Return max. length of string representation of Source;
  329.         template< class Source,         // Source type of lexical_cast.
  330.                   class Enable = void   // helper type
  331.                 >
  332.         struct lcast_src_length
  333.         {
  334.             BOOST_STATIC_CONSTANT(std::size_t, value = 1);
  335.         };
  336.  
  337.         // Helper for integral types.
  338.         // Notes on length calculation:
  339.         // Max length for 32bit int with grouping "\1" and thousands_sep ',':
  340.         // "-2,1,4,7,4,8,3,6,4,7"
  341.         //  ^                    - is_signed
  342.         //   ^                   - 1 digit not counted by digits10
  343.         //    ^^^^^^^^^^^^^^^^^^ - digits10 * 2
  344.         //
  345.         // Constant is_specialized is used instead of constant 1
  346.         // to prevent buffer overflow in a rare case when
  347.         // <boost/limits.hpp> doesn't add missing specialization for
  348.         // numeric_limits<T> for some integral type T.
  349.         // When is_specialized is false, the whole expression is 0.
  350.         template <class Source>
  351.         struct lcast_src_length<
  352.                     Source, BOOST_DEDUCED_TYPENAME mars_boost::enable_if<mars_boost::is_integral<Source> >::type
  353.                 >
  354.         {
  355. #ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
  356.             BOOST_STATIC_CONSTANT(std::size_t, value =
  357.                   std::numeric_limits<Source>::is_signed +
  358.                   std::numeric_limits<Source>::is_specialized + /* == 1 */
  359.                   std::numeric_limits<Source>::digits10 * 2
  360.               );
  361. #else
  362.             BOOST_STATIC_CONSTANT(std::size_t, value = 156);
  363.             BOOST_STATIC_ASSERT(sizeof(Source) * CHAR_BIT <= 256);
  364. #endif
  365.         };
  366.  
  367.         // Helper for floating point types.
  368.         // -1.23456789e-123456
  369.         // ^                   sign
  370.         //  ^                  leading digit
  371.         //   ^                 decimal point
  372.         //    ^^^^^^^^         lcast_precision<Source>::value
  373.         //            ^        "e"
  374.         //             ^       exponent sign
  375.         //              ^^^^^^ exponent (assumed 6 or less digits)
  376.         // sign + leading digit + decimal point + "e" + exponent sign == 5
  377.         template<class Source>
  378.         struct lcast_src_length<
  379.                 Source, BOOST_DEDUCED_TYPENAME mars_boost::enable_if<mars_boost::is_float<Source> >::type
  380.             >
  381.         {
  382.  
  383. #ifndef BOOST_LCAST_NO_COMPILE_TIME_PRECISION
  384.             BOOST_STATIC_ASSERT(
  385.                     std::numeric_limits<Source>::max_exponent10 <=  999999L &&
  386.                     std::numeric_limits<Source>::min_exponent10 >= -999999L
  387.                 );
  388.  
  389.             BOOST_STATIC_CONSTANT(std::size_t, value =
  390.                     5 + lcast_precision<Source>::value + 6
  391.                 );
  392. #else // #ifndef BOOST_LCAST_NO_COMPILE_TIME_PRECISION
  393.             BOOST_STATIC_CONSTANT(std::size_t, value = 156);
  394. #endif // #ifndef BOOST_LCAST_NO_COMPILE_TIME_PRECISION
  395.         };
  396.     }
  397.  
  398.     namespace detail // lexical_cast_stream_traits<Source, Target>
  399.     {
  400.         template <class Source, class Target>
  401.         struct lexical_cast_stream_traits {
  402.             typedef BOOST_DEDUCED_TYPENAME mars_boost::detail::array_to_pointer_decay<Source>::type src;
  403.             typedef BOOST_DEDUCED_TYPENAME mars_boost::remove_cv<src>::type            no_cv_src;
  404.                
  405.             typedef mars_boost::detail::deduce_source_char<no_cv_src>                           deduce_src_char_metafunc;
  406.             typedef BOOST_DEDUCED_TYPENAME deduce_src_char_metafunc::type           src_char_t;
  407.             typedef BOOST_DEDUCED_TYPENAME mars_boost::detail::deduce_target_char<Target>::type target_char_t;
  408.                
  409.             typedef BOOST_DEDUCED_TYPENAME mars_boost::detail::widest_char<
  410.                 target_char_t, src_char_t
  411.             >::type char_type;
  412.  
  413. #if !defined(BOOST_NO_CXX11_CHAR16_T) && defined(BOOST_NO_CXX11_UNICODE_LITERALS)
  414.             BOOST_STATIC_ASSERT_MSG(( !mars_boost::is_same<char16_t, src_char_t>::value
  415.                                         && !mars_boost::is_same<char16_t, target_char_t>::value),
  416.                 "Your compiler does not have full support for char16_t" );
  417. #endif
  418. #if !defined(BOOST_NO_CXX11_CHAR32_T) && defined(BOOST_NO_CXX11_UNICODE_LITERALS)
  419.             BOOST_STATIC_ASSERT_MSG(( !mars_boost::is_same<char32_t, src_char_t>::value
  420.                                         && !mars_boost::is_same<char32_t, target_char_t>::value),
  421.                 "Your compiler does not have full support for char32_t" );
  422. #endif
  423.  
  424.             typedef BOOST_DEDUCED_TYPENAME mars_boost::mpl::if_c<
  425.                 mars_boost::detail::extract_char_traits<char_type, Target>::value,
  426.                 BOOST_DEDUCED_TYPENAME mars_boost::detail::extract_char_traits<char_type, Target>,
  427.                 BOOST_DEDUCED_TYPENAME mars_boost::detail::extract_char_traits<char_type, no_cv_src>
  428.             >::type::trait_t traits;
  429.            
  430.             typedef mars_boost::mpl::bool_
  431.                 <
  432.                 mars_boost::is_same<char, src_char_t>::value &&                                 // source is not a wide character based type
  433.                 (sizeof(char) != sizeof(target_char_t)) &&  // target type is based on wide character
  434.                 (!(mars_boost::detail::is_character<no_cv_src>::value))
  435.                 > is_string_widening_required_t;
  436.  
  437.             typedef mars_boost::mpl::bool_
  438.                 <
  439.                 !(mars_boost::is_integral<no_cv_src>::value ||
  440.                   mars_boost::detail::is_character<
  441.                     BOOST_DEDUCED_TYPENAME deduce_src_char_metafunc::stage1_type          // if we did not get character type at stage1
  442.                   >::value                                                           // then we have no optimization for that type
  443.                  )
  444.                 > is_source_input_not_optimized_t;
  445.            
  446.             // If we have an optimized conversion for
  447.             // Source, we do not need to construct stringbuf.
  448.             BOOST_STATIC_CONSTANT(bool, requires_stringbuf =
  449.                 (is_string_widening_required_t::value || is_source_input_not_optimized_t::value)
  450.             );
  451.            
  452.             typedef mars_boost::detail::lcast_src_length<no_cv_src> len_t;
  453.         };
  454.     }
  455.  
  456.     namespace detail
  457.     {
  458.         template<typename Target, typename Source>
  459.         struct lexical_converter_impl
  460.         {
  461.             typedef lexical_cast_stream_traits<Source, Target>  stream_trait;
  462.  
  463.             typedef detail::lexical_istream_limited_src<
  464.                 BOOST_DEDUCED_TYPENAME stream_trait::char_type,
  465.                 BOOST_DEDUCED_TYPENAME stream_trait::traits,
  466.                 stream_trait::requires_stringbuf,
  467.                 stream_trait::len_t::value + 1
  468.             > i_interpreter_type;
  469.  
  470.             typedef detail::lexical_ostream_limited_src<
  471.                 BOOST_DEDUCED_TYPENAME stream_trait::char_type,
  472.                 BOOST_DEDUCED_TYPENAME stream_trait::traits
  473.             > o_interpreter_type;
  474.  
  475.             static inline bool try_convert(const Source& arg, Target& result) {
  476.                 i_interpreter_type i_interpreter;
  477.  
  478.                 // Disabling ADL, by directly specifying operators.
  479.                 if (!(i_interpreter.operator <<(arg)))
  480.                     return false;
  481.  
  482.                 o_interpreter_type out(i_interpreter.cbegin(), i_interpreter.cend());
  483.  
  484.                 // Disabling ADL, by directly specifying operators.
  485.                 if(!(out.operator >>(result)))
  486.                     return false;
  487.  
  488.                 return true;
  489.             }
  490.         };
  491.     }
  492.  
  493. } // namespace mars_boost
  494.  
  495. #undef BOOST_LCAST_NO_WCHAR_T
  496.  
  497. #endif // BOOST_LEXICAL_CAST_DETAIL_CONVERTER_LEXICAL_HPP
  498.  
  499.  
downloadconverter_lexical.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