feedc0de/boost_conversion
1
0
Fork 0
forked from boostorg/conversion
Code Pull Requests Activity

Patches for Codegear C++ Builder 2009

Browse Source 
[SVN r48981]
This commit is contained in:
Nicola Musatti
2008-09-27 08:59:20 +00:00
parent 42ac4cab8a ae273a3e7b
commit 6ca60264f4
6 changed files with 453 additions and 198 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
cast.htm
View File

@@ -120,10 +120,10 @@ void f( Fruit * fruit ) {
<p><code>polymorphic_cast</code> was suggested by Bjarne Stroustrup in "The C++ <p><code>polymorphic_cast</code> was suggested by Bjarne Stroustrup in "The C++
Programming Language".<br> Programming Language".<br>
<code>polymorphic_downcast</code> was contributed by <a href= <code>polymorphic_downcast</code> was contributed by <a href=
"../../people/dave_abrahams.htm">Dave Abrahams</a>.<code><br> "http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a>.<code><br>
An old An old
numeric_cast</code> that was contributed by <a href= numeric_cast</code> that was contributed by <a href=
"../../people/kevlin_henney.htm">Kevlin Henney</a> is now superseeded by the <a href="../numeric/conversion/doc/index.html">Boost Numeric Conversion Library</a></p> "http://www.boost.org/people/kevlin_henney.htm">Kevlin Henney</a> is now superseeded by the <a href="../numeric/conversion/doc/html/index.html">Boost Numeric Conversion Library</a></p>
<hr> <hr>
<p>Revised <p>Revised

16
include/boost/detail/lcast_precision.hpp
View File

@@ -21,7 +21,13 @@
#include <boost/type_traits/is_abstract.hpp> #include <boost/type_traits/is_abstract.hpp>
#endif #endif
#ifdef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS #if defined(BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS) || \
(defined(BOOST_MSVC) && (BOOST_MSVC<1310))
#define BOOST_LCAST_NO_COMPILE_TIME_PRECISION
#endif
#ifdef BOOST_LCAST_NO_COMPILE_TIME_PRECISION
#include <boost/assert.hpp> #include <boost/assert.hpp>
#else #else
#include <boost/static_assert.hpp> #include <boost/static_assert.hpp>
@@ -31,7 +37,7 @@ namespace boost { namespace detail {
class lcast_abstract_stub {}; class lcast_abstract_stub {};
#ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS #ifndef BOOST_LCAST_NO_COMPILE_TIME_PRECISION
// Calculate an argument to pass to std::ios_base::precision from // Calculate an argument to pass to std::ios_base::precision from
// lexical_cast. See alternative implementation for broken standard // lexical_cast. See alternative implementation for broken standard
// libraries in lcast_get_precision below. Keep them in sync, please. // libraries in lcast_get_precision below. Keep them in sync, please.
@@ -77,9 +83,9 @@ struct lcast_precision
); );
BOOST_STATIC_ASSERT(!is_specialized_bin || BOOST_STATIC_ASSERT(!is_specialized_bin ||
limits::digits + 0UL < ULONG_MAX / 30103UL && (limits::digits + 0UL < ULONG_MAX / 30103UL &&
precision_bin > limits::digits10 + 0UL && precision_bin > limits::digits10 + 0UL &&
precision_bin <= streamsize_max + 0UL precision_bin <= streamsize_max + 0UL)
); );
BOOST_STATIC_CONSTANT(std::streamsize, value = BOOST_STATIC_CONSTANT(std::streamsize, value =
@@ -92,7 +98,7 @@ struct lcast_precision
template<class T> template<class T>
inline std::streamsize lcast_get_precision(T* = 0) inline std::streamsize lcast_get_precision(T* = 0)
{ {
#if !defined(BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS) #ifndef BOOST_LCAST_NO_COMPILE_TIME_PRECISION
return lcast_precision<T>::value; return lcast_precision<T>::value;
#else // Follow lcast_precision algorithm at run-time: #else // Follow lcast_precision algorithm at run-time:

0
include/boost/implicit_cast.hpp Executable file → Normal file
View File

371
include/boost/lexical_cast.hpp
View File

@@ -3,7 +3,7 @@
// Boost lexical_cast.hpp header -------------------------------------------// // Boost lexical_cast.hpp header -------------------------------------------//
// //
// See http://www.boost.org/ for most recent version including documentation. // See http://www.boost.org/libs/conversion for documentation.
// See end of this header for rights and permissions. // See end of this header for rights and permissions.
// //
// what: lexical_cast custom keyword cast // what: lexical_cast custom keyword cast
@@ -17,17 +17,23 @@
#include <climits> #include <climits>
#include <cstddef> #include <cstddef>
#include <istream> #include <istream>
#include <locale>
#include <string> #include <string>
#include <typeinfo> #include <typeinfo>
#include <exception>
#include <boost/config.hpp> #include <boost/config.hpp>
#include <boost/limits.hpp> #include <boost/limits.hpp>
#include <boost/mpl/if.hpp> #include <boost/mpl/if.hpp>
#include <boost/throw_exception.hpp> #include <boost/throw_exception.hpp>
#include <boost/type_traits/is_pointer.hpp> #include <boost/type_traits/is_pointer.hpp>
#include <boost/type_traits/make_unsigned.hpp>
#include <boost/call_traits.hpp> #include <boost/call_traits.hpp>
#include <boost/static_assert.hpp> #include <boost/static_assert.hpp>
#include <boost/detail/lcast_precision.hpp> #include <boost/detail/lcast_precision.hpp>
#include <boost/detail/workaround.hpp>
#ifndef BOOST_NO_STD_LOCALE
#include <locale>
#endif
#ifdef BOOST_NO_STRINGSTREAM #ifdef BOOST_NO_STRINGSTREAM
#include <strstream> #include <strstream>
@@ -45,6 +51,12 @@ namespace boost
{ {
// exception used to indicate runtime lexical_cast failure // exception used to indicate runtime lexical_cast failure
class bad_lexical_cast : public std::bad_cast 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: public:
bad_lexical_cast() : bad_lexical_cast() :
@@ -52,9 +64,9 @@ namespace boost
{ {
} }
bad_lexical_cast( bad_lexical_cast(
const std::type_info &source_type, const std::type_info &source_type_arg,
const std::type_info &target_type) : const std::type_info &target_type_arg) :
source(&source_type), target(&target_type) source(&source_type_arg), target(&target_type_arg)
{ {
} }
const std::type_info &source_type() const const std::type_info &source_type() const
@@ -86,6 +98,14 @@ namespace boost
typedef char type; 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 DISABLE_WIDE_CHAR_SUPPORT #ifndef DISABLE_WIDE_CHAR_SUPPORT
#ifndef BOOST_NO_INTRINSIC_WCHAR_T #ifndef BOOST_NO_INTRINSIC_WCHAR_T
template<> template<>
@@ -107,11 +127,13 @@ namespace boost
typedef wchar_t type; typedef wchar_t type;
}; };
#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
template<> template<>
struct stream_char<std::wstring> struct stream_char<std::wstring>
{ {
typedef wchar_t type; typedef wchar_t type;
}; };
#endif
#endif #endif
template<typename TargetChar, typename SourceChar> template<typename TargetChar, typename SourceChar>
@@ -127,6 +149,44 @@ namespace boost
}; };
} }
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 namespace detail // lcast_src_length
{ {
// Return max. length of string representation of Source; // Return max. length of string representation of Source;
@@ -267,14 +327,15 @@ namespace boost
template<class Source> template<class Source>
struct lcast_src_length_integral struct lcast_src_length_integral
{ {
#if !defined(__BORLANDC__) || __BORLANDC__ >= 0x581 #ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
BOOST_STATIC_CONSTANT(std::size_t, value = BOOST_STATIC_CONSTANT(std::size_t, value =
std::numeric_limits<Source>::is_signed + std::numeric_limits<Source>::is_signed +
std::numeric_limits<Source>::is_specialized + // == 1 std::numeric_limits<Source>::is_specialized + // == 1
std::numeric_limits<Source>::digits10 * 2 std::numeric_limits<Source>::digits10 * 2
); );
#else #else
BOOST_STATIC_CONSTANT(std::size_t, value = 156); // 256bit integers BOOST_STATIC_CONSTANT(std::size_t, value = 156);
BOOST_STATIC_ASSERT(sizeof(Source) * CHAR_BIT <= 256);
#endif #endif
}; };
@@ -307,9 +368,7 @@ namespace boost
#undef BOOST_AUX_LEXICAL_CAST_DEF #undef BOOST_AUX_LEXICAL_CAST_DEF
#undef BOOST_AUX_LEXICAL_CAST_DEF1 #undef BOOST_AUX_LEXICAL_CAST_DEF1
#ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS #ifndef BOOST_LCAST_NO_COMPILE_TIME_PRECISION
// This #if is in sync with lcast_precision
// Helper for floating point types. // Helper for floating point types.
// -1.23456789e-123456 // -1.23456789e-123456
// ^ sign // ^ sign
@@ -376,7 +435,7 @@ namespace boost
}; };
#endif // #ifndef DISABLE_WIDE_CHAR_SUPPORT #endif // #ifndef DISABLE_WIDE_CHAR_SUPPORT
#endif // #ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS #endif // #ifndef BOOST_LCAST_NO_COMPILE_TIME_PRECISION
} }
namespace detail // '0' and '-' constants namespace detail // '0' and '-' constants
@@ -400,14 +459,8 @@ namespace boost
#endif #endif
} }
namespace detail // lexical_streambuf and lexical_streambuf_fake namespace detail // lexical_streambuf_fake
{ {
template<typename CharT>
class lexical_streambuf : public std::basic_streambuf<CharT>
{
};
template<typename CharT>
struct lexical_streambuf_fake struct lexical_streambuf_fake
{ {
}; };
@@ -420,61 +473,36 @@ namespace boost
// C4146: unary minus operator applied to unsigned type, result still unsigned // C4146: unary minus operator applied to unsigned type, result still unsigned
# pragma warning( disable : 4146 ) # pragma warning( disable : 4146 )
#endif #endif
template<class T>
inline unsigned int lcast_to_unsigned(int value) inline
BOOST_DEDUCED_TYPENAME make_unsigned<T>::type lcast_to_unsigned(T value)
{ {
unsigned int uval = value; typedef BOOST_DEDUCED_TYPENAME make_unsigned<T>::type result_type;
return value < 0 ? -uval : uval; result_type uvalue = static_cast<result_type>(value);
return value < 0 ? -uvalue : uvalue;
} }
inline unsigned long lcast_to_unsigned(long value)
{
unsigned long uval = value;
return value < 0 ? -uval : uval;
}
#if defined(BOOST_HAS_LONG_LONG)
inline boost::ulong_long_type lcast_to_unsigned(boost::long_long_type v)
{
boost::ulong_long_type uval = v;
return v < 0 ? -uval : uval;
}
#elif defined(BOOST_HAS_MS_INT64)
inline unsigned __int64 lcast_to_unsigned(__int64 value)
{
unsigned __int64 uval = value;
return value < 0 ? -uval : uval;
}
#endif
#if (defined _MSC_VER) #if (defined _MSC_VER)
# pragma warning( pop ) // C4146: unary minus operator applied to unsigned type, result still unsigned # pragma warning( pop )
#endif #endif
} }
namespace detail // lcast_put_unsigned namespace detail // lcast_put_unsigned
{ {
// I'd personally put lcast_put_unsigned in .cpp file if not template<class Traits, class T, class CharT>
// boost practice for header-only libraries (Alexander Nasonov).
template<typename T, typename CharT>
CharT* lcast_put_unsigned(T n, CharT* finish) CharT* lcast_put_unsigned(T n, CharT* finish)
{ {
CharT thousands_sep = 0; #ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
BOOST_STATIC_ASSERT(!std::numeric_limits<T>::is_signed);
#endif
#ifdef BOOST_LEXICAL_CAST_ASSUME_C_LOCALE #ifndef BOOST_LEXICAL_CAST_ASSUME_C_LOCALE
char const* grouping = ""; // TODO: use BOOST_NO_STD_LOCALE
std::size_t const grouping_size = 0;
#else
std::locale loc; std::locale loc;
typedef std::numpunct<CharT> numpunct; typedef std::numpunct<CharT> numpunct;
numpunct const& np = BOOST_USE_FACET(numpunct, loc); numpunct const& np = BOOST_USE_FACET(numpunct, loc);
std::string const& grouping = np.grouping(); std::string const& grouping = np.grouping();
std::string::size_type const grouping_size = grouping.size(); std::string::size_type const grouping_size = grouping.size();
CharT thousands_sep = grouping_size ? np.thousands_sep() : 0;
if(grouping_size)
thousands_sep = np.thousands_sep();
#endif
std::string::size_type group = 0; // current group number std::string::size_type group = 0; // current group number
char last_grp_size = grouping[0] <= 0 ? CHAR_MAX : grouping[0]; char last_grp_size = grouping[0] <= 0 ? CHAR_MAX : grouping[0];
// a) Since grouping is const, grouping[grouping.size()] returns 0. // a) Since grouping is const, grouping[grouping.size()] returns 0.
@@ -485,9 +513,15 @@ namespace boost
#endif #endif
char left = last_grp_size; 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 do
{ {
#ifndef BOOST_LEXICAL_CAST_ASSUME_C_LOCALE
if(left == 0) if(left == 0)
{ {
++group; ++group;
@@ -499,14 +533,15 @@ namespace boost
left = last_grp_size; left = last_grp_size;
--finish; --finish;
*finish = thousands_sep; Traits::assign(*finish, thousands_sep);
} }
--left; --left;
#endif
--finish; --finish;
int const digit = static_cast<int>(n % 10); int_type const digit = static_cast<int_type>(n % 10U);
int const cdigit = digit + lcast_char_constants<CharT>::zero; Traits::assign(*finish, Traits::to_char_type(zero + digit));
*finish = static_cast<char>(cdigit);
n /= 10; n /= 10;
} while(n); } while(n);
@@ -516,7 +551,7 @@ namespace boost
namespace detail // stream wrapper for handling lexical conversions namespace detail // stream wrapper for handling lexical conversions
{ {
template<typename Target, typename Source> template<typename Target, typename Source, typename Traits>
class lexical_stream class lexical_stream
{ {
private: private:
@@ -524,6 +559,8 @@ namespace boost
typename stream_char<Target>::type, typename stream_char<Target>::type,
typename stream_char<Source>::type>::type char_type; typename stream_char<Source>::type>::type char_type;
typedef Traits traits_type;
public: public:
lexical_stream(char_type* = 0, char_type* = 0) lexical_stream(char_type* = 0, char_type* = 0)
{ {
@@ -553,9 +590,12 @@ namespace boost
EOF; EOF;
#else #else
std::char_traits<char_type>::eof(); traits_type::eof();
#endif #endif
} }
#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
bool operator>>(std::string &output) bool operator>>(std::string &output)
{ {
#if defined(BOOST_NO_STRINGSTREAM) #if defined(BOOST_NO_STRINGSTREAM)
@@ -571,13 +611,29 @@ namespace boost
return true; return true;
} }
#endif #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: private:
#if defined(BOOST_NO_STRINGSTREAM) #if defined(BOOST_NO_STRINGSTREAM)
std::strstream stream; std::strstream stream;
#elif defined(BOOST_NO_STD_LOCALE) #elif defined(BOOST_NO_STD_LOCALE)
std::stringstream stream; std::stringstream stream;
#else #else
std::basic_stringstream<char_type> stream; std::basic_stringstream<char_type,traits_type> stream;
#endif #endif
}; };
} }
@@ -586,7 +642,8 @@ namespace boost
{ {
// String representation of Source has an upper limit. // String representation of Source has an upper limit.
template< class CharT // a result of widest_char transformation template< class CharT // a result of widest_char transformation
, class Base // lexical_streambuf or lexical_streambuf_fake , class Base // lexical_streambuf_fake or basic_streambuf<CharT>
, class Traits // usually char_traits<CharT>
> >
class lexical_stream_limited_src : public Base class lexical_stream_limited_src : public Base
{ {
@@ -600,19 +657,21 @@ namespace boost
static void widen_and_assign(char*p, char ch) static void widen_and_assign(char*p, char ch)
{ {
*p = ch; Traits::assign(*p, ch);
} }
#ifndef DISABLE_WIDE_CHAR_SUPPORT #ifndef DISABLE_WIDE_CHAR_SUPPORT
static void widen_and_assign(wchar_t* p, char ch) static void widen_and_assign(wchar_t* p, char ch)
{ {
// TODO: use BOOST_NO_STD_LOCALE
std::locale loc; std::locale loc;
*p = BOOST_USE_FACET(std::ctype<wchar_t>, loc).widen(ch); 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) static void widen_and_assign(wchar_t* p, wchar_t ch)
{ {
*p = ch; Traits::assign(*p, ch);
} }
static void widen_and_assign(char*, wchar_t ch); // undefined static void widen_and_assign(char*, wchar_t ch); // undefined
@@ -642,8 +701,8 @@ namespace boost
public: // output public: // output
template<class Traits, class Alloc> template<class Alloc>
bool operator<<(std::basic_string<CharT, Traits, Alloc> const& str) bool operator<<(std::basic_string<CharT,Traits,Alloc> const& str)
{ {
start = const_cast<CharT*>(str.data()); start = const_cast<CharT*>(str.data());
finish = start + str.length(); finish = start + str.length();
@@ -706,7 +765,7 @@ namespace boost
EOF; EOF;
#else #else
std::char_traits<CharT>::eof(); Traits::eof();
#endif #endif
} }
@@ -722,7 +781,7 @@ namespace boost
#endif #endif
#else #else
template<class Traits, class Alloc> template<class Alloc>
bool operator>>(std::basic_string<CharT,Traits,Alloc>& str) bool operator>>(std::basic_string<CharT,Traits,Alloc>& str)
{ {
str.assign(start, finish); str.assign(start, finish);
@@ -731,17 +790,21 @@ namespace boost
#endif #endif
}; };
template<typename CharT, class Base> template<typename CharT, class Base, class Traits>
inline bool lexical_stream_limited_src<CharT,Base>::operator<<( inline bool lexical_stream_limited_src<CharT,Base,Traits>::operator<<(
bool value) bool value)
{ {
*start = value + lcast_char_constants<CharT>::zero; 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; finish = start + 1;
return true; return true;
} }
template<typename CharT, class Base> template<typename CharT, class Base, class Traits>
inline bool lexical_stream_limited_src<CharT,Base>::operator<<(char ch) inline bool lexical_stream_limited_src<CharT,Base,Traits>::operator<<(
char ch)
{ {
widen_and_assign(start, ch); widen_and_assign(start, ch);
finish = start + 1; finish = start + 1;
@@ -749,8 +812,8 @@ namespace boost
} }
#if !defined(DISABLE_WIDE_CHAR_SUPPORT) && !defined(BOOST_NO_INTRINSIC_WCHAR_T) #if !defined(DISABLE_WIDE_CHAR_SUPPORT) && !defined(BOOST_NO_INTRINSIC_WCHAR_T)
template<typename CharT, class Base> template<typename CharT, class Base, class Traits>
inline bool lexical_stream_limited_src<CharT,Base>::operator<<( inline bool lexical_stream_limited_src<CharT,Base,Traits>::operator<<(
wchar_t ch) wchar_t ch)
{ {
widen_and_assign(start, ch); widen_and_assign(start, ch);
@@ -759,140 +822,163 @@ namespace boost
} }
#endif #endif
template<typename CharT, class Base> template<typename CharT, class Base, class Traits>
inline bool lexical_stream_limited_src<CharT,Base>::operator<<(short n) inline bool lexical_stream_limited_src<CharT,Base,Traits>::operator<<(
short n)
{ {
start = lcast_put_unsigned(lcast_to_unsigned(n), finish); start = lcast_put_unsigned<Traits>(lcast_to_unsigned(n), finish);
if(n < 0) if(n < 0)
*--start = lcast_char_constants<CharT>::minus; {
--start;
CharT const minus = lcast_char_constants<CharT>::minus;
Traits::assign(*start, minus);
}
return true; return true;
} }
template<typename CharT, class Base> template<typename CharT, class Base, class Traits>
inline bool lexical_stream_limited_src<CharT,Base>::operator<<(int n) inline bool lexical_stream_limited_src<CharT,Base,Traits>::operator<<(
int n)
{ {
start = lcast_put_unsigned(lcast_to_unsigned(n), finish); start = lcast_put_unsigned<Traits>(lcast_to_unsigned(n), finish);
if(n < 0) if(n < 0)
*--start = lcast_char_constants<CharT>::minus; {
--start;
CharT const minus = lcast_char_constants<CharT>::minus;
Traits::assign(*start, minus);
}
return true; return true;
} }
template<typename CharT, class Base> template<typename CharT, class Base, class Traits>
inline bool lexical_stream_limited_src<CharT,Base>::operator<<(long n) inline bool lexical_stream_limited_src<CharT,Base,Traits>::operator<<(
long n)
{ {
start = lcast_put_unsigned(lcast_to_unsigned(n), finish); start = lcast_put_unsigned<Traits>(lcast_to_unsigned(n), finish);
if(n < 0) if(n < 0)
*--start = lcast_char_constants<CharT>::minus; {
--start;
CharT const minus = lcast_char_constants<CharT>::minus;
Traits::assign(*start, minus);
}
return true; return true;
} }
#if defined(BOOST_HAS_LONG_LONG) #if defined(BOOST_HAS_LONG_LONG)
template<typename CharT, class Base> template<typename CharT, class Base, class Traits>
inline bool lexical_stream_limited_src<CharT,Base>::operator<<( inline bool lexical_stream_limited_src<CharT,Base,Traits>::operator<<(
boost::long_long_type n) boost::long_long_type n)
{ {
start = lcast_put_unsigned(lcast_to_unsigned(n), finish); start = lcast_put_unsigned<Traits>(lcast_to_unsigned(n), finish);
if(n < 0) if(n < 0)
*--start = lcast_char_constants<CharT>::minus; {
--start;
CharT const minus = lcast_char_constants<CharT>::minus;
Traits::assign(*start, minus);
}
return true; return true;
} }
#elif defined(BOOST_HAS_MS_INT64) #elif defined(BOOST_HAS_MS_INT64)
template<typename CharT, class Base> template<typename CharT, class Base, class Traits>
inline bool lexical_stream_limited_src<CharT,Base>::operator<<( inline bool lexical_stream_limited_src<CharT,Base,Traits>::operator<<(
__int64 n) __int64 n)
{ {
start = lcast_put_unsigned(lcast_to_unsigned(n), finish); start = lcast_put_unsigned<Traits>(lcast_to_unsigned(n), finish);
if(n < 0) if(n < 0)
*--start = lcast_char_constants<CharT>::minus; {
--start;
CharT const minus = lcast_char_constants<CharT>::minus;
Traits::assign(*start, minus);
}
return true; return true;
} }
#endif #endif
template<typename CharT, class Base> template<typename CharT, class Base, class Traits>
inline bool lexical_stream_limited_src<CharT,Base>::operator<<( inline bool lexical_stream_limited_src<CharT,Base,Traits>::operator<<(
unsigned short n) unsigned short n)
{ {
start = lcast_put_unsigned(+n, finish); start = lcast_put_unsigned<Traits>(n, finish);
return true; return true;
} }
template<typename CharT, class Base> template<typename CharT, class Base, class Traits>
inline bool lexical_stream_limited_src<CharT,Base>::operator<<( inline bool lexical_stream_limited_src<CharT,Base,Traits>::operator<<(
unsigned int n) unsigned int n)
{ {
start = lcast_put_unsigned(n, finish); start = lcast_put_unsigned<Traits>(n, finish);
return true; return true;
} }
template<typename CharT, class Base> template<typename CharT, class Base, class Traits>
inline bool lexical_stream_limited_src<CharT,Base>::operator<<( inline bool lexical_stream_limited_src<CharT,Base,Traits>::operator<<(
unsigned long n) unsigned long n)
{ {
start = lcast_put_unsigned(n, finish); start = lcast_put_unsigned<Traits>(n, finish);
return true; return true;
} }
#if defined(BOOST_HAS_LONG_LONG) #if defined(BOOST_HAS_LONG_LONG)
template<typename CharT, class Base> template<typename CharT, class Base, class Traits>
inline bool lexical_stream_limited_src<CharT,Base>::operator<<( inline bool lexical_stream_limited_src<CharT,Base,Traits>::operator<<(
boost::ulong_long_type n) boost::ulong_long_type n)
{ {
start = lcast_put_unsigned(n, finish); start = lcast_put_unsigned<Traits>(n, finish);
return true; return true;
} }
#elif defined(BOOST_HAS_MS_INT64) #elif defined(BOOST_HAS_MS_INT64)
template<typename CharT, class Base> template<typename CharT, class Base, class Traits>
inline bool lexical_stream_limited_src<CharT,Base>::operator<<( inline bool lexical_stream_limited_src<CharT,Base,Traits>::operator<<(
unsigned __int64 n) unsigned __int64 n)
{ {
start = lcast_put_unsigned(n, finish); start = lcast_put_unsigned<Traits>(n, finish);
return true; return true;
} }
#endif #endif
template<typename CharT, class Base> template<typename CharT, class Base, class Traits>
inline bool lexical_stream_limited_src<CharT,Base>::operator<<( inline bool lexical_stream_limited_src<CharT,Base,Traits>::operator<<(
float val) float val)
{ {
return this->lcast_put(val); return this->lcast_put(val);
} }
template<typename CharT, class Base> template<typename CharT, class Base, class Traits>
inline bool lexical_stream_limited_src<CharT,Base>::operator<<( inline bool lexical_stream_limited_src<CharT,Base,Traits>::operator<<(
double val) double val)
{ {
return this->lcast_put(val); return this->lcast_put(val);
} }
template<typename CharT, class Base> template<typename CharT, class Base, class Traits>
inline bool lexical_stream_limited_src<CharT,Base>::operator<<( inline bool lexical_stream_limited_src<CharT,Base,Traits>::operator<<(
long double val) long double val)
{ {
return this->lcast_put(val); return this->lcast_put(val);
} }
template<typename CharT, class Base> template<typename CharT, class Base, class Traits>
inline bool lexical_stream_limited_src<CharT,Base>::operator<<( inline bool lexical_stream_limited_src<CharT,Base,Traits>::operator<<(
CharT const* str) CharT const* str)
{ {
start = const_cast<CharT*>(str); start = const_cast<CharT*>(str);
finish = start + std::char_traits<CharT>::length(str); finish = start + Traits::length(str);
return true; return true;
} }
template<typename CharT, class Base> template<typename CharT, class Base, class Traits>
inline bool lexical_stream_limited_src<CharT,Base>::operator>>( inline bool lexical_stream_limited_src<CharT,Base,Traits>::operator>>(
CharT& output) CharT& output)
{ {
bool const ok = (finish - start == 1); bool const ok = (finish - start == 1);
if(ok) if(ok)
output = *start; Traits::assign(output, *start);
return ok; return ok;
} }
#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION #ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
template<typename CharT, class Base> template<typename CharT, class Base, class Traits>
inline bool lexical_stream_limited_src<CharT,Base>::operator>>( inline bool lexical_stream_limited_src<CharT,Base,Traits>::operator>>(
std::string& str) std::string& str)
{ {
str.assign(start, finish); str.assign(start, finish);
@@ -900,8 +986,8 @@ namespace boost
} }
#ifndef DISABLE_WIDE_CHAR_SUPPORT #ifndef DISABLE_WIDE_CHAR_SUPPORT
template<typename CharT, class Base> template<typename CharT, class Base, class Traits>
inline bool lexical_stream_limited_src<CharT,Base>::operator>>( inline bool lexical_stream_limited_src<CharT,Base,Traits>::operator>>(
std::wstring& str) std::wstring& str)
{ {
str.assign(start, finish); str.assign(start, finish);
@@ -913,7 +999,7 @@ namespace boost
namespace detail // lcast_streambuf_for_source namespace detail // lcast_streambuf_for_source
{ {
// Returns true if optimized stream wrapper uses ostream for formatting. // Returns true if optimized stream wrapper needs ostream for writing.
template<class Source> template<class Source>
struct lcast_streambuf_for_source struct lcast_streambuf_for_source
{ {
@@ -941,7 +1027,7 @@ namespace boost
namespace detail // lcast_streambuf_for_target namespace detail // lcast_streambuf_for_target
{ {
// Returns true if optimized stream wrapper use istream for reading. // Returns true if optimized stream wrapper needs istream for reading.
template<class Target> template<class Target>
struct lcast_streambuf_for_target struct lcast_streambuf_for_target
{ {
@@ -1022,17 +1108,20 @@ namespace boost
BOOST_DEDUCED_TYPENAME boost::call_traits<Source>::param_type arg, BOOST_DEDUCED_TYPENAME boost::call_traits<Source>::param_type arg,
CharT* buf, std::size_t src_len) 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< typedef BOOST_DEDUCED_TYPENAME boost::mpl::if_c<
lcast_streambuf_for_target<Target>::value || lcast_streambuf_for_target<Target>::value ||
lcast_streambuf_for_source<Source>::value lcast_streambuf_for_source<Source>::value
, lexical_streambuf<CharT> , std::basic_streambuf<CharT>
, lexical_streambuf_fake<CharT> , lexical_streambuf_fake
>::type base; >::type base;
BOOST_DEDUCED_TYPENAME boost::mpl::if_c< BOOST_DEDUCED_TYPENAME boost::mpl::if_c<
Unlimited Unlimited
, detail::lexical_stream<Target, Source> , detail::lexical_stream<Target,Source,traits>
, detail::lexical_stream_limited_src<CharT,base> , detail::lexical_stream_limited_src<CharT,base,traits>
>::type interpreter(buf, buf + src_len); >::type interpreter(buf, buf + src_len);
// The original form, reproduced below, is more elegant // The original form, reproduced below, is more elegant
@@ -1079,7 +1168,13 @@ namespace boost
template<typename Target, typename Source> template<typename Target, typename Source>
Target lexical_cast(Source arg) Target lexical_cast(Source arg)
{ {
detail::lexical_stream<Target, Source> interpreter; 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; Target result;
if(!(interpreter << arg && interpreter >> result)) if(!(interpreter << arg && interpreter >> result))
@@ -1091,7 +1186,7 @@ namespace boost
} }
// Copyright Kevlin Henney, 2000-2005. // Copyright Kevlin Henney, 2000-2005.
// Copyright Alexander Nasonov, 2006. // Copyright Alexander Nasonov, 2006-2007.
// //
// Distributed under the Boost Software License, Version 1.0. (See // Distributed under the Boost Software License, Version 1.0. (See
// accompanying file LICENSE_1_0.txt or copy at // accompanying file LICENSE_1_0.txt or copy at

15
lexical_cast.htm
View File

@@ -194,7 +194,18 @@ public:
</pre> </pre>
</blockquote>Exception used to indicate runtime <a href="#lexical_cast"><code>lexical_cast</code></a> </blockquote>Exception used to indicate runtime <a href="#lexical_cast"><code>lexical_cast</code></a>
failure. failure.
<hr>
<hr>
<h2><a name="BOOST_LEXICAL_CAST_ASSUME_C_LOCALE"><code>BOOST_LEXICAL_CAST_ASSUME_C_LOCALE</code></a></h2>
<blockquote><pre>#define BOOST_LEXICAL_CAST_ASSUME_C_LOCALE
or,
g++ -DBOOST_LEXICAL_CAST_ASSUME_C_LOCALE ... (gcc on Linux/Unix)
cl.exe /DBOOST_LEXICAL_CAST_ASSUME_C_LOCALE ... (Visual C++ on Windows)
</pre>
Eliminate an overhead of <code>std::locale</code> if your program runs in the "C" locale. If the option is set but a program runs in other locale, <code>lexical_cast</code> result is unspecified.
<hr>
<h2><a name="faq">Frequently Asked Questions</h2> <h2><a name="faq">Frequently Asked Questions</h2>
<p> Q: Why does <code>lexical_cast&lt;int8_t&gt;("127")</code> throw <code>bad_lexical_cast</code>? <p> Q: Why does <code>lexical_cast&lt;int8_t&gt;("127")</code> throw <code>bad_lexical_cast</code>?
@@ -219,7 +230,7 @@ public:
<a name="n1973"></a><li> [N1973] Kevlin Henney, Beman Dawes, Lexical Conversion Library Proposal for TR2, <a name="n1973"></a><li> [N1973] Kevlin Henney, Beman Dawes, Lexical Conversion Library Proposal for TR2,
<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1973.html">N1973</a>. <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1973.html">N1973</a>.
<a name="tuning"></a><li> [Tuning] Alexander Nasonov, Fine Tuning for lexical_cast, <a name="tuning"></a><li> [Tuning] Alexander Nasonov, Fine Tuning for lexical_cast,
<a href="http://www.accu.org/var/uploads/journals/overload74.pdf">Overload #74</a>, <a href="http://accu.org/index.php/journals/1375">Overload #74</a> (<a href="http://www.accu.org/var/uploads/journals/overload74.pdf">PDF</a>),
August 2006.</li> August 2006.</li>
</ul> </ul>
<h2><a name="changes">Changes</a></h2> <h2><a name="changes">Changes</a></h2>

245
lexical_cast_test.cpp
View File

@@ -24,6 +24,9 @@
#include <boost/test/unit_test.hpp> #include <boost/test/unit_test.hpp>
#include <boost/test/floating_point_comparison.hpp> #include <boost/test/floating_point_comparison.hpp>
#include <string>
#include <memory>
#if defined(BOOST_NO_STRINGSTREAM) || \ #if defined(BOOST_NO_STRINGSTREAM) || \
defined(BOOST_NO_STD_WSTRING) || \ defined(BOOST_NO_STD_WSTRING) || \
defined(BOOST_NO_STD_LOCALE) defined(BOOST_NO_STD_LOCALE)
@@ -35,6 +38,16 @@
#define LCAST_TEST_LONGLONG #define LCAST_TEST_LONGLONG
#endif #endif
template<class CharT>
struct my_traits : std::char_traits<CharT>
{
};
template<class CharT>
struct my_allocator : std::allocator<CharT>
{
};
// Test all 65536 values if true: // Test all 65536 values if true:
bool const lcast_test_small_integral_types_completely = false; bool const lcast_test_small_integral_types_completely = false;
@@ -57,15 +70,21 @@ void test_conversion_from_wstring();
void test_conversion_to_wstring(); void test_conversion_to_wstring();
void test_bad_lexical_cast(); void test_bad_lexical_cast();
void test_no_whitespace_stripping(); void test_no_whitespace_stripping();
void test_conversion_from_short(); void test_conversion_from_to_short();
void test_conversion_from_ushort(); void test_conversion_from_to_ushort();
void test_conversion_from_int(); void test_conversion_from_to_int();
void test_conversion_from_uint(); void test_conversion_from_to_uint();
void test_conversion_from_long(); void test_conversion_from_to_long();
void test_conversion_from_ulong(); void test_conversion_from_to_ulong();
#ifdef LCAST_TEST_LONGLONG #ifdef LCAST_TEST_LONGLONG
void test_conversion_from_longlong(); void test_conversion_from_to_longlong();
void test_conversion_from_ulonglong(); void test_conversion_from_to_ulonglong();
#endif
#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
void test_traits();
void test_wtraits();
void test_allocator();
void test_wallocator();
#endif #endif
unit_test::test_suite *init_unit_test_suite(int, char *[]) unit_test::test_suite *init_unit_test_suite(int, char *[])
@@ -87,15 +106,21 @@ unit_test::test_suite *init_unit_test_suite(int, char *[])
#endif #endif
suite->add(BOOST_TEST_CASE(test_bad_lexical_cast)); suite->add(BOOST_TEST_CASE(test_bad_lexical_cast));
suite->add(BOOST_TEST_CASE(test_no_whitespace_stripping)); suite->add(BOOST_TEST_CASE(test_no_whitespace_stripping));
suite->add(BOOST_TEST_CASE(&test_conversion_from_short)); suite->add(BOOST_TEST_CASE(&test_conversion_from_to_short));
suite->add(BOOST_TEST_CASE(&test_conversion_from_ushort)); suite->add(BOOST_TEST_CASE(&test_conversion_from_to_ushort));
suite->add(BOOST_TEST_CASE(&test_conversion_from_int)); suite->add(BOOST_TEST_CASE(&test_conversion_from_to_int));
suite->add(BOOST_TEST_CASE(&test_conversion_from_uint)); suite->add(BOOST_TEST_CASE(&test_conversion_from_to_uint));
suite->add(BOOST_TEST_CASE(&test_conversion_from_ulong)); suite->add(BOOST_TEST_CASE(&test_conversion_from_to_ulong));
suite->add(BOOST_TEST_CASE(&test_conversion_from_long)); suite->add(BOOST_TEST_CASE(&test_conversion_from_to_long));
#ifdef LCAST_TEST_LONGLONG #ifdef LCAST_TEST_LONGLONG
suite->add(BOOST_TEST_CASE(&test_conversion_from_longlong)); suite->add(BOOST_TEST_CASE(&test_conversion_from_to_longlong));
suite->add(BOOST_TEST_CASE(&test_conversion_from_ulonglong)); suite->add(BOOST_TEST_CASE(&test_conversion_from_to_ulonglong));
#endif
#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
suite->add(BOOST_TEST_CASE(&test_traits));
suite->add(BOOST_TEST_CASE(&test_wtraits));
suite->add(BOOST_TEST_CASE(&test_allocator));
suite->add(BOOST_TEST_CASE(&test_wallocator));
#endif #endif
return suite; return suite;
@@ -129,10 +154,15 @@ void test_conversion_to_int()
BOOST_CHECK_EQUAL(0, lexical_cast<int>('0')); BOOST_CHECK_EQUAL(0, lexical_cast<int>('0'));
BOOST_CHECK_THROW(lexical_cast<int>('A'), bad_lexical_cast); BOOST_CHECK_THROW(lexical_cast<int>('A'), bad_lexical_cast);
BOOST_CHECK_EQUAL(1, lexical_cast<int>(1)); BOOST_CHECK_EQUAL(1, lexical_cast<int>(1));
BOOST_CHECK_EQUAL(1, lexical_cast<int>(1.0));
BOOST_CHECK_EQUAL( BOOST_CHECK_EQUAL(
(std::numeric_limits<int>::max)(), (std::numeric_limits<int>::max)(),
lexical_cast<int>((std::numeric_limits<int>::max)())); lexical_cast<int>((std::numeric_limits<int>::max)()));
BOOST_CHECK_EQUAL(1, lexical_cast<int>(1.0));
BOOST_CHECK_EQUAL(
(std::numeric_limits<int>::min)(),
lexical_cast<int>((std::numeric_limits<int>::min)()));
BOOST_CHECK_THROW(lexical_cast<int>(1.23), bad_lexical_cast); BOOST_CHECK_THROW(lexical_cast<int>(1.23), bad_lexical_cast);
@@ -407,7 +437,7 @@ void test_conversion_from_integral_to_char(CharT zero)
BOOST_CHECK_THROW(lexical_cast<CharT>(static_cast<T>(10)), bad_lexical_cast); BOOST_CHECK_THROW(lexical_cast<CharT>(static_cast<T>(10)), bad_lexical_cast);
T t = std::numeric_limits<T>::max(); T t = (std::numeric_limits<T>::max)();
BOOST_CHECK_THROW(lexical_cast<CharT>(t), bad_lexical_cast); BOOST_CHECK_THROW(lexical_cast<CharT>(t), bad_lexical_cast);
} }
@@ -427,10 +457,10 @@ void test_conversion_from_integral_to_integral()
BOOST_CHECK(lexical_cast<long>(t) == st); BOOST_CHECK(lexical_cast<long>(t) == st);
BOOST_CHECK(lexical_cast<unsigned long>(t) == ut); BOOST_CHECK(lexical_cast<unsigned long>(t) == ut);
t = std::numeric_limits<T>::max(); t = (std::numeric_limits<T>::max)();
BOOST_CHECK(lexical_cast<T>(t) == t); BOOST_CHECK(lexical_cast<T>(t) == t);
t = std::numeric_limits<T>::min(); t = (std::numeric_limits<T>::min)();
BOOST_CHECK(lexical_cast<T>(t) == t); BOOST_CHECK(lexical_cast<T>(t) == t);
} }
@@ -442,19 +472,20 @@ void test_conversion_from_integral_to_string(CharT)
T t; T t;
t = limits::min(); t = (limits::min)();
BOOST_CHECK(lexical_cast<string_type>(t) == to_str<CharT>(t)); BOOST_CHECK(lexical_cast<string_type>(t) == to_str<CharT>(t));
t = limits::max(); t = (limits::max)();
BOOST_CHECK(lexical_cast<string_type>(t) == to_str<CharT>(t)); BOOST_CHECK(lexical_cast<string_type>(t) == to_str<CharT>(t));
if(limits::digits <= 16 && lcast_test_small_integral_types_completely) if(limits::digits <= 16 && lcast_test_small_integral_types_completely)
for(t = 1 + limits::min(); t != limits::max(); ++t) // min and max have already been tested.
for(t = 1 + (limits::min)(); t != (limits::max)(); ++t)
BOOST_CHECK(lexical_cast<string_type>(t) == to_str<CharT>(t)); BOOST_CHECK(lexical_cast<string_type>(t) == to_str<CharT>(t));
else else
{ {
T const min_val = limits::min(); T const min_val = (limits::min)();
T const max_val = limits::max(); T const max_val = (limits::max)();
T const half_max_val = max_val / 2; T const half_max_val = max_val / 2;
T const cnt = lcast_integral_test_counter; // to supress warnings T const cnt = lcast_integral_test_counter; // to supress warnings
unsigned int const counter = cnt < half_max_val ? cnt : half_max_val; unsigned int const counter = cnt < half_max_val ? cnt : half_max_val;
@@ -480,20 +511,75 @@ void test_conversion_from_integral_to_string(CharT)
T ten_power = 100; T ten_power = 100;
for(int e = 2; e <= limits::digits10; ++e, ten_power *= 10) for(int e = 2; e <= limits::digits10; ++e, ten_power *= 10)
{ {
// I believe that (ten_power + 100) never overflows // ten_power + 100 probably never overflows
for(t = ten_power - 100; t != ten_power + 100; ++t) for(t = ten_power - 100; t != ten_power + 100; ++t)
BOOST_CHECK(lexical_cast<string_type>(t) == to_str<CharT>(t)); BOOST_CHECK(lexical_cast<string_type>(t) == to_str<CharT>(t));
} }
} }
} }
template<class T, class CharT>
void test_conversion_from_string_to_integral(CharT)
{
typedef std::numeric_limits<T> limits;
T t;
t = (limits::min)();
BOOST_CHECK(lexical_cast<T>(to_str<CharT>(t)) == t);
t = (limits::max)();
BOOST_CHECK(lexical_cast<T>(to_str<CharT>(t)) == t);
if(limits::digits <= 16 && lcast_test_small_integral_types_completely)
// min and max have already been tested.
for(t = 1 + (limits::min)(); t != (limits::max)(); ++t)
BOOST_CHECK(lexical_cast<T>(to_str<CharT>(t)) == t);
else
{
T const min_val = (limits::min)();
T const max_val = (limits::max)();
T const half_max_val = max_val / 2;
T const cnt = lcast_integral_test_counter; // to supress warnings
unsigned int const counter = cnt < half_max_val ? cnt : half_max_val;
unsigned int i;
// Test values around min:
t = min_val;
for(i = 0; i < counter; ++i, ++t)
BOOST_CHECK(lexical_cast<T>(to_str<CharT>(t)) == t);
// Test values around max:
t = max_val;
for(i = 0; i < counter; ++i, --t)
BOOST_CHECK(lexical_cast<T>(to_str<CharT>(t)) == t);
// Test values around zero:
if(limits::is_signed)
for(t = -counter; t < static_cast<T>(counter); ++t)
BOOST_CHECK(lexical_cast<T>(to_str<CharT>(t)) == t);
// Test values around 100, 1000, 10000, ...
T ten_power = 100;
for(int e = 2; e <= limits::digits10; ++e, ten_power *= 10)
{
// ten_power + 100 probably never overflows
for(t = ten_power - 100; t != ten_power + 100; ++t)
BOOST_CHECK(lexical_cast<T>(to_str<CharT>(t)) == t);
}
}
}
template<class T> template<class T>
void test_conversion_from_integral_for_locale() void test_conversion_from_to_integral_for_locale()
{ {
test_conversion_from_integral_to_integral<T>(); test_conversion_from_integral_to_integral<T>();
test_conversion_from_integral_to_string<T>('0'); test_conversion_from_integral_to_string<T>('0');
test_conversion_from_string_to_integral<T>('0');
#if !defined(DISABLE_WIDE_CHAR_SUPPORT) && !defined(BOOST_NO_INTRINSIC_WCHAR_T) #if !defined(DISABLE_WIDE_CHAR_SUPPORT) && !defined(BOOST_NO_INTRINSIC_WCHAR_T)
test_conversion_from_integral_to_string<T>(L'0'); test_conversion_from_integral_to_string<T>(L'0');
test_conversion_from_string_to_integral<T>(L'0');
#endif #endif
} }
@@ -504,7 +590,7 @@ struct restore_oldloc
}; };
template<class T> template<class T>
void test_conversion_from_integral() void test_conversion_from_to_integral()
{ {
char const zero = '0'; char const zero = '0';
signed char const szero = '0'; signed char const szero = '0';
@@ -517,7 +603,7 @@ void test_conversion_from_integral()
test_conversion_from_integral_to_char<T>(wzero); test_conversion_from_integral_to_char<T>(wzero);
#endif #endif
// test_conversion_from_integral_for_locale // test_conversion_from_to_integral_for_locale
typedef std::numpunct<char> numpunct; typedef std::numpunct<char> numpunct;
@@ -527,7 +613,7 @@ void test_conversion_from_integral()
std::string grouping1 = BOOST_USE_FACET(numpunct, oldloc).grouping(); std::string grouping1 = BOOST_USE_FACET(numpunct, oldloc).grouping();
std::string grouping2(grouping1); std::string grouping2(grouping1);
test_conversion_from_integral_for_locale<T>(); test_conversion_from_to_integral_for_locale<T>();
try try
{ {
@@ -544,64 +630,121 @@ void test_conversion_from_integral()
} }
if(grouping1 != grouping2) if(grouping1 != grouping2)
test_conversion_from_integral_for_locale<T>(); test_conversion_from_to_integral_for_locale<T>();
if(grouping1.empty() && grouping2.empty()) if(grouping1.empty() && grouping2.empty())
BOOST_TEST_MESSAGE("Formatting with thousands_sep has not been tested"); BOOST_TEST_MESSAGE("Formatting with thousands_sep has not been tested");
} }
void test_conversion_from_short() void test_conversion_from_to_short()
{ {
test_conversion_from_integral<short>(); test_conversion_from_to_integral<short>();
} }
void test_conversion_from_ushort() void test_conversion_from_to_ushort()
{ {
test_conversion_from_integral<unsigned short>(); test_conversion_from_to_integral<unsigned short>();
} }
void test_conversion_from_int() void test_conversion_from_to_int()
{ {
test_conversion_from_integral<int>(); test_conversion_from_to_integral<int>();
} }
void test_conversion_from_uint() void test_conversion_from_to_uint()
{ {
test_conversion_from_integral<unsigned int>(); test_conversion_from_to_integral<unsigned int>();
} }
void test_conversion_from_ulong() void test_conversion_from_to_ulong()
{ {
test_conversion_from_integral<unsigned long>(); test_conversion_from_to_integral<unsigned long>();
} }
void test_conversion_from_long() void test_conversion_from_to_long()
{ {
test_conversion_from_integral<long>(); test_conversion_from_to_integral<long>();
} }
#if defined(BOOST_HAS_LONG_LONG) #if defined(BOOST_HAS_LONG_LONG)
void test_conversion_from_longlong() void test_conversion_from_to_longlong()
{ {
test_conversion_from_integral<boost::long_long_type>(); test_conversion_from_to_integral<boost::long_long_type>();
} }
void test_conversion_from_ulonglong() void test_conversion_from_to_ulonglong()
{ {
test_conversion_from_integral<boost::ulong_long_type>(); test_conversion_from_to_integral<boost::ulong_long_type>();
} }
#elif defined(LCAST_TEST_LONGLONG) #elif defined(LCAST_TEST_LONGLONG)
void test_conversion_from_longlong() void test_conversion_from_to_longlong()
{ {
test_conversion_from_integral<__int64>(); test_conversion_from_to_integral<__int64>();
} }
void test_conversion_from_ulonglong() void test_conversion_from_to_ulonglong()
{ {
test_conversion_from_integral<unsigned __int64>(); test_conversion_from_to_integral<unsigned __int64>();
}
#endif
#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
void test_traits()
{
typedef std::basic_string<char, my_traits<char> > my_string;
my_string const s("s");
BOOST_CHECK(boost::lexical_cast<char>(s) == s[0]);
BOOST_CHECK(boost::lexical_cast<my_string>(s) == s);
BOOST_CHECK(boost::lexical_cast<my_string>(-1) == "-1");
}
void test_wtraits()
{
typedef std::basic_string<wchar_t, my_traits<wchar_t> > my_string;
my_string const s(L"s");
BOOST_CHECK(boost::lexical_cast<wchar_t>(s) == s[0]);
BOOST_CHECK(boost::lexical_cast<my_string>(s) == s);
//BOOST_CHECK(boost::lexical_cast<my_string>(-1) == L"-1");
// Commented out because gcc 3.3 doesn't support this:
// basic_ostream<wchar_t, my_traits<wchar_t> > o; o << -1;
}
void test_allocator()
{
typedef std::basic_string< char
, std::char_traits<char>
, my_allocator<char>
> my_string;
my_string s("s");
BOOST_CHECK(boost::lexical_cast<char>(s) == s[0]);
BOOST_CHECK(boost::lexical_cast<std::string>(s) == "s");
BOOST_CHECK(boost::lexical_cast<my_string>(s) == s);
BOOST_CHECK(boost::lexical_cast<my_string>(1) == "1");
BOOST_CHECK(boost::lexical_cast<my_string>("s") == s);
BOOST_CHECK(boost::lexical_cast<my_string>(std::string("s")) == s);
}
void test_wallocator()
{
typedef std::basic_string< wchar_t
, std::char_traits<wchar_t>
, my_allocator<wchar_t>
> my_string;
my_string s(L"s");
BOOST_CHECK(boost::lexical_cast<wchar_t>(s) == s[0]);
BOOST_CHECK(boost::lexical_cast<std::wstring>(s) == L"s");
BOOST_CHECK(boost::lexical_cast<my_string>(s) == s);
BOOST_CHECK(boost::lexical_cast<my_string>(1) == L"1");
BOOST_CHECK(boost::lexical_cast<my_string>(L"s") == s);
BOOST_CHECK(boost::lexical_cast<my_string>(std::wstring(L"s")) == s);
} }
#endif #endif