Subject: [Boost-commit] svn:boost r73323 - trunk/boost
From: antoshkka_at_[hidden]
Date: 2011-07-24 05:42:09
Author: apolukhin
Date: 2011-07-24 05:42:06 EDT (Sun, 24 Jul 2011)
New Revision: 73323
URL: http://svn.boost.org/trac/boost/changeset/73323
Log:
Fixes #5732.
* fixes performance regression, that was added by previous commit
* fixes float types preformance regression for old compilers
Text files modified:
trunk/boost/lexical_cast.hpp | 108 +++++++++++++++++++++++++++------------
1 files changed, 73 insertions(+), 35 deletions(-)
Modified: trunk/boost/lexical_cast.hpp
==============================================================================
--- trunk/boost/lexical_cast.hpp (original)
+++ trunk/boost/lexical_cast.hpp 2011-07-24 05:42:06 EDT (Sun, 24 Jul 2011)
@@ -25,6 +25,7 @@
#include <istream>
#include <string>
#include <cstring>
+#include <cstdio>
#include <typeinfo>
#include <exception>
#include <cmath>
@@ -35,6 +36,7 @@
#include <boost/type_traits/is_pointer.hpp>
#include <boost/type_traits/is_integral.hpp>
#include <boost/type_traits/is_arithmetic.hpp>
+#include <boost/type_traits/remove_pointer.hpp>
#include <boost/numeric/conversion/cast.hpp>
#include <boost/type_traits/ice.hpp>
#include <boost/type_traits/make_unsigned.hpp>
@@ -1003,6 +1005,7 @@
// String representation of Source has an upper limit.
template< class CharT // a result of widest_char transformation
, class Traits // usually char_traits<CharT>
+ , bool RequiresStringbuffer
>
class lexical_stream_limited_src
{
@@ -1015,25 +1018,23 @@
#else
typedef stl_buf_unlocker<std::basic_stringbuf<CharT, Traits>, CharT > local_stringbuffer_t;
#endif
+ typedef BOOST_DEDUCED_TYPENAME ::boost::mpl::if_c<
+ RequiresStringbuffer,
+ local_stringbuffer_t,
+ char
+ >::type deduced_stringbuffer_t;
+
// A string representation of Source is written to [start, finish).
- // Currently, it is assumed that [start, finish) is big enough
- // to hold a string representation of any Source value.
CharT* start;
CharT* finish;
- local_stringbuffer_t *stringbuf;
+ deduced_stringbuffer_t stringbuffer;
public:
lexical_stream_limited_src(CharT* sta, CharT* fin)
: start(sta)
, finish(fin)
- , stringbuf(NULL)
{}
- ~lexical_stream_limited_src()
- {
- if (stringbuf) delete stringbuf;
- }
-
private:
// Undefined:
lexical_stream_limited_src(lexical_stream_limited_src const&);
@@ -1078,7 +1079,7 @@
bool shl_char_array(T const* str)
{
BOOST_STATIC_ASSERT_MSG(( sizeof(T) <= sizeof(CharT)),
- "boost::lexical_cast does not support conversions from whar_t to char types."
+ "boost::lexical_cast does not support conversions from wchar_t to char types."
"Use boost::locale instead" );
return shl_input_streamable(str);
}
@@ -1087,15 +1088,10 @@
template<typename InputStreamable>
bool shl_input_streamable(InputStreamable& input)
{
- /* No one will call this function twice,
- * so we do not need `if (!stringbuf)' */
- stringbuf = new local_stringbuffer_t();
-
- std::basic_ostream<CharT> stream(stringbuf);
- lcast_set_precision(stream, static_cast<InputStreamable*>(0));
+ std::basic_ostream<CharT> stream(&stringbuffer);
bool const result = !(stream << input).fail();
- start = stringbuf->pbase();
- finish = stringbuf->pptr();
+ start = stringbuffer.pbase();
+ finish = stringbuffer.pptr();
return result;
}
@@ -1112,18 +1108,44 @@
return true;
}
-#ifndef BOOST_LCAST_NO_COMPILE_TIME_PRECISION
template <class T>
- bool shl_float_types(T val)
- {
- if (put_inf_nan(start, finish, val)) return true;
- local_streambuffer_t bb;
- bb.setp(start, finish);
- std::basic_ostream<CharT> stream(&bb);
- lcast_set_precision(stream, &val);
- bool const result = !(stream << val).fail();
- finish = bb.pptr();
- return result;
+ bool shl_float(float val,T* out)
+ { using namespace std;
+ finish = start + sprintf(out,"%.*g", static_cast<int>(boost::detail::lcast_get_precision<float >()), val );
+ return finish > start;
+ }
+
+ template <class T>
+ bool shl_double(double val,T* out)
+ { using namespace std;
+ finish = start + sprintf(out,"%.*lg", static_cast<int>(boost::detail::lcast_get_precision<double >()), val );
+ return finish > start;
+ }
+
+ template <class T>
+ bool shl_long_double(long double val,T* out)
+ { using namespace std;
+ finish = start + sprintf(out,"%.*Lg", static_cast<int>(boost::detail::lcast_get_precision<long double >()), val );
+ return finish > start;
+ }
+
+#ifndef BOOST_LCAST_NO_WCHAR_T
+ bool shl_float(float val,wchar_t* out)
+ { using namespace std;
+ finish = start + swprintf(out,finish-start,L"%.*g", static_cast<int>(boost::detail::lcast_get_precision<float >()), val );
+ return finish > start;
+ }
+
+ bool shl_double(double val,wchar_t* out)
+ { using namespace std;
+ finish = start + swprintf(out,finish-start,L"%.*lg", static_cast<int>(boost::detail::lcast_get_precision<double >()), val );
+ return finish > start;
+ }
+
+ bool shl_long_double(long double val,wchar_t* out)
+ { using namespace std;
+ finish = start + swprintf(out,finish-start,L"%.*Lg", static_cast<int>(boost::detail::lcast_get_precision<long double >()), val );
+ return finish > start;
}
#endif
@@ -1171,11 +1193,9 @@
bool operator<<(unsigned __int64 n) { start = lcast_put_unsigned<Traits>(n, finish); return true; }
bool operator<<( __int64 n) { return shl_signed(n); }
#endif
-#ifndef BOOST_LCAST_NO_COMPILE_TIME_PRECISION
- bool operator<<(float val) { return shl_float_types(val); }
- bool operator<<(double val) { return shl_float_types(val); }
- bool operator<<(long double val) { return shl_float_types(val); }
-#endif // BOOST_LCAST_NO_COMPILE_TIME_PRECISION
+ bool operator<<(float val) { return shl_float(val,start); }
+ bool operator<<(double val) { return shl_double(val,start); }
+ bool operator<<(long double val) { return shl_long_double(val,start); }
template<class InStreamable>
bool operator<<(const InStreamable& input) { return shl_input_streamable(input); }
@@ -1586,7 +1606,25 @@
typedef BOOST_DEDUCED_TYPENAME
deduce_char_traits<char_type,Target,Source>::type traits;
- detail::lexical_stream_limited_src<char_type,traits> interpreter(buf, buf + src_len);
+ typedef BOOST_DEDUCED_TYPENAME remove_pointer<src >::type removed_ptr_t;
+ const bool requires_stringbuf =
+ !(
+ ::boost::type_traits::ice_or<
+ is_stdstring<src >::value,
+ is_arithmetic<src >::value,
+ ::boost::type_traits::ice_and<
+ is_pointer<src >::value,
+ is_char_or_wchar<removed_ptr_t >::value,
+ ::boost::type_traits::ice_eq<
+ sizeof(char_type),
+ sizeof(removed_ptr_t)
+ >::value
+ >::value
+ >::value
+ );
+
+ detail::lexical_stream_limited_src<char_type,traits, requires_stringbuf >
+ interpreter(buf, buf + src_len);
Target result;
if(!(interpreter << arg && interpreter >> result))