Release 1.48.0

[SVN r75495]
2026-08-09 23:11:18 +02:00 · 2011-11-15 15:44:44 +00:00
36 changed files with 5629 additions and 1285 deletions
@@ -1,11 +0,0 @@
 # To get started with Dependabot version updates, you'll need to specify which
 # package ecosystems to update and where the package manifests are located.
 # Please see the documentation for all configuration options:
 # https://docs.github.com/code-security/dependabot/dependabot-version-updates/configuration-options-for-the-dependabot.yml-file
 version: 2
 updates:
  - package-ecosystem: "github-actions" # See documentation for possible values
    directory: "/" # Location of package manifests
    schedule:
        interval: "weekly"
@@ -1,182 +0,0 @@
 name: CI
 on:
  pull_request:
  push:
    branches:
      - master
      - develop
      - feature/**
 env:
  UBSAN_OPTIONS: print_stacktrace=1
 jobs:
  posix:
    strategy:
      fail-fast: false
      matrix:
        include:
          - toolset: gcc-14  # Do not remove! It is the only toolset that tests CMake tests down below
            cxxstd: "03,11,14,17,20"
            os: ubuntu-24.04
          - toolset: gcc-12
            cxxstd: "03,11,14,17,2a"
            os: ubuntu-22.04
            cxxflags: "cxxflags=--coverage -fsanitize=address,leak,undefined -fno-sanitize-recover=undefined"
            linkflags: "linkflags=--coverage -lasan -lubsan"
            gcov_tool: "gcov-12"
          - toolset: clang
            compiler: clang++-14
            cxxstd: "03,11,14,17,2a"
            os: ubuntu-22.04
    runs-on: ${{matrix.os}}
    steps:
      - uses: actions/checkout@v6
      - name: Install packages
        if: matrix.install
        run: sudo apt install ${{matrix.install}}
      - name: Setup Boost
        run: |
          echo GITHUB_REPOSITORY: $GITHUB_REPOSITORY
          LIBRARY=${GITHUB_REPOSITORY#*/}
          echo LIBRARY: $LIBRARY
          echo "LIBRARY=$LIBRARY" >> $GITHUB_ENV
          echo GITHUB_BASE_REF: $GITHUB_BASE_REF
          echo GITHUB_REF: $GITHUB_REF
          REF=${GITHUB_BASE_REF:-$GITHUB_REF}
          REF=${REF#refs/heads/}
          echo REF: $REF
          BOOST_BRANCH=develop && [ "$REF" == "master" ] && BOOST_BRANCH=master || true
          echo BOOST_BRANCH: $BOOST_BRANCH
          cd ..
          git clone -b $BOOST_BRANCH --depth 10 https://github.com/boostorg/boost.git boost-root
          cd boost-root
          git submodule update --init --depth 10 --jobs 2 tools/boostdep tools/inspect libs/filesystem
          python tools/boostdep/depinst/depinst.py --git_args "--depth 10 --jobs 3" filesystem
          rm -rf libs/$LIBRARY/*
          cp -r $GITHUB_WORKSPACE/* libs/$LIBRARY
          python tools/boostdep/depinst/depinst.py --include benchmark --include example --include examples --include tools --git_args "--depth 10 --jobs 3" $LIBRARY
          ./bootstrap.sh
          ./b2 -j4 variant=debug tools/inspect
      - name: Run CMake tests
        if: ${{matrix.toolset == 'gcc-14'}}
        run: |
          cd ../boost-root/
          mkdir __build
          cd __build
          cmake -DBUILD_TESTING=1 -DBOOST_INCLUDE_LIBRARIES=conversion -DCMAKE_CXX_COMPILER=g++-14 -DCMAKE_C_COMPILER=gcc-14 ..
          cmake --build . --target tests
          ctest --output-on-failure --no-tests=error
          cd ..
          rm -rf __build
      - name: Run tests
        run: |
          cd ../boost-root
          ./b2 -j3 libs/$LIBRARY/test toolset=${{matrix.toolset}} cxxstd=${{matrix.cxxstd}} variant=debug,release "${{matrix.cxxflags}}" "${{matrix.linkflags}}" "${{matrix.launcher}}"
          dist/bin/inspect libs/$LIBRARY
      - name: Prepare coverage data
        if: matrix.gcov_tool
        run: |
          mkdir -p $GITHUB_WORKSPACE/coveralls
          echo -e "#!/bin/bash\nexec ${{matrix.gcov_tool}} \"\$@\"" > $GITHUB_WORKSPACE/coveralls/gcov_wrapper.sh
          chmod +x $GITHUB_WORKSPACE/coveralls/gcov_wrapper.sh
          wget https://github.com/linux-test-project/lcov/archive/v1.16.zip
          unzip v1.16.zip
          LCOV="`pwd`/lcov-1.16/bin/lcov --gcov-tool $GITHUB_WORKSPACE/coveralls/gcov_wrapper.sh"
          echo "$LCOV --directory ../boost-root/bin.v2/libs/$LIBRARY/ --base-directory `pwd`/libs/$LIBRARY/test --capture --output-file $GITHUB_WORKSPACE/coveralls/coverage.info"
          $LCOV --directory ../boost-root/bin.v2/libs/$LIBRARY/ --base-directory ../boost-root/ --capture --output-file $GITHUB_WORKSPACE/coveralls/coverage.info
          $LCOV --remove $GITHUB_WORKSPACE/coveralls/coverage.info "/usr*" "*/$LIBRARY/test/*" ${{matrix.ignore_coverage}} "*/$LIBRARY/tests/*" "*/$LIBRARY/examples/*" "*/$LIBRARY/example/*" -o $GITHUB_WORKSPACE/coveralls/coverage.info
          cd ../boost-root
          OTHER_LIBS=`grep "submodule .*" .gitmodules | sed 's/\[submodule\ "\(.*\)"\]/"\*\/boost\/\1\.hpp" "\*\/boost\/\1\/\*"/g'| sed "/\"\*\/boost\/$LIBRARY\/\*\"/d" | sed ':a;N;$!ba;s/\n/ /g'`
          echo $OTHER_LIBS
          eval "$LCOV --remove $GITHUB_WORKSPACE/coveralls/coverage.info $OTHER_LIBS -o $GITHUB_WORKSPACE/coveralls/coverage.info"
      - name: Coveralls
        uses: coverallsapp/github-action@master
        if: matrix.gcov_tool
        with:
          github-token: ${{ secrets.GITHUB_TOKEN }}
          path-to-lcov: ./coveralls/coverage.info
          parallel: true
  windows:
    strategy:
      fail-fast: false
      matrix:
        include:
          - toolset: msvc-14.3
            cxxstd: "14,17,latest"
            addrmd: 32,64
            os: windows-2025
          - toolset: gcc
            cxxstd: "03,11,14,17,2a"
            addrmd: 64
            os: windows-2025
    runs-on: ${{matrix.os}}
    steps:
      - uses: actions/checkout@v6
      - name: Setup Boost
        shell: cmd
        run: |
          echo GITHUB_REPOSITORY: %GITHUB_REPOSITORY%
          for /f %%i in ("%GITHUB_REPOSITORY%") do set LIBRARY=%%~nxi
          echo LIBRARY: %LIBRARY%
          echo LIBRARY=%LIBRARY%>>%GITHUB_ENV%
          echo GITHUB_BASE_REF: %GITHUB_BASE_REF%
          echo GITHUB_REF: %GITHUB_REF%
          if "%GITHUB_BASE_REF%" == "" set GITHUB_BASE_REF=%GITHUB_REF%
          set BOOST_BRANCH=develop
          for /f %%i in ("%GITHUB_BASE_REF%") do if "%%~nxi" == "master" set BOOST_BRANCH=master
          echo BOOST_BRANCH: %BOOST_BRANCH%
          cd ..
          git clone -b %BOOST_BRANCH% --depth 10 https://github.com/boostorg/boost.git boost-root
          cd boost-root
          xcopy /s /e /q %GITHUB_WORKSPACE% libs\%LIBRARY%\
          git submodule update --init tools/boostdep
          python tools/boostdep/depinst/depinst.py --include benchmark --include example --include examples --include tools --git_args "--jobs 3" %LIBRARY%
          cmd /c bootstrap
      - name: Run CMake tests
        if: ${{matrix.toolset == 'msvc-14.3'}}
        shell: cmd
        run: |
          choco install --no-progress ninja
          call "C:/Program Files/Microsoft Visual Studio/2022/Enterprise/VC/Auxiliary/Build/vcvarsall.bat" x64
          cd ../boost-root/
          mkdir __build
          cd __build
          cmake -DBUILD_TESTING=1 -DBOOST_INCLUDE_LIBRARIES=conversion ..
          cmake --build . --target tests --config Debug
          ctest --output-on-failure --no-tests=error -C Debug
          cd ..
          rm -rf __build
      - name: Run tests
        shell: cmd
        run: |
          cd ../boost-root
          b2 -j3 libs/%LIBRARY%/test toolset=${{matrix.toolset}} cxxstd=${{matrix.cxxstd}} address-model=${{matrix.addrmd}} variant=debug,release
  finish:
    needs: posix
    runs-on: ubuntu-latest
    steps:
    - name: Coveralls Finished
      uses: coverallsapp/github-action@master
      with:
        github-token: ${{ secrets.github_token }}
        parallel-finished: true
@@ -1,22 +0,0 @@
 # Copyright 2019 Mike Dev
 # Distributed under the Boost Software License, Version 1.0.
 # See accompanying file LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt
 cmake_minimum_required( VERSION 3.5...4.20 )
 project( boost_conversion VERSION "${BOOST_SUPERPROJECT_VERSION}" LANGUAGES CXX )
 add_library( boost_conversion INTERFACE )
 add_library( Boost::conversion ALIAS boost_conversion )
 target_include_directories( boost_conversion INTERFACE include )
 target_link_libraries( boost_conversion
    INTERFACE
        Boost::assert
        Boost::config
        Boost::throw_exception
 )
 if(BUILD_TESTING)
  add_subdirectory(test)
 endif()
@@ -1,15 +0,0 @@
 # [Boost.Conversion](https://boost.org/libs/conversion)
 Boost.Conversion is one of the [Boost C++ Libraries](https://github.com/boostorg). This library improves program safety and clarity by performing otherwise messy conversions. 
 ### Test results
@               | Build         | Tests coverage | More info
 ----------------|-------------- | -------------- |-----------
 Develop branch: | [![CI](https://github.com/boostorg/conversion/actions/workflows/ci.yml/badge.svg?branch=develop)](https://github.com/boostorg/conversion/actions/workflows/ci.yml) [![Build status](https://ci.appveyor.com/api/projects/status/1cky1hrunfa46bdx/branch/develop?svg=true)](https://ci.appveyor.com/project/apolukhin/conversion/branch/develop) | [![Coverage Status](https://coveralls.io/repos/github/boostorg/conversion/badge.svg?branch=develop)](https://coveralls.io/github/boostorg/conversion?branch=develop) | [details...](https://regression.boost.io/develop/developer/conversion.html)
 Master branch:  | [![CI](https://github.com/boostorg/conversion/actions/workflows/ci.yml/badge.svg?branch=master)](https://github.com/boostorg/conversion/actions/workflows/ci.yml) [![Build status](https://ci.appveyor.com/api/projects/status/1cky1hrunfa46bdx/branch/master?svg=true)](https://ci.appveyor.com/project/apolukhin/conversion/branch/master) | [![Coverage Status](https://coveralls.io/repos/github/boostorg/conversion/badge.svg?branch=master)](https://coveralls.io/github/boostorg/conversion?branch=master) | [details...](https://regression.boost.io/master/developer/conversion.html)
 [Latest developer documentation](https://www.boost.org/doc/libs/develop/doc/html/conversion.html)
 ### License
 Distributed under the [Boost Software License, Version 1.0](https://boost.org/LICENSE_1_0.txt).
@@ -1,25 +0,0 @@
 # Copyright René Ferdinand Rivera Morell 2023-2024
 # 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)
 require-b2 5.2 ;
 constant boost_dependencies :
    /boost/assert//boost_assert
    /boost/config//boost_config
    /boost/throw_exception//boost_throw_exception ;
 project /boost/conversion
    : common-requirements
        <include>include
    ;
 explicit
    [ alias boost_conversion : : : : <library>$(boost_dependencies) ]
    [ alias all : boost_conversion test ]
    ;
 call-if : boost-library conversion
    ;
@@ -0,0 +1,140 @@
 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 <html>
  <head>
    <meta name="generator" content=
    "Microsoft FrontPage 5.0">
    <meta http-equiv="Content-Type" content=
    "text/html; charset=windows-1252">
    <meta name="GENERATOR" content="Microsoft FrontPage 4.0">
    <meta name="ProgId" content="FrontPage.Editor.Document">
    <title>Header boost/cast.hpp Documentation</title>
  </head>
  <body bgcolor="#FFFFFF" text="#000000">
    <h1><img src="../../boost.png" alt="boost.png (6897 bytes)" align=
    "middle" width="277" height="86">Header <a href=
    "../../boost/cast.hpp">boost/cast.hpp</a></h1>
    <h2><a name="Cast Functions">Cast Functions</a></h2>
    <p>The header <a href="../../boost/cast.hpp">boost/cast.hpp</a> provides <code>
    <a href="#Polymorphic_cast">polymorphic_cast</a> and</code> <a href=
    "#Polymorphic_cast"><code>polymorphic_downcast</code></a> function templates designed to
    complement the C++ built-in casts.</p>
    <p>The program <a href="cast_test.cpp">cast_test.cpp</a> can be used to
    verify these function templates work as expected.</p>
    <h3><a name="Polymorphic_cast">Polymorphic casts</a></h3>
    <p>Pointers to polymorphic objects (objects of classes which define at
    least one virtual function) are sometimes downcast or crosscast.
    Downcasting means casting from a base class to a derived class.
    Crosscasting means casting across an inheritance hierarchy diagram, such
    as from one base to the other in a <code>Y</code> diagram hierarchy.</p>
    <p>Such casts can be done with old-style casts, but this approach is
    never to be recommended. Old-style casts are sorely lacking in type
    safety, suffer poor readability, and are difficult to locate with search
    tools.</p>
    <p>The C++ built-in <code>static_cast</code> can be used for efficiently
    downcasting pointers to polymorphic objects, but provides no error
    detection for the case where the pointer being cast actually points to
    the wrong derived class. The <code>polymorphic_downcast</code> template retains
    the efficiency of <code>static_cast</code> for non-debug compilations, but for
    debug compilations adds safety via an assert() that a <code>dynamic_cast</code>
    succeeds.</p>
    <p>The C++ built-in <code>dynamic_cast</code> can be used for downcasts and
    crosscasts of pointers to polymorphic objects, but error notification in
    the form of a returned value of 0 is inconvenient to test, or worse yet,
    easy to forget to test. The throwing form of <code>dynamic_cast</code>, which
    works on references, can be used on pointers through the ugly expression
    &amp;<code>dynamic_cast&lt;T&amp;&gt;(*p)</code>, which causes undefined
    behavior if <code>p</code> is <code>0</code>. The <code>polymorphic_cast</code>
    template performs a <code>dynamic_cast</code> on a pointer, and throws an
    exception if the <code>dynamic_cast</code> returns 0.</p>
    <p>A <code>polymorphic_downcast</code> should be used for
    downcasts that you are certain should succeed.  Error checking is
    only performed in translation units where <code>NDEBUG</code> is
    not defined, via
 <pre>  assert( dynamic_cast&lt;Derived&gt;(x) == x )
 </pre> where <code>x</code> is the source pointer.  This approach
    ensures that not only is a non-zero pointer returned, but also
    that it is correct in the presence of multiple inheritance.
    Attempts to crosscast using <code>polymorphic_downcast</code> will
    fail to compile.
    <b>Warning:</b> Because <code>polymorphic_downcast</code> uses assert(), it
    violates the One Definition Rule (ODR) if NDEBUG is inconsistently
    defined across translation units. [See ISO Std 3.2]
 </p><p>
    For crosscasts, or when the success of a cast can only be known at
    runtime, or when efficiency is not important,
    <code>polymorphic_cast</code> is preferred. </p>
    <p>The C++ built-in <code>dynamic_cast</code> must be used to cast references
    rather than pointers. It is also the only cast that can be used to check
    whether a given interface is supported; in that case a return of 0 isn't
    an error condition.</p>
    <h3>polymorphic_cast and polymorphic_downcast synopsis</h3>
    <blockquote>
 <pre>namespace boost {
 template &lt;class Derived, class Base&gt;
 inline Derived polymorphic_cast(Base* x);
 // Throws: std::bad_cast if ( dynamic_cast&lt;Derived&gt;(x) == 0 )
 // Returns: dynamic_cast&lt;Derived&gt;(x)
 template &lt;class Derived, class Base&gt;
 inline Derived polymorphic_downcast(Base* x);
 // Effects: assert( dynamic_cast&lt;Derived&gt;(x) == x );
 // Returns: static_cast&lt;Derived&gt;(x)
 }
 </pre>
    </blockquote>
    <h3>polymorphic_downcast example</h3>
    <blockquote>
 <pre>#include &lt;boost/cast.hpp&gt;
 ...
 class Fruit { public: virtual ~Fruit(){}; ... };
 class Banana : public Fruit { ... };
 ...
 void f( Fruit * fruit ) {
 // ... logic which leads us to believe it is a Banana
  Banana * banana = boost::polymorphic_downcast&lt;Banana*&gt;(fruit);
  ...
 </pre>
    </blockquote>
    <h3>History</h3>
    <p><code>polymorphic_cast</code> was suggested by Bjarne Stroustrup in "The C++
    Programming Language".<br>
     <code>polymorphic_downcast</code> was contributed by <a href=
    "http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a>.<code><br>
     An old
     numeric_cast</code> that was contributed by <a href=
    "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>
    <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>&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>
@@ -14,8 +14,13 @@
 //    3 Aug 99  Initial Version
 #include <iostream>
-#include <boost/polymorphic_cast.hpp>
+#include <climits>
-#include <boost/core/lightweight_test.hpp>
+#include <cfloat>   // for DBL_MAX (Peter Schmid)
 #include <boost/cast.hpp>
 #  if SCHAR_MAX == LONG_MAX
 #      error "This test program doesn't work if SCHAR_MAX == LONG_MAX"
 #  endif
 using namespace boost;
 using std::cout;
@@ -38,48 +43,6 @@ namespace
    };
 }
 constexpr bool compile_time_polymorphic_cast_check() {
 #if defined(__cpp_constexpr) && __cpp_constexpr >= 201907L
    Derived derived;
    Base* base = &derived;
    return polymorphic_cast<Derived*>(base) != nullptr;
 #endif
    return true;
 }
 static_assert(
    compile_time_polymorphic_cast_check(),
    "polymorphic_cast does not work at compile time"
 );
 constexpr bool compile_time_polymorphic_downcast_check() {
 #if defined(__cpp_constexpr) && __cpp_constexpr >= 201907L
    Derived derived;
    Base* base = &derived;
    return polymorphic_downcast<Derived*>(base) != nullptr;
 #endif
    return true;
 }
 static_assert(
    compile_time_polymorphic_downcast_check(),
    "polymorphic_downcast does not work at compile time"
 );
 constexpr bool compile_time_polymorphic_downcast2_check() {
 #if defined(__cpp_constexpr) && __cpp_constexpr >= 201907L
    Derived derived;
    Base& base = derived;
    Derived& derived_again = polymorphic_downcast<Derived&>(base);
    (void)derived_again;
 #endif
    return true;
 }
 static_assert(
    compile_time_polymorphic_downcast2_check(),
    "polymorphic_downcast does not work at compile time"
 );
 int main( int argc, char * argv[] )
 {
@@ -94,31 +57,35 @@ int main( int argc, char * argv[] )
 //  test polymorphic_cast  ---------------------------------------------------//
    //  tests which should succeed
-    Derived derived_instance;
+    Base *    base = new Derived;
-    Base * base = &derived_instance;
+    Base2 *   base2 = 0;
-    Derived * derived = polymorphic_downcast<Derived*>( base );  // downcast
+    Derived * derived = 0;
-    BOOST_TEST( derived->kind() == 'D' );
+    derived = polymorphic_downcast<Derived*>( base );  // downcast
    assert( derived->kind() == 'D' );
    derived = 0;
    derived = polymorphic_cast<Derived*>( base ); // downcast, throw on error
-    BOOST_TEST( derived->kind() == 'D' );
+    assert( derived->kind() == 'D' );
-    Base2 *   base2 =  polymorphic_cast<Base2*>( base ); // crosscast
+    base2 = polymorphic_cast<Base2*>( base ); // crosscast
-    BOOST_TEST( base2->kind2() == '2' );
+    assert( base2->kind2() == '2' );
     //  tests which should result in errors being detected
-    Base base_instance;
+    int err_count = 0;
-    base = &base_instance;
+    base = new Base;
    if ( argc > 1 && *argv[1] == '1' )
        { derived = polymorphic_downcast<Derived*>( base ); } // #1 assert failure
    bool caught_exception = false;
    try { derived = polymorphic_cast<Derived*>( base ); }
-    catch (const std::bad_cast&)
+    catch (std::bad_cast)
        { cout<<"caught bad_cast\n"; caught_exception = true; }
-    BOOST_TEST( caught_exception );
+    if ( !caught_exception ) ++err_count;
    //  the following is just so generated code can be inspected
-    BOOST_TEST( derived->kind() != 'B' );
+    if ( derived->kind() == 'B' ) ++err_count;
-    return boost::report_errors();
+    cout << err_count << " errors detected\nTest "
         << (err_count==0 ? "passed\n" : "failed\n");
    return err_count;
 }   // main
@@ -1,38 +1,16 @@
-#   Copyright (c) 2016 Mikhail Maximov <vigorous.activity -at- gmail.com>
+# Copyright Antony Polukhin 2011. Use, modification, and distribution are
-
+# subject to the Boost Software License, Version 1.0. (See accompanying
-#   Distributed under the Boost Software License, Version 1.0.
+# file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 #   (See accompanying file LICENSE_1_0.txt or copy at
 #   http://www.boost.org/LICENSE_1_0.txt)
 project doc/conversion ;
 using quickbook ;
-import boostbook ;
+import boostbook : boostbook ;
-xml conversion : conversion.qbk ;
+xml lexical_cast : lexical_cast.qbk ;
-boostbook standalone
+boostbook standalone 
-    :
+    : 
-        conversion
+    lexical_cast 
    :
        <xsl:param>boost.root=../../../..
-        # File name of HTML output:
+        <format>pdf:<xsl:param>boost.url.prefix=http://www.boost.org/doc/libs/release/doc/html
-        <xsl:param>root.filename=conversion
+    ;
        # How far down we chunk nested sections, basically all of them:
        <xsl:param>chunk.section.depth=0
        # Don't put the first section on the same page as the TOC:
        <xsl:param>chunk.first.sections=0
        # How far down sections get TOC's
        <xsl:param>toc.section.depth=2
        # Max depth in each TOC:
        <xsl:param>toc.max.depth=2
        # How far down we go with TOC's
        <xsl:param>generate.section.toc.level=0
        <xsl:param>generate.manifest=0
     ;
 ###############################################################################
 alias boostdoc : conversion ;
 explicit boostdoc ;
 alias boostrelease ;
 explicit boostrelease ;
@@ -1,215 +0,0 @@
 [/
    Copyright 2016 Mikhail Maximov.
    Copyright Antony Polukhin, 2020-2026.
    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>)
 ]
 [article The Conversion Library
    [quickbook 1.6]
    [compatibility-mode 1.5]
    [id conversion]
    [version 1.7]
    [authors [Stroustrup, Bjarne], [Abrahams, Dave], [Rasin, Boris], [Polukhin, Antony]]
    [copyright 2001 Beman Dawes, 2014-2026 Antony Polukhin]
    [license
        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])
    ]
    [source-mode c++]
 ]
 [/ QuickBook Document version 1.5 ]
 [/ Dec, 2016 ]
 [section Description]
 The Conversion Library improves program safety and clarity by performing
 otherwise messy conversions. It includes cast-style function templates designed 
 to complement the C++ Standard's built-in casts.
 To reduce coupling, the Boost Conversion Library is supplied by several headers:
 # The [@boost:boost/polymorphic_cast.hpp boost/polymorphic_cast.hpp] header
  provides [link polymorphic_cast `polymorphic_cast<>`] and
  [link polymorphic_downcast `polymorphic_downcast<>`]
  to perform safe casting between polymorphic types.
 # The [@boost:boost/polymorphic_pointer_cast.hpp boost/polymorphic_pointer_cast.hpp] header
  provides [link polymorphic_pointer_cast `polymorphic_pointer_cast<>`] and
  [link polymorphic_pointer_cast `polymorphic_pointer_downcast<>`]
 # The [@boost:boost/implicit_cast.hpp boost/implicit_cast.hpp] header provides `implicit_cast<>` 
  to perform implicit casts only (no down-cast, no void*->T*, no U->T if T has only explicit constructors for U).
 [endsect]
 [section Polymorphic casts]
 Pointers to polymorphic objects (objects of classes which define at
 least one virtual function) are sometimes downcast or crosscast.
 Downcasting means casting from a base class to a derived class.
 Crosscasting means casting across an inheritance hierarchy diagram, such
 as from one base to the other in a [^Y] diagram hierarchy.
 Such casts can be done with old-style casts, but this approach is
 never to be recommended. Old-style casts are sorely lacking in type
 safety, suffer poor readability, and are difficult to locate with search
 tools.
 [#polymorphic_downcast]
 [section polymorphic_downcast]
 The C++ built-in `static_cast` can be used for efficiently
 downcasting pointers to polymorphic objects, but provides no error
 detection for the case where the pointer being cast actually points to
 the wrong derived class. The `polymorphic_downcast` template retains
 the efficiency of `static_cast` for non-debug compilations, but for
 debug compilations adds safety via an `assert()` that a `dynamic_cast`
 succeeds.
 A `polymorphic_downcast` should be used for
 downcasts that you are certain should succeed. Error checking is
 only performed in translation units where `NDEBUG` is
 not defined, via
 ```
    assert( dynamic_cast<Derived>(x) == x )
 ```
 where `x` is the source pointer.  This approach
 ensures that not only is a non-zero pointer returned, but also
 that it is correct in the presence of multiple inheritance.
 Attempts to crosscast using `polymorphic_downcast` will
 fail to compile.
 [warning Because `polymorphic_downcast` uses `assert()`, it
 violates the One Definition Rule (ODR) if `NDEBUG` is inconsistently
 defined across translation units. See ISO Std 3.2]
 [h4 Example:]
 ```
    #include <boost/polymorphic_cast.hpp>
    ...
    class Fruit { public: virtual ~Fruit(){}; ... };
    class Banana : public Fruit { ... };
    ...
    void f( Fruit * fruit ) {
      // ... logic which leads us to believe it is a Banana
      Banana * banana = boost::polymorphic_downcast<Banana*>(fruit);
      ...
    }
 ```
 [endsect]
 [#polymorphic_cast]
 [section polymorphic_cast]
 The C++ built-in `dynamic_cast` can be used for downcasts and
 crosscasts of pointers to polymorphic objects, but error notification in
 the form of a returned value of 0 is inconvenient to test, or worse yet,
 easy to forget to test. The throwing form of `dynamic_cast`, which
 works on references, can be used on pointers through the ugly expression
 `&dynamic_cast<T&>(*p)`, which causes undefined
 behavior if `p` is `0`. The `polymorphic_cast`
 template performs a `dynamic_cast` on a pointer, and throws an
 exception if the `dynamic_cast` returns 0.
 For crosscasts, or when the success of a cast can only be known at runtime, 
 or when efficiency is not important, `polymorphic_cast` is preferred.
 The C++ built-in `dynamic_cast` must be used to cast references rather than pointers.
 It is also the only cast that can be used to check whether a given interface is supported; in that case a return of 0 isn't an error condition.
 [endsect]
 [#polymorphic_pointer_cast]
 [section polymorphic_pointer_cast]
 While `polymorphic_downcast` and `polymorphic_cast` work with built-in pointer types only,
 `polymorphic_pointer_downcast` and `polymorphic_pointer_cast` are more generic versions
 with support for any pointer type for which the following expressions would be valid:
 For `polymorphic_pointer_downcast`:
 ```
    static_pointer_cast<Derived>(p);
    dynamic_pointer_cast<Derived>(p);
 ```
 For `polymorphic_pointer_cast`:
 ```
    dynamic_pointer_cast<Derived>(p);
    !p; // conversion to bool with negation
 ```
 This includes C++ built-in pointers, `std::shared_ptr`,
 `boost::shared_ptr`, `boost::intrusive_ptr`, etc.
 [h4 Example:]
 ```
    #include <boost/polymorphic_pointer_cast.hpp>
    class Fruit { public: virtual ~Fruit(){} };
    class Banana : public Fruit {};
    // Use one of these:
    using FruitPtr = Fruit*;
    using FruitPtr = std::shared_ptr<Fruit>;
    using FruitPtr = boost::shared_ptr<Fruit>;
    using FruitPtr = boost::intrusive_ptr<Fruit>;
    void f(FruitPtr fruit) {
      // ... logic which leads us to believe it is a banana
      auto banana = boost::polymorphic_pointer_downcast<Banana>(fruit);
      ...
    }
 ```
 [endsect]
 [endsect]
 [section Synopsis]
 ```
    namespace boost {
    // Throws: std::bad_cast if ( dynamic_cast<Derived>(x) == 0 )
    // Returns: dynamic_cast<Derived>(x)
    template <class Derived, class Base>
    constexpr Derived polymorphic_cast(Base* x);
    // Effects: assert( dynamic_cast<Derived>(x) == x );
    // Returns: static_cast<Derived>(x)
    template <class Derived, class Base>
    constexpr Derived polymorphic_downcast(Base* x);
    // Effects: assert( dynamic_cast<Derived>(&x) == &x );
    // Returns: static_cast<Derived>(x)
    template <class Derived, class Base>
    constexpr Derived polymorphic_downcast(Base& x);
    // Throws: std::bad_cast if ( dynamic_pointer_cast<Derived>(x) == 0 )
    // Returns: dynamic_pointer_cast<Derived>(x)
    template <class Derived, class Base>
    inline auto polymorphic_pointer_cast(Base x);
    // Effects: assert( dynamic_pointer_cast<Derived>(x) == x );
    // Returns: static_pointer_cast<Derived>(x)
    template <class Derived, class Base>
    inline auto polymorphic_pointer_downcast(Base x);
    }
 ```
 [endsect]
 [section History]
 `polymorphic_cast` was suggested by Bjarne Stroustrup in "The C++ Programming Language".
 `polymorphic_downcast` was contributed by [@http://www.boost.org/people/dave_abrahams.htm Dave Abrahams].
 `polymorphic_pointer_downcast` was contributed by [@http://www.boost.org/people/boris_rasin.htm Boris Rasin]
 and `polymorphic_pointer_cast` by Antony Polukhin.
 `polymorphic_downcast` overload for references was contributed by Julien Delacroix.
 An old `numeric_cast` that was contributed by [@http://www.boost.org/people/kevlin_henney.htm Kevlin Henney]
 is now superseded by the [@boost:numeric_conversion/doc/html/html/boost_numericconversion/improved_numeric_cast__.html Boost Numeric Conversion Library]
 [endsect]
@@ -0,0 +1,607 @@
 [library Boost.Lexical_Cast
    [quickbook 1.5]
    [version 1.0]
    [copyright 2000-2005 Kevlin Henney]
    [copyright 2006-2010 Alexander Nasonov]
    [copyright 2011 Antony Polukhin]
    [category String and text processing]
    [category Miscellaneous]
    [license
        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])
    ]
 ]
 [def __numericcast__  [@boost:libs/numeric/conversion/doc/html/boost_numericconversion/improved_numeric_cast__.html `boost::numeric_cast`]]
 [def __proposallong__ [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1973.html Lexical Conversion Library Proposal for TR2, N1973 by Kevlin Henney and Beman Dawes]]
 [def __proposalshort__ [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1973.html Lexical Conversion Library Proposal for TR2, N1973]]
 [section Motivation]
 Sometimes a value must be converted to a literal text form, such as an [c++] `int` represented as a `std::string`, or vice-versa, when a `std::string` is interpreted as an `int`. Such examples are common when converting between data types internal to a program and representation external to a program, such as windows and configuration files.
 The standard C and C++ libraries offer a number of facilities for performing such conversions. However, they vary with their ease of use, extensibility, and safety.
 For instance, there are a number of limitations with the family of standard C functions typified by `atoi`:
 * Conversion is supported in one direction only: from text to internal data type. Converting the other way using the C library requires either the inconvenience and compromised safety of the `sprintf` function, or the loss of portability associated with non-standard functions such as `itoa`.
 * The range of types supported is only a subset of the built-in numeric types, namely `int`, `long`, and `double`.
 * The range of types cannot be extended in a uniform manner. For instance, conversion from string representation to complex or rational.
 The standard C functions typified by `strtol` have the same basic limitations, but offer finer control over the conversion process. However, for the common case such control is often either not required or not used. The `scanf` family of functions offer even greater control, but also lack safety and ease of use.
 The standard C++ library offers `stringstream` for the kind of in-core formatting being discussed. It offers a great deal of control over the formatting and conversion of I/O to and from arbitrary types through text. However, for simple conversions direct use of `stringstream` can be either clumsy (with the introduction of extra local variables and the loss of infix-expression convenience) or obscure (where `stringstream` objects are created as temporary objects in an expression). Facets provide a comprehensive concept and facility for controlling textual representation, but their perceived complexity and high entry level requires an extreme degree of involvement for simple conversions, and excludes all but a few programmers.
 The `lexical_cast` function template offers a convenient and consistent form for supporting common conversions to and from arbitrary types when they are represented as text. The simplification it offers is in expression-level convenience for such conversions. For more involved conversions, such as where precision or formatting need tighter control than is offered by the default behavior of `lexical_cast`, the conventional `std::stringstream` approach is recommended. Where the conversions are numeric to numeric, __numericcast__ may offer more reasonable behavior than `lexical_cast`.
 For a good discussion of the options and issues involved in string-based formatting, including comparison of `stringstream`, `lexical_cast`, and others, see Herb Sutter's article, [@http://www.gotw.ca/publications/mill19.htm The String Formatters of Manor Farm]. Also, take a look at the [link boost_lexical_cast.performance Performance] section. 
 [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;
        std::vector<short> args;
        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));
    }
 ``
 [endsect]
 [section Synopsis]
 Library features defined in [@boost:boost/lexical_cast.hpp boost/lexical_cast.hpp]:
 ``
    namespace boost
    {
        class bad_lexical_cast;
        template<typename Target, typename Source>
          Target lexical_cast(const Source& arg);
    }
 ``
 [section lexical_cast]
 ``
    template<typename Target, typename Source>
      Target lexical_cast(const Source& arg);
 ``
 Returns the result of streaming arg into a standard library string-based stream and then out as a Target object. Where Target is either `std::string` or `std::wstring`, stream extraction takes the whole content of the string, including spaces, rather than relying on the default `operator>>` behavior. If the conversion is unsuccessful, a `bad_lexical_cast` exception is thrown.
 The requirements on the argument and result types are:
 * Source is OutputStreamable, meaning that an `operator<<` is defined that takes a `std::ostream` or `std::wostream` object on the left hand side and an instance of the argument type on the right.
 * Target is InputStreamable, meaning that an `operator>>` is defined that takes a `std::istream` or `std::wistream` object on the left hand side and an instance of the result type on the right.
 * Target is CopyConstructible [20.1.3].
 * Target is DefaultConstructible, meaning that it is possible to default-initialize an object of that type [8.5, 20.1.4].
 The character type of the underlying stream is assumed to be char unless either the Source or the Target requires wide-character streaming, in which case the underlying stream uses `wchar_t`. Source types that require wide-character streaming are `wchar_t`, `wchar_t *`, and `std::wstring`. Target types that require wide-character streaming are `wchar_t` and `std::wstring`.
 Where a higher degree of control is required over conversions, `std::stringstream` and `std::wstringstream` offer a more appropriate path. Where non-stream-based conversions are required, `lexical_cast` is the wrong tool for the job and is not special-cased for such scenarios.
 [endsect]
 [section bad_lexical_cast]
 ``
    class bad_lexical_cast : public std::bad_cast
    {
    public:
        ... // same member function interface as std::exception
    };
 ``
 Exception used to indicate runtime lexical_cast failure.
 [endsect]
 [endsect]
 [section Frequently Asked Questions]
 * [*Question:]    Why does `lexical_cast<int8_t>("127")` throw `bad_lexical_cast`?
  * [*Answer:]      The type `int8_t` is a `typedef` to `char` or `signed char`. Lexical conversion to these types is simply reading a byte from source but since the source has more than one byte, the exception is thrown. 
 Please use other integer types such as `int` or `short int`. If bounds checking is important, you can also 
 call __numericcast__: 
 `numeric_cast<int8_t>(lexical_cast<int>("127"));`
 [pre
 ]
 * [*Question:]    Why does `lexical_cast<unsigned char>("127")` throw `bad_lexical_cast`?
  * [*Answer:]      Lexical conversion to any char type is simply reading a byte from source. But since the source has more than one byte, the exception is thrown. 
 Please use other integer types such as `int` or `short int`. If bounds checking is important, you can also 
 call __numericcast__: 
 `numeric_cast<unsigned char>(lexical_cast<int>("127"));`
 [pre
 ]
 * [*Question:]    What does `lexical_cast<std::string>` of an `int8_t` or `uint8_t` not do what I expect?
  * [*Answer:]      As above, note that int8_t and uint8_t are actually chars and are formatted as such. To avoid 
 this, cast to an integer type first: `lexical_cast<std::string>(static_cast<int>(n));`
 [pre
 ]
 * [*Question:]    The implementation always resets the `ios_base::skipws` flag of an underlying stream object. 
 It breaks my `operator>>` that works only in presence of this flag. Can you remove code that resets the flag?
  * [*Answer:]      May be in a future version. There is no requirement in 
 __proposallong__ to reset the flag but 
 remember that __proposalshort__ is not yet accepted by the committee. By the way, it's a great opportunity to 
 make your `operator>>` conform to the standard.
 Read a good C++ book, study `std::sentry` and [@boost:libs/io/doc/ios_state.html `ios_state_saver`].
 [pre
 ]
 * [*Question:]    Why `std::cout << boost::lexical_cast<unsigned int>("-1");` does not throw, but outputs 4294967295?
  * [*Answer:]      `boost::lexical_cast` has the behavior of `std::stringstream`, which uses `num_get` functions of 
 `std::locale` to convert numbers. If we look at the Programming languages — C++, we'll see, that `num_get` uses 
 the rules of `scanf` for conversions. And in the C99 standard for unsigned input value minus sign is optional, so 
 if a negative number is read, no errors will arise and the result will be the two's complement.
 [endsect]
 [section Changes]
 * [*boost 1.48.0 :]
    * Added code to work with Inf and NaN on any platform.    
    * Better performance and less memory usage for conversions to float type (and to double type, if `sizeof(double) < sizeof(long double)`).
 * [*boost 1.47.0 :]
    * Optimizations for "C" and other locales without number grouping.
    * Better performance and less memory usage for unsigned char and signed char conversions.
    * Better performance and less memory usage for conversions to arithmetic types.
    * Better performance and less memory usage for conversions from arithmetic type to arithmetic type.
    * Directly construct Target from Source on some conversions (like conversions from string to string, from char array to string, from char to char and others).
 * [*boost 1.34.0 :]
    * Better performance for many combinations of Source and Target types. For more details refer to Alexander Nasonovs article [@http://accu.org/index.php/journals/1375 Fine Tuning for lexical_cast, Overload #74, August 2006] [@http://www.accu.org/var/uploads/journals/overload74.pdf (PDF)].
 * [*boost 1.33.0 :]
    * Call-by-const reference for the parameters. This requires partial specialization of class templates, so it doesn't work for MSVC 6, and it uses the original pass by value there.
    * The MSVC 6 support is deprecated, and will be removed in a future Boost version.
 * [*Earlier :]
    * The previous version of lexical_cast used the default stream precision for reading and writing floating-point numbers. For numerics that have a corresponding specialization of `std::numeric_limits`, the current version now chooses a precision to match.
    * The previous version of lexical_cast did not support conversion to or from any wide-character-based types. For compilers with full language and library support for wide characters, `lexical_cast` now supports conversions from `wchar_t`, `wchar_t *`, and `std::wstring` and to `wchar_t` and `std::wstring`.
    * The previous version of `lexical_cast` assumed that the conventional stream extractor operators were sufficient for reading values. However, string I/O is asymmetric, with the result that spaces play the role of I/O separators rather than string content. The current version fixes this error for `std::string` and, where supported, `std::wstring`: `lexical_cast<std::string>("Hello, World")` succeeds instead of failing with a `bad_lexical_cast` exception.
    * The previous version of `lexical_cast` allowed unsafe and meaningless conversions to pointers. The current version now throws a `bad_lexical_cast` for conversions to pointers: `lexical_cast<char *>("Goodbye, World")` now throws an exception instead of causing undefined behavior. 
 [endsect]
 [section Performance]
 In most cases `boost::lexical_cast` is faster than `scanf`, `printf`, `std::stringstream`. For more detailed info you can look at the tables below.
 [section Tests description]
 All the tests measure execution speed in milliseconds for 10000 iterations of the following code blocks:
 [table:legend Tests source code
 [[Test name] [Code]]
 [[lexical_cast]
  [``
            _out = boost::lexical_cast<OUTTYPE>(_in);
  ``]
  ]
 [[std::stringstream with construction]
  [``
            std::stringstream ss;
            ss << _in;
            if (ss.fail()) throw std::logic_error(descr);
            ss >> _out;
            if (ss.fail()) throw std::logic_error(descr);
  ``]
  ]
 [[std::stringstream without construction]
  [``
            ss << _in; // ss is an instance of std::stringstream
            if (ss.fail()) throw std::logic_error(descr);
            ss >> _out;
            if (ss.fail()) throw std::logic_error(descr);
            /* reseting std::stringstream to use it again */
            ss.str(std::string());
            ss.clear();
  ``]
  ]
 [[scanf/printf]
  [``
            typename OUTTYPE::value_type buffer[500];
            sprintf( (char*)buffer, conv, _in);
            _out = buffer;
  ``]
  ]
 ]
 Fastest results are highlitened with "!!! *x* !!!". 
 Do not use this results to compare compilers, because tests were taken on different hardware.
 [endsect]
 [/ BEGIN of section, generated by performance measuring program ]
 [section clang-linux-2.8][table:id Performance Table (clang-linux-2.8)
 [[From->To] [lexical_cast] [std::stringstream with construction] [std::stringstream without construction][scanf/printf]]
 [[ string->char ][ !!! *<1* !!! ][ 148 ][ 14 ][ 12 ]]
 [[ string->signed char ][ !!! *<1* !!! ][ 97 ][ 8 ][ 7 ]]
 [[ string->unsigned char ][ !!! *<1* !!! ][ 90 ][ 8 ][ 13 ]]
 [[ string->int ][ !!! *4* !!! ][ 102 ][ 19 ][ 15 ]]
 [[ string->short ][ !!! *4* !!! ][ 105 ][ 20 ][ 15 ]]
 [[ string->long int ][ !!! *4* !!! ][ 105 ][ 19 ][ 15 ]]
 [[ string->long long ][ !!! *4* !!! ][ 115 ][ 19 ][ 14 ]]
 [[ string->unsigned int ][ !!! *4* !!! ][ 102 ][ 18 ][ 14 ]]
 [[ string->unsigned short ][ !!! *4* !!! ][ 101 ][ 19 ][ 15 ]]
 [[ string->unsigned long int ][ !!! *3* !!! ][ 107 ][ 20 ][ 14 ]]
 [[ string->unsigned long long ][ !!! *3* !!! ][ 103 ][ 20 ][ 14 ]]
 [[ string->bool ][ !!! *<1* !!! ][ 97 ][ 16 ][ 8 ]]
 [[ string->float ][ !!! *21* !!! ][ 170 ][ 61 ][ 32 ]]
 [[ string->double ][ !!! *18* !!! ][ 206 ][ 93 ][ 58 ]]
 [[ string->long double ][ 135 ][ 221 ][ 94 ][ !!! *57* !!! ]]
 [[ char->string ][ !!! *7* !!! ][ 100 ][ 17 ][ 13 ]]
 [[ unsigned char->string ][ !!! *7* !!! ][ 99 ][ 18 ][ 16 ]]
 [[ signed char->string ][ !!! *7* !!! ][ 101 ][ 17 ][ 12 ]]
 [[ int->string ][ !!! *13* !!! ][ 110 ][ 23 ][ 15 ]]
 [[ short->string ][ !!! *13* !!! ][ 112 ][ 24 ][ 18 ]]
 [[ long int->string ][ !!! *13* !!! ][ 119 ][ 23 ][ 17 ]]
 [[ long long->string ][ !!! *13* !!! ][ 110 ][ 23 ][ 18 ]]
 [[ unsigned int->string ][ !!! *14* !!! ][ 113 ][ 24 ][ 17 ]]
 [[ unsigned short->string ][ !!! *13* !!! ][ 108 ][ 24 ][ 17 ]]
 [[ unsigned long int->string ][ !!! *13* !!! ][ 109 ][ 24 ][ 16 ]]
 [[ unsigned long long->string ][ !!! *13* !!! ][ 110 ][ 23 ][ 17 ]]
 [[ bool->string ][ !!! *7* !!! ][ 105 ][ 24 ][ 12 ]]
 [[ float->string ][ 70 ][ 192 ][ 94 ][ !!! *49* !!! ]]
 [[ double->string ][ 106 ][ 217 ][ 122 ][ !!! *76* !!! ]]
 [[ long double->string ][ 120 ][ 219 ][ 123 ][ !!! *80* !!! ]]
 [[ char*->char ][ !!! *2* !!! ][ 90 ][ 9 ][ 8 ]]
 [[ char*->signed char ][ !!! *2* !!! ][ 87 ][ 10 ][ 7 ]]
 [[ char*->unsigned char ][ !!! *3* !!! ][ 90 ][ 10 ][ 13 ]]
 [[ char*->int ][ !!! *6* !!! ][ 107 ][ 21 ][ 15 ]]
 [[ char*->short ][ !!! *6* !!! ][ 110 ][ 19 ][ 14 ]]
 [[ char*->long int ][ !!! *6* !!! ][ 103 ][ 19 ][ 14 ]]
 [[ char*->long long ][ !!! *7* !!! ][ 104 ][ 20 ][ 15 ]]
 [[ char*->unsigned int ][ !!! *6* !!! ][ 101 ][ 20 ][ 15 ]]
 [[ char*->unsigned short ][ !!! *7* !!! ][ 100 ][ 20 ][ 14 ]]
 [[ char*->unsigned long int ][ !!! *6* !!! ][ 105 ][ 22 ][ 15 ]]
 [[ char*->unsigned long long ][ !!! *7* !!! ][ 106 ][ 21 ][ 14 ]]
 [[ char*->bool ][ !!! *2* !!! ][ 99 ][ 18 ][ 7 ]]
 [[ char*->float ][ !!! *22* !!! ][ 159 ][ 67 ][ 33 ]]
 [[ char*->double ][ !!! *20* !!! ][ 205 ][ 94 ][ 58 ]]
 [[ char*->long double ][ 140 ][ 214 ][ 95 ][ !!! *58* !!! ]]
 [[ unsigned char*->char ][ !!! *2* !!! ][ 92 ][ 9 ][ 7 ]]
 [[ unsigned char*->signed char ][ !!! *2* !!! ][ 89 ][ 10 ][ 7 ]]
 [[ unsigned char*->unsigned char ][ !!! *2* !!! ][ 89 ][ 10 ][ 14 ]]
 [[ unsigned char*->int ][ !!! *6* !!! ][ 104 ][ 20 ][ 14 ]]
 [[ unsigned char*->short ][ !!! *6* !!! ][ 106 ][ 21 ][ 14 ]]
 [[ unsigned char*->long int ][ !!! *6* !!! ][ 105 ][ 19 ][ 14 ]]
 [[ unsigned char*->long long ][ !!! *6* !!! ][ 106 ][ 20 ][ 15 ]]
 [[ unsigned char*->unsigned int ][ !!! *7* !!! ][ 105 ][ 19 ][ 14 ]]
 [[ unsigned char*->unsigned short ][ !!! *6* !!! ][ 103 ][ 19 ][ 14 ]]
 [[ unsigned char*->unsigned long int ][ !!! *6* !!! ][ 106 ][ 19 ][ 14 ]]
 [[ unsigned char*->unsigned long long ][ !!! *6* !!! ][ 104 ][ 21 ][ 15 ]]
 [[ unsigned char*->bool ][ !!! *2* !!! ][ 102 ][ 18 ][ 7 ]]
 [[ unsigned char*->float ][ !!! *23* !!! ][ 160 ][ 66 ][ 32 ]]
 [[ unsigned char*->double ][ !!! *20* !!! ][ 201 ][ 95 ][ 58 ]]
 [[ unsigned char*->long double ][ 144 ][ 221 ][ 95 ][ !!! *60* !!! ]]
 [[ unsigned char*->string ][ !!! *12* !!! ][ 104 ][ 23 ][ --- ]]
 [[ signed char*->char ][ !!! *2* !!! ][ 90 ][ 9 ][ 7 ]]
 [[ signed char*->signed char ][ !!! *2* !!! ][ 89 ][ 9 ][ 7 ]]
 [[ signed char*->unsigned char ][ !!! *2* !!! ][ 89 ][ 10 ][ 13 ]]
 [[ signed char*->int ][ !!! *6* !!! ][ 106 ][ 19 ][ 15 ]]
 [[ signed char*->short ][ !!! *6* !!! ][ 107 ][ 20 ][ 15 ]]
 [[ signed char*->long int ][ !!! *6* !!! ][ 103 ][ 19 ][ 14 ]]
 [[ signed char*->long long ][ !!! *6* !!! ][ 103 ][ 19 ][ 14 ]]
 [[ signed char*->unsigned int ][ !!! *6* !!! ][ 101 ][ 19 ][ 15 ]]
 [[ signed char*->unsigned short ][ !!! *6* !!! ][ 101 ][ 19 ][ 16 ]]
 [[ signed char*->unsigned long int ][ !!! *6* !!! ][ 105 ][ 22 ][ 15 ]]
 [[ signed char*->unsigned long long ][ !!! *6* !!! ][ 104 ][ 21 ][ 15 ]]
 [[ signed char*->bool ][ !!! *2* !!! ][ 100 ][ 18 ][ 7 ]]
 [[ signed char*->float ][ !!! *23* !!! ][ 161 ][ 62 ][ 32 ]]
 [[ signed char*->double ][ !!! *20* !!! ][ 207 ][ 102 ][ 57 ]]
 [[ signed char*->long double ][ 144 ][ 216 ][ 96 ][ !!! *63* !!! ]]
 [[ signed char*->string ][ !!! *12* !!! ][ 104 ][ 23 ][ --- ]]
 [[ int->int ][ !!! *<1* !!! ][ 110 ][ 22 ][ --- ]]
 [[ float->double ][ !!! *<1* !!! ][ 223 ][ 113 ][ --- ]]
 [[ double->double ][ !!! *<1* !!! ][ 227 ][ 111 ][ --- ]]
 [[ int->int ][ !!! *<1* !!! ][ 231 ][ 122 ][ --- ]]
 [[ int->int ][ !!! *<1* !!! ][ 229 ][ 121 ][ --- ]]
 [[ char->unsigned char ][ !!! *<1* !!! ][ 90 ][ 8 ][ --- ]]
 [[ char->signed char ][ !!! *<1* !!! ][ 88 ][ 8 ][ --- ]]
 [[ unsigned char->char ][ !!! *<1* !!! ][ 89 ][ 8 ][ --- ]]
 [[ signed char->char ][ !!! *<1* !!! ][ 91 ][ 9 ][ --- ]]
 ]
 [endsect]
 [section gcc-4.4][table:id Performance Table (gcc-4.4)
 [[From->To] [lexical_cast] [std::stringstream with construction] [std::stringstream without construction][scanf/printf]]
 [[ string->char ][ !!! *<1* !!! ][ 90 ][ 7 ][ 7 ]]
 [[ string->signed char ][ !!! *<1* !!! ][ 88 ][ 7 ][ 8 ]]
 [[ string->unsigned char ][ !!! *<1* !!! ][ 88 ][ 8 ][ 14 ]]
 [[ string->int ][ !!! *3* !!! ][ 103 ][ 18 ][ 15 ]]
 [[ string->short ][ !!! *3* !!! ][ 105 ][ 20 ][ 15 ]]
 [[ string->long int ][ !!! *3* !!! ][ 101 ][ 18 ][ 16 ]]
 [[ string->long long ][ !!! *3* !!! ][ 101 ][ 18 ][ 15 ]]
 [[ string->unsigned int ][ !!! *3* !!! ][ 98 ][ 23 ][ 14 ]]
 [[ string->unsigned short ][ !!! *3* !!! ][ 100 ][ 17 ][ 14 ]]
 [[ string->unsigned long int ][ !!! *3* !!! ][ 100 ][ 21 ][ 15 ]]
 [[ string->unsigned long long ][ !!! *3* !!! ][ 99 ][ 19 ][ 15 ]]
 [[ string->bool ][ !!! *<1* !!! ][ 95 ][ 16 ][ 8 ]]
 [[ string->float ][ !!! *13* !!! ][ 160 ][ 61 ][ 33 ]]
 [[ string->double ][ !!! *14* !!! ][ 206 ][ 93 ][ 59 ]]
 [[ string->long double ][ 128 ][ 217 ][ 96 ][ !!! *61* !!! ]]
 [[ char->string ][ !!! *7* !!! ][ 100 ][ 17 ][ 12 ]]
 [[ unsigned char->string ][ !!! *7* !!! ][ 109 ][ 17 ][ 16 ]]
 [[ signed char->string ][ !!! *7* !!! ][ 99 ][ 17 ][ 12 ]]
 [[ int->string ][ !!! *13* !!! ][ 110 ][ 21 ][ 15 ]]
 [[ short->string ][ !!! *14* !!! ][ 110 ][ 22 ][ 17 ]]
 [[ long int->string ][ !!! *14* !!! ][ 109 ][ 21 ][ 16 ]]
 [[ long long->string ][ !!! *13* !!! ][ 114 ][ 20 ][ 17 ]]
 [[ unsigned int->string ][ !!! *13* !!! ][ 109 ][ 23 ][ 15 ]]
 [[ unsigned short->string ][ !!! *14* !!! ][ 109 ][ 23 ][ 17 ]]
 [[ unsigned long int->string ][ !!! *13* !!! ][ 112 ][ 23 ][ 16 ]]
 [[ unsigned long long->string ][ !!! *14* !!! ][ 109 ][ 21 ][ 17 ]]
 [[ bool->string ][ !!! *7* !!! ][ 108 ][ 23 ][ 11 ]]
 [[ float->string ][ 63 ][ 185 ][ 92 ][ !!! *50* !!! ]]
 [[ double->string ][ 106 ][ 216 ][ 116 ][ !!! *75* !!! ]]
 [[ long double->string ][ 118 ][ 219 ][ 119 ][ !!! *80* !!! ]]
 [[ char*->char ][ !!! *1* !!! ][ 93 ][ 9 ][ 9 ]]
 [[ char*->signed char ][ !!! *1* !!! ][ 92 ][ 9 ][ 9 ]]
 [[ char*->unsigned char ][ !!! *1* !!! ][ 92 ][ 9 ][ 14 ]]
 [[ char*->int ][ !!! *4* !!! ][ 107 ][ 19 ][ 15 ]]
 [[ char*->short ][ !!! *5* !!! ][ 109 ][ 19 ][ 15 ]]
 [[ char*->long int ][ !!! *4* !!! ][ 113 ][ 19 ][ 15 ]]
 [[ char*->long long ][ !!! *4* !!! ][ 108 ][ 20 ][ 15 ]]
 [[ char*->unsigned int ][ !!! *4* !!! ][ 106 ][ 19 ][ 15 ]]
 [[ char*->unsigned short ][ !!! *4* !!! ][ 106 ][ 18 ][ 15 ]]
 [[ char*->unsigned long int ][ !!! *4* !!! ][ 103 ][ 22 ][ 15 ]]
 [[ char*->unsigned long long ][ !!! *4* !!! ][ 105 ][ 20 ][ 15 ]]
 [[ char*->bool ][ !!! *1* !!! ][ 104 ][ 18 ][ 8 ]]
 [[ char*->float ][ !!! *15* !!! ][ 164 ][ 62 ][ 33 ]]
 [[ char*->double ][ !!! *16* !!! ][ 203 ][ 97 ][ 58 ]]
 [[ char*->long double ][ 132 ][ 223 ][ 98 ][ !!! *60* !!! ]]
 [[ unsigned char*->char ][ !!! *2* !!! ][ 90 ][ 9 ][ 8 ]]
 [[ unsigned char*->signed char ][ !!! *2* !!! ][ 92 ][ 10 ][ 8 ]]
 [[ unsigned char*->unsigned char ][ !!! *2* !!! ][ 91 ][ 9 ][ 14 ]]
 [[ unsigned char*->int ][ !!! *6* !!! ][ 106 ][ 20 ][ 15 ]]
 [[ unsigned char*->short ][ !!! *6* !!! ][ 106 ][ 21 ][ 15 ]]
 [[ unsigned char*->long int ][ !!! *6* !!! ][ 111 ][ 19 ][ 15 ]]
 [[ unsigned char*->long long ][ !!! *6* !!! ][ 107 ][ 20 ][ 15 ]]
 [[ unsigned char*->unsigned int ][ !!! *6* !!! ][ 105 ][ 19 ][ 15 ]]
 [[ unsigned char*->unsigned short ][ !!! *6* !!! ][ 103 ][ 18 ][ 15 ]]
 [[ unsigned char*->unsigned long int ][ !!! *6* !!! ][ 106 ][ 22 ][ 14 ]]
 [[ unsigned char*->unsigned long long ][ !!! *6* !!! ][ 105 ][ 20 ][ 14 ]]
 [[ unsigned char*->bool ][ !!! *2* !!! ][ 106 ][ 18 ][ 8 ]]
 [[ unsigned char*->float ][ !!! *15* !!! ][ 167 ][ 68 ][ 33 ]]
 [[ unsigned char*->double ][ !!! *17* !!! ][ 203 ][ 99 ][ 58 ]]
 [[ unsigned char*->long double ][ 129 ][ 216 ][ 97 ][ !!! *61* !!! ]]
 [[ unsigned char*->string ][ !!! *13* !!! ][ 111 ][ 23 ][ --- ]]
 [[ signed char*->char ][ !!! *2* !!! ][ 92 ][ 9 ][ 8 ]]
 [[ signed char*->signed char ][ !!! *2* !!! ][ 91 ][ 9 ][ 8 ]]
 [[ signed char*->unsigned char ][ !!! *2* !!! ][ 91 ][ 9 ][ 14 ]]
 [[ signed char*->int ][ !!! *6* !!! ][ 107 ][ 19 ][ 15 ]]
 [[ signed char*->short ][ !!! *6* !!! ][ 109 ][ 24 ][ 14 ]]
 [[ signed char*->long int ][ !!! *6* !!! ][ 112 ][ 19 ][ 15 ]]
 [[ signed char*->long long ][ !!! *5* !!! ][ 107 ][ 20 ][ 15 ]]
 [[ signed char*->unsigned int ][ !!! *6* !!! ][ 108 ][ 20 ][ 15 ]]
 [[ signed char*->unsigned short ][ !!! *6* !!! ][ 104 ][ 18 ][ 15 ]]
 [[ signed char*->unsigned long int ][ !!! *6* !!! ][ 102 ][ 22 ][ 15 ]]
 [[ signed char*->unsigned long long ][ !!! *6* !!! ][ 104 ][ 20 ][ 15 ]]
 [[ signed char*->bool ][ !!! *2* !!! ][ 104 ][ 18 ][ 8 ]]
 [[ signed char*->float ][ !!! *16* !!! ][ 165 ][ 63 ][ 33 ]]
 [[ signed char*->double ][ !!! *16* !!! ][ 203 ][ 98 ][ 59 ]]
 [[ signed char*->long double ][ 129 ][ 215 ][ 98 ][ !!! *61* !!! ]]
 [[ signed char*->string ][ !!! *13* !!! ][ 109 ][ 21 ][ --- ]]
 [[ int->int ][ !!! *<1* !!! ][ 109 ][ 21 ][ --- ]]
 [[ float->double ][ !!! *<1* !!! ][ 221 ][ 102 ][ --- ]]
 [[ double->double ][ !!! *<1* !!! ][ 223 ][ 103 ][ --- ]]
 [[ int->int ][ !!! *<1* !!! ][ 231 ][ 115 ][ --- ]]
 [[ int->int ][ !!! *<1* !!! ][ 231 ][ 115 ][ --- ]]
 [[ char->unsigned char ][ !!! *<1* !!! ][ 92 ][ 8 ][ --- ]]
 [[ char->signed char ][ !!! *<1* !!! ][ 88 ][ 8 ][ --- ]]
 [[ unsigned char->char ][ !!! *<1* !!! ][ 88 ][ 7 ][ --- ]]
 [[ signed char->char ][ !!! *<1* !!! ][ 89 ][ 8 ][ --- ]]
 ]
 [endsect]
 [section gcc-4.5][table:id Performance Table (gcc-4.5)
 [[From->To] [lexical_cast] [std::stringstream with construction] [std::stringstream without construction][scanf/printf]]
 [[ string->char ][ !!! *<1* !!! ][ 91 ][ 8 ][ 7 ]]
 [[ string->signed char ][ !!! *<1* !!! ][ 91 ][ 8 ][ 7 ]]
 [[ string->unsigned char ][ !!! *<1* !!! ][ 90 ][ 8 ][ 13 ]]
 [[ string->int ][ !!! *3* !!! ][ 100 ][ 20 ][ 14 ]]
 [[ string->short ][ !!! *3* !!! ][ 106 ][ 20 ][ 14 ]]
 [[ string->long int ][ !!! *3* !!! ][ 100 ][ 18 ][ 14 ]]
 [[ string->long long ][ !!! *9* !!! ][ 100 ][ 18 ][ 15 ]]
 [[ string->unsigned int ][ !!! *3* !!! ][ 97 ][ 20 ][ 14 ]]
 [[ string->unsigned short ][ !!! *3* !!! ][ 102 ][ 17 ][ 14 ]]
 [[ string->unsigned long int ][ !!! *3* !!! ][ 97 ][ 21 ][ 14 ]]
 [[ string->unsigned long long ][ !!! *3* !!! ][ 97 ][ 19 ][ 14 ]]
 [[ string->bool ][ !!! *<1* !!! ][ 95 ][ 16 ][ 7 ]]
 [[ string->float ][ !!! *15* !!! ][ 157 ][ 63 ][ 32 ]]
 [[ string->double ][ !!! *17* !!! ][ 203 ][ 95 ][ 59 ]]
 [[ string->long double ][ 129 ][ 216 ][ 93 ][ !!! *58* !!! ]]
 [[ char->string ][ !!! *8* !!! ][ 100 ][ 17 ][ 10 ]]
 [[ unsigned char->string ][ !!! *8* !!! ][ 96 ][ 18 ][ 16 ]]
 [[ signed char->string ][ !!! *8* !!! ][ 96 ][ 18 ][ 10 ]]
 [[ int->string ][ !!! *14* !!! ][ 105 ][ 22 ][ 15 ]]
 [[ short->string ][ !!! *14* !!! ][ 107 ][ 23 ][ 17 ]]
 [[ long int->string ][ !!! *14* !!! ][ 109 ][ 22 ][ 17 ]]
 [[ long long->string ][ !!! *14* !!! ][ 105 ][ 22 ][ 18 ]]
 [[ unsigned int->string ][ !!! *14* !!! ][ 105 ][ 25 ][ 15 ]]
 [[ unsigned short->string ][ !!! *15* !!! ][ 105 ][ 23 ][ 17 ]]
 [[ unsigned long int->string ][ !!! *14* !!! ][ 109 ][ 24 ][ 17 ]]
 [[ unsigned long long->string ][ !!! *14* !!! ][ 102 ][ 23 ][ 17 ]]
 [[ bool->string ][ !!! *8* !!! ][ 104 ][ 23 ][ 12 ]]
 [[ float->string ][ 66 ][ 181 ][ 92 ][ !!! *49* !!! ]]
 [[ double->string ][ 107 ][ 215 ][ 120 ][ !!! *75* !!! ]]
 [[ long double->string ][ 117 ][ 221 ][ 125 ][ !!! *79* !!! ]]
 [[ char*->char ][ !!! *1* !!! ][ 89 ][ 9 ][ 7 ]]
 [[ char*->signed char ][ !!! *1* !!! ][ 90 ][ 9 ][ 7 ]]
 [[ char*->unsigned char ][ !!! *2* !!! ][ 90 ][ 9 ][ 13 ]]
 [[ char*->int ][ !!! *7* !!! ][ 103 ][ 20 ][ 15 ]]
 [[ char*->short ][ !!! *6* !!! ][ 102 ][ 29 ][ 14 ]]
 [[ char*->long int ][ !!! *7* !!! ][ 101 ][ 20 ][ 15 ]]
 [[ char*->long long ][ !!! *6* !!! ][ 102 ][ 20 ][ 14 ]]
 [[ char*->unsigned int ][ !!! *6* !!! ][ 99 ][ 19 ][ 14 ]]
 [[ char*->unsigned short ][ !!! *6* !!! ][ 101 ][ 18 ][ 14 ]]
 [[ char*->unsigned long int ][ !!! *6* !!! ][ 102 ][ 22 ][ 14 ]]
 [[ char*->unsigned long long ][ !!! *6* !!! ][ 101 ][ 21 ][ 14 ]]
 [[ char*->bool ][ !!! *3* !!! ][ 98 ][ 18 ][ 7 ]]
 [[ char*->float ][ !!! *18* !!! ][ 162 ][ 63 ][ 31 ]]
 [[ char*->double ][ !!! *17* !!! ][ 203 ][ 96 ][ 58 ]]
 [[ char*->long double ][ 135 ][ 214 ][ 98 ][ !!! *58* !!! ]]
 [[ unsigned char*->char ][ !!! *2* !!! ][ 87 ][ 9 ][ 7 ]]
 [[ unsigned char*->signed char ][ !!! *2* !!! ][ 87 ][ 9 ][ 7 ]]
 [[ unsigned char*->unsigned char ][ !!! *3* !!! ][ 87 ][ 9 ][ 13 ]]
 [[ unsigned char*->int ][ !!! *6* !!! ][ 105 ][ 20 ][ 14 ]]
 [[ unsigned char*->short ][ !!! *6* !!! ][ 102 ][ 21 ][ 14 ]]
 [[ unsigned char*->long int ][ !!! *6* !!! ][ 101 ][ 20 ][ 14 ]]
 [[ unsigned char*->long long ][ !!! *6* !!! ][ 102 ][ 20 ][ 14 ]]
 [[ unsigned char*->unsigned int ][ !!! *6* !!! ][ 99 ][ 19 ][ 14 ]]
 [[ unsigned char*->unsigned short ][ !!! *6* !!! ][ 100 ][ 18 ][ 14 ]]
 [[ unsigned char*->unsigned long int ][ !!! *6* !!! ][ 101 ][ 24 ][ 14 ]]
 [[ unsigned char*->unsigned long long ][ !!! *6* !!! ][ 100 ][ 20 ][ 14 ]]
 [[ unsigned char*->bool ][ !!! *3* !!! ][ 99 ][ 18 ][ 8 ]]
 [[ unsigned char*->float ][ !!! *17* !!! ][ 164 ][ 64 ][ 32 ]]
 [[ unsigned char*->double ][ !!! *18* !!! ][ 201 ][ 94 ][ 58 ]]
 [[ unsigned char*->long double ][ 133 ][ 217 ][ 95 ][ !!! *60* !!! ]]
 [[ unsigned char*->string ][ !!! *14* !!! ][ 103 ][ 23 ][ --- ]]
 [[ signed char*->char ][ !!! *3* !!! ][ 88 ][ 10 ][ 8 ]]
 [[ signed char*->signed char ][ !!! *2* !!! ][ 87 ][ 10 ][ 7 ]]
 [[ signed char*->unsigned char ][ !!! *3* !!! ][ 87 ][ 9 ][ 13 ]]
 [[ signed char*->int ][ !!! *6* !!! ][ 104 ][ 20 ][ 14 ]]
 [[ signed char*->short ][ !!! *6* !!! ][ 105 ][ 21 ][ 14 ]]
 [[ signed char*->long int ][ !!! *6* !!! ][ 104 ][ 20 ][ 15 ]]
 [[ signed char*->long long ][ !!! *6* !!! ][ 106 ][ 20 ][ 14 ]]
 [[ signed char*->unsigned int ][ !!! *6* !!! ][ 99 ][ 20 ][ 14 ]]
 [[ signed char*->unsigned short ][ !!! *6* !!! ][ 100 ][ 18 ][ 14 ]]
 [[ signed char*->unsigned long int ][ !!! *6* !!! ][ 102 ][ 23 ][ 14 ]]
 [[ signed char*->unsigned long long ][ !!! *6* !!! ][ 103 ][ 20 ][ 14 ]]
 [[ signed char*->bool ][ !!! *3* !!! ][ 99 ][ 18 ][ 7 ]]
 [[ signed char*->float ][ !!! *18* !!! ][ 159 ][ 60 ][ 32 ]]
 [[ signed char*->double ][ !!! *18* !!! ][ 203 ][ 95 ][ 57 ]]
 [[ signed char*->long double ][ 129 ][ 213 ][ 97 ][ !!! *56* !!! ]]
 [[ signed char*->string ][ !!! *14* !!! ][ 105 ][ 22 ][ --- ]]
 [[ int->int ][ !!! *<1* !!! ][ 109 ][ 22 ][ --- ]]
 [[ float->double ][ !!! *<1* !!! ][ 226 ][ 104 ][ --- ]]
 [[ double->double ][ !!! *<1* !!! ][ 229 ][ 103 ][ --- ]]
 [[ int->int ][ !!! *<1* !!! ][ 225 ][ 115 ][ --- ]]
 [[ int->int ][ !!! *<1* !!! ][ 227 ][ 115 ][ --- ]]
 [[ char->unsigned char ][ !!! *<1* !!! ][ 90 ][ 8 ][ --- ]]
 [[ char->signed char ][ !!! *<1* !!! ][ 84 ][ 8 ][ --- ]]
 [[ unsigned char->char ][ !!! *<1* !!! ][ 88 ][ 8 ][ --- ]]
 [[ signed char->char ][ !!! *<1* !!! ][ 89 ][ 8 ][ --- ]]
 ]
 [endsect]
 [section gcc-4.6][table:id Performance Table (gcc-4.6)
 [[From->To] [lexical_cast] [std::stringstream with construction] [std::stringstream without construction][scanf/printf]]
 [[ string->char ][ !!! *<1* !!! ][ 94 ][ 8 ][ 7 ]]
 [[ string->signed char ][ !!! *<1* !!! ][ 96 ][ 9 ][ 7 ]]
 [[ string->unsigned char ][ !!! *<1* !!! ][ 96 ][ 8 ][ 13 ]]
 [[ string->int ][ !!! *3* !!! ][ 110 ][ 18 ][ 16 ]]
 [[ string->short ][ !!! *3* !!! ][ 111 ][ 18 ][ 16 ]]
 [[ string->long int ][ !!! *3* !!! ][ 109 ][ 18 ][ 15 ]]
 [[ string->long long ][ !!! *3* !!! ][ 111 ][ 18 ][ 15 ]]
 [[ string->unsigned int ][ !!! *3* !!! ][ 110 ][ 20 ][ 15 ]]
 [[ string->unsigned short ][ !!! *3* !!! ][ 111 ][ 18 ][ 15 ]]
 [[ string->unsigned long int ][ !!! *3* !!! ][ 109 ][ 18 ][ 15 ]]
 [[ string->unsigned long long ][ !!! *3* !!! ][ 114 ][ 19 ][ 15 ]]
 [[ string->bool ][ !!! *<1* !!! ][ 106 ][ 17 ][ 8 ]]
 [[ string->float ][ !!! *13* !!! ][ 175 ][ 70 ][ 33 ]]
 [[ string->double ][ !!! *14* !!! ][ 182 ][ 81 ][ 58 ]]
 [[ string->long double ][ 118 ][ 190 ][ 87 ][ !!! *58* !!! ]]
 [[ char->string ][ !!! *8* !!! ][ 118 ][ 21 ][ 12 ]]
 [[ unsigned char->string ][ !!! *8* !!! ][ 109 ][ 18 ][ 16 ]]
 [[ signed char->string ][ !!! *8* !!! ][ 108 ][ 18 ][ 12 ]]
 [[ int->string ][ 20 ][ 121 ][ 21 ][ !!! *16* !!! ]]
 [[ short->string ][ !!! *15* !!! ][ 120 ][ 22 ][ 17 ]]
 [[ long int->string ][ !!! *15* !!! ][ 120 ][ 22 ][ 16 ]]
 [[ long long->string ][ !!! *15* !!! ][ 120 ][ 22 ][ 17 ]]
 [[ unsigned int->string ][ !!! *15* !!! ][ 120 ][ 22 ][ 16 ]]
 [[ unsigned short->string ][ !!! *15* !!! ][ 120 ][ 22 ][ 18 ]]
 [[ unsigned long int->string ][ 16 ][ 118 ][ 22 ][ !!! *15* !!! ]]
 [[ unsigned long long->string ][ !!! *15* !!! ][ 117 ][ 21 ][ 17 ]]
 [[ bool->string ][ !!! *8* !!! ][ 117 ][ 23 ][ 10 ]]
 [[ float->string ][ 77 ][ 218 ][ 105 ][ !!! *50* !!! ]]
 [[ double->string ][ 108 ][ 247 ][ 129 ][ !!! *73* !!! ]]
 [[ long double->string ][ 120 ][ 250 ][ 131 ][ !!! *79* !!! ]]
 [[ char*->char ][ !!! *2* !!! ][ 99 ][ 9 ][ 7 ]]
 [[ char*->signed char ][ !!! *2* !!! ][ 98 ][ 9 ][ 8 ]]
 [[ char*->unsigned char ][ !!! *2* !!! ][ 98 ][ 9 ][ 13 ]]
 [[ char*->int ][ !!! *6* !!! ][ 115 ][ 22 ][ 15 ]]
 [[ char*->short ][ !!! *6* !!! ][ 114 ][ 22 ][ 15 ]]
 [[ char*->long int ][ !!! *6* !!! ][ 114 ][ 22 ][ 16 ]]
 [[ char*->long long ][ !!! *6* !!! ][ 119 ][ 22 ][ 15 ]]
 [[ char*->unsigned int ][ !!! *6* !!! ][ 114 ][ 20 ][ 15 ]]
 [[ char*->unsigned short ][ !!! *6* !!! ][ 116 ][ 20 ][ 15 ]]
 [[ char*->unsigned long int ][ !!! *6* !!! ][ 117 ][ 22 ][ 15 ]]
 [[ char*->unsigned long long ][ !!! *6* !!! ][ 118 ][ 22 ][ 15 ]]
 [[ char*->bool ][ !!! *3* !!! ][ 113 ][ 18 ][ 8 ]]
 [[ char*->float ][ !!! *15* !!! ][ 180 ][ 78 ][ 32 ]]
 [[ char*->double ][ !!! *16* !!! ][ 185 ][ 89 ][ 58 ]]
 [[ char*->long double ][ 119 ][ 193 ][ 91 ][ !!! *60* !!! ]]
 [[ unsigned char*->char ][ !!! *2* !!! ][ 99 ][ 9 ][ 8 ]]
 [[ unsigned char*->signed char ][ !!! *2* !!! ][ 99 ][ 10 ][ 8 ]]
 [[ unsigned char*->unsigned char ][ !!! *2* !!! ][ 100 ][ 9 ][ 15 ]]
 [[ unsigned char*->int ][ !!! *6* !!! ][ 118 ][ 22 ][ 15 ]]
 [[ unsigned char*->short ][ !!! *6* !!! ][ 117 ][ 26 ][ 15 ]]
 [[ unsigned char*->long int ][ !!! *6* !!! ][ 119 ][ 21 ][ 15 ]]
 [[ unsigned char*->long long ][ !!! *6* !!! ][ 118 ][ 21 ][ 14 ]]
 [[ unsigned char*->unsigned int ][ !!! *6* !!! ][ 115 ][ 22 ][ 14 ]]
 [[ unsigned char*->unsigned short ][ !!! *6* !!! ][ 117 ][ 20 ][ 15 ]]
 [[ unsigned char*->unsigned long int ][ !!! *6* !!! ][ 115 ][ 21 ][ 15 ]]
 [[ unsigned char*->unsigned long long ][ !!! *6* !!! ][ 117 ][ 22 ][ 15 ]]
 [[ unsigned char*->bool ][ !!! *3* !!! ][ 112 ][ 18 ][ 8 ]]
 [[ unsigned char*->float ][ !!! *15* !!! ][ 181 ][ 78 ][ 33 ]]
 [[ unsigned char*->double ][ !!! *16* !!! ][ 185 ][ 92 ][ 59 ]]
 [[ unsigned char*->long double ][ 120 ][ 190 ][ 89 ][ !!! *58* !!! ]]
 [[ unsigned char*->string ][ !!! *14* !!! ][ 121 ][ 22 ][ --- ]]
 [[ signed char*->char ][ !!! *2* !!! ][ 99 ][ 9 ][ 9 ]]
 [[ signed char*->signed char ][ !!! *2* !!! ][ 98 ][ 9 ][ 8 ]]
 [[ signed char*->unsigned char ][ !!! *2* !!! ][ 98 ][ 9 ][ 14 ]]
 [[ signed char*->int ][ !!! *6* !!! ][ 119 ][ 22 ][ 16 ]]
 [[ signed char*->short ][ !!! *6* !!! ][ 115 ][ 22 ][ 15 ]]
 [[ signed char*->long int ][ !!! *6* !!! ][ 119 ][ 22 ][ 15 ]]
 [[ signed char*->long long ][ !!! *6* !!! ][ 117 ][ 22 ][ 15 ]]
 [[ signed char*->unsigned int ][ !!! *6* !!! ][ 117 ][ 23 ][ 15 ]]
 [[ signed char*->unsigned short ][ !!! *6* !!! ][ 117 ][ 21 ][ 14 ]]
 [[ signed char*->unsigned long int ][ !!! *7* !!! ][ 119 ][ 24 ][ 15 ]]
 [[ signed char*->unsigned long long ][ !!! *6* !!! ][ 116 ][ 22 ][ 15 ]]
 [[ signed char*->bool ][ !!! *3* !!! ][ 111 ][ 18 ][ 8 ]]
 [[ signed char*->float ][ !!! *16* !!! ][ 180 ][ 78 ][ 33 ]]
 [[ signed char*->double ][ !!! *16* !!! ][ 185 ][ 89 ][ 59 ]]
 [[ signed char*->long double ][ 120 ][ 191 ][ 91 ][ !!! *59* !!! ]]
 [[ signed char*->string ][ !!! *14* !!! ][ 122 ][ 23 ][ --- ]]
 [[ int->int ][ !!! *<1* !!! ][ 120 ][ 22 ][ --- ]]
 [[ float->double ][ !!! *<1* !!! ][ 242 ][ 115 ][ --- ]]
 [[ double->double ][ !!! *<1* !!! ][ 243 ][ 115 ][ --- ]]
 [[ int->int ][ !!! *<1* !!! ][ 265 ][ 141 ][ --- ]]
 [[ int->int ][ !!! *<1* !!! ][ 266 ][ 140 ][ --- ]]
 [[ char->unsigned char ][ !!! *<1* !!! ][ 95 ][ 8 ][ --- ]]
 [[ char->signed char ][ !!! *<1* !!! ][ 95 ][ 8 ][ --- ]]
 [[ unsigned char->char ][ !!! *<1* !!! ][ 94 ][ 8 ][ --- ]]
 [[ signed char->char ][ !!! *<1* !!! ][ 94 ][ 8 ][ --- ]]
 ]
 [endsect]
 [/ END of section, generated by performance measuring program ]
 [endsect]
