Merge pull request #13 from boostorg/danieljames-patch-3

Change the path of the quickbook documentation

.travis.yml

@@ -0,0 +1,119 @@
+# 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 2014-2016.
+
+#
+# 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 #7
+
+sudo: false
+language: cpp
+compiler:
+    - gcc
+#    - clang
+
+os:
+    - linux
+
+env:
+    global:
+        # Autodetect Boost branch by using the following code: - BRANCH_TO_TEST=$TRAVIS_BRANCH
+        # or just directly specify it
+        - BRANCH_TO_TEST=$TRAVIS_BRANCH
+
+        # Files, which coverage results must be ignored (files from other projects).
+        # Example: - IGNORE_COVERAGE='*/boost/progress.hpp */filesystem/src/*'
+        - IGNORE_COVERAGE=''
+
+        # Explicitly remove the following library from Boost. This may be usefull, if you're for example running Travis
+        # from `Boost.DLL` repo, while Boost already has `dll`.
+        #
+        # By default is eaual to - BOOST_REMOVE=$(basename $TRAVIS_BUILD_DIR)
+        # This will force to use local repo content, instead of the Boost's default.
+        - BOOST_REMOVE=$(basename $TRAVIS_BUILD_DIR)
+
+    matrix:
+        # Note that "--coverage -fsanitize=address,leak,undefined -DBOOST_TRAVISCI_BUILD" are added automatically lower in code
+        - CXX_FLAGS="-std=c++98" LINK_FLAGS="" TOOLSET=gcc-6
+        - CXX_FLAGS="-std=c++11" LINK_FLAGS="" TOOLSET=gcc-6
+        - CXX_FLAGS="-std=c++1y" LINK_FLAGS="" TOOLSET=gcc-6
+        #- CXX_FLAGS="-std=c++11 -stdlib=libc++" LINK_FLAGS="-stdlib=libc++" TOOLSET=clang
+        #- CXX_FLAGS="-std=c++1y -stdlib=libc++" LINK_FLAGS="-stdlib=libc++" TOOLSET=clang
+
+###############################################################################################################
+# From this point and below code is same for all the Boost libs
+###############################################################################################################
+
+
+# Installing additional tools
+addons:
+  apt:
+    sources:
+    - ubuntu-toolchain-r-test
+    - git-core
+    packages:
+    - git
+    - python-yaml
+    - gcc-6
+    - g++-6
+    - clang
+    - libc++-dev
+
+before_install:
+    # Set this to the name of the library
+    - PROJECT_TO_TEST=`basename $TRAVIS_BUILD_DIR`
+    # Cloning Boost libraries (fast nondeep cloning)
+    - BOOST=$HOME/boost-local
+    - echo "Testing $PROJECT_TO_TEST, to remove $BOOST/libs/$BOOST_REMOVE, testing branch $BRANCH_TO_TEST"
+    - git init $BOOST
+    - cd $BOOST
+    - git remote add --no-tags -t $BRANCH_TO_TEST origin https://github.com/boostorg/boost.git
+    - git fetch --depth=1
+    - git checkout $BRANCH_TO_TEST
+    - git submodule update --jobs=3 --init --merge
+    - git remote set-branches --add origin $BRANCH_TO_TEST
+    - git pull --recurse-submodules
+    - git status
+    - rm -rf $BOOST/libs/$BOOST_REMOVE
+    - mv $TRAVIS_BUILD_DIR $BOOST/libs/$PROJECT_TO_TEST
+    - TRAVIS_BUILD_DIR=$BOOST/libs/$PROJECT_TO_TEST
+    - ./bootstrap.sh
+    - ./b2 headers
+    - cd $BOOST/libs/$PROJECT_TO_TEST/test/
+
+script:
+    # `--coverage` flags required to generate coverage info for Coveralls
+    - ../../../b2 "testing.launcher=LD_PRELOAD=/usr/lib/x86_64-linux-gnu/libasan.so.3 " address-model=64 architecture=x86 toolset=$TOOLSET cxxflags="--coverage -fsanitize=address,leak,undefined -DBOOST_TRAVISCI_BUILD $CXX_FLAGS" linkflags="$LINK_FLAGS --coverage -lasan -lubsan"
+
+after_success:
+    # Copying Coveralls data to a separate folder
+    - mkdir -p $TRAVIS_BUILD_DIR/coverals
+    - find ../../../bin.v2/ -name "*.gcda" -exec cp "{}" $TRAVIS_BUILD_DIR/coverals/ \;
+    - find ../../../bin.v2/ -name "*.gcno" -exec cp "{}" $TRAVIS_BUILD_DIR/coverals/ \;
+    - find ../../../bin.v2/ -name "*.da" -exec cp "{}" $TRAVIS_BUILD_DIR/coverals/ \;
+    - find ../../../bin.v2/ -name "*.no" -exec cp "{}" $TRAVIS_BUILD_DIR/coverals/ \;
+    - wget https://github.com/linux-test-project/lcov/archive/v1.12.zip
+    - unzip v1.12.zip
+    - LCOV="`pwd`/lcov-1.12/bin/lcov --gcov-tool gcov-6"
+
+    # Preparing Coveralls data by changind data format to a readable one
+    - echo "$LCOV --directory $TRAVIS_BUILD_DIR/coverals --base-directory `pwd` --capture --output-file $TRAVIS_BUILD_DIR/coverals/coverage.info"
+    - $LCOV --directory $TRAVIS_BUILD_DIR/coverals --base-directory `pwd` --capture --output-file $TRAVIS_BUILD_DIR/coverals/coverage.info
+
+    # ... erasing /test/ /example/ folder data
+    - cd $BOOST
+    - $LCOV --remove $TRAVIS_BUILD_DIR/coverals/coverage.info "/usr*" "*/$PROJECT_TO_TEST/test/*" $IGNORE_COVERAGE "*/$PROJECT_TO_TEST/tests/*" "*/$PROJECT_TO_TEST/examples/*" "*/$PROJECT_TO_TEST/example/*" -o $TRAVIS_BUILD_DIR/coverals/coverage.info
+
+    # ... erasing data that is not related to this project directly
+    - OTHER_LIBS=`grep "submodule .*" .gitmodules | sed 's/\[submodule\ "\(.*\)"\]/"\*\/boost\/\1\.hpp" "\*\/boost\/\1\/\*"/g'| sed "/\"\*\/boost\/$PROJECT_TO_TEST\/\*\"/d" | sed ':a;N;$!ba;s/\n/ /g'`
+    - echo $OTHER_LIBS
+    - eval "$LCOV --remove $TRAVIS_BUILD_DIR/coverals/coverage.info $OTHER_LIBS -o $TRAVIS_BUILD_DIR/coverals/coverage.info"
+
+    # Sending data to Coveralls
+    - cd $TRAVIS_BUILD_DIR
+    - gem install coveralls-lcov
+    - coveralls-lcov coverals/coverage.info

