#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