@@ -1,7 +1,6 @@
-//  boost polymorphic_cast.hpp header file  ----------------------------------------------//
+//  boost cast.hpp header file  ----------------------------------------------//
 //  (C) Copyright Kevlin Henney and Dave Abrahams 1999.
 //  (C) Copyright Boris Rasin 2014.
 //  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)
@@ -9,12 +8,7 @@
 //  See http://www.boost.org/libs/conversion for Documentation.
 //  Revision History
-//  10 Nov 14  polymorphic_pointer_downcast moved to a separate header,
+//  23 JUn 05  numeric_cast removed and redirected to the new verion (Fernando Cacciola)
 //             minor improvements to stisfy latest Boost coding style
 //  08 Nov 14  Add polymorphic_pointer_downcast (Boris Rasin)
 //  09 Jun 14  "cast.hpp" was renamed to "polymorphic_cast.hpp" and
 //             inclusion of numeric_cast was removed (Antony Polukhin)
 //  23 Jun 05  numeric_cast removed and redirected to the new version (Fernando Cacciola)
 //  02 Apr 01  Removed BOOST_NO_LIMITS workarounds and included
 //             <boost/limits.hpp> instead (the workaround did not
 //             actually compile when BOOST_NO_LIMITS was defined in
@@ -31,7 +25,7 @@
 //  19 Oct 00  Fix numeric_cast for floating-point types (Dave Abrahams)
 //  15 Jul 00  Suppress numeric_cast warnings for GCC, Borland and MSVC
 //             (Dave Abrahams)
