diff options
Diffstat (limited to 'src/third_party/boost-1.56.0/boost/lexical_cast.hpp')
| -rw-r--r-- | src/third_party/boost-1.56.0/boost/lexical_cast.hpp | 2515 |
1 files changed, 0 insertions, 2515 deletions
diff --git a/src/third_party/boost-1.56.0/boost/lexical_cast.hpp b/src/third_party/boost-1.56.0/boost/lexical_cast.hpp deleted file mode 100644 index 97f9f80089e..00000000000 --- a/src/third_party/boost-1.56.0/boost/lexical_cast.hpp +++ /dev/null @@ -1,2515 +0,0 @@ -#ifndef BOOST_LEXICAL_CAST_INCLUDED -#define BOOST_LEXICAL_CAST_INCLUDED - -// MS compatible compilers support #pragma once - -#if defined(_MSC_VER) -# pragma once -#endif - -// Boost lexical_cast.hpp header -------------------------------------------// -// -// See http://www.boost.org/libs/conversion for documentation. -// See end of this header for rights and permissions. -// -// what: lexical_cast custom keyword cast -// who: contributed by Kevlin Henney, -// enhanced with contributions from Terje Slettebo, -// with additional fixes and suggestions from Gennaro Prota, -// Beman Dawes, Dave Abrahams, Daryle Walker, Peter Dimov, -// Alexander Nasonov, Antony Polukhin, Justin Viiret, Michael Hofmann, -// Cheng Yang, Matthew Bradbury, David W. Birdsall, Pavel Korzh and other Boosters -// when: November 2000, March 2003, June 2005, June 2006, March 2011 - 2014 - -#include <boost/config.hpp> -#if defined(BOOST_NO_STRINGSTREAM) || defined(BOOST_NO_STD_WSTRING) -#define BOOST_LCAST_NO_WCHAR_T -#endif - -#include <climits> -#include <cstddef> -#include <string> -#include <cstring> -#include <cstdio> -#include <typeinfo> -#include <exception> -#include <boost/limits.hpp> -#include <boost/mpl/if.hpp> -#include <boost/throw_exception.hpp> -#include <boost/type_traits/ice.hpp> -#include <boost/type_traits/is_pointer.hpp> -#include <boost/static_assert.hpp> -#include <boost/utility/value_init.hpp> -#include <boost/detail/lcast_precision.hpp> -#include <boost/detail/workaround.hpp> - - -#ifndef BOOST_NO_STD_LOCALE -# include <locale> -#else -# ifndef BOOST_LEXICAL_CAST_ASSUME_C_LOCALE - // Getting error at this point means, that your STL library is old/lame/misconfigured. - // If nothing can be done with STL library, define BOOST_LEXICAL_CAST_ASSUME_C_LOCALE, - // but beware: lexical_cast will understand only 'C' locale delimeters and thousands - // separators. -# error "Unable to use <locale> header. Define BOOST_LEXICAL_CAST_ASSUME_C_LOCALE to force " -# error "boost::lexical_cast to use only 'C' locale during conversions." -# endif -#endif - -#ifdef BOOST_NO_STRINGSTREAM -#include <strstream> -#else -#include <sstream> -#endif - -#ifdef BOOST_NO_TYPEID -#define BOOST_LCAST_THROW_BAD_CAST(S, T) throw_exception(bad_lexical_cast()) -#else -#define BOOST_LCAST_THROW_BAD_CAST(Source, Target) \ - throw_exception(bad_lexical_cast(typeid(Source), typeid(Target))) -#endif - -namespace boost -{ - // exception used to indicate runtime lexical_cast failure - class BOOST_SYMBOL_VISIBLE bad_lexical_cast : - // workaround MSVC bug with std::bad_cast when _HAS_EXCEPTIONS == 0 -#if defined(BOOST_MSVC) && defined(_HAS_EXCEPTIONS) && !_HAS_EXCEPTIONS - public std::exception -#else - public std::bad_cast -#endif - -#if defined(__BORLANDC__) && BOOST_WORKAROUND( __BORLANDC__, < 0x560 ) - // under bcc32 5.5.1 bad_cast doesn't derive from exception - , public std::exception -#endif - - { - public: - bad_lexical_cast() BOOST_NOEXCEPT -#ifndef BOOST_NO_TYPEID - : source(&typeid(void)), target(&typeid(void)) -#endif - {} - - virtual const char *what() const BOOST_NOEXCEPT_OR_NOTHROW { - return "bad lexical cast: " - "source type value could not be interpreted as target"; - } - - virtual ~bad_lexical_cast() BOOST_NOEXCEPT_OR_NOTHROW - {} - -#ifndef BOOST_NO_TYPEID - bad_lexical_cast( - const std::type_info &source_type_arg, - const std::type_info &target_type_arg) BOOST_NOEXCEPT - : source(&source_type_arg), target(&target_type_arg) - {} - - const std::type_info &source_type() const BOOST_NOEXCEPT { - return *source; - } - - const std::type_info &target_type() const BOOST_NOEXCEPT { - return *target; - } - - private: - const std::type_info *source; - const std::type_info *target; -#endif - }; - - namespace detail // widest_char - { - template <typename TargetChar, typename SourceChar> - struct widest_char - { - typedef BOOST_DEDUCED_TYPENAME boost::mpl::if_c< - (sizeof(TargetChar) > sizeof(SourceChar)) - , TargetChar - , SourceChar >::type type; - }; - } -} // namespace boost - -#if !defined(__SUNPRO_CC) && !defined(__PGIC__) - -#include <cmath> -#include <istream> - -#ifndef BOOST_NO_CXX11_HDR_ARRAY -#include <array> -#endif - -#include <boost/array.hpp> -#include <boost/numeric/conversion/cast.hpp> -#include <boost/type_traits/make_unsigned.hpp> -#include <boost/type_traits/is_signed.hpp> -#include <boost/type_traits/is_integral.hpp> -#include <boost/type_traits/is_arithmetic.hpp> -#include <boost/type_traits/remove_pointer.hpp> -#include <boost/type_traits/has_left_shift.hpp> -#include <boost/type_traits/has_right_shift.hpp> -#include <boost/math/special_functions/sign.hpp> -#include <boost/math/special_functions/fpclassify.hpp> -#include <boost/range/iterator_range_core.hpp> -#include <boost/container/container_fwd.hpp> -#include <boost/integer.hpp> -#include <boost/detail/basic_pointerbuf.hpp> -#include <boost/noncopyable.hpp> -#ifndef BOOST_NO_CWCHAR -# include <cwchar> -#endif - -namespace boost { - - namespace detail // is_character<...> - { - // returns true, if T is one of the character types - template < typename T > - struct is_character - { - typedef boost::type_traits::ice_or< - boost::is_same< T, char >::value, - #ifndef BOOST_LCAST_NO_WCHAR_T - boost::is_same< T, wchar_t >::value, - #endif - #ifndef BOOST_NO_CXX11_CHAR16_T - boost::is_same< T, char16_t >::value, - #endif - #ifndef BOOST_NO_CXX11_CHAR32_T - boost::is_same< T, char32_t >::value, - #endif - boost::is_same< T, unsigned char >::value, - boost::is_same< T, signed char >::value - > result_type; - - BOOST_STATIC_CONSTANT(bool, value = (result_type::value) ); - }; - } - - namespace detail // normalize_single_byte_char<Char> - { - // Converts signed/unsigned char to char - template < class Char > - struct normalize_single_byte_char - { - typedef Char type; - }; - - template <> - struct normalize_single_byte_char< signed char > - { - typedef char type; - }; - - template <> - struct normalize_single_byte_char< unsigned char > - { - typedef char type; - }; - } - - namespace detail // deduce_character_type_later<T> - { - // Helper type, meaning that stram character for T must be deduced - // at Stage 2 (See deduce_source_char<T> and deduce_target_char<T>) - template < class T > struct deduce_character_type_later {}; - } - - namespace detail // stream_char_common<T> - { - // Selectors to choose stream character type (common for Source and Target) - // Returns one of char, wchar_t, char16_t, char32_t or deduce_character_type_later<T> types - // Executed on Stage 1 (See deduce_source_char<T> and deduce_target_char<T>) - template < typename Type > - struct stream_char_common: public boost::mpl::if_c< - boost::detail::is_character< Type >::value, - Type, - boost::detail::deduce_character_type_later< Type > - > {}; - - template < typename Char > - struct stream_char_common< Char* >: public boost::mpl::if_c< - boost::detail::is_character< Char >::value, - Char, - boost::detail::deduce_character_type_later< Char* > - > {}; - - template < typename Char > - struct stream_char_common< const Char* >: public boost::mpl::if_c< - boost::detail::is_character< Char >::value, - Char, - boost::detail::deduce_character_type_later< const Char* > - > {}; - - template < typename Char > - struct stream_char_common< boost::iterator_range< Char* > >: public boost::mpl::if_c< - boost::detail::is_character< Char >::value, - Char, - boost::detail::deduce_character_type_later< boost::iterator_range< Char* > > - > {}; - - template < typename Char > - struct stream_char_common< boost::iterator_range< const Char* > >: public boost::mpl::if_c< - boost::detail::is_character< Char >::value, - Char, - boost::detail::deduce_character_type_later< boost::iterator_range< const Char* > > - > {}; - - template < class Char, class Traits, class Alloc > - struct stream_char_common< std::basic_string< Char, Traits, Alloc > > - { - typedef Char type; - }; - - template < class Char, class Traits, class Alloc > - struct stream_char_common< boost::container::basic_string< Char, Traits, Alloc > > - { - typedef Char type; - }; - - template < typename Char, std::size_t N > - struct stream_char_common< boost::array< Char, N > >: public boost::mpl::if_c< - boost::detail::is_character< Char >::value, - Char, - boost::detail::deduce_character_type_later< boost::array< Char, N > > - > {}; - - template < typename Char, std::size_t N > - struct stream_char_common< boost::array< const Char, N > >: public boost::mpl::if_c< - boost::detail::is_character< Char >::value, - Char, - boost::detail::deduce_character_type_later< boost::array< const Char, N > > - > {}; - -#ifndef BOOST_NO_CXX11_HDR_ARRAY - template < typename Char, std::size_t N > - struct stream_char_common< std::array<Char, N > >: public boost::mpl::if_c< - boost::detail::is_character< Char >::value, - Char, - boost::detail::deduce_character_type_later< std::array< Char, N > > - > {}; - - template < typename Char, std::size_t N > - struct stream_char_common< std::array< const Char, N > >: public boost::mpl::if_c< - boost::detail::is_character< Char >::value, - Char, - boost::detail::deduce_character_type_later< std::array< const Char, N > > - > {}; -#endif - -#ifdef BOOST_HAS_INT128 - template <> struct stream_char_common< boost::int128_type >: public boost::mpl::identity< char > {}; - template <> struct stream_char_common< boost::uint128_type >: public boost::mpl::identity< char > {}; -#endif - -#if !defined(BOOST_LCAST_NO_WCHAR_T) && defined(BOOST_NO_INTRINSIC_WCHAR_T) - template <> - struct stream_char_common< wchar_t > - { - typedef char type; - }; -#endif - } - - namespace detail // deduce_source_char_impl<T> - { - // If type T is `deduce_character_type_later` type, then tries to deduce - // character type using boost::has_left_shift<T> metafunction. - // Otherwise supplied type T is a character type, that must be normalized - // using normalize_single_byte_char<Char>. - // Executed at Stage 2 (See deduce_source_char<T> and deduce_target_char<T>) - template < class Char > - struct deduce_source_char_impl - { - typedef BOOST_DEDUCED_TYPENAME boost::detail::normalize_single_byte_char< Char >::type type; - }; - - template < class T > - struct deduce_source_char_impl< deduce_character_type_later< T > > - { - typedef boost::has_left_shift< std::basic_ostream< char >, T > result_t; - -#if defined(BOOST_LCAST_NO_WCHAR_T) - BOOST_STATIC_ASSERT_MSG((result_t::value), - "Source type is not std::ostream`able and std::wostream`s are not supported by your STL implementation"); - typedef char type; -#else - typedef BOOST_DEDUCED_TYPENAME boost::mpl::if_c< - result_t::value, char, wchar_t - >::type type; - - BOOST_STATIC_ASSERT_MSG((result_t::value || boost::has_left_shift< std::basic_ostream< type >, T >::value), - "Source type is neither std::ostream`able nor std::wostream`able"); -#endif - }; - } - - namespace detail // deduce_target_char_impl<T> - { - // If type T is `deduce_character_type_later` type, then tries to deduce - // character type using boost::has_right_shift<T> metafunction. - // Otherwise supplied type T is a character type, that must be normalized - // using normalize_single_byte_char<Char>. - // Executed at Stage 2 (See deduce_source_char<T> and deduce_target_char<T>) - template < class Char > - struct deduce_target_char_impl - { - typedef BOOST_DEDUCED_TYPENAME normalize_single_byte_char< Char >::type type; - }; - - template < class T > - struct deduce_target_char_impl< deduce_character_type_later<T> > - { - typedef boost::has_right_shift<std::basic_istream<char>, T > result_t; - -#if defined(BOOST_LCAST_NO_WCHAR_T) - BOOST_STATIC_ASSERT_MSG((result_t::value), - "Target type is not std::istream`able and std::wistream`s are not supported by your STL implementation"); - typedef char type; -#else - typedef BOOST_DEDUCED_TYPENAME boost::mpl::if_c< - result_t::value, char, wchar_t - >::type type; - - BOOST_STATIC_ASSERT_MSG((result_t::value || boost::has_right_shift<std::basic_istream<wchar_t>, T >::value), - "Target type is neither std::istream`able nor std::wistream`able"); -#endif - }; - } - - namespace detail // deduce_target_char<T> and deduce_source_char<T> - { - // We deduce stream character types in two stages. - // - // Stage 1 is common for Target and Source. At Stage 1 we get - // non normalized character type (may contain unsigned/signed char) - // or deduce_character_type_later<T> where T is the original type. - // Stage 1 is executed by stream_char_common<T> - // - // At Stage 2 we normalize character types or try to deduce character - // type using metafunctions. - // Stage 2 is executed by deduce_target_char_impl<T> and - // deduce_source_char_impl<T> - // - // deduce_target_char<T> and deduce_source_char<T> functions combine - // both stages - - template < class T > - struct deduce_target_char - { - typedef BOOST_DEDUCED_TYPENAME stream_char_common< T >::type stage1_type; - typedef BOOST_DEDUCED_TYPENAME deduce_target_char_impl< stage1_type >::type stage2_type; - - typedef stage2_type type; - }; - - template < class T > - struct deduce_source_char - { - typedef BOOST_DEDUCED_TYPENAME stream_char_common< T >::type stage1_type; - typedef BOOST_DEDUCED_TYPENAME deduce_source_char_impl< stage1_type >::type stage2_type; - - typedef stage2_type type; - }; - } - - namespace detail // extract_char_traits template - { - // We are attempting to get char_traits<> from T - // template parameter. Otherwise we'll be using std::char_traits<Char> - template < class Char, class T > - struct extract_char_traits - : boost::false_type - { - typedef std::char_traits< Char > trait_t; - }; - - template < class Char, class Traits, class Alloc > - struct extract_char_traits< Char, std::basic_string< Char, Traits, Alloc > > - : boost::true_type - { - typedef Traits trait_t; - }; - - template < class Char, class Traits, class Alloc> - struct extract_char_traits< Char, boost::container::basic_string< Char, Traits, Alloc > > - : boost::true_type - { - typedef Traits trait_t; - }; - } - - namespace detail // array_to_pointer_decay<T> - { - template<class T> - struct array_to_pointer_decay - { - typedef T type; - }; - - template<class T, std::size_t N> - struct array_to_pointer_decay<T[N]> - { - typedef const T * type; - }; - } - - namespace detail // is_this_float_conversion_optimized<Float, Char> - { - // this metafunction evaluates to true, if we have optimized comnversion - // from Float type to Char array. - // Must be in sync with lexical_stream_limited_src<Char, ...>::shl_real_type(...) - template <typename Float, typename Char> - struct is_this_float_conversion_optimized - { - typedef boost::type_traits::ice_and< - boost::is_float<Float>::value, -#if !defined(BOOST_LCAST_NO_WCHAR_T) && !defined(BOOST_NO_SWPRINTF) && !defined(__MINGW32__) - boost::type_traits::ice_or< - boost::type_traits::ice_eq<sizeof(Char), sizeof(char) >::value, - boost::is_same<Char, wchar_t>::value - >::value -#else - boost::type_traits::ice_eq<sizeof(Char), sizeof(char) >::value -#endif - > result_type; - - BOOST_STATIC_CONSTANT(bool, value = (result_type::value) ); - }; - } - - namespace detail // lcast_src_length - { - // Return max. length of string representation of Source; - template< class Source, // Source type of lexical_cast. - class Enable = void // helper type - > - struct lcast_src_length - { - BOOST_STATIC_CONSTANT(std::size_t, value = 1); - }; - - // Helper for integral types. - // Notes on length calculation: - // Max length for 32bit int with grouping "\1" and thousands_sep ',': - // "-2,1,4,7,4,8,3,6,4,7" - // ^ - is_signed - // ^ - 1 digit not counted by digits10 - // ^^^^^^^^^^^^^^^^^^ - digits10 * 2 - // - // Constant is_specialized is used instead of constant 1 - // to prevent buffer overflow in a rare case when - // <boost/limits.hpp> doesn't add missing specialization for - // numeric_limits<T> for some integral type T. - // When is_specialized is false, the whole expression is 0. - template <class Source> - struct lcast_src_length< - Source, BOOST_DEDUCED_TYPENAME boost::enable_if<boost::is_integral<Source> >::type - > - { -#ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS - BOOST_STATIC_CONSTANT(std::size_t, value = - std::numeric_limits<Source>::is_signed + - std::numeric_limits<Source>::is_specialized + /* == 1 */ - std::numeric_limits<Source>::digits10 * 2 - ); -#else - BOOST_STATIC_CONSTANT(std::size_t, value = 156); - BOOST_STATIC_ASSERT(sizeof(Source) * CHAR_BIT <= 256); -#endif - }; - -#ifndef BOOST_LCAST_NO_COMPILE_TIME_PRECISION - // Helper for floating point types. - // -1.23456789e-123456 - // ^ sign - // ^ leading digit - // ^ decimal point - // ^^^^^^^^ lcast_precision<Source>::value - // ^ "e" - // ^ exponent sign - // ^^^^^^ exponent (assumed 6 or less digits) - // sign + leading digit + decimal point + "e" + exponent sign == 5 - template<class Source> - struct lcast_src_length< - Source, BOOST_DEDUCED_TYPENAME boost::enable_if<boost::is_float<Source> >::type - > - { - BOOST_STATIC_ASSERT( - std::numeric_limits<Source>::max_exponent10 <= 999999L && - std::numeric_limits<Source>::min_exponent10 >= -999999L - ); - - BOOST_STATIC_CONSTANT(std::size_t, value = - 5 + lcast_precision<Source>::value + 6 - ); - }; -#endif // #ifndef BOOST_LCAST_NO_COMPILE_TIME_PRECISION - } - - namespace detail // lexical_cast_stream_traits<Source, Target> - { - template <class Source, class Target> - struct lexical_cast_stream_traits { - typedef BOOST_DEDUCED_TYPENAME boost::detail::array_to_pointer_decay<Source>::type src; - typedef BOOST_DEDUCED_TYPENAME boost::remove_cv<src>::type no_cv_src; - - typedef boost::detail::deduce_source_char<no_cv_src> deduce_src_char_metafunc; - typedef BOOST_DEDUCED_TYPENAME deduce_src_char_metafunc::type src_char_t; - typedef BOOST_DEDUCED_TYPENAME boost::detail::deduce_target_char<Target>::type target_char_t; - - typedef BOOST_DEDUCED_TYPENAME boost::detail::widest_char< - target_char_t, src_char_t - >::type char_type; - -#if !defined(BOOST_NO_CXX11_CHAR16_T) && defined(BOOST_NO_CXX11_UNICODE_LITERALS) - BOOST_STATIC_ASSERT_MSG(( !boost::is_same<char16_t, src_char_t>::value - && !boost::is_same<char16_t, target_char_t>::value), - "Your compiler does not have full support for char16_t" ); -#endif -#if !defined(BOOST_NO_CXX11_CHAR32_T) && defined(BOOST_NO_CXX11_UNICODE_LITERALS) - BOOST_STATIC_ASSERT_MSG(( !boost::is_same<char32_t, src_char_t>::value - && !boost::is_same<char32_t, target_char_t>::value), - "Your compiler does not have full support for char32_t" ); -#endif - - typedef BOOST_DEDUCED_TYPENAME boost::mpl::if_c< - boost::detail::extract_char_traits<char_type, Target>::value, - BOOST_DEDUCED_TYPENAME boost::detail::extract_char_traits<char_type, Target>, - BOOST_DEDUCED_TYPENAME boost::detail::extract_char_traits<char_type, no_cv_src> - >::type::trait_t traits; - - typedef boost::type_traits::ice_and< - boost::is_same<char, src_char_t>::value, // source is not a wide character based type - boost::type_traits::ice_ne<sizeof(char), sizeof(target_char_t) >::value, // target type is based on wide character - boost::type_traits::ice_not< - boost::detail::is_character<no_cv_src>::value // single character widening is optimized - >::value // and does not requires stringbuffer - > is_string_widening_required_t; - - typedef boost::type_traits::ice_not< boost::type_traits::ice_or< - boost::is_integral<no_cv_src>::value, - boost::detail::is_this_float_conversion_optimized<no_cv_src, char_type >::value, - boost::detail::is_character< - BOOST_DEDUCED_TYPENAME deduce_src_char_metafunc::stage1_type // if we did not get character type at stage1 - >::value // then we have no optimization for that type - >::value > is_source_input_not_optimized_t; - - // If we have an optimized conversion for - // Source, we do not need to construct stringbuf. - BOOST_STATIC_CONSTANT(bool, requires_stringbuf = - (boost::type_traits::ice_or< - is_string_widening_required_t::value, is_source_input_not_optimized_t::value - >::value) - ); - - typedef boost::detail::lcast_src_length<no_cv_src> len_t; - }; - } - - namespace detail // '0', '-', '+', 'e', 'E' and '.' constants - { - template < typename Char > - struct lcast_char_constants { - // We check in tests assumption that static casted character is - // equal to correctly written C++ literal: U'0' == static_cast<char32_t>('0') - BOOST_STATIC_CONSTANT(Char, zero = static_cast<Char>('0')); - BOOST_STATIC_CONSTANT(Char, minus = static_cast<Char>('-')); - BOOST_STATIC_CONSTANT(Char, plus = static_cast<Char>('+')); - BOOST_STATIC_CONSTANT(Char, lowercase_e = static_cast<Char>('e')); - BOOST_STATIC_CONSTANT(Char, capital_e = static_cast<Char>('E')); - BOOST_STATIC_CONSTANT(Char, c_decimal_separator = static_cast<Char>('.')); - }; - } - - namespace detail // lcast_to_unsigned - { - template<class T> - inline - BOOST_DEDUCED_TYPENAME boost::make_unsigned<T>::type lcast_to_unsigned(const T value) BOOST_NOEXCEPT { - typedef BOOST_DEDUCED_TYPENAME boost::make_unsigned<T>::type result_type; - return value < 0 - ? static_cast<result_type>(0u - static_cast<result_type>(value)) - : static_cast<result_type>(value); - } - } - - namespace detail // lcast_put_unsigned - { - template <class Traits, class T, class CharT> - class lcast_put_unsigned: boost::noncopyable { - typedef BOOST_DEDUCED_TYPENAME Traits::int_type int_type; - BOOST_DEDUCED_TYPENAME boost::mpl::if_c< - (sizeof(int_type) > sizeof(T)) - , int_type - , T - >::type m_value; - CharT* m_finish; - CharT const m_czero; - int_type const m_zero; - - public: - lcast_put_unsigned(const T n_param, CharT* finish) BOOST_NOEXCEPT - : m_value(n_param), m_finish(finish) - , m_czero(lcast_char_constants<CharT>::zero), m_zero(Traits::to_int_type(m_czero)) - { -#ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS - BOOST_STATIC_ASSERT(!std::numeric_limits<T>::is_signed); -#endif - } - - CharT* convert() { -#ifndef BOOST_LEXICAL_CAST_ASSUME_C_LOCALE - std::locale loc; - if (loc == std::locale::classic()) { - return main_convert_loop(); - } - - typedef std::numpunct<CharT> numpunct; - numpunct const& np = BOOST_USE_FACET(numpunct, loc); - std::string const grouping = np.grouping(); - std::string::size_type const grouping_size = grouping.size(); - - if (!grouping_size || grouping[0] <= 0) { - return main_convert_loop(); - } - -#ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS - // Check that ulimited group is unreachable: - BOOST_STATIC_ASSERT(std::numeric_limits<T>::digits10 < CHAR_MAX); -#endif - CharT const thousands_sep = np.thousands_sep(); - std::string::size_type group = 0; // current group number - char last_grp_size = grouping[0]; - char left = last_grp_size; - - do { - if (left == 0) { - ++group; - if (group < grouping_size) { - char const grp_size = grouping[group]; - last_grp_size = (grp_size <= 0 ? static_cast<char>(CHAR_MAX) : grp_size); - } - - left = last_grp_size; - --m_finish; - Traits::assign(*m_finish, thousands_sep); - } - - --left; - } while (main_convert_itaration()); - - return m_finish; -#else - return main_convert_loop(); -#endif - } - - private: - inline bool main_convert_itaration() BOOST_NOEXCEPT { - --m_finish; - int_type const digit = static_cast<int_type>(m_value % 10U); - Traits::assign(*m_finish, Traits::to_char_type(m_zero + digit)); - m_value /= 10; - return !!m_value; // supressing warnings - } - - inline CharT* main_convert_loop() BOOST_NOEXCEPT { - while (main_convert_itaration()); - return m_finish; - } - }; - } - - namespace detail // lcast_ret_unsigned - { - template <class Traits, class T, class CharT> - class lcast_ret_unsigned: boost::noncopyable { - bool m_multiplier_overflowed; - T m_multiplier; - T& m_value; - const CharT* const m_begin; - const CharT* m_end; - - public: - lcast_ret_unsigned(T& value, const CharT* const begin, const CharT* end) BOOST_NOEXCEPT - : m_multiplier_overflowed(false), m_multiplier(1), m_value(value), m_begin(begin), m_end(end) - { -#ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS - BOOST_STATIC_ASSERT(!std::numeric_limits<T>::is_signed); - - // GCC when used with flag -std=c++0x may not have std::numeric_limits - // specializations for __int128 and unsigned __int128 types. - // Try compilation with -std=gnu++0x or -std=gnu++11. - // - // http://gcc.gnu.org/bugzilla/show_bug.cgi?id=40856 - BOOST_STATIC_ASSERT_MSG(std::numeric_limits<T>::is_specialized, - "std::numeric_limits are not specialized for integral type passed to boost::lexical_cast" - ); -#endif - } - - inline bool convert() { - CharT const czero = lcast_char_constants<CharT>::zero; - --m_end; - m_value = static_cast<T>(0); - - if (m_begin > m_end || *m_end < czero || *m_end >= czero + 10) - return false; - m_value = static_cast<T>(*m_end - czero); - --m_end; - -#ifdef BOOST_LEXICAL_CAST_ASSUME_C_LOCALE - return main_convert_loop(); -#else - std::locale loc; - if (loc == std::locale::classic()) { - return main_convert_loop(); - } - - typedef std::numpunct<CharT> numpunct; - numpunct const& np = BOOST_USE_FACET(numpunct, loc); - std::string const& grouping = np.grouping(); - std::string::size_type const grouping_size = grouping.size(); - - /* According to Programming languages - C++ - * we MUST check for correct grouping - */ - if (!grouping_size || grouping[0] <= 0) { - return main_convert_loop(); - } - - unsigned char current_grouping = 0; - CharT const thousands_sep = np.thousands_sep(); - char remained = static_cast<char>(grouping[current_grouping] - 1); - - for (;m_end >= m_begin; --m_end) - { - if (remained) { - if (!main_convert_itaration()) { - return false; - } - --remained; - } else { - if ( !Traits::eq(*m_end, thousands_sep) ) //|| begin == end ) return false; - { - /* - * According to Programming languages - C++ - * Digit grouping is checked. That is, the positions of discarded - * separators is examined for consistency with - * use_facet<numpunct<charT> >(loc ).grouping() - * - * BUT what if there is no separators at all and grouping() - * is not empty? Well, we have no extraced separators, so we - * won`t check them for consistency. This will allow us to - * work with "C" locale from other locales - */ - return main_convert_loop(); - } else { - if (m_begin == m_end) return false; - if (current_grouping < grouping_size - 1) ++current_grouping; - remained = grouping[current_grouping]; - } - } - } /*for*/ - - return true; -#endif - } - - private: - // Iteration that does not care about grouping/separators and assumes that all - // input characters are digits - inline bool main_convert_itaration() BOOST_NOEXCEPT { - CharT const czero = lcast_char_constants<CharT>::zero; - T const maxv = (std::numeric_limits<T>::max)(); - - m_multiplier_overflowed = m_multiplier_overflowed || (maxv/10 < m_multiplier); - m_multiplier = static_cast<T>(m_multiplier * 10); - - T const dig_value = static_cast<T>(*m_end - czero); - T const new_sub_value = static_cast<T>(m_multiplier * dig_value); - - // We must correctly handle situations like `000000000000000000000000000001`. - // So we take care of overflow only if `dig_value` is not '0'. - if (*m_end < czero || *m_end >= czero + 10 // checking for correct digit - || (dig_value && ( // checking for overflow of ... - m_multiplier_overflowed // ... multiplier - || static_cast<T>(maxv / dig_value) < m_multiplier // ... subvalue - || static_cast<T>(maxv - new_sub_value) < m_value // ... whole expression - )) - ) return false; - - m_value = static_cast<T>(m_value + new_sub_value); - - return true; - } - - bool main_convert_loop() BOOST_NOEXCEPT { - for ( ; m_end >= m_begin; --m_end) { - if (!main_convert_itaration()) { - return false; - } - } - - return true; - } - }; - } - - namespace detail - { - template <class CharT> - bool lc_iequal(const CharT* val, const CharT* lcase, const CharT* ucase, unsigned int len) BOOST_NOEXCEPT { - for( unsigned int i=0; i < len; ++i ) { - if ( val[i] != lcase[i] && val[i] != ucase[i] ) return false; - } - - return true; - } - - /* Returns true and sets the correct value if found NaN or Inf. */ - template <class CharT, class T> - inline bool parse_inf_nan_impl(const CharT* begin, const CharT* end, T& value - , const CharT* lc_NAN, const CharT* lc_nan - , const CharT* lc_INFINITY, const CharT* lc_infinity - , const CharT opening_brace, const CharT closing_brace) BOOST_NOEXCEPT - { - using namespace std; - if (begin == end) return false; - const CharT minus = lcast_char_constants<CharT>::minus; - const CharT plus = lcast_char_constants<CharT>::plus; - const int inifinity_size = 8; // == sizeof("infinity") - 1 - - /* Parsing +/- */ - bool const has_minus = (*begin == minus); - if (has_minus || *begin == plus) { - ++ begin; - } - - if (end - begin < 3) return false; - if (lc_iequal(begin, lc_nan, lc_NAN, 3)) { - begin += 3; - if (end != begin) { - /* It is 'nan(...)' or some bad input*/ - - if (end - begin < 2) return false; // bad input - -- end; - if (*begin != opening_brace || *end != closing_brace) return false; // bad input - } - - if( !has_minus ) value = std::numeric_limits<T>::quiet_NaN(); - else value = (boost::math::changesign) (std::numeric_limits<T>::quiet_NaN()); - return true; - } else if ( - ( /* 'INF' or 'inf' */ - end - begin == 3 // 3 == sizeof('inf') - 1 - && lc_iequal(begin, lc_infinity, lc_INFINITY, 3) - ) - || - ( /* 'INFINITY' or 'infinity' */ - end - begin == inifinity_size - && lc_iequal(begin, lc_infinity, lc_INFINITY, inifinity_size) - ) - ) - { - if( !has_minus ) value = std::numeric_limits<T>::infinity(); - else value = (boost::math::changesign) (std::numeric_limits<T>::infinity()); - return true; - } - - return false; - } - - template <class CharT, class T> - bool put_inf_nan_impl(CharT* begin, CharT*& end, const T& value - , const CharT* lc_nan - , const CharT* lc_infinity) BOOST_NOEXCEPT - { - using namespace std; - const CharT minus = lcast_char_constants<CharT>::minus; - if ((boost::math::isnan)(value)) { - if ((boost::math::signbit)(value)) { - *begin = minus; - ++ begin; - } - - memcpy(begin, lc_nan, 3 * sizeof(CharT)); - end = begin + 3; - return true; - } else if ((boost::math::isinf)(value)) { - if ((boost::math::signbit)(value)) { - *begin = minus; - ++ begin; - } - - memcpy(begin, lc_infinity, 3 * sizeof(CharT)); - end = begin + 3; - return true; - } - - return false; - } - - -#ifndef BOOST_LCAST_NO_WCHAR_T - template <class T> - bool parse_inf_nan(const wchar_t* begin, const wchar_t* end, T& value) BOOST_NOEXCEPT { - return parse_inf_nan_impl(begin, end, value - , L"NAN", L"nan" - , L"INFINITY", L"infinity" - , L'(', L')'); - } - - template <class T> - bool put_inf_nan(wchar_t* begin, wchar_t*& end, const T& value) BOOST_NOEXCEPT { - return put_inf_nan_impl(begin, end, value, L"nan", L"infinity"); - } - -#endif -#if !defined(BOOST_NO_CXX11_CHAR16_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS) - template <class T> - bool parse_inf_nan(const char16_t* begin, const char16_t* end, T& value) BOOST_NOEXCEPT { - return parse_inf_nan_impl(begin, end, value - , u"NAN", u"nan" - , u"INFINITY", u"infinity" - , u'(', u')'); - } - - template <class T> - bool put_inf_nan(char16_t* begin, char16_t*& end, const T& value) BOOST_NOEXCEPT { - return put_inf_nan_impl(begin, end, value, u"nan", u"infinity"); - } -#endif -#if !defined(BOOST_NO_CXX11_CHAR32_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS) - template <class T> - bool parse_inf_nan(const char32_t* begin, const char32_t* end, T& value) BOOST_NOEXCEPT { - return parse_inf_nan_impl(begin, end, value - , U"NAN", U"nan" - , U"INFINITY", U"infinity" - , U'(', U')'); - } - - template <class T> - bool put_inf_nan(char32_t* begin, char32_t*& end, const T& value) BOOST_NOEXCEPT { - return put_inf_nan_impl(begin, end, value, U"nan", U"infinity"); - } -#endif - - template <class CharT, class T> - bool parse_inf_nan(const CharT* begin, const CharT* end, T& value) BOOST_NOEXCEPT { - return parse_inf_nan_impl(begin, end, value - , "NAN", "nan" - , "INFINITY", "infinity" - , '(', ')'); - } - - template <class CharT, class T> - bool put_inf_nan(CharT* begin, CharT*& end, const T& value) BOOST_NOEXCEPT { - return put_inf_nan_impl(begin, end, value, "nan", "infinity"); - } - } - - - namespace detail // lcast_ret_float - { - -// Silence buggy MS warnings like C4244: '+=' : conversion from 'int' to 'unsigned short', possible loss of data -#if defined(_MSC_VER) && (_MSC_VER == 1400) -# pragma warning(push) -# pragma warning(disable:4244) -#endif - template <class T> - struct mantissa_holder_type - { - /* Can not be used with this type */ - }; - - template <> - struct mantissa_holder_type<float> - { - typedef unsigned int type; - typedef double wide_result_t; - }; - - template <> - struct mantissa_holder_type<double> - { -#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS - typedef long double wide_result_t; -#if defined(BOOST_HAS_LONG_LONG) - typedef boost::ulong_long_type type; -#elif defined(BOOST_HAS_MS_INT64) - typedef unsigned __int64 type; -#endif -#endif - }; - - template<class Traits, class T, class CharT> - inline bool lcast_ret_float(T& value, const CharT* begin, const CharT* const end) - { - value = static_cast<T>(0); - if (begin == end) return false; - if (parse_inf_nan(begin, end, value)) return true; - - CharT const czero = lcast_char_constants<CharT>::zero; - CharT const minus = lcast_char_constants<CharT>::minus; - CharT const plus = lcast_char_constants<CharT>::plus; - CharT const capital_e = lcast_char_constants<CharT>::capital_e; - CharT const lowercase_e = lcast_char_constants<CharT>::lowercase_e; - - /* Getting the plus/minus sign */ - bool const has_minus = Traits::eq(*begin, minus); - if (has_minus || Traits::eq(*begin, plus)) { - ++ begin; - if (begin == end) return false; - } - -#ifndef BOOST_LEXICAL_CAST_ASSUME_C_LOCALE - std::locale loc; - typedef std::numpunct<CharT> numpunct; - numpunct const& np = BOOST_USE_FACET(numpunct, loc); - std::string const grouping( - (loc == std::locale::classic()) - ? std::string() - : np.grouping() - ); - std::string::size_type const grouping_size = grouping.size(); - CharT const thousands_sep = static_cast<CharT>(grouping_size ? np.thousands_sep() : 0); - CharT const decimal_point = np.decimal_point(); - bool found_grouping = false; - std::string::size_type last_grouping_pos = grouping_size - 1; -#else - CharT const decimal_point = lcast_char_constants<CharT>::c_decimal_separator; -#endif - - bool found_decimal = false; - bool found_number_before_exp = false; - typedef int pow_of_10_t; - pow_of_10_t pow_of_10 = 0; - - typedef BOOST_DEDUCED_TYPENAME mantissa_holder_type<T>::type mantissa_type; - mantissa_type mantissa=0; - bool is_mantissa_full = false; - char length_since_last_delim = 0; - - while (begin != end) { - if (found_decimal) { - /* We allow no thousand_separators after decimal point */ - - const mantissa_type tmp_sub_value = static_cast<mantissa_type>(*begin - czero); - if (Traits::eq(*begin, lowercase_e) || Traits::eq(*begin, capital_e)) break; - if ( *begin < czero || *begin >= czero + 10 ) return false; - if ( is_mantissa_full - || ((std::numeric_limits<mantissa_type>::max)() - tmp_sub_value) / 10u < mantissa - ) { - is_mantissa_full = true; - ++ begin; - continue; - } - - -- pow_of_10; - mantissa = static_cast<mantissa_type>(mantissa * 10 + tmp_sub_value); - - found_number_before_exp = true; - } else { - - if (*begin >= czero && *begin < czero + 10) { - - /* Checking for mantissa overflow. If overflow will - * occur, them we only increase multiplyer - */ - const mantissa_type tmp_sub_value = static_cast<mantissa_type>(*begin - czero); - if( is_mantissa_full - || ((std::numeric_limits<mantissa_type>::max)() - tmp_sub_value) / 10u < mantissa - ) - { - is_mantissa_full = true; - ++ pow_of_10; - } else { - mantissa = static_cast<mantissa_type>(mantissa * 10 + tmp_sub_value); - } - - found_number_before_exp = true; - ++ length_since_last_delim; - } else if (Traits::eq(*begin, decimal_point) || Traits::eq(*begin, lowercase_e) || Traits::eq(*begin, capital_e)) { -#ifndef BOOST_LEXICAL_CAST_ASSUME_C_LOCALE - /* If ( we need to check grouping - * and ( grouping missmatches - * or grouping position is incorrect - * or we are using the grouping position 0 twice - * ) - * ) then return error - */ - if( grouping_size && found_grouping - && ( - length_since_last_delim != grouping[0] - || last_grouping_pos>1 - || (last_grouping_pos==0 && grouping_size>1) - ) - ) return false; -#endif - - if (Traits::eq(*begin, decimal_point)) { - ++ begin; - found_decimal = true; - if (!found_number_before_exp && begin==end) return false; - continue; - } else { - if (!found_number_before_exp) return false; - break; - } - } -#ifndef BOOST_LEXICAL_CAST_ASSUME_C_LOCALE - else if (grouping_size && Traits::eq(*begin, thousands_sep)){ - if(found_grouping) - { - /* It is not he first time, when we find thousands separator, - * so we need to chek, is the distance between two groupings - * equal to grouping[last_grouping_pos] */ - - if (length_since_last_delim != grouping[last_grouping_pos] ) - { - if (!last_grouping_pos) return false; - else - { - -- last_grouping_pos; - if (length_since_last_delim != grouping[last_grouping_pos]) return false; - } - } else - /* We are calling the grouping[0] twice, when grouping size is more than 1 */ - if (grouping_size>1u && last_grouping_pos+1<grouping_size) return false; - - } else { - /* Delimiter at the begining ',000' */ - if (!length_since_last_delim) return false; - - found_grouping = true; - if (length_since_last_delim > grouping[last_grouping_pos] ) return false; - } - - length_since_last_delim = 0; - ++ begin; - - /* Delimiter at the end '100,' */ - if (begin == end) return false; - continue; - } -#endif - else return false; - } - - ++begin; - } - - // Exponent found - if (begin != end && (Traits::eq(*begin, lowercase_e) || Traits::eq(*begin, capital_e))) { - ++ begin; - if (begin == end) return false; - - bool const exp_has_minus = Traits::eq(*begin, minus); - if (exp_has_minus || Traits::eq(*begin, plus)) { - ++ begin; - if (begin == end) return false; - } - - pow_of_10_t exp_pow_of_10 = 0; - while (begin != end) { - pow_of_10_t const sub_value = *begin - czero; - - if ( *begin < czero || *begin >= czero + 10 - || ((std::numeric_limits<pow_of_10_t>::max)() - sub_value) / 10 < exp_pow_of_10) - return false; - - exp_pow_of_10 *= 10; - exp_pow_of_10 += sub_value; - ++ begin; - }; - - if (exp_has_minus) { - if ((std::numeric_limits<pow_of_10_t>::min)() + exp_pow_of_10 > pow_of_10) - return false; // failed overflow check - pow_of_10 -= exp_pow_of_10; - } else { - if ((std::numeric_limits<pow_of_10_t>::max)() - exp_pow_of_10 < pow_of_10) - return false; // failed overflow check - pow_of_10 += exp_pow_of_10; - } - } - - /* We need a more accurate algorithm... We can not use current algorithm - * with long doubles (and with doubles if sizeof(double)==sizeof(long double)). - */ - typedef BOOST_DEDUCED_TYPENAME mantissa_holder_type<T>::wide_result_t wide_result_t; - const wide_result_t result = std::pow(static_cast<wide_result_t>(10.0), pow_of_10) * mantissa; - value = static_cast<T>( has_minus ? (boost::math::changesign)(result) : result); - - return !((boost::math::isinf)(value) || (boost::math::isnan)(value)); - } -// Unsilence buggy MS warnings like C4244: '+=' : conversion from 'int' to 'unsigned short', possible loss of data -#if defined(_MSC_VER) && (_MSC_VER == 1400) -# pragma warning(pop) -#endif - } - - namespace detail // basic_unlockedbuf - { - // acts as a stream buffer which wraps around a pair of pointers - // and gives acces to internals - template <class BufferType, class CharT> - class basic_unlockedbuf : public basic_pointerbuf<CharT, BufferType> { - public: - typedef basic_pointerbuf<CharT, BufferType> base_type; - typedef BOOST_DEDUCED_TYPENAME base_type::streamsize streamsize; - -#ifndef BOOST_NO_USING_TEMPLATE - using base_type::pptr; - using base_type::pbase; - using base_type::setbuf; -#else - charT* pptr() const { return base_type::pptr(); } - charT* pbase() const { return base_type::pbase(); } - BufferType* setbuf(char_type* s, streamsize n) { return base_type::setbuf(s, n); } -#endif - }; - } - - namespace detail - { - struct do_not_construct_out_stream_t{}; - - template <class CharT, class Traits> - struct out_stream_helper_trait { -#if defined(BOOST_NO_STRINGSTREAM) - typedef std::ostrstream out_stream_t; - typedef void buffer_t; -#elif defined(BOOST_NO_STD_LOCALE) - typedef std::ostringstream out_stream_t; - typedef basic_unlockedbuf<std::streambuf, char> buffer_t; -#else - typedef std::basic_ostringstream<CharT, Traits> - out_stream_t; - typedef basic_unlockedbuf<std::basic_streambuf<CharT, Traits>, CharT> - buffer_t; -#endif - }; - } - - namespace detail // optimized stream wrappers - { - template< class CharT // a result of widest_char transformation - , class Traits - , bool RequiresStringbuffer - , std::size_t CharacterBufferSize - > - class lexical_istream_limited_src: boost::noncopyable { - typedef BOOST_DEDUCED_TYPENAME out_stream_helper_trait<CharT, Traits>::buffer_t - buffer_t; - - typedef BOOST_DEDUCED_TYPENAME out_stream_helper_trait<CharT, Traits>::out_stream_t - out_stream_t; - - typedef BOOST_DEDUCED_TYPENAME boost::mpl::if_c< - RequiresStringbuffer, - out_stream_t, - do_not_construct_out_stream_t - >::type deduced_out_stream_t; - - // A string representation of Source is written to `buffer`. - deduced_out_stream_t out_stream; - CharT buffer[CharacterBufferSize]; - - // After the `operator <<` finishes, `[start, finish)` is - // the range to output by `operator >>` - const CharT* start; - const CharT* finish; - - public: - lexical_istream_limited_src() BOOST_NOEXCEPT - : start(buffer) - , finish(buffer + CharacterBufferSize) - {} - - const CharT* cbegin() const BOOST_NOEXCEPT { - return start; - } - - const CharT* cend() const BOOST_NOEXCEPT { - return finish; - } - - private: - // Undefined: - lexical_istream_limited_src(lexical_istream_limited_src const&); - void operator=(lexical_istream_limited_src const&); - -/************************************ HELPER FUNCTIONS FOR OPERATORS << ( ... ) ********************************/ - bool shl_char(CharT ch) BOOST_NOEXCEPT { - Traits::assign(buffer[0], ch); - finish = start + 1; - return true; - } - -#ifndef BOOST_LCAST_NO_WCHAR_T - template <class T> - bool shl_char(T ch) { - BOOST_STATIC_ASSERT_MSG(( sizeof(T) <= sizeof(CharT)) , - "boost::lexical_cast does not support narrowing of char types." - "Use boost::locale instead" ); -#ifndef BOOST_LEXICAL_CAST_ASSUME_C_LOCALE - std::locale loc; - CharT const w = BOOST_USE_FACET(std::ctype<CharT>, loc).widen(ch); -#else - CharT const w = static_cast<CharT>(ch); -#endif - Traits::assign(buffer[0], w); - finish = start + 1; - return true; - } -#endif - - bool shl_char_array(CharT const* str) BOOST_NOEXCEPT { - start = str; - finish = start + Traits::length(str); - return true; - } - - template <class T> - bool shl_char_array(T const* str) { - BOOST_STATIC_ASSERT_MSG(( sizeof(T) <= sizeof(CharT)), - "boost::lexical_cast does not support narrowing of char types." - "Use boost::locale instead" ); - return shl_input_streamable(str); - } - - bool shl_char_array_limited(CharT const* str, std::size_t max_size) BOOST_NOEXCEPT { - start = str; - finish = std::find(start, start + max_size, Traits::to_char_type(0)); - return true; - } - - template<typename InputStreamable> - bool shl_input_streamable(InputStreamable& input) { -#if defined(BOOST_NO_STRINGSTREAM) || defined(BOOST_NO_STD_LOCALE) - // If you have compilation error at this point, than your STL library - // does not support such conversions. Try updating it. - BOOST_STATIC_ASSERT((boost::is_same<char, CharT>::value)); -#endif - -#ifndef BOOST_NO_EXCEPTIONS - out_stream.exceptions(std::ios::badbit); - try { -#endif - bool const result = !(out_stream << input).fail(); - const buffer_t* const p = static_cast<buffer_t*>( - static_cast<std::basic_streambuf<CharT, Traits>*>(out_stream.rdbuf()) - ); - start = p->pbase(); - finish = p->pptr(); - return result; -#ifndef BOOST_NO_EXCEPTIONS - } catch (const ::std::ios_base::failure& /*f*/) { - return false; - } -#endif - } - - template <class T> - inline bool shl_unsigned(const T n) { - CharT* tmp_finish = buffer + CharacterBufferSize; - start = lcast_put_unsigned<Traits, T, CharT>(n, tmp_finish).convert(); - finish = tmp_finish; - return true; - } - - template <class T> - inline bool shl_signed(const T n) { - CharT* tmp_finish = buffer + CharacterBufferSize; - typedef BOOST_DEDUCED_TYPENAME boost::make_unsigned<T>::type utype; - CharT* tmp_start = lcast_put_unsigned<Traits, utype, CharT>(lcast_to_unsigned(n), tmp_finish).convert(); - if (n < 0) { - --tmp_start; - CharT const minus = lcast_char_constants<CharT>::minus; - Traits::assign(*tmp_start, minus); - } - start = tmp_start; - finish = tmp_finish; - return true; - } - - template <class T, class SomeCharT> - bool shl_real_type(const T& val, SomeCharT* /*begin*/) { - lcast_set_precision(out_stream, &val); - return shl_input_streamable(val); - } - - bool shl_real_type(float val, char* begin) { - using namespace std; - const double val_as_double = val; - finish = start + -#if defined(_MSC_VER) && (_MSC_VER >= 1400) && !defined(__SGI_STL_PORT) && !defined(_STLPORT_VERSION) - sprintf_s(begin, CharacterBufferSize, -#else - sprintf(begin, -#endif - "%.*g", static_cast<int>(boost::detail::lcast_get_precision<float>()), val_as_double); - return finish > start; - } - - bool shl_real_type(double val, char* begin) { - using namespace std; - finish = start + -#if defined(_MSC_VER) && (_MSC_VER >= 1400) && !defined(__SGI_STL_PORT) && !defined(_STLPORT_VERSION) - sprintf_s(begin, CharacterBufferSize, -#else - sprintf(begin, -#endif - "%.*g", static_cast<int>(boost::detail::lcast_get_precision<double>()), val); - return finish > start; - } - -#ifndef __MINGW32__ - bool shl_real_type(long double val, char* begin) { - using namespace std; - finish = start + -#if defined(_MSC_VER) && (_MSC_VER >= 1400) && !defined(__SGI_STL_PORT) && !defined(_STLPORT_VERSION) - sprintf_s(begin, CharacterBufferSize, -#else - sprintf(begin, -#endif - "%.*Lg", static_cast<int>(boost::detail::lcast_get_precision<long double>()), val ); - return finish > start; - } -#endif - - -#if !defined(BOOST_LCAST_NO_WCHAR_T) && !defined(BOOST_NO_SWPRINTF) && !defined(__MINGW32__) - bool shl_real_type(float val, wchar_t* begin) { - using namespace std; - const double val_as_double = val; - finish = start + swprintf(begin, CharacterBufferSize, - L"%.*g", - static_cast<int>(boost::detail::lcast_get_precision<float >()), - val_as_double ); - return finish > start; - } - - bool shl_real_type(double val, wchar_t* begin) { - using namespace std; - finish = start + swprintf(begin, CharacterBufferSize, - L"%.*g", static_cast<int>(boost::detail::lcast_get_precision<double >()), val ); - return finish > start; - } - - bool shl_real_type(long double val, wchar_t* begin) { - using namespace std; - finish = start + swprintf(begin, CharacterBufferSize, - L"%.*Lg", static_cast<int>(boost::detail::lcast_get_precision<long double >()), val ); - return finish > start; - } -#endif - template <class T> - bool shl_real(T val) { - CharT* tmp_finish = buffer + CharacterBufferSize; - if (put_inf_nan(buffer, tmp_finish, val)) { - finish = tmp_finish; - return true; - } - - return shl_real_type(val, static_cast<CharT*>(buffer)); - } - -/************************************ OPERATORS << ( ... ) ********************************/ - public: - template<class Alloc> - bool operator<<(std::basic_string<CharT,Traits,Alloc> const& str) BOOST_NOEXCEPT { - start = str.data(); - finish = start + str.length(); - return true; - } - - template<class Alloc> - bool operator<<(boost::container::basic_string<CharT,Traits,Alloc> const& str) BOOST_NOEXCEPT { - start = str.data(); - finish = start + str.length(); - return true; - } - - bool operator<<(bool value) BOOST_NOEXCEPT { - CharT const czero = lcast_char_constants<CharT>::zero; - Traits::assign(buffer[0], Traits::to_char_type(czero + value)); - finish = start + 1; - return true; - } - - template <class C> - BOOST_DEDUCED_TYPENAME boost::disable_if<boost::is_const<C>, bool>::type - operator<<(const iterator_range<C*>& rng) BOOST_NOEXCEPT { - return (*this) << iterator_range<const C*>(rng.begin(), rng.end()); - } - - bool operator<<(const iterator_range<const CharT*>& rng) BOOST_NOEXCEPT { - start = rng.begin(); - finish = rng.end(); - return true; - } - - bool operator<<(const iterator_range<const signed char*>& rng) BOOST_NOEXCEPT { - return (*this) << iterator_range<const char*>( - reinterpret_cast<const char*>(rng.begin()), - reinterpret_cast<const char*>(rng.end()) - ); - } - - bool operator<<(const iterator_range<const unsigned char*>& rng) BOOST_NOEXCEPT { - return (*this) << iterator_range<const char*>( - reinterpret_cast<const char*>(rng.begin()), - reinterpret_cast<const char*>(rng.end()) - ); - } - - bool operator<<(char ch) { return shl_char(ch); } - bool operator<<(unsigned char ch) { return ((*this) << static_cast<char>(ch)); } - bool operator<<(signed char ch) { return ((*this) << static_cast<char>(ch)); } -#if !defined(BOOST_LCAST_NO_WCHAR_T) - bool operator<<(wchar_t const* str) { return shl_char_array(str); } - bool operator<<(wchar_t * str) { return shl_char_array(str); } -#ifndef BOOST_NO_INTRINSIC_WCHAR_T - bool operator<<(wchar_t ch) { return shl_char(ch); } -#endif -#endif -#if !defined(BOOST_NO_CXX11_CHAR16_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS) - bool operator<<(char16_t ch) { return shl_char(ch); } - bool operator<<(char16_t * str) { return shl_char_array(str); } - bool operator<<(char16_t const * str) { return shl_char_array(str); } -#endif -#if !defined(BOOST_NO_CXX11_CHAR32_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS) - bool operator<<(char32_t ch) { return shl_char(ch); } - bool operator<<(char32_t * str) { return shl_char_array(str); } - bool operator<<(char32_t const * str) { return shl_char_array(str); } -#endif - bool operator<<(unsigned char const* ch) { return ((*this) << reinterpret_cast<char const*>(ch)); } - bool operator<<(unsigned char * ch) { return ((*this) << reinterpret_cast<char *>(ch)); } - bool operator<<(signed char const* ch) { return ((*this) << reinterpret_cast<char const*>(ch)); } - bool operator<<(signed char * ch) { return ((*this) << reinterpret_cast<char *>(ch)); } - bool operator<<(char const* str) { return shl_char_array(str); } - bool operator<<(char* str) { return shl_char_array(str); } - bool operator<<(short n) { return shl_signed(n); } - bool operator<<(int n) { return shl_signed(n); } - bool operator<<(long n) { return shl_signed(n); } - bool operator<<(unsigned short n) { return shl_unsigned(n); } - bool operator<<(unsigned int n) { return shl_unsigned(n); } - bool operator<<(unsigned long n) { return shl_unsigned(n); } - -#if defined(BOOST_HAS_LONG_LONG) - bool operator<<(boost::ulong_long_type n) { return shl_unsigned(n); } - bool operator<<(boost::long_long_type n) { return shl_signed(n); } -#elif defined(BOOST_HAS_MS_INT64) - bool operator<<(unsigned __int64 n) { return shl_unsigned(n); } - bool operator<<( __int64 n) { return shl_signed(n); } -#endif - -#ifdef BOOST_HAS_INT128 - bool operator<<(const boost::uint128_type& n) { return shl_unsigned(n); } - bool operator<<(const boost::int128_type& n) { return shl_signed(n); } -#endif - bool operator<<(float val) { return shl_real(val); } - bool operator<<(double val) { return shl_real(val); } - bool operator<<(long double val) { -#ifndef __MINGW32__ - return shl_real(val); -#else - return shl_real(static_cast<double>(val)); -#endif - } - - // Adding constness to characters. Constness does not change layout - template <class C, std::size_t N> - BOOST_DEDUCED_TYPENAME boost::disable_if<boost::is_const<C>, bool>::type - operator<<(boost::array<C, N> const& input) BOOST_NOEXCEPT { - BOOST_STATIC_ASSERT_MSG( - (sizeof(boost::array<const C, N>) == sizeof(boost::array<C, N>)), - "boost::array<C, N> and boost::array<const C, N> must have exactly the same layout." - ); - return ((*this) << reinterpret_cast<boost::array<const C, N> const& >(input)); - } - - template <std::size_t N> - bool operator<<(boost::array<const CharT, N> const& input) BOOST_NOEXCEPT { - return shl_char_array_limited(input.begin(), N); - } - - template <std::size_t N> - bool operator<<(boost::array<const unsigned char, N> const& input) BOOST_NOEXCEPT { - return ((*this) << reinterpret_cast<boost::array<const char, N> const& >(input)); - } - - template <std::size_t N> - bool operator<<(boost::array<const signed char, N> const& input) BOOST_NOEXCEPT { - return ((*this) << reinterpret_cast<boost::array<const char, N> const& >(input)); - } - -#ifndef BOOST_NO_CXX11_HDR_ARRAY - // Making a Boost.Array from std::array - template <class C, std::size_t N> - bool operator<<(std::array<C, N> const& input) BOOST_NOEXCEPT { - BOOST_STATIC_ASSERT_MSG( - (sizeof(std::array<C, N>) == sizeof(boost::array<C, N>)), - "std::array and boost::array must have exactly the same layout. " - "Bug in implementation of std::array or boost::array." - ); - return ((*this) << reinterpret_cast<boost::array<C, N> const& >(input)); - } -#endif - template <class InStreamable> - bool operator<<(const InStreamable& input) { return shl_input_streamable(input); } - }; - - - template <class CharT, class Traits> - class lexical_ostream_limited_src: boost::noncopyable { - //`[start, finish)` is the range to output by `operator >>` - const CharT* start; - const CharT* const finish; - - public: - lexical_ostream_limited_src(const CharT* begin, const CharT* end) BOOST_NOEXCEPT - : start(begin) - , finish(end) - {} - -/************************************ HELPER FUNCTIONS FOR OPERATORS >> ( ... ) ********************************/ - private: - template <typename Type> - bool shr_unsigned(Type& output) { - if (start == finish) return false; - CharT const minus = lcast_char_constants<CharT>::minus; - CharT const plus = lcast_char_constants<CharT>::plus; - bool const has_minus = Traits::eq(minus, *start); - - /* We won`t use `start' any more, so no need in decrementing it after */ - if (has_minus || Traits::eq(plus, *start)) { - ++start; - } - - bool const succeed = lcast_ret_unsigned<Traits, Type, CharT>(output, start, finish).convert(); - - if (has_minus) { - output = static_cast<Type>(0u - output); - } - - return succeed; - } - - template <typename Type> - bool shr_signed(Type& output) { - if (start == finish) return false; - CharT const minus = lcast_char_constants<CharT>::minus; - CharT const plus = lcast_char_constants<CharT>::plus; - typedef BOOST_DEDUCED_TYPENAME make_unsigned<Type>::type utype; - utype out_tmp = 0; - bool const has_minus = Traits::eq(minus, *start); - - /* We won`t use `start' any more, so no need in decrementing it after */ - if (has_minus || Traits::eq(plus, *start)) { - ++start; - } - - bool succeed = lcast_ret_unsigned<Traits, utype, CharT>(out_tmp, start, finish).convert(); - if (has_minus) { - utype const comp_val = (static_cast<utype>(1) << std::numeric_limits<Type>::digits); - succeed = succeed && out_tmp<=comp_val; - output = static_cast<Type>(0u - out_tmp); - } else { - utype const comp_val = static_cast<utype>((std::numeric_limits<Type>::max)()); - succeed = succeed && out_tmp<=comp_val; - output = static_cast<Type>(out_tmp); - } - return succeed; - } - - template<typename InputStreamable> - bool shr_using_base_class(InputStreamable& output) - { - BOOST_STATIC_ASSERT_MSG( - (!boost::is_pointer<InputStreamable>::value), - "boost::lexical_cast can not convert to pointers" - ); - -#if defined(BOOST_NO_STRINGSTREAM) || defined(BOOST_NO_STD_LOCALE) - BOOST_STATIC_ASSERT_MSG((boost::is_same<char, CharT>::value), - "boost::lexical_cast can not convert, because your STL library does not " - "support such conversions. Try updating it." - ); -#endif - typedef BOOST_DEDUCED_TYPENAME out_stream_helper_trait<CharT, Traits>::buffer_t - buffer_t; - -#if defined(BOOST_NO_STRINGSTREAM) - std::istrstream stream(start, finish - start); -#else - - buffer_t buf; - // Usually `istream` and `basic_istream` do not modify - // content of buffer; `buffer_t` assures that this is true - buf.setbuf(const_cast<CharT*>(start), finish - start); -#if defined(BOOST_NO_STD_LOCALE) - std::istream stream(&buf); -#else - std::basic_istream<CharT, Traits> stream(&buf); -#endif // BOOST_NO_STD_LOCALE -#endif // BOOST_NO_STRINGSTREAM - -#ifndef BOOST_NO_EXCEPTIONS - stream.exceptions(std::ios::badbit); - try { -#endif - stream.unsetf(std::ios::skipws); - lcast_set_precision(stream, static_cast<InputStreamable*>(0)); - - return (stream >> output) - && (stream.get() == Traits::eof()); - -#ifndef BOOST_NO_EXCEPTIONS - } catch (const ::std::ios_base::failure& /*f*/) { - return false; - } -#endif - } - - template<class T> - inline bool shr_xchar(T& output) BOOST_NOEXCEPT { - BOOST_STATIC_ASSERT_MSG(( sizeof(CharT) == sizeof(T) ), - "boost::lexical_cast does not support narrowing of character types." - "Use boost::locale instead" ); - bool const ok = (finish - start == 1); - if (ok) { - CharT out; - Traits::assign(out, *start); - output = static_cast<T>(out); - } - return ok; - } - - template <std::size_t N, class ArrayT> - bool shr_std_array(ArrayT& output) BOOST_NOEXCEPT { - using namespace std; - const std::size_t size = static_cast<std::size_t>(finish - start); - if (size > N - 1) { // `-1` because we need to store \0 at the end - return false; - } - - memcpy(&output[0], start, size * sizeof(CharT)); - output[size] = Traits::to_char_type(0); - return true; - } - -/************************************ OPERATORS >> ( ... ) ********************************/ - public: - bool operator>>(unsigned short& output) { return shr_unsigned(output); } - bool operator>>(unsigned int& output) { return shr_unsigned(output); } - bool operator>>(unsigned long int& output) { return shr_unsigned(output); } - bool operator>>(short& output) { return shr_signed(output); } - bool operator>>(int& output) { return shr_signed(output); } - bool operator>>(long int& output) { return shr_signed(output); } -#if defined(BOOST_HAS_LONG_LONG) - bool operator>>(boost::ulong_long_type& output) { return shr_unsigned(output); } - bool operator>>(boost::long_long_type& output) { return shr_signed(output); } -#elif defined(BOOST_HAS_MS_INT64) - bool operator>>(unsigned __int64& output) { return shr_unsigned(output); } - bool operator>>(__int64& output) { return shr_signed(output); } -#endif - -#ifdef BOOST_HAS_INT128 - bool operator>>(boost::uint128_type& output) { return shr_unsigned(output); } - bool operator>>(boost::int128_type& output) { return shr_signed(output); } -#endif - - bool operator>>(char& output) { return shr_xchar(output); } - bool operator>>(unsigned char& output) { return shr_xchar(output); } - bool operator>>(signed char& output) { return shr_xchar(output); } -#if !defined(BOOST_LCAST_NO_WCHAR_T) && !defined(BOOST_NO_INTRINSIC_WCHAR_T) - bool operator>>(wchar_t& output) { return shr_xchar(output); } -#endif -#if !defined(BOOST_NO_CXX11_CHAR16_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS) - bool operator>>(char16_t& output) { return shr_xchar(output); } -#endif -#if !defined(BOOST_NO_CXX11_CHAR32_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS) - bool operator>>(char32_t& output) { return shr_xchar(output); } -#endif - template<class Alloc> - bool operator>>(std::basic_string<CharT,Traits,Alloc>& str) { - str.assign(start, finish); return true; - } - - template<class Alloc> - bool operator>>(boost::container::basic_string<CharT,Traits,Alloc>& str) { - str.assign(start, finish); return true; - } - - template <std::size_t N> - bool operator>>(boost::array<CharT, N>& output) BOOST_NOEXCEPT { - return shr_std_array<N>(output); - } - - template <std::size_t N> - bool operator>>(boost::array<unsigned char, N>& output) BOOST_NOEXCEPT { - return ((*this) >> reinterpret_cast<boost::array<char, N>& >(output)); - } - - template <std::size_t N> - bool operator>>(boost::array<signed char, N>& output) BOOST_NOEXCEPT { - return ((*this) >> reinterpret_cast<boost::array<char, N>& >(output)); - } - -#ifndef BOOST_NO_CXX11_HDR_ARRAY - template <class C, std::size_t N> - bool operator>>(std::array<C, N>& output) BOOST_NOEXCEPT { - BOOST_STATIC_ASSERT_MSG( - (sizeof(boost::array<C, N>) == sizeof(boost::array<C, N>)), - "std::array<C, N> and boost::array<C, N> must have exactly the same layout." - ); - return ((*this) >> reinterpret_cast<boost::array<C, N>& >(output)); - } -#endif - - bool operator>>(bool& output) BOOST_NOEXCEPT { - output = false; // Suppress warning about uninitalized variable - - if (start == finish) return false; - CharT const zero = lcast_char_constants<CharT>::zero; - CharT const plus = lcast_char_constants<CharT>::plus; - CharT const minus = lcast_char_constants<CharT>::minus; - - const CharT* const dec_finish = finish - 1; - output = Traits::eq(*dec_finish, zero + 1); - if (!output && !Traits::eq(*dec_finish, zero)) { - return false; // Does not ends on '0' or '1' - } - - if (start == dec_finish) return true; - - // We may have sign at the beginning - if (Traits::eq(plus, *start) || (Traits::eq(minus, *start) && !output)) { - ++ start; - } - - // Skipping zeros - while (start != dec_finish) { - if (!Traits::eq(zero, *start)) { - return false; // Not a zero => error - } - - ++ start; - } - - return true; - } - - bool operator>>(float& output) { return lcast_ret_float<Traits>(output,start,finish); } - - private: - // Not optimised converter - template <class T> - bool float_types_converter_internal(T& output, int /*tag*/) { - if (parse_inf_nan(start, finish, output)) return true; - bool const return_value = shr_using_base_class(output); - - /* Some compilers and libraries successfully - * parse 'inf', 'INFINITY', '1.0E', '1.0E-'... - * We are trying to provide a unified behaviour, - * so we just forbid such conversions (as some - * of the most popular compilers/libraries do) - * */ - CharT const minus = lcast_char_constants<CharT>::minus; - CharT const plus = lcast_char_constants<CharT>::plus; - CharT const capital_e = lcast_char_constants<CharT>::capital_e; - CharT const lowercase_e = lcast_char_constants<CharT>::lowercase_e; - if ( return_value && - ( - Traits::eq(*(finish-1), lowercase_e) // 1.0e - || Traits::eq(*(finish-1), capital_e) // 1.0E - || Traits::eq(*(finish-1), minus) // 1.0e- or 1.0E- - || Traits::eq(*(finish-1), plus) // 1.0e+ or 1.0E+ - ) - ) return false; - - return return_value; - } - - // Optimised converter - bool float_types_converter_internal(double& output, char /*tag*/) { - return lcast_ret_float<Traits>(output, start, finish); - } - public: - - bool operator>>(double& output) { - /* - * Some compilers implement long double as double. In that case these types have - * same size, same precision, same max and min values... And it means, - * that current implementation of lcast_ret_float cannot be used for type - * double, because it will give a big precision loss. - * */ - boost::mpl::if_c< -#if (defined(BOOST_HAS_LONG_LONG) || defined(BOOST_HAS_MS_INT64)) && !defined(BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS) - boost::type_traits::ice_eq< sizeof(double), sizeof(long double) >::value, -#else - 1, -#endif - int, - char - >::type tag = 0; - - return float_types_converter_internal(output, tag); - } - - bool operator>>(long double& output) { - int tag = 0; - return float_types_converter_internal(output, tag); - } - - // Generic istream-based algorithm. - // lcast_streambuf_for_target<InputStreamable>::value is true. - template <typename InputStreamable> - bool operator>>(InputStreamable& output) { - return shr_using_base_class(output); - } - }; - } - - namespace detail - { - template<typename T> - struct is_stdstring - : boost::false_type - {}; - - template<typename CharT, typename Traits, typename Alloc> - struct is_stdstring< std::basic_string<CharT, Traits, Alloc> > - : boost::true_type - {}; - - template<typename CharT, typename Traits, typename Alloc> - struct is_stdstring< boost::container::basic_string<CharT, Traits, Alloc> > - : boost::true_type - {}; - - template<typename Target, typename Source> - struct is_arithmetic_and_not_xchars - { - BOOST_STATIC_CONSTANT(bool, value = ( - boost::type_traits::ice_and< - boost::type_traits::ice_not< - boost::detail::is_character<Target>::value - >::value, - boost::type_traits::ice_not< - boost::detail::is_character<Source>::value - >::value, - boost::is_arithmetic<Source>::value, - boost::is_arithmetic<Target>::value - >::value - )); - }; - - /* - * is_xchar_to_xchar<Target, Source>::value is true, - * Target and Souce are char types of the same size 1 (char, signed char, unsigned char). - */ - template<typename Target, typename Source> - struct is_xchar_to_xchar - { - BOOST_STATIC_CONSTANT(bool, value = ( - boost::type_traits::ice_and< - boost::type_traits::ice_eq<sizeof(Source), sizeof(Target)>::value, - boost::type_traits::ice_eq<sizeof(Source), sizeof(char)>::value, - boost::detail::is_character<Target>::value, - boost::detail::is_character<Source>::value - >::value - )); - }; - - template<typename Target, typename Source> - struct is_char_array_to_stdstring - : boost::false_type - {}; - - template<typename CharT, typename Traits, typename Alloc> - struct is_char_array_to_stdstring< std::basic_string<CharT, Traits, Alloc>, CharT* > - : boost::true_type - {}; - - template<typename CharT, typename Traits, typename Alloc> - struct is_char_array_to_stdstring< std::basic_string<CharT, Traits, Alloc>, const CharT* > - : boost::true_type - {}; - - template<typename CharT, typename Traits, typename Alloc> - struct is_char_array_to_stdstring< boost::container::basic_string<CharT, Traits, Alloc>, CharT* > - : boost::true_type - {}; - - template<typename CharT, typename Traits, typename Alloc> - struct is_char_array_to_stdstring< boost::container::basic_string<CharT, Traits, Alloc>, const CharT* > - : boost::true_type - {}; - - template<typename Target, typename Source> - struct lexical_converter_impl - { - typedef lexical_cast_stream_traits<Source, Target> stream_trait; - - typedef detail::lexical_istream_limited_src< - BOOST_DEDUCED_TYPENAME stream_trait::char_type, - BOOST_DEDUCED_TYPENAME stream_trait::traits, - stream_trait::requires_stringbuf, - stream_trait::len_t::value + 1 - > i_interpreter_type; - - typedef detail::lexical_ostream_limited_src< - BOOST_DEDUCED_TYPENAME stream_trait::char_type, - BOOST_DEDUCED_TYPENAME stream_trait::traits - > o_interpreter_type; - - static inline bool try_convert(const Source& arg, Target& result) { - i_interpreter_type i_interpreter; - - // Disabling ADL, by directly specifying operators. - if (!(i_interpreter.operator <<(arg))) - return false; - - o_interpreter_type out(i_interpreter.cbegin(), i_interpreter.cend()); - - // Disabling ADL, by directly specifying operators. - if(!(out.operator >>(result))) - return false; - - return true; - } - }; - - template <typename Target, typename Source> - struct copy_converter_impl - { -// MSVC fail to forward an array (DevDiv#555157 "SILENT BAD CODEGEN triggered by perfect forwarding", -// fixed in 2013 RTM). -#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && (!defined(BOOST_MSVC) || BOOST_MSVC >= 1800) - template <class T> - static inline bool try_convert(T&& arg, Target& result) { - result = static_cast<T&&>(arg); // eqaul to `result = std::forward<T>(arg);` - return true; - } -#else - static inline bool try_convert(const Source& arg, Target& result) { - result = arg; - return true; - } -#endif - }; - - template <class Source > - struct detect_precision_loss - { - typedef Source source_type; - typedef boost::numeric::Trunc<Source> Rounder; - typedef BOOST_DEDUCED_TYPENAME mpl::if_< - boost::is_arithmetic<Source>, Source, Source const& - >::type argument_type ; - - static inline source_type nearbyint(argument_type s, bool& is_ok) BOOST_NOEXCEPT { - const source_type near_int = Rounder::nearbyint(s); - if (near_int && is_ok) { - const source_type orig_div_round = s / near_int; - const source_type eps = std::numeric_limits<source_type>::epsilon(); - - is_ok = !((orig_div_round > 1 ? orig_div_round - 1 : 1 - orig_div_round) > eps); - } - - return s; - } - - typedef typename Rounder::round_style round_style; - }; - - template <typename Base, class Source> - struct fake_precision_loss: public Base - { - typedef Source source_type ; - typedef BOOST_DEDUCED_TYPENAME mpl::if_< - boost::is_arithmetic<Source>, Source, Source const& - >::type argument_type ; - - static inline source_type nearbyint(argument_type s, bool& /*is_ok*/) BOOST_NOEXCEPT { - return s; - } - }; - - struct nothrow_overflow_handler - { - inline bool operator() ( boost::numeric::range_check_result r ) const BOOST_NOEXCEPT { - return (r == boost::numeric::cInRange); - } - }; - - template <typename Target, typename Source> - inline bool noexcept_numeric_convert(const Source& arg, Target& result) BOOST_NOEXCEPT { - typedef boost::numeric::converter< - Target, - Source, - boost::numeric::conversion_traits<Target, Source >, - nothrow_overflow_handler, - detect_precision_loss<Source > - > converter_orig_t; - - typedef BOOST_DEDUCED_TYPENAME boost::mpl::if_c< - boost::is_base_of< detect_precision_loss<Source >, converter_orig_t >::value, - converter_orig_t, - fake_precision_loss<converter_orig_t, Source> - >::type converter_t; - - bool res = nothrow_overflow_handler()(converter_t::out_of_range(arg)); - result = converter_t::low_level_convert(converter_t::nearbyint(arg, res)); - return res; - } - - template <typename Target, typename Source> - struct lexical_cast_dynamic_num_not_ignoring_minus - { - static inline bool try_convert(const Source &arg, Target& result) BOOST_NOEXCEPT { - return noexcept_numeric_convert<Target, Source >(arg, result); - } - }; - - template <typename Target, typename Source> - struct lexical_cast_dynamic_num_ignoring_minus - { - static inline bool try_convert(const Source &arg, Target& result) BOOST_NOEXCEPT { - typedef BOOST_DEDUCED_TYPENAME boost::mpl::eval_if_c< - boost::is_float<Source>::value, - boost::mpl::identity<Source>, - boost::make_unsigned<Source> - >::type usource_t; - - if (arg < 0) { - const bool res = noexcept_numeric_convert<Target, usource_t>(0u - arg, result); - result = static_cast<Target>(0u - result); - return res; - } else { - return noexcept_numeric_convert<Target, usource_t>(arg, result); - } - } - }; - - /* - * lexical_cast_dynamic_num follows the rules: - * 1) If Source can be converted to Target without precision loss and - * without overflows, then assign Source to Target and return - * - * 2) If Source is less than 0 and Target is an unsigned integer, - * then negate Source, check the requirements of rule 1) and if - * successful, assign static_casted Source to Target and return - * - * 3) Otherwise throw a bad_lexical_cast exception - * - * - * Rule 2) required because boost::lexical_cast has the behavior of - * stringstream, which uses the rules of scanf for conversions. And - * in the C99 standard for unsigned input value minus sign is - * optional, so if a negative number is read, no errors will arise - * and the result will be the two's complement. - */ - template <typename Target, typename Source> - struct dynamic_num_converter_impl - { - static inline bool try_convert(const Source &arg, Target& result) BOOST_NOEXCEPT { - typedef BOOST_DEDUCED_TYPENAME boost::mpl::if_c< - boost::type_traits::ice_and< - boost::is_unsigned<Target>::value, - boost::type_traits::ice_or< - boost::is_signed<Source>::value, - boost::is_float<Source>::value - >::value, - boost::type_traits::ice_not< - boost::is_same<Source, bool>::value - >::value, - boost::type_traits::ice_not< - boost::is_same<Target, bool>::value - >::value - >::value, - lexical_cast_dynamic_num_ignoring_minus<Target, Source>, - lexical_cast_dynamic_num_not_ignoring_minus<Target, Source> - >::type caster_type; - - return caster_type::try_convert(arg, result); - } - }; - } - - namespace conversion { namespace detail { - - template <typename Target, typename Source> - inline bool try_lexical_convert(const Source& arg, Target& result) - { - typedef BOOST_DEDUCED_TYPENAME boost::detail::array_to_pointer_decay<Source>::type src; - - typedef BOOST_DEDUCED_TYPENAME boost::type_traits::ice_or< - boost::detail::is_xchar_to_xchar<Target, src >::value, - boost::detail::is_char_array_to_stdstring<Target, src >::value, - boost::type_traits::ice_and< - boost::is_same<Target, src >::value, - boost::detail::is_stdstring<Target >::value - >::value, - boost::type_traits::ice_and< - boost::is_same<Target, src >::value, - boost::detail::is_character<Target >::value - >::value - > shall_we_copy_t; - - typedef boost::detail::is_arithmetic_and_not_xchars<Target, src > - shall_we_copy_with_dynamic_check_t; - - // We do evaluate second `if_` lazily to avoid unnecessary instantiations - // of `shall_we_copy_with_dynamic_check_t` and improve compilation times. - typedef BOOST_DEDUCED_TYPENAME boost::mpl::if_c< - shall_we_copy_t::value, - boost::mpl::identity<boost::detail::copy_converter_impl<Target, src > >, - boost::mpl::if_< - shall_we_copy_with_dynamic_check_t, - boost::detail::dynamic_num_converter_impl<Target, src >, - boost::detail::lexical_converter_impl<Target, src > - > - >::type caster_type_lazy; - - typedef BOOST_DEDUCED_TYPENAME caster_type_lazy::type caster_type; - - return caster_type::try_convert(arg, result); - } - - template <typename Target, typename CharacterT> - inline bool try_lexical_convert(const CharacterT* chars, std::size_t count, Target& result) - { - BOOST_STATIC_ASSERT_MSG( - boost::detail::is_character<CharacterT>::value, - "This overload of try_lexical_convert is meant to be used only with arrays of characters." - ); - return ::boost::conversion::detail::try_lexical_convert( - ::boost::iterator_range<const CharacterT*>(chars, chars + count), result - ); - } - - }} // namespace conversion::detail - - namespace conversion { - // ADL barrier - using ::boost::conversion::detail::try_lexical_convert; - } - - template <typename Target, typename Source> - inline Target lexical_cast(const Source &arg) - { - boost::value_initialized<Target> result; - - if (!boost::conversion::detail::try_lexical_convert(arg, get(result))) - BOOST_LCAST_THROW_BAD_CAST(Source, Target); - - return get(result); - } - - template <typename Target> - inline Target lexical_cast(const char* chars, std::size_t count) - { - return ::boost::lexical_cast<Target>( - ::boost::iterator_range<const char*>(chars, chars + count) - ); - } - - template <typename Target> - inline Target lexical_cast(const unsigned char* chars, std::size_t count) - { - return ::boost::lexical_cast<Target>( - ::boost::iterator_range<const unsigned char*>(chars, chars + count) - ); - } - - template <typename Target> - inline Target lexical_cast(const signed char* chars, std::size_t count) - { - return ::boost::lexical_cast<Target>( - ::boost::iterator_range<const signed char*>(chars, chars + count) - ); - } - -#ifndef BOOST_LCAST_NO_WCHAR_T - template <typename Target> - inline Target lexical_cast(const wchar_t* chars, std::size_t count) - { - return ::boost::lexical_cast<Target>( - ::boost::iterator_range<const wchar_t*>(chars, chars + count) - ); - } -#endif -#ifndef BOOST_NO_CXX11_CHAR16_T - template <typename Target> - inline Target lexical_cast(const char16_t* chars, std::size_t count) - { - return ::boost::lexical_cast<Target>( - ::boost::iterator_range<const char16_t*>(chars, chars + count) - ); - } -#endif -#ifndef BOOST_NO_CXX11_CHAR32_T - template <typename Target> - inline Target lexical_cast(const char32_t* chars, std::size_t count) - { - return ::boost::lexical_cast<Target>( - ::boost::iterator_range<const char32_t*>(chars, chars + count) - ); - } -#endif - -} // namespace boost - -#else - -namespace boost { - namespace detail - { - - // selectors for choosing stream character type - template<typename Type> - struct stream_char - { - typedef char type; - }; - -#ifndef BOOST_LCAST_NO_WCHAR_T -#ifndef BOOST_NO_INTRINSIC_WCHAR_T - template<> - struct stream_char<wchar_t> - { - typedef wchar_t type; - }; -#endif - - template<> - struct stream_char<wchar_t *> - { - typedef wchar_t type; - }; - - template<> - struct stream_char<const wchar_t *> - { - typedef wchar_t type; - }; - - template<> - struct stream_char<std::wstring> - { - typedef wchar_t type; - }; -#endif - - // stream wrapper for handling lexical conversions - template<typename Target, typename Source, typename Traits> - class lexical_stream - { - private: - typedef typename widest_char< - typename stream_char<Target>::type, - typename stream_char<Source>::type>::type char_type; - - typedef Traits traits_type; - - public: - lexical_stream(char_type* = 0, char_type* = 0) - { - stream.unsetf(std::ios::skipws); - lcast_set_precision(stream, static_cast<Source*>(0), static_cast<Target*>(0) ); - } - ~lexical_stream() - { - #if defined(BOOST_NO_STRINGSTREAM) - stream.freeze(false); - #endif - } - bool operator<<(const Source &input) - { - return !(stream << input).fail(); - } - template<typename InputStreamable> - bool operator>>(InputStreamable &output) - { - return !is_pointer<InputStreamable>::value && - stream >> output && - stream.get() == traits_type::eof(); - } - - bool operator>>(std::string &output) - { - #if defined(BOOST_NO_STRINGSTREAM) - stream << '\0'; - #endif - stream.str().swap(output); - return true; - } - #ifndef BOOST_LCAST_NO_WCHAR_T - bool operator>>(std::wstring &output) - { - stream.str().swap(output); - return true; - } - #endif - - private: - #if defined(BOOST_NO_STRINGSTREAM) - std::strstream stream; - #elif defined(BOOST_NO_STD_LOCALE) - std::stringstream stream; - #else - std::basic_stringstream<char_type,traits_type> stream; - #endif - }; - } - - // call-by-value fallback version (deprecated) - - template<typename Target, typename Source> - Target lexical_cast(Source arg) - { - typedef typename detail::widest_char< - BOOST_DEDUCED_TYPENAME detail::stream_char<Target>::type - , BOOST_DEDUCED_TYPENAME detail::stream_char<Source>::type - >::type char_type; - - typedef std::char_traits<char_type> traits; - detail::lexical_stream<Target, Source, traits> interpreter; - Target result; - - if(!(interpreter << arg && interpreter >> result)) - BOOST_LCAST_THROW_BAD_CAST(Source, Target); - return result; - } - -} // namespace boost - -#endif - -// Copyright Kevlin Henney, 2000-2005. -// Copyright Alexander Nasonov, 2006-2010. -// Copyright Antony Polukhin, 2011-2014. -// -// 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) - -#undef BOOST_LCAST_THROW_BAD_CAST -#undef BOOST_LCAST_NO_WCHAR_T - -#endif // BOOST_LEXICAL_CAST_INCLUDED - |