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

         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