-//  30 Jun 00  More MSVC6 workarounds.  See comments below.  (Dave Abrahams)
+//  30 Jun 00  More MSVC6 wordarounds.  See comments below.  (Dave Abrahams)
 //  28 Jun 00  Removed implicit_cast<>.  See comment below. (Beman Dawes)
 //  27 Jun 00  More MSVC6 workarounds
 //  15 Jun 00  Add workarounds for MSVC6
@@ -46,27 +40,26 @@
 //             place in nested namespace.
 //   3 Aug 99  Initial version
-#ifndef BOOST_POLYMORPHIC_CAST_HPP
+#ifndef BOOST_CAST_HPP
-#define BOOST_POLYMORPHIC_CAST_HPP
+#define BOOST_CAST_HPP
 #include <boost/config.hpp>
 #ifdef BOOST_HAS_PRAGMA_ONCE
 #   pragma once
 #endif
 # include <boost/config.hpp>
 # include <boost/assert.hpp>
 # include <boost/throw_exception.hpp>
 # include <memory>  // std::addressof
 # include <typeinfo>
-# include <type_traits>
+# include <boost/type.hpp>
 # include <boost/limits.hpp>
 # include <boost/detail/select_type.hpp>
-#if defined(__cpp_constexpr) && __cpp_constexpr >= 201907L
+//  It has been demonstrated numerous times that MSVC 6.0 fails silently at link
-#define BOOST_CONVERSION_IMPL_CONSTEXPR_DYN_CAST constexpr
+//  time if you use a template function which has template parameters that don't
-#else
+//  appear in the function's argument list.
-#define BOOST_CONVERSION_IMPL_CONSTEXPR_DYN_CAST inline
+//
-#endif
+//  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
 {
@@ -80,16 +73,16 @@ namespace boost
    //  section 15.8 exercise 1, page 425.
    template <class Target, class Source>
-    BOOST_CONVERSION_IMPL_CONSTEXPR_DYN_CAST Target polymorphic_cast(Source* x)
+    inline Target polymorphic_cast(Source* x BOOST_EXPLICIT_DEFAULT_TARGET)
    {
        Target tmp = dynamic_cast<Target>(x);
-        if ( tmp == 0 ) boost::throw_exception( std::bad_cast() );
+        if ( tmp == 0 ) throw std::bad_cast();
        return tmp;
    }
 //  polymorphic_downcast  ----------------------------------------------------//
-    //  BOOST_ASSERT() checked raw pointer polymorphic downcast.  Crosscasts prohibited.
+    //  BOOST_ASSERT() checked polymorphic downcast.  Crosscasts prohibited.
    //  WARNING: Because this cast uses BOOST_ASSERT(), it violates
    //  the One Definition Rule if used in multiple translation units
@@ -99,34 +92,16 @@ namespace boost
    //  Contributed by Dave Abrahams
    template <class Target, class Source>
-    BOOST_CONVERSION_IMPL_CONSTEXPR_DYN_CAST 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);
    }