README.md

@@ -0,0 +1,16 @@
+#[Boost.Conversion](http://boost.org/libs/conversion)
+Boost.Conversion is one of the [Boost C++ Libraries](http://github.com/boostorg). This library improves program safety and clarity by performing otherwise messy conversions. 
+
+### Test results
+
+@               | Build         | Tests coverage | More info
+----------------|-------------- | -------------- |-----------
+Develop branch: | [![Build Status](https://travis-ci.org/apolukhin/conversion.svg?branch=develop)](https://travis-ci.org/apolukhin/conversion) [![Build status](https://ci.appveyor.com/api/projects/status/yep84179w535pppg/branch/develop?svg=true)](https://ci.appveyor.com/project/apolukhin/conversion/branch/develop) | [![Coverage Status](https://coveralls.io/repos/apolukhin/conversion/badge.png?branch=develop)](https://coveralls.io/r/apolukhin/conversion?branch=develop) | [details...](http://www.boost.org/development/tests/develop/developer/conversion.html)
+Master branch:  | [![Build Status](https://travis-ci.org/apolukhin/conversion.svg?branch=master)](https://travis-ci.org/apolukhin/conversion) [![Build status](https://ci.appveyor.com/api/projects/status/yep84179w535pppg/branch/master?svg=true)](https://ci.appveyor.com/project/apolukhin/conversion/branch/master) | [![Coverage Status](https://coveralls.io/repos/apolukhin/conversion/badge.png?branch=master)](https://coveralls.io/r/apolukhin/conversion?branch=master) | [details...](http://www.boost.org/development/tests/master/developer/conversion.html)
+
+
+[Open Issues](https://svn.boost.org/trac/boost/query?status=!closed&component=conversion&or&status=!closed&component=lexical_cast)
+
+### License
+
+Distributed under the [Boost Software License, Version 1.0](http://boost.org/LICENSE_1_0.txt).

cast.htm

@@ -1,146 +0,0 @@
-<!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/polymorphic_cast.hpp Documentation</title>
-    <style>
-       .copyright
-        {
-            color: #666666;
-            font-size: small;
-        }
-    </style>
-  </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/polymorphic_cast.hpp">boost/polymorphic_cast.hpp</a></h1>
-
-    <h2><a name="Cast Functions">Cast Functions</a></h2>
-
-    <p>The header <a href="../../boost/polymorphic_cast.hpp">boost/polymorphic_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="test/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/polymorphic_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 class="copyright">&copy; Copyright boost.org 1999. 
-    Distributed under the Boost Software License, Version 1.0. (See accompanying
-    file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</a>)
-    </p>
-  </body>
-</html>

doc/Jamfile.v2

@@ -0,0 +1,38 @@
+#   Copyright (c) 2016 Mikhail Maximov <vigorous.activity -at- gmail.com>
+
+#   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)
+
+project doc/conversion ;
+
+using quickbook ;
+import boostbook ;
+
+xml conversion : conversion.qbk ;
+boostbook standalone
+    :
+        conversion
+    :
+        <xsl:param>boost.root=../../../..
+        # File name of HTML output:
+        <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 ;

doc/conversion.qbk

@@ -0,0 +1,197 @@
+[/
+    Copyright 2016 Mikhail Maximov.
+    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.6]
+    [authors [Stroustrup, Bjarne], [Abrahams, Dave], [Rasin, Boris], [Polukhin, Antony]]
+    [copyright 2001 Beman Dawes]
+    [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 teletype]
+]
+
+[/ 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, particularly to standard library IOStreams, 
+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).
+# The [@boost:boost/lexical_cast.hpp boost/lexical_cast.hpp] header 
+  provides [@boost:libs/lexical_cast/doc/html/index.html `lexical_cast<>`] general literal text conversions, such as an `int` represented as a `string`, or vice-versa. 
+
+[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]
+
+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]
+
+[#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.
+
+[#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.
+
+[endsect]
+[section `polymorphic_cast`, `polymorphic_downcast`, `polymorphic_pointer_cast` and `polymorphic_pointer_downcast` synopsis]
+```
+	namespace boost {
+
+	template <class Derived, class Base>
+	inline Derived polymorphic_cast(Base* x);
+	// Throws: std::bad_cast if ( dynamic_cast<Derived>(x) == 0 )
+	// Returns: dynamic_cast<Derived>(x)
+
+	template <class Derived, class Base>
+	inline Derived polymorphic_downcast(Base* x);
+	// Effects: assert( dynamic_cast<Derived>(x) == x );
+	// Returns: static_cast<Derived>(x)
+
+	template <class Derived, class Base>
+	inline auto polymorphic_pointer_cast(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_downcast(Base x);
+	// Effects: assert( dynamic_pointer_cast<Derived>(x) == x );
+	// Returns: static_pointer_cast<Derived>(x)
+
+	}
+```
+[endsect]
+[section `polymorphic_downcast` 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]
+[section `polymorphic_pointer_downcast` example]
+```
+	#include <boost/polymorphic_pointer_cast.hpp>
+
+	class Fruit { public: virtual ~Fruit(){} };
+	class Banana : public Fruit {};
+
+	// use one of these:
+
+	typedef Fruit* FruitPtr;
+	typedef std::shared_ptr<Fruit> FruitPtr;
+	typedef boost::shared_ptr<Fruit> FruitPtr;
+	typedef boost::intrusive_ptr<Fruit> FruitPtr;
+
+	void f(FruitPtr fruit) {
+	  // ... logic which leads us to believe it is a banana
+	  auto banana = boost::polymorphic_pointer_downcast<Banana>(fruit);
+	  ...
+	}
+```
+[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.
+
+An old numeric_cast that was contributed by [@http://www.boost.org/people/kevlin_henney.htm Kevlin Henney]
+is now superseeded by the [@boost:numeric_conversion/doc/html/html/boost_numericconversion/improved_numeric_cast__.html Boost Numeric Conversion Library]
+[endsect]

include/boost/polymorphic_cast.hpp

@@ -1,6 +1,7 @@
 //  boost polymorphic_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)
@@ -8,6 +9,9 @@
 //  See http://www.boost.org/libs/conversion for Documentation.
 
 //  Revision History
+//  10 Nov 14  polymorphic_pointer_downcast moved to a separate header,
+//             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 verion (Fernando Cacciola)
@@ -47,8 +51,13 @@
 
 # include <boost/config.hpp>
 # include <boost/assert.hpp>
+# include <boost/throw_exception.hpp>
 # include <typeinfo>
 
+#ifdef BOOST_HAS_PRAGMA_ONCE
+#   pragma once
+#endif
+
 namespace boost
 {
 //  See the documentation for descriptions of how to choose between
@@ -64,7 +73,7 @@ namespace boost
     inline Target polymorphic_cast(Source* x)
     {
         Target tmp = dynamic_cast<Target>(x);
-        if ( tmp == 0 ) throw std::bad_cast();
+        if ( tmp == 0 ) boost::throw_exception( std::bad_cast() );
         return tmp;
     }
 

include/boost/polymorphic_pointer_cast.hpp

@@ -0,0 +1,78 @@
+//  boost polymorphic_pointer_cast.hpp header file  ----------------------------------------------//
+//  (C) Copyright Boris Rasin and Antony Polukhin 2014-2015.
+//  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>
+# include <boost/assert.hpp>
+# include <boost/pointer_cast.hpp>
+# include <boost/throw_exception.hpp>
+# include <boost/utility/declval.hpp>
+# ifdef BOOST_NO_CXX11_DECLTYPE
+#   include <boost/typeof/typeof.hpp>
+# endif
+
+#ifdef BOOST_HAS_PRAGMA_ONCE
+#   pragma once
+#endif
+
+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
+
+    namespace detail
+    {
+        template <typename Target, typename Source>
+        struct dynamic_pointer_cast_result
+        {
+#ifdef BOOST_NO_CXX11_DECLTYPE
+            BOOST_TYPEOF_NESTED_TYPEDEF_TPL(nested, dynamic_pointer_cast<Target>(boost::declval<Source>()))
+            typedef typename nested::type type;
+#else
+            typedef decltype(dynamic_pointer_cast<Target>(boost::declval<Source>())) type;
+#endif
+        };
+    }
+
+    template <typename Target, typename Source>
+    inline typename detail::dynamic_pointer_cast_result<Target, Source>::type
+    polymorphic_pointer_downcast (const Source& x)
+    {
+        BOOST_ASSERT(dynamic_pointer_cast<Target> (x) == x);
+        return static_pointer_cast<Target> (x);
+    }
+
+    template <typename Target, typename Source>
+    inline typename detail::dynamic_pointer_cast_result<Target, Source>::type
+    polymorphic_pointer_cast (const Source& x)
+    {
+        typename detail::dynamic_pointer_cast_result<Target, Source>::type 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

index.html

@@ -1,49 +1,35 @@
+<!DOCTYPE html>
+<!--
+ Copyright (c) 2016 Mikhail Maximov
+ vigorous.activity at gmail dot com
+ 
+ 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)
+-->
 <html>
-
 <head>
-<meta http-equiv="Content-Language" content="en-us">
-<meta http-equiv="Content-Type" content="text/html; charset=windows-1252">
-<meta name="GENERATOR" content="Microsoft FrontPage 5.0">
-<meta name="ProgId" content="FrontPage.Editor.Document">
-<title>Boost Conversion Library</title>
+<meta charset="utf-8">
+<meta http-equiv="refresh" content="0; url=../../doc/html/conversion.html">
+<title>Boost.Conversion</title>
 <style>
-   .copyright
-    {
-        color: #666666;
-        font-size: small;
-    }
+  body {
+    background: #fff;
+    color: #000;
+  }
+  a {
+    color: #00f;
+    text-decoration: none;
+  }
 </style>
 </head>
-
-<body bgcolor="#FFFFFF" text="#000000">
-
-<h1><img border="0" src="../../boost.png" align="center" width="277" height="86">Boost
-Conversion Library</h1>
-
-<p>The Conversion Library improves program safety and clarity by performing
-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>
-<p class="copyright">
-    Copyright 2001 Beman Dawes.
-    Distributed under the Boost Software License, Version 1.0. (See accompanying
-    file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</a>)
-</p>
+<body>
+  <p>
+    Automatic redirection failed, please go to
+    <a href="../../doc/html/conversion.html">../../doc/html/conversion.html</a>
+  </p>
+  <p>
+    &copy; 2014 Antony Polukhin
+  </p>
 </body>
-
-</html>
+</html>

test/appveyor.yml

@@ -0,0 +1,64 @@
+# 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-2017.
+
+#
+# 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 #3
+
+init:
+    - set BRANCH_TO_TEST=%APPVEYOR_REPO_BRANCH%  # Change to branch you wish to test. Use %APPVEYOR_REPO_BRANCH% for current branch.
+    - set BOOST_REMOVE=conversion                # Remove this folder from lib from full clone of Boost. If you are testing `any` repo, write here `any`.
+
+###############################################################################################################
+# From this point and below code is same for all the Boost libs
+###############################################################################################################
+
+version: 1.64.{build}-{branch}
+ 
+# branches to build
+branches:
+  except:
+    - gh-pages
+
+skip_tags: true
+
+before_build:
+    - set PATH=%PATH%;C:\\MinGW\\bin
+    # Set this to the name of the library
+    - set PROJECT_TO_TEST=%APPVEYOR_PROJECT_NAME%
+    - echo "Testing %PROJECT_TO_TEST%"
+    # Cloning Boost libraries (fast nondeep cloning)
+    - set BOOST=C:/boost-local
+    - git init %BOOST%
+    - cd %BOOST%
+    - git remote add --no-tags -t %BRANCH_TO_TEST% origin https://github.com/boostorg/boost.git
+    - git fetch --depth=1
+    - git checkout %BRANCH_TO_TEST%
+    - git submodule update --init --merge
+    - git remote set-branches --add origin %BRANCH_TO_TEST%
+    - git pull --recurse-submodules
+    - git status
+    - rm -rf %BOOST%/libs/%BOOST_REMOVE%
+    - mv %APPVEYOR_BUILD_FOLDER% %BOOST%/libs/%PROJECT_TO_TEST%
+    - set TRAVIS_BUILD_DIR=%BOOST%/libs/%PROJECT_TO_TEST%
+
+build_script:
+    - call "C:\Program Files (x86)\Microsoft Visual Studio 14.0\VC\vcvarsall.bat" x64
+    - bootstrap.bat
+    - b2.exe headers
+    - cd %BOOST%/libs/%PROJECT_TO_TEST%/test
+
+after_build:
+before_test:
+test_script:
+    - ..\..\..\b2.exe address-model=32 architecture=x86 toolset=msvc,gcc cxxflags="-DBOOST_TRAVISCI_BUILD" -sBOOST_BUILD_PATH=.
+
+after_test:
+on_success:
+on_failure:
+on_finish:

test/cast_test.cpp

@@ -15,6 +15,7 @@
 
 #include <iostream>
 #include <boost/polymorphic_cast.hpp>
+#include <boost/core/lightweight_test.hpp>
 
 using namespace boost;
 using std::cout;
@@ -51,22 +52,20 @@ int main( int argc, char * argv[] )
 //  test polymorphic_cast  ---------------------------------------------------//
 
     //  tests which should succeed
-    Base *    base = new Derived;
-    Base2 *   base2 = 0;
-    Derived * derived = 0;
-    derived = polymorphic_downcast<Derived*>( base );  // downcast
-    assert( derived->kind() == 'D' );
+    Derived derived_instance;
+    Base * base = &derived_instance;
+    Derived * derived = polymorphic_downcast<Derived*>( base );  // downcast
+    BOOST_TEST( derived->kind() == 'D' );
 
-    derived = 0;
     derived = polymorphic_cast<Derived*>( base ); // downcast, throw on error
-    assert( derived->kind() == 'D' );
+    BOOST_TEST( derived->kind() == 'D' );
 
-    base2 = polymorphic_cast<Base2*>( base ); // crosscast
-    assert( base2->kind2() == '2' );
+    Base2 *   base2 =  polymorphic_cast<Base2*>( base ); // crosscast
+    BOOST_TEST( base2->kind2() == '2' );
 
      //  tests which should result in errors being detected
-    int err_count = 0;
-    base = new Base;
+    Base base_instance;
+    base = &base_instance;
 
     if ( argc > 1 && *argv[1] == '1' )
         { derived = polymorphic_downcast<Derived*>( base ); } // #1 assert failure
@@ -75,11 +74,9 @@ int main( int argc, char * argv[] )
     try { derived = polymorphic_cast<Derived*>( base ); }
     catch (std::bad_cast)
         { cout<<"caught bad_cast\n"; caught_exception = true; }
-    if ( !caught_exception ) ++err_count;
+    BOOST_TEST( caught_exception );
     //  the following is just so generated code can be inspected
-    if ( derived->kind() == 'B' ) ++err_count;
+    BOOST_TEST( derived->kind() != 'B' );
 
-    cout << err_count << " errors detected\nTest "
-         << (err_count==0 ? "passed\n" : "failed\n");
-    return err_count;
+    return boost::report_errors();
 }   // main

test/implicit_cast.cpp

@@ -29,7 +29,7 @@ int main()
     type<foo> f = check_return(boost::implicit_cast<foo>("hello"));
     type<long> z = check_return(boost::implicit_cast<long>(foo("hello")));
 
-    // warning supression:
+    // warning suppression:
     (void)x;
     (void)f;
     (void)z;

test/polymorphic_cast_test.cpp

@@ -1,9 +1,11 @@
 //
-// Test boost::polymorphic_cast, boost::polymorphic_downcast
+// 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
 //
 // Distributed under the Boost Software License, Version 1.0.
 //
@@ -12,18 +14,28 @@
 
 #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
     {
@@ -37,7 +49,7 @@ void boost::assertion_failed( char const * expr, char const * function, char con
 
 //
 
-struct Base
+struct Base : boost::intrusive_ref_counter<Base>
 {
     virtual ~Base() {}
     virtual std::string kind() { return "Base"; }
@@ -97,6 +109,67 @@ static void test_polymorphic_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 = new Derived;
@@ -115,6 +188,70 @@ static void test_polymorphic_downcast()
     delete base;
 }
 
+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" );
+    }
+}
+
+#ifndef BOOST_NO_CXX11_SMART_PTR
+
+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" );
+    }
+}
+
+#endif
+
 static void test_polymorphic_cast_fail()
 {
     Base * base = new Base;
@@ -124,6 +261,21 @@ static void test_polymorphic_cast_fail()
     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 );
+
+#ifndef BOOST_NO_CXX11_SMART_PTR
+    BOOST_TEST_THROWS( boost::polymorphic_pointer_cast<Derived>( std::shared_ptr<Base>(new Base) ), std::bad_cast );
+#endif
+
+    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 = new Base;
@@ -131,7 +283,7 @@ static void test_polymorphic_downcast_fail()
     int old_count = assertion_failed_count;
     expect_assertion = true;
 
-    boost::polymorphic_downcast<Derived*>( base ); // should assert
+    BOOST_TEST_THROWS( boost::polymorphic_downcast<Derived*>( base ), expected_assertion ); // should assert
 
     BOOST_TEST_EQ( assertion_failed_count, old_count + 1 );
     expect_assertion = false;
@@ -139,12 +291,83 @@ static void test_polymorphic_downcast_fail()
     delete base;
 }
 
+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;
+}
+
+#ifndef BOOST_NO_CXX11_SMART_PTR
+
+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;
+}
+
+#endif
+
+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();
+
+#ifndef BOOST_NO_CXX11_SMART_PTR
+    test_polymorphic_pointer_downcast_std_shared();
+    test_polymorphic_pointer_downcast_std_shared_fail();
+#endif
 
     return boost::report_errors();
 }