| // 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) |
| // |
| // 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 |
| |
| #ifndef BOOST_LEXICAL_CAST_DETAIL_CONVERTER_LEXICAL_STREAMS_HPP |
| #define BOOST_LEXICAL_CAST_DETAIL_CONVERTER_LEXICAL_STREAMS_HPP |
| |
| #include <boost/config.hpp> |
| #ifdef BOOST_HAS_PRAGMA_ONCE |
| # pragma once |
| #endif |
| |
| |
| #if defined(BOOST_NO_STRINGSTREAM) || defined(BOOST_NO_STD_WSTRING) |
| #define BOOST_LCAST_NO_WCHAR_T |
| #endif |
| |
| #include <cstddef> |
| #include <string> |
| #include <cstring> |
| #include <cstdio> |
| #include <boost/limits.hpp> |
| #include <boost/mpl/if.hpp> |
| #include <boost/type_traits/ice.hpp> |
| #include <boost/type_traits/is_pointer.hpp> |
| #include <boost/static_assert.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 |
| |
| #include <boost/lexical_cast/detail/lcast_char_constants.hpp> |
| #include <boost/lexical_cast/detail/lcast_unsigned_converters.hpp> |
| #include <boost/lexical_cast/detail/inf_nan.hpp> |
| #include <boost/lexical_cast/detail/lcast_float_converters.hpp> |
| |
| #include <istream> |
| |
| #ifndef BOOST_NO_CXX11_HDR_ARRAY |
| #include <array> |
| #endif |
| |
| #include <boost/array.hpp> |
| #include <boost/type_traits/make_unsigned.hpp> |
| #include <boost/type_traits/is_integral.hpp> |
| #include <boost/type_traits/is_float.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 // 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 boost |
| |
| #undef BOOST_LCAST_NO_WCHAR_T |
| |
| #endif // BOOST_LEXICAL_CAST_DETAIL_CONVERTER_LEXICAL_HPP |
| |