-    //  BOOST_ASSERT() checked reference polymorphic downcast.  Crosscasts prohibited.
+#  undef BOOST_EXPLICIT_DEFAULT_TARGET
    //  WARNING: Because this cast uses BOOST_ASSERT(), it violates
    //  the One Definition Rule if used in multiple translation units
    //  where BOOST_DISABLE_ASSERTS, BOOST_ENABLE_ASSERT_HANDLER
    //  NDEBUG are defined inconsistently.
    //  Contributed by Julien Delacroix
    template <class Target, class Source>
    BOOST_CONVERSION_IMPL_CONSTEXPR_DYN_CAST typename std::enable_if<
        std::is_reference<Target>::value, Target
    >::type polymorphic_downcast(Source& x)
    {
        using target_pointer_type = typename std::remove_reference<Target>::type*;
        return *boost::polymorphic_downcast<target_pointer_type>(
            std::addressof(x)
        );
    }
 } // namespace boost
-#undef BOOST_CONVERSION_IMPL_CONSTEXPR_DYN_CAST
+# include <boost/numeric/conversion/cast.hpp>
-#endif  // BOOST_POLYMORPHIC_CAST_HPP
+#endif  // BOOST_CAST_HPP
@@ -0,0 +1,184 @@
 // Copyright Alexander Nasonov & Paul A. Bristow 2006.
 // Use, modification and distribution are subject to 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_LCAST_PRECISION_HPP_INCLUDED
 #define BOOST_DETAIL_LCAST_PRECISION_HPP_INCLUDED
 #include <climits>
 #include <ios>
 #include <limits>
 #include <boost/config.hpp>
 #include <boost/integer_traits.hpp>
 #ifndef BOOST_NO_IS_ABSTRACT
 // Fix for SF:1358600 - lexical_cast & pure virtual functions & VC 8 STL
 #include <boost/mpl/if.hpp>
 #include <boost/type_traits/is_abstract.hpp>
 #endif
 #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>
 #else
 #include <boost/static_assert.hpp>
 #endif
 namespace boost { namespace detail {
 class lcast_abstract_stub {};
 #ifndef BOOST_LCAST_NO_COMPILE_TIME_PRECISION
 // Calculate an argument to pass to std::ios_base::precision from
 // lexical_cast. See alternative implementation for broken standard
 // libraries in lcast_get_precision below. Keep them in sync, please.
 template<class T>
 struct lcast_precision
 {
 #ifdef BOOST_NO_IS_ABSTRACT
    typedef std::numeric_limits<T> limits; // No fix for SF:1358600.
 #else
    typedef BOOST_DEDUCED_TYPENAME boost::mpl::if_<
        boost::is_abstract<T>
      , std::numeric_limits<lcast_abstract_stub>
      , std::numeric_limits<T>
      >::type limits;
 #endif
    BOOST_STATIC_CONSTANT(bool, use_default_precision =
            !limits::is_specialized || limits::is_exact
        );
    BOOST_STATIC_CONSTANT(bool, is_specialized_bin =
            !use_default_precision &&
            limits::radix == 2 && limits::digits > 0
        );
    BOOST_STATIC_CONSTANT(bool, is_specialized_dec =
            !use_default_precision &&
            limits::radix == 10 && limits::digits10 > 0
        );
    BOOST_STATIC_CONSTANT(std::streamsize, streamsize_max =
            boost::integer_traits<std::streamsize>::const_max
        );
    BOOST_STATIC_CONSTANT(unsigned int, precision_dec = limits::digits10 + 1U);
    BOOST_STATIC_ASSERT(!is_specialized_dec ||
            precision_dec <= streamsize_max + 0UL
        );
    BOOST_STATIC_CONSTANT(unsigned long, precision_bin =
            2UL + limits::digits * 30103UL / 100000UL
        );
    BOOST_STATIC_ASSERT(!is_specialized_bin ||
            (limits::digits + 0UL < ULONG_MAX / 30103UL &&
            precision_bin > limits::digits10 + 0UL &&
            precision_bin <= streamsize_max + 0UL)
        );
    BOOST_STATIC_CONSTANT(std::streamsize, value =
            is_specialized_bin ? precision_bin
                               : is_specialized_dec ? precision_dec : 6
        );
 };
 #endif
 template<class T>
 inline std::streamsize lcast_get_precision(T* = 0)
 {
 #ifndef BOOST_LCAST_NO_COMPILE_TIME_PRECISION
    return lcast_precision<T>::value;
 #else // Follow lcast_precision algorithm at run-time:
 #ifdef BOOST_NO_IS_ABSTRACT
    typedef std::numeric_limits<T> limits; // No fix for SF:1358600.
 #else
    typedef BOOST_DEDUCED_TYPENAME boost::mpl::if_<
        boost::is_abstract<T>
      , std::numeric_limits<lcast_abstract_stub>
      , std::numeric_limits<T>
      >::type limits;
 #endif
    bool const use_default_precision =
        !limits::is_specialized || limits::is_exact;
    if(!use_default_precision)
    { // Includes all built-in floating-point types, float, double ...
      // and UDT types for which digits (significand bits) is defined (not zero)
        bool const is_specialized_bin =
            limits::radix == 2 && limits::digits > 0;
        bool const is_specialized_dec =
            limits::radix == 10 && limits::digits10 > 0;
        std::streamsize const streamsize_max =
            (boost::integer_traits<std::streamsize>::max)();
        if(is_specialized_bin)
        { // Floating-point types with
          // limits::digits defined by the specialization.
            unsigned long const digits = limits::digits;
            unsigned long const precision = 2UL + digits * 30103UL / 100000UL;
            // unsigned long is selected because it is at least 32-bits
            // and thus ULONG_MAX / 30103UL is big enough for all types.
            BOOST_ASSERT(
                    digits < ULONG_MAX / 30103UL &&
                    precision > limits::digits10 + 0UL &&
                    precision <= streamsize_max + 0UL
                );
            return precision;
        }
        else if(is_specialized_dec)
        {   // Decimal Floating-point type, most likely a User Defined Type
            // rather than a real floating-point hardware type.
            unsigned int const precision = limits::digits10 + 1U;
            BOOST_ASSERT(precision <= streamsize_max + 0UL);
            return precision;
        }
    }
    // Integral type (for which precision has no effect)
    // or type T for which limits is NOT specialized,
    // so assume stream precision remains the default 6 decimal digits.
    // Warning: if your User-defined Floating-point type T is NOT specialized,
    // then you may lose accuracy by only using 6 decimal digits.
    // To avoid this, you need to specialize T with either
    // radix == 2 and digits == the number of significand bits,
    // OR
    // radix = 10 and digits10 == the number of decimal digits.
    return 6;
 #endif
 }
 template<class T>
 inline void lcast_set_precision(std::ios_base& stream, T*)
 {
    stream.precision(lcast_get_precision<T>());
 }
 template<class Source, class Target>
 inline void lcast_set_precision(std::ios_base& stream, Source*, Target*)
 {
    std::streamsize const s = lcast_get_precision(static_cast<Source*>(0));
    std::streamsize const t = lcast_get_precision(static_cast<Target*>(0));
    stream.precision(s > t ? s : t);
 }
 }}
 #endif //  BOOST_DETAIL_LCAST_PRECISION_HPP_INCLUDED
