#ifndef BOOST_LEXICAL_CAST_INCLUDED

#define BOOST_LEXICAL_CAST_INCLUDED

// Boost lexical_cast.hpp header  -------------------------------------------//

//

// See http://www.boost.org for most recent version including 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 Slettebų,

//        with additional fixes and suggestions from Gennaro Prota,

//        Beman Dawes, Dave Abrahams, Daryle Walker, Peter Dimov,

//        and other Boosters

// when:  November 2000, March 2003, June 2005

#include <cstddef>

#include <string>

#include <typeinfo>

#include <boost/config.hpp>

#include <boost/limits.hpp>

#include <boost/throw_exception.hpp>

#include <boost/type_traits/is_pointer.hpp>

#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 DISABLE_WIDE_CHAR_SUPPORT

#endif

namespace boost

{

    // exception used to indicate runtime lexical_cast failure

    class bad_lexical_cast : public std::bad_cast

    {

    public:

        bad_lexical_cast() :

        source(&typeid(void)), target(&typeid(void))

        {

        }

        bad_lexical_cast(

            const std::type_info &source_type,

            const std::type_info &target_type) :

            source(&source_type), target(&target_type)

        {

        }

        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 DISABLE_WIDE_CHAR_SUPPORT

#if !defined(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

        template<typename TargetChar, typename SourceChar>

        struct widest_char

        {

            typedef TargetChar type;

        };

        template<>

        struct widest_char<char, wchar_t>

        {

            typedef wchar_t type;

        };

    }

    namespace detail // stream wrapper for handling lexical conversions

    {

        template<typename Target, typename Source>

        class lexical_stream

        {

        private:

            typedef typename widest_char<

                typename stream_char<Target>::type,

                typename stream_char<Source>::type>::type char_type;

        public:

            lexical_stream()

            {

                stream.unsetf(std::ios::skipws);

                if(std::numeric_limits<Target>::is_specialized)

                    stream.precision(std::numeric_limits<Target>::digits10 + 1);

                else if(std::numeric_limits<Source>::is_specialized)

                    stream.precision(std::numeric_limits<Source>::digits10 + 1);

            }

            ~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

                           std::char_traits<char_type>::eof();

#endif

            }

            bool operator>>(std::string &output)

            {

                #if defined(BOOST_NO_STRINGSTREAM)

                stream << '\0';

                #endif

                output = stream.str();

                return true;

            }

            #ifndef DISABLE_WIDE_CHAR_SUPPORT

            bool operator>>(std::wstring &output)

            {

                output = stream.str();

                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> stream;

            #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>

    Target lexical_cast(const Source &arg)

    {

        typedef typename detail::array_to_pointer_decay<Source>::type NewSource;

        detail::lexical_stream<Target, NewSource> interpreter;

        Target result = 0;

        if(!(interpreter << arg && interpreter >> result))

            throw_exception(bad_lexical_cast(typeid(NewSource), typeid(Target)));

        return result;

    }

    #else

    // call-by-value fallback version (deprecated)

    template<typename Target, typename Source>

    Target lexical_cast(Source arg)

    {

        detail::lexical_stream<Target, Source> interpreter;

        Target result;

        if(!(interpreter << arg && interpreter >> result))

            throw_exception(bad_lexical_cast(typeid(Source), typeid(Target)));

        return result;

    }

    #endif

}

// Copyright Kevlin Henney, 2000-2005. All rights reserved.

//

// 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 DISABLE_WIDE_CHAR_SUPPORT

#endif