Release 1.54.0

[SVN r84923]
2026-08-04 20:44:11 +02:00 · 2013-07-01 16:53:14 +00:00
29 changed files with 1414 additions and 1208 deletions
@@ -10,13 +10,6 @@
    <meta name="ProgId" content="FrontPage.Editor.Document">

    <title>Header boost/cast.hpp Documentation</title>
-    <style>
-       .copyright
-        {
-            color: #666666;
-            font-size: small;
-        }
-    </style>
  </head>

  <body bgcolor="#FFFFFF" text="#000000">
@@ -138,9 +131,10 @@ void f( Fruit * fruit ) {
                    -->June 23, 2005<!--webbot bot="Timestamp" endspan i-checksum="30348"
                    --></p>

-    <p class="copyright">&copy; Copyright boost.org 1999. 
-    Distributed under the Boost Software License, Version 1.0. (See accompanying
-    file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</a>)
-    </p>
+    <p>&copy; Copyright boost.org 1999. Permission to copy, use, modify, sell
+    and distribute this document is granted provided this copyright notice
+    appears in all copies. This document is provided "as is" without express
+    or implied warranty, and with no claim as to its suitability for any
+    purpose.</p>
  </body>
-</html>
+</html>
@@ -38,22 +38,54 @@ For a good discussion of the options and issues involved in string-based formatt
 [endsect]

 [section Examples]
+The following example treats command line arguments as a sequence of numeric data:
+``
+    int main(int argc, char * argv[])
+    {
+        using boost::lexical_cast;
+        using boost::bad_lexical_cast;

-[import ../example/args_to_numbers.cpp]
+        std::vector<short> args;

-[section Strings to numbers conversion] [lexical_cast_args_example] [endsect]
-
-[import ../example/small_examples.cpp]
-[section Numbers to strings conversion] [lexical_cast_log_errno] [endsect]
-[section Converting to string without dynamic memory allocation] [lexical_cast_fixed_buffer] [endsect]
-[section Converting part of the string] [lexical_cast_substring_conversion] [endsect]
-
-[import ../example/generic_stringize.cpp]
-[section Generic programming (Boost.Fusion)] [lexical_cast_stringize] [endsect]
-
-[import ../example/variant_to_long_double.cpp]
-[section Generic programming (Boost.Variant)] [lexical_cast_variant_to_long_double] [endsect]
+        while(*++argv)
+        {
+            try
+            {
+                args.push_back(lexical_cast<short>(*argv));
+            }
+            catch(bad_lexical_cast &)
+            {
+                args.push_back(0);
+            }
+        }
+        ...
+    }
+``
+The following example uses numeric data in a string expression:
+``
+    void log_message(const std::string &);

+    void log_errno(int yoko)
+    {
+        log_message("Error " + boost::lexical_cast<std::string>(yoko) + ": " + strerror(yoko));
+    }
+``
+Following example converts some number and puts it to file:
+``
+    int i;
+    FILE* file;
+    ...
+    typedef boost::array<char, 50> buf_t; // You can use std::array if your compiler supports it
+    buf_t buffer = boost::lexical_cast<buf_t>(i); // No dynamic memory allocation
+    puts(buffer.begin(), file);
+``
+Following example takes part of the string and converts it to `int`:
+``
+int convert_strings_part(const std::string& s, std::size_t pos, std::size_t n) 
+{
+    return boost::lexical_cast<int>(s.data() + pos, n);
+}
+``
 [endsect]

 [section Synopsis]
@@ -124,6 +156,56 @@ Exception used to indicate runtime lexical_cast failure.

 [endsect]

+[/ Commenting out bad advise (this will break the ability to get correct function pointers via &lexical_cast<Target, Source>)
+[section Tuning classes for fast lexical conversions]
+Because of `boost::lexical_cast` optimizations for `boost::iterator_range<character_type*>`, it is possibile to make very fast lexical conversions for non zero terminated strings, substrings and user-defined classes.
+
+Consider the following example:
+``
+    class example_class {
+        char non_zero_terminated_data[10];
+        std::size_t data_length;
+
+    public:
+        example_class();
+        void fill_data();
+
+        const char* data() const {
+            return non_zero_terminated_data;
+        }
+
+        std::size_t size() const {
+            return data_length;
+        }
+    };
+
+    inline std::ostream& operator << (std::ostream& ostr, const example_class& rhs) {
+        return ostr << boost::make_iterator_range(rhs.data(), rhs.data() + rhs.size());
+    }
+``
+
+This is a good generic solution for most use cases.
+But we can make it even faster for some performance critical applications. During conversion, we loose speed at:
+
+ * `std::ostream` construction     (it makes some heap allocations)
+ * `operator <<`                   (it copyies one by one all the symbols to an instance of `std::ostream`)
+ * `std::ostream` destruction      (it makes some heap deallocations)
+
+We can avoid all of this, by specifieng an overload for `boost::lexical_cast`:
+``
+namespace boost {
+    template <class OutT>
+    OutT lexical_cast(const example_class& rhs) {
+        return boost::lexical_cast<OutT>(
+            boost::make_iterator_range(rhs.data(), rhs.data() + rhs.size())
+        );
+    }
+}
+``
+Now `boost::lexical_cast<some_type>(example_class_instance)` conversions won't copy data and construct heavy STL stream objects. See [link boost_lexical_cast.performance Performance] section for info on `boost::iterator_range` conversion performance.
+[endsect]
+]
+
 [section Frequently Asked Questions]

 * [*Question:]    Why does `lexical_cast<int8_t>("127")` throw `bad_lexical_cast`?
@@ -194,11 +276,6 @@ limitation of compiler options that you use.

 [section Changes]

-* [*boost 1.54.0 :]
-
-    * Fix some issues with `boost::int128_type` and `boost::uint128_type` conversions. Notify user at compile time 
-      if the `std::numeric_limits` are not specialized for 128bit types and `boost::lexical_cast` can not make conversions.
-
 * [*boost 1.54.0 :]

    * Added code to convert `boost::int128_type` and `boost::uint128_type` types (requires GCC 4.7 or higher).
@@ -1,35 +0,0 @@
-// Copyright 2013 Antony Polukhin
-
-// Distributed under the Boost Software License, Version 1.0.
-// (See the accompanying file LICENSE_1_0.txt
-// or a copy at <http://www.boost.org/LICENSE_1_0.txt>.)
-
-//[lexical_cast_args_example
-//`The following example treats command line arguments as a sequence of numeric data
-
-#include <boost/lexical_cast.hpp>
-#include <vector>
-
-int main(int /*argc*/, char * argv[])
-{
-    using boost::lexical_cast;
-    using boost::bad_lexical_cast;
-
-    std::vector<short> args;
-
-    while (*++argv)
-    {
-        try
-        {
-            args.push_back(lexical_cast<short>(*argv));
-        }
-        catch(const bad_lexical_cast &)
-        {
-            args.push_back(0);
-        }
-    }
-
-    // ...
-}
-
-//] [/lexical_cast_args_example]
@@ -1,61 +0,0 @@
-// Copyright 2013 Antony Polukhin
-
-// Distributed under the Boost Software License, Version 1.0.
-// (See the accompanying file LICENSE_1_0.txt
-// or a copy at <http://www.boost.org/LICENSE_1_0.txt>.)
-
-
-//[lexical_cast_stringize
-/*`
-    In this example we'll make a `stringize` method that accepts a sequence, converts
-    each element of the sequence into string and appends that string to the result.
-
-    Example is based on the example from the [@http://www.packtpub.com/boost-cplusplus-application-development-cookbook/book Boost C++ Application Development Cookbook]
-    by Antony Polukhin, ISBN 9781849514880.
-
-    Step 1: Making a functor that converts any type to a string and remembers result:
-*/
-
-#include <boost/lexical_cast.hpp>
-
-struct stringize_functor {
-private:
-    std::string& result;
-
-public:
-    explicit stringize_functor(std::string& res)
-        : result(res)
-    {}
-
-    template <class T>
-    void operator()(const T& v) const {
-        result += boost::lexical_cast<std::string>(v);
-    }
-};
-
-//` Step 2: Applying `stringize_functor` to each element in sequence:
-#include <boost/fusion/include/for_each.hpp>
-template <class Sequence>
-std::string stringize(const Sequence& seq) {
-    std::string result;
-    boost::fusion::for_each(seq, stringize_functor(result));
-    return result;
-}
-
-//` Step 3: Using the `stringize` with different types:
-#include <cassert>
-#include <boost/fusion/adapted/boost_tuple.hpp>
-#include <boost/fusion/adapted/std_pair.hpp>
-
-int main() {
-    boost::tuple<char, int, char, int> decim('-', 10, 'e', 5);
-    assert(stringize(decim) == "-10e5");
-
-    std::pair<short, std::string> value_and_type(270, "Kelvin");
-    assert(stringize(value_and_type) == "270Kelvin");
-}
-
-//] [/lexical_cast_stringize]
-
-
-
@@ -1,52 +0,0 @@
-// Copyright 2013 Antony Polukhin
-
-// Distributed under the Boost Software License, Version 1.0.
-// (See the accompanying file LICENSE_1_0.txt
-// or a copy at <http://www.boost.org/LICENSE_1_0.txt>.)
-
-#include <boost/lexical_cast.hpp>
-#include <string>
-#include <cstdio>
-
-//[lexical_cast_log_errno
-//`The following example uses numeric data in a string expression: 
-
-void log_message(const std::string &);
-
-void log_errno(int yoko)
-{
-    log_message("Error " + boost::lexical_cast<std::string>(yoko) + ": " + strerror(yoko));
-}
-
-//] [/lexical_cast_log_errno]
-
-
-//[lexical_cast_fixed_buffer
-//`The following example converts some number and puts it to file:
-
-void number_to_file(int number, FILE* file)
-{
-    typedef boost::array<char, 50> buf_t; // You can use std::array if your compiler supports it
-    buf_t buffer = boost::lexical_cast<buf_t>(number); // No dynamic memory allocation
-    fputs(buffer.begin(), file);
-}
-
-//] [/lexical_cast_fixed_buffer]
-
-//[lexical_cast_substring_conversion
-//`The following example takes part of the string and converts it to `int`:
-
-int convert_strings_part(const std::string& s, std::size_t pos, std::size_t n)
-{
-    return boost::lexical_cast<int>(s.data() + pos, n);
-}
-
-//] [/lexical_cast_substring_conversion]
-
-void log_message(const std::string &) {}
-
-int main()
-{
-    return 0;
-}
-
@@ -1,39 +0,0 @@
-// Copyright 2013 Antony Polukhin
-
-// Distributed under the Boost Software License, Version 1.0.
-// (See the accompanying file LICENSE_1_0.txt
-// or a copy at <http://www.boost.org/LICENSE_1_0.txt>.)
-
-
-//[lexical_cast_variant_to_long_double
-/*`
-    In this example we'll make a `to_long_double` method that converts value of the Boost.Variant to `long double`.
-*/
-
-#include <boost/lexical_cast.hpp>
-#include <boost/variant.hpp>
-#include <cassert>
-
-struct to_long_double_functor: boost::static_visitor<long double> {
-    template <class T>
-    long double operator()(const T& v) const {
-        // Lexical cast has many optimizations including optimizations for situations that usually 
-        // occur in generic programming, like std::string to std::string or arithmetic type to arithmetic type conversion. 
-        return boost::lexical_cast<long double>(v);
-    }
-};
-
-// Throws `boost::bad_lexical_cast` if value of the variant is not convertible to `long double`
-template <class Variant>
-long double to_long_double(const Variant& v) {
-    return boost::apply_visitor(to_long_double_functor(), v);
-}
-
-int main() {
-    boost::variant<char, int, std::string> v1('0'), v2("10.0001"), v3(1);
-
-    long double sum = to_long_double(v1) + to_long_double(v2) + to_long_double(v3);
-    assert(sum > 11 && sum < 11.1);
-}
-
-//] [/lexical_cast_variant_to_long_double]
@@ -50,6 +50,17 @@
 # include <boost/limits.hpp>
 # include <boost/detail/select_type.hpp>

+//  It has been demonstrated numerous times that MSVC 6.0 fails silently at link
+//  time if you use a template function which has template parameters that don't
+//  appear in the function's argument list.
+//
+//  TODO: Add this to config.hpp?
+# if defined(BOOST_MSVC) && BOOST_MSVC < 1300
+#  define BOOST_EXPLICIT_DEFAULT_TARGET , ::boost::type<Target>* = 0
+# else
+#  define BOOST_EXPLICIT_DEFAULT_TARGET
+# endif
+
 namespace boost
 {
 //  See the documentation for descriptions of how to choose between
@@ -62,7 +73,7 @@ namespace boost
    //  section 15.8 exercise 1, page 425.

    template <class Target, class Source>
-    inline Target polymorphic_cast(Source* x)
+    inline Target polymorphic_cast(Source* x BOOST_EXPLICIT_DEFAULT_TARGET)
    {
        Target tmp = dynamic_cast<Target>(x);
        if ( tmp == 0 ) throw std::bad_cast();
@@ -81,12 +92,14 @@ namespace boost
    //  Contributed by Dave Abrahams

    template <class Target, class Source>
-    inline Target polymorphic_downcast(Source* x)
+    inline Target polymorphic_downcast(Source* x BOOST_EXPLICIT_DEFAULT_TARGET)
    {
        BOOST_ASSERT( dynamic_cast<Target>(x) == x );  // detect logic error
        return static_cast<Target>(x);
    }

+#  undef BOOST_EXPLICIT_DEFAULT_TARGET
+
 } // namespace boost

 # include <boost/numeric/conversion/cast.hpp>
@@ -1,139 +0,0 @@
-//-----------------------------------------------------------------------------
-// boost detail/templated_streams.hpp header file
-// See http://www.boost.org for updates, documentation, and revision history.
-//-----------------------------------------------------------------------------
-//
-// Copyright (c) 2013 John Maddock, Antony Polukhin
-// 
-//
-// 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)
-
-#ifndef BOOST_DETAIL_BASIC_POINTERBUF_HPP
-#define BOOST_DETAIL_BASIC_POINTERBUF_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-#include "boost/config.hpp"
-#include <streambuf>
-
-namespace boost { namespace detail {
-
-//
-// class basic_pointerbuf:
-// acts as a stream buffer which wraps around a pair of pointers:
-//
-template <class charT, class BufferT >
-class basic_pointerbuf : public BufferT {
-protected:
-   typedef BufferT base_type;
-   typedef basic_pointerbuf<charT, BufferT> this_type;
-   typedef typename base_type::int_type int_type;
-   typedef typename base_type::char_type char_type;
-   typedef typename base_type::pos_type pos_type;
-   typedef ::std::streamsize streamsize;
-   typedef typename base_type::off_type off_type;
-
-public:
-   basic_pointerbuf() : base_type() { setbuf(0, 0); }
-   const charT* getnext() { return this->gptr(); }
-
-#ifndef BOOST_NO_USING_TEMPLATE
-    using base_type::pptr;
-    using base_type::pbase;
-#else
-    charT* pptr() const { return base_type::pptr(); }
-    charT* pbase() const { return base_type::pbase(); }
-#endif
-
-protected:
-   // VC mistakenly assumes that `setbuf` and other functions are not referenced.
-   // Marking those functions with `inline` suppresses the warnings.
-   // There must be no harm from marking virtual functions as inline: inline virtual
-   // call can be inlined ONLY when the compiler knows the "exact class".
-   inline base_type* setbuf(char_type* s, streamsize n);
-   inline typename this_type::pos_type seekpos(pos_type sp, ::std::ios_base::openmode which);
-   inline typename this_type::pos_type seekoff(off_type off, ::std::ios_base::seekdir way, ::std::ios_base::openmode which);
-
-private:
-   basic_pointerbuf& operator=(const basic_pointerbuf&);
-   basic_pointerbuf(const basic_pointerbuf&);
-};
-
-template<class charT, class BufferT>
-BufferT*
-basic_pointerbuf<charT, BufferT>::setbuf(char_type* s, streamsize n)
-{
-   this->setg(s, s, s + n);
-   return this;
-}
-
-template<class charT, class BufferT>
-typename basic_pointerbuf<charT, BufferT>::pos_type
-basic_pointerbuf<charT, BufferT>::seekoff(off_type off, ::std::ios_base::seekdir way, ::std::ios_base::openmode which)
-{
-   typedef typename boost::int_t<sizeof(way) * CHAR_BIT>::least cast_type;
-
-   if(which & ::std::ios_base::out)
-      return pos_type(off_type(-1));
-   std::ptrdiff_t size = this->egptr() - this->eback();
-   std::ptrdiff_t pos = this->gptr() - this->eback();
-   charT* g = this->eback();
-   switch(static_cast<cast_type>(way))
-   {
-   case ::std::ios_base::beg:
-      if((off < 0) || (off > size))
-         return pos_type(off_type(-1));
-      else
-         this->setg(g, g + off, g + size);
-      break;
-   case ::std::ios_base::end:
-      if((off < 0) || (off > size))
-         return pos_type(off_type(-1));
-      else
-         this->setg(g, g + size - off, g + size);
-      break;
-   case ::std::ios_base::cur:
-   {
-      std::ptrdiff_t newpos = static_cast<std::ptrdiff_t>(pos + off);
-      if((newpos < 0) || (newpos > size))
-         return pos_type(off_type(-1));
-      else
-         this->setg(g, g + newpos, g + size);
-      break;
-   }
-   default: ;
-   }
-#ifdef BOOST_MSVC
-#pragma warning(push)
-#pragma warning(disable:4244)
-#endif
-   return static_cast<pos_type>(this->gptr() - this->eback());
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
-}
-
-template<class charT, class BufferT>
-typename basic_pointerbuf<charT, BufferT>::pos_type
-basic_pointerbuf<charT, BufferT>::seekpos(pos_type sp, ::std::ios_base::openmode which)
-{
-   if(which & ::std::ios_base::out)
-      return pos_type(off_type(-1));
-   off_type size = static_cast<off_type>(this->egptr() - this->eback());
-   charT* g = this->eback();
-   if(off_type(sp) <= size)
-   {
-      this->setg(g, g + off_type(sp), g + size);
-   }
-   return pos_type(off_type(-1));
-}
-
-}} // namespace boost::detail
-
-#endif // BOOST_DETAIL_BASIC_POINTERBUF_HPP
-
@@ -6,13 +6,6 @@
 <meta name="GENERATOR" content="Microsoft FrontPage 5.0">
 <meta name="ProgId" content="FrontPage.Editor.Document">
 <title>Boost Conversion Library</title>
-<style>
-   .copyright
-    {
-        color: #666666;
-        font-size: small;
-    }
-</style>
 </head>

 <body bgcolor="#FFFFFF" text="#000000">
@@ -39,11 +32,7 @@ supplied by several headers:</p>
 <p>Revised <!--webbot bot="Timestamp" S-Type="EDITED"
 S-Format="%d %B, %Y" startspan -->June 23, 2005<!--webbot bot="Timestamp" endspan i-checksum="30348" -->
 </p>
-<p class="copyright">
-    Copyright 2001 Beman Dawes.
-    Distributed under the Boost Software License, Version 1.0. (See accompanying
-    file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</a>)
-</p>
+
 </body>

-</html>
+</html>
@@ -48,7 +48,7 @@ int test_main( int , char * [] )
    long large_negative_value = LONG_MIN;
    signed char c = 0;

-    c = static_cast<signed char>(large_value);
+    c = large_value;  // see if compiler generates warning

    c = numeric_cast<signed char>( small_value );
    BOOST_CHECK( c == 1 );
@@ -0,0 +1,308 @@
+// what:  simple unit test framework
+// who:   developed by Kevlin Henney
+// when:  November 2000
+// where: tested with BCC 5.5, MSVC 6.0, and g++ 2.91
+//
+// ChangeLog:
+//      20 Jan 2001 - Fixed a warning for MSVC (Dave Abrahams)
+
+#ifndef TEST_INCLUDED
+#define TEST_INCLUDED
+
+#include <exception>
+#include <iostream>
+#include <strstream> // for out-of-the-box g++
+#include <string>
+
+namespace test // test tuple comprises name and nullary function (object)
+{
+    template<typename string_type, typename function_type>
+    struct test
+    {
+        string_type   name;
+        function_type action;
+
+        static test make(string_type name, function_type action)
+        {
+            test result; // MSVC aggreggate initializer bugs
+            result.name   = name;
+            result.action = action;
+            return result;
+        }
+    };
+}
+
+namespace test // failure exception used to indicate checked test failures
+{
+    class failure : public std::exception
+    {
+    public: // struction (default cases are OK)
+
+        failure(const std::string & why)
+          : reason(why)
+        {
+        }
+
+        // std::~string has no exception-specification (could throw anything),
+        // but we need to be compatible with std::~exception's empty one
+        // see std::15.4p13 and std::15.4p3
+        ~failure() throw()
+        {
+        }
+
+    public: // usage
+
+        virtual const char * what() const throw()
+        {
+            return reason.c_str();
+        }
+
+    private: // representation
+
+        std::string reason;
+
+    };
+}
+
+namespace test // not_implemented exception used to mark unimplemented tests
+{
+    class not_implemented : public std::exception
+    {
+    public: // usage (default ctor and dtor are OK)
+
+        virtual const char * what() const throw()
+        {
+            return "not implemented";
+        }
+
+    };
+}
+
+namespace test // test utilities
+{
+    inline void check(bool condition, const std::string & description)
+    {
+        if(!condition)
+        {
+            throw failure(description);
+        }
+    }
+
+    inline void check_true(bool value, const std::string & description)
+    {
+        check(value, "expected true: " + description);
+    }
+
+    inline void check_false(bool value, const std::string & description)
+    {
+        check(!value, "expected false: " + description);
+    }
+
+    template<typename lhs_type, typename rhs_type>
+    void check_equal(
+        const lhs_type & lhs, const rhs_type & rhs,
+        const std::string & description)
+    {
+        check(lhs == rhs, "expected equal values: " + description);
+    }
+
+    template<typename lhs_type, typename rhs_type>
+    void check_unequal(
+        const lhs_type & lhs, const rhs_type & rhs,
+        const std::string & description)
+    {
+        check(lhs != rhs, "expected unequal values: " + description);
+    }
+
+    inline void check_null(const void* ptr, const std::string & description)
+    {
+        check(!ptr, "expected null pointer: " + description);
+    }
+
+    inline void check_non_null(const void* ptr, const std::string & description)
+    {
+        check(ptr != 0, "expected non-null pointer: " + description);
+    }
+}
+
+#define TEST_CHECK_THROW(expression, exception, description) \
+    try \
+    { \
+        expression; \
+        throw ::test::failure(description); \
+    } \
+    catch(exception &) \
+    { \
+    }
+
+namespace test // memory tracking (enabled if test new and delete linked in)
+{
+    class allocations
+    {
+    public: // singleton access
+
+        static allocations & instance()
+        {
+            static allocations singleton;
+            return singleton;
+        }
+
+    public: // logging
+
+        void clear()
+        {
+            alloc_count = dealloc_count = 0;
+        }
+
+        void allocation()
+        {
+            ++alloc_count;
+        }
+
+        void deallocation()
+        {
+            ++dealloc_count;
+        }
+
+    public: // reporting
+
+        unsigned long allocated() const
+        {
+            return alloc_count;
+        }
+
+        unsigned long deallocated() const
+        {
+            return dealloc_count;
+        }
+
+        bool balanced() const
+        {
+            return alloc_count == dealloc_count;
+        }
+
+    private: // structors (default dtor is fine)
+    
+        allocations()
+          : alloc_count(0), dealloc_count(0)
+        {
+        }
+
+    private: // prevention
+
+        allocations(const allocations &);
+        allocations & operator=(const allocations &);
+
+    private: // state
+
+        unsigned long alloc_count, dealloc_count;
+
+    };
+}
+
+namespace test // tester is the driver class for a sequence of tests
+{
+    template<typename test_iterator>
+    class tester
+    {
+    public: // structors (default destructor is OK)
+
+        tester(test_iterator first_test, test_iterator after_last_test)
+          : begin(first_test), end(after_last_test)
+        {
+        }
+
+    public: // usage
+
+        bool operator()(); // returns true if all tests passed
+
+    private: // representation
+
+        test_iterator begin, end;
+
+    private: // prevention
+
+        tester(const tester &);
+        tester &operator=(const tester &);
+
+    };
+
+    template<typename test_iterator>
+    bool tester<test_iterator>::operator()()
+    {
+        using namespace std;
+
+        unsigned long passed = 0, failed = 0, unimplemented = 0;
+
+        for(test_iterator current = begin; current != end; ++current)
+        {
+            cerr << "[" << current->name << "] " << flush;
+            string result = "passed"; // optimistic
+
+            try
+            {
+                allocations::instance().clear();
+                current->action();
+
+                if(!allocations::instance().balanced())
+                {
+                    unsigned long allocated   = allocations::instance().allocated();
+                    unsigned long deallocated = allocations::instance().deallocated();
+                    ostrstream report;
+                    report << "new/delete ("
+                           << allocated << " allocated, "
+                           << deallocated << " deallocated)"
+                           << ends;
+                    const char * text = report.str();
+                    report.freeze(false);
+                    throw failure(text);
+                }
+
+                ++passed;
+            }
+            catch(const failure & caught)
+            {
+                (result = "failed: ") += caught.what();
+                ++failed;
+            }
+            catch(const not_implemented &)
+            {
+                result = "not implemented";
+                ++unimplemented;
+            }
+            catch(const exception & caught)
+            {
+                (result = "exception: ") += caught.what();
+                ++failed;
+            }
+            catch(...)
+            {
+                result = "failed with unknown exception";
+                ++failed;
+            }
+
+            cerr << result << endl;
+        }
+
+        cerr << passed + failed << " tests: "
+             << passed << " passed, "
+             << failed << " failed";
+
+        if(unimplemented)
+        {
+            cerr << " (" << unimplemented << " not implemented)";
+        }
+
+        cerr << endl;
+
+        return failed == 0;
+    }
+}
+
+#endif
+
+// Copyright Kevlin Henney, 2000. 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)
@@ -1,5 +1,5 @@
 # Copyright (C) 2001-2003 Douglas Gregor
-# Copyright (C) 2011-2013 Antony Polukhin
+# Copyright (C) 2011-2012 Antony Polukhin
 #
 # 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)
@@ -15,11 +15,6 @@ project
        <toolset>gcc-4.7:<cxxflags>-ftrapv
        <toolset>gcc-4.6:<cxxflags>-ftrapv
        <toolset>clang:<cxxflags>-ftrapv
-        # default to all warnings on:
-        <warnings>all
-        # set warnings as errors for those compilers we know we get warning free:
-        <toolset>gcc:<cxxflags>-Wextra
-        <toolset>gcc:<cxxflags>-Wno-uninitialized
    ;

 # Thanks to Steven Watanabe for helping with <nowchar> feature
@@ -30,9 +25,9 @@ feature.compose <nowchar>on : <cxxflags>/Zc:wchar_t- ;
 test-suite conversion
  : [ run implicit_cast.cpp ]
    [ compile-fail implicit_cast_fail.cpp ]
-    [ run cast_test.cpp ]
-    [ run numeric_cast_test.cpp ]
-    [ run lexical_cast_test.cpp ]
+    [ run ../cast_test.cpp ]
+    [ run ../numeric_cast_test.cpp ]
+    [ run ../lexical_cast_test.cpp ]
    [ run lexical_cast_loopback_test.cpp ]
    [ run lexical_cast_abstract_test.cpp ]
    [ run lexical_cast_noncopyable_test.cpp ]
@@ -40,7 +35,7 @@ test-suite conversion
    [ run lexical_cast_wchars_test.cpp ]
    [ run lexical_cast_float_types_test.cpp ]
    [ run lexical_cast_inf_nan_test.cpp ]
-    [ run lexical_cast_containers_test.cpp : : : <toolset>gcc:<cxxflags>-Wno-long-long <toolset>clang:<cxxflags>-Wno-long-long ]
+    [ run lexical_cast_containers_test.cpp ]
    [ run lexical_cast_empty_input_test.cpp ]
    [ run lexical_cast_pointers_test.cpp ]
    [ compile lexical_cast_typedefed_wchar_test.cpp : <toolset>msvc:<nowchar>on ]
@@ -64,10 +59,3 @@ test-suite conversion
    [ run lexical_cast_filesystem_test.cpp ../../filesystem/build//boost_filesystem/<link>static ]
  ;

-# Assuring that examples compile and run. Adding sources from `example` directory to the `conversion` test suite. 
-for local p in [ glob ../example/*.cpp ]
-{
-    conversion += [ run $(p) ] ;
-}
-
-
@@ -19,8 +19,6 @@ struct foo
 int test_main(int, char*[])
 {
    foo x = implicit_cast<foo>("foobar");
-    (void)x;            // warning suppression.
-    BOOST_CHECK(false); // suppressing warning about 'boost::unit_test::{anonymous}::unit_test_log' defined but not used
+    (void)x;  // warning suppression.
    return 0;
 }
-
@@ -222,8 +222,7 @@ static void testing_template_array_output_on_char_value()
        BOOST_CHECK(&res3[0] == u16ethalon);
    }
    
-    // Some compillers may throw std::bad_alloc here
-    BOOST_CHECK_THROW(lexical_cast<u16short_arr_type>(val), std::exception); 
+    BOOST_CHECK_THROW(lexical_cast<u16short_arr_type>(val), boost::bad_lexical_cast);
 #endif

 #ifdef BOOST_LC_RUNU32
@@ -249,8 +248,7 @@ static void testing_template_array_output_on_char_value()
        BOOST_CHECK(&res3[0] == u32ethalon);
    }
    
-    // Some compillers may throw std::bad_alloc here
-    BOOST_CHECK_THROW(lexical_cast<u32short_arr_type>(val), std::exception);
+    BOOST_CHECK_THROW(lexical_cast<u32short_arr_type>(val), boost::bad_lexical_cast);
 #endif
 }

@@ -297,16 +297,12 @@ void test_float_typess_for_overflows()
    BOOST_CHECK_CLOSE_FRACTION(maxvalue, lexical_cast<test_t>(maxvalue), (std::numeric_limits<test_t>::epsilon()));
    BOOST_CHECK_CLOSE_FRACTION(maxvalue, lexical_cast<test_t>(s_max_value), (std::numeric_limits<test_t>::epsilon()));

-#ifndef _LIBCPP_VERSION
-    // libc++ had a bug in implementation of stream conversions for values that must be represented as infinity. 
-    // http://llvm.org/bugs/show_bug.cgi?id=15723#c4
    BOOST_CHECK_THROW(lexical_cast<test_t>(s_max_value+"1"), bad_lexical_cast);
    BOOST_CHECK_THROW(lexical_cast<test_t>(s_max_value+"9"), bad_lexical_cast);

-    // VC9 can fail the following tests on floats and doubles when using stingstream...
+    // VC9 can fail the fllowing tests on floats and doubles when using stingstream...
    BOOST_CHECK_THROW(lexical_cast<test_t>("1"+s_max_value), bad_lexical_cast);
    BOOST_CHECK_THROW(lexical_cast<test_t>("9"+s_max_value), bad_lexical_cast);
-#endif

    if ( is_same<test_t,float>::value )
    {
@@ -48,6 +48,10 @@
 #define BOOST_LCAST_NO_WCHAR_T
 #endif

+#if (defined(BOOST_LCAST_HAS_INT128) && !defined(__GNUC__)) || GCC_VERSION > 40700
+#define BOOST_LCAST_HAS_INT128
+#endif
+
 // Test all 65536 values if true:
 bool const lcast_test_small_integral_types_completely = false;

@@ -71,7 +75,7 @@ void test_conversion_from_to_uintmax_t();
 void test_conversion_from_to_longlong();
 void test_conversion_from_to_ulonglong();
 #endif
-#ifdef BOOST_HAS_INT128
+#ifdef BOOST_LCAST_HAS_INT128
 void test_conversion_from_to_int128();
 void test_conversion_from_to_uint128();
 #endif
@@ -95,7 +99,7 @@ unit_test::test_suite *init_unit_test_suite(int, char *[])
    suite->add(BOOST_TEST_CASE(&test_conversion_from_to_longlong));
    suite->add(BOOST_TEST_CASE(&test_conversion_from_to_ulonglong));
 #endif
-#ifdef BOOST_HAS_INT128
+#ifdef BOOST_LCAST_HAS_INT128
    suite->add(BOOST_TEST_CASE(&test_conversion_from_to_int128));
    suite->add(BOOST_TEST_CASE(&test_conversion_from_to_uint128));
 #endif
@@ -367,36 +371,10 @@ void test_conversion_from_to_integral_for_locale()
        BOOST_CHECK( lexical_cast<T>("30000") == static_cast<T>(30000) );
    }

-
    test_conversion_from_integral_to_integral<T>();
-
-    // This is a part of test_conversion_from_integral_to_string<T>('0') method,
-    // but with BOOST_CHECK_EQUAL instead of BOOST_CHECK. It is required to see 
-    // what is produced by the to_str<char>(t) method in situations when result 
-    // is different. BOOST_CHECK does not work with wchar_t.
-    typedef std::numeric_limits<T> limits;
-    T t = (limits::min)();
-    BOOST_CHECK_EQUAL(lexical_cast<std::string>(t), to_str<char>(t));
-
    test_conversion_from_integral_to_string<T>('0');
    test_conversion_from_string_to_integral<T>('0');
 #if !defined(BOOST_LCAST_NO_WCHAR_T)
-    if (lexical_cast<std::wstring>(t) != to_str<wchar_t>(t)) {
-        // Something went wrong, and now we are attempting to find and print the 
-        // difference.
-        std::wstring wstr = to_str<wchar_t>(t);
-        std::string lcast_str = lexical_cast<std::string>(t);
-        std::string str;
-        str.reserve(wstr.size());
-        for (std::size_t i = 0; i < wstr.size(); ++i) {
-            str.push_back(static_cast<char>(wstr[i]));
-        }
-        
-        BOOST_CHECK_EQUAL(lcast_str.length(), lexical_cast<std::wstring>(t).length());
-        BOOST_CHECK_EQUAL(to_str<char>(t), str);
-        BOOST_CHECK_EQUAL(lcast_str, str);
-    }
-
    test_conversion_from_integral_to_string<T>(L'0');
    test_conversion_from_string_to_integral<T>(L'0');
 #endif
@@ -466,8 +444,8 @@ void test_conversion_from_to_integral_minimal()
    // test_conversion_from_to_integral_for_locale

    // Overflow test case from David W. Birdsall
-    std::string must_owerflow_str =             (sizeof(T) < 16 ?  "160000000000000000000" :  "1600000000000000000000000000000000000000");
-    std::string must_owerflow_negative_str =    (sizeof(T) < 16 ? "-160000000000000000000" : "-1600000000000000000000000000000000000000");
+    std::string must_owerflow_str = "160000000000000000000";
+    std::string must_owerflow_negative_str = "-160000000000000000000";
    for (int i = 0; i < 15; ++i) {
        BOOST_CHECK_THROW(lexical_cast<T>(must_owerflow_str), bad_lexical_cast);
        BOOST_CHECK_THROW(lexical_cast<T>(must_owerflow_negative_str), bad_lexical_cast);
@@ -579,34 +557,15 @@ void test_conversion_from_to_ulonglong()
 #endif


-#ifdef BOOST_HAS_INT128
-
-template <bool Specialized, class T>
-struct test_if_specialized {
-    static void test() {}
-};
-
-template <class T>
-struct test_if_specialized<true, T> {
-    static void test() {
-        test_conversion_from_to_integral_minimal<T>();
-    }
-};
-
+#ifdef BOOST_LCAST_HAS_INT128
 void test_conversion_from_to_int128()
 {
-    test_if_specialized<
-        std::numeric_limits<boost::int128_type>::is_specialized, 
-        boost::int128_type
-    >::test();
+    test_conversion_from_to_integral_minimal<boost::int128_type>();
 }

 void test_conversion_from_to_uint128()
 {
-    test_if_specialized<
-        std::numeric_limits<boost::int128_type>::is_specialized, 
-        boost::uint128_type
-    >::test();
+    test_conversion_from_to_integral_minimal<boost::uint128_type>();
 }
 #endif

@@ -643,7 +602,7 @@ void test_integral_conversions_on_min_max()
    test_integral_conversions_on_min_max_impl<__int64>();
 #endif

-#ifdef BOOST_HAS_INT128
+#ifdef BOOST_LCAST_HAS_INT128
    test_integral_conversions_on_min_max_impl<boost::int128_type>();
 #endif
 #endif
@@ -40,7 +40,7 @@ static void test_optimized_types_to_string_const()
    BOOST_CHECK((boost::is_same<BOOST_DEDUCED_TYPENAME trait_3::target_char_t, wchar_t>::value));
    BOOST_CHECK((boost::is_same<BOOST_DEDUCED_TYPENAME trait_3::char_type, wchar_t>::value));

-    BOOST_CHECK((boost::detail::is_character<BOOST_DEDUCED_TYPENAME trait_3::no_cv_src>::value != trait_3::is_string_widening_required_t::value));
+    BOOST_CHECK((boost::detail::is_char_or_wchar<BOOST_DEDUCED_TYPENAME trait_3::no_cv_src>::value != trait_3::is_string_widening_required_t::value));

    BOOST_CHECK(!trait_3::is_source_input_not_optimized_t::value);
 }    
@@ -17,7 +17,5 @@
 int test_main(int, char*[])
 {
    boost::lexical_cast<char*>("Hello");
-    BOOST_CHECK(false); // suppressing warning about 'boost::unit_test::{anonymous}::unit_test_log' defined but not used
    return 0;
 }
-
@@ -51,23 +51,6 @@ void test_char_types_conversions_wchar_t()
 {
 #ifndef BOOST_LCAST_NO_WCHAR_T
    test_impl(L"Test array of chars");
-    wchar_t c = boost::detail::lcast_char_constants<wchar_t>::zero;
-    BOOST_CHECK_EQUAL(L'0', c);
-
-    c = boost::detail::lcast_char_constants<wchar_t>::minus;
-    BOOST_CHECK_EQUAL(L'-', c);
-
-    c = boost::detail::lcast_char_constants<wchar_t>::plus;
-    BOOST_CHECK_EQUAL(L'+', c);
-
-    c = boost::detail::lcast_char_constants<wchar_t>::lowercase_e;
-    BOOST_CHECK_EQUAL(L'e', c);
-
-    c = boost::detail::lcast_char_constants<wchar_t>::capital_e;
-    BOOST_CHECK_EQUAL(L'E', c);
-
-    c = boost::detail::lcast_char_constants<wchar_t>::c_decimal_separator;
-    BOOST_CHECK_EQUAL(L'.', c);
 #endif

    BOOST_CHECK(true);
@@ -77,23 +60,6 @@ void test_char_types_conversions_char16_t()
 {
 #if !defined(BOOST_NO_CXX11_CHAR16_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS) && defined(BOOST_STL_SUPPORTS_NEW_UNICODE_LOCALES)
    test_impl(u"Test array of chars");
-    char16_t c = boost::detail::lcast_char_constants<char16_t>::zero;
-    BOOST_CHECK_EQUAL(u'0', c);
-
-    c = boost::detail::lcast_char_constants<char16_t>::minus;
-    BOOST_CHECK_EQUAL(u'-', c);
-
-    c = boost::detail::lcast_char_constants<char16_t>::plus;
-    BOOST_CHECK_EQUAL(u'+', c);
-
-    c = boost::detail::lcast_char_constants<char16_t>::lowercase_e;
-    BOOST_CHECK_EQUAL(u'e', c);
-
-    c = boost::detail::lcast_char_constants<char16_t>::capital_e;
-    BOOST_CHECK_EQUAL(u'E', c);
-
-    c = boost::detail::lcast_char_constants<char16_t>::c_decimal_separator;
-    BOOST_CHECK_EQUAL(u'.', c);
 #endif

    BOOST_CHECK(true);
@@ -103,23 +69,6 @@ void test_char_types_conversions_char32_t()
 {
 #if !defined(BOOST_NO_CXX11_CHAR32_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS) && defined(BOOST_STL_SUPPORTS_NEW_UNICODE_LOCALES)
    test_impl(U"Test array of chars");
-    char32_t c = boost::detail::lcast_char_constants<char32_t>::zero;
-    BOOST_CHECK_EQUAL(U'0', c);
-
-    c = boost::detail::lcast_char_constants<char32_t>::minus;
-    BOOST_CHECK_EQUAL(U'-', c);
-
-    c = boost::detail::lcast_char_constants<char32_t>::plus;
-    BOOST_CHECK_EQUAL(U'+', c);
-
-    c = boost::detail::lcast_char_constants<char32_t>::lowercase_e;
-    BOOST_CHECK_EQUAL(U'e', c);
-
-    c = boost::detail::lcast_char_constants<char32_t>::capital_e;
-    BOOST_CHECK_EQUAL(U'E', c);
-
-    c = boost::detail::lcast_char_constants<char32_t>::c_decimal_separator;
-    BOOST_CHECK_EQUAL(U'.', c);
 #endif

    BOOST_CHECK(true);