@@ -2,37 +2,28 @@
 // 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 IMPLICIT_CAST_DWA200356_HPP
 # define IMPLICIT_CAST_DWA200356_HPP
-#ifndef BOOST_IMPLICIT_CAST_DWA200356_HPP
+# include <boost/mpl/identity.hpp>
 #define BOOST_IMPLICIT_CAST_DWA200356_HPP
 #include <boost/config.hpp>
 #ifdef BOOST_HAS_PRAGMA_ONCE
 # pragma once
 #endif
 namespace boost {
 namespace detail {
 template<class T> struct icast_identity
 {
    using type = T;
 };
 } // namespace detail
 // implementation originally suggested by C. Green in
 // http://lists.boost.org/MailArchives/boost/msg00886.php
 // The use of identity creates a non-deduced form, so that the
 // explicit template argument must be supplied
 template <typename T>
-constexpr T implicit_cast (typename boost::detail::icast_identity<T>::type x) {
+inline T implicit_cast (typename mpl::identity<T>::type x) {
    return x;
 }
 // incomplete return type now is here
 //template <typename T>
 //void implicit_cast (...);
 } // namespace boost
-#endif // BOOST_IMPLICIT_CAST_DWA200356_HPP
+#endif // IMPLICIT_CAST_DWA200356_HPP
@@ -1,60 +0,0 @@
 //  boost polymorphic_pointer_cast.hpp header file  ----------------------------------------------//
 //  (C) Copyright Boris Rasin, 2014-2021.
 //  (C) Copyright Antony Polukhin, 2014-2026.
 //  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)
 //  See http://www.boost.org/libs/conversion for Documentation.
 #ifndef BOOST_CONVERSION_POLYMORPHIC_POINTER_CAST_HPP
 #define BOOST_CONVERSION_POLYMORPHIC_POINTER_CAST_HPP
 #include <boost/config.hpp>
 #ifdef BOOST_HAS_PRAGMA_ONCE
 #   pragma once
 #endif
 # include <boost/assert.hpp>
 # include <boost/pointer_cast.hpp>
 # include <boost/throw_exception.hpp>
 namespace boost
 {
 //  See the documentation for descriptions of how to choose between
 //  static_pointer_cast<>, dynamic_pointer_cast<>, polymorphic_pointer_cast<> and polymorphic_pointer_downcast<>
 //  polymorphic_pointer_downcast  --------------------------------------------//
    //  BOOST_ASSERT() checked polymorphic downcast.  Crosscasts prohibited.
    //  Supports any type with static_pointer_cast/dynamic_pointer_cast functions:
    //  built-in pointers, std::shared_ptr, boost::shared_ptr, boost::intrusive_ptr, etc.
    //  WARNING: Because this cast uses BOOST_ASSERT(), it violates
    //  the One Definition Rule if used in multiple translation units
    //  where BOOST_DISABLE_ASSERTS, BOOST_ENABLE_ASSERT_HANDLER
    //  NDEBUG are defined inconsistently.
    //  Contributed by Boris Rasin
    template <typename Target, typename Source>
    inline auto polymorphic_pointer_downcast (const Source& x)
        -> decltype(static_pointer_cast<Target>(x))
    {
        BOOST_ASSERT(dynamic_pointer_cast<Target> (x) == x);
        return static_pointer_cast<Target> (x);
    }
    template <typename Target, typename Source>
    inline auto polymorphic_pointer_cast (const Source& x)
        -> decltype(dynamic_pointer_cast<Target>(x))
    {
        auto tmp = dynamic_pointer_cast<Target> (x);
        if ( !tmp ) boost::throw_exception( std::bad_cast() );
        return tmp;
    }
 } // namespace boost
 #endif  // BOOST_CONVERSION_POLYMORPHIC_POINTER_CAST_HPP
@@ -1,39 +1,38 @@
 <!DOCTYPE html>
 <!--
 Copyright (c) 2016 Mikhail Maximov
 vigorous.activity at gmail dot com
 Copyright (c) Antony Polukhin, 2021-2026
 Distributed under the Boost Software License,
 Version 1.0. (See accompanying file LICENSE_1_0.txt
 or copy at http://boost.org/LICENSE_1_0.txt)
 boost-no-inspect
 -->
 <html>
 <head>
-<meta charset="utf-8">
+<meta http-equiv="Content-Language" content="en-us">
-<meta http-equiv="refresh" content="0; url=../../doc/html/conversion.html">
+<meta http-equiv="Content-Type" content="text/html; charset=windows-1252">
-<title>Boost.Conversion</title>
+<meta name="GENERATOR" content="Microsoft FrontPage 5.0">
-<style>
+<meta name="ProgId" content="FrontPage.Editor.Document">
-  body {
+<title>Boost Conversion Library</title>
    background: #fff;
    color: #000;
  }
  a {
    color: #00f;
    text-decoration: none;
  }
 </style>
 </head>
-<body>
+
-  <p>
+<body bgcolor="#FFFFFF" text="#000000">
-    Automatic redirection failed, please go to
+
-    <a href="../../doc/html/conversion.html">../../doc/html/conversion.html</a>
+<h1><img border="0" src="../../boost.png" align="center" width="277" height="86">Boost
-  </p>
+Conversion Library</h1>
-  <p>
+
-    &copy; Antony Polukhin, 2014-2024
+<p>The Conversion Library improves program safety and clarity by performing
-  </p>
+otherwise messy conversions.&nbsp; It includes cast-style function templates designed to complement the C++
 Standard's built-in casts.</p>
 <p>To reduce coupling, particularly to standard library IOStreams, the Boost
 Conversion Library is
 supplied by several headers:</p>
 <ul>
  <li>The <a href="cast.htm">boost/cast</a> header provides <b>polymorphic_cast&lt;&gt;</b>
    and <b>polymorphic_downcast&lt;&gt;</b> to perform safe casting between
  polymorphic types.<br>
  </li>
  <li>The <a href="../../doc/html/boost_lexical_cast.html">boost/lexical_cast</a> header provides <b>lexical_cast&lt;&gt;</b>
    general literal text conversions, such as an <code>int</code> represented as
    a <code>string</code>, or vice-versa.</li>
 </ul>
 <hr>
 <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>
 </body>
-</html>
+
 </html>
@@ -0,0 +1,16 @@
 <!--
 Copyright 2005-2007 Daniel James.
 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)
 -->
 <html>
 <head>
    <meta http-equiv="refresh" content="0; URL=../../doc/html/boost_lexical_cast.html">
 </head>
 <body>
 Automatic redirection failed, please go to
 <a href="../../doc/html/boost_lexical_cast.html">../../doc/html/boost_lexical_cast.html</a>
 </body>
 </html>
@@ -1,16 +0,0 @@
 {
    "key": "conversion",
    "name": "Conversion",
    "authors": [
        "Dave Abrahams",
        "Kevlin Henney"
    ],
    "description": "Polymorphic casts.",
    "category": [
        "Miscellaneous"
    ],
    "maintainers": [
        "Antony Polukhin <antoshkka -at- gmail.com>"
    ],
    "cxxstd": "11"
 }
@@ -0,0 +1,100 @@
 //  boost utility cast test program  -----------------------------------------//
 //  (C) Copyright Beman Dawes, Dave Abrahams 1999. 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)
 //  See http://www.boost.org for most recent version including documentation.
 //  Revision History
 //   28 Set 04  factored out numeric_cast<> test (Fernando Cacciola)
 //   20 Jan 01  removed use of <limits> for portability to raw GCC (David Abrahams)
 //   28 Jun 00  implicit_cast removed (Beman Dawes)
 //   30 Aug 99  value_cast replaced by numeric_cast
 //    3 Aug 99  Initial Version
 #include <iostream>
 #include <climits>
 #include <cfloat>   // for DBL_MAX (Peter Schmid)
 #include <boost/cast.hpp>
 #include "boost/test/minimal.hpp"
 #  if SCHAR_MAX == LONG_MAX
 #      error "This test program doesn't work if SCHAR_MAX == LONG_MAX"
 #  endif
 using namespace boost;
 using std::cout;
 int test_main( int argc, char * argv[] )
 {
 #   ifdef NDEBUG
        cout << "NDEBUG is defined\n";
 #   else
        cout << "NDEBUG is not defined\n";
 #   endif
    cout << "\nBeginning tests...\n";
 //  test implicit_cast and numeric_cast  -------------------------------------//
    //  tests which should succeed
    long small_value = 1;
    long small_negative_value = -1;
    long large_value = LONG_MAX;
    long large_negative_value = LONG_MIN;
    signed char c = 0;
    c = large_value;  // see if compiler generates warning
    c = numeric_cast<signed char>( small_value );
    BOOST_CHECK( c == 1 );
    c = 0;
    c = numeric_cast<signed char>( small_value );
    BOOST_CHECK( c == 1 );
    c = 0;
    c = numeric_cast<signed char>( small_negative_value );
    BOOST_CHECK( c == -1 );
    // These tests courtesy of Joe R NWP Swatosh<joe.r.swatosh@usace.army.mil>
    BOOST_CHECK( 0.0f == numeric_cast<float>( 0.0 ) );
    BOOST_CHECK( 0.0 == numeric_cast<double>( 0.0 ) );
    //  tests which should result in errors being detected
    bool caught_exception = false;
    try { c = numeric_cast<signed char>( large_value ); }
    catch (bad_numeric_cast)
        { cout<<"caught bad_numeric_cast #1\n"; caught_exception = true; }
    BOOST_CHECK ( caught_exception );
    caught_exception = false;
    try { c = numeric_cast<signed char>( large_negative_value ); }
    catch (bad_numeric_cast)
        { cout<<"caught bad_numeric_cast #2\n"; caught_exception = true; }
    BOOST_CHECK ( caught_exception );
    unsigned long ul;
    caught_exception = false;
    try { ul = numeric_cast<unsigned long>( large_negative_value ); }
    catch (bad_numeric_cast)
        { cout<<"caught bad_numeric_cast #3\n"; caught_exception = true; }
    BOOST_CHECK ( caught_exception );
    caught_exception = false;
    try { ul = numeric_cast<unsigned long>( small_negative_value ); }
    catch (bad_numeric_cast)
        { cout<<"caught bad_numeric_cast #4\n"; caught_exception = true; }
    BOOST_CHECK ( caught_exception );
    caught_exception = false;
    try { numeric_cast<int>( DBL_MAX ); }
    catch (bad_numeric_cast)
        { cout<<"caught bad_numeric_cast #5\n"; caught_exception = true; }
    BOOST_CHECK ( caught_exception );
    return 0 ;
 }
@@ -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,17 +0,0 @@
 # Copyright  (c) 2016-2026 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
 include(BoostTest OPTIONAL RESULT_VARIABLE HAVE_BOOST_TEST)
 if(NOT HAVE_BOOST_TEST)
  return()
 endif()
 set(BOOST_TEST_LINK_LIBRARIES Boost::conversion Boost::core)
 boost_test(TYPE run SOURCES cast_test.cpp)
 boost_test(TYPE run SOURCES implicit_cast.cpp)
 boost_test(TYPE compile-fail SOURCES implicit_cast_fail.cpp)
 boost_test(TYPE compile-fail SOURCES implicit_cast_fail2.cpp)
 boost_test(TYPE run SOURCES polymorphic_cast_test.cpp LINK_LIBRARIES Boost::smart_ptr)
@@ -1,31 +1,34 @@
 # Signals library
 # Copyright (C) 2001-2003 Douglas Gregor
 # Copyright (C) Antony Polukhin, 2011-2024
 #
 # 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)
 #
-require-b2 5.0.1 ;
+# Permission to copy, use, sell and distribute this software is granted 
-import-search /boost/config/checks ;
+# provided this copyright notice appears in all copies. Permission to modify 
-import config : requires ;
+# the code and to distribute modified code is granted provided this copyright 
 # notice appears in all copies, and a notice that the code was modified is 
 # included with the copyright notice. This software is provided "as is" 
 # without express or implied warranty, and with no claim as to its suitability 
 # for any purpose. 
 # For more information, see http://www.boost.org/
 # bring in rules for testing
 import testing ;
 import feature ;
 project
    : requirements
        <library>/boost/conversion//boost_conversion
        [ requires cxx11_decltype ]
        # 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
    ;
 test-suite conversion
  : [ run implicit_cast.cpp ]
    [ compile-fail implicit_cast_fail.cpp ]
-    [ run cast_test.cpp ]
+    [ run ../cast_test.cpp ]
-    [ run polymorphic_cast_test.cpp : : : <library>/boost/smart_ptr//boost_smart_ptr ]
+    [ run ../numeric_cast_test.cpp ]    
-    [ compile-fail implicit_cast_fail2.cpp ]
+    [ run ../lexical_cast_test.cpp ../../test/build//boost_unit_test_framework/<link>static ]
    [ run lexical_cast_loopback_test.cpp ../../test/build//boost_unit_test_framework/<link>static ]
    [ run lexical_cast_abstract_test.cpp ../../test/build//boost_unit_test_framework/<link>static ]
    [ run lexical_cast_noncopyable_test.cpp ../../test/build//boost_unit_test_framework/<link>static ]
    [ run lexical_cast_vc8_bug_test.cpp ../../test/build//boost_unit_test_framework/<link>static ]
    [ run lexical_cast_wchars_test.cpp ../../test/build//boost_unit_test_framework/<link>static ]
    [ run lexical_cast_float_types_test.cpp ../../test/build//boost_unit_test_framework/<link>static ]
    [ run lexical_cast_inf_nan_test.cpp ../../test/build//boost_unit_test_framework/<link>static ]
    [ run lexical_cast_empty_input_test.cpp ../../test/build//boost_unit_test_framework/<link>static ]
  ;
@@ -1,87 +0,0 @@
 # Use, modification, and distribution are
 # subject to 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)
 #
 # Copyright Antony Polukhin, 2016-2025.
 #
 # See https://svn.boost.org/trac/boost/wiki/TravisCoverals for description of this file
 # and how it can be used with Boost libraries.
 #
 # File revision #6
 init:
    # boost-local/libs/ folder to put this library into. This may be useful, if you're for example running Travis
    # from `Boost.DLL` repo while Boost already has `dll` and with to replace `dll` with content of`Boost.DLL`.
    #
    # Otherwise just leave the default value - set BOOST_LIBS_FOLDER=%APPVEYOR_PROJECT_NAME%
    - set BOOST_LIBS_FOLDER=%APPVEYOR_PROJECT_NAME%
 ###############################################################################################################
 # From this point and below code is same for all the Boost libs
 ###############################################################################################################
 version: 1.84.{build}-{branch}
 # branches to build
 branches:
  except:
    - gh-pages
 skip_tags: true
 environment:
  matrix:
    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
      TOOLSET: msvc-14.1,clang-win
      CXXSTD: 14,17
      ADDRMD: 32,64
    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
      ADDPATH: C:\cygwin\bin;
      TOOLSET: gcc
      CXXSTD: 03,11,14,1z
    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
      ADDPATH: C:\cygwin64\bin;
      TOOLSET: gcc
      CXXSTD: 03,11,14,1z
    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
      ADDPATH: C:\mingw\bin;
      TOOLSET: gcc
      CXXSTD: 03,11,14,1z
    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
      ADDPATH: C:\mingw-w64\x86_64-7.2.0-posix-seh-rt_v5-rev1\mingw64\bin;
      TOOLSET: gcc
      CXXSTD: 03,11,14,1z
 before_build:
    - set BOOST_BRANCH=develop
    - if "%APPVEYOR_REPO_BRANCH%" == "master" set BOOST_BRANCH=master
    - echo "Testing %APPVEYOR_PROJECT_NAME%"
    # Cloning Boost libraries (fast nondeep cloning)
    - set BOOST=C:/boost-local
    - git clone -b %BOOST_BRANCH% --depth 10 https://github.com/boostorg/boost.git %BOOST%
    - cd %BOOST%
    - git submodule update --init --depth 10 tools/build tools/boostdep
    - rm -rf %BOOST%/libs/%BOOST_LIBS_FOLDER%
    - mv -f %APPVEYOR_BUILD_FOLDER% %BOOST%/libs/%BOOST_LIBS_FOLDER%
    - python tools/boostdep/depinst/depinst.py --git_args "--depth 10 --jobs 2" %BOOST_LIBS_FOLDER%
 build_script:
    - cmd /c bootstrap
    - b2.exe headers
    - cd %BOOST%/libs/%BOOST_LIBS_FOLDER%/test
 after_build:
 before_test:
 test_script:
  - PATH=%ADDPATH%%PATH%
  - if not "%CXXSTD%" == "" set CXXSTD=cxxstd=%CXXSTD%
  - if not "%ADDRMD%" == "" set ADDRMD=address-model=%ADDRMD%
  - echo "Running command ..\..\..\b2 -j3 toolset=%TOOLSET% %CXXSTD% %ADDRMD% variant=debug,release"
  - ..\..\..\b2.exe -j3 toolset=%TOOLSET% %CXXSTD% %ADDRMD% variant=debug,release cxxflags="-DBOOST_TRAVISCI_BUILD"
 after_test:
 on_success:
 on_failure:
 on_finish:
@@ -4,9 +4,8 @@
 // http://www.boost.org/LICENSE_1_0.txt)
 #include <boost/implicit_cast.hpp>
-#include <boost/core/lightweight_test.hpp>
+#include <boost/detail/lightweight_test.hpp>
 #include <boost/type.hpp>
 using boost::implicit_cast;
 using boost::type;
@@ -19,8 +18,8 @@ struct foo
    operator long() const { return 0; }
 };
-using long_type = type<long>;
+typedef type<long> long_type;
-using foo_type = type<foo>;
+typedef type<foo> foo_type;
 int main()
 {
@@ -29,15 +28,5 @@ int main()
    type<foo> f = check_return(boost::implicit_cast<foo>("hello"));
    type<long> z = check_return(boost::implicit_cast<long>(foo("hello")));
    // warning suppression:
    (void)x;
    (void)f;
    (void)z;
    constexpr long value = boost::implicit_cast<long>(42);
    BOOST_TEST(value == 42L);
    return boost::report_errors();
 }
@@ -4,6 +4,10 @@
 // http://www.boost.org/LICENSE_1_0.txt)
 #include <boost/implicit_cast.hpp>
 #include <boost/type.hpp>
 #define BOOST_INCLUDE_MAIN
 #include <boost/test/test_tools.hpp>
 using boost::implicit_cast;
@@ -12,9 +16,7 @@ struct foo
    explicit foo(char const*) {}
 };
-int main()
+int test_main(int, char*[])
 {
    foo x = implicit_cast<foo>("foobar");
    (void)x;            // warning suppression.
    return 0;
 }
@@ -1,19 +0,0 @@
 //
 // Test that implicit_cast requires a template argument
 //
 // Copyright 2014 Peter Dimov
 //
 // 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
 //
 #include <boost/implicit_cast.hpp>
 int main()
 {
    int x = boost::implicit_cast( 1 );
    (void)x;
    return 0;
 }
@@ -0,0 +1,61 @@
 //  Unit test for boost::lexical_cast.
 //
 //  See http://www.boost.org for most recent version, including documentation.
 //
 //  Copyright Sergey Shandar 2005, Alexander Nasonov, 2007.
 //
 //  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).
 //
 // Test abstract class. Bug 1358600:
 // http://sf.net/tracker/?func=detail&aid=1358600&group_id=7586&atid=107586
 #include <boost/config.hpp>
 #if defined(__INTEL_COMPILER)
 #pragma warning(disable: 193 383 488 981 1418 1419)
 #elif defined(BOOST_MSVC)
 #pragma warning(disable: 4097 4100 4121 4127 4146 4244 4245 4511 4512 4701 4800)
 #endif
 #include <boost/lexical_cast.hpp>
 #include <boost/test/unit_test.hpp>
 using namespace boost;
 void test_abstract();
 unit_test::test_suite *init_unit_test_suite(int, char *[])
 {
    unit_test_framework::test_suite *suite =
        BOOST_TEST_SUITE("lexical_cast unit test");
    suite->add(BOOST_TEST_CASE(&test_abstract));
    return suite;
 }
 class A
 {
 public:
    virtual void out(std::ostream &) const = 0;
 };
 class B: public A
 {
 public:
    virtual void out(std::ostream &O) const { O << "B"; }
 };
 std::ostream &operator<<(std::ostream &O, const A &a)
 {
    a.out(O);
    return O;
 }
 void test_abstract()
 {
    const A &a = B();
    BOOST_CHECK(boost::lexical_cast<std::string>(a) == "B");
 }
@@ -0,0 +1,58 @@
 //  Unit test for boost::lexical_cast.
 //
 //  See http://www.boost.org for most recent version, including documentation.
 //
 //  Copyright Antony Polukhin, 2011.
 //
 //  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).
 #include <boost/config.hpp>
 #if defined(__INTEL_COMPILER)
 #pragma warning(disable: 193 383 488 981 1418 1419)
 #elif defined(BOOST_MSVC)
 #pragma warning(disable: 4097 4100 4121 4127 4146 4244 4245 4511 4512 4701 4800)
 #endif
 #include <boost/lexical_cast.hpp>
 #include <boost/test/unit_test.hpp>
 #include <boost/range/iterator_range.hpp>
 using namespace boost;
 void test_empty_iterator_range()
 {
 		boost::iterator_range<const char*> v;
    BOOST_CHECK_THROW(lexical_cast<int>(v), bad_lexical_cast);
    BOOST_CHECK_THROW(lexical_cast<float>(v), bad_lexical_cast);
    BOOST_CHECK_THROW(lexical_cast<double>(v), bad_lexical_cast);
    BOOST_CHECK_THROW(lexical_cast<long double>(v), bad_lexical_cast);
    BOOST_CHECK_THROW(lexical_cast<unsigned int>(v), bad_lexical_cast);
    BOOST_CHECK_THROW(lexical_cast<std::string>(v), bad_lexical_cast);
    BOOST_CHECK_THROW(lexical_cast<unsigned short>(v), bad_lexical_cast);
    BOOST_CHECK_THROW(lexical_cast<char>(v), bad_lexical_cast);
 }
 void test_empty_string()
 {
    BOOST_CHECK_THROW(lexical_cast<int>(std::string()), bad_lexical_cast);
    BOOST_CHECK_THROW(lexical_cast<float>(std::string()), bad_lexical_cast);
    BOOST_CHECK_THROW(lexical_cast<double>(std::string()), bad_lexical_cast);
    BOOST_CHECK_THROW(lexical_cast<long double>(std::string()), bad_lexical_cast);
    BOOST_CHECK_THROW(lexical_cast<unsigned int>(std::string()), bad_lexical_cast);
    BOOST_CHECK_EQUAL(lexical_cast<std::string>(std::string()), std::string());
    BOOST_CHECK_THROW(lexical_cast<unsigned short>(std::string()), bad_lexical_cast);
    BOOST_CHECK_THROW(lexical_cast<char>(std::string()), bad_lexical_cast);
 }
 unit_test::test_suite *init_unit_test_suite(int, char *[])
 {
    unit_test_framework::test_suite *suite =
        BOOST_TEST_SUITE("lexical_cast. Empty input unit test");
    suite->add(BOOST_TEST_CASE(&test_empty_iterator_range));
    suite->add(BOOST_TEST_CASE(&test_empty_string));
    return suite;
 }
@@ -0,0 +1,513 @@
 //  Unit test for boost::lexical_cast.
 //
 //  See http://www.boost.org for most recent version, including documentation.
 //
 //  Copyright Antony Polukhin, 2011.
 //
 //  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).
 #include <boost/config.hpp>
 #if defined(__INTEL_COMPILER)
 #pragma warning(disable: 193 383 488 981 1418 1419)
 #elif defined(BOOST_MSVC)
 #pragma warning(disable: 4097 4100 4121 4127 4146 4244 4245 4511 4512 4701 4800)
 #endif
 #include <boost/lexical_cast.hpp>
 #include <boost/cstdint.hpp>
 #include <boost/test/unit_test.hpp>
 #include <boost/test/floating_point_comparison.hpp>
 void test_conversion_from_to_float();
 void test_conversion_from_to_double();
 void test_conversion_from_to_long_double();
 using namespace boost;
 unit_test::test_suite *init_unit_test_suite(int, char *[])
 {
    unit_test_framework::test_suite *suite =
        BOOST_TEST_SUITE("lexical_cast float types unit test");
    suite->add(BOOST_TEST_CASE(&test_conversion_from_to_float));
    suite->add(BOOST_TEST_CASE(&test_conversion_from_to_double));
    suite->add(BOOST_TEST_CASE(&test_conversion_from_to_long_double));
    return suite;
 }
 // Replace "-,999" with "-999".
 template<class CharT>
 std::basic_string<CharT> to_str_gcc_workaround(std::basic_string<CharT> str)
 {
    std::locale loc;
    std::numpunct<CharT> const& np = BOOST_USE_FACET(std::numpunct<CharT>, loc);
    std::ctype<CharT> const& ct = BOOST_USE_FACET(std::ctype<CharT>, loc);
    if(np.grouping().empty())
        return str;
    CharT prefix[3] = { ct.widen('-'), np.thousands_sep(), CharT() };
    if(str.find(prefix) != 0)
        return str;
    prefix[1] = CharT();
    str.replace(0, 2, prefix);
    return str;
 }
 template<class CharT, class T>
 std::basic_string<CharT> to_str(T t)
 {
    std::basic_ostringstream<CharT> o;
    o << t;
    return to_str_gcc_workaround(o.str());
 }
 template<class T>
 void test_conversion_from_to_float_for_locale()
 {
    std::locale current_locale;
    typedef std::numpunct<char> numpunct;
    numpunct const& np = BOOST_USE_FACET(numpunct, current_locale);
    if ( !np.grouping().empty() )
    {
        BOOST_CHECK_THROW(
                lexical_cast<T>( std::string("100") + np.thousands_sep() + np.thousands_sep() + "0" )
                , bad_lexical_cast);
        BOOST_CHECK_THROW(lexical_cast<T>( std::string("100") + np.thousands_sep() ), bad_lexical_cast);
        BOOST_CHECK_THROW(lexical_cast<T>( np.thousands_sep() + std::string("100") ), bad_lexical_cast);
        BOOST_CHECK_THROW(lexical_cast<T>( std::string("1") + np.thousands_sep() + np.decimal_point() + "e10" ), bad_lexical_cast);
        BOOST_CHECK_THROW(lexical_cast<T>( std::string("1e10") + np.thousands_sep() ), bad_lexical_cast);
        BOOST_CHECK_THROW(lexical_cast<T>( std::string("1") + np.thousands_sep() + "e10" ), bad_lexical_cast);
        BOOST_CHECK_CLOSE_FRACTION(lexical_cast<T>( to_str< char >(100000) ), 100000, (std::numeric_limits<T>::epsilon()) );
        BOOST_CHECK_CLOSE_FRACTION(lexical_cast<T>( to_str< char >(10000000u) ), 10000000u, (std::numeric_limits<T>::epsilon()) );
        BOOST_CHECK_CLOSE_FRACTION(lexical_cast<T>( to_str< char >(100) ), 100, (std::numeric_limits<T>::epsilon()) );
 #if !defined(BOOST_LCAST_NO_WCHAR_T) && !defined(BOOST_NO_INTRINSIC_WCHAR_T)
        BOOST_CHECK_CLOSE_FRACTION(lexical_cast<T>( to_str< wchar_t >(100000) ), 100000, (std::numeric_limits<T>::epsilon()) );
        BOOST_CHECK_CLOSE_FRACTION(lexical_cast<T>( to_str< wchar_t >(10000000u) ), 10000000u, (std::numeric_limits<T>::epsilon()) );
        BOOST_CHECK_CLOSE_FRACTION(lexical_cast<T>( to_str< wchar_t >(100) ), 100, (std::numeric_limits<T>::epsilon()) );
 #endif
        // Exception must not be thrown, when we are using no separators at all
        BOOST_CHECK_CLOSE_FRACTION( lexical_cast<T>("30000"), static_cast<T>(30000), (std::numeric_limits<T>::epsilon()) );
    }
 }
 /*
 * Converts char* [and wchar_t] to float number type and checks, that generated
 * number is in interval [base_value-epsilon, base_value+epsilon].
 */
 #ifndef BOOST_LCAST_NO_WCHAR_T
 #define CHECK_CLOSE_ABS_DIFF(VAL,PREFIX)                                                          \
    converted_val = lexical_cast<test_t>(#VAL);                                                   \
    BOOST_CHECK_CLOSE_FRACTION( (VAL ## L? VAL ## L : std::numeric_limits<test_t>::epsilon()),             \
                       (converted_val ? converted_val : std::numeric_limits<test_t>::epsilon()),  \
                       std::numeric_limits<test_t>::epsilon()                                     \
                     );                                                                           \
    BOOST_CHECK_EQUAL(converted_val, lexical_cast<test_t>(L## #VAL) );
 #else
 #define CHECK_CLOSE_ABS_DIFF(VAL,TYPE)                                                            \
    converted_val = lexical_cast<test_t>(#VAL);                                                   \
    BOOST_CHECK_CLOSE_FRACTION( (VAL ## L? VAL ## L : std::numeric_limits<test_t>::epsilon()),             \
                       (converted_val ? converted_val : std::numeric_limits<test_t>::epsilon()),  \
                       std::numeric_limits<test_t>::epsilon()                                     \
                     );
 #endif
 template <class TestType>
 void test_converion_to_float_types()
 {
    typedef TestType test_t;
    test_t converted_val;
    BOOST_CHECK_CLOSE_FRACTION(1.0, lexical_cast<test_t>('1'), (std::numeric_limits<test_t>::epsilon()));
    BOOST_CHECK_EQUAL(0.0, lexical_cast<test_t>('0'));
    unsigned char const uc_one = '1';
    unsigned char const uc_zero ='0';
    BOOST_CHECK_CLOSE_FRACTION(1.0, lexical_cast<test_t>(uc_one), (std::numeric_limits<test_t>::epsilon()));
    BOOST_CHECK_EQUAL(0.0, lexical_cast<test_t>(uc_zero));
    signed char const sc_one = '1';
    signed char const sc_zero ='0';
    BOOST_CHECK_CLOSE_FRACTION(1.0, lexical_cast<test_t>(sc_one), (std::numeric_limits<test_t>::epsilon()));
    BOOST_CHECK_EQUAL(0.0, lexical_cast<test_t>(sc_zero));
    BOOST_CHECK_CLOSE_FRACTION(1e34L, lexical_cast<test_t>( "10000000000000000000000000000000000"), (std::numeric_limits<test_t>::epsilon()) );
 //    VC failes the next test
 //    BOOST_CHECK_CLOSE_FRACTION(1e-35L, lexical_cast<test_t>("0.00000000000000000000000000000000001"), (std::numeric_limits<test_t>::epsilon()) );
    BOOST_CHECK_CLOSE_FRACTION(
                                    0.1111111111111111111111111111111111111111111111111111111111111111111111111L
            , lexical_cast<test_t>("0.1111111111111111111111111111111111111111111111111111111111111111111111111")
            , (std::numeric_limits<test_t>::epsilon()) );
    CHECK_CLOSE_ABS_DIFF(1,test_t);
    BOOST_CHECK_EQUAL(0,lexical_cast<test_t>("0"));
    CHECK_CLOSE_ABS_DIFF(-1,test_t);
    CHECK_CLOSE_ABS_DIFF(1.0, test_t);
    CHECK_CLOSE_ABS_DIFF(0.0, test_t);
    CHECK_CLOSE_ABS_DIFF(-1.0,test_t);
    CHECK_CLOSE_ABS_DIFF(1e1, test_t);
    CHECK_CLOSE_ABS_DIFF(0e1, test_t);
    CHECK_CLOSE_ABS_DIFF(-1e1,test_t);
    CHECK_CLOSE_ABS_DIFF(1.0e1, test_t);
    CHECK_CLOSE_ABS_DIFF(0.0e1, test_t);
    CHECK_CLOSE_ABS_DIFF(-1.0e1,test_t);
    CHECK_CLOSE_ABS_DIFF(1e-1, test_t);
    CHECK_CLOSE_ABS_DIFF(0e-1, test_t);
    CHECK_CLOSE_ABS_DIFF(-1e-1,test_t);
    CHECK_CLOSE_ABS_DIFF(1.0e-1, test_t);
    CHECK_CLOSE_ABS_DIFF(0.0e-1, test_t);
    CHECK_CLOSE_ABS_DIFF(-1.0e-1,test_t);
    CHECK_CLOSE_ABS_DIFF(1E1, test_t);
    CHECK_CLOSE_ABS_DIFF(0E1, test_t);
    CHECK_CLOSE_ABS_DIFF(-1E1,test_t);
    CHECK_CLOSE_ABS_DIFF(1.0E1, test_t);
    CHECK_CLOSE_ABS_DIFF(0.0E1, test_t);
    CHECK_CLOSE_ABS_DIFF(-1.0E1,test_t);
    CHECK_CLOSE_ABS_DIFF(1E-1, test_t);
    CHECK_CLOSE_ABS_DIFF(0E-1, test_t);
    CHECK_CLOSE_ABS_DIFF(-1E-1,test_t);
    CHECK_CLOSE_ABS_DIFF(1.0E-1, test_t);
    CHECK_CLOSE_ABS_DIFF(0.0E-1, test_t);
    CHECK_CLOSE_ABS_DIFF(-1.0E-1, test_t);
    CHECK_CLOSE_ABS_DIFF(.0E-1, test_t);
    CHECK_CLOSE_ABS_DIFF(.0E-1, test_t);
    CHECK_CLOSE_ABS_DIFF(-.0E-1, test_t);
    CHECK_CLOSE_ABS_DIFF(10.0, test_t);
    CHECK_CLOSE_ABS_DIFF(00.0, test_t);
    CHECK_CLOSE_ABS_DIFF(-10.0,test_t);
    CHECK_CLOSE_ABS_DIFF(10e1, test_t);
    CHECK_CLOSE_ABS_DIFF(00e1, test_t);
    CHECK_CLOSE_ABS_DIFF(-10e1,test_t);
    CHECK_CLOSE_ABS_DIFF(10.0e1, test_t);
    CHECK_CLOSE_ABS_DIFF(00.0e1, test_t);
    CHECK_CLOSE_ABS_DIFF(-10.0e1,test_t);
    CHECK_CLOSE_ABS_DIFF(10e-1, test_t);
    CHECK_CLOSE_ABS_DIFF(00e-1, test_t);
    CHECK_CLOSE_ABS_DIFF(-10e-1,test_t);
    CHECK_CLOSE_ABS_DIFF(10.0e-1, test_t);
    CHECK_CLOSE_ABS_DIFF(00.0e-1, test_t);
    CHECK_CLOSE_ABS_DIFF(-10.0e-1,test_t);
    CHECK_CLOSE_ABS_DIFF(10E1, test_t);
    CHECK_CLOSE_ABS_DIFF(00E1, test_t);
    CHECK_CLOSE_ABS_DIFF(-10E1,test_t);
    CHECK_CLOSE_ABS_DIFF(10.0E1, test_t);
    CHECK_CLOSE_ABS_DIFF(00.0E1, test_t);
    CHECK_CLOSE_ABS_DIFF(-10.0E1,test_t);
    CHECK_CLOSE_ABS_DIFF(10E-1, test_t);
    CHECK_CLOSE_ABS_DIFF(00E-1, test_t);
    CHECK_CLOSE_ABS_DIFF(-10E-1,test_t);
    CHECK_CLOSE_ABS_DIFF(10.0E-1, test_t);
    CHECK_CLOSE_ABS_DIFF(00.0E-1, test_t);
    CHECK_CLOSE_ABS_DIFF(-10.0E-1, test_t);
    CHECK_CLOSE_ABS_DIFF(-10101.0E-011, test_t);
    CHECK_CLOSE_ABS_DIFF(-10101093, test_t);
    CHECK_CLOSE_ABS_DIFF(10101093, test_t);
    CHECK_CLOSE_ABS_DIFF(-.34, test_t);
    CHECK_CLOSE_ABS_DIFF(.34, test_t);
    CHECK_CLOSE_ABS_DIFF(.34e10, test_t);
    BOOST_CHECK_THROW(lexical_cast<test_t>("-1.e"), bad_lexical_cast);
    BOOST_CHECK_THROW(lexical_cast<test_t>("-1.E"), bad_lexical_cast);
    BOOST_CHECK_THROW(lexical_cast<test_t>("1.e"), bad_lexical_cast);
    BOOST_CHECK_THROW(lexical_cast<test_t>("1.E"), bad_lexical_cast);
    BOOST_CHECK_THROW(lexical_cast<test_t>("1.0e"), bad_lexical_cast);
    BOOST_CHECK_THROW(lexical_cast<test_t>("1.0E"), bad_lexical_cast);
    BOOST_CHECK_THROW(lexical_cast<test_t>("10E"), bad_lexical_cast);
    BOOST_CHECK_THROW(lexical_cast<test_t>("10e"), bad_lexical_cast);
    BOOST_CHECK_THROW(lexical_cast<test_t>("1.0e-"), bad_lexical_cast);
    BOOST_CHECK_THROW(lexical_cast<test_t>("1.0E-"), bad_lexical_cast);
    BOOST_CHECK_THROW(lexical_cast<test_t>("10E-"), bad_lexical_cast);
    BOOST_CHECK_THROW(lexical_cast<test_t>("10e-"), bad_lexical_cast);
    BOOST_CHECK_THROW(lexical_cast<test_t>("e1"), bad_lexical_cast);
    BOOST_CHECK_THROW(lexical_cast<test_t>("e-1"), bad_lexical_cast);
    BOOST_CHECK_THROW(lexical_cast<test_t>("e-"), bad_lexical_cast);
    BOOST_CHECK_THROW(lexical_cast<test_t>(".e"), bad_lexical_cast);
    BOOST_CHECK_THROW(lexical_cast<test_t>(".11111111111111111111111111111111111111111111111111111111111111111111ee"), bad_lexical_cast);
    BOOST_CHECK_THROW(lexical_cast<test_t>(".11111111111111111111111111111111111111111111111111111111111111111111e-"), bad_lexical_cast);
    BOOST_CHECK_THROW(lexical_cast<test_t>("-B"), bad_lexical_cast);
    BOOST_CHECK_THROW(lexical_cast<test_t>("0xB"), bad_lexical_cast);
    BOOST_CHECK_THROW(lexical_cast<test_t>("0x0"), bad_lexical_cast);
    BOOST_CHECK_THROW(lexical_cast<test_t>("--1.0"), bad_lexical_cast);
    BOOST_CHECK_THROW(lexical_cast<test_t>("1.0e--1"), bad_lexical_cast);
    BOOST_CHECK_THROW(lexical_cast<test_t>("1.0.0"), bad_lexical_cast);
    BOOST_CHECK_THROW(lexical_cast<test_t>("1e1e1"), bad_lexical_cast);
    BOOST_CHECK_THROW(lexical_cast<test_t>("1.0e-1e-1"), bad_lexical_cast);
    BOOST_CHECK_THROW(lexical_cast<test_t>(" 1.0"), bad_lexical_cast);
    BOOST_CHECK_THROW(lexical_cast<test_t>("1.0 "), bad_lexical_cast);
    BOOST_CHECK_THROW(lexical_cast<test_t>(""), bad_lexical_cast);
    BOOST_CHECK_THROW(lexical_cast<test_t>("-"), bad_lexical_cast);
    BOOST_CHECK_THROW(lexical_cast<test_t>('\0'), bad_lexical_cast);
    BOOST_CHECK_THROW(lexical_cast<test_t>('-'), bad_lexical_cast);
 }
 template <class T>
 void test_float_typess_for_overflows()
 {
    typedef T test_t;
    test_t minvalue = (std::numeric_limits<test_t>::min)();
    std::string s_min_value = lexical_cast<std::string>(minvalue);
    BOOST_CHECK_CLOSE_FRACTION(minvalue, lexical_cast<test_t>(minvalue), (std::numeric_limits<test_t>::epsilon()));
    BOOST_CHECK_CLOSE_FRACTION(minvalue, lexical_cast<test_t>(s_min_value), (std::numeric_limits<test_t>::epsilon()));
    test_t maxvalue = (std::numeric_limits<test_t>::max)();
    std::string s_max_value = lexical_cast<std::string>(maxvalue);
    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()));
    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 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);
    if ( is_same<test_t,float>::value )
    {
        BOOST_CHECK_THROW(lexical_cast<test_t>( (std::numeric_limits<double>::max)() ), bad_lexical_cast);
        BOOST_CHECK(
                (std::numeric_limits<double>::min)() - std::numeric_limits<test_t>::epsilon()
                <= lexical_cast<test_t>( (std::numeric_limits<double>::min)() )
                && lexical_cast<test_t>( (std::numeric_limits<double>::min)() )
                <= (std::numeric_limits<double>::min)() + std::numeric_limits<test_t>::epsilon()
        );
    }
    if ( sizeof(test_t) < sizeof(long double) )
    {
        BOOST_CHECK_THROW(lexical_cast<test_t>( (std::numeric_limits<long double>::max)() ), bad_lexical_cast);
        BOOST_CHECK(
                (std::numeric_limits<long double>::min)() - std::numeric_limits<test_t>::epsilon()
                <= lexical_cast<test_t>( (std::numeric_limits<long double>::min)() )
                && lexical_cast<test_t>( (std::numeric_limits<long double>::min)() )
                <= (std::numeric_limits<long double>::min)() + std::numeric_limits<test_t>::epsilon()
        );
    }
 }
 #undef CHECK_CLOSE_ABS_DIFF
 #define TEST_TO_FROM_CAST_AROUND_TYPED(VAL,STRING_TYPE)                             \
    test_value = VAL + std::numeric_limits<test_t>::epsilon() * i ;                 \
    converted_val = lexical_cast<test_t>( lexical_cast<STRING_TYPE>(test_value) );  \
    BOOST_CHECK_CLOSE_FRACTION(                                                              \
            test_value,                                                             \
            converted_val,                                                          \
            std::numeric_limits<test_t>::epsilon()                                  \
        );
 /*
 * For interval [ from_mult*epsilon+VAL, to_mult*epsilon+VAL ], converts float type
 * numbers to string[wstring] and then back to float type, then compares initial
 * values and generated.
 * Step is epsilon
 */
 #ifndef BOOST_LCAST_NO_WCHAR_T
 #   define TEST_TO_FROM_CAST_AROUND(VAL)                    \
    for(i=from_mult; i<=to_mult; ++i) {                     \
        TEST_TO_FROM_CAST_AROUND_TYPED(VAL, std::string)    \
        TEST_TO_FROM_CAST_AROUND_TYPED(VAL, std::wstring)   \
    }
 #else
 #   define TEST_TO_FROM_CAST_AROUND(VAL)                    \
    for(i=from_mult; i<=to_mult; ++i) {                     \
        TEST_TO_FROM_CAST_AROUND_TYPED(VAL, std::string)    \
    }
 #endif
 template <class TestType>
 void test_converion_from_to_float_types()
 {
    typedef TestType test_t;
    test_t test_value;
    test_t converted_val;
    int i;
    int from_mult = -50;
    int to_mult = 50;
    TEST_TO_FROM_CAST_AROUND( 0.0 );
    long double val1;
    for(val1 = 1.0e-10L; val1 < 1e11; val1*=10 )
        TEST_TO_FROM_CAST_AROUND( val1 );
    long double val2;
    for(val2 = -1.0e-10L; val2 > -1e11; val2*=10 )
        TEST_TO_FROM_CAST_AROUND( val2 );
    from_mult = -100;
    to_mult = 0;
    TEST_TO_FROM_CAST_AROUND( (std::numeric_limits<test_t>::max)() );
    from_mult = 0;
    to_mult = 100;
    TEST_TO_FROM_CAST_AROUND( (std::numeric_limits<test_t>::min)() );
 }
 #undef TEST_TO_FROM_CAST_AROUND
 #undef TEST_TO_FROM_CAST_AROUND_TYPED
 template<class T, class CharT>
 void test_conversion_from_float_to_char(CharT zero)
 {
    BOOST_CHECK(lexical_cast<CharT>(static_cast<T>(0)) == zero + 0);
    BOOST_CHECK(lexical_cast<CharT>(static_cast<T>(1)) == zero + 1);
    BOOST_CHECK(lexical_cast<CharT>(static_cast<T>(2)) == zero + 2);
    BOOST_CHECK(lexical_cast<CharT>(static_cast<T>(3)) == zero + 3);
    BOOST_CHECK(lexical_cast<CharT>(static_cast<T>(4)) == zero + 4);
    BOOST_CHECK(lexical_cast<CharT>(static_cast<T>(5)) == zero + 5);
    BOOST_CHECK(lexical_cast<CharT>(static_cast<T>(6)) == zero + 6);
    BOOST_CHECK(lexical_cast<CharT>(static_cast<T>(7)) == zero + 7);
    BOOST_CHECK(lexical_cast<CharT>(static_cast<T>(8)) == zero + 8);
    BOOST_CHECK(lexical_cast<CharT>(static_cast<T>(9)) == zero + 9);
    BOOST_CHECK_THROW(lexical_cast<CharT>(static_cast<T>(10)), bad_lexical_cast);
    T t = (std::numeric_limits<T>::max)();
    BOOST_CHECK_THROW(lexical_cast<CharT>(t), bad_lexical_cast);
 }
 template<class T, class CharT>
 void test_conversion_from_char_to_float(CharT zero)
 {
    BOOST_CHECK_CLOSE_FRACTION(lexical_cast<T>( static_cast<CharT>(zero + 0)), static_cast<T>(0), (std::numeric_limits<T>::epsilon()) );
    BOOST_CHECK_CLOSE_FRACTION(lexical_cast<T>( static_cast<CharT>(zero + 1)), static_cast<T>(1), (std::numeric_limits<T>::epsilon()) );
    BOOST_CHECK_CLOSE_FRACTION(lexical_cast<T>( static_cast<CharT>(zero + 2)), static_cast<T>(2), (std::numeric_limits<T>::epsilon()) );
    BOOST_CHECK_CLOSE_FRACTION(lexical_cast<T>( static_cast<CharT>(zero + 3)), static_cast<T>(3), (std::numeric_limits<T>::epsilon()) );
    BOOST_CHECK_CLOSE_FRACTION(lexical_cast<T>( static_cast<CharT>(zero + 4)), static_cast<T>(4), (std::numeric_limits<T>::epsilon()) );
    BOOST_CHECK_CLOSE_FRACTION(lexical_cast<T>( static_cast<CharT>(zero + 5)), static_cast<T>(5), (std::numeric_limits<T>::epsilon()) );
    BOOST_CHECK_CLOSE_FRACTION(lexical_cast<T>( static_cast<CharT>(zero + 6)), static_cast<T>(6), (std::numeric_limits<T>::epsilon()) );
    BOOST_CHECK_CLOSE_FRACTION(lexical_cast<T>( static_cast<CharT>(zero + 7)), static_cast<T>(7), (std::numeric_limits<T>::epsilon()) );
    BOOST_CHECK_CLOSE_FRACTION(lexical_cast<T>( static_cast<CharT>(zero + 8)), static_cast<T>(8), (std::numeric_limits<T>::epsilon()) );
    BOOST_CHECK_CLOSE_FRACTION(lexical_cast<T>( static_cast<CharT>(zero + 9)), static_cast<T>(9), (std::numeric_limits<T>::epsilon()) );
    BOOST_CHECK_THROW(lexical_cast<T>( static_cast<CharT>(zero + 10)), bad_lexical_cast);
    BOOST_CHECK_THROW(lexical_cast<T>( static_cast<CharT>(zero - 1)), bad_lexical_cast);
 }
 struct restore_oldloc
 {
    std::locale oldloc;
    ~restore_oldloc() { std::locale::global(oldloc); }
 };
 template<class T>
 void test_conversion_from_to_float()
 {    char const zero = '0';
    signed char const szero = '0';
    unsigned char const uzero = '0';
    test_conversion_from_float_to_char<T>(zero);
    test_conversion_from_char_to_float<T>(zero);
    test_conversion_from_float_to_char<T>(szero);
    test_conversion_from_char_to_float<T>(szero);
    test_conversion_from_float_to_char<T>(uzero);
    test_conversion_from_char_to_float<T>(uzero);
    #if !defined(BOOST_LCAST_NO_WCHAR_T) && !defined(BOOST_NO_INTRINSIC_WCHAR_T)
    wchar_t const wzero = L'0';
    test_conversion_from_float_to_char<T>(wzero);
    test_conversion_from_char_to_float<T>(wzero);
    #endif
    BOOST_CHECK_CLOSE_FRACTION(lexical_cast<T>("+1"), 1, std::numeric_limits<T>::epsilon());
    BOOST_CHECK_CLOSE_FRACTION(lexical_cast<T>("+9"), 9, std::numeric_limits<T>::epsilon());
    BOOST_CHECK_THROW(lexical_cast<T>("++1"), bad_lexical_cast);
    BOOST_CHECK_THROW(lexical_cast<T>("-+9"), bad_lexical_cast);
    BOOST_CHECK_THROW(lexical_cast<T>("--1"), bad_lexical_cast);
    BOOST_CHECK_THROW(lexical_cast<T>("+-9"), bad_lexical_cast);
    test_converion_to_float_types<T>();
    test_float_typess_for_overflows<T>();
    test_converion_from_to_float_types<T>();
    typedef std::numpunct<char> numpunct;
    restore_oldloc guard;
    std::locale const& oldloc = guard.oldloc;
    std::string grouping1 = BOOST_USE_FACET(numpunct, oldloc).grouping();
    std::string grouping2(grouping1);
    test_conversion_from_to_float_for_locale<T>();
    try
    {
        std::locale newloc("");
        std::locale::global(newloc);
        grouping2 = BOOST_USE_FACET(numpunct, newloc).grouping();
    }
    catch(std::exception const& ex)
    {
        std::string msg("Failed to set system locale: ");
        msg += ex.what();
        BOOST_TEST_MESSAGE(msg);
    }
    if(grouping1 != grouping2)
        test_conversion_from_to_float_for_locale<T>();
    if(grouping1.empty() && grouping2.empty())
        BOOST_TEST_MESSAGE("Formatting with thousands_sep has not been tested");
 }
 void test_conversion_from_to_float()
 {
    test_conversion_from_to_float<float>();
 }
 void test_conversion_from_to_double()
 {
    test_conversion_from_to_float<double>();
 }
 void test_conversion_from_to_long_double()
 {
    test_conversion_from_to_float<long double>();
 }
@@ -0,0 +1,180 @@
 //  Unit test for boost::lexical_cast.
 //
 //  See http://www.boost.org for most recent version, including documentation.
 //
 //  Copyright Antony Polukhin, 2011.
 //
 //  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).
 #include <boost/config.hpp>
 #if defined(__INTEL_COMPILER)
 #pragma warning(disable: 193 383 488 981 1418 1419)
 #elif defined(BOOST_MSVC)
 #pragma warning(disable: 4097 4100 4121 4127 4146 4244 4245 4511 4512 4701 4800)
 #endif
 #include <boost/lexical_cast.hpp>
 #include <boost/math/special_functions/sign.hpp>
 #include <boost/math/special_functions/fpclassify.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/test/unit_test.hpp>
 #include <boost/test/floating_point_comparison.hpp>
 #if defined(BOOST_NO_STRINGSTREAM) || defined(BOOST_NO_STD_WSTRING)
 #define BOOST_LCAST_NO_WCHAR_T
 #endif
 using namespace boost;
 template <class T>
 bool is_pos_inf(T value)
 {
    return (boost::math::isinf)(value) && !(boost::math::signbit)(value);
 }
 template <class T>
 bool is_neg_inf(T value)
 {
    return (boost::math::isinf)(value) && (boost::math::signbit)(value);
 }
 template <class T>
 bool is_pos_nan(T value)
 {
    return (boost::math::isnan)(value) && !(boost::math::signbit)(value);
 }
 template <class T>
 bool is_neg_nan(T value)
 {
    /* There is some strange behaviour on Itanium platform with -nan nuber for long double.
    * It is a IA64 feature, or it is a boost::math feature, not a lexical_cast bug */
 #if defined(__ia64__) || defined(_M_IA64)
    return (boost::math::isnan)(value)
            && ( boost::is_same<T, long double >::value || (boost::math::signbit)(value) );
 #else
    return (boost::math::isnan)(value) && (boost::math::signbit)(value);
 #endif
 }
 template <class T>
 void test_inf_nan_templated()
 {
    typedef T test_t;
    BOOST_CHECK( is_pos_inf( lexical_cast<test_t>("inf") ) );
    BOOST_CHECK( is_pos_inf( lexical_cast<test_t>("INF") ) );
    BOOST_CHECK( is_neg_inf( lexical_cast<test_t>("-inf") ) );
    BOOST_CHECK( is_neg_inf( lexical_cast<test_t>("-INF") ) );
    BOOST_CHECK( is_pos_inf( lexical_cast<test_t>("+inf") ) );
    BOOST_CHECK( is_pos_inf( lexical_cast<test_t>("+INF") ) );
    BOOST_CHECK( is_pos_inf( lexical_cast<test_t>("infinity") ) );
    BOOST_CHECK( is_pos_inf( lexical_cast<test_t>("INFINITY") ) );
    BOOST_CHECK( is_neg_inf( lexical_cast<test_t>("-infinity") ) );
    BOOST_CHECK( is_neg_inf( lexical_cast<test_t>("-INFINITY") ) );
    BOOST_CHECK( is_pos_inf( lexical_cast<test_t>("+infinity") ) );
    BOOST_CHECK( is_pos_inf( lexical_cast<test_t>("+INFINITY") ) );
    BOOST_CHECK( is_pos_nan( lexical_cast<test_t>("nan") ) );
    BOOST_CHECK( is_pos_nan( lexical_cast<test_t>("NAN") ) );
    BOOST_CHECK( is_neg_nan( lexical_cast<test_t>("-nan") ) );
    BOOST_CHECK( is_neg_nan( lexical_cast<test_t>("-NAN") ) );
    BOOST_CHECK( is_pos_nan( lexical_cast<test_t>("+nan") ) );
    BOOST_CHECK( is_pos_nan( lexical_cast<test_t>("+NAN") ) );
    BOOST_CHECK( is_pos_nan( lexical_cast<test_t>("nan()") ) );
    BOOST_CHECK( is_pos_nan( lexical_cast<test_t>("NAN(some string)") ) );
    BOOST_CHECK_THROW( lexical_cast<test_t>("NAN(some string"), bad_lexical_cast );
    BOOST_CHECK(lexical_cast<std::string>( (boost::math::changesign)(std::numeric_limits<test_t >::infinity()))
                == "-inf" );
    BOOST_CHECK(lexical_cast<std::string>( std::numeric_limits<test_t >::infinity()) == "inf" );
    BOOST_CHECK(lexical_cast<std::string>( std::numeric_limits<test_t >::quiet_NaN()) == "nan" );
 #if !defined(__ia64__) && !defined(_M_IA64)
    BOOST_CHECK(lexical_cast<std::string>(
                (boost::math::changesign)(std::numeric_limits<test_t >::quiet_NaN()))
                == "-nan" );
 #endif
 #ifndef  BOOST_LCAST_NO_WCHAR_T
    BOOST_CHECK( is_pos_inf( lexical_cast<test_t>(L"inf") ) );
    BOOST_CHECK( is_pos_inf( lexical_cast<test_t>(L"INF") ) );
    BOOST_CHECK( is_neg_inf( lexical_cast<test_t>(L"-inf") ) );
    BOOST_CHECK( is_neg_inf( lexical_cast<test_t>(L"-INF") ) );
    BOOST_CHECK( is_pos_inf( lexical_cast<test_t>(L"+inf") ) );
    BOOST_CHECK( is_pos_inf( lexical_cast<test_t>(L"+INF") ) );
    BOOST_CHECK( is_pos_inf( lexical_cast<test_t>(L"infinity") ) );
    BOOST_CHECK( is_pos_inf( lexical_cast<test_t>(L"INFINITY") ) );
    BOOST_CHECK( is_neg_inf( lexical_cast<test_t>(L"-infinity") ) );
    BOOST_CHECK( is_neg_inf( lexical_cast<test_t>(L"-INFINITY") ) );
    BOOST_CHECK( is_pos_inf( lexical_cast<test_t>(L"+infinity") ) );
    BOOST_CHECK( is_pos_inf( lexical_cast<test_t>(L"+INFINITY") ) );
    BOOST_CHECK( is_pos_nan( lexical_cast<test_t>(L"nan") ) );
    BOOST_CHECK( is_pos_nan( lexical_cast<test_t>(L"NAN") ) );
    BOOST_CHECK( is_neg_nan( lexical_cast<test_t>(L"-nan") ) );
    BOOST_CHECK( is_neg_nan( lexical_cast<test_t>(L"-NAN") ) );
    BOOST_CHECK( is_pos_nan( lexical_cast<test_t>(L"+nan") ) );
    BOOST_CHECK( is_pos_nan( lexical_cast<test_t>(L"+NAN") ) );
    BOOST_CHECK( is_pos_nan( lexical_cast<test_t>(L"nan()") ) );
    BOOST_CHECK( is_pos_nan( lexical_cast<test_t>(L"NAN(some string)") ) );
    BOOST_CHECK_THROW( lexical_cast<test_t>(L"NAN(some string"), bad_lexical_cast );
    BOOST_CHECK(lexical_cast<std::wstring>( (boost::math::changesign)(std::numeric_limits<test_t >::infinity()))
                == L"-inf" );
    BOOST_CHECK(lexical_cast<std::wstring>( std::numeric_limits<test_t >::infinity()) == L"inf" );
    BOOST_CHECK(lexical_cast<std::wstring>( std::numeric_limits<test_t >::quiet_NaN()) == L"nan" );
 #if !defined(__ia64__) && !defined(_M_IA64)
    BOOST_CHECK(lexical_cast<std::wstring>(
                (boost::math::changesign)(std::numeric_limits<test_t >::quiet_NaN()))
                == L"-nan" );
 #endif
 #endif
 }
 void test_inf_nan_float()
 {
    test_inf_nan_templated<float >();
 }
 void test_inf_nan_double()
 {
    test_inf_nan_templated<double >();
 }
 void test_inf_nan_long_double()
 {
    test_inf_nan_templated<long double >();
 }
 unit_test::test_suite *init_unit_test_suite(int, char *[])
 {
    unit_test_framework::test_suite *suite =
        BOOST_TEST_SUITE("lexical_cast inf anf nan parsing unit test");
    suite->add(BOOST_TEST_CASE(&test_inf_nan_float));
    suite->add(BOOST_TEST_CASE(&test_inf_nan_double));
    suite->add(BOOST_TEST_CASE(&test_inf_nan_long_double));
    return suite;
 }
@@ -0,0 +1,92 @@
 //  Unit test for boost::lexical_cast.
 //
 //  See http://www.boost.org for most recent version, including documentation.
 //
 //  Copyright Alexander Nasonov, 2006.
 //
 //  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).
 //
 //  Test round-tripping conversion FPT -> string -> FPT,
 //  where FPT is Floating Point Type.
 #include <boost/config.hpp>
 #if defined(__INTEL_COMPILER)
 #pragma warning(disable: 193 383 488 981 1418 1419)
 #elif defined(BOOST_MSVC)
 #pragma warning(disable: 4097 4100 4121 4127 4146 4244 4245 4511 4512 4701 4800)
 #endif
 #include <boost/lexical_cast.hpp>
 #include <boost/test/unit_test.hpp>
 using namespace boost;
 void test_round_conversion_float();
 void test_round_conversion_double();
 void test_round_conversion_long_double();
 unit_test::test_suite *init_unit_test_suite(int, char *[])
 {
    unit_test_framework::test_suite *suite =
        BOOST_TEST_SUITE("lexical_cast unit test");
    suite->add(BOOST_TEST_CASE(&test_round_conversion_float));
    suite->add(BOOST_TEST_CASE(&test_round_conversion_double));
    suite->add(BOOST_TEST_CASE(&test_round_conversion_long_double));
    return suite;
 }
 template<class T>
 void test_round_conversion()
 {
    T epsilon = std::numeric_limits<T>::epsilon();
    std::string const epsilon_s = boost::lexical_cast<std::string>(epsilon);
    BOOST_CHECK(epsilon == lexical_cast<T>(epsilon_s));
    T max_ = (std::numeric_limits<T>::max)();
    std::string const max_s = boost::lexical_cast<std::string>(max_);
    BOOST_CHECK(max_ == lexical_cast<T>(max_s));
    T min_ = (std::numeric_limits<T>::min)();
    std::string const min_s = boost::lexical_cast<std::string>(min_);
    BOOST_CHECK(min_ == lexical_cast<T>(min_s));
    T max_div137 = max_ / 137;
    std::string max_div137_s = boost::lexical_cast<std::string>(max_div137);
    BOOST_CHECK(max_div137 == lexical_cast<T>(max_div137_s));
    T epsilon_mult137 = epsilon * 137;
    std::string epsilon_mult137_s(lexical_cast<std::string>(epsilon_mult137));
    BOOST_CHECK(epsilon_mult137 == lexical_cast<T>(epsilon_mult137_s));
 }
 // See bug http://tinyurl.com/vhpvo
 template<class T>
 void test_msvc_magic_values()
 {
    T magic_msvc = 0.00010000433948393407;
    std::string magic_msvc_s = boost::lexical_cast<std::string>(magic_msvc);
    BOOST_CHECK(magic_msvc == lexical_cast<T>(magic_msvc_s));
 }
 void test_round_conversion_float()
 {
    test_round_conversion<float>();
 }
 void test_round_conversion_double()
 {
    test_round_conversion<double>();
    test_msvc_magic_values<double>();
 }
 void test_round_conversion_long_double()
 {
    test_round_conversion<long double>();
    test_msvc_magic_values<long double>();
 }
@@ -0,0 +1,54 @@
 //  Unit test for boost::lexical_cast.
 //
 //  See http://www.boost.org for most recent version, including documentation.
 //
 //  Copyright Alexander Nasonov, 2007.
 //
 //  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).
 //
 //  Test that Source can be non-copyable.
 #include <boost/config.hpp>
 #if defined(__INTEL_COMPILER)
 #pragma warning(disable: 193 383 488 981 1418 1419)
 #elif defined(BOOST_MSVC)
 #pragma warning(disable: 4097 4100 4121 4127 4146 4244 4245 4511 4512 4701 4800)
 #endif
 #include <boost/lexical_cast.hpp>
 #include <boost/noncopyable.hpp>
 #include <boost/test/unit_test.hpp>
 using namespace boost;
 void test_noncopyable();
 unit_test::test_suite *init_unit_test_suite(int, char *[])
 {
    unit_test_framework::test_suite *suite =
        BOOST_TEST_SUITE("lexical_cast unit test");
    suite->add(BOOST_TEST_CASE(&test_noncopyable));
    return suite;
 }
 class Noncopyable : private boost::noncopyable
 {
 public:
    Noncopyable() {}
 };
 inline std::ostream &operator<<(std::ostream &out, const Noncopyable&)
 {
    return out << "Noncopyable";
 }
 void test_noncopyable()
 {
    Noncopyable x;
    BOOST_CHECK(boost::lexical_cast<std::string>(x) == "Noncopyable");
 }
@@ -0,0 +1,67 @@
 //  Unit test for boost::lexical_cast.
 //
 //  See http://www.boost.org for most recent version, including documentation.
 //
 //  Copyright Alexander Nasonov, 2007.
 //
 //  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).
 //
 // This tests now must pass on vc8, because lexical_cast
 // implementation has changed and it does not use stringstream for casts
 // to integral types
 #include <boost/config.hpp>
 #include <boost/lexical_cast.hpp>
 #include <boost/cstdint.hpp>
 #include <boost/test/unit_test.hpp>
 #include <string>
 using namespace boost;
 // See also test_conversion_from_string_to_integral(CharT)
 // in libs/conversion/lexical_cast_test.cpp
 template<class T, class CharT>
 void test_too_long_number(CharT zero)
 {
    typedef std::numeric_limits<T> limits;
    std::basic_string<CharT> s;
    std::basic_ostringstream<CharT> o;
    o << (limits::max)() << zero;
    s = o.str();
    BOOST_CHECK_THROW(lexical_cast<T>(s), bad_lexical_cast);
    s[s.size()-1] += 9; // '0' -> '9'
    BOOST_CHECK_THROW(lexical_cast<T>(s), bad_lexical_cast);
    if(limits::is_signed)
    {
        std::basic_ostringstream<CharT> o;
        o << (limits::min)() << zero;
        s = o.str();
        BOOST_CHECK_THROW(lexical_cast<T>(s), bad_lexical_cast);
        s[s.size()-1] += 9; // '0' -> '9'
        BOOST_CHECK_THROW(lexical_cast<T>(s), bad_lexical_cast);
    }
 }
 void test_vc8_bug()
 {
    test_too_long_number<boost::intmax_t>('0');
    test_too_long_number<boost::uintmax_t>('0');
 #if !defined(BOOST_LCAST_NO_WCHAR_T)
    test_too_long_number<boost::intmax_t>(L'0');
    test_too_long_number<boost::uintmax_t>(L'0');
 #endif
 }
 unit_test::test_suite *init_unit_test_suite(int, char *[])
 {
    unit_test_framework::test_suite *suite =
        BOOST_TEST_SUITE("lexical_cast vc8 bug unit test");
    suite->add(BOOST_TEST_CASE(test_vc8_bug));
    return suite;
 }
@@ -0,0 +1,56 @@
 //  Unit test for boost::lexical_cast.
 //
 //  See http://www.boost.org for most recent version, including documentation.
 //
 //  Copyright Antony Polukhin, 2011.
 //
 //  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).
 #include <boost/config.hpp>
 #if defined(__INTEL_COMPILER)
 #pragma warning(disable: 193 383 488 981 1418 1419)
 #elif defined(BOOST_MSVC)
 #pragma warning(disable: 4097 4100 4121 4127 4146 4244 4245 4511 4512 4701 4800)
 #endif
 #include <boost/lexical_cast.hpp>
 #include <boost/cstdint.hpp>
 #include <boost/test/unit_test.hpp>
 #include <boost/test/floating_point_comparison.hpp>
 using namespace boost;
 void test_char_types_conversions()
 {
 #ifndef BOOST_LCAST_NO_WCHAR_T
    const char c_arr[]            = "Test array of chars";
    const unsigned char uc_arr[]  = "Test array of chars";
    const signed char sc_arr[]    = "Test array of chars";
    const wchar_t wc_arr[]        =L"Test array of chars";
    // Following tests depend on realization of std::locale
    // and pass for popular compilers and STL realizations
    BOOST_CHECK(boost::lexical_cast<wchar_t>(c_arr[0]) == wc_arr[0]);
    BOOST_CHECK(boost::lexical_cast<std::wstring>(c_arr) == std::wstring(wc_arr));
    BOOST_CHECK(boost::lexical_cast<std::wstring>(sc_arr) == std::wstring(wc_arr) );
    BOOST_CHECK(boost::lexical_cast<std::wstring>(uc_arr) == std::wstring(wc_arr) );
    BOOST_CHECK_EQUAL(boost::lexical_cast<wchar_t>(uc_arr[0]), wc_arr[0]);
    BOOST_CHECK_EQUAL(boost::lexical_cast<wchar_t>(sc_arr[0]), wc_arr[0]);
 #endif
    BOOST_CHECK(1);
 }
 unit_test::test_suite *init_unit_test_suite(int, char *[])
 {
    unit_test_framework::test_suite *suite =
        BOOST_TEST_SUITE("lexical_cast char<->wchar_t unit test");
    suite->add(BOOST_TEST_CASE(&test_char_types_conversions));
    return suite;
 }
@@ -1,383 +0,0 @@
 //
 // Test boost::polymorphic_cast, boost::polymorphic_downcast and 
 // boost::polymorphic_pointer_cast, boost::polymorphic_pointer_downcast
 //
 // Copyright 1999 Beman Dawes
 // Copyright 1999 Dave Abrahams
 // Copyright 2014 Peter Dimov
 // Copyright 2014 Boris Rasin, Antony Polukhin
 // Copyright 2023 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
 //
 #define BOOST_ENABLE_ASSERT_HANDLER
 #include <boost/polymorphic_cast.hpp>
 #include <boost/polymorphic_pointer_cast.hpp>
 #include <boost/smart_ptr/shared_ptr.hpp>
 #include <boost/smart_ptr/intrusive_ptr.hpp>
 #include <boost/smart_ptr/intrusive_ref_counter.hpp>
 #include <boost/core/lightweight_test.hpp>
 #include <string>
 #include <memory>
 static bool expect_assertion = false;
 static int assertion_failed_count = 0;
 //assertion handler throws it to exit like assert, but to be able to catch it and stop
 //usage: BOOST_TEST_THROWS( function_with_assert(), expected_assertion );
 struct expected_assertion {};
 // BOOST_ASSERT custom handler
 void boost::assertion_failed( char const * expr, char const * function, char const * file, long line )
 {
    if( expect_assertion )
    {
        ++assertion_failed_count;
        throw expected_assertion();
    }
    else
    {
        BOOST_ERROR( "unexpected assertion" );
        BOOST_LIGHTWEIGHT_TEST_OSTREAM
          << file << "(" << line << "): assertion '" << expr << "' failed in function '"
          << function << "'" << std::endl;
    }
 }
 //
 struct Base : boost::intrusive_ref_counter<Base>
 {
    virtual ~Base() {}
    virtual std::string kind() { return "Base"; }
 };
 struct Base2
 {
    virtual ~Base2() {}
    virtual std::string kind2() { return "Base2"; }
 };
 struct Derived : public Base, Base2
 {
    virtual std::string kind() { return "Derived"; }
 };
 static void test_polymorphic_cast()
 {
    Base * base = new Derived;
    Derived * derived;
    try
    {
        derived = boost::polymorphic_cast<Derived*>( base );
        BOOST_TEST( derived != 0 );
        if( derived != 0 )
        {
            BOOST_TEST_EQ( derived->kind(), "Derived" );
        }
    }
    catch( std::bad_cast const& )
    {
        BOOST_ERROR( "boost::polymorphic_cast<Derived*>( base ) threw std::bad_cast" );
    }
    Base2 * base2;
    try
    {
        base2 = boost::polymorphic_cast<Base2*>( base ); // crosscast
        BOOST_TEST( base2 != 0 );
        if( base2 != 0 )
        {
            BOOST_TEST_EQ( base2->kind2(), "Base2" );
        }
    }
    catch( std::bad_cast const& )
    {
        BOOST_ERROR( "boost::polymorphic_cast<Base2*>( base ) threw std::bad_cast" );
    }
    delete base;
 }
 static void test_polymorphic_pointer_cast()
 {
    Base * base = new Derived;
    Derived * derived;
    try
    {
        derived = boost::polymorphic_pointer_cast<Derived>( base );
        BOOST_TEST( derived != 0 );
        if( derived != 0 )
        {
            BOOST_TEST_EQ( derived->kind(), "Derived" );
        }
    }
    catch( std::bad_cast const& )
    {
        BOOST_ERROR( "boost::polymorphic_pointer_cast<Derived>( base ) threw std::bad_cast" );
    }
    Base2 * base2;
    try
    {
        base2 = boost::polymorphic_pointer_cast<Base2>( base ); // crosscast
        BOOST_TEST( base2 != 0 );
        if( base2 != 0 )
        {
            BOOST_TEST_EQ( base2->kind2(), "Base2" );
        }
    }
    catch( std::bad_cast const& )
    {
        BOOST_ERROR( "boost::polymorphic_pointer_cast<Base2>( base ) threw std::bad_cast" );
    }
    boost::shared_ptr<Base> sp_base( base );
    boost::shared_ptr<Base2> sp_base2;
    try
    {
        sp_base2 = boost::polymorphic_pointer_cast<Base2>( sp_base ); // crosscast
        BOOST_TEST( sp_base2 != 0 );
        if( sp_base2 != 0 )
        {
            BOOST_TEST_EQ( sp_base2->kind2(), "Base2" );
        }
    }
    catch( std::bad_cast const& )
    {
        BOOST_ERROR( "boost::polymorphic_pointer_cast<Base2>( sp_base ) threw std::bad_cast" );
    }
    // we do not `delete base;` because sahred_ptr is holding base
 }
 static void test_polymorphic_downcast()
 {
    Base *base_pointer = new Derived;
    // test raw pointer cast
    Derived *derived_pointer = boost::polymorphic_downcast<Derived *>(base_pointer);
    BOOST_TEST(derived_pointer != 0);
    if (derived_pointer != 0)
    {
        BOOST_TEST_EQ(derived_pointer->kind(), "Derived");
    }
    // test reference cast
    Derived& derived_ref = boost::polymorphic_downcast<Derived&>(*base_pointer);
    BOOST_TEST_EQ(derived_ref.kind(), "Derived");
    delete base_pointer;
 }
 static void test_polymorphic_pointer_downcast_builtin()
 {
    Base * base = new Derived;
    Derived * derived = boost::polymorphic_pointer_downcast<Derived>( base );
    BOOST_TEST( derived != 0 );
    if( derived != 0 )
    {
        BOOST_TEST_EQ( derived->kind(), "Derived" );
    }
    // polymorphic_pointer_downcast can't do crosscasts
    delete base;
 }
 static void test_polymorphic_pointer_downcast_boost_shared()
 {
    boost::shared_ptr<Base> base (new Derived);
    boost::shared_ptr<Derived> derived = boost::polymorphic_pointer_downcast<Derived>( base );
    BOOST_TEST( derived != 0 );
    if( derived != 0 )
    {
        BOOST_TEST_EQ( derived->kind(), "Derived" );
    }
 }
 static void test_polymorphic_pointer_downcast_intrusive()
 {
    boost::intrusive_ptr<Base> base (new Derived);
    boost::intrusive_ptr<Derived> derived = boost::polymorphic_pointer_downcast<Derived>( base );
    BOOST_TEST( derived != 0 );
    if( derived != 0 )
    {
        BOOST_TEST_EQ( derived->kind(), "Derived" );
    }
 }
 static void test_polymorphic_pointer_downcast_std_shared()
 {
    std::shared_ptr<Base> base (new Derived);
    std::shared_ptr<Derived> derived = boost::polymorphic_pointer_downcast<Derived>( base );
    BOOST_TEST( derived != 0 );
    if( derived != 0 )
    {
        BOOST_TEST_EQ( derived->kind(), "Derived" );
    }
 }
 static void test_polymorphic_cast_fail()
 {
    Base * base = new Base;
    BOOST_TEST_THROWS( boost::polymorphic_cast<Derived*>( base ), std::bad_cast );
    delete base;
 }
 static void test_polymorphic_pointer_cast_fail()
 {
    Base * base = new Base;
    BOOST_TEST_THROWS( boost::polymorphic_pointer_cast<Derived>( base ), std::bad_cast );
    delete base;
    BOOST_TEST_THROWS( boost::polymorphic_pointer_cast<Derived>( boost::shared_ptr<Base>(new Base) ), std::bad_cast );
    BOOST_TEST_THROWS( boost::polymorphic_pointer_cast<Derived>( std::shared_ptr<Base>(new Base) ), std::bad_cast );
    BOOST_TEST_THROWS( boost::polymorphic_pointer_cast<Derived>( boost::intrusive_ptr<Base>(new Base) ), std::bad_cast );
 }
 static void test_polymorphic_downcast_fail()
 {
    Base * base_pointer = new Base;
    {
        // test raw pointer cast
        int old_count = assertion_failed_count;
        expect_assertion = true;
        BOOST_TEST_THROWS(boost::polymorphic_downcast<Derived *>(base_pointer), expected_assertion); // should assert
        BOOST_TEST_EQ(assertion_failed_count, old_count + 1);
        expect_assertion = false;
    }
    {
        // test reference cast
        int old_count = assertion_failed_count;
        expect_assertion = true;
        BOOST_TEST_THROWS(boost::polymorphic_downcast<Derived &>(*base_pointer), expected_assertion); // should assert
        BOOST_TEST_EQ(assertion_failed_count, old_count + 1);
        expect_assertion = false;
    }
    delete base_pointer;
 }
 static void test_polymorphic_pointer_downcast_builtin_fail()
 {
    Base * base = new Base;
    int old_count = assertion_failed_count;
    expect_assertion = true;
    BOOST_TEST_THROWS( boost::polymorphic_pointer_downcast<Derived>( base ), expected_assertion ); // should assert
    BOOST_TEST_EQ( assertion_failed_count, old_count + 1 );
    expect_assertion = false;
    delete base;
 }
 static void test_polymorphic_pointer_downcast_boost_shared_fail()
 {
    boost::shared_ptr<Base> base (new Base);
    int old_count = assertion_failed_count;
    expect_assertion = true;
    BOOST_TEST_THROWS( boost::polymorphic_pointer_downcast<Derived>( base ), expected_assertion ); // should assert
    BOOST_TEST_EQ( assertion_failed_count, old_count + 1 );
    expect_assertion = false;
 }
 static void test_polymorphic_pointer_downcast_std_shared_fail()
 {
    std::shared_ptr<Base> base (new Base);
    int old_count = assertion_failed_count;
    expect_assertion = true;
    BOOST_TEST_THROWS( boost::polymorphic_pointer_downcast<Derived>( base ), expected_assertion ); // should assert
    BOOST_TEST_EQ( assertion_failed_count, old_count + 1 );
    expect_assertion = false;
 }
 static void test_polymorphic_pointer_downcast_intrusive_fail()
 {
    boost::intrusive_ptr<Base> base (new Base);
    int old_count = assertion_failed_count;
    expect_assertion = true;
    BOOST_TEST_THROWS( boost::polymorphic_pointer_downcast<Derived>( base ), expected_assertion); // should assert
    BOOST_TEST_EQ( assertion_failed_count, old_count + 1 );
    expect_assertion = false;
 }
 int main()
 {
    test_polymorphic_cast();
    test_polymorphic_pointer_cast();
    test_polymorphic_downcast();
    test_polymorphic_pointer_downcast_builtin();
    test_polymorphic_pointer_downcast_boost_shared();
    test_polymorphic_pointer_downcast_intrusive();
    test_polymorphic_cast_fail();
    test_polymorphic_pointer_cast_fail();
    test_polymorphic_downcast_fail();
    test_polymorphic_pointer_downcast_builtin_fail();
    test_polymorphic_pointer_downcast_boost_shared_fail();
    test_polymorphic_pointer_downcast_intrusive_fail();
    test_polymorphic_pointer_downcast_std_shared();
    test_polymorphic_pointer_downcast_std_shared_fail();
    return boost::report_errors();
 }