diff options
Diffstat (limited to '3rdParty/Boost/boost/lexical_cast.hpp')
m--------- | 3rdParty/Boost | 0 | ||||
-rw-r--r-- | 3rdParty/Boost/boost/lexical_cast.hpp | 1216 |
2 files changed, 0 insertions, 1216 deletions
diff --git a/3rdParty/Boost b/3rdParty/Boost new file mode 160000 +Subproject 3bbdbc8cf1996f23d9a366da8bac0f97be6ad79 diff --git a/3rdParty/Boost/boost/lexical_cast.hpp b/3rdParty/Boost/boost/lexical_cast.hpp deleted file mode 100644 index 0da0d3d..0000000 --- a/3rdParty/Boost/boost/lexical_cast.hpp +++ /dev/null @@ -1,1216 +0,0 @@ -#ifndef BOOST_LEXICAL_CAST_INCLUDED -#define BOOST_LEXICAL_CAST_INCLUDED - -// 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 and other Boosters -// when: November 2000, March 2003, June 2005, June 2006 - -#include <climits> -#include <cstddef> -#include <istream> -#include <string> -#include <typeinfo> -#include <exception> -#include <boost/config.hpp> -#include <boost/limits.hpp> -#include <boost/mpl/if.hpp> -#include <boost/throw_exception.hpp> -#include <boost/type_traits/is_pointer.hpp> -#include <boost/type_traits/make_unsigned.hpp> -#include <boost/call_traits.hpp> -#include <boost/static_assert.hpp> -#include <boost/detail/lcast_precision.hpp> -#include <boost/detail/workaround.hpp> - -#ifndef BOOST_NO_STD_LOCALE -#include <locale> -#endif - -#ifdef BOOST_NO_STRINGSTREAM -#include <strstream> -#else -#include <sstream> -#endif - -#if defined(BOOST_NO_STRINGSTREAM) || \ - defined(BOOST_NO_STD_WSTRING) || \ - defined(BOOST_NO_STD_LOCALE) -#define BOOST_LCAST_NO_WCHAR_T -#endif - -namespace boost -{ - // exception used to indicate runtime lexical_cast failure - class bad_lexical_cast : public std::bad_cast - -#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() : -#ifndef BOOST_NO_TYPEID - source(&typeid(void)), target(&typeid(void)) -#else - source(0), target(0) // this breaks getters -#endif - { - } - - bad_lexical_cast( - const std::type_info &source_type_arg, - const std::type_info &target_type_arg) : - source(&source_type_arg), target(&target_type_arg) - { - } - - const std::type_info &source_type() const - { - return *source; - } - const std::type_info &target_type() const - { - return *target; - } - - virtual const char *what() const throw() - { - return "bad lexical cast: " - "source type value could not be interpreted as target"; - } - virtual ~bad_lexical_cast() throw() - { - } - private: - const std::type_info *source; - const std::type_info *target; - }; - - namespace detail // selectors for choosing stream character type - { - template<typename Type> - struct stream_char - { - typedef char type; - }; - -#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION - template<class CharT, class Traits, class Alloc> - struct stream_char< std::basic_string<CharT,Traits,Alloc> > - { - typedef CharT type; - }; -#endif - -#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; - }; - -#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION - template<> - struct stream_char<std::wstring> - { - typedef wchar_t type; - }; -#endif -#endif - - template<typename TargetChar, typename SourceChar> - struct widest_char - { - typedef TargetChar type; - }; - - template<> - struct widest_char<char, wchar_t> - { - typedef wchar_t type; - }; - } - - namespace detail // deduce_char_traits template - { -#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION - template<class CharT, class Target, class Source> - struct deduce_char_traits - { - typedef std::char_traits<CharT> type; - }; - - template<class CharT, class Traits, class Alloc, class Source> - struct deduce_char_traits< CharT - , std::basic_string<CharT,Traits,Alloc> - , Source - > - { - typedef Traits type; - }; - - template<class CharT, class Target, class Traits, class Alloc> - struct deduce_char_traits< CharT - , Target - , std::basic_string<CharT,Traits,Alloc> - > - { - typedef Traits type; - }; - - template<class CharT, class Traits, class Alloc1, class Alloc2> - struct deduce_char_traits< CharT - , std::basic_string<CharT,Traits,Alloc1> - , std::basic_string<CharT,Traits,Alloc2> - > - { - typedef Traits type; - }; -#endif - } - - namespace detail // lcast_src_length - { - // Return max. length of string representation of Source; - // 0 if unlimited (with exceptions for some types, see below). - // Values with limited string representation are placed to - // the buffer locally defined in lexical_cast function. - // 1 is returned for few types such as CharT const* or - // std::basic_string<CharT> that already have an internal - // buffer ready to be reused by lexical_stream_limited_src. - // Each specialization should have a correspondent operator<< - // defined in lexical_stream_limited_src. - template< class CharT // A result of widest_char transformation. - , class Source // Source type of lexical_cast. - > - struct lcast_src_length - { - BOOST_STATIC_CONSTANT(std::size_t, value = 0); - // To check coverage, build the test with - // bjam --v2 profile optimization=off - static void check_coverage() {} - }; - - template<> - struct lcast_src_length<char, bool> - { - BOOST_STATIC_CONSTANT(std::size_t, value = 1); - static void check_coverage() {} - }; - - template<> - struct lcast_src_length<char, char> - { - BOOST_STATIC_CONSTANT(std::size_t, value = 1); - static void check_coverage() {} - }; - - // No specializations for: - // lcast_src_length<char, signed char> - // lcast_src_length<char, unsigned char> - // lcast_src_length<char, signed char*> - // lcast_src_length<char, unsigned char*> - // lcast_src_length<char, signed char const*> - // lcast_src_length<char, unsigned char const*> - -#ifndef BOOST_LCAST_NO_WCHAR_T - template<> - struct lcast_src_length<wchar_t, bool> - { - BOOST_STATIC_CONSTANT(std::size_t, value = 1); - static void check_coverage() {} - }; - - template<> - struct lcast_src_length<wchar_t, char> - { - BOOST_STATIC_CONSTANT(std::size_t, value = 1); - static void check_coverage() {} - }; - -#ifndef BOOST_NO_INTRINSIC_WCHAR_T - template<> - struct lcast_src_length<wchar_t, wchar_t> - { - BOOST_STATIC_CONSTANT(std::size_t, value = 1); - static void check_coverage() {} - }; -#endif -#endif - - template<> - struct lcast_src_length<char, char const*> - { - BOOST_STATIC_CONSTANT(std::size_t, value = 1); - static void check_coverage() {} - }; - - template<> - struct lcast_src_length<char, char*> - { - BOOST_STATIC_CONSTANT(std::size_t, value = 1); - static void check_coverage() {} - }; - -#ifndef BOOST_LCAST_NO_WCHAR_T - template<> - struct lcast_src_length<wchar_t, wchar_t const*> - { - BOOST_STATIC_CONSTANT(std::size_t, value = 1); - static void check_coverage() {} - }; - - template<> - struct lcast_src_length<wchar_t, wchar_t*> - { - BOOST_STATIC_CONSTANT(std::size_t, value = 1); - static void check_coverage() {} - }; -#endif - -#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION - template<class CharT, class Traits, class Alloc> - struct lcast_src_length< CharT, std::basic_string<CharT,Traits,Alloc> > - { - BOOST_STATIC_CONSTANT(std::size_t, value = 1); - static void check_coverage() {} - }; -#else - template<> - struct lcast_src_length< char, std::basic_string<char> > - { - BOOST_STATIC_CONSTANT(std::size_t, value = 1); - static void check_coverage() {} - }; - -#ifndef BOOST_LCAST_NO_WCHAR_T - template<> - struct lcast_src_length< wchar_t, std::basic_string<wchar_t> > - { - BOOST_STATIC_CONSTANT(std::size_t, value = 1); - static void check_coverage() {} - }; -#endif -#endif - - // 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_integral - { -#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 - }; - -#define BOOST_LCAST_DEF1(CharT, T) \ - template<> struct lcast_src_length<CharT, T> \ - : lcast_src_length_integral<T> \ - { static void check_coverage() {} }; - -#ifdef BOOST_LCAST_NO_WCHAR_T -#define BOOST_LCAST_DEF(T) BOOST_LCAST_DEF1(char, T) -#else -#define BOOST_LCAST_DEF(T) \ - BOOST_LCAST_DEF1(char, T) \ - BOOST_LCAST_DEF1(wchar_t, T) -#endif - - BOOST_LCAST_DEF(short) - BOOST_LCAST_DEF(unsigned short) - BOOST_LCAST_DEF(int) - BOOST_LCAST_DEF(unsigned int) - BOOST_LCAST_DEF(long) - BOOST_LCAST_DEF(unsigned long) -#if defined(BOOST_HAS_LONG_LONG) - BOOST_LCAST_DEF(boost::ulong_long_type) - BOOST_LCAST_DEF(boost::long_long_type ) -#elif defined(BOOST_HAS_MS_INT64) - BOOST_LCAST_DEF(unsigned __int64) - BOOST_LCAST_DEF( __int64) -#endif - -#undef BOOST_LCAST_DEF -#undef BOOST_LCAST_DEF1 - -#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_floating - { - 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 - ); - }; - - template<> - struct lcast_src_length<char,float> - : lcast_src_length_floating<float> - { - static void check_coverage() {} - }; - - template<> - struct lcast_src_length<char,double> - : lcast_src_length_floating<double> - { - static void check_coverage() {} - }; - - template<> - struct lcast_src_length<char,long double> - : lcast_src_length_floating<long double> - { - static void check_coverage() {} - }; - -#ifndef BOOST_LCAST_NO_WCHAR_T - template<> - struct lcast_src_length<wchar_t,float> - : lcast_src_length_floating<float> - { - static void check_coverage() {} - }; - - template<> - struct lcast_src_length<wchar_t,double> - : lcast_src_length_floating<double> - { - static void check_coverage() {} - }; - - template<> - struct lcast_src_length<wchar_t,long double> - : lcast_src_length_floating<long double> - { - static void check_coverage() {} - }; - -#endif // #ifndef BOOST_LCAST_NO_WCHAR_T -#endif // #ifndef BOOST_LCAST_NO_COMPILE_TIME_PRECISION - } - - namespace detail // '0' and '-' constants - { - template<typename CharT> struct lcast_char_constants; - - template<> - struct lcast_char_constants<char> - { - BOOST_STATIC_CONSTANT(char, zero = '0'); - BOOST_STATIC_CONSTANT(char, minus = '-'); - }; - -#ifndef BOOST_LCAST_NO_WCHAR_T - template<> - struct lcast_char_constants<wchar_t> - { - BOOST_STATIC_CONSTANT(wchar_t, zero = L'0'); - BOOST_STATIC_CONSTANT(wchar_t, minus = L'-'); - }; -#endif - } - - namespace detail // lexical_streambuf_fake - { - struct lexical_streambuf_fake - { - }; - } - - namespace detail // lcast_to_unsigned - { -#if (defined _MSC_VER) -# pragma warning( push ) -// C4146: unary minus operator applied to unsigned type, result still unsigned -# pragma warning( disable : 4146 ) -#elif defined( __BORLANDC__ ) -# pragma option push -w-8041 -#endif - template<class T> - inline - BOOST_DEDUCED_TYPENAME make_unsigned<T>::type lcast_to_unsigned(T value) - { - typedef BOOST_DEDUCED_TYPENAME make_unsigned<T>::type result_type; - result_type uvalue = static_cast<result_type>(value); - return value < 0 ? -uvalue : uvalue; - } -#if (defined _MSC_VER) -# pragma warning( pop ) -#elif defined( __BORLANDC__ ) -# pragma option pop -#endif - } - - namespace detail // lcast_put_unsigned - { - template<class Traits, class T, class CharT> - CharT* lcast_put_unsigned(T n, CharT* finish) - { -#ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS - BOOST_STATIC_ASSERT(!std::numeric_limits<T>::is_signed); -#endif - -#ifndef BOOST_LEXICAL_CAST_ASSUME_C_LOCALE - // TODO: use BOOST_NO_STD_LOCALE - std::locale loc; - 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(); - CharT thousands_sep = grouping_size ? np.thousands_sep() : 0; - std::string::size_type group = 0; // current group number - char last_grp_size = grouping[0] <= 0 ? CHAR_MAX : grouping[0]; - // a) Since grouping is const, grouping[grouping.size()] returns 0. - // b) It's safe to assume here and below that CHAR_MAX - // is equivalent to unlimited grouping: -#ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS - BOOST_STATIC_ASSERT(std::numeric_limits<T>::digits10 < CHAR_MAX); -#endif - - char left = last_grp_size; -#endif - - typedef typename Traits::int_type int_type; - CharT const czero = lcast_char_constants<CharT>::zero; - int_type const zero = Traits::to_int_type(czero); - - do - { -#ifndef BOOST_LEXICAL_CAST_ASSUME_C_LOCALE - if(left == 0) - { - ++group; - if(group < grouping_size) - { - char const grp_size = grouping[group]; - last_grp_size = grp_size <= 0 ? CHAR_MAX : grp_size; - } - - left = last_grp_size; - --finish; - Traits::assign(*finish, thousands_sep); - } - - --left; -#endif - - --finish; - int_type const digit = static_cast<int_type>(n % 10U); - Traits::assign(*finish, Traits::to_char_type(zero + digit)); - n /= 10; - } while(n); - - return finish; - } - } - - namespace detail // 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, (Source*)0, (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() == -#if defined(__GNUC__) && (__GNUC__<3) && defined(BOOST_NO_STD_WSTRING) -// GCC 2.9x lacks std::char_traits<>::eof(). -// We use BOOST_NO_STD_WSTRING to filter out STLport and libstdc++-v3 -// configurations, which do provide std::char_traits<>::eof(). - - EOF; -#else - traits_type::eof(); -#endif - } - -#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION - - 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 - -#else - bool operator>>(std::basic_string<char_type,traits_type>& output) - { - stream.str().swap(output); - return true; - } - - template<class Alloc> - bool operator>>(std::basic_string<char_type,traits_type,Alloc>& out) - { - std::basic_string<char_type,traits_type> str(stream.str()); - out.assign(str.begin(), str.end()); - 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 - }; - } - - namespace detail // optimized stream wrapper - { - // String representation of Source has an upper limit. - template< class CharT // a result of widest_char transformation - , class Base // lexical_streambuf_fake or basic_streambuf<CharT> - , class Traits // usually char_traits<CharT> - > - class lexical_stream_limited_src : public Base - { - // A string representation of Source is written to [start, finish). - // Currently, it is assumed that [start, finish) is big enough - // to hold a string representation of any Source value. - CharT* start; - CharT* finish; - - private: - - static void widen_and_assign(char*p, char ch) - { - Traits::assign(*p, ch); - } - -#ifndef BOOST_LCAST_NO_WCHAR_T - static void widen_and_assign(wchar_t* p, char ch) - { - // TODO: use BOOST_NO_STD_LOCALE - std::locale loc; - wchar_t w = BOOST_USE_FACET(std::ctype<wchar_t>, loc).widen(ch); - Traits::assign(*p, w); - } - - static void widen_and_assign(wchar_t* p, wchar_t ch) - { - Traits::assign(*p, ch); - } - - static void widen_and_assign(char*, wchar_t ch); // undefined -#endif - - template<class OutputStreamable> - bool lcast_put(const OutputStreamable& input) - { - this->setp(start, finish); - std::basic_ostream<CharT> stream(static_cast<Base*>(this)); - lcast_set_precision(stream, (OutputStreamable*)0); - bool const result = !(stream << input).fail(); - finish = this->pptr(); - return result; - } - - // Undefined: - lexical_stream_limited_src(lexical_stream_limited_src const&); - void operator=(lexical_stream_limited_src const&); - - public: - - lexical_stream_limited_src(CharT* sta, CharT* fin) - : start(sta) - , finish(fin) - {} - - public: // output - - template<class Alloc> - bool operator<<(std::basic_string<CharT,Traits,Alloc> const& str) - { - start = const_cast<CharT*>(str.data()); - finish = start + str.length(); - return true; - } - - bool operator<<(bool); - bool operator<<(char); -#if !defined(BOOST_LCAST_NO_WCHAR_T) && !defined(BOOST_NO_INTRINSIC_WCHAR_T) - bool operator<<(wchar_t); -#endif - bool operator<<(CharT const*); - bool operator<<(short); - bool operator<<(int); - bool operator<<(long); - bool operator<<(unsigned short); - bool operator<<(unsigned int); - bool operator<<(unsigned long); -#if defined(BOOST_HAS_LONG_LONG) - bool operator<<(boost::ulong_long_type); - bool operator<<(boost::long_long_type ); -#elif defined(BOOST_HAS_MS_INT64) - bool operator<<(unsigned __int64); - bool operator<<( __int64); -#endif - // These three operators use ostream and streambuf. - // lcast_streambuf_for_source<T>::value is true. - bool operator<<(float); - bool operator<<(double); - bool operator<<(long double); - - public: // input - - // Generic istream-based algorithm. - // lcast_streambuf_for_target<InputStreamable>::value is true. - template<typename InputStreamable> - bool operator>>(InputStreamable& output) - { -#if (defined _MSC_VER) -# pragma warning( push ) - // conditional expression is constant -# pragma warning( disable : 4127 ) -#endif - if(is_pointer<InputStreamable>::value) - return false; - - this->setg(start, start, finish); - std::basic_istream<CharT> stream(static_cast<Base*>(this)); - stream.unsetf(std::ios::skipws); - lcast_set_precision(stream, (InputStreamable*)0); -#if (defined _MSC_VER) -# pragma warning( pop ) -#endif - return stream >> output && - stream.get() == -#if defined(__GNUC__) && (__GNUC__<3) && defined(BOOST_NO_STD_WSTRING) - // GCC 2.9x lacks std::char_traits<>::eof(). - // We use BOOST_NO_STD_WSTRING to filter out STLport and libstdc++-v3 - // configurations, which do provide std::char_traits<>::eof(). - - EOF; -#else - Traits::eof(); -#endif - } - - bool operator>>(CharT&); - -#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION -// This #if is in sync with lcast_streambuf_for_target - - bool operator>>(std::string&); - -#ifndef BOOST_LCAST_NO_WCHAR_T - bool operator>>(std::wstring&); -#endif - -#else - template<class Alloc> - bool operator>>(std::basic_string<CharT,Traits,Alloc>& str) - { - str.assign(start, finish); - return true; - } -#endif - }; - - template<typename CharT, class Base, class Traits> - inline bool lexical_stream_limited_src<CharT,Base,Traits>::operator<<( - bool value) - { - typedef typename Traits::int_type int_type; - CharT const czero = lcast_char_constants<CharT>::zero; - int_type const zero = Traits::to_int_type(czero); - Traits::assign(*start, Traits::to_char_type(zero + value)); - finish = start + 1; - return true; - } - - template<typename CharT, class Base, class Traits> - inline bool lexical_stream_limited_src<CharT,Base,Traits>::operator<<( - char ch) - { - widen_and_assign(start, ch); - finish = start + 1; - return true; - } - -#if !defined(BOOST_LCAST_NO_WCHAR_T) && !defined(BOOST_NO_INTRINSIC_WCHAR_T) - template<typename CharT, class Base, class Traits> - inline bool lexical_stream_limited_src<CharT,Base,Traits>::operator<<( - wchar_t ch) - { - widen_and_assign(start, ch); - finish = start + 1; - return true; - } -#endif - - template<typename CharT, class Base, class Traits> - inline bool lexical_stream_limited_src<CharT,Base,Traits>::operator<<( - short n) - { - start = lcast_put_unsigned<Traits>(lcast_to_unsigned(n), finish); - if(n < 0) - { - --start; - CharT const minus = lcast_char_constants<CharT>::minus; - Traits::assign(*start, minus); - } - return true; - } - - template<typename CharT, class Base, class Traits> - inline bool lexical_stream_limited_src<CharT,Base,Traits>::operator<<( - int n) - { - start = lcast_put_unsigned<Traits>(lcast_to_unsigned(n), finish); - if(n < 0) - { - --start; - CharT const minus = lcast_char_constants<CharT>::minus; - Traits::assign(*start, minus); - } - return true; - } - - template<typename CharT, class Base, class Traits> - inline bool lexical_stream_limited_src<CharT,Base,Traits>::operator<<( - long n) - { - start = lcast_put_unsigned<Traits>(lcast_to_unsigned(n), finish); - if(n < 0) - { - --start; - CharT const minus = lcast_char_constants<CharT>::minus; - Traits::assign(*start, minus); - } - return true; - } - -#if defined(BOOST_HAS_LONG_LONG) - template<typename CharT, class Base, class Traits> - inline bool lexical_stream_limited_src<CharT,Base,Traits>::operator<<( - boost::long_long_type n) - { - start = lcast_put_unsigned<Traits>(lcast_to_unsigned(n), finish); - if(n < 0) - { - --start; - CharT const minus = lcast_char_constants<CharT>::minus; - Traits::assign(*start, minus); - } - return true; - } -#elif defined(BOOST_HAS_MS_INT64) - template<typename CharT, class Base, class Traits> - inline bool lexical_stream_limited_src<CharT,Base,Traits>::operator<<( - __int64 n) - { - start = lcast_put_unsigned<Traits>(lcast_to_unsigned(n), finish); - if(n < 0) - { - --start; - CharT const minus = lcast_char_constants<CharT>::minus; - Traits::assign(*start, minus); - } - return true; - } -#endif - - template<typename CharT, class Base, class Traits> - inline bool lexical_stream_limited_src<CharT,Base,Traits>::operator<<( - unsigned short n) - { - start = lcast_put_unsigned<Traits>(n, finish); - return true; - } - - template<typename CharT, class Base, class Traits> - inline bool lexical_stream_limited_src<CharT,Base,Traits>::operator<<( - unsigned int n) - { - start = lcast_put_unsigned<Traits>(n, finish); - return true; - } - - template<typename CharT, class Base, class Traits> - inline bool lexical_stream_limited_src<CharT,Base,Traits>::operator<<( - unsigned long n) - { - start = lcast_put_unsigned<Traits>(n, finish); - return true; - } - -#if defined(BOOST_HAS_LONG_LONG) - template<typename CharT, class Base, class Traits> - inline bool lexical_stream_limited_src<CharT,Base,Traits>::operator<<( - boost::ulong_long_type n) - { - start = lcast_put_unsigned<Traits>(n, finish); - return true; - } -#elif defined(BOOST_HAS_MS_INT64) - template<typename CharT, class Base, class Traits> - inline bool lexical_stream_limited_src<CharT,Base,Traits>::operator<<( - unsigned __int64 n) - { - start = lcast_put_unsigned<Traits>(n, finish); - return true; - } -#endif - - template<typename CharT, class Base, class Traits> - inline bool lexical_stream_limited_src<CharT,Base,Traits>::operator<<( - float val) - { - return this->lcast_put(val); - } - - template<typename CharT, class Base, class Traits> - inline bool lexical_stream_limited_src<CharT,Base,Traits>::operator<<( - double val) - { - return this->lcast_put(val); - } - - template<typename CharT, class Base, class Traits> - inline bool lexical_stream_limited_src<CharT,Base,Traits>::operator<<( - long double val) - { - return this->lcast_put(val); - } - - template<typename CharT, class Base, class Traits> - inline bool lexical_stream_limited_src<CharT,Base,Traits>::operator<<( - CharT const* str) - { - start = const_cast<CharT*>(str); - finish = start + Traits::length(str); - return true; - } - - template<typename CharT, class Base, class Traits> - inline bool lexical_stream_limited_src<CharT,Base,Traits>::operator>>( - CharT& output) - { - bool const ok = (finish - start == 1); - if(ok) - Traits::assign(output, *start); - return ok; - } - -#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION - template<typename CharT, class Base, class Traits> - inline bool lexical_stream_limited_src<CharT,Base,Traits>::operator>>( - std::string& str) - { - str.assign(start, finish); - return true; - } - -#ifndef BOOST_LCAST_NO_WCHAR_T - template<typename CharT, class Base, class Traits> - inline bool lexical_stream_limited_src<CharT,Base,Traits>::operator>>( - std::wstring& str) - { - str.assign(start, finish); - return true; - } -#endif -#endif - } - - namespace detail // lcast_streambuf_for_source - { - // Returns true if optimized stream wrapper needs ostream for writing. - template<class Source> - struct lcast_streambuf_for_source - { - BOOST_STATIC_CONSTANT(bool, value = false); - }; - - template<> - struct lcast_streambuf_for_source<float> - { - BOOST_STATIC_CONSTANT(bool, value = true); - }; - - template<> - struct lcast_streambuf_for_source<double> - { - BOOST_STATIC_CONSTANT(bool, value = true); - }; - - template<> - struct lcast_streambuf_for_source<long double> - { - BOOST_STATIC_CONSTANT(bool, value = true); - }; - } - - namespace detail // lcast_streambuf_for_target - { - // Returns true if optimized stream wrapper needs istream for reading. - template<class Target> - struct lcast_streambuf_for_target - { - BOOST_STATIC_CONSTANT(bool, value = true); - }; - - template<> - struct lcast_streambuf_for_target<char> - { - BOOST_STATIC_CONSTANT(bool, value = false); - }; - -#if !defined(BOOST_LCAST_NO_WCHAR_T) && !defined(BOOST_NO_INTRINSIC_WCHAR_T) - template<> - struct lcast_streambuf_for_target<wchar_t> - { - BOOST_STATIC_CONSTANT(bool, value = false); - }; -#endif - -#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION - template<class Traits, class Alloc> - struct lcast_streambuf_for_target< - std::basic_string<char,Traits,Alloc> > - { - BOOST_STATIC_CONSTANT(bool, value = false); - }; - -#ifndef BOOST_LCAST_NO_WCHAR_T - template<class Traits, class Alloc> - struct lcast_streambuf_for_target< - std::basic_string<wchar_t,Traits,Alloc> > - { - BOOST_STATIC_CONSTANT(bool, value = false); - }; -#endif -#else - template<> - struct lcast_streambuf_for_target<std::string> - { - BOOST_STATIC_CONSTANT(bool, value = false); - }; - -#ifndef BOOST_LCAST_NO_WCHAR_T - template<> - struct lcast_streambuf_for_target<std::wstring> - { - BOOST_STATIC_CONSTANT(bool, value = false); - }; -#endif -#endif - } - - #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION - - // call-by-const reference version - - namespace detail - { - 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; - }; - - template< typename Target - , typename Source - , bool Unlimited // string representation of Source is unlimited - , typename CharT - > - Target lexical_cast( - BOOST_DEDUCED_TYPENAME boost::call_traits<Source>::param_type arg, - CharT* buf, std::size_t src_len) - { - typedef BOOST_DEDUCED_TYPENAME - deduce_char_traits<CharT,Target,Source>::type traits; - - typedef BOOST_DEDUCED_TYPENAME boost::mpl::if_c< - lcast_streambuf_for_target<Target>::value || - lcast_streambuf_for_source<Source>::value - , std::basic_streambuf<CharT> - , lexical_streambuf_fake - >::type base; - - BOOST_DEDUCED_TYPENAME boost::mpl::if_c< - Unlimited - , detail::lexical_stream<Target,Source,traits> - , detail::lexical_stream_limited_src<CharT,base,traits> - >::type interpreter(buf, buf + src_len); - - // The original form, reproduced below, is more elegant - // but yields a spurious C4701 warning ("possible use of - // "result" before initialization") with VC7.1 (/W4). -// -// Target result; -// -// if(!(interpreter << arg && interpreter >> result)) -// throw_exception(bad_lexical_cast(typeid(Source), typeid(Target))); -// return result; - - if(interpreter << arg) { - Target result; - if (interpreter >> result) - return result; - } -#ifndef BOOST_NO_TYPEID - throw_exception(bad_lexical_cast(typeid(Source), typeid(Target))); -#else - throw_exception(bad_lexical_cast()); -#endif - return Target(); // normally never reached (throw_exception) - } - } - - template<typename Target, typename Source> - inline Target lexical_cast(const Source &arg) - { - typedef typename detail::array_to_pointer_decay<Source>::type src; - - typedef typename detail::widest_char< - typename detail::stream_char<Target>::type - , typename detail::stream_char<src>::type - >::type char_type; - - typedef detail::lcast_src_length<char_type, src> lcast_src_length; - std::size_t const src_len = lcast_src_length::value; - char_type buf[src_len + 1]; - lcast_src_length::check_coverage(); - return detail::lexical_cast<Target, src, !src_len>(arg, buf, src_len); - } - - #else - - // 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)) -#ifndef BOOST_NO_TYPEID - throw_exception(bad_lexical_cast(typeid(Source), typeid(Target))); -#else - throw_exception(bad_lexical_cast()); -#endif - return result; - } - - #endif -} - -// Copyright Kevlin Henney, 2000-2005. -// Copyright Alexander Nasonov, 2006-2007. -// -// 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_NO_WCHAR_T -#endif |