-// boost lexical_cast.hpp header -------------------------------------------//
-
-// See http://www.boost.org/libs/conversion for documentation.
-
#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, with alternative naming, behaviors
-// and fixes contributed by Dave Abrahams, Daryle Walker and other
-// Boosters on the list
-// when: November 2000
-// where: tested with MSVC 6.0, BCC 5.5, and g++ 2.91
+// 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>
-// Some sstream implementations are broken for the purposes of lexical cast.
-# if defined(BOOST_NO_STRINGSTREAM)
-# define BOOST_LEXICAL_CAST_USE_STRSTREAM
-# endif
-
-#ifdef BOOST_LEXICAL_CAST_USE_STRSTREAM
-# include <strstream>
+#ifdef BOOST_NO_STRINGSTREAM
+#include <strstream>
#else
-# include <sstream>
+#include <sstream>
#endif
-#include <typeinfo>
+#if defined(BOOST_NO_STRINGSTREAM) || \
+ defined(BOOST_NO_STD_WSTRING) || \
+ defined(BOOST_NO_STD_LOCALE)
+#define DISABLE_WIDE_CHAR_SUPPORT
+#endif
namespace boost
{
class bad_lexical_cast : public std::bad_cast
{
public:
- // constructors, destructors, and assignment operator defaulted
-
- // function inlined for brevity and consistency with rest of library
- virtual const char * what() const throw()
+ 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(Source arg)
+ Target lexical_cast(const Source &arg)
{
-# ifdef BOOST_LEXICAL_CAST_USE_STRSTREAM
- std::strstream interpreter; // for out-of-the-box g++ 2.95.2
-# else
- std::stringstream interpreter;
-# endif
+ typedef typename detail::array_to_pointer_decay<Source>::type NewSource;
+
+ detail::lexical_stream<Target, NewSource> interpreter;
Target result;
- if(!(interpreter << arg) || !(interpreter >> result) ||
- !(interpreter >> std::ws).eof())
- throw bad_lexical_cast();
+ 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, 2001, 2002. All rights reserved.
-//
-// Permission to use, copy, modify, and distribute this software for any
-// purpose is hereby granted without fee, provided that this copyright and
-// permissions notice appear in all copies and derivatives.
+// Copyright Kevlin Henney, 2000-2005. All rights reserved.
//
-// This software is provided "as is" without express or implied warranty.
-
-#ifdef BOOST_LEXICAL_CAST_USE_STRSTREAM
-# undef BOOST_LEXICAL_CAST_USE_STRSTREAM
-#endif
+// 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
projects / lyx.git / blobdiff