Release 1.44.0

[SVN r64846]

.travis.yml

@@ -1,274 +0,0 @@
-# Copyright 2016 Peter Dimov
-# 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)
-
-language: cpp
-
-sudo: false
-
-os:
-  - linux
-  - osx
-
-branches:
-  only:
-    - master
-    - develop
-
-env:
-  matrix:
-    - BOGUS_JOB=true
-
-matrix:
-
-  exclude:
-    - env: BOGUS_JOB=true
-
-  include:
-    - os: linux
-      env: TOOLSET=gcc COMPILER=g++ CXXSTD=c++03
-
-    - os: linux
-      env: TOOLSET=gcc COMPILER=g++-4.7 CXXSTD=c++03
-      addons:
-        apt:
-          packages:
-            - g++-4.7
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      env: TOOLSET=gcc COMPILER=g++-4.7 CXXSTD=c++11
-      addons:
-        apt:
-          packages:
-            - g++-4.7
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      env: TOOLSET=gcc COMPILER=g++-4.8 CXXSTD=c++03
-      addons:
-        apt:
-          packages:
-            - g++-4.8
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      env: TOOLSET=gcc COMPILER=g++-4.8 CXXSTD=c++11
-      addons:
-        apt:
-          packages:
-            - g++-4.8
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      env: TOOLSET=gcc COMPILER=g++-4.9 CXXSTD=c++03
-      addons:
-        apt:
-          packages:
-            - g++-4.9
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      env: TOOLSET=gcc COMPILER=g++-4.9 CXXSTD=c++11
-      addons:
-        apt:
-          packages:
-            - g++-4.9
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      env: TOOLSET=gcc COMPILER=g++-5 CXXSTD=c++03
-      addons:
-        apt:
-          packages:
-            - g++-5
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      env: TOOLSET=gcc COMPILER=g++-5 CXXSTD=c++11
-      addons:
-        apt:
-          packages:
-            - g++-5
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      env: TOOLSET=gcc COMPILER=g++-5 CXXSTD=c++14
-      addons:
-        apt:
-          packages:
-            - g++-5
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      env: TOOLSET=gcc COMPILER=g++-6 CXXSTD=c++03
-      addons:
-        apt:
-          packages:
-            - g++-6
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      env: TOOLSET=gcc COMPILER=g++-6 CXXSTD=c++11
-      addons:
-        apt:
-          packages:
-            - g++-6
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      env: TOOLSET=gcc COMPILER=g++-6 CXXSTD=c++14
-      addons:
-        apt:
-          packages:
-            - g++-6
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      env: TOOLSET=gcc COMPILER=g++-6 CXXSTD=c++1z
-      addons:
-        apt:
-          packages:
-            - g++-6
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      env: TOOLSET=clang COMPILER=clang++ CXXSTD=c++03
-
-    - os: linux
-      env: TOOLSET=clang COMPILER=clang++ CXXSTD=c++11
-
-    - os: linux
-      env: TOOLSET=clang COMPILER=clang++-3.6 CXXSTD=c++03
-      addons:
-        apt:
-          packages:
-            - clang-3.6
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-precise-3.6
-
-    - os: linux
-      env: TOOLSET=clang COMPILER=clang++-3.6 CXXSTD=c++11
-      addons:
-        apt:
-          packages:
-            - clang-3.6
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-precise-3.6
-
-    - os: linux
-      env: TOOLSET=clang COMPILER=clang++-3.7 CXXSTD=c++03
-      addons:
-        apt:
-          packages:
-            - clang-3.7
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-precise-3.7
-
-    - os: linux
-      env: TOOLSET=clang COMPILER=clang++-3.7 CXXSTD=c++11
-      addons:
-        apt:
-          packages:
-            - clang-3.7
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-precise-3.7
-
-    - os: linux
-      env: TOOLSET=clang COMPILER=clang++-3.8 CXXSTD=c++03
-      addons:
-        apt:
-          packages:
-            - clang-3.8
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-precise-3.8
-
-    - os: linux
-      env: TOOLSET=clang COMPILER=clang++-3.8 CXXSTD=c++11
-      addons:
-        apt:
-          packages:
-            - clang-3.8
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-precise-3.8
-
-    - os: linux
-      env: TOOLSET=clang COMPILER=clang++-3.8 CXXSTD=c++14
-      addons:
-        apt:
-          packages:
-            - clang-3.8
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-precise-3.8
-
-    - os: linux
-      env: TOOLSET=clang COMPILER=clang++-3.8 CXXSTD=c++1z
-      addons:
-        apt:
-          packages:
-            - clang-3.8
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-precise-3.8
-
-    - os: osx
-      env: TOOLSET=clang COMPILER=clang++ CXXSTD=c++03
-
-    - os: osx
-      env: TOOLSET=clang COMPILER=clang++ CXXSTD=c++11
-
-    - os: osx
-      env: TOOLSET=clang COMPILER=clang++ CXXSTD=c++14
-
-install:
-  - cd ..
-  - git clone -b $TRAVIS_BRANCH https://github.com/boostorg/boost.git boost-root
-  - cd boost-root
-  - git submodule init libs/align
-  - git submodule init libs/assert
-  - git submodule init libs/atomic
-  - git submodule init libs/config
-  - git submodule init libs/core
-  - git submodule init libs/detail
-  - git submodule init libs/functional
-  - git submodule init libs/integer
-  - git submodule init libs/move
-  - git submodule init libs/predef
-  - git submodule init libs/preprocessor
-  - git submodule init libs/static_assert
-  - git submodule init libs/throw_exception
-  - git submodule init libs/type_traits
-  - git submodule init tools/build
-  - git submodule update
-  - cp -r $TRAVIS_BUILD_DIR/* libs/smart_ptr
-  - ./bootstrap.sh
-  - ./b2 headers
-
-script:
-  - |-
-    echo "using $TOOLSET : : $COMPILER : <cxxflags>-std=$CXXSTD ;" > ~/user-config.jam
-  - ./b2 libs/smart_ptr/test toolset=$TOOLSET
-
-notifications:
-  email:
-    on_success: always

README.md

@@ -1,6 +0,0 @@
-# Boost.SmartPtr
-
-Branch   | Travis | Appveyor
----------|--------|---------
-Develop  | [![Build Status](https://travis-ci.org/boostorg/smart_ptr.svg?branch=develop)](https://travis-ci.org/boostorg/smart_ptr) | [![Build Status](https://ci.appveyor.com/api/projects/status/github/boostorg/smart_ptr?branch=develop&svg=true)](https://ci.appveyor.com/project/pdimov/smart_ptr)
-Master   | [![Build Status](https://travis-ci.org/boostorg/smart_ptr.svg?branch=master)](https://travis-ci.org/boostorg/smart_ptr) | [![Build Status](https://ci.appveyor.com/api/projects/status/github/boostorg/smart_ptr?branch=master&svg=true)](https://ci.appveyor.com/project/pdimov/smart_ptr)

appveyor.yml

@@ -1,41 +0,0 @@
-# Copyright 2016 Peter Dimov
-# 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)
-
-version: 1.0.{build}-{branch}
-
-shallow_clone: true
-
-branches:
-  only:
-    - master
-    - develop
-
-install:
-  - cd ..
-  - git clone -b %APPVEYOR_REPO_BRANCH% https://github.com/boostorg/boost.git boost-root
-  - cd boost-root
-  - git submodule init libs/align
-  - git submodule init libs/assert
-  - git submodule init libs/atomic
-  - git submodule init libs/config
-  - git submodule init libs/core
-  - git submodule init libs/detail
-  - git submodule init libs/functional
-  - git submodule init libs/integer
-  - git submodule init libs/move
-  - git submodule init libs/predef
-  - git submodule init libs/preprocessor
-  - git submodule init libs/static_assert
-  - git submodule init libs/throw_exception
-  - git submodule init libs/type_traits
-  - git submodule init tools/build
-  - git submodule update
-  - xcopy /s /e /q %APPVEYOR_BUILD_FOLDER% libs\smart_ptr
-  - bootstrap
-  - b2 headers
-
-build: off
-
-test_script:
-  - b2 libs/smart_ptr/test toolset=msvc-9.0,msvc-10.0,msvc-11.0,msvc-14.0

compatibility.htm

@@ -1,12 +1,12 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 <html>
 	<head>
 		<title>Smart Pointer Changes</title>
 		<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
 	</head>
-    <body text="#000000" bgcolor="#ffffff" link="#0000ff" vlink="#0000ff">
-        <h1><img height="86" alt="boost.png (6897 bytes)" src="../../boost.png" 
-            width="277" align="middle" border="0">Smart Pointer Changes</h1>
+	<body bgcolor="#ffffff" text="#000000">
+		<h1><A href="../../index.htm"><img src="../../boost.png" alt="boost.png (6897 bytes)" align="middle" width="277" height="86"
+					border="0"></A>Smart Pointer Changes</h1>
 		<p>The February 2002 change to the Boost smart pointers introduced a number of 
 			changes. Since the previous version of the smart pointers was in use for a long 
 			time, it's useful to have a detailed list of what changed from a library user's 
@@ -80,7 +80,7 @@
 				violate the C++ standard.</li>
 		</ul>
 		<hr>
-        <p>$Date$</p>
+		<p>Revised 1 February 2002</p>
 		<p><small>Copyright 2002 Darin Adler. Distributed under the Boost Software License, Version 
 				1.0. See accompanying file <A href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</A> or 
 				copy at <A href="http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</A>.</small></p>

enable_shared_from_this.html

@@ -1,27 +1,33 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
 <html>
 	<head>
-        <title>enable_shared_from_this</title>
-        <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
+		<title>Boost: enable_shared_from_this.hpp documentation</title>
+		<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
 	</head>
-    <body text="#000000" bgcolor="#ffffff" link="#0000ff" vlink="#0000ff">
-        <h1><img height="86" alt="boost.png (6897 bytes)" src="../../boost.png"
-            width="277" align="middle" border="0" />enable_shared_from_this</h1>
-        <h2><a name="Purpose">Purpose</a></h2>
+	<body bgcolor="white" style="MARGIN-LEFT: 5%; MARGIN-RIGHT: 5%">
+		<table border="0" width="100%">
+			<tr>
+				<td width="277"><A href="../../index.htm"> <img src="../../boost.png" alt="boost.png (6897 bytes)" width="277" height="86" border="0"></A>
+				</td>
+				<td align="center">
+					<h1>enable_shared_from_this.hpp</h1>
+				</td>
+			</tr>
+			<tr>
+				<td colspan="2" height="64">&nbsp;</td>
+			</tr>
+		</table>
+		<h3><a name="Purpose">Purpose</a></h3>
 		<p>
-            The header <code>&lt;boost/enable_shared_from_this.hpp&gt;</code> defines
-            the class template <code>enable_shared_from_this</code>. It is used as a
-            base class that allows a <a href="shared_ptr.htm">shared_ptr</a> or
-            a <a href="weak_ptr.htm">weak_ptr</a> to the current object to be obtained
-            from within a member function.
+			The header <STRONG>&lt;boost/enable_shared_from_this.hpp&gt;</STRONG> defines 
+			the class template <STRONG>enable_shared_from_this</STRONG>. It is used as a 
+			base class that allows a <A href="shared_ptr.htm">shared_ptr</A> to the current 
+			object to be obtained from within a member function.
 		</p>
-        <p><code>enable_shared_from_this&lt;T&gt;</code> defines two member functions
-            called <code>shared_from_this</code> that return a <code>shared_ptr&lt;T&gt;</code>
-            and <code>shared_ptr&lt;T const&gt;</code>, depending on constness, to <code>this</code>.
-            It also defines two member functions called <code>weak_from_this</code> that return
-            a corresponding <code>weak_ptr</code>.
-        </p>
-        <h2><a name="Example">Example</a></h2>
+		<P><STRONG>enable_shared_from_this&lt;T&gt;</STRONG> defines two member functions 
+			called <STRONG>shared_from_this</STRONG> that return a <STRONG>shared_ptr&lt;T&gt;</STRONG>
+			and <STRONG>shared_ptr&lt;T const&gt;</STRONG>, depending on constness, to <STRONG>this</STRONG>.</P>
+		<h3><a name="Example">Example</a></h3>
 		<pre>
 #include &lt;boost/enable_shared_from_this.hpp&gt;
 #include &lt;boost/shared_ptr.hpp&gt;
@@ -45,7 +51,7 @@ int main()
     assert(!(p &lt; q || q &lt; p)); // p and q must share ownership
 }
 </pre>
-        <h2><a name="Synopsis">Synopsis</a></h2>
+		<h3><a name="Synopsis">Synopsis</a></h3>
 		<pre>
 namespace boost
 {
@@ -56,55 +62,34 @@ public:
 
     shared_ptr&lt;T&gt; shared_from_this();
     shared_ptr&lt;T const&gt; shared_from_this() const;
-
-    weak_ptr&lt;T&gt; weak_from_this() noexcept;
-    weak_ptr&lt;T const&gt; weak_from_this() const noexcept;
 }
 
 }
 </pre>
-        <h4><code>template&lt;class T&gt; shared_ptr&lt;T&gt;
-            enable_shared_from_this&lt;T&gt;::shared_from_this();</code></h4>
-        <h4><code>template&lt;class T&gt; shared_ptr&lt;T const&gt;
-            enable_shared_from_this&lt;T&gt;::shared_from_this() const;</code></h4>
+		<h4>template&lt;class T&gt; shared_ptr&lt;T&gt; 
+			enable_shared_from_this&lt;T&gt;::shared_from_this();</h4>
+		<h4>template&lt;class T&gt; shared_ptr&lt;T const&gt; 
+			enable_shared_from_this&lt;T&gt;::shared_from_this() const;</h4>
 		<blockquote>
 			<p>
-                <b>Requires:</b> <code>enable_shared_from_this&lt;T&gt;</code> must be an 
-                accessible base class of <code>T</code>. <code>*this</code> must be a subobject 
-                of an instance <code>t</code> of type <code>T</code>.
+				<b>Requires:</b> <STRONG>enable_shared_from_this&lt;T&gt;</STRONG> must be an 
+				accessible base class of <b>T</b>. <STRONG>*this</STRONG> must be a subobject 
+				of an instance <STRONG>t</STRONG> of type <STRONG>T</STRONG> . There must exist 
+				at least one <STRONG>shared_ptr</STRONG> instance <STRONG>p</STRONG> that <EM>owns</EM>
+				<STRONG>t</STRONG>.
 			</p>
 			<p>
-                <b>Returns:</b> If a <code>shared_ptr</code> instance <code>p</code> that <em>owns</em>
-                <code>t</code> exists, a <code>shared_ptr&lt;T&gt;</code> instance <code>r</code> that shares 
-                ownership with <code>p</code>.
+				<b>Returns:</b> A <b>shared_ptr&lt;T&gt;</b> instance <b>r</b> that shares 
+				ownership with <b>p</b>.
 			</p>
 			<p>
-                <b>Postconditions:</b> <code>r.get() == this</code>.
-            </p>
-            <p>
-                <b>Throws:</b> <code>bad_weak_ptr</code> when no <code>shared_ptr</code> <em>owns</em> <code>*this</code>.
+				<b>Postconditions:</b> <tt>r.get() == this</tt>.
 			</p>
 		</blockquote>
-        <h4><code>template&lt;class T&gt; weak_ptr&lt;T&gt;
-            enable_shared_from_this&lt;T&gt;::weak_from_this() noexcept;</code></h4>
-        <h4><code>template&lt;class T&gt; weak_ptr&lt;T const&gt;
-            enable_shared_from_this&lt;T&gt;::weak_from_this() const noexcept;</code></h4>
-        <blockquote>
 		<p>
-                <b>Requires:</b> <code>enable_shared_from_this&lt;T&gt;</code> must be an 
-                accessible base class of <code>T</code>. <code>*this</code> must be a subobject 
-                of an instance <code>t</code> of type <code>T</code>.
-            </p>
-            <p>
-                <b>Returns:</b> If a <code>shared_ptr</code> instance <code>p</code> that <em>owns</em>
-                <code>t</code> exists or has existed in the past, a <code>weak_ptr&lt;T&gt;</code> instance
-                <code>r</code> that shares ownership with <code>p</code>. Otherwise, an empty <code>weak_ptr</code>.
-            </p>
-        </blockquote>
-        <hr />
-        <p>
-            <small>Copyright &copy; 2002, 2003, 2015 by Peter Dimov. Distributed under the Boost Software License, Version 
-                1.0. See accompanying file <a href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or 
-                copy at <a href="http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</a>.</small></p>
+			<br>
+			<small>Copyright <20> 2002, 2003 by Peter Dimov. Distributed under the Boost Software License, Version 
+				1.0. See accompanying file <A href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</A> or 
+				copy at <A href="http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</A>.</small></p>
 	</body>
 </html>

include/boost/detail/lightweight_thread.hpp

@@ -1,135 +0,0 @@
-#ifndef BOOST_DETAIL_LIGHTWEIGHT_THREAD_HPP_INCLUDED
-#define BOOST_DETAIL_LIGHTWEIGHT_THREAD_HPP_INCLUDED
-
-// MS compatible compilers support #pragma once
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-//  boost/detail/lightweight_thread.hpp
-//
-//  Copyright (c) 2002 Peter Dimov and Multi Media Ltd.
-//  Copyright (c) 2008 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/config.hpp>
-#include <memory>
-#include <cerrno>
-
-// pthread_create, pthread_join
-
-#if defined( BOOST_HAS_PTHREADS )
-
-#include <pthread.h>
-
-#else
-
-#include <windows.h>
-#include <process.h>
-
-typedef HANDLE pthread_t;
-
-int pthread_create( pthread_t * thread, void const *, unsigned (__stdcall * start_routine) (void*), void* arg )
-{
-    HANDLE h = (HANDLE)_beginthreadex( 0, 0, start_routine, arg, 0, 0 );
-
-    if( h != 0 )
-    {
-        *thread = h;
-        return 0;
-    }
-    else
-    {
-        return EAGAIN;
-    }
-}
-
-int pthread_join( pthread_t thread, void ** /*value_ptr*/ )
-{
-    ::WaitForSingleObject( thread, INFINITE );
-    ::CloseHandle( thread );
-    return 0;
-}
-
-#endif
-
-// template<class F> int lw_thread_create( pthread_t & pt, F f );
-
-namespace boost
-{
-
-namespace detail
-{
-
-class lw_abstract_thread
-{
-public:
-
-    virtual ~lw_abstract_thread() {}
-    virtual void run() = 0;
-};
-
-#if defined( BOOST_HAS_PTHREADS )
-
-extern "C" void * lw_thread_routine( void * pv )
-{
-    std::auto_ptr<lw_abstract_thread> pt( static_cast<lw_abstract_thread *>( pv ) );
-
-    pt->run();
-
-    return 0;
-}
-
-#else
-
-unsigned __stdcall lw_thread_routine( void * pv )
-{
-    std::auto_ptr<lw_abstract_thread> pt( static_cast<lw_abstract_thread *>( pv ) );
-
-    pt->run();
-
-    return 0;
-}
-
-#endif
-
-template<class F> class lw_thread_impl: public lw_abstract_thread
-{
-public:
-
-    explicit lw_thread_impl( F f ): f_( f )
-    {
-    }
-
-    void run()
-    {
-        f_();
-    }
-
-private:
-
-    F f_;
-};
-
-template<class F> int lw_thread_create( pthread_t & pt, F f )
-{
-    std::auto_ptr<lw_abstract_thread> p( new lw_thread_impl<F>( f ) );
-
-    int r = pthread_create( &pt, 0, lw_thread_routine, p.get() );
-
-    if( r == 0 )
-    {
-        p.release();
-    }
-
-    return r;
-}
-
-} // namespace detail
-} // namespace boost
-
-#endif // #ifndef BOOST_DETAIL_LIGHTWEIGHT_THREAD_HPP_INCLUDED

include/boost/detail/quick_allocator.hpp

@@ -1,23 +0,0 @@
-#ifndef BOOST_DETAIL_QUICK_ALLOCATOR_HPP_INCLUDED
-#define BOOST_DETAIL_QUICK_ALLOCATOR_HPP_INCLUDED
-
-// MS compatible compilers support #pragma once
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-//
-//  detail/quick_allocator.hpp
-//
-//  Copyright (c) 2003 David Abrahams
-//  Copyright (c) 2003 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/smart_ptr/detail/quick_allocator.hpp>
-
-#endif  // #ifndef BOOST_DETAIL_QUICK_ALLOCATOR_HPP_INCLUDED

include/boost/detail/sp_typeinfo.hpp

@@ -0,0 +1,129 @@
+#ifndef BOOST_DETAIL_SP_TYPEINFO_HPP_INCLUDED
+#define BOOST_DETAIL_SP_TYPEINFO_HPP_INCLUDED
+
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+//  detail/sp_typeinfo.hpp
+//
+//  Copyright 2007 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/config.hpp>
+
+#if defined( BOOST_NO_TYPEID )
+
+#include <boost/current_function.hpp>
+#include <functional>
+
+namespace boost
+{
+
+namespace detail
+{
+
+class sp_typeinfo
+{
+private:
+
+    sp_typeinfo( sp_typeinfo const& );
+    sp_typeinfo& operator=( sp_typeinfo const& );
+
+    char const * name_;
+
+public:
+
+    explicit sp_typeinfo( char const * name ): name_( name )
+    {
+    }
+
+    bool operator==( sp_typeinfo const& rhs ) const
+    {
+        return this == &rhs;
+    }
+
+    bool operator!=( sp_typeinfo const& rhs ) const
+    {
+        return this != &rhs;
+    }
+
+    bool before( sp_typeinfo const& rhs ) const
+    {
+        return std::less< sp_typeinfo const* >()( this, &rhs );
+    }
+
+    char const* name() const
+    {
+        return name_;
+    }
+};
+
+template<class T> struct sp_typeid_
+{
+    static sp_typeinfo ti_;
+
+    static char const * name()
+    {
+        return BOOST_CURRENT_FUNCTION;
+    }
+};
+
+template<class T> sp_typeinfo sp_typeid_< T >::ti_ = sp_typeid_< T >::name();
+
+template<class T> struct sp_typeid_< T & >: sp_typeid_< T >
+{
+};
+
+template<class T> struct sp_typeid_< T const >: sp_typeid_< T >
+{
+};
+
+template<class T> struct sp_typeid_< T volatile >: sp_typeid_< T >
+{
+};
+
+template<class T> struct sp_typeid_< T const volatile >: sp_typeid_< T >
+{
+};
+
+} // namespace detail
+
+} // namespace boost
+
+#define BOOST_SP_TYPEID(T) (boost::detail::sp_typeid_<T>::ti_)
+
+#else
+
+#include <typeinfo>
+
+namespace boost
+{
+
+namespace detail
+{
+
+#if defined( BOOST_NO_STD_TYPEINFO )
+
+typedef ::type_info sp_typeinfo;
+
+#else
+
+typedef std::type_info sp_typeinfo;
+
+#endif
+
+} // namespace detail
+
+} // namespace boost
+
+#define BOOST_SP_TYPEID(T) typeid(T)
+
+#endif
+
+#endif  // #ifndef BOOST_DETAIL_SP_TYPEINFO_HPP_INCLUDED

include/boost/get_pointer.hpp

@@ -0,0 +1,33 @@
+// Copyright Peter Dimov and David Abrahams 2002.
+// 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 GET_POINTER_DWA20021219_HPP
+# define GET_POINTER_DWA20021219_HPP
+
+// In order to avoid circular dependencies with Boost.TR1
+// we make sure that our include of <memory> doesn't try to
+// pull in the TR1 headers: that's why we use this header 
+// rather than including <memory> directly:
+# include <boost/config/no_tr1/memory.hpp>  // std::auto_ptr
+
+namespace boost { 
+
+// get_pointer(p) extracts a ->* capable pointer from p
+
+template<class T> T * get_pointer(T * p)
+{
+    return p;
+}
+
+// get_pointer(shared_ptr<T> const & p) has been moved to shared_ptr.hpp
+
+template<class T> T * get_pointer(std::auto_ptr<T> const& p)
+{
+    return p.get();
+}
+
+
+} // namespace boost
+
+#endif // GET_POINTER_DWA20021219_HPP

include/boost/make_unique.hpp

@@ -1,13 +0,0 @@
-/*
-Copyright 2014 Glen Joseph Fernandes
-(glenjofe@gmail.com)
-
-Distributed under the Boost Software License, Version 1.0.
-(http://www.boost.org/LICENSE_1_0.txt)
-*/
-#ifndef BOOST_MAKE_UNIQUE_HPP_INCLUDED
-#define BOOST_MAKE_UNIQUE_HPP_INCLUDED
-
-#include <boost/smart_ptr/make_unique.hpp>
-
-#endif

include/boost/memory_order.hpp

@@ -0,0 +1,53 @@
+#ifndef BOOST_MEMORY_ORDER_HPP_INCLUDED
+#define BOOST_MEMORY_ORDER_HPP_INCLUDED
+
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+//  boost/memory_order.hpp
+//
+//  Defines enum boost::memory_order per the C++0x working draft
+//
+//  Copyright (c) 2008, 2009 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)
+
+
+namespace boost
+{
+
+//
+// Enum values are chosen so that code that needs to insert
+// a trailing fence for acquire semantics can use a single
+// test such as:
+//
+// if( mo & memory_order_acquire ) { ...fence... }
+//
+// For leading fences one can use:
+//
+// if( mo & memory_order_release ) { ...fence... }
+//
+// Architectures such as Alpha that need a fence on consume
+// can use:
+//
+// if( mo & ( memory_order_acquire | memory_order_consume ) ) { ...fence... }
+//
+
+enum memory_order
+{
+    memory_order_relaxed = 0,
+    memory_order_acquire = 1,
+    memory_order_release = 2,
+    memory_order_acq_rel = 3, // acquire | release
+    memory_order_seq_cst = 7, // acq_rel | 4
+    memory_order_consume = 8
+};
+
+} // namespace boost
+
+#endif // #ifndef BOOST_MEMORY_ORDER_HPP_INCLUDED

include/boost/pointer_cast.hpp

@@ -10,8 +10,6 @@
 #ifndef BOOST_POINTER_CAST_HPP
 #define BOOST_POINTER_CAST_HPP
 
-#include <boost/config.hpp>
-
 namespace boost { 
 
 //static_pointer_cast overload for raw pointers
@@ -44,78 +42,4 @@ inline T* reinterpret_pointer_cast(U *ptr)
 
 } // namespace boost
 
-#if !defined( BOOST_NO_CXX11_SMART_PTR )
-
-#include <boost/type_traits/has_virtual_destructor.hpp>
-#include <boost/static_assert.hpp>
-#include <memory>
-
-namespace boost {
-
-//static_pointer_cast overload for std::shared_ptr
-using std::static_pointer_cast;
-
-//dynamic_pointer_cast overload for std::shared_ptr
-using std::dynamic_pointer_cast;
-
-//const_pointer_cast overload for std::shared_ptr
-using std::const_pointer_cast;
-
-//reinterpret_pointer_cast overload for std::shared_ptr
-template<class T, class U> std::shared_ptr<T> reinterpret_pointer_cast(const std::shared_ptr<U> & r ) BOOST_NOEXCEPT
-{
-    (void) reinterpret_cast< T* >( static_cast< U* >( 0 ) );
-
-    typedef typename std::shared_ptr<T>::element_type E;
-
-    E * p = reinterpret_cast< E* >( r.get() );
-    return std::shared_ptr<T>( r, p );
-}
-
-//static_pointer_cast overload for std::unique_ptr
-template<class T, class U> std::unique_ptr<T> static_pointer_cast( std::unique_ptr<U> && r ) BOOST_NOEXCEPT
-{
-    (void) static_cast< T* >( static_cast< U* >( 0 ) );
-
-    typedef typename std::unique_ptr<T>::element_type E;
-
-    return std::unique_ptr<T>( static_cast<E*>( r.release() ) );
-}
-
-//dynamic_pointer_cast overload for std::unique_ptr
-template<class T, class U> std::unique_ptr<T> dynamic_pointer_cast( std::unique_ptr<U> && r ) BOOST_NOEXCEPT
-{
-    (void) dynamic_cast< T* >( static_cast< U* >( 0 ) );
-
-    BOOST_STATIC_ASSERT_MSG( boost::has_virtual_destructor<T>::value, "The target of dynamic_pointer_cast must have a virtual destructor." );
-
-    T * p = dynamic_cast<T*>( r.get() );
-    if( p ) r.release();
-    return std::unique_ptr<T>( p );
-}
-
-//const_pointer_cast overload for std::unique_ptr
-template<class T, class U> std::unique_ptr<T> const_pointer_cast( std::unique_ptr<U> && r ) BOOST_NOEXCEPT
-{
-    (void) const_cast< T* >( static_cast< U* >( 0 ) );
-
-    typedef typename std::unique_ptr<T>::element_type E;
-
-    return std::unique_ptr<T>( const_cast<E*>( r.release() ) );
-}
-
-//reinterpret_pointer_cast overload for std::unique_ptr
-template<class T, class U> std::unique_ptr<T> reinterpret_pointer_cast( std::unique_ptr<U> && r ) BOOST_NOEXCEPT
-{
-    (void) reinterpret_cast< T* >( static_cast< U* >( 0 ) );
-
-    typedef typename std::unique_ptr<T>::element_type E;
-
-    return std::unique_ptr<T>( reinterpret_cast<E*>( r.release() ) );
-}
-
-} // namespace boost
-
-#endif // #if !defined( BOOST_NO_CXX11_SMART_PTR )
-
 #endif   //BOOST_POINTER_CAST_HPP

include/boost/smart_ptr.hpp

@@ -1,6 +1,3 @@
-#ifndef BOOST_SMART_PTR_HPP_INCLUDED
-#define BOOST_SMART_PTR_HPP_INCLUDED
-
 //
 //  smart_ptr.hpp
 //
@@ -25,7 +22,4 @@
 # include <boost/weak_ptr.hpp>
 # include <boost/intrusive_ptr.hpp>
 # include <boost/enable_shared_from_this.hpp>
-# include <boost/make_shared.hpp>
 #endif
-
-#endif // #ifndef BOOST_SMART_PTR_HPP_INCLUDED

include/boost/smart_ptr/bad_weak_ptr.hpp

@@ -36,11 +36,6 @@ namespace boost
 # pragma option push -pc
 #endif
 
-#if defined(__clang__)
-# pragma clang diagnostic push
-# pragma clang diagnostic ignored "-Wweak-vtables"
-#endif
-
 class bad_weak_ptr: public std::exception
 {
 public:
@@ -51,10 +46,6 @@ public:
     }
 };
 
-#if defined(__clang__)
-# pragma clang diagnostic pop
-#endif
-
 #if defined(__BORLANDC__) && __BORLANDC__ <= 0x564
 # pragma option pop
 #endif

include/boost/smart_ptr/detail/atomic_count.hpp

@@ -11,11 +11,10 @@
 //  boost/detail/atomic_count.hpp - thread/SMP safe reference counter
 //
 //  Copyright (c) 2001, 2002 Peter Dimov and Multi Media Ltd.
-//  Copyright (c) 2013 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
+// 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)
 //
 //  typedef <implementation-defined> boost::detail::atomic_count;
 //
@@ -28,71 +27,92 @@
 //  a;
 //
 //    Returns: (long) the current value of a
-//    Memory Ordering: acquire
 //
 //  ++a;
 //
 //    Effects: Atomically increments the value of a
 //    Returns: (long) the new value of a
-//    Memory Ordering: acquire/release
 //
 //  --a;
 //
 //    Effects: Atomically decrements the value of a
 //    Returns: (long) the new value of a
-//    Memory Ordering: acquire/release
+//
+//    Important note: when --a returns zero, it must act as a
+//      read memory barrier (RMB); i.e. the calling thread must
+//      have a synchronized view of the memory
+//
+//    On Intel IA-32 (x86) memory is always synchronized, so this
+//      is not a problem.
+//
+//    On many architectures the atomic instructions already act as
+//      a memory barrier.
+//
+//    This property is necessary for proper reference counting, since
+//      a thread can update the contents of a shared object, then
+//      release its reference, and another thread may immediately
+//      release the last reference causing object destruction.
+//
+//    The destructor needs to have a synchronized view of the
+//      object to perform proper cleanup.
+//
+//    Original example by Alexander Terekhov:
+//
+//    Given:
+//
+//    - a mutable shared object OBJ;
+//    - two threads THREAD1 and THREAD2 each holding 
+//      a private smart_ptr object pointing to that OBJ.
+//
+//    t1: THREAD1 updates OBJ (thread-safe via some synchronization)
+//      and a few cycles later (after "unlock") destroys smart_ptr;
+//
+//    t2: THREAD2 destroys smart_ptr WITHOUT doing any synchronization 
+//      with respect to shared mutable object OBJ; OBJ destructors
+//      are called driven by smart_ptr interface...
 //
 
 #include <boost/config.hpp>
 #include <boost/smart_ptr/detail/sp_has_sync.hpp>
 
-#if defined( BOOST_AC_DISABLE_THREADS )
-# include <boost/smart_ptr/detail/atomic_count_nt.hpp>
+#ifndef BOOST_HAS_THREADS
 
-#elif defined( BOOST_AC_USE_STD_ATOMIC )
-# include <boost/smart_ptr/detail/atomic_count_std_atomic.hpp>
+namespace boost
+{
 
-#elif defined( BOOST_AC_USE_SPINLOCK )
-# include <boost/smart_ptr/detail/atomic_count_spin.hpp>
+namespace detail
+{
+
+typedef long atomic_count;
+
+}
+
+}
 
 #elif defined(BOOST_AC_USE_PTHREADS)
-# include <boost/smart_ptr/detail/atomic_count_pt.hpp>
+#  include <boost/smart_ptr/detail/atomic_count_pthreads.hpp>
 
-#elif defined( BOOST_SP_DISABLE_THREADS )
-# include <boost/smart_ptr/detail/atomic_count_nt.hpp>
-
-#elif defined( BOOST_SP_USE_STD_ATOMIC )
-# include <boost/smart_ptr/detail/atomic_count_std_atomic.hpp>
-
-#elif defined( BOOST_SP_USE_SPINLOCK )
-# include <boost/smart_ptr/detail/atomic_count_spin.hpp>
-
-#elif defined( BOOST_SP_USE_PTHREADS )
-# include <boost/smart_ptr/detail/atomic_count_pt.hpp>
-
-#elif defined( BOOST_DISABLE_THREADS ) && !defined( BOOST_SP_ENABLE_THREADS ) && !defined( BOOST_DISABLE_WIN32 )
-# include <boost/smart_ptr/detail/atomic_count_nt.hpp>
-
-#elif !defined( BOOST_NO_CXX11_HDR_ATOMIC )
-# include <boost/smart_ptr/detail/atomic_count_std_atomic.hpp>
-
-#elif defined( __GNUC__ ) && ( defined( __i386__ ) || defined( __x86_64__ ) ) && !defined( __PATHSCALE__ )
+#elif defined( __GNUC__ ) && ( defined( __i386__ ) || defined( __x86_64__ ) )
 #  include <boost/smart_ptr/detail/atomic_count_gcc_x86.hpp>
 
-#elif defined( BOOST_SP_HAS_SYNC )
-# include <boost/smart_ptr/detail/atomic_count_sync.hpp>
-
 #elif defined(WIN32) || defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 #  include <boost/smart_ptr/detail/atomic_count_win32.hpp>
 
+#elif defined( BOOST_SP_HAS_SYNC )
+#  include <boost/smart_ptr/detail/atomic_count_sync.hpp>
+
 #elif defined(__GLIBCPP__) || defined(__GLIBCXX__)
 #  include <boost/smart_ptr/detail/atomic_count_gcc.hpp>
 
-#elif !defined( BOOST_HAS_THREADS )
-# include <boost/smart_ptr/detail/atomic_count_nt.hpp>
+#elif defined(BOOST_HAS_PTHREADS)
+
+#  define BOOST_AC_USE_PTHREADS
+#  include <boost/smart_ptr/detail/atomic_count_pthreads.hpp>
 
 #else
-# include <boost/smart_ptr/detail/atomic_count_spin.hpp>
+
+// Use #define BOOST_DISABLE_THREADS to avoid the error
+#error Unrecognized threading platform
 
 #endif
 

include/boost/smart_ptr/detail/atomic_count_nt.hpp

@@ -1,59 +0,0 @@
-#ifndef BOOST_SMART_PTR_DETAIL_ATOMIC_COUNT_NT_HPP_INCLUDED
-#define BOOST_SMART_PTR_DETAIL_ATOMIC_COUNT_NT_HPP_INCLUDED
-
-//
-//  boost/detail/atomic_count_nt.hpp
-//
-//  Trivial atomic_count for the single-threaded case
-//
-//  http://gcc.gnu.org/onlinedocs/porting/Thread-safety.html
-//
-//  Copyright 2013 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
-//
-
-namespace boost
-{
-
-namespace detail
-{
-
-class atomic_count
-{
-public:
-
-    explicit atomic_count( long v ): value_( v )
-    {
-    }
-
-    long operator++()
-    {
-        return ++value_;
-    }
-
-    long operator--()
-    {
-        return --value_;
-    }
-
-    operator long() const
-    {
-        return value_;
-    }
-
-private:
-
-    atomic_count(atomic_count const &);
-    atomic_count & operator=(atomic_count const &);
-
-    long value_;
-};
-
-} // namespace detail
-
-} // namespace boost
-
-#endif // #ifndef BOOST_SMART_PTR_DETAIL_ATOMIC_COUNT_NT_HPP_INCLUDED

include/boost/smart_ptr/detail/atomic_count_pthreads.hpp

@@ -11,7 +11,6 @@
 // http://www.boost.org/LICENSE_1_0.txt)
 //
 
-#include <boost/assert.hpp>
 #include <pthread.h>
 
 //
@@ -38,12 +37,12 @@ private:
 
         scoped_lock(pthread_mutex_t & m): m_(m)
         {
-            BOOST_VERIFY( pthread_mutex_lock( &m_ ) == 0 );
+            pthread_mutex_lock(&m_);
         }
 
         ~scoped_lock()
         {
-            BOOST_VERIFY( pthread_mutex_unlock( &m_ ) == 0 );
+            pthread_mutex_unlock(&m_);
         }
 
     private:
@@ -55,12 +54,12 @@ public:
 
     explicit atomic_count(long v): value_(v)
     {
-        BOOST_VERIFY( pthread_mutex_init( &mutex_, 0 ) == 0 );
+        pthread_mutex_init(&mutex_, 0);
     }
 
     ~atomic_count()
     {
-        BOOST_VERIFY( pthread_mutex_destroy( &mutex_ ) == 0 );
+        pthread_mutex_destroy(&mutex_);
     }
 
     long operator++()

include/boost/smart_ptr/detail/atomic_count_spin.hpp

@@ -1,62 +0,0 @@
-#ifndef BOOST_SMART_PTR_DETAIL_ATOMIC_COUNT_SPIN_HPP_INCLUDED
-#define BOOST_SMART_PTR_DETAIL_ATOMIC_COUNT_SPIN_HPP_INCLUDED
-
-//
-//  boost/detail/atomic_count_spin.hpp
-//
-//  Copyright (c) 2013 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/smart_ptr/detail/spinlock_pool.hpp>
-
-namespace boost
-{
-
-namespace detail
-{
-
-class atomic_count
-{
-private:
-
-public:
-
-    explicit atomic_count( long v ): value_( v )
-    {
-    }
-
-    long operator++()
-    {
-        spinlock_pool<0>::scoped_lock lock( &value_ );
-        return ++value_;
-    }
-
-    long operator--()
-    {
-        spinlock_pool<0>::scoped_lock lock( &value_ );
-        return --value_;
-    }
-
-    operator long() const
-    {
-        spinlock_pool<0>::scoped_lock lock( &value_ );
-        return value_;
-    }
-
-private:
-
-    atomic_count(atomic_count const &);
-    atomic_count & operator=(atomic_count const &);
-
-    long value_;
-};
-
-} // namespace detail
-
-} // namespace boost
-
-#endif // #ifndef BOOST_SMART_PTR_DETAIL_ATOMIC_COUNT_SPIN_HPP_INCLUDED

include/boost/smart_ptr/detail/atomic_count_std_atomic.hpp

@@ -1,60 +0,0 @@
-#ifndef BOOST_SMART_PTR_DETAIL_ATOMIC_COUNT_STD_ATOMIC_HPP_INCLUDED
-#define BOOST_SMART_PTR_DETAIL_ATOMIC_COUNT_STD_ATOMIC_HPP_INCLUDED
-
-//
-//  boost/detail/atomic_count_std_atomic.hpp
-//
-//  atomic_count for std::atomic
-//
-//  Copyright 2013 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 <atomic>
-#include <cstdint>
-
-namespace boost
-{
-
-namespace detail
-{
-
-class atomic_count
-{
-public:
-
-    explicit atomic_count( long v ): value_( v )
-    {
-    }
-
-    long operator++()
-    {
-        return value_.fetch_add( 1, std::memory_order_acq_rel ) + 1;
-    }
-
-    long operator--()
-    {
-        return value_.fetch_sub( 1, std::memory_order_acq_rel ) - 1;
-    }
-
-    operator long() const
-    {
-        return value_.load( std::memory_order_acquire );
-    }
-
-private:
-
-    atomic_count(atomic_count const &);
-    atomic_count & operator=(atomic_count const &);
-
-    std::atomic_int_least32_t value_;
-};
-
-} // namespace detail
-
-} // namespace boost
-
-#endif // #ifndef BOOST_SMART_PTR_DETAIL_ATOMIC_COUNT_STD_ATOMIC_HPP_INCLUDED

include/boost/smart_ptr/detail/atomic_count_win32.hpp

@@ -17,7 +17,7 @@
 // http://www.boost.org/LICENSE_1_0.txt)
 //
 
-#include <boost/smart_ptr/detail/sp_interlocked.hpp>
+#include <boost/detail/interlocked.hpp>
 
 namespace boost
 {
@@ -35,12 +35,12 @@ public:
 
     long operator++()
     {
-        return BOOST_SP_INTERLOCKED_INCREMENT( &value_ );
+        return BOOST_INTERLOCKED_INCREMENT( &value_ );
     }
 
     long operator--()
     {
-        return BOOST_SP_INTERLOCKED_DECREMENT( &value_ );
+        return BOOST_INTERLOCKED_DECREMENT( &value_ );
     }
 
     operator long() const

include/boost/smart_ptr/detail/lwm_win32_cs.hpp

@@ -11,15 +11,12 @@
 //  boost/detail/lwm_win32_cs.hpp
 //
 //  Copyright (c) 2002, 2003 Peter Dimov
-//  Copyright (c) Microsoft Corporation 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)
 //
 
-#include <boost/predef.h>
-
 #ifdef BOOST_USE_WINDOWS_H
 #  include <windows.h>
 #endif
@@ -46,11 +43,7 @@ struct critical_section
 #endif
 };
 
-#if BOOST_PLAT_WINDOWS_RUNTIME
-extern "C" __declspec(dllimport) void __stdcall InitializeCriticalSectionEx(critical_section *, unsigned long, unsigned long);
-#else
 extern "C" __declspec(dllimport) void __stdcall InitializeCriticalSection(critical_section *);
-#endif
 extern "C" __declspec(dllimport) void __stdcall EnterCriticalSection(critical_section *);
 extern "C" __declspec(dllimport) void __stdcall LeaveCriticalSection(critical_section *);
 extern "C" __declspec(dllimport) void __stdcall DeleteCriticalSection(critical_section *);
@@ -74,11 +67,7 @@ public:
 
     lightweight_mutex()
     {
-#if BOOST_PLAT_WINDOWS_RUNTIME
-        InitializeCriticalSectionEx(&cs_, 4000, 0);
-#else
         InitializeCriticalSection(&cs_);
-#endif
     }
 
     ~lightweight_mutex()

include/boost/smart_ptr/detail/operator_bool.hpp

@@ -1,22 +1,14 @@
 //  This header intentionally has no include guards.
 //
-//  Copyright (c) 2001-2009, 2012 Peter Dimov
+//  Copyright (c) 2001-2009 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
 
-#if !defined( BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS ) && !defined( BOOST_NO_CXX11_NULLPTR )\
-    && !(defined(__SUNPRO_CC) && BOOST_WORKAROUND(__SUNPRO_CC, <= 0x5130))
+#if ( defined(__SUNPRO_CC) && BOOST_WORKAROUND(__SUNPRO_CC, < 0x570) ) || defined(__CINT__)
 
-    explicit operator bool () const BOOST_NOEXCEPT
-    {
-        return px != 0;
-    }
-
-#elif ( defined(__SUNPRO_CC) && BOOST_WORKAROUND(__SUNPRO_CC, < 0x570) ) || defined(__CINT__)
-
-    operator bool () const BOOST_NOEXCEPT
+    operator bool () const
     {
         return px != 0;
     }
@@ -29,7 +21,7 @@
 
     typedef void (*unspecified_bool_type)( this_type*** );
 
-    operator unspecified_bool_type() const BOOST_NOEXCEPT
+    operator unspecified_bool_type() const // never throws
     {
         return px == 0? 0: unspecified_bool;
     }
@@ -39,18 +31,18 @@
     ( defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__ < 304) ) || \
     ( defined(__SUNPRO_CC) && BOOST_WORKAROUND(__SUNPRO_CC, <= 0x590) )
 
-    typedef element_type * (this_type::*unspecified_bool_type)() const;
+    typedef T * (this_type::*unspecified_bool_type)() const;
 
-    operator unspecified_bool_type() const BOOST_NOEXCEPT
+    operator unspecified_bool_type() const // never throws
     {
         return px == 0? 0: &this_type::get;
     }
 
 #else
 
-    typedef element_type * this_type::*unspecified_bool_type;
+    typedef T * this_type::*unspecified_bool_type;
 
-    operator unspecified_bool_type() const BOOST_NOEXCEPT
+    operator unspecified_bool_type() const // never throws
     {
         return px == 0? 0: &this_type::px;
     }
@@ -58,7 +50,7 @@
 #endif
 
     // operator! is redundant, but some compilers need it
-    bool operator! () const BOOST_NOEXCEPT
+    bool operator! () const // never throws
     {
         return px == 0;
     }

include/boost/smart_ptr/detail/shared_array_nmt.hpp

@@ -0,0 +1,151 @@
+#ifndef BOOST_SMART_PTR_DETAIL_SHARED_ARRAY_NMT_HPP_INCLUDED
+#define BOOST_SMART_PTR_DETAIL_SHARED_ARRAY_NMT_HPP_INCLUDED
+
+//
+//  detail/shared_array_nmt.hpp - shared_array.hpp without member templates
+//
+//  (C) Copyright Greg Colvin and Beman Dawes 1998, 1999.
+//  Copyright (c) 2001, 2002 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)
+//
+//  See http://www.boost.org/libs/smart_ptr/shared_array.htm for documentation.
+//
+
+#include <boost/assert.hpp>
+#include <boost/checked_delete.hpp>
+#include <boost/throw_exception.hpp>
+#include <boost/smart_ptr/detail/atomic_count.hpp>
+
+#include <cstddef>          // for std::ptrdiff_t
+#include <algorithm>        // for std::swap
+#include <functional>       // for std::less
+#include <new>              // for std::bad_alloc
+
+namespace boost
+{
+
+template<class T> class shared_array
+{
+private:
+
+    typedef detail::atomic_count count_type;
+
+public:
+
+    typedef T element_type;
+      
+    explicit shared_array(T * p = 0): px(p)
+    {
+#ifndef BOOST_NO_EXCEPTIONS
+
+        try  // prevent leak if new throws
+        {
+            pn = new count_type(1);
+        }
+        catch(...)
+        {
+            boost::checked_array_delete(p);
+            throw;
+        }
+
+#else
+
+        pn = new count_type(1);
+
+        if(pn == 0)
+        {
+            boost::checked_array_delete(p);
+            boost::throw_exception(std::bad_alloc());
+        }
+
+#endif
+    }
+
+    ~shared_array()
+    {
+        if(--*pn == 0)
+        {
+            boost::checked_array_delete(px);
+            delete pn;
+        }
+    }
+
+    shared_array(shared_array const & r) : px(r.px)  // never throws
+    {
+        pn = r.pn;
+        ++*pn;
+    }
+
+    shared_array & operator=(shared_array const & r)
+    {
+        shared_array(r).swap(*this);
+        return *this;
+    }
+
+    void reset(T * p = 0)
+    {
+        BOOST_ASSERT(p == 0 || p != px);
+        shared_array(p).swap(*this);
+    }
+
+    T * get() const  // never throws
+    {
+        return px;
+    }
+
+    T & operator[](std::ptrdiff_t i) const  // never throws
+    {
+        BOOST_ASSERT(px != 0);
+        BOOST_ASSERT(i >= 0);
+        return px[i];
+    }
+
+    long use_count() const  // never throws
+    {
+        return *pn;
+    }
+
+    bool unique() const  // never throws
+    {
+        return *pn == 1;
+    }
+
+    void swap(shared_array<T> & other)  // never throws
+    {
+        std::swap(px, other.px);
+        std::swap(pn, other.pn);
+    }
+
+private:
+
+    T * px;            // contained pointer
+    count_type * pn;   // ptr to reference counter
+      
+};  // shared_array
+
+template<class T, class U> inline bool operator==(shared_array<T> const & a, shared_array<U> const & b)
+{
+    return a.get() == b.get();
+}
+
+template<class T, class U> inline bool operator!=(shared_array<T> const & a, shared_array<U> const & b)
+{
+    return a.get() != b.get();
+}
+
+template<class T> inline bool operator<(shared_array<T> const & a, shared_array<T> const & b)
+{
+    return std::less<T*>()(a.get(), b.get());
+}
+
+template<class T> void swap(shared_array<T> & a, shared_array<T> & b)
+{
+    a.swap(b);
+}
+
+} // namespace boost
+
+#endif  // #ifndef BOOST_SMART_PTR_DETAIL_SHARED_ARRAY_NMT_HPP_INCLUDED

include/boost/smart_ptr/detail/shared_count.hpp

@@ -28,7 +28,6 @@
 #include <boost/smart_ptr/bad_weak_ptr.hpp>
 #include <boost/smart_ptr/detail/sp_counted_base.hpp>
 #include <boost/smart_ptr/detail/sp_counted_impl.hpp>
-#include <boost/smart_ptr/detail/sp_disable_deprecated.hpp>
 #include <boost/detail/workaround.hpp>
 // In order to avoid circular dependencies with Boost.TR1
 // we make sure that our include of <memory> doesn't try to
@@ -36,28 +35,11 @@
 // rather than including <memory> directly:
 #include <boost/config/no_tr1/memory.hpp>  // std::auto_ptr
 #include <functional>       // std::less
-
-#ifdef BOOST_NO_EXCEPTIONS
 #include <new>              // std::bad_alloc
-#endif
-
-#include <boost/core/addressof.hpp>
-
-#if defined( BOOST_SP_DISABLE_DEPRECATED )
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-#endif
 
 namespace boost
 {
 
-namespace movelib
-{
-
-    template< class T, class D > class unique_ptr;
-
-} // namespace movelib
-
 namespace detail
 {
 
@@ -70,38 +52,6 @@ int const   weak_count_id = 0x298C38A4;
 
 struct sp_nothrow_tag {};
 
-template< class D > struct sp_inplace_tag
-{
-};
-
-template< class T > class sp_reference_wrapper
-{ 
-public:
-
-    explicit sp_reference_wrapper( T & t): t_( boost::addressof( t ) )
-    {
-    }
-
-    template< class Y > void operator()( Y * p ) const
-    {
-        (*t_)( p );
-    }
-
-private:
-
-    T * t_;
-};
-
-template< class D > struct sp_convert_reference
-{
-    typedef D type;
-};
-
-template< class D > struct sp_convert_reference< D& >
-{
-    typedef sp_reference_wrapper< D > type;
-};
-
 class weak_count;
 
 class shared_count
@@ -192,65 +142,22 @@ public:
 #endif
     }
 
-#if !defined( BOOST_NO_FUNCTION_TEMPLATE_ORDERING )
-
-    template< class P, class D > shared_count( P p, sp_inplace_tag<D> ): pi_( 0 )
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
-        , id_(shared_count_id)
-#endif
-    {
-#ifndef BOOST_NO_EXCEPTIONS
-
-        try
-        {
-            pi_ = new sp_counted_impl_pd< P, D >( p );
-        }
-        catch( ... )
-        {
-            D::operator_fn( p ); // delete p
-            throw;
-        }
-
-#else
-
-        pi_ = new sp_counted_impl_pd< P, D >( p );
-
-        if( pi_ == 0 )
-        {
-            D::operator_fn( p ); // delete p
-            boost::throw_exception( std::bad_alloc() );
-        }
-
-#endif // #ifndef BOOST_NO_EXCEPTIONS
-    }
-
-#endif // !defined( BOOST_NO_FUNCTION_TEMPLATE_ORDERING )
-
     template<class P, class D, class A> shared_count( P p, D d, A a ): pi_( 0 )
 #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
         , id_(shared_count_id)
 #endif
     {
         typedef sp_counted_impl_pda<P, D, A> impl_type;
-
-#if !defined( BOOST_NO_CXX11_ALLOCATOR )
-
-        typedef typename std::allocator_traits<A>::template rebind_alloc< impl_type > A2;
-
-#else
-
         typedef typename A::template rebind< impl_type >::other A2;
 
-#endif
-
         A2 a2( a );
 
 #ifndef BOOST_NO_EXCEPTIONS
 
         try
         {
-            pi_ = a2.allocate( 1 );
-            ::new( static_cast< void* >( pi_ ) ) impl_type( p, d, a );
+            pi_ = a2.allocate( 1, static_cast< impl_type* >( 0 ) );
+            new( static_cast< void* >( pi_ ) ) impl_type( p, d, a );
         }
         catch(...)
         {
@@ -266,11 +173,11 @@ public:
 
 #else
 
-        pi_ = a2.allocate( 1 );
+        pi_ = a2.allocate( 1, static_cast< impl_type* >( 0 ) );
 
         if( pi_ != 0 )
         {
-            ::new( static_cast< void* >( pi_ ) ) impl_type( p, d, a );
+            new( static_cast< void* >( pi_ ) ) impl_type( p, d, a );
         }
         else
         {
@@ -281,65 +188,6 @@ public:
 #endif
     }
 
-#if !defined( BOOST_NO_FUNCTION_TEMPLATE_ORDERING )
-
-    template< class P, class D, class A > shared_count( P p, sp_inplace_tag< D >, A a ): pi_( 0 )
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
-        , id_(shared_count_id)
-#endif
-    {
-        typedef sp_counted_impl_pda< P, D, A > impl_type;
-
-#if !defined( BOOST_NO_CXX11_ALLOCATOR )
-
-        typedef typename std::allocator_traits<A>::template rebind_alloc< impl_type > A2;
-
-#else
-
-        typedef typename A::template rebind< impl_type >::other A2;
-
-#endif
-
-        A2 a2( a );
-
-#ifndef BOOST_NO_EXCEPTIONS
-
-        try
-        {
-            pi_ = a2.allocate( 1 );
-            ::new( static_cast< void* >( pi_ ) ) impl_type( p, a );
-        }
-        catch(...)
-        {
-            D::operator_fn( p );
-
-            if( pi_ != 0 )
-            {
-                a2.deallocate( static_cast< impl_type* >( pi_ ), 1 );
-            }
-
-            throw;
-        }
-
-#else
-
-        pi_ = a2.allocate( 1 );
-
-        if( pi_ != 0 )
-        {
-            ::new( static_cast< void* >( pi_ ) ) impl_type( p, a );
-        }
-        else
-        {
-            D::operator_fn( p );
-            boost::throw_exception( std::bad_alloc() );
-        }
-
-#endif // #ifndef BOOST_NO_EXCEPTIONS
-    }
-
-#endif // !defined( BOOST_NO_FUNCTION_TEMPLATE_ORDERING )
-
 #ifndef BOOST_NO_AUTO_PTR
 
     // auto_ptr<Y> is special cased to provide the strong guarantee
@@ -364,56 +212,6 @@ public:
 
 #endif 
 
-#if !defined( BOOST_NO_CXX11_SMART_PTR )
-
-    template<class Y, class D>
-    explicit shared_count( std::unique_ptr<Y, D> & r ): pi_( 0 )
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
-        , id_(shared_count_id)
-#endif
-    {
-        typedef typename sp_convert_reference<D>::type D2;
-
-        D2 d2( r.get_deleter() );
-        pi_ = new sp_counted_impl_pd< typename std::unique_ptr<Y, D>::pointer, D2 >( r.get(), d2 );
-
-#ifdef BOOST_NO_EXCEPTIONS
-
-        if( pi_ == 0 )
-        {
-            boost::throw_exception( std::bad_alloc() );
-        }
-
-#endif
-
-        r.release();
-    }
-
-#endif
-
-    template<class Y, class D>
-    explicit shared_count( boost::movelib::unique_ptr<Y, D> & r ): pi_( 0 )
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
-        , id_(shared_count_id)
-#endif
-    {
-        typedef typename sp_convert_reference<D>::type D2;
-
-        D2 d2( r.get_deleter() );
-        pi_ = new sp_counted_impl_pd< typename boost::movelib::unique_ptr<Y, D>::pointer, D2 >( r.get(), d2 );
-
-#ifdef BOOST_NO_EXCEPTIONS
-
-        if( pi_ == 0 )
-        {
-            boost::throw_exception( std::bad_alloc() );
-        }
-
-#endif
-
-        r.release();
-    }
-
     ~shared_count() // nothrow
     {
         if( pi_ != 0 ) pi_->release();
@@ -430,7 +228,7 @@ public:
         if( pi_ != 0 ) pi_->add_ref_copy();
     }
 
-#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
+#if defined( BOOST_HAS_RVALUE_REFS )
 
     shared_count(shared_count && r): pi_(r.pi_) // nothrow
 #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
@@ -495,11 +293,6 @@ public:
     {
         return pi_? pi_->get_deleter( ti ): 0;
     }
-
-    void * get_untyped_deleter() const
-    {
-        return pi_? pi_->get_untyped_deleter(): 0;
-    }
 };
 
 
@@ -542,7 +335,7 @@ public:
 
 // Move support
 
-#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
+#if defined( BOOST_HAS_RVALUE_REFS )
 
     weak_count(weak_count && r): pi_(r.pi_) // nothrow
 #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
@@ -644,10 +437,6 @@ inline shared_count::shared_count( weak_count const & r, sp_nothrow_tag ): pi_(
 
 } // namespace boost
 
-#if defined( BOOST_SP_DISABLE_DEPRECATED )
-#pragma GCC diagnostic pop
-#endif
-
 #ifdef __BORLANDC__
 # pragma warn .8027     // Functions containing try are not expanded inline
 #endif

include/boost/smart_ptr/detail/shared_ptr_nmt.hpp

@@ -0,0 +1,182 @@
+#ifndef BOOST_SMART_PTR_DETAIL_SHARED_PTR_NMT_HPP_INCLUDED
+#define BOOST_SMART_PTR_DETAIL_SHARED_PTR_NMT_HPP_INCLUDED
+
+//
+//  detail/shared_ptr_nmt.hpp - shared_ptr.hpp without member templates
+//
+//  (C) Copyright Greg Colvin and Beman Dawes 1998, 1999.
+//  Copyright (c) 2001, 2002 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)
+//
+//  See http://www.boost.org/libs/smart_ptr/shared_ptr.htm for documentation.
+//
+
+#include <boost/assert.hpp>
+#include <boost/checked_delete.hpp>
+#include <boost/throw_exception.hpp>
+#include <boost/smart_ptr/detail/atomic_count.hpp>
+
+#ifndef BOOST_NO_AUTO_PTR
+# include <memory>          // for std::auto_ptr
+#endif
+
+#include <algorithm>        // for std::swap
+#include <functional>       // for std::less
+#include <new>              // for std::bad_alloc
+
+namespace boost
+{
+
+template<class T> class shared_ptr
+{
+private:
+
+    typedef detail::atomic_count count_type;
+
+public:
+
+    typedef T element_type;
+    typedef T value_type;
+
+    explicit shared_ptr(T * p = 0): px(p)
+    {
+#ifndef BOOST_NO_EXCEPTIONS
+
+        try  // prevent leak if new throws
+        {
+            pn = new count_type(1);
+        }
+        catch(...)
+        {
+            boost::checked_delete(p);
+            throw;
+        }
+
+#else
+
+        pn = new count_type(1);
+
+        if(pn == 0)
+        {
+            boost::checked_delete(p);
+            boost::throw_exception(std::bad_alloc());
+        }
+
+#endif
+    }
+
+    ~shared_ptr()
+    {
+        if(--*pn == 0)
+        {
+            boost::checked_delete(px);
+            delete pn;
+        }
+    }
+
+    shared_ptr(shared_ptr const & r): px(r.px)  // never throws
+    {
+        pn = r.pn;
+        ++*pn;
+    }
+
+    shared_ptr & operator=(shared_ptr const & r)
+    {
+        shared_ptr(r).swap(*this);
+        return *this;
+    }
+
+#ifndef BOOST_NO_AUTO_PTR
+
+    explicit shared_ptr(std::auto_ptr<T> & r)
+    { 
+        pn = new count_type(1); // may throw
+        px = r.release(); // fix: moved here to stop leak if new throws
+    } 
+
+    shared_ptr & operator=(std::auto_ptr<T> & r)
+    {
+        shared_ptr(r).swap(*this);
+        return *this;
+    }
+
+#endif
+
+    void reset(T * p = 0)
+    {
+        BOOST_ASSERT(p == 0 || p != px);
+        shared_ptr(p).swap(*this);
+    }
+
+    T & operator*() const  // never throws
+    {
+        BOOST_ASSERT(px != 0);
+        return *px;
+    }
+
+    T * operator->() const  // never throws
+    {
+        BOOST_ASSERT(px != 0);
+        return px;
+    }
+
+    T * get() const  // never throws
+    {
+        return px;
+    }
+
+    long use_count() const  // never throws
+    {
+        return *pn;
+    }
+
+    bool unique() const  // never throws
+    {
+        return *pn == 1;
+    }
+    
+    void swap(shared_ptr<T> & other)  // never throws
+    {
+        std::swap(px, other.px);
+        std::swap(pn, other.pn);
+    }
+
+private:
+
+    T * px;            // contained pointer
+    count_type * pn;   // ptr to reference counter
+};
+
+template<class T, class U> inline bool operator==(shared_ptr<T> const & a, shared_ptr<U> const & b)
+{
+    return a.get() == b.get();
+}
+
+template<class T, class U> inline bool operator!=(shared_ptr<T> const & a, shared_ptr<U> const & b)
+{
+    return a.get() != b.get();
+}
+
+template<class T> inline bool operator<(shared_ptr<T> const & a, shared_ptr<T> const & b)
+{
+    return std::less<T*>()(a.get(), b.get());
+}
+
+template<class T> void swap(shared_ptr<T> & a, shared_ptr<T> & b)
+{
+    a.swap(b);
+}
+
+// get_pointer() enables boost::mem_fn to recognize shared_ptr
+
+template<class T> inline T * get_pointer(shared_ptr<T> const & p)
+{
+    return p.get();
+}
+
+} // namespace boost
+
+#endif  // #ifndef BOOST_SMART_PTR_DETAIL_SHARED_PTR_NMT_HPP_INCLUDED

include/boost/smart_ptr/detail/sp_convertible.hpp

@@ -16,7 +16,6 @@
 //  http://www.boost.org/LICENSE_1_0.txt
 
 #include <boost/config.hpp>
-#include <cstddef>
 
 #if !defined( BOOST_SP_NO_SP_CONVERTIBLE ) && defined( BOOST_NO_SFINAE )
 # define BOOST_SP_NO_SP_CONVERTIBLE
@@ -49,21 +48,6 @@ template< class Y, class T > struct sp_convertible
     enum _vt { value = sizeof( (f)( static_cast<Y*>(0) ) ) == sizeof(yes) };
 };
 
-template< class Y, class T > struct sp_convertible< Y, T[] >
-{
-    enum _vt { value = false };
-};
-
-template< class Y, class T > struct sp_convertible< Y[], T[] >
-{
-    enum _vt { value = sp_convertible< Y[1], T[1] >::value };
-};
-
-template< class Y, std::size_t N, class T > struct sp_convertible< Y[N], T[] >
-{
-    enum _vt { value = sp_convertible< Y[1], T[1] >::value };
-};
-
 struct sp_empty
 {
 };

include/boost/smart_ptr/detail/sp_counted_base.hpp

@@ -10,7 +10,7 @@
 //
 //  detail/sp_counted_base.hpp
 //
-//  Copyright 2005-2013 Peter Dimov
+//  Copyright 2005, 2006 Peter Dimov
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
@@ -20,18 +20,9 @@
 #include <boost/config.hpp>
 #include <boost/smart_ptr/detail/sp_has_sync.hpp>
 
-#if !defined( __c2__ ) && defined( __clang__ ) && defined( __has_extension )
-# if __has_extension( __c_atomic__ )
-#   define BOOST_SP_HAS_CLANG_C11_ATOMICS
-# endif
-#endif
-
 #if defined( BOOST_SP_DISABLE_THREADS )
 # include <boost/smart_ptr/detail/sp_counted_base_nt.hpp>
 
-#elif defined( BOOST_SP_USE_STD_ATOMIC )
-# include <boost/smart_ptr/detail/sp_counted_base_std_atomic.hpp>
-
 #elif defined( BOOST_SP_USE_SPINLOCK )
 # include <boost/smart_ptr/detail/sp_counted_base_spin.hpp>
 
@@ -41,34 +32,22 @@
 #elif defined( BOOST_DISABLE_THREADS ) && !defined( BOOST_SP_ENABLE_THREADS ) && !defined( BOOST_DISABLE_WIN32 )
 # include <boost/smart_ptr/detail/sp_counted_base_nt.hpp>
 
-#elif defined( BOOST_SP_HAS_CLANG_C11_ATOMICS )
-# include <boost/smart_ptr/detail/sp_counted_base_clang.hpp>
-
-#elif !defined( BOOST_NO_CXX11_HDR_ATOMIC )
-# include <boost/smart_ptr/detail/sp_counted_base_std_atomic.hpp>
-
-#elif defined( __SNC__ )
-# include <boost/smart_ptr/detail/sp_counted_base_snc_ps3.hpp>
-
-#elif defined( __GNUC__ ) && ( defined( __i386__ ) || defined( __x86_64__ ) ) && !defined(__PATHSCALE__)
+#elif defined( __GNUC__ ) && ( defined( __i386__ ) || defined( __x86_64__ ) )
 # include <boost/smart_ptr/detail/sp_counted_base_gcc_x86.hpp>
 
+#elif defined( __GNUC__ ) && defined( __ia64__ ) && !defined( __INTEL_COMPILER )
+# include <boost/smart_ptr/detail/sp_counted_base_gcc_ia64.hpp>
+
 #elif defined(__HP_aCC) && defined(__ia64)
 # include <boost/smart_ptr/detail/sp_counted_base_acc_ia64.hpp>
 
-#elif defined( __GNUC__ ) && defined( __ia64__ ) && !defined( __INTEL_COMPILER ) && !defined(__PATHSCALE__)
-# include <boost/smart_ptr/detail/sp_counted_base_gcc_ia64.hpp>
-
-#elif defined( __IBMCPP__ ) && defined( __powerpc )
-# include <boost/smart_ptr/detail/sp_counted_base_vacpp_ppc.hpp>
-
 #elif defined( __MWERKS__ ) && defined( __POWERPC__ )
 # include <boost/smart_ptr/detail/sp_counted_base_cw_ppc.hpp>
 
-#elif defined( __GNUC__ ) && ( defined( __powerpc__ ) || defined( __ppc__ ) || defined( __ppc ) ) && !defined(__PATHSCALE__) && !defined( _AIX )
+#elif defined( __GNUC__ ) && ( defined( __powerpc__ ) || defined( __ppc__ ) || defined( __ppc ) )
 # include <boost/smart_ptr/detail/sp_counted_base_gcc_ppc.hpp>
 
-#elif defined( __GNUC__ ) && ( defined( __mips__ ) || defined( _mips ) ) && !defined(__PATHSCALE__) && !defined( __mips16 )
+#elif defined( __GNUC__ ) && ( defined( __mips__ ) || defined( _mips ) )
 # include <boost/smart_ptr/detail/sp_counted_base_gcc_mips.hpp>
 
 #elif defined( BOOST_SP_HAS_SYNC )
@@ -80,9 +59,6 @@
 #elif defined( WIN32 ) || defined( _WIN32 ) || defined( __WIN32__ ) || defined(__CYGWIN__)
 # include <boost/smart_ptr/detail/sp_counted_base_w32.hpp>
 
-#elif defined( _AIX )
-# include <boost/smart_ptr/detail/sp_counted_base_aix.hpp>
-
 #elif !defined( BOOST_HAS_THREADS )
 # include <boost/smart_ptr/detail/sp_counted_base_nt.hpp>
 
@@ -91,6 +67,4 @@
 
 #endif
 
-#undef BOOST_SP_HAS_CLANG_C11_ATOMICS
-
 #endif  // #ifndef BOOST_SMART_PTR_DETAIL_SP_COUNTED_BASE_HPP_INCLUDED

include/boost/smart_ptr/detail/sp_counted_base_acc_ia64.hpp

@@ -104,7 +104,6 @@ public:
     }
 
     virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
-    virtual void * get_untyped_deleter() = 0;
 
     void add_ref_copy()
     {

include/boost/smart_ptr/detail/sp_counted_base_aix.hpp

@@ -1,143 +0,0 @@
-#ifndef BOOST_SMART_PTR_DETAIL_SP_COUNTED_BASE_AIX_HPP_INCLUDED
-#define BOOST_SMART_PTR_DETAIL_SP_COUNTED_BASE_AIX_HPP_INCLUDED
-
-//
-//  detail/sp_counted_base_aix.hpp
-//   based on: detail/sp_counted_base_w32.hpp
-//
-//  Copyright (c) 2001, 2002, 2003 Peter Dimov and Multi Media Ltd.
-//  Copyright 2004-2005 Peter Dimov
-//  Copyright 2006 Michael van der Westhuizen
-//
-//  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)
-//
-//
-//  Lock-free algorithm by Alexander Terekhov
-//
-//  Thanks to Ben Hitchings for the #weak + (#shared != 0)
-//  formulation
-//
-
-#include <boost/detail/sp_typeinfo.hpp>
-#include <builtins.h>
-#include <sys/atomic_op.h>
-
-namespace boost
-{
-
-namespace detail
-{
-
-inline void atomic_increment( int32_t* pw )
-{
-    // ++*pw;
-
-    fetch_and_add( pw, 1 );
-}
-
-inline int32_t atomic_decrement( int32_t * pw )
-{
-    // return --*pw;
-
-    int32_t originalValue;
-
-    __lwsync();
-    originalValue = fetch_and_add( pw, -1 );
-    __isync();
-
-    return (originalValue - 1);
-}
-
-inline int32_t atomic_conditional_increment( int32_t * pw )
-{
-    // if( *pw != 0 ) ++*pw;
-    // return *pw;
-
-    int32_t tmp = fetch_and_add( pw, 0 );
-    for( ;; )
-    {
-        if( tmp == 0 ) return 0;
-        if( compare_and_swap( pw, &tmp, tmp + 1 ) ) return (tmp + 1);
-    }
-}
-
-class sp_counted_base
-{
-private:
-
-    sp_counted_base( sp_counted_base const & );
-    sp_counted_base & operator= ( sp_counted_base const & );
-
-    int32_t use_count_;        // #shared
-    int32_t weak_count_;       // #weak + (#shared != 0)
-
-public:
-
-    sp_counted_base(): use_count_( 1 ), weak_count_( 1 )
-    {
-    }
-
-    virtual ~sp_counted_base() // nothrow
-    {
-    }
-
-    // dispose() is called when use_count_ drops to zero, to release
-    // the resources managed by *this.
-
-    virtual void dispose() = 0; // nothrow
-
-    // destroy() is called when weak_count_ drops to zero.
-
-    virtual void destroy() // nothrow
-    {
-        delete this;
-    }
-
-    virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
-    virtual void * get_untyped_deleter() = 0;
-
-    void add_ref_copy()
-    {
-        atomic_increment( &use_count_ );
-    }
-
-    bool add_ref_lock() // true on success
-    {
-        return atomic_conditional_increment( &use_count_ ) != 0;
-    }
-
-    void release() // nothrow
-    {
-        if( atomic_decrement( &use_count_ ) == 0 )
-        {
-            dispose();
-            weak_release();
-        }
-    }
-
-    void weak_add_ref() // nothrow
-    {
-        atomic_increment( &weak_count_ );
-    }
-
-    void weak_release() // nothrow
-    {
-        if( atomic_decrement( &weak_count_ ) == 0 )
-        {
-            destroy();
-        }
-    }
-
-    long use_count() const // nothrow
-    {
-        return fetch_and_add( const_cast<int32_t*>(&use_count_), 0 );
-    }
-};
-
-} // namespace detail
-
-} // namespace boost
-
-#endif  // #ifndef BOOST_SMART_PTR_DETAIL_SP_COUNTED_BASE_AIX_HPP_INCLUDED

include/boost/smart_ptr/detail/sp_counted_base_clang.hpp

@@ -1,149 +0,0 @@
-#ifndef BOOST_SMART_PTR_DETAIL_SP_COUNTED_BASE_CLANG_HPP_INCLUDED
-#define BOOST_SMART_PTR_DETAIL_SP_COUNTED_BASE_CLANG_HPP_INCLUDED
-
-// MS compatible compilers support #pragma once
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-//  detail/sp_counted_base_clang.hpp - __c11 clang intrinsics
-//
-//  Copyright (c) 2007, 2013, 2015 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/detail/sp_typeinfo.hpp>
-#include <boost/cstdint.hpp>
-
-namespace boost
-{
-
-namespace detail
-{
-
-typedef _Atomic( boost::int_least32_t ) atomic_int_least32_t;
-
-inline void atomic_increment( atomic_int_least32_t * pw )
-{
-    __c11_atomic_fetch_add( pw, 1, __ATOMIC_RELAXED );
-}
-
-inline boost::int_least32_t atomic_decrement( atomic_int_least32_t * pw )
-{
-    return __c11_atomic_fetch_sub( pw, 1, __ATOMIC_ACQ_REL );
-}
-
-inline boost::int_least32_t atomic_conditional_increment( atomic_int_least32_t * pw )
-{
-    // long r = *pw;
-    // if( r != 0 ) ++*pw;
-    // return r;
-
-    boost::int_least32_t r = __c11_atomic_load( pw, __ATOMIC_RELAXED );
-
-    for( ;; )
-    {
-        if( r == 0 )
-        {
-            return r;
-        }
-
-        if( __c11_atomic_compare_exchange_weak( pw, &r, r + 1, __ATOMIC_RELAXED, __ATOMIC_RELAXED ) )
-        {
-            return r;
-        }
-    }    
-}
-
-#if defined(__clang__)
-# pragma clang diagnostic push
-# pragma clang diagnostic ignored "-Wweak-vtables"
-#endif
-
-class sp_counted_base
-{
-private:
-
-    sp_counted_base( sp_counted_base const & );
-    sp_counted_base & operator= ( sp_counted_base const & );
-
-    atomic_int_least32_t use_count_;	// #shared
-    atomic_int_least32_t weak_count_;	// #weak + (#shared != 0)
-
-public:
-
-    sp_counted_base()
-    {
-        __c11_atomic_init( &use_count_, 1 );
-        __c11_atomic_init( &weak_count_, 1 );
-    }
-
-    virtual ~sp_counted_base() // nothrow
-    {
-    }
-
-    // dispose() is called when use_count_ drops to zero, to release
-    // the resources managed by *this.
-
-    virtual void dispose() = 0; // nothrow
-
-    // destroy() is called when weak_count_ drops to zero.
-
-    virtual void destroy() // nothrow
-    {
-        delete this;
-    }
-
-    virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
-    virtual void * get_untyped_deleter() = 0;
-
-    void add_ref_copy()
-    {
-        atomic_increment( &use_count_ );
-    }
-
-    bool add_ref_lock() // true on success
-    {
-        return atomic_conditional_increment( &use_count_ ) != 0;
-    }
-
-    void release() // nothrow
-    {
-        if( atomic_decrement( &use_count_ ) == 1 )
-        {
-            dispose();
-            weak_release();
-        }
-    }
-
-    void weak_add_ref() // nothrow
-    {
-        atomic_increment( &weak_count_ );
-    }
-
-    void weak_release() // nothrow
-    {
-        if( atomic_decrement( &weak_count_ ) == 1 )
-        {
-            destroy();
-        }
-    }
-
-    long use_count() const // nothrow
-    {
-        return __c11_atomic_load( const_cast< atomic_int_least32_t* >( &use_count_ ), __ATOMIC_ACQUIRE );
-    }
-};
-
-#if defined(__clang__)
-# pragma clang diagnostic pop
-#endif
-
-} // namespace detail
-
-} // namespace boost
-
-#endif  // #ifndef BOOST_SMART_PTR_DETAIL_SP_COUNTED_BASE_CLANG_HPP_INCLUDED

include/boost/smart_ptr/detail/sp_counted_base_cw_ppc.hpp

@@ -124,7 +124,6 @@ public:
     }
 
     virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
-    virtual void * get_untyped_deleter() = 0;
 
     void add_ref_copy()
     {

include/boost/smart_ptr/detail/sp_counted_base_cw_x86.hpp

@@ -112,7 +112,6 @@ public:
     }
 
     virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
-    virtual void * get_untyped_deleter() = 0;
 
     void add_ref_copy()
     {

include/boost/smart_ptr/detail/sp_counted_base_gcc_ia64.hpp

@@ -111,7 +111,6 @@ public:
     }
 
     virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
-    virtual void * get_untyped_deleter() = 0;
 
     void add_ref_copy()
     {

include/boost/smart_ptr/detail/sp_counted_base_gcc_mips.hpp

@@ -37,12 +37,9 @@ inline void atomic_increment( int * pw )
     __asm__ __volatile__
     (
         "0:\n\t"
-        ".set push\n\t"
-        ".set mips2\n\t"
         "ll %0, %1\n\t"
         "addiu %0, 1\n\t"
         "sc %0, %1\n\t"
-        ".set pop\n\t"
         "beqz %0, 0b":
         "=&r"( tmp ), "=m"( *pw ):
         "m"( *pw )
@@ -58,12 +55,9 @@ inline int atomic_decrement( int * pw )
     __asm__ __volatile__
     (
         "0:\n\t"
-        ".set push\n\t"
-        ".set mips2\n\t"
         "ll %1, %2\n\t"
         "addiu %0, %1, -1\n\t"
         "sc %0, %2\n\t"
-        ".set pop\n\t"
         "beqz %0, 0b\n\t"
         "addiu %0, %1, -1":
         "=&r"( rv ), "=&r"( tmp ), "=m"( *pw ):
@@ -84,13 +78,10 @@ inline int atomic_conditional_increment( int * pw )
     __asm__ __volatile__
     (
         "0:\n\t"
-        ".set push\n\t"
-        ".set mips2\n\t"
         "ll %0, %2\n\t"
         "beqz %0, 1f\n\t"
         "addiu %1, %0, 1\n\t"
         "sc %1, %2\n\t"
-        ".set pop\n\t"
         "beqz %1, 0b\n\t"
         "addiu %0, %0, 1\n\t"
         "1:":
@@ -135,7 +126,6 @@ public:
     }
 
     virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
-    virtual void * get_untyped_deleter() = 0;
 
     void add_ref_copy()
     {

include/boost/smart_ptr/detail/sp_counted_base_gcc_ppc.hpp

@@ -135,7 +135,6 @@ public:
     }
 
     virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
-    virtual void * get_untyped_deleter() = 0;
 
     void add_ref_copy()
     {

include/boost/smart_ptr/detail/sp_counted_base_gcc_sparc.hpp

@@ -120,7 +120,6 @@ public:
     }
 
     virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
-    virtual void * get_untyped_deleter() = 0;
 
     void add_ref_copy()
     {

include/boost/smart_ptr/detail/sp_counted_base_gcc_x86.hpp

@@ -127,7 +127,6 @@ public:
     }
 
     virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
-    virtual void * get_untyped_deleter() = 0;
 
     void add_ref_copy()
     {

include/boost/smart_ptr/detail/sp_counted_base_nt.hpp

@@ -59,7 +59,6 @@ public:
     }
 
     virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
-    virtual void * get_untyped_deleter() = 0;
 
     void add_ref_copy()
     {

include/boost/smart_ptr/detail/sp_counted_base_pt.hpp

@@ -19,7 +19,6 @@
 //
 
 #include <boost/detail/sp_typeinfo.hpp>
-#include <boost/assert.hpp>
 #include <pthread.h>
 
 namespace boost
@@ -47,15 +46,15 @@ public:
 // HPUX 10.20 / DCE has a nonstandard pthread_mutex_init
 
 #if defined(__hpux) && defined(_DECTHREADS_)
-        BOOST_VERIFY( pthread_mutex_init( &m_, pthread_mutexattr_default ) == 0 );
+        pthread_mutex_init( &m_, pthread_mutexattr_default );
 #else
-        BOOST_VERIFY( pthread_mutex_init( &m_, 0 ) == 0 );
+        pthread_mutex_init( &m_, 0 );
 #endif
     }
 
     virtual ~sp_counted_base() // nothrow
     {
-        BOOST_VERIFY( pthread_mutex_destroy( &m_ ) == 0 );
+        pthread_mutex_destroy( &m_ );
     }
 
     // dispose() is called when use_count_ drops to zero, to release
@@ -71,28 +70,27 @@ public:
     }
 
     virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
-    virtual void * get_untyped_deleter() = 0;
 
     void add_ref_copy()
     {
-        BOOST_VERIFY( pthread_mutex_lock( &m_ ) == 0 );
+        pthread_mutex_lock( &m_ );
         ++use_count_;
-        BOOST_VERIFY( pthread_mutex_unlock( &m_ ) == 0 );
+        pthread_mutex_unlock( &m_ );
     }
 
     bool add_ref_lock() // true on success
     {
-        BOOST_VERIFY( pthread_mutex_lock( &m_ ) == 0 );
+        pthread_mutex_lock( &m_ );
         bool r = use_count_ == 0? false: ( ++use_count_, true );
-        BOOST_VERIFY( pthread_mutex_unlock( &m_ ) == 0 );
+        pthread_mutex_unlock( &m_ );
         return r;
     }
 
     void release() // nothrow
     {
-        BOOST_VERIFY( pthread_mutex_lock( &m_ ) == 0 );
+        pthread_mutex_lock( &m_ );
         long new_use_count = --use_count_;
-        BOOST_VERIFY( pthread_mutex_unlock( &m_ ) == 0 );
+        pthread_mutex_unlock( &m_ );
 
         if( new_use_count == 0 )
         {
@@ -103,16 +101,16 @@ public:
 
     void weak_add_ref() // nothrow
     {
-        BOOST_VERIFY( pthread_mutex_lock( &m_ ) == 0 );
+        pthread_mutex_lock( &m_ );
         ++weak_count_;
-        BOOST_VERIFY( pthread_mutex_unlock( &m_ ) == 0 );
+        pthread_mutex_unlock( &m_ );
     }
 
     void weak_release() // nothrow
     {
-        BOOST_VERIFY( pthread_mutex_lock( &m_ ) == 0 );
+        pthread_mutex_lock( &m_ );
         long new_weak_count = --weak_count_;
-        BOOST_VERIFY( pthread_mutex_unlock( &m_ ) == 0 );
+        pthread_mutex_unlock( &m_ );
 
         if( new_weak_count == 0 )
         {
@@ -122,9 +120,9 @@ public:
 
     long use_count() const // nothrow
     {
-        BOOST_VERIFY( pthread_mutex_lock( &m_ ) == 0 );
+        pthread_mutex_lock( &m_ );
         long r = use_count_;
-        BOOST_VERIFY( pthread_mutex_unlock( &m_ ) == 0 );
+        pthread_mutex_unlock( &m_ );
 
         return r;
     }

include/boost/smart_ptr/detail/sp_counted_base_snc_ps3.hpp

@@ -1,162 +0,0 @@
-#ifndef BOOST_SMART_PTR_DETAIL_SP_COUNTED_BASE_SNC_PS3_HPP_INCLUDED
-#define BOOST_SMART_PTR_DETAIL_SP_COUNTED_BASE_SNC_PS3_HPP_INCLUDED
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-//  detail/sp_counted_base_gcc_sparc.hpp - g++ on Sparc V8+
-//
-//  Copyright (c) 2006 Piotr Wyderski
-//  Copyright (c) 2006 Tomas Puverle
-//  Copyright (c) 2006 Peter Dimov
-//  Copyright (c) 2011 Emil Dotchevski
-//
-//  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
-//
-//  Thanks to Michael van der Westhuizen
-
-#include <boost/detail/sp_typeinfo.hpp>
-#include <inttypes.h> // uint32_t
-
-namespace boost
-{
-
-namespace detail
-{
-
-inline uint32_t compare_and_swap( uint32_t * dest_, uint32_t compare_, uint32_t swap_ )
-{
-    return __builtin_cellAtomicCompareAndSwap32(dest_,compare_,swap_);
-}
-
-inline uint32_t atomic_fetch_and_add( uint32_t * pw, uint32_t dv )
-{
-    // long r = *pw;
-    // *pw += dv;
-    // return r;
-
-    for( ;; )
-    {
-        uint32_t r = *pw;
-
-        if( __builtin_expect((compare_and_swap(pw, r, r + dv) == r), 1) )
-        {
-            return r;
-        }
-    }
-}
-
-inline void atomic_increment( uint32_t * pw )
-{
-    (void) __builtin_cellAtomicIncr32( pw );
-}
-
-inline uint32_t atomic_decrement( uint32_t * pw )
-{
-    return __builtin_cellAtomicDecr32( pw );
-}
-
-inline uint32_t atomic_conditional_increment( uint32_t * pw )
-{
-    // long r = *pw;
-    // if( r != 0 ) ++*pw;
-    // return r;
-
-    for( ;; )
-    {
-        uint32_t r = *pw;
-
-        if( r == 0 )
-        {
-            return r;
-        }
-
-        if( __builtin_expect( ( compare_and_swap( pw, r, r + 1 ) == r ), 1 ) )
-        {
-            return r;
-        }
-    }    
-}
-
-class sp_counted_base
-{
-private:
-
-    sp_counted_base( sp_counted_base const & );
-    sp_counted_base & operator= ( sp_counted_base const & );
-
-    uint32_t use_count_;        // #shared
-    uint32_t weak_count_;       // #weak + (#shared != 0)
-
-public:
-
-    sp_counted_base(): use_count_( 1 ), weak_count_( 1 )
-    {
-    }
-
-    virtual ~sp_counted_base() // nothrow
-    {
-    }
-
-    // dispose() is called when use_count_ drops to zero, to release
-    // the resources managed by *this.
-
-    virtual void dispose() = 0; // nothrow
-
-    // destroy() is called when weak_count_ drops to zero.
-
-    virtual void destroy() // nothrow
-    {
-        delete this;
-    }
-
-    virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
-    virtual void * get_untyped_deleter() = 0;
-
-    void add_ref_copy()
-    {
-        atomic_increment( &use_count_ );
-    }
-
-    bool add_ref_lock() // true on success
-    {
-        return atomic_conditional_increment( &use_count_ ) != 0;
-    }
-
-    void release() // nothrow
-    {
-        if( atomic_decrement( &use_count_ ) == 1 )
-        {
-            dispose();
-            weak_release();
-        }
-    }
-
-    void weak_add_ref() // nothrow
-    {
-        atomic_increment( &weak_count_ );
-    }
-
-    void weak_release() // nothrow
-    {
-        if( atomic_decrement( &weak_count_ ) == 1 )
-        {
-            destroy();
-        }
-    }
-
-    long use_count() const // nothrow
-    {
-        return const_cast< uint32_t const volatile & >( use_count_ );
-    }
-};
-
-} // namespace detail
-
-} // namespace boost
-
-#endif  // #ifndef BOOST_SMART_PTR_DETAIL_SP_COUNTED_BASE_SNC_PS3_HPP_INCLUDED

include/boost/smart_ptr/detail/sp_counted_base_solaris.hpp

@@ -62,7 +62,6 @@ public:
     }
 
     virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
-    virtual void * get_untyped_deleter() = 0;
 
     void add_ref_copy()
     {

include/boost/smart_ptr/detail/sp_counted_base_spin.hpp

@@ -84,7 +84,6 @@ public:
     }
 
     virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
-    virtual void * get_untyped_deleter() = 0;
 
     void add_ref_copy()
     {

include/boost/smart_ptr/detail/sp_counted_base_std_atomic.hpp

@@ -1,137 +0,0 @@
-#ifndef BOOST_SMART_PTR_DETAIL_SP_COUNTED_BASE_STD_ATOMIC_HPP_INCLUDED
-#define BOOST_SMART_PTR_DETAIL_SP_COUNTED_BASE_STD_ATOMIC_HPP_INCLUDED
-
-// MS compatible compilers support #pragma once
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-//  detail/sp_counted_base_std_atomic.hpp - C++11 std::atomic
-//
-//  Copyright (c) 2007, 2013 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/detail/sp_typeinfo.hpp>
-#include <atomic>
-#include <cstdint>
-
-namespace boost
-{
-
-namespace detail
-{
-
-inline void atomic_increment( std::atomic_int_least32_t * pw )
-{
-    pw->fetch_add( 1, std::memory_order_relaxed );
-}
-
-inline std::int_least32_t atomic_decrement( std::atomic_int_least32_t * pw )
-{
-    return pw->fetch_sub( 1, std::memory_order_acq_rel );
-}
-
-inline std::int_least32_t atomic_conditional_increment( std::atomic_int_least32_t * pw )
-{
-    // long r = *pw;
-    // if( r != 0 ) ++*pw;
-    // return r;
-
-    std::int_least32_t r = pw->load( std::memory_order_relaxed );
-
-    for( ;; )
-    {
-        if( r == 0 )
-        {
-            return r;
-        }
-
-        if( pw->compare_exchange_weak( r, r + 1, std::memory_order_relaxed, std::memory_order_relaxed ) )
-        {
-            return r;
-        }
-    }    
-}
-
-class sp_counted_base
-{
-private:
-
-    sp_counted_base( sp_counted_base const & );
-    sp_counted_base & operator= ( sp_counted_base const & );
-
-    std::atomic_int_least32_t use_count_;	// #shared
-    std::atomic_int_least32_t weak_count_;	// #weak + (#shared != 0)
-
-public:
-
-    sp_counted_base(): use_count_( 1 ), weak_count_( 1 )
-    {
-    }
-
-    virtual ~sp_counted_base() // nothrow
-    {
-    }
-
-    // dispose() is called when use_count_ drops to zero, to release
-    // the resources managed by *this.
-
-    virtual void dispose() = 0; // nothrow
-
-    // destroy() is called when weak_count_ drops to zero.
-
-    virtual void destroy() // nothrow
-    {
-        delete this;
-    }
-
-    virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
-    virtual void * get_untyped_deleter() = 0;
-
-    void add_ref_copy()
-    {
-        atomic_increment( &use_count_ );
-    }
-
-    bool add_ref_lock() // true on success
-    {
-        return atomic_conditional_increment( &use_count_ ) != 0;
-    }
-
-    void release() // nothrow
-    {
-        if( atomic_decrement( &use_count_ ) == 1 )
-        {
-            dispose();
-            weak_release();
-        }
-    }
-
-    void weak_add_ref() // nothrow
-    {
-        atomic_increment( &weak_count_ );
-    }
-
-    void weak_release() // nothrow
-    {
-        if( atomic_decrement( &weak_count_ ) == 1 )
-        {
-            destroy();
-        }
-    }
-
-    long use_count() const // nothrow
-    {
-        return use_count_.load( std::memory_order_acquire );
-    }
-};
-
-} // namespace detail
-
-} // namespace boost
-
-#endif  // #ifndef BOOST_SMART_PTR_DETAIL_SP_COUNTED_BASE_STD_ATOMIC_HPP_INCLUDED

include/boost/smart_ptr/detail/sp_counted_base_sync.hpp

@@ -109,7 +109,6 @@ public:
     }
 
     virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
-    virtual void * get_untyped_deleter() = 0;
 
     void add_ref_copy()
     {

include/boost/smart_ptr/detail/sp_counted_base_vacpp_ppc.hpp

@@ -1,151 +0,0 @@
-#ifndef BOOST_SMART_PTR_DETAIL_SP_COUNTED_BASE_VACPP_PPC_HPP_INCLUDED
-#define BOOST_SMART_PTR_DETAIL_SP_COUNTED_BASE_VACPP_PPC_HPP_INCLUDED
-
-//
-//  detail/sp_counted_base_vacpp_ppc.hpp - xlC(vacpp) on POWER
-//   based on: detail/sp_counted_base_w32.hpp
-//
-//  Copyright (c) 2001, 2002, 2003 Peter Dimov and Multi Media Ltd.
-//  Copyright 2004-2005 Peter Dimov
-//  Copyright 2006 Michael van der Westhuizen
-//  Copyright 2012 IBM Corp.
-//
-//  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)
-//
-//
-//  Lock-free algorithm by Alexander Terekhov
-//
-//  Thanks to Ben Hitchings for the #weak + (#shared != 0)
-//  formulation
-//
-
-#include <boost/detail/sp_typeinfo.hpp>
-
-extern "builtin" void __lwsync(void);
-extern "builtin" void __isync(void);
-extern "builtin" int __fetch_and_add(volatile int* addr, int val);
-extern "builtin" int __compare_and_swap(volatile int*, int*, int);
-
-namespace boost
-{
-
-namespace detail
-{
-
-inline void atomic_increment( int *pw )
-{
-   // ++*pw;
-   __lwsync();
-   __fetch_and_add(pw, 1);
-   __isync();
-} 
-
-inline int atomic_decrement( int *pw )
-{
-   // return --*pw;
-   __lwsync();
-   int originalValue = __fetch_and_add(pw, -1);
-   __isync();
-
-   return (originalValue - 1);
-}
-
-inline int atomic_conditional_increment( int *pw )
-{
-   // if( *pw != 0 ) ++*pw;
-   // return *pw;
-
-   __lwsync();
-   int v = *const_cast<volatile int*>(pw);
-   for (;;)
-   // loop until state is known
-   {
-      if (v == 0) return 0;
-      if (__compare_and_swap(pw, &v, v + 1))
-      {
-         __isync(); return (v + 1);
-      }
-   }
-}
-
-class sp_counted_base
-{
-private:
-
-    sp_counted_base( sp_counted_base const & );
-    sp_counted_base & operator= ( sp_counted_base const & );
-
-    int use_count_;        // #shared
-    int weak_count_;       // #weak + (#shared != 0)
-    char pad[64] __attribute__((__aligned__(64)));
-            // pad to prevent false sharing
-public:
-
-    sp_counted_base(): use_count_( 1 ), weak_count_( 1 )
-    {
-    }
-
-    virtual ~sp_counted_base() // nothrow
-    {
-    }
-
-    // dispose() is called when use_count_ drops to zero, to release
-    // the resources managed by *this.
-
-    virtual void dispose() = 0; // nothrow
-
-    // destroy() is called when weak_count_ drops to zero.
-
-    virtual void destroy() // nothrow
-    {
-        delete this;
-    }
-
-    virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
-    virtual void * get_untyped_deleter() = 0;
-
-    void add_ref_copy()
-    {
-        atomic_increment( &use_count_ );
-    }
-
-    bool add_ref_lock() // true on success
-    {
-        return atomic_conditional_increment( &use_count_ ) != 0;
-    }
-
-    void release() // nothrow
-    {
-        if( atomic_decrement( &use_count_ ) == 0 )
-        {
-            dispose();
-            weak_release();
-        }
-    }
-
-    void weak_add_ref() // nothrow
-    {
-        atomic_increment( &weak_count_ );
-    }
-
-    void weak_release() // nothrow
-    {
-        if( atomic_decrement( &weak_count_ ) == 0 )
-        {
-            destroy();
-        }
-    }
-
-    long use_count() const // nothrow
-    {
-        return *const_cast<volatile int*>(&use_count_); 
-    }
-};
-
-} // namespace detail
-
-} // namespace boost
-
-#endif  // #ifndef BOOST_SMART_PTR_DETAIL_SP_COUNTED_BASE_VACPP_PPC_HPP_INCLUDED

include/boost/smart_ptr/detail/sp_counted_base_w32.hpp

@@ -24,7 +24,7 @@
 //  formulation
 //
 
-#include <boost/smart_ptr/detail/sp_interlocked.hpp>
+#include <boost/detail/interlocked.hpp>
 #include <boost/detail/workaround.hpp>
 #include <boost/detail/sp_typeinfo.hpp>
 
@@ -67,11 +67,10 @@ public:
     }
 
     virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
-    virtual void * get_untyped_deleter() = 0;
 
     void add_ref_copy()
     {
-        BOOST_SP_INTERLOCKED_INCREMENT( &use_count_ );
+        BOOST_INTERLOCKED_INCREMENT( &use_count_ );
     }
 
     bool add_ref_lock() // true on success
@@ -86,11 +85,11 @@ public:
             // work around a code generation bug
 
             long tmp2 = tmp + 1;
-            if( BOOST_SP_INTERLOCKED_COMPARE_EXCHANGE( &use_count_, tmp2, tmp ) == tmp2 - 1 ) return true;
+            if( BOOST_INTERLOCKED_COMPARE_EXCHANGE( &use_count_, tmp2, tmp ) == tmp2 - 1 ) return true;
 
 #else
 
-            if( BOOST_SP_INTERLOCKED_COMPARE_EXCHANGE( &use_count_, tmp + 1, tmp ) == tmp ) return true;
+            if( BOOST_INTERLOCKED_COMPARE_EXCHANGE( &use_count_, tmp + 1, tmp ) == tmp ) return true;
 
 #endif
         }
@@ -98,7 +97,7 @@ public:
 
     void release() // nothrow
     {
-        if( BOOST_SP_INTERLOCKED_DECREMENT( &use_count_ ) == 0 )
+        if( BOOST_INTERLOCKED_DECREMENT( &use_count_ ) == 0 )
         {
             dispose();
             weak_release();
@@ -107,12 +106,12 @@ public:
 
     void weak_add_ref() // nothrow
     {
-        BOOST_SP_INTERLOCKED_INCREMENT( &weak_count_ );
+        BOOST_INTERLOCKED_INCREMENT( &weak_count_ );
     }
 
     void weak_release() // nothrow
     {
-        if( BOOST_SP_INTERLOCKED_DECREMENT( &weak_count_ ) == 0 )
+        if( BOOST_INTERLOCKED_DECREMENT( &weak_count_ ) == 0 )
         {
             destroy();
         }

include/boost/smart_ptr/detail/sp_counted_impl.hpp

@@ -78,12 +78,7 @@ public:
         boost::checked_delete( px_ );
     }
 
-    virtual void * get_deleter( sp_typeinfo const & )
-    {
-        return 0;
-    }
-
-    virtual void * get_untyped_deleter()
+    virtual void * get_deleter( detail::sp_typeinfo const & )
     {
         return 0;
     }
@@ -140,11 +135,7 @@ public:
 
     // pre: d(p) must not throw
 
-    sp_counted_impl_pd( P p, D & d ): ptr( p ), del( d )
-    {
-    }
-
-    sp_counted_impl_pd( P p ): ptr( p ), del()
+    sp_counted_impl_pd( P p, D d ): ptr(p), del(d)
     {
     }
 
@@ -153,16 +144,11 @@ public:
         del( ptr );
     }
 
-    virtual void * get_deleter( sp_typeinfo const & ti )
+    virtual void * get_deleter( detail::sp_typeinfo const & ti )
     {
         return ti == BOOST_SP_TYPEID(D)? &reinterpret_cast<char&>( del ): 0;
     }
 
-    virtual void * get_untyped_deleter()
-    {
-        return &reinterpret_cast<char&>( del );
-    }
-
 #if defined(BOOST_SP_USE_STD_ALLOCATOR)
 
     void * operator new( std::size_t )
@@ -209,11 +195,7 @@ public:
 
     // pre: d( p ) must not throw
 
-    sp_counted_impl_pda( P p, D & d, A a ): p_( p ), d_( d ), a_( a )
-    {
-    }
-
-    sp_counted_impl_pda( P p, A a ): p_( p ), d_( a ), a_( a )
+    sp_counted_impl_pda( P p, D d, A a ): p_( p ), d_( d ), a_( a )
     {
     }
 
@@ -224,32 +206,18 @@ public:
 
     virtual void destroy() // nothrow
     {
-#if !defined( BOOST_NO_CXX11_ALLOCATOR )
-
-        typedef typename std::allocator_traits<A>::template rebind_alloc< this_type > A2;
-
-#else
-
         typedef typename A::template rebind< this_type >::other A2;
 
-#endif
-
         A2 a2( a_ );
 
         this->~this_type();
-
         a2.deallocate( this, 1 );
     }
 
-    virtual void * get_deleter( sp_typeinfo const & ti )
+    virtual void * get_deleter( detail::sp_typeinfo const & ti )
     {
         return ti == BOOST_SP_TYPEID( D )? &reinterpret_cast<char&>( d_ ): 0;
     }
-
-    virtual void * get_untyped_deleter()
-    {
-        return &reinterpret_cast<char&>( d_ );
-    }
 };
 
 #ifdef __CODEGUARD__

include/boost/smart_ptr/detail/sp_disable_deprecated.hpp

@@ -1,40 +0,0 @@
-#ifndef BOOST_SMART_PTR_DETAIL_SP_DISABLE_DEPRECATED_HPP_INCLUDED
-#define BOOST_SMART_PTR_DETAIL_SP_DISABLE_DEPRECATED_HPP_INCLUDED
-
-// MS compatible compilers support #pragma once
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-//
-//  boost/smart_ptr/detail/sp_disable_deprecated.hpp
-//
-//  Copyright 2015 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/config.hpp>
-
-#if defined( __GNUC__ ) && ( defined( __GXX_EXPERIMENTAL_CXX0X__ ) || ( __cplusplus >= 201103L ) )
-
-# if defined( BOOST_GCC )
-
-#  if BOOST_GCC >= 40600
-#   define BOOST_SP_DISABLE_DEPRECATED
-#  endif
-
-# elif defined( __clang__ ) && defined( __has_warning )
-
-#  if __has_warning( "-Wdeprecated-declarations" )
-#   define BOOST_SP_DISABLE_DEPRECATED
-#  endif
-
-# endif
-
-#endif
-
-#endif // #ifndef BOOST_SMART_PTR_DETAIL_SP_DISABLE_DEPRECATED_HPP_INCLUDED

include/boost/smart_ptr/detail/sp_forward.hpp

@@ -1,52 +0,0 @@
-#ifndef BOOST_SMART_PTR_DETAIL_SP_FORWARD_HPP_INCLUDED
-#define BOOST_SMART_PTR_DETAIL_SP_FORWARD_HPP_INCLUDED
-
-// MS compatible compilers support #pragma once
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-//  detail/sp_forward.hpp
-//
-//  Copyright 2008,2012 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/config.hpp>
-
-namespace boost
-{
-
-namespace detail
-{
-
-#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
-
-#if defined( BOOST_GCC ) && __GNUC__ * 100 + __GNUC_MINOR__ <= 404
-
-// GCC 4.4 supports an outdated version of rvalue references and creates a copy of the forwarded object.
-// This results in warnings 'returning reference to temporary'. Therefore we use a special version similar to std::forward.
-template< class T > T&& sp_forward( T && t ) BOOST_NOEXCEPT
-{
-    return t;
-}
-
-#else
-
-template< class T > T&& sp_forward( T & t ) BOOST_NOEXCEPT
-{
-    return static_cast< T&& >( t );
-}
-
-#endif
-
-#endif
-
-} // namespace detail
-
-} // namespace boost
-
-#endif  // #ifndef BOOST_SMART_PTR_DETAIL_SP_FORWARD_HPP_INCLUDED

include/boost/smart_ptr/detail/sp_has_sync.hpp

@@ -20,17 +20,7 @@
 //  are available.
 //
 
-#ifndef BOOST_SP_NO_SYNC
-
-#if !defined( __c2__ ) && defined( __GCC_HAVE_SYNC_COMPARE_AND_SWAP_4 )
-
-# define BOOST_SP_HAS_SYNC
-
-#elif defined( __IBMCPP__ ) && ( __IBMCPP__ >= 1210 ) && !defined( __COMPILER_VER__ )
-
-# define BOOST_SP_HAS_SYNC
-
-#elif !defined( __c2__ ) && defined( __GNUC__ ) && ( __GNUC__ * 100 + __GNUC_MINOR__ >= 401 )
+#if defined(__GNUC__) && ( __GNUC__ * 100 + __GNUC_MINOR__ >= 401 )
 
 #define BOOST_SP_HAS_SYNC
 
@@ -46,24 +36,14 @@
 #undef BOOST_SP_HAS_SYNC
 #endif
 
-#if defined( __sh__ )
-#undef BOOST_SP_HAS_SYNC
-#endif
-
 #if defined( __sparc__ )
 #undef BOOST_SP_HAS_SYNC
 #endif
 
-#if defined( __INTEL_COMPILER ) && !defined( __ia64__ ) && ( __INTEL_COMPILER < 1110 )
+#if defined( __INTEL_COMPILER ) && !defined( __ia64__ ) && ( __INTEL_COMPILER < 1100 )
 #undef BOOST_SP_HAS_SYNC
 #endif
 
-#if defined(__PATHSCALE__) && ((__PATHCC__ == 4) && (__PATHCC_MINOR__ < 9)) 
-#undef BOOST_SP_HAS_SYNC
-#endif
-
-#endif
-
-#endif // #ifndef BOOST_SP_NO_SYNC
+#endif // __GNUC__ * 100 + __GNUC_MINOR__ >= 401
 
 #endif // #ifndef BOOST_SMART_PTR_DETAIL_SP_HAS_SYNC_HPP_INCLUDED

include/boost/smart_ptr/detail/sp_interlocked.hpp

@@ -1,163 +0,0 @@
-#ifndef BOOST_SMART_PTR_DETAIL_SP_INTERLOCKED_HPP_INCLUDED
-#define BOOST_SMART_PTR_DETAIL_SP_INTERLOCKED_HPP_INCLUDED
-
-// MS compatible compilers support #pragma once
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-//
-//  boost/detail/sp_interlocked.hpp
-//
-//  Copyright 2005, 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/config.hpp>
-
-// BOOST_SP_HAS_INTRIN_H
-
-// VC9 has intrin.h, but it collides with <utility>
-#if defined( BOOST_MSVC ) && BOOST_MSVC >= 1600
-
-# define BOOST_SP_HAS_INTRIN_H
-
-// Unlike __MINGW64__, __MINGW64_VERSION_MAJOR is defined by MinGW-w64 for both 32 and 64-bit targets.
-#elif defined( __MINGW64_VERSION_MAJOR )
-
-// MinGW-w64 provides intrin.h for both 32 and 64-bit targets.
-# define BOOST_SP_HAS_INTRIN_H
-
-// Intel C++ on Windows on VC10+ stdlib
-#elif defined( BOOST_INTEL_WIN ) && defined( _CPPLIB_VER ) && _CPPLIB_VER >= 520
-
-# define BOOST_SP_HAS_INTRIN_H
-
-#endif
-
-#if defined( BOOST_USE_WINDOWS_H )
-
-# include <windows.h>
-
-# define BOOST_SP_INTERLOCKED_INCREMENT InterlockedIncrement
-# define BOOST_SP_INTERLOCKED_DECREMENT InterlockedDecrement
-# define BOOST_SP_INTERLOCKED_COMPARE_EXCHANGE InterlockedCompareExchange
-# define BOOST_SP_INTERLOCKED_EXCHANGE InterlockedExchange
-# define BOOST_SP_INTERLOCKED_EXCHANGE_ADD InterlockedExchangeAdd
-
-#elif defined( BOOST_USE_INTRIN_H ) || defined( BOOST_SP_HAS_INTRIN_H )
-
-#include <intrin.h>
-
-# define BOOST_SP_INTERLOCKED_INCREMENT _InterlockedIncrement
-# define BOOST_SP_INTERLOCKED_DECREMENT _InterlockedDecrement
-# define BOOST_SP_INTERLOCKED_COMPARE_EXCHANGE _InterlockedCompareExchange
-# define BOOST_SP_INTERLOCKED_EXCHANGE _InterlockedExchange
-# define BOOST_SP_INTERLOCKED_EXCHANGE_ADD _InterlockedExchangeAdd
-
-#elif defined( _WIN32_WCE )
-
-#if _WIN32_WCE >= 0x600
-
-extern "C" long __cdecl _InterlockedIncrement( long volatile * );
-extern "C" long __cdecl _InterlockedDecrement( long volatile * );
-extern "C" long __cdecl _InterlockedCompareExchange( long volatile *, long, long );
-extern "C" long __cdecl _InterlockedExchange( long volatile *, long );
-extern "C" long __cdecl _InterlockedExchangeAdd( long volatile *, long );
-
-# define BOOST_SP_INTERLOCKED_INCREMENT _InterlockedIncrement
-# define BOOST_SP_INTERLOCKED_DECREMENT _InterlockedDecrement
-# define BOOST_SP_INTERLOCKED_COMPARE_EXCHANGE _InterlockedCompareExchange
-# define BOOST_SP_INTERLOCKED_EXCHANGE _InterlockedExchange
-# define BOOST_SP_INTERLOCKED_EXCHANGE_ADD _InterlockedExchangeAdd
-
-#else
-
-// under Windows CE we still have old-style Interlocked* functions
-
-extern "C" long __cdecl InterlockedIncrement( long* );
-extern "C" long __cdecl InterlockedDecrement( long* );
-extern "C" long __cdecl InterlockedCompareExchange( long*, long, long );
-extern "C" long __cdecl InterlockedExchange( long*, long );
-extern "C" long __cdecl InterlockedExchangeAdd( long*, long );
-
-# define BOOST_SP_INTERLOCKED_INCREMENT InterlockedIncrement
-# define BOOST_SP_INTERLOCKED_DECREMENT InterlockedDecrement
-# define BOOST_SP_INTERLOCKED_COMPARE_EXCHANGE InterlockedCompareExchange
-# define BOOST_SP_INTERLOCKED_EXCHANGE InterlockedExchange
-# define BOOST_SP_INTERLOCKED_EXCHANGE_ADD InterlockedExchangeAdd
-
-#endif
-
-#elif defined( BOOST_MSVC ) || defined( BOOST_INTEL_WIN )
-
-#if defined( __CLRCALL_PURE_OR_CDECL )
-
-extern "C" long __CLRCALL_PURE_OR_CDECL _InterlockedIncrement( long volatile * );
-extern "C" long __CLRCALL_PURE_OR_CDECL _InterlockedDecrement( long volatile * );
-extern "C" long __CLRCALL_PURE_OR_CDECL _InterlockedCompareExchange( long volatile *, long, long );
-extern "C" long __CLRCALL_PURE_OR_CDECL _InterlockedExchange( long volatile *, long );
-extern "C" long __CLRCALL_PURE_OR_CDECL _InterlockedExchangeAdd( long volatile *, long );
-
-#else
-
-extern "C" long __cdecl _InterlockedIncrement( long volatile * );
-extern "C" long __cdecl _InterlockedDecrement( long volatile * );
-extern "C" long __cdecl _InterlockedCompareExchange( long volatile *, long, long );
-extern "C" long __cdecl _InterlockedExchange( long volatile *, long );
-extern "C" long __cdecl _InterlockedExchangeAdd( long volatile *, long );
-
-# if defined( BOOST_MSVC ) && BOOST_MSVC == 1310
-//From MSDN, Visual Studio .NET 2003 spedific: To declare one of the interlocked functions
-//for use as an intrinsic, the function must be declared with the leading underscore and
-//the new function must appear in a #pragma intrinsic statement.
-#  pragma intrinsic( _InterlockedIncrement )
-#  pragma intrinsic( _InterlockedDecrement )
-#  pragma intrinsic( _InterlockedCompareExchange )
-#  pragma intrinsic( _InterlockedExchange )
-#  pragma intrinsic( _InterlockedExchangeAdd )
-# endif
-
-#endif
-
-# define BOOST_SP_INTERLOCKED_INCREMENT _InterlockedIncrement
-# define BOOST_SP_INTERLOCKED_DECREMENT _InterlockedDecrement
-# define BOOST_SP_INTERLOCKED_COMPARE_EXCHANGE _InterlockedCompareExchange
-# define BOOST_SP_INTERLOCKED_EXCHANGE _InterlockedExchange
-# define BOOST_SP_INTERLOCKED_EXCHANGE_ADD _InterlockedExchangeAdd
-
-#elif defined( WIN32 ) || defined( _WIN32 ) || defined( __WIN32__ ) || defined( __CYGWIN__ )
-
-namespace boost
-{
-
-namespace detail
-{
-
-extern "C" __declspec(dllimport) long __stdcall InterlockedIncrement( long volatile * );
-extern "C" __declspec(dllimport) long __stdcall InterlockedDecrement( long volatile * );
-extern "C" __declspec(dllimport) long __stdcall InterlockedCompareExchange( long volatile *, long, long );
-extern "C" __declspec(dllimport) long __stdcall InterlockedExchange( long volatile *, long );
-extern "C" __declspec(dllimport) long __stdcall InterlockedExchangeAdd( long volatile *, long );
-
-} // namespace detail
-
-} // namespace boost
-
-# define BOOST_SP_INTERLOCKED_INCREMENT ::boost::detail::InterlockedIncrement
-# define BOOST_SP_INTERLOCKED_DECREMENT ::boost::detail::InterlockedDecrement
-# define BOOST_SP_INTERLOCKED_COMPARE_EXCHANGE ::boost::detail::InterlockedCompareExchange
-# define BOOST_SP_INTERLOCKED_EXCHANGE ::boost::detail::InterlockedExchange
-# define BOOST_SP_INTERLOCKED_EXCHANGE_ADD ::boost::detail::InterlockedExchangeAdd
-
-#else
-
-# error "Interlocked intrinsics not available"
-
-#endif
-
-#endif // #ifndef BOOST_SMART_PTR_DETAIL_SP_INTERLOCKED_HPP_INCLUDED

include/boost/smart_ptr/detail/sp_noexcept.hpp

@@ -1,30 +0,0 @@
-#ifndef BOOST_SMART_PTR_DETAIL_SP_NOEXCEPT_HPP_INCLUDED
-#define BOOST_SMART_PTR_DETAIL_SP_NOEXCEPT_HPP_INCLUDED
-
-// MS compatible compilers support #pragma once
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-//  detail/sp_noexcept.hpp
-//
-//  Copyright 2016 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/config.hpp>
-
-#if defined( BOOST_MSVC ) && BOOST_MSVC >= 1700 && BOOST_MSVC < 1900
-
-#define BOOST_SP_NOEXCEPT BOOST_NOEXCEPT_OR_NOTHROW
-
-#else
-
-#define BOOST_SP_NOEXCEPT BOOST_NOEXCEPT
-
-#endif
-
-#endif  // #ifndef BOOST_SMART_PTR_DETAIL_SP_NOEXCEPT_HPP_INCLUDED

include/boost/smart_ptr/detail/sp_nullptr_t.hpp

@@ -1,45 +0,0 @@
-#ifndef BOOST_SMART_PTR_DETAIL_SP_NULLPTR_T_HPP_INCLUDED
-#define BOOST_SMART_PTR_DETAIL_SP_NULLPTR_T_HPP_INCLUDED
-
-// MS compatible compilers support #pragma once
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-//  detail/sp_nullptr_t.hpp
-//
-//  Copyright 2013 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/config.hpp>
-#include <cstddef>
-
-#if !defined( BOOST_NO_CXX11_NULLPTR )
-
-namespace boost
-{
-
-namespace detail
-{
-
-#if !defined( BOOST_NO_CXX11_DECLTYPE ) && ( ( defined( __clang__ ) && !defined( _LIBCPP_VERSION ) ) || defined( __INTEL_COMPILER ) )
-
-    typedef decltype(nullptr) sp_nullptr_t;
-
-#else
-
-    typedef std::nullptr_t sp_nullptr_t;
-
-#endif
-
-} // namespace detail
-
-} // namespace boost
-
-#endif // !defined( BOOST_NO_CXX11_NULLPTR )
-
-#endif  // #ifndef BOOST_SMART_PTR_DETAIL_SP_NULLPTR_T_HPP_INCLUDED

include/boost/smart_ptr/detail/spinlock.hpp

@@ -31,22 +31,7 @@
 #include <boost/config.hpp>
 #include <boost/smart_ptr/detail/sp_has_sync.hpp>
 
-#if defined( BOOST_SP_USE_STD_ATOMIC )
-# if !defined( __clang__ )
-#   include <boost/smart_ptr/detail/spinlock_std_atomic.hpp>
-# else
-//  Clang (at least up to 3.4) can't compile spinlock_pool when
-//  using std::atomic, so substitute the __sync implementation instead.
-#   include <boost/smart_ptr/detail/spinlock_sync.hpp>
-# endif
-
-#elif defined( BOOST_SP_USE_PTHREADS )
-#  include <boost/smart_ptr/detail/spinlock_pt.hpp>
-
-#elif !defined( BOOST_NO_CXX11_HDR_ATOMIC )
-#  include <boost/smart_ptr/detail/spinlock_std_atomic.hpp>
-
-#elif defined(__GNUC__) && defined( __arm__ ) && !defined( __thumb__ )
+#if defined(__GNUC__) && defined( __arm__ ) && !defined( __thumb__ )
 #  include <boost/smart_ptr/detail/spinlock_gcc_arm.hpp>
 
 #elif defined( BOOST_SP_HAS_SYNC )

include/boost/smart_ptr/detail/spinlock_gcc_arm.hpp

@@ -2,7 +2,7 @@
 #define BOOST_SMART_PTR_DETAIL_SPINLOCK_GCC_ARM_HPP_INCLUDED
 
 //
-//  Copyright (c) 2008, 2011 Peter Dimov
+//  Copyright (c) 2008 Peter Dimov
 //
 //  Distributed under the Boost Software License, Version 1.0.
 //  See accompanying file LICENSE_1_0.txt or copy at
@@ -11,22 +11,6 @@
 
 #include <boost/smart_ptr/detail/yield_k.hpp>
 
-#if defined(__ARM_ARCH_7__) || defined(__ARM_ARCH_7A__) || defined(__ARM_ARCH_7R__) || defined(__ARM_ARCH_7M__) || defined(__ARM_ARCH_7EM__) || defined(__ARM_ARCH_7S__)
-
-# define BOOST_SP_ARM_BARRIER "dmb"
-# define BOOST_SP_ARM_HAS_LDREX
-
-#elif defined(__ARM_ARCH_6__) || defined(__ARM_ARCH_6J__) || defined(__ARM_ARCH_6K__) || defined(__ARM_ARCH_6Z__) || defined(__ARM_ARCH_6ZK__) || defined(__ARM_ARCH_6T2__)
-
-# define BOOST_SP_ARM_BARRIER "mcr p15, 0, r0, c7, c10, 5"
-# define BOOST_SP_ARM_HAS_LDREX
-
-#else
-
-# define BOOST_SP_ARM_BARRIER ""
-
-#endif
-
 namespace boost
 {
 
@@ -45,28 +29,12 @@ public:
     {
         int r;
 
-#ifdef BOOST_SP_ARM_HAS_LDREX
-
         __asm__ __volatile__(
-            "ldrex %0, [%2]; \n"
-            "cmp %0, %1; \n"
-            "strexne %0, %1, [%2]; \n"
-            BOOST_SP_ARM_BARRIER :
+            "swp %0, %1, [%2]":
             "=&r"( r ): // outputs
             "r"( 1 ), "r"( &v_ ): // inputs
             "memory", "cc" );
 
-#else
-
-        __asm__ __volatile__(
-            "swp %0, %1, [%2];\n"
-            BOOST_SP_ARM_BARRIER :
-            "=&r"( r ): // outputs
-            "r"( 1 ), "r"( &v_ ): // inputs
-            "memory", "cc" );
-
-#endif
-
         return r == 0;
     }
 
@@ -80,9 +48,8 @@ public:
 
     void unlock()
     {
-        __asm__ __volatile__( BOOST_SP_ARM_BARRIER ::: "memory" );
+        __asm__ __volatile__( "" ::: "memory" );
         *const_cast< int volatile* >( &v_ ) = 0;
-        __asm__ __volatile__( BOOST_SP_ARM_BARRIER ::: "memory" );
     }
 
 public:
@@ -115,7 +82,4 @@ public:
 
 #define BOOST_DETAIL_SPINLOCK_INIT {0}
 
-#undef BOOST_SP_ARM_BARRIER
-#undef BOOST_SP_ARM_HAS_LDREX
-
 #endif // #ifndef BOOST_SMART_PTR_DETAIL_SPINLOCK_GCC_ARM_HPP_INCLUDED

include/boost/smart_ptr/detail/spinlock_pool.hpp

@@ -31,7 +31,7 @@ namespace boost
 namespace detail
 {
 
-template< int M > class spinlock_pool
+template< int I > class spinlock_pool
 {
 private:
 
@@ -41,11 +41,7 @@ public:
 
     static spinlock & spinlock_for( void const * pv )
     {
-#if defined(__VMS) && __INITIAL_POINTER_SIZE == 64  
-        std::size_t i = reinterpret_cast< unsigned long long >( pv ) % 41;
-#else  
         std::size_t i = reinterpret_cast< std::size_t >( pv ) % 41;
-#endif  
         return pool_[ i ];
     }
 
@@ -72,7 +68,7 @@ public:
     };
 };
 
-template< int M > spinlock spinlock_pool< M >::pool_[ 41 ] =
+template< int I > spinlock spinlock_pool< I >::pool_[ 41 ] =
 {
     BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, 
     BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, 

include/boost/smart_ptr/detail/spinlock_std_atomic.hpp

@@ -1,83 +0,0 @@
-#ifndef BOOST_SMART_PTR_DETAIL_SPINLOCK_STD_ATOMIC_HPP_INCLUDED
-#define BOOST_SMART_PTR_DETAIL_SPINLOCK_STD_ATOMIC_HPP_INCLUDED
-
-// MS compatible compilers support #pragma once
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-//
-//  Copyright (c) 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/smart_ptr/detail/yield_k.hpp>
-#include <atomic>
-
-namespace boost
-{
-
-namespace detail
-{
-
-class spinlock
-{
-public:
-
-    std::atomic_flag v_;
-
-public:
-
-    bool try_lock()
-    {
-        return !v_.test_and_set( std::memory_order_acquire );
-    }
-
-    void lock()
-    {
-        for( unsigned k = 0; !try_lock(); ++k )
-        {
-            boost::detail::yield( k );
-        }
-    }
-
-    void unlock()
-    {
-        v_ .clear( std::memory_order_release );
-    }
-
-public:
-
-    class scoped_lock
-    {
-    private:
-
-        spinlock & sp_;
-
-        scoped_lock( scoped_lock const & );
-        scoped_lock & operator=( scoped_lock const & );
-
-    public:
-
-        explicit scoped_lock( spinlock & sp ): sp_( sp )
-        {
-            sp.lock();
-        }
-
-        ~scoped_lock()
-        {
-            sp_.unlock();
-        }
-    };
-};
-
-} // namespace detail
-} // namespace boost
-
-#define BOOST_DETAIL_SPINLOCK_INIT { ATOMIC_FLAG_INIT }
-
-#endif // #ifndef BOOST_SMART_PTR_DETAIL_SPINLOCK_STD_ATOMIC_HPP_INCLUDED

include/boost/smart_ptr/detail/spinlock_w32.hpp

@@ -15,7 +15,7 @@
 //  http://www.boost.org/LICENSE_1_0.txt)
 //
 
-#include <boost/smart_ptr/detail/sp_interlocked.hpp>
+#include <boost/detail/interlocked.hpp>
 #include <boost/smart_ptr/detail/yield_k.hpp>
 
 // BOOST_COMPILER_FENCE
@@ -59,7 +59,7 @@ public:
 
     bool try_lock()
     {
-        long r = BOOST_SP_INTERLOCKED_EXCHANGE( &v_, 1 );
+        long r = BOOST_INTERLOCKED_EXCHANGE( &v_, 1 );
 
         BOOST_COMPILER_FENCE
 

include/boost/smart_ptr/detail/yield_k.hpp

@@ -11,7 +11,6 @@
 //  yield_k.hpp
 //
 //  Copyright (c) 2008 Peter Dimov
-//  Copyright (c) Microsoft Corporation 2014
 //
 //  void yield( unsigned k );
 //
@@ -25,17 +24,13 @@
 //
 
 #include <boost/config.hpp>
-#include <boost/predef.h>
-
-#if BOOST_PLAT_WINDOWS_RUNTIME
-#include <thread>
-#endif
 
 // BOOST_SMT_PAUSE
 
 #if defined(_MSC_VER) && _MSC_VER >= 1310 && ( defined(_M_IX86) || defined(_M_X64) )
 
 extern "C" void _mm_pause();
+#pragma intrinsic( _mm_pause )
 
 #define BOOST_SMT_PAUSE _mm_pause();
 
@@ -59,17 +54,8 @@ namespace boost
 namespace detail
 {
 
-#if !defined( BOOST_USE_WINDOWS_H ) && !BOOST_PLAT_WINDOWS_RUNTIME
-#if !BOOST_COMP_CLANG || !defined __MINGW32__
+#if !defined( BOOST_USE_WINDOWS_H )
   extern "C" void __stdcall Sleep( unsigned long ms );
-#else
-#include <_mingw.h>
-#if !defined __MINGW64_VERSION_MAJOR
-  extern "C" void __stdcall Sleep( unsigned long ms );
-#else
-  extern "C" __declspec(dllimport) void __stdcall Sleep( unsigned long ms );
-#endif
-#endif
 #endif
 
 inline void yield( unsigned k )
@@ -83,7 +69,6 @@ inline void yield( unsigned k )
         BOOST_SMT_PAUSE
     }
 #endif
-#if !BOOST_PLAT_WINDOWS_RUNTIME
     else if( k < 32 )
     {
         Sleep( 0 );
@@ -92,13 +77,6 @@ inline void yield( unsigned k )
     {
         Sleep( 1 );
     }
-#else
-    else
-    {
-        // Sleep isn't supported on the Windows Runtime.
-        std::this_thread::yield();
-    }
-#endif
 }
 
 } // namespace detail
@@ -107,13 +85,7 @@ inline void yield( unsigned k )
 
 #elif defined( BOOST_HAS_PTHREADS )
 
-#ifndef _AIX
 #include <sched.h>
-#else
-   // AIX's sched.h defines ::var which sometimes conflicts with Lambda's var
-       extern "C" int sched_yield(void);
-#endif
-
 #include <time.h>
 
 namespace boost

include/boost/smart_ptr/enable_shared_from_raw.hpp

@@ -1,165 +0,0 @@
-#ifndef BOOST_ENABLE_SHARED_FROM_RAW_HPP_INCLUDED
-#define BOOST_ENABLE_SHARED_FROM_RAW_HPP_INCLUDED
-
-//
-//  enable_shared_from_raw.hpp
-//
-//  Copyright 2002, 2009, 2014 Peter Dimov
-//  Copyright 2008-2009 Frank Mori Hess
-//
-//  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>
-#include <boost/shared_ptr.hpp>
-#include <boost/weak_ptr.hpp>
-#include <boost/assert.hpp>
-#include <boost/detail/workaround.hpp>
-
-namespace boost
-{
-template<typename T> boost::shared_ptr<T> shared_from_raw(T *);
-template<typename T> boost::weak_ptr<T> weak_from_raw(T *);
-
-namespace detail
-{
-template< class X, class Y > inline void sp_enable_shared_from_this( boost::shared_ptr<X> * ppx, Y const * py, boost::enable_shared_from_raw const * pe );
-
-} // namespace detail
-
-class enable_shared_from_raw
-{
-protected:
-
-    enable_shared_from_raw()
-    {
-    }
-
-    enable_shared_from_raw( enable_shared_from_raw const & )
-    {
-    }
-
-    enable_shared_from_raw & operator=( enable_shared_from_raw const & )
-    {
-        return *this;
-    }
-
-    ~enable_shared_from_raw()
-    {
-        BOOST_ASSERT( shared_this_.use_count() <= 1 ); // make sure no dangling shared_ptr objects exist
-    }
-
-private:
-
-    void init_if_expired() const
-    {
-        if( weak_this_.expired() )
-        {
-            shared_this_.reset( static_cast<void*>(0), detail::esft2_deleter_wrapper() );
-            weak_this_ = shared_this_;
-        }
-    }
-
-    void init_if_empty() const
-    {
-        if( weak_this_._empty() )
-        {
-            shared_this_.reset( static_cast<void*>(0), detail::esft2_deleter_wrapper() );
-            weak_this_ = shared_this_;
-        }
-    }
-
-#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
-public:
-#else
-private:
-    template<class Y> friend class shared_ptr;
-    template<typename T> friend boost::shared_ptr<T> shared_from_raw(T *);
-    template<typename T> friend boost::weak_ptr<T> weak_from_raw(T *);
-    template< class X, class Y > friend inline void detail::sp_enable_shared_from_this( boost::shared_ptr<X> * ppx, Y const * py, boost::enable_shared_from_raw const * pe );
-#endif
-
-    shared_ptr<void const volatile> shared_from_this() const
-    {
-        init_if_expired();
-        return shared_ptr<void const volatile>( weak_this_ );
-    }
-
-    shared_ptr<void const volatile> shared_from_this() const volatile
-    {
-        return const_cast< enable_shared_from_raw const * >( this )->shared_from_this();
-    }
-
-    weak_ptr<void const volatile> weak_from_this() const
-    {
-        init_if_empty();
-        return weak_this_;
-    }
-
-    weak_ptr<void const volatile> weak_from_this() const volatile
-    {
-        return const_cast< enable_shared_from_raw const * >( this )->weak_from_this();
-    }
-
-    // Note: invoked automatically by shared_ptr; do not call
-    template<class X, class Y> void _internal_accept_owner( shared_ptr<X> * ppx, Y * ) const
-    {
-        BOOST_ASSERT( ppx != 0 );
-
-        if( weak_this_.expired() )
-        {
-            weak_this_ = *ppx;
-        }
-        else if( shared_this_.use_count() != 0 )
-        {
-            BOOST_ASSERT( ppx->unique() ); // no weak_ptrs should exist either, but there's no way to check that
-
-            detail::esft2_deleter_wrapper * pd = boost::get_deleter<detail::esft2_deleter_wrapper>( shared_this_ );
-            BOOST_ASSERT( pd != 0 );
-
-            pd->set_deleter( *ppx );
-
-            ppx->reset( shared_this_, ppx->get() );
-            shared_this_.reset();
-        }
-    }
-
-    mutable weak_ptr<void const volatile> weak_this_;
-
-private:
-
-    mutable shared_ptr<void const volatile> shared_this_;
-};
-
-template<typename T>
-boost::shared_ptr<T> shared_from_raw(T *p)
-{
-    BOOST_ASSERT(p != 0);
-    return boost::shared_ptr<T>(p->enable_shared_from_raw::shared_from_this(), p);
-}
-
-template<typename T>
-boost::weak_ptr<T> weak_from_raw(T *p)
-{
-    BOOST_ASSERT(p != 0);
-    boost::weak_ptr<T> result;
-    result._internal_aliasing_assign(p->enable_shared_from_raw::weak_from_this(), p);
-    return result;
-}
-
-namespace detail
-{
-    template< class X, class Y > inline void sp_enable_shared_from_this( boost::shared_ptr<X> * ppx, Y const * py, boost::enable_shared_from_raw const * pe )
-    {
-        if( pe != 0 )
-        {
-            pe->_internal_accept_owner( ppx, const_cast< Y* >( py ) );
-        }
-    }
-} // namepsace detail
-
-} // namespace boost
-
-#endif  // #ifndef BOOST_ENABLE_SHARED_FROM_RAW_HPP_INCLUDED

include/boost/smart_ptr/enable_shared_from_this.hpp

@@ -15,7 +15,6 @@
 
 #include <boost/smart_ptr/weak_ptr.hpp>
 #include <boost/smart_ptr/shared_ptr.hpp>
-#include <boost/smart_ptr/detail/sp_noexcept.hpp>
 #include <boost/assert.hpp>
 #include <boost/config.hpp>
 
@@ -26,20 +25,20 @@ template<class T> class enable_shared_from_this
 {
 protected:
 
-    enable_shared_from_this() BOOST_SP_NOEXCEPT
+    enable_shared_from_this()
     {
     }
 
-    enable_shared_from_this(enable_shared_from_this const &) BOOST_SP_NOEXCEPT
+    enable_shared_from_this(enable_shared_from_this const &)
     {
     }
 
-    enable_shared_from_this & operator=(enable_shared_from_this const &) BOOST_SP_NOEXCEPT
+    enable_shared_from_this & operator=(enable_shared_from_this const &)
     {
         return *this;
     }
 
-    ~enable_shared_from_this() BOOST_SP_NOEXCEPT // ~weak_ptr<T> newer throws, so this call also must not throw
+    ~enable_shared_from_this()
     {
     }
 
@@ -59,16 +58,6 @@ public:
         return p;
     }
 
-    weak_ptr<T> weak_from_this() BOOST_NOEXCEPT
-    {
-        return weak_this_;
-    }
-
-    weak_ptr<T const> weak_from_this() const BOOST_NOEXCEPT
-    {
-        return weak_this_;
-    }
-
 public: // actually private, but avoids compiler template friendship issues
 
     // Note: invoked automatically by shared_ptr; do not call

include/boost/smart_ptr/enable_shared_from_this2.hpp

@@ -0,0 +1,132 @@
+#ifndef BOOST_ENABLE_SHARED_FROM_THIS2_HPP_INCLUDED
+#define BOOST_ENABLE_SHARED_FROM_THIS2_HPP_INCLUDED
+
+//
+//  enable_shared_from_this2.hpp
+//
+//  Copyright 2002, 2009 Peter Dimov
+//  Copyright 2008 Frank Mori Hess
+//
+//  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>
+#include <boost/shared_ptr.hpp>
+#include <boost/assert.hpp>
+#include <boost/detail/workaround.hpp>
+
+namespace boost
+{
+
+namespace detail
+{
+
+class esft2_deleter_wrapper
+{
+private:
+
+    shared_ptr<void> deleter_;
+
+public:
+
+    esft2_deleter_wrapper()
+    {
+    }
+
+    template< class T > void set_deleter( shared_ptr<T> const & deleter )
+    {
+        deleter_ = deleter;
+    }
+
+    template< class T> void operator()( T* )
+    {
+        BOOST_ASSERT( deleter_.use_count() <= 1 );
+        deleter_.reset();
+    }
+};
+
+} // namespace detail
+
+template< class T > class enable_shared_from_this2
+{
+protected:
+
+    enable_shared_from_this2()
+    {
+    }
+
+    enable_shared_from_this2( enable_shared_from_this2 const & )
+    {
+    }
+
+    enable_shared_from_this2 & operator=( enable_shared_from_this2 const & )
+    {
+        return *this;
+    }
+
+    ~enable_shared_from_this2()
+    {
+        BOOST_ASSERT( shared_this_.use_count() <= 1 ); // make sure no dangling shared_ptr objects exist
+    }
+
+private:
+
+    mutable weak_ptr<T> weak_this_;
+    mutable shared_ptr<T> shared_this_;
+
+public:
+
+    shared_ptr<T> shared_from_this()
+    {
+        init_weak_once();
+        return shared_ptr<T>( weak_this_ );
+    }
+
+    shared_ptr<T const> shared_from_this() const
+    {
+        init_weak_once();
+        return shared_ptr<T>( weak_this_ );
+    }
+
+private:
+
+    void init_weak_once() const
+    {
+        if( weak_this_._empty() )
+        {
+            shared_this_.reset( static_cast< T* >( 0 ), detail::esft2_deleter_wrapper() );
+            weak_this_ = shared_this_;
+        }
+    }
+
+public: // actually private, but avoids compiler template friendship issues
+
+    // Note: invoked automatically by shared_ptr; do not call
+    template<class X, class Y> void _internal_accept_owner( shared_ptr<X> * ppx, Y * py ) const
+    {
+        BOOST_ASSERT( ppx != 0 );
+
+        if( weak_this_.use_count() == 0 )
+        {
+            weak_this_ = shared_ptr<T>( *ppx, py );
+        }
+        else if( shared_this_.use_count() != 0 )
+        {
+            BOOST_ASSERT( ppx->unique() ); // no weak_ptrs should exist either, but there's no way to check that
+
+            detail::esft2_deleter_wrapper * pd = boost::get_deleter<detail::esft2_deleter_wrapper>( shared_this_ );
+            BOOST_ASSERT( pd != 0 );
+
+            pd->set_deleter( *ppx );
+
+            ppx->reset( shared_this_, ppx->get() );
+            shared_this_.reset();
+        }
+    }
+};
+
+} // namespace boost
+
+#endif  // #ifndef BOOST_ENABLE_SHARED_FROM_THIS2_HPP_INCLUDED

include/boost/smart_ptr/intrusive_ptr.hpp

@@ -15,11 +15,14 @@
 
 #include <boost/config.hpp>
 
+#ifdef BOOST_MSVC  // moved here to work around VC++ compiler crash
+# pragma warning(push)
+# pragma warning(disable:4284) // odd return type for operator->
+#endif
+
 #include <boost/assert.hpp>
 #include <boost/detail/workaround.hpp>
 #include <boost/smart_ptr/detail/sp_convertible.hpp>
-#include <boost/smart_ptr/detail/sp_nullptr_t.hpp>
-#include <boost/smart_ptr/detail/sp_noexcept.hpp>
 
 #include <boost/config/no_tr1/functional.hpp>           // for std::less
 
@@ -60,7 +63,7 @@ public:
 
     typedef T element_type;
 
-    BOOST_CONSTEXPR intrusive_ptr() BOOST_SP_NOEXCEPT : px( 0 )
+    intrusive_ptr(): px( 0 )
     {
     }
 
@@ -110,43 +113,19 @@ public:
 
 // Move support
 
-#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
+#if defined( BOOST_HAS_RVALUE_REFS )
 
-    intrusive_ptr(intrusive_ptr && rhs) BOOST_SP_NOEXCEPT : px( rhs.px )
+    intrusive_ptr(intrusive_ptr && rhs): px( rhs.px )
     {
         rhs.px = 0;
     }
 
-    intrusive_ptr & operator=(intrusive_ptr && rhs) BOOST_SP_NOEXCEPT
+    intrusive_ptr & operator=(intrusive_ptr && rhs)
     {
         this_type( static_cast< intrusive_ptr && >( rhs ) ).swap(*this);
         return *this;
     }
 
-    template<class U> friend class intrusive_ptr;
-
-    template<class U>
-#if !defined( BOOST_SP_NO_SP_CONVERTIBLE )
-
-    intrusive_ptr(intrusive_ptr<U> && rhs, typename boost::detail::sp_enable_if_convertible<U,T>::type = boost::detail::sp_empty())
-
-#else
-
-    intrusive_ptr(intrusive_ptr<U> && rhs)
-
-#endif        
-    : px( rhs.px )
-    {
-        rhs.px = 0;
-    }
-
-    template<class U>
-    intrusive_ptr & operator=(intrusive_ptr<U> && rhs) BOOST_NOEXCEPT
-    {
-        this_type( static_cast< intrusive_ptr<U> && >( rhs ) ).swap(*this);
-        return *this;
-    }
-
 #endif
 
     intrusive_ptr & operator=(intrusive_ptr const & rhs)
@@ -161,7 +140,7 @@ public:
         return *this;
     }
 
-    void reset() BOOST_NOEXCEPT
+    void reset()
     {
         this_type().swap( *this );
     }
@@ -171,23 +150,11 @@ public:
         this_type( rhs ).swap( *this );
     }
 
-    void reset( T * rhs, bool add_ref )
-    {
-        this_type( rhs, add_ref ).swap( *this );
-    }
-
-    T * get() const BOOST_NOEXCEPT
+    T * get() const
     {
         return px;
     }
 
-    T * detach() BOOST_NOEXCEPT
-    {
-        T * ret = px;
-        px = 0;
-        return ret;
-    }
-
     T & operator*() const
     {
         BOOST_ASSERT( px != 0 );
@@ -203,7 +170,7 @@ public:
 // implicit conversion to "bool"
 #include <boost/smart_ptr/detail/operator_bool.hpp>
 
-    void swap(intrusive_ptr & rhs) BOOST_NOEXCEPT
+    void swap(intrusive_ptr & rhs)
     {
         T * tmp = px;
         px = rhs.px;
@@ -256,30 +223,6 @@ template<class T> inline bool operator!=(intrusive_ptr<T> const & a, intrusive_p
 
 #endif
 
-#if !defined( BOOST_NO_CXX11_NULLPTR )
-
-template<class T> inline bool operator==( intrusive_ptr<T> const & p, boost::detail::sp_nullptr_t ) BOOST_NOEXCEPT
-{
-    return p.get() == 0;
-}
-
-template<class T> inline bool operator==( boost::detail::sp_nullptr_t, intrusive_ptr<T> const & p ) BOOST_NOEXCEPT
-{
-    return p.get() == 0;
-}
-
-template<class T> inline bool operator!=( intrusive_ptr<T> const & p, boost::detail::sp_nullptr_t ) BOOST_NOEXCEPT
-{
-    return p.get() != 0;
-}
-
-template<class T> inline bool operator!=( boost::detail::sp_nullptr_t, intrusive_ptr<T> const & p ) BOOST_NOEXCEPT
-{
-    return p.get() != 0;
-}
-
-#endif
-
 template<class T> inline bool operator<(intrusive_ptr<T> const & a, intrusive_ptr<T> const & b)
 {
     return std::less<T *>()(a.get(), b.get());
@@ -347,15 +290,10 @@ template<class E, class T, class Y> std::basic_ostream<E, T> & operator<< (std::
 
 #endif // !defined(BOOST_NO_IOSTREAM)
 
-// hash_value
-
-template< class T > struct hash;
-
-template< class T > std::size_t hash_value( boost::intrusive_ptr<T> const & p )
-{
-    return boost::hash< T* >()( p.get() );
-}
-
 } // namespace boost
 
+#ifdef BOOST_MSVC
+# pragma warning(pop)
+#endif    
+
 #endif  // #ifndef BOOST_SMART_PTR_INTRUSIVE_PTR_HPP_INCLUDED

include/boost/smart_ptr/intrusive_ref_counter.hpp

@@ -1,187 +0,0 @@
-/*
- *          Copyright Andrey Semashev 2007 - 2013.
- * 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)
- */
-/*!
- * \file   intrusive_ref_counter.hpp
- * \author Andrey Semashev
- * \date   12.03.2009
- *
- * This header contains a reference counter class for \c intrusive_ptr.
- */
-
-#ifndef BOOST_SMART_PTR_INTRUSIVE_REF_COUNTER_HPP_INCLUDED_
-#define BOOST_SMART_PTR_INTRUSIVE_REF_COUNTER_HPP_INCLUDED_
-
-#include <boost/config.hpp>
-#include <boost/smart_ptr/detail/atomic_count.hpp>
-
-#ifdef BOOST_HAS_PRAGMA_ONCE
-#pragma once
-#endif
-
-#if defined(_MSC_VER)
-#pragma warning(push)
-// This is a bogus MSVC warning, which is flagged by friend declarations of intrusive_ptr_add_ref and intrusive_ptr_release in intrusive_ref_counter:
-// 'name' : the inline specifier cannot be used when a friend declaration refers to a specialization of a function template
-// Note that there is no inline specifier in the declarations.
-#pragma warning(disable: 4396)
-#endif
-
-namespace boost {
-
-namespace sp_adl_block {
-
-/*!
- * \brief Thread unsafe reference counter policy for \c intrusive_ref_counter
- *
- * The policy instructs the \c intrusive_ref_counter base class to implement
- * a reference counter suitable for single threaded use only. Pointers to the same
- * object with this kind of reference counter must not be used by different threads.
- */
-struct thread_unsafe_counter
-{
-    typedef unsigned int type;
-
-    static unsigned int load(unsigned int const& counter) BOOST_NOEXCEPT
-    {
-        return counter;
-    }
-
-    static void increment(unsigned int& counter) BOOST_NOEXCEPT
-    {
-        ++counter;
-    }
-
-    static unsigned int decrement(unsigned int& counter) BOOST_NOEXCEPT
-    {
-        return --counter;
-    }
-};
-
-/*!
- * \brief Thread safe reference counter policy for \c intrusive_ref_counter
- *
- * The policy instructs the \c intrusive_ref_counter base class to implement
- * a thread-safe reference counter, if the target platform supports multithreading.
- */
-struct thread_safe_counter
-{
-    typedef boost::detail::atomic_count type;
-
-    static unsigned int load(boost::detail::atomic_count const& counter) BOOST_NOEXCEPT
-    {
-        return static_cast< unsigned int >(static_cast< long >(counter));
-    }
-
-    static void increment(boost::detail::atomic_count& counter) BOOST_NOEXCEPT
-    {
-        ++counter;
-    }
-
-    static unsigned int decrement(boost::detail::atomic_count& counter) BOOST_NOEXCEPT
-    {
-        return static_cast< unsigned int >(--counter);
-    }
-};
-
-template< typename DerivedT, typename CounterPolicyT = thread_safe_counter >
-class intrusive_ref_counter;
-
-template< typename DerivedT, typename CounterPolicyT >
-void intrusive_ptr_add_ref(const intrusive_ref_counter< DerivedT, CounterPolicyT >* p) BOOST_NOEXCEPT;
-template< typename DerivedT, typename CounterPolicyT >
-void intrusive_ptr_release(const intrusive_ref_counter< DerivedT, CounterPolicyT >* p) BOOST_NOEXCEPT;
-
-/*!
- * \brief A reference counter base class
- *
- * This base class can be used with user-defined classes to add support
- * for \c intrusive_ptr. The class contains a reference counter defined by the \c CounterPolicyT.
- * Upon releasing the last \c intrusive_ptr referencing the object
- * derived from the \c intrusive_ref_counter class, operator \c delete
- * is automatically called on the pointer to the object.
- *
- * The other template parameter, \c DerivedT, is the user's class that derives from \c intrusive_ref_counter.
- */
-template< typename DerivedT, typename CounterPolicyT >
-class intrusive_ref_counter
-{
-private:
-    //! Reference counter type
-    typedef typename CounterPolicyT::type counter_type;
-    //! Reference counter
-    mutable counter_type m_ref_counter;
-
-public:
-    /*!
-     * Default constructor
-     *
-     * \post <tt>use_count() == 0</tt>
-     */
-    intrusive_ref_counter() BOOST_NOEXCEPT : m_ref_counter(0)
-    {
-    }
-
-    /*!
-     * Copy constructor
-     *
-     * \post <tt>use_count() == 0</tt>
-     */
-    intrusive_ref_counter(intrusive_ref_counter const&) BOOST_NOEXCEPT : m_ref_counter(0)
-    {
-    }
-
-    /*!
-     * Assignment
-     *
-     * \post The reference counter is not modified after assignment
-     */
-    intrusive_ref_counter& operator= (intrusive_ref_counter const&) BOOST_NOEXCEPT { return *this; }
-
-    /*!
-     * \return The reference counter
-     */
-    unsigned int use_count() const BOOST_NOEXCEPT
-    {
-        return CounterPolicyT::load(m_ref_counter);
-    }
-
-protected:
-    /*!
-     * Destructor
-     */
-    BOOST_DEFAULTED_FUNCTION(~intrusive_ref_counter(), {})
-
-    friend void intrusive_ptr_add_ref< DerivedT, CounterPolicyT >(const intrusive_ref_counter< DerivedT, CounterPolicyT >* p) BOOST_NOEXCEPT;
-    friend void intrusive_ptr_release< DerivedT, CounterPolicyT >(const intrusive_ref_counter< DerivedT, CounterPolicyT >* p) BOOST_NOEXCEPT;
-};
-
-template< typename DerivedT, typename CounterPolicyT >
-inline void intrusive_ptr_add_ref(const intrusive_ref_counter< DerivedT, CounterPolicyT >* p) BOOST_NOEXCEPT
-{
-    CounterPolicyT::increment(p->m_ref_counter);
-}
-
-template< typename DerivedT, typename CounterPolicyT >
-inline void intrusive_ptr_release(const intrusive_ref_counter< DerivedT, CounterPolicyT >* p) BOOST_NOEXCEPT
-{
-    if (CounterPolicyT::decrement(p->m_ref_counter) == 0)
-        delete static_cast< const DerivedT* >(p);
-}
-
-} // namespace sp_adl_block
-
-using sp_adl_block::intrusive_ref_counter;
-using sp_adl_block::thread_unsafe_counter;
-using sp_adl_block::thread_safe_counter;
-
-} // namespace boost
-
-#if defined(_MSC_VER)
-#pragma warning(pop)
-#endif
-
-#endif // BOOST_SMART_PTR_INTRUSIVE_REF_COUNTER_HPP_INCLUDED_

include/boost/smart_ptr/make_shared.hpp

@@ -3,7 +3,7 @@
 
 //  make_shared.hpp
 //
-//  Copyright (c) 2007, 2008, 2012 Peter Dimov
+//  Copyright (c) 2007, 2008 Peter Dimov
 //
 //  Distributed under the Boost Software License, Version 1.0.
 //  See accompanying file LICENSE_1_0.txt or copy at
@@ -12,11 +12,497 @@
 //  See http://www.boost.org/libs/smart_ptr/make_shared.html
 //  for documentation.
 
-#include <boost/smart_ptr/make_shared_object.hpp>
+#include <boost/config.hpp>
+#include <boost/smart_ptr/shared_ptr.hpp>
+#include <boost/type_traits/type_with_alignment.hpp>
+#include <boost/type_traits/alignment_of.hpp>
+#include <cstddef>
+#include <new>
+
+namespace boost
+{
+
+namespace detail
+{
+
+template< std::size_t N, std::size_t A > struct sp_aligned_storage
+{
+    union type
+    {
+        char data_[ N ];
+        typename boost::type_with_alignment< A >::type align_;
+    };
+};
+
+template< class T > class sp_ms_deleter
+{
+private:
+
+    typedef typename sp_aligned_storage< sizeof( T ), ::boost::alignment_of< T >::value >::type storage_type;
+
+    bool initialized_;
+    storage_type storage_;
+
+private:
+
+    void destroy()
+    {
+        if( initialized_ )
+        {
+            reinterpret_cast< T* >( storage_.data_ )->~T();
+            initialized_ = false;
+        }
+    }
+
+public:
+
+    sp_ms_deleter(): initialized_( false )
+    {
+    }
+
+    // optimization: do not copy storage_
+    sp_ms_deleter( sp_ms_deleter const & ): initialized_( false )
+    {
+    }
+
+    ~sp_ms_deleter()
+    {
+        destroy();
+    }
+
+    void operator()( T * )
+    {
+        destroy();
+    }
+
+    void * address()
+    {
+        return storage_.data_;
+    }
+
+    void set_initialized()
+    {
+        initialized_ = true;
+    }
+};
+
+#if defined( BOOST_HAS_RVALUE_REFS )
+
+template< class T > T&& sp_forward( T & t )
+{
+    return static_cast< T&& >( t );
+}
 
-#if !defined( BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION ) && !defined( BOOST_NO_SFINAE )
-# include <boost/smart_ptr/make_shared_array.hpp>
-# include <boost/smart_ptr/allocate_shared_array.hpp>
 #endif
 
+} // namespace detail
+
+// Zero-argument versions
+//
+// Used even when variadic templates are available because of the new T() vs new T issue
+
+template< class T > boost::shared_ptr< T > make_shared()
+{
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), boost::detail::sp_ms_deleter< T >() );
+
+    boost::detail::sp_ms_deleter< T > * pd = boost::get_deleter< boost::detail::sp_ms_deleter< T > >( pt );
+
+    void * pv = pd->address();
+
+    ::new( pv ) T();
+    pd->set_initialized();
+
+    T * pt2 = static_cast< T* >( pv );
+
+    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
+    return boost::shared_ptr< T >( pt, pt2 );
+}
+
+template< class T, class A > boost::shared_ptr< T > allocate_shared( A const & a )
+{
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), boost::detail::sp_ms_deleter< T >(), a );
+
+    boost::detail::sp_ms_deleter< T > * pd = boost::get_deleter< boost::detail::sp_ms_deleter< T > >( pt );
+
+    void * pv = pd->address();
+
+    ::new( pv ) T();
+    pd->set_initialized();
+
+    T * pt2 = static_cast< T* >( pv );
+
+    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
+    return boost::shared_ptr< T >( pt, pt2 );
+}
+
+#if defined( BOOST_HAS_VARIADIC_TMPL ) && defined( BOOST_HAS_RVALUE_REFS )
+
+// Variadic templates, rvalue reference
+
+template< class T, class Arg1, class... Args > boost::shared_ptr< T > make_shared( Arg1 && arg1, Args && ... args )
+{
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), boost::detail::sp_ms_deleter< T >() );
+
+    boost::detail::sp_ms_deleter< T > * pd = boost::get_deleter< boost::detail::sp_ms_deleter< T > >( pt );
+
+    void * pv = pd->address();
+
+    ::new( pv ) T( boost::detail::sp_forward<Arg1>( arg1 ), boost::detail::sp_forward<Args>( args )... );
+    pd->set_initialized();
+
+    T * pt2 = static_cast< T* >( pv );
+
+    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
+    return boost::shared_ptr< T >( pt, pt2 );
+}
+
+template< class T, class A, class Arg1, class... Args > boost::shared_ptr< T > allocate_shared( A const & a, Arg1 && arg1, Args && ... args )
+{
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), boost::detail::sp_ms_deleter< T >(), a );
+
+    boost::detail::sp_ms_deleter< T > * pd = boost::get_deleter< boost::detail::sp_ms_deleter< T > >( pt );
+
+    void * pv = pd->address();
+
+    ::new( pv ) T( boost::detail::sp_forward<Arg1>( arg1 ), boost::detail::sp_forward<Args>( args )... );
+    pd->set_initialized();
+
+    T * pt2 = static_cast< T* >( pv );
+
+    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
+    return boost::shared_ptr< T >( pt, pt2 );
+}
+
+#else
+
+// C++03 version
+
+template< class T, class A1 >
+boost::shared_ptr< T > make_shared( A1 const & a1 )
+{
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), boost::detail::sp_ms_deleter< T >() );
+
+    boost::detail::sp_ms_deleter< T > * pd = boost::get_deleter< boost::detail::sp_ms_deleter< T > >( pt );
+
+    void * pv = pd->address();
+
+    ::new( pv ) T( a1 );
+    pd->set_initialized();
+
+    T * pt2 = static_cast< T* >( pv );
+
+    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
+    return boost::shared_ptr< T >( pt, pt2 );
+}
+
+template< class T, class A, class A1 >
+boost::shared_ptr< T > allocate_shared( A const & a, A1 const & a1 )
+{
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), boost::detail::sp_ms_deleter< T >(), a );
+
+    boost::detail::sp_ms_deleter< T > * pd = boost::get_deleter< boost::detail::sp_ms_deleter< T > >( pt );
+
+    void * pv = pd->address();
+
+    ::new( pv ) T( a1 );
+    pd->set_initialized();
+
+    T * pt2 = static_cast< T* >( pv );
+
+    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
+    return boost::shared_ptr< T >( pt, pt2 );
+}
+
+template< class T, class A1, class A2 >
+boost::shared_ptr< T > make_shared( A1 const & a1, A2 const & a2 )
+{
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), boost::detail::sp_ms_deleter< T >() );
+
+    boost::detail::sp_ms_deleter< T > * pd = boost::get_deleter< boost::detail::sp_ms_deleter< T > >( pt );
+
+    void * pv = pd->address();
+
+    ::new( pv ) T( a1, a2 );
+    pd->set_initialized();
+
+    T * pt2 = static_cast< T* >( pv );
+
+    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
+    return boost::shared_ptr< T >( pt, pt2 );
+}
+
+template< class T, class A, class A1, class A2 >
+boost::shared_ptr< T > allocate_shared( A const & a, A1 const & a1, A2 const & a2 )
+{
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), boost::detail::sp_ms_deleter< T >(), a );
+
+    boost::detail::sp_ms_deleter< T > * pd = boost::get_deleter< boost::detail::sp_ms_deleter< T > >( pt );
+
+    void * pv = pd->address();
+
+    ::new( pv ) T( a1, a2 );
+    pd->set_initialized();
+
+    T * pt2 = static_cast< T* >( pv );
+
+    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
+    return boost::shared_ptr< T >( pt, pt2 );
+}
+
+template< class T, class A1, class A2, class A3 >
+boost::shared_ptr< T > make_shared( A1 const & a1, A2 const & a2, A3 const & a3 )
+{
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), boost::detail::sp_ms_deleter< T >() );
+
+    boost::detail::sp_ms_deleter< T > * pd = boost::get_deleter< boost::detail::sp_ms_deleter< T > >( pt );
+
+    void * pv = pd->address();
+
+    ::new( pv ) T( a1, a2, a3 );
+    pd->set_initialized();
+
+    T * pt2 = static_cast< T* >( pv );
+
+    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
+    return boost::shared_ptr< T >( pt, pt2 );
+}
+
+template< class T, class A, class A1, class A2, class A3 >
+boost::shared_ptr< T > allocate_shared( A const & a, A1 const & a1, A2 const & a2, A3 const & a3 )
+{
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), boost::detail::sp_ms_deleter< T >(), a );
+
+    boost::detail::sp_ms_deleter< T > * pd = boost::get_deleter< boost::detail::sp_ms_deleter< T > >( pt );
+
+    void * pv = pd->address();
+
+    ::new( pv ) T( a1, a2, a3 );
+    pd->set_initialized();
+
+    T * pt2 = static_cast< T* >( pv );
+
+    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
+    return boost::shared_ptr< T >( pt, pt2 );
+}
+
+template< class T, class A1, class A2, class A3, class A4 >
+boost::shared_ptr< T > make_shared( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4 )
+{
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), boost::detail::sp_ms_deleter< T >() );
+
+    boost::detail::sp_ms_deleter< T > * pd = boost::get_deleter< boost::detail::sp_ms_deleter< T > >( pt );
+
+    void * pv = pd->address();
+
+    ::new( pv ) T( a1, a2, a3, a4 );
+    pd->set_initialized();
+
+    T * pt2 = static_cast< T* >( pv );
+
+    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
+    return boost::shared_ptr< T >( pt, pt2 );
+}
+
+template< class T, class A, class A1, class A2, class A3, class A4 >
+boost::shared_ptr< T > allocate_shared( A const & a, A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4 )
+{
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), boost::detail::sp_ms_deleter< T >(), a );
+
+    boost::detail::sp_ms_deleter< T > * pd = boost::get_deleter< boost::detail::sp_ms_deleter< T > >( pt );
+
+    void * pv = pd->address();
+
+    ::new( pv ) T( a1, a2, a3, a4 );
+    pd->set_initialized();
+
+    T * pt2 = static_cast< T* >( pv );
+
+    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
+    return boost::shared_ptr< T >( pt, pt2 );
+}
+
+template< class T, class A1, class A2, class A3, class A4, class A5 >
+boost::shared_ptr< T > make_shared( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5 )
+{
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), boost::detail::sp_ms_deleter< T >() );
+
+    boost::detail::sp_ms_deleter< T > * pd = boost::get_deleter< boost::detail::sp_ms_deleter< T > >( pt );
+
+    void * pv = pd->address();
+
+    ::new( pv ) T( a1, a2, a3, a4, a5 );
+    pd->set_initialized();
+
+    T * pt2 = static_cast< T* >( pv );
+
+    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
+    return boost::shared_ptr< T >( pt, pt2 );
+}
+
+template< class T, class A, class A1, class A2, class A3, class A4, class A5 >
+boost::shared_ptr< T > allocate_shared( A const & a, A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5 )
+{
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), boost::detail::sp_ms_deleter< T >(), a );
+
+    boost::detail::sp_ms_deleter< T > * pd = boost::get_deleter< boost::detail::sp_ms_deleter< T > >( pt );
+
+    void * pv = pd->address();
+
+    ::new( pv ) T( a1, a2, a3, a4, a5 );
+    pd->set_initialized();
+
+    T * pt2 = static_cast< T* >( pv );
+
+    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
+    return boost::shared_ptr< T >( pt, pt2 );
+}
+
+template< class T, class A1, class A2, class A3, class A4, class A5, class A6 >
+boost::shared_ptr< T > make_shared( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6 )
+{
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), boost::detail::sp_ms_deleter< T >() );
+
+    boost::detail::sp_ms_deleter< T > * pd = boost::get_deleter< boost::detail::sp_ms_deleter< T > >( pt );
+
+    void * pv = pd->address();
+
+    ::new( pv ) T( a1, a2, a3, a4, a5, a6 );
+    pd->set_initialized();
+
+    T * pt2 = static_cast< T* >( pv );
+
+    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
+    return boost::shared_ptr< T >( pt, pt2 );
+}
+
+template< class T, class A, class A1, class A2, class A3, class A4, class A5, class A6 >
+boost::shared_ptr< T > allocate_shared( A const & a, A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6 )
+{
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), boost::detail::sp_ms_deleter< T >(), a );
+
+    boost::detail::sp_ms_deleter< T > * pd = boost::get_deleter< boost::detail::sp_ms_deleter< T > >( pt );
+
+    void * pv = pd->address();
+
+    ::new( pv ) T( a1, a2, a3, a4, a5, a6 );
+    pd->set_initialized();
+
+    T * pt2 = static_cast< T* >( pv );
+
+    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
+    return boost::shared_ptr< T >( pt, pt2 );
+}
+
+template< class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7 >
+boost::shared_ptr< T > make_shared( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7 )
+{
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), boost::detail::sp_ms_deleter< T >() );
+
+    boost::detail::sp_ms_deleter< T > * pd = boost::get_deleter< boost::detail::sp_ms_deleter< T > >( pt );
+
+    void * pv = pd->address();
+
+    ::new( pv ) T( a1, a2, a3, a4, a5, a6, a7 );
+    pd->set_initialized();
+
+    T * pt2 = static_cast< T* >( pv );
+
+    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
+    return boost::shared_ptr< T >( pt, pt2 );
+}
+
+template< class T, class A, class A1, class A2, class A3, class A4, class A5, class A6, class A7 >
+boost::shared_ptr< T > allocate_shared( A const & a, A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7 )
+{
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), boost::detail::sp_ms_deleter< T >(), a );
+
+    boost::detail::sp_ms_deleter< T > * pd = boost::get_deleter< boost::detail::sp_ms_deleter< T > >( pt );
+
+    void * pv = pd->address();
+
+    ::new( pv ) T( a1, a2, a3, a4, a5, a6, a7 );
+    pd->set_initialized();
+
+    T * pt2 = static_cast< T* >( pv );
+
+    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
+    return boost::shared_ptr< T >( pt, pt2 );
+}
+
+template< class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8 >
+boost::shared_ptr< T > make_shared( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8 )
+{
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), boost::detail::sp_ms_deleter< T >() );
+
+    boost::detail::sp_ms_deleter< T > * pd = boost::get_deleter< boost::detail::sp_ms_deleter< T > >( pt );
+
+    void * pv = pd->address();
+
+    ::new( pv ) T( a1, a2, a3, a4, a5, a6, a7, a8 );
+    pd->set_initialized();
+
+    T * pt2 = static_cast< T* >( pv );
+
+    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
+    return boost::shared_ptr< T >( pt, pt2 );
+}
+
+template< class T, class A, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8 >
+boost::shared_ptr< T > allocate_shared( A const & a, A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8 )
+{
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), boost::detail::sp_ms_deleter< T >(), a );
+
+    boost::detail::sp_ms_deleter< T > * pd = boost::get_deleter< boost::detail::sp_ms_deleter< T > >( pt );
+
+    void * pv = pd->address();
+
+    ::new( pv ) T( a1, a2, a3, a4, a5, a6, a7, a8 );
+    pd->set_initialized();
+
+    T * pt2 = static_cast< T* >( pv );
+
+    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
+    return boost::shared_ptr< T >( pt, pt2 );
+}
+
+template< class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9 >
+boost::shared_ptr< T > make_shared( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8, A9 const & a9 )
+{
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), boost::detail::sp_ms_deleter< T >() );
+
+    boost::detail::sp_ms_deleter< T > * pd = boost::get_deleter< boost::detail::sp_ms_deleter< T > >( pt );
+
+    void * pv = pd->address();
+
+    ::new( pv ) T( a1, a2, a3, a4, a5, a6, a7, a8, a9 );
+    pd->set_initialized();
+
+    T * pt2 = static_cast< T* >( pv );
+
+    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
+    return boost::shared_ptr< T >( pt, pt2 );
+}
+
+template< class T, class A, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9 >
+boost::shared_ptr< T > allocate_shared( A const & a, A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8, A9 const & a9 )
+{
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), boost::detail::sp_ms_deleter< T >(), a );
+
+    boost::detail::sp_ms_deleter< T > * pd = boost::get_deleter< boost::detail::sp_ms_deleter< T > >( pt );
+
+    void * pv = pd->address();
+
+    ::new( pv ) T( a1, a2, a3, a4, a5, a6, a7, a8, a9 );
+    pd->set_initialized();
+
+    T * pt2 = static_cast< T* >( pv );
+
+    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
+    return boost::shared_ptr< T >( pt, pt2 );
+}
+
+#endif
+
+} // namespace boost
+
 #endif // #ifndef BOOST_SMART_PTR_MAKE_SHARED_HPP_INCLUDED

include/boost/smart_ptr/make_shared_array.hpp

@@ -1,66 +0,0 @@
-/*
-Copyright 2012-2017 Glen Joseph Fernandes
-(glenjofe@gmail.com)
-
-Distributed under the Boost Software License, Version 1.0.
-(http://www.boost.org/LICENSE_1_0.txt)
-*/
-#ifndef BOOST_SMART_PTR_MAKE_SHARED_ARRAY_HPP
-#define BOOST_SMART_PTR_MAKE_SHARED_ARRAY_HPP
-
-#include <boost/smart_ptr/allocate_shared_array.hpp>
-
-namespace boost {
-
-template<class T>
-inline typename detail::sp_if_size_array<T>::type
-make_shared()
-{
-    return boost::allocate_shared<T>(std::allocator<typename
-        detail::sp_array_scalar<T>::type>());
-}
-
-template<class T>
-inline typename detail::sp_if_size_array<T>::type
-make_shared(const typename detail::sp_array_element<T>::type& value)
-{
-    return boost::allocate_shared<T>(std::allocator<typename
-        detail::sp_array_scalar<T>::type>(), value);
-}
-
-template<class T>
-inline typename detail::sp_if_array<T>::type
-make_shared(std::size_t size)
-{
-    return boost::allocate_shared<T>(std::allocator<typename
-        detail::sp_array_scalar<T>::type>(), size);
-}
-
-template<class T>
-inline typename detail::sp_if_array<T>::type
-make_shared(std::size_t size,
-    const typename detail::sp_array_element<T>::type& value)
-{
-    return boost::allocate_shared<T>(std::allocator<typename
-        detail::sp_array_scalar<T>::type>(), size, value);
-}
-
-template<class T>
-inline typename detail::sp_if_size_array<T>::type
-make_shared_noinit()
-{
-    return allocate_shared_noinit<T>(std::allocator<typename
-        detail::sp_array_scalar<T>::type>());
-}
-
-template<class T>
-inline typename detail::sp_if_array<T>::type
-make_shared_noinit(std::size_t size)
-{
-    return allocate_shared_noinit<T>(std::allocator<typename
-        detail::sp_array_scalar<T>::type>(), size);
-}
-
-} /* boost */
-
-#endif

include/boost/smart_ptr/make_shared_object.hpp

@@ -1,801 +0,0 @@
-#ifndef BOOST_SMART_PTR_MAKE_SHARED_OBJECT_HPP_INCLUDED
-#define BOOST_SMART_PTR_MAKE_SHARED_OBJECT_HPP_INCLUDED
-
-//  make_shared_object.hpp
-//
-//  Copyright (c) 2007, 2008, 2012 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
-//
-//  See http://www.boost.org/libs/smart_ptr/make_shared.html
-//  for documentation.
-
-#include <boost/config.hpp>
-#include <boost/move/core.hpp>
-#include <boost/move/utility_core.hpp>
-#include <boost/smart_ptr/shared_ptr.hpp>
-#include <boost/smart_ptr/detail/sp_forward.hpp>
-#include <boost/type_traits/type_with_alignment.hpp>
-#include <boost/type_traits/alignment_of.hpp>
-#include <cstddef>
-#include <new>
-
-namespace boost
-{
-
-namespace detail
-{
-
-template< std::size_t N, std::size_t A > struct sp_aligned_storage
-{
-    union type
-    {
-        char data_[ N ];
-        typename boost::type_with_alignment< A >::type align_;
-    };
-};
-
-template< class T > class sp_ms_deleter
-{
-private:
-
-    typedef typename sp_aligned_storage< sizeof( T ), ::boost::alignment_of< T >::value >::type storage_type;
-
-    bool initialized_;
-    storage_type storage_;
-
-private:
-
-    void destroy()
-    {
-        if( initialized_ )
-        {
-#if defined( __GNUC__ )
-
-            // fixes incorrect aliasing warning
-            T * p = reinterpret_cast< T* >( storage_.data_ );
-            p->~T();
-
-#else
-
-            reinterpret_cast< T* >( storage_.data_ )->~T();
-
-#endif
-
-            initialized_ = false;
-        }
-    }
-
-public:
-
-    sp_ms_deleter() BOOST_NOEXCEPT : initialized_( false )
-    {
-    }
-
-    template<class A> explicit sp_ms_deleter( A const & ) BOOST_NOEXCEPT : initialized_( false )
-    {
-    }
-
-    // optimization: do not copy storage_
-    sp_ms_deleter( sp_ms_deleter const & ) BOOST_NOEXCEPT : initialized_( false )
-    {
-    }
-
-    ~sp_ms_deleter()
-    {
-        destroy();
-    }
-
-    void operator()( T * )
-    {
-        destroy();
-    }
-
-    static void operator_fn( T* ) // operator() can't be static
-    {
-    }
-
-    void * address() BOOST_NOEXCEPT
-    {
-        return storage_.data_;
-    }
-
-    void set_initialized() BOOST_NOEXCEPT
-    {
-        initialized_ = true;
-    }
-};
-
-template< class T, class A > class sp_as_deleter
-{
-private:
-
-    typedef typename sp_aligned_storage< sizeof( T ), ::boost::alignment_of< T >::value >::type storage_type;
-
-    storage_type storage_;
-    A a_;
-    bool initialized_;
-
-private:
-
-    void destroy()
-    {
-        if( initialized_ )
-        {
-            T * p = reinterpret_cast< T* >( storage_.data_ );
-
-#if !defined( BOOST_NO_CXX11_ALLOCATOR )
-
-            std::allocator_traits<A>::destroy( a_, p );
-
-#else
-
-            p->~T();
-
-#endif
-
-            initialized_ = false;
-        }
-    }
-
-public:
-
-    sp_as_deleter( A const & a ) BOOST_NOEXCEPT : a_( a ), initialized_( false )
-    {
-    }
-
-    // optimization: do not copy storage_
-    sp_as_deleter( sp_as_deleter const & r ) BOOST_NOEXCEPT : a_( r.a_), initialized_( false )
-    {
-    }
-
-    ~sp_as_deleter()
-    {
-        destroy();
-    }
-
-    void operator()( T * )
-    {
-        destroy();
-    }
-
-    static void operator_fn( T* ) // operator() can't be static
-    {
-    }
-
-    void * address() BOOST_NOEXCEPT
-    {
-        return storage_.data_;
-    }
-
-    void set_initialized() BOOST_NOEXCEPT
-    {
-        initialized_ = true;
-    }
-};
-
-template< class T > struct sp_if_not_array
-{
-    typedef boost::shared_ptr< T > type;
-};
-
-#if !defined( BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION )
-
-template< class T > struct sp_if_not_array< T[] >
-{
-};
-
-#if !defined( __BORLANDC__ ) || !BOOST_WORKAROUND( __BORLANDC__, < 0x600 )
-
-template< class T, std::size_t N > struct sp_if_not_array< T[N] >
-{
-};
-
-#endif
-
-#endif
-
-} // namespace detail
-
-#if !defined( BOOST_NO_FUNCTION_TEMPLATE_ORDERING )
-# define BOOST_SP_MSD( T ) boost::detail::sp_inplace_tag< boost::detail::sp_ms_deleter< T > >()
-#else
-# define BOOST_SP_MSD( T ) boost::detail::sp_ms_deleter< T >()
-#endif
-
-// _noinit versions
-
-template< class T > typename boost::detail::sp_if_not_array< T >::type make_shared_noinit()
-{
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
-
-    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
-
-    void * pv = pd->address();
-
-    ::new( pv ) T;
-    pd->set_initialized();
-
-    T * pt2 = static_cast< T* >( pv );
-
-    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
-    return boost::shared_ptr< T >( pt, pt2 );
-}
-
-template< class T, class A > typename boost::detail::sp_if_not_array< T >::type allocate_shared_noinit( A const & a )
-{
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
-
-    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
-
-    void * pv = pd->address();
-
-    ::new( pv ) T;
-    pd->set_initialized();
-
-    T * pt2 = static_cast< T* >( pv );
-
-    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
-    return boost::shared_ptr< T >( pt, pt2 );
-}
-
-#if !defined( BOOST_NO_CXX11_VARIADIC_TEMPLATES ) && !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
-
-// Variadic templates, rvalue reference
-
-template< class T, class... Args > typename boost::detail::sp_if_not_array< T >::type make_shared( Args && ... args )
-{
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
-
-    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
-
-    void * pv = pd->address();
-
-    ::new( pv ) T( boost::detail::sp_forward<Args>( args )... );
-    pd->set_initialized();
-
-    T * pt2 = static_cast< T* >( pv );
-
-    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
-    return boost::shared_ptr< T >( pt, pt2 );
-}
-
-template< class T, class A, class... Args > typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, Args && ... args )
-{
-#if !defined( BOOST_NO_CXX11_ALLOCATOR )
-
-    typedef typename std::allocator_traits<A>::template rebind_alloc<T> A2;
-    A2 a2( a );
-
-    typedef boost::detail::sp_as_deleter< T, A2 > D;
-
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), boost::detail::sp_inplace_tag<D>(), a2 );
-
-#else
-
-    typedef boost::detail::sp_ms_deleter< T > D;
-
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), boost::detail::sp_inplace_tag<D>(), a );
-
-#endif
-
-    D * pd = static_cast< D* >( pt._internal_get_untyped_deleter() );
-    void * pv = pd->address();
-
-#if !defined( BOOST_NO_CXX11_ALLOCATOR )
-
-    std::allocator_traits<A2>::construct( a2, static_cast< T* >( pv ), boost::detail::sp_forward<Args>( args )... );
-
-#else
-
-    ::new( pv ) T( boost::detail::sp_forward<Args>( args )... );
-
-#endif
-
-    pd->set_initialized();
-
-    T * pt2 = static_cast< T* >( pv );
-
-    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
-    return boost::shared_ptr< T >( pt, pt2 );
-}
-
-#else // !defined( BOOST_NO_CXX11_VARIADIC_TEMPLATES ) && !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
-
-// Common zero-argument versions
-
-template< class T > typename boost::detail::sp_if_not_array< T >::type make_shared()
-{
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
-
-    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
-
-    void * pv = pd->address();
-
-    ::new( pv ) T();
-    pd->set_initialized();
-
-    T * pt2 = static_cast< T* >( pv );
-
-    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
-    return boost::shared_ptr< T >( pt, pt2 );
-}
-
-template< class T, class A > typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a )
-{
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
-
-    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
-
-    void * pv = pd->address();
-
-    ::new( pv ) T();
-    pd->set_initialized();
-
-    T * pt2 = static_cast< T* >( pv );
-
-    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
-    return boost::shared_ptr< T >( pt, pt2 );
-}
-
-// C++03 version
-
-template< class T, class A1 >
-typename boost::detail::sp_if_not_array< T >::type make_shared( BOOST_FWD_REF(A1) a1 )
-{
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
-
-    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
-
-    void * pv = pd->address();
-
-    ::new( pv ) T(
-        boost::forward<A1>( a1 )
-        );
-
-    pd->set_initialized();
-
-    T * pt2 = static_cast< T* >( pv );
-
-    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
-    return boost::shared_ptr< T >( pt, pt2 );
-}
-
-template< class T, class A, class A1 >
-typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, BOOST_FWD_REF(A1) a1 )
-{
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
-
-    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
-
-    void * pv = pd->address();
-
-    ::new( pv ) T(
-        boost::forward<A1>( a1 )
-        );
-
-    pd->set_initialized();
-
-    T * pt2 = static_cast< T* >( pv );
-
-    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
-    return boost::shared_ptr< T >( pt, pt2 );
-}
-
-template< class T, class A1, class A2 >
-typename boost::detail::sp_if_not_array< T >::type make_shared( BOOST_FWD_REF(A1) a1, BOOST_FWD_REF(A2) a2 )
-{
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
-
-    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
-
-    void * pv = pd->address();
-
-    ::new( pv ) T(
-        boost::forward<A1>( a1 ),
-        boost::forward<A2>( a2 )
-        );
-
-    pd->set_initialized();
-
-    T * pt2 = static_cast< T* >( pv );
-
-    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
-    return boost::shared_ptr< T >( pt, pt2 );
-}
-
-template< class T, class A, class A1, class A2 >
-typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, BOOST_FWD_REF(A1) a1, BOOST_FWD_REF(A2) a2 )
-{
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
-
-    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
-
-    void * pv = pd->address();
-
-    ::new( pv ) T(
-        boost::forward<A1>( a1 ),
-        boost::forward<A2>( a2 )
-        );
-
-    pd->set_initialized();
-
-    T * pt2 = static_cast< T* >( pv );
-
-    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
-    return boost::shared_ptr< T >( pt, pt2 );
-}
-
-template< class T, class A1, class A2, class A3 >
-typename boost::detail::sp_if_not_array< T >::type make_shared( BOOST_FWD_REF(A1) a1, BOOST_FWD_REF(A2) a2, BOOST_FWD_REF(A3) a3 )
-{
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
-
-    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
-
-    void * pv = pd->address();
-
-    ::new( pv ) T(
-        boost::forward<A1>( a1 ),
-        boost::forward<A2>( a2 ),
-        boost::forward<A3>( a3 )
-        );
-
-    pd->set_initialized();
-
-    T * pt2 = static_cast< T* >( pv );
-
-    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
-    return boost::shared_ptr< T >( pt, pt2 );
-}
-
-template< class T, class A, class A1, class A2, class A3 >
-typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, BOOST_FWD_REF(A1) a1, BOOST_FWD_REF(A2) a2, BOOST_FWD_REF(A3) a3 )
-{
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
-
-    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
-
-    void * pv = pd->address();
-
-    ::new( pv ) T(
-        boost::forward<A1>( a1 ),
-        boost::forward<A2>( a2 ),
-        boost::forward<A3>( a3 )
-        );
-
-    pd->set_initialized();
-
-    T * pt2 = static_cast< T* >( pv );
-
-    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
-    return boost::shared_ptr< T >( pt, pt2 );
-}
-
-template< class T, class A1, class A2, class A3, class A4 >
-typename boost::detail::sp_if_not_array< T >::type make_shared( BOOST_FWD_REF(A1) a1, BOOST_FWD_REF(A2) a2, BOOST_FWD_REF(A3) a3, BOOST_FWD_REF(A4) a4 )
-{
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
-
-    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
-
-    void * pv = pd->address();
-
-    ::new( pv ) T(
-        boost::forward<A1>( a1 ),
-        boost::forward<A2>( a2 ),
-        boost::forward<A3>( a3 ),
-        boost::forward<A4>( a4 )
-        );
-
-    pd->set_initialized();
-
-    T * pt2 = static_cast< T* >( pv );
-
-    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
-    return boost::shared_ptr< T >( pt, pt2 );
-}
-
-template< class T, class A, class A1, class A2, class A3, class A4 >
-typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, BOOST_FWD_REF(A1) a1, BOOST_FWD_REF(A2) a2, BOOST_FWD_REF(A3) a3, BOOST_FWD_REF(A4) a4 )
-{
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
-
-    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
-
-    void * pv = pd->address();
-
-    ::new( pv ) T(
-        boost::forward<A1>( a1 ),
-        boost::forward<A2>( a2 ),
-        boost::forward<A3>( a3 ),
-        boost::forward<A4>( a4 )
-        );
-
-    pd->set_initialized();
-
-    T * pt2 = static_cast< T* >( pv );
-
-    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
-    return boost::shared_ptr< T >( pt, pt2 );
-}
-
-template< class T, class A1, class A2, class A3, class A4, class A5 >
-typename boost::detail::sp_if_not_array< T >::type make_shared( BOOST_FWD_REF(A1) a1, BOOST_FWD_REF(A2) a2, BOOST_FWD_REF(A3) a3, BOOST_FWD_REF(A4) a4, BOOST_FWD_REF(A5) a5 )
-{
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
-
-    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
-
-    void * pv = pd->address();
-
-    ::new( pv ) T(
-        boost::forward<A1>( a1 ),
-        boost::forward<A2>( a2 ),
-        boost::forward<A3>( a3 ),
-        boost::forward<A4>( a4 ),
-        boost::forward<A5>( a5 )
-        );
-
-    pd->set_initialized();
-
-    T * pt2 = static_cast< T* >( pv );
-
-    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
-    return boost::shared_ptr< T >( pt, pt2 );
-}
-
-template< class T, class A, class A1, class A2, class A3, class A4, class A5 >
-typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, BOOST_FWD_REF(A1) a1, BOOST_FWD_REF(A2) a2, BOOST_FWD_REF(A3) a3, BOOST_FWD_REF(A4) a4, BOOST_FWD_REF(A5) a5 )
-{
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
-
-    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
-
-    void * pv = pd->address();
-
-    ::new( pv ) T(
-        boost::forward<A1>( a1 ),
-        boost::forward<A2>( a2 ),
-        boost::forward<A3>( a3 ),
-        boost::forward<A4>( a4 ),
-        boost::forward<A5>( a5 )
-        );
-
-    pd->set_initialized();
-
-    T * pt2 = static_cast< T* >( pv );
-
-    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
-    return boost::shared_ptr< T >( pt, pt2 );
-}
-
-template< class T, class A1, class A2, class A3, class A4, class A5, class A6 >
-typename boost::detail::sp_if_not_array< T >::type make_shared( BOOST_FWD_REF(A1) a1, BOOST_FWD_REF(A2) a2, BOOST_FWD_REF(A3) a3, BOOST_FWD_REF(A4) a4, BOOST_FWD_REF(A5) a5, BOOST_FWD_REF(A6) a6 )
-{
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
-
-    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
-
-    void * pv = pd->address();
-
-    ::new( pv ) T(
-        boost::forward<A1>( a1 ),
-        boost::forward<A2>( a2 ),
-        boost::forward<A3>( a3 ),
-        boost::forward<A4>( a4 ),
-        boost::forward<A5>( a5 ),
-        boost::forward<A6>( a6 )
-        );
-
-    pd->set_initialized();
-
-    T * pt2 = static_cast< T* >( pv );
-
-    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
-    return boost::shared_ptr< T >( pt, pt2 );
-}
-
-template< class T, class A, class A1, class A2, class A3, class A4, class A5, class A6 >
-typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, BOOST_FWD_REF(A1) a1, BOOST_FWD_REF(A2) a2, BOOST_FWD_REF(A3) a3, BOOST_FWD_REF(A4) a4, BOOST_FWD_REF(A5) a5, BOOST_FWD_REF(A6) a6 )
-{
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
-
-    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
-
-    void * pv = pd->address();
-
-    ::new( pv ) T(
-        boost::forward<A1>( a1 ),
-        boost::forward<A2>( a2 ),
-        boost::forward<A3>( a3 ),
-        boost::forward<A4>( a4 ),
-        boost::forward<A5>( a5 ),
-        boost::forward<A6>( a6 )
-        );
-
-    pd->set_initialized();
-
-    T * pt2 = static_cast< T* >( pv );
-
-    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
-    return boost::shared_ptr< T >( pt, pt2 );
-}
-
-template< class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7 >
-typename boost::detail::sp_if_not_array< T >::type make_shared( BOOST_FWD_REF(A1) a1, BOOST_FWD_REF(A2) a2, BOOST_FWD_REF(A3) a3, BOOST_FWD_REF(A4) a4, BOOST_FWD_REF(A5) a5, BOOST_FWD_REF(A6) a6, BOOST_FWD_REF(A7) a7 )
-{
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
-
-    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
-
-    void * pv = pd->address();
-
-    ::new( pv ) T(
-        boost::forward<A1>( a1 ),
-        boost::forward<A2>( a2 ),
-        boost::forward<A3>( a3 ),
-        boost::forward<A4>( a4 ),
-        boost::forward<A5>( a5 ),
-        boost::forward<A6>( a6 ),
-        boost::forward<A7>( a7 )
-        );
-
-    pd->set_initialized();
-
-    T * pt2 = static_cast< T* >( pv );
-
-    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
-    return boost::shared_ptr< T >( pt, pt2 );
-}
-
-template< class T, class A, class A1, class A2, class A3, class A4, class A5, class A6, class A7 >
-typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, BOOST_FWD_REF(A1) a1, BOOST_FWD_REF(A2) a2, BOOST_FWD_REF(A3) a3, BOOST_FWD_REF(A4) a4, BOOST_FWD_REF(A5) a5, BOOST_FWD_REF(A6) a6, BOOST_FWD_REF(A7) a7 )
-{
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
-
-    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
-
-    void * pv = pd->address();
-
-    ::new( pv ) T(
-        boost::forward<A1>( a1 ),
-        boost::forward<A2>( a2 ),
-        boost::forward<A3>( a3 ),
-        boost::forward<A4>( a4 ),
-        boost::forward<A5>( a5 ),
-        boost::forward<A6>( a6 ),
-        boost::forward<A7>( a7 )
-        );
-
-    pd->set_initialized();
-
-    T * pt2 = static_cast< T* >( pv );
-
-    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
-    return boost::shared_ptr< T >( pt, pt2 );
-}
-
-template< class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8 >
-typename boost::detail::sp_if_not_array< T >::type make_shared( BOOST_FWD_REF(A1) a1, BOOST_FWD_REF(A2) a2, BOOST_FWD_REF(A3) a3, BOOST_FWD_REF(A4) a4, BOOST_FWD_REF(A5) a5, BOOST_FWD_REF(A6) a6, BOOST_FWD_REF(A7) a7, BOOST_FWD_REF(A8) a8 )
-{
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
-
-    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
-
-    void * pv = pd->address();
-
-    ::new( pv ) T(
-        boost::forward<A1>( a1 ),
-        boost::forward<A2>( a2 ),
-        boost::forward<A3>( a3 ),
-        boost::forward<A4>( a4 ),
-        boost::forward<A5>( a5 ),
-        boost::forward<A6>( a6 ),
-        boost::forward<A7>( a7 ),
-        boost::forward<A8>( a8 )
-        );
-
-    pd->set_initialized();
-
-    T * pt2 = static_cast< T* >( pv );
-
-    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
-    return boost::shared_ptr< T >( pt, pt2 );
-}
-
-template< class T, class A, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8 >
-typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, BOOST_FWD_REF(A1) a1, BOOST_FWD_REF(A2) a2, BOOST_FWD_REF(A3) a3, BOOST_FWD_REF(A4) a4, BOOST_FWD_REF(A5) a5, BOOST_FWD_REF(A6) a6, BOOST_FWD_REF(A7) a7, BOOST_FWD_REF(A8) a8 )
-{
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
-
-    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
-
-    void * pv = pd->address();
-
-    ::new( pv ) T(
-        boost::forward<A1>( a1 ),
-        boost::forward<A2>( a2 ),
-        boost::forward<A3>( a3 ),
-        boost::forward<A4>( a4 ),
-        boost::forward<A5>( a5 ),
-        boost::forward<A6>( a6 ),
-        boost::forward<A7>( a7 ),
-        boost::forward<A8>( a8 )
-        );
-
-    pd->set_initialized();
-
-    T * pt2 = static_cast< T* >( pv );
-
-    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
-    return boost::shared_ptr< T >( pt, pt2 );
-}
-
-template< class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9 >
-typename boost::detail::sp_if_not_array< T >::type make_shared( BOOST_FWD_REF(A1) a1, BOOST_FWD_REF(A2) a2, BOOST_FWD_REF(A3) a3, BOOST_FWD_REF(A4) a4, BOOST_FWD_REF(A5) a5, BOOST_FWD_REF(A6) a6, BOOST_FWD_REF(A7) a7, BOOST_FWD_REF(A8) a8, BOOST_FWD_REF(A9) a9 )
-{
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
-
-    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
-
-    void * pv = pd->address();
-
-    ::new( pv ) T(
-        boost::forward<A1>( a1 ),
-        boost::forward<A2>( a2 ),
-        boost::forward<A3>( a3 ),
-        boost::forward<A4>( a4 ),
-        boost::forward<A5>( a5 ),
-        boost::forward<A6>( a6 ),
-        boost::forward<A7>( a7 ),
-        boost::forward<A8>( a8 ),
-        boost::forward<A9>( a9 )
-        );
-
-    pd->set_initialized();
-
-    T * pt2 = static_cast< T* >( pv );
-
-    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
-    return boost::shared_ptr< T >( pt, pt2 );
-}
-
-template< class T, class A, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9 >
-typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, BOOST_FWD_REF(A1) a1, BOOST_FWD_REF(A2) a2, BOOST_FWD_REF(A3) a3, BOOST_FWD_REF(A4) a4, BOOST_FWD_REF(A5) a5, BOOST_FWD_REF(A6) a6, BOOST_FWD_REF(A7) a7, BOOST_FWD_REF(A8) a8, BOOST_FWD_REF(A9) a9 )
-{
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
-
-    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
-
-    void * pv = pd->address();
-
-    ::new( pv ) T(
-        boost::forward<A1>( a1 ),
-        boost::forward<A2>( a2 ),
-        boost::forward<A3>( a3 ),
-        boost::forward<A4>( a4 ),
-        boost::forward<A5>( a5 ),
-        boost::forward<A6>( a6 ),
-        boost::forward<A7>( a7 ),
-        boost::forward<A8>( a8 ),
-        boost::forward<A9>( a9 )
-        );
-
-    pd->set_initialized();
-
-    T * pt2 = static_cast< T* >( pv );
-
-    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
-    return boost::shared_ptr< T >( pt, pt2 );
-}
-
-#endif // !defined( BOOST_NO_CXX11_VARIADIC_TEMPLATES ) && !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
-
-#undef BOOST_SP_MSD
-
-} // namespace boost
-
-#endif // #ifndef BOOST_SMART_PTR_MAKE_SHARED_OBJECT_HPP_INCLUDED

include/boost/smart_ptr/make_unique.hpp

@@ -1,110 +0,0 @@
-/*
-Copyright 2012-2015 Glen Joseph Fernandes
-(glenjofe@gmail.com)
-
-Distributed under the Boost Software License, Version 1.0.
-(http://www.boost.org/LICENSE_1_0.txt)
-*/
-#ifndef BOOST_SMART_PTR_MAKE_UNIQUE_HPP
-#define BOOST_SMART_PTR_MAKE_UNIQUE_HPP
-
-#include <boost/config.hpp>
-#include <memory>
-#include <utility>
-
-namespace boost {
-namespace detail {
-
-template<class T>
-struct up_if_object {
-    typedef std::unique_ptr<T> type;
-};
-
-template<class T>
-struct up_if_object<T[]> { };
-
-template<class T, std::size_t N>
-struct up_if_object<T[N]> { };
-
-template<class T>
-struct up_if_array { };
-
-template<class T>
-struct up_if_array<T[]> {
-    typedef std::unique_ptr<T[]> type;
-};
-
-template<class T>
-struct up_remove_reference {
-    typedef T type;
-};
-
-template<class T>
-struct up_remove_reference<T&> {
-    typedef T type;
-};
-
-template<class T>
-struct up_remove_reference<T&&> {
-    typedef T type;
-};
-
-template<class T>
-struct up_element { };
-
-template<class T>
-struct up_element<T[]> {
-    typedef T type;
-};
-
-} /* detail */
-
-template<class T>
-inline typename detail::up_if_object<T>::type
-make_unique()
-{
-    return std::unique_ptr<T>(new T());
-}
-
-#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-template<class T, class... Args>
-inline typename detail::up_if_object<T>::type
-make_unique(Args&&... args)
-{
-    return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
-}
-#endif
-
-template<class T>
-inline typename detail::up_if_object<T>::type
-make_unique(typename detail::up_remove_reference<T>::type&& value)
-{
-    return std::unique_ptr<T>(new T(std::move(value)));
-}
-
-template<class T>
-inline typename detail::up_if_object<T>::type
-make_unique_noinit()
-{
-    return std::unique_ptr<T>(new T);
-}
-
-template<class T>
-inline typename detail::up_if_array<T>::type
-make_unique(std::size_t size)
-{
-    return std::unique_ptr<T>(new typename
-        detail::up_element<T>::type[size]());
-}
-
-template<class T>
-inline typename detail::up_if_array<T>::type
-make_unique_noinit(std::size_t size)
-{
-    return std::unique_ptr<T>(new typename
-        detail::up_element<T>::type[size]);
-}
-
-} /* boost */
-
-#endif

include/boost/smart_ptr/owner_less.hpp

@@ -1,34 +0,0 @@
-#ifndef BOOST_SMART_PTR_OWNER_LESS_HPP_INCLUDED
-#define BOOST_SMART_PTR_OWNER_LESS_HPP_INCLUDED
-
-//
-//  owner_less.hpp
-//
-//  Copyright (c) 2008 Frank Mori Hess
-//  Copyright (c) 2016 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)
-//
-//  See http://www.boost.org/libs/smart_ptr/smart_ptr.htm for documentation.
-//
-
-namespace boost
-{
-
-template<class T = void> struct owner_less
-{
-    typedef bool result_type;
-    typedef T first_argument_type;
-    typedef T second_argument_type;
-
-    template<class U, class V> bool operator()( U const & u, V const & v ) const
-    {
-        return u.owner_before( v );
-    }
-};
-
-} // namespace boost
-
-#endif  // #ifndef BOOST_SMART_PTR_OWNER_LESS_HPP_INCLUDED

include/boost/smart_ptr/scoped_array.hpp

@@ -11,11 +11,9 @@
 //  http://www.boost.org/libs/smart_ptr/scoped_array.htm
 //
 
-#include <boost/config.hpp>
 #include <boost/assert.hpp>
 #include <boost/checked_delete.hpp>
-#include <boost/smart_ptr/detail/sp_nullptr_t.hpp>
-#include <boost/smart_ptr/detail/sp_noexcept.hpp>
+#include <boost/config.hpp>   // in case ptrdiff_t not in std
 
 #include <boost/detail/workaround.hpp>
 
@@ -55,7 +53,7 @@ public:
 
     typedef T element_type;
 
-    explicit scoped_array( T * p = 0 ) BOOST_SP_NOEXCEPT : px( p )
+    explicit scoped_array( T * p = 0 ) : px( p ) // never throws
     {
 #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
         boost::sp_array_constructor_hook( px );
@@ -70,20 +68,20 @@ public:
         boost::checked_array_delete( px );
     }
 
-    void reset(T * p = 0) // never throws (but has a BOOST_ASSERT in it, so not marked with BOOST_NOEXCEPT)
+    void reset(T * p = 0) // never throws
     {
         BOOST_ASSERT( p == 0 || p != px ); // catch self-reset errors
         this_type(p).swap(*this);
     }
 
-    T & operator[](std::ptrdiff_t i) const // never throws (but has a BOOST_ASSERT in it, so not marked with BOOST_NOEXCEPT)
+    T & operator[](std::ptrdiff_t i) const // never throws
     {
         BOOST_ASSERT( px != 0 );
         BOOST_ASSERT( i >= 0 );
         return px[i];
     }
 
-    T * get() const BOOST_NOEXCEPT
+    T * get() const // never throws
     {
         return px;
     }
@@ -91,7 +89,7 @@ public:
 // implicit conversion to "bool"
 #include <boost/smart_ptr/detail/operator_bool.hpp>
 
-    void swap(scoped_array & b) BOOST_NOEXCEPT
+    void swap(scoped_array & b) // never throws
     {
         T * tmp = b.px;
         b.px = px;
@@ -99,31 +97,7 @@ public:
     }
 };
 
-#if !defined( BOOST_NO_CXX11_NULLPTR )
-
-template<class T> inline bool operator==( scoped_array<T> const & p, boost::detail::sp_nullptr_t ) BOOST_NOEXCEPT
-{
-    return p.get() == 0;
-}
-
-template<class T> inline bool operator==( boost::detail::sp_nullptr_t, scoped_array<T> const & p ) BOOST_NOEXCEPT
-{
-    return p.get() == 0;
-}
-
-template<class T> inline bool operator!=( scoped_array<T> const & p, boost::detail::sp_nullptr_t ) BOOST_NOEXCEPT
-{
-    return p.get() != 0;
-}
-
-template<class T> inline bool operator!=( boost::detail::sp_nullptr_t, scoped_array<T> const & p ) BOOST_NOEXCEPT
-{
-    return p.get() != 0;
-}
-
-#endif
-
-template<class T> inline void swap(scoped_array<T> & a, scoped_array<T> & b) BOOST_NOEXCEPT
+template<class T> inline void swap(scoped_array<T> & a, scoped_array<T> & b) // never throws
 {
     a.swap(b);
 }

include/boost/smart_ptr/scoped_ptr.hpp

@@ -11,23 +11,14 @@
 //  http://www.boost.org/libs/smart_ptr/scoped_ptr.htm
 //
 
-#include <boost/config.hpp>
 #include <boost/assert.hpp>
 #include <boost/checked_delete.hpp>
-#include <boost/smart_ptr/detail/sp_nullptr_t.hpp>
-#include <boost/smart_ptr/detail/sp_disable_deprecated.hpp>
-#include <boost/smart_ptr/detail/sp_noexcept.hpp>
 #include <boost/detail/workaround.hpp>
 
 #ifndef BOOST_NO_AUTO_PTR
 # include <memory>          // for std::auto_ptr
 #endif
 
-#if defined( BOOST_SP_DISABLE_DEPRECATED )
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-#endif
-
 namespace boost
 {
 
@@ -63,7 +54,7 @@ public:
 
     typedef T element_type;
 
-    explicit scoped_ptr( T * p = 0 ) BOOST_SP_NOEXCEPT : px( p ) // never throws
+    explicit scoped_ptr( T * p = 0 ): px( p ) // never throws
     {
 #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
         boost::sp_scalar_constructor_hook( px );
@@ -72,7 +63,7 @@ public:
 
 #ifndef BOOST_NO_AUTO_PTR
 
-    explicit scoped_ptr( std::auto_ptr<T> p ) BOOST_NOEXCEPT : px( p.release() )
+    explicit scoped_ptr( std::auto_ptr<T> p ): px( p.release() ) // never throws
     {
 #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
         boost::sp_scalar_constructor_hook( px );
@@ -107,7 +98,7 @@ public:
         return px;
     }
 
-    T * get() const BOOST_NOEXCEPT
+    T * get() const // never throws
     {
         return px;
     }
@@ -115,7 +106,7 @@ public:
 // implicit conversion to "bool"
 #include <boost/smart_ptr/detail/operator_bool.hpp>
 
-    void swap(scoped_ptr & b) BOOST_NOEXCEPT
+    void swap(scoped_ptr & b) // never throws
     {
         T * tmp = b.px;
         b.px = px;
@@ -123,46 +114,18 @@ public:
     }
 };
 
-#if !defined( BOOST_NO_CXX11_NULLPTR )
-
-template<class T> inline bool operator==( scoped_ptr<T> const & p, boost::detail::sp_nullptr_t ) BOOST_NOEXCEPT
-{
-    return p.get() == 0;
-}
-
-template<class T> inline bool operator==( boost::detail::sp_nullptr_t, scoped_ptr<T> const & p ) BOOST_NOEXCEPT
-{
-    return p.get() == 0;
-}
-
-template<class T> inline bool operator!=( scoped_ptr<T> const & p, boost::detail::sp_nullptr_t ) BOOST_NOEXCEPT
-{
-    return p.get() != 0;
-}
-
-template<class T> inline bool operator!=( boost::detail::sp_nullptr_t, scoped_ptr<T> const & p ) BOOST_NOEXCEPT
-{
-    return p.get() != 0;
-}
-
-#endif
-
-template<class T> inline void swap(scoped_ptr<T> & a, scoped_ptr<T> & b) BOOST_NOEXCEPT
+template<class T> inline void swap(scoped_ptr<T> & a, scoped_ptr<T> & b) // never throws
 {
     a.swap(b);
 }
 
 // get_pointer(p) is a generic way to say p.get()
 
-template<class T> inline T * get_pointer(scoped_ptr<T> const & p) BOOST_NOEXCEPT
+template<class T> inline T * get_pointer(scoped_ptr<T> const & p)
 {
     return p.get();
 }
 
 } // namespace boost
 
-#if defined( BOOST_SP_DISABLE_DEPRECATED )
-#pragma GCC diagnostic pop
-#endif
-
 #endif // #ifndef BOOST_SMART_PTR_SCOPED_PTR_HPP_INCLUDED

include/boost/smart_ptr/shared_array.hpp

@@ -5,7 +5,7 @@
 //  shared_array.hpp
 //
 //  (C) Copyright Greg Colvin and Beman Dawes 1998, 1999.
-//  Copyright (c) 2001, 2002, 2012 Peter Dimov
+//  Copyright (c) 2001, 2002 Peter Dimov
 //
 //  Distributed under the Boost Software License, Version 1.0. (See
 //  accompanying file LICENSE_1_0.txt or copy at
@@ -16,15 +16,16 @@
 
 #include <boost/config.hpp>   // for broken compiler workarounds
 
+#if defined(BOOST_NO_MEMBER_TEMPLATES) && !defined(BOOST_MSVC6_MEMBER_TEMPLATES)
+#include <boost/smart_ptr/detail/shared_array_nmt.hpp>
+#else
+
 #include <memory>             // TR1 cyclic inclusion fix
 
 #include <boost/assert.hpp>
 #include <boost/checked_delete.hpp>
 
-#include <boost/smart_ptr/shared_ptr.hpp>
 #include <boost/smart_ptr/detail/shared_count.hpp>
-#include <boost/smart_ptr/detail/sp_nullptr_t.hpp>
-#include <boost/smart_ptr/detail/sp_noexcept.hpp>
 #include <boost/detail/workaround.hpp>
 
 #include <cstddef>            // for std::ptrdiff_t
@@ -54,154 +55,41 @@ public:
 
     typedef T element_type;
 
-    shared_array() BOOST_SP_NOEXCEPT : px( 0 ), pn()
+    explicit shared_array(T * p = 0): px(p), pn(p, deleter())
     {
     }
 
-#if !defined( BOOST_NO_CXX11_NULLPTR )
-
-    shared_array( boost::detail::sp_nullptr_t ) BOOST_SP_NOEXCEPT : px( 0 ), pn()
-    {
-    }
-
-#endif
-
-    template<class Y>
-    explicit shared_array( Y * p ): px( p ), pn( p, checked_array_deleter<Y>() )
-    {
-        boost::detail::sp_assert_convertible< Y[], T[] >();
-    }
-
     //
     // Requirements: D's copy constructor must not throw
     //
     // shared_array will release p by calling d(p)
     //
 
-    template<class Y, class D> shared_array( Y * p, D d ): px( p ), pn( p, d )
-    {
-        boost::detail::sp_assert_convertible< Y[], T[] >();
-    }
-
-    // As above, but with allocator. A's copy constructor shall not throw.
-
-    template<class Y, class D, class A> shared_array( Y * p, D d, A a ): px( p ), pn( p, d, a )
-    {
-        boost::detail::sp_assert_convertible< Y[], T[] >();
-    }
-
-//  generated copy constructor, destructor are fine...
-
-#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
-
-// ... except in C++0x, move disables the implicit copy
-
-    shared_array( shared_array const & r ) BOOST_SP_NOEXCEPT : px( r.px ), pn( r.pn )
+    template<class D> shared_array(T * p, D d): px(p), pn(p, d)
     {
     }
 
-    shared_array( shared_array && r ) BOOST_SP_NOEXCEPT : px( r.px ), pn()
+//  generated copy constructor, assignment, destructor are fine
+
+    void reset(T * p = 0)
     {
-        pn.swap( r.pn );
-        r.px = 0;
-    }
-
-#endif
-
-    // conversion
-
-    template<class Y>
-#if !defined( BOOST_SP_NO_SP_CONVERTIBLE )
-
-    shared_array( shared_array<Y> const & r, typename boost::detail::sp_enable_if_convertible< Y[], T[] >::type = boost::detail::sp_empty() )
-
-#else
-
-    shared_array( shared_array<Y> const & r )
-
-#endif
-    BOOST_NOEXCEPT : px( r.px ), pn( r.pn ) // never throws
-    {
-        boost::detail::sp_assert_convertible< Y[], T[] >();
-    }
-
-    // aliasing
-
-    template< class Y >
-    shared_array( shared_array<Y> const & r, element_type * p ) BOOST_NOEXCEPT : px( p ), pn( r.pn )
-    {
-    }
-
-    // assignment
-
-    shared_array & operator=( shared_array const & r ) BOOST_SP_NOEXCEPT
-    {
-        this_type( r ).swap( *this );
-        return *this;
-    }
-
-#if !defined(BOOST_MSVC) || (BOOST_MSVC >= 1400)
-
-    template<class Y>
-    shared_array & operator=( shared_array<Y> const & r ) BOOST_NOEXCEPT
-    {
-        this_type( r ).swap( *this );
-        return *this;
-    }
-
-#endif
-
-#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
-
-    shared_array & operator=( shared_array && r ) BOOST_SP_NOEXCEPT
-    {
-        this_type( static_cast< shared_array && >( r ) ).swap( *this );
-        return *this;
-    }
-
-    template<class Y>
-    shared_array & operator=( shared_array<Y> && r ) BOOST_NOEXCEPT
-    {
-        this_type( static_cast< shared_array<Y> && >( r ) ).swap( *this );
-        return *this;
-    }
-
-#endif
-
-    void reset() BOOST_NOEXCEPT
-    {
-        this_type().swap( *this );
-    }
-
-    template<class Y> void reset( Y * p ) // Y must be complete
-    {
-        BOOST_ASSERT( p == 0 || p != px ); // catch self-reset errors
+        BOOST_ASSERT(p == 0 || p != px);
         this_type(p).swap(*this);
     }
 
-    template<class Y, class D> void reset( Y * p, D d )
+    template <class D> void reset(T * p, D d)
     {
         this_type(p, d).swap(*this);
     }
 
-    template<class Y, class D, class A> void reset( Y * p, D d, A a )
-    {
-        this_type( p, d, a ).swap( *this );
-    }
-
-    template<class Y> void reset( shared_array<Y> const & r, element_type * p )
-    {
-        this_type( r, p ).swap( *this );
-    }
-
-    T & operator[] (std::ptrdiff_t i) const // never throws (but has a BOOST_ASSERT in it, so not marked with BOOST_NOEXCEPT)
+    T & operator[] (std::ptrdiff_t i) const // never throws
     {
         BOOST_ASSERT(px != 0);
         BOOST_ASSERT(i >= 0);
         return px[i];
     }
     
-    T * get() const BOOST_NOEXCEPT
+    T * get() const // never throws
     {
         return px;
     }
@@ -209,85 +97,51 @@ public:
 // implicit conversion to "bool"
 #include <boost/smart_ptr/detail/operator_bool.hpp>
 
-    bool unique() const BOOST_NOEXCEPT
+    bool unique() const // never throws
     {
         return pn.unique();
     }
 
-    long use_count() const BOOST_NOEXCEPT
+    long use_count() const // never throws
     {
         return pn.use_count();
     }
 
-    void swap(shared_array<T> & other) BOOST_NOEXCEPT
+    void swap(shared_array<T> & other) // never throws
     {
         std::swap(px, other.px);
         pn.swap(other.pn);
     }
 
-    void * _internal_get_deleter( boost::detail::sp_typeinfo const & ti ) const
-    {
-        return pn.get_deleter( ti );
-    }
-
 private:
 
-    template<class Y> friend class shared_array;
-
     T * px;                     // contained pointer
     detail::shared_count pn;    // reference counter
 
 };  // shared_array
 
-template<class T> inline bool operator==(shared_array<T> const & a, shared_array<T> const & b) BOOST_NOEXCEPT
+template<class T> inline bool operator==(shared_array<T> const & a, shared_array<T> const & b) // never throws
 {
     return a.get() == b.get();
 }
 
-template<class T> inline bool operator!=(shared_array<T> const & a, shared_array<T> const & b) BOOST_NOEXCEPT
+template<class T> inline bool operator!=(shared_array<T> const & a, shared_array<T> const & b) // never throws
 {
     return a.get() != b.get();
 }
 
-#if !defined( BOOST_NO_CXX11_NULLPTR )
-
-template<class T> inline bool operator==( shared_array<T> const & p, boost::detail::sp_nullptr_t ) BOOST_NOEXCEPT
-{
-    return p.get() == 0;
-}
-
-template<class T> inline bool operator==( boost::detail::sp_nullptr_t, shared_array<T> const & p ) BOOST_NOEXCEPT
-{
-    return p.get() == 0;
-}
-
-template<class T> inline bool operator!=( shared_array<T> const & p, boost::detail::sp_nullptr_t ) BOOST_NOEXCEPT
-{
-    return p.get() != 0;
-}
-
-template<class T> inline bool operator!=( boost::detail::sp_nullptr_t, shared_array<T> const & p ) BOOST_NOEXCEPT
-{
-    return p.get() != 0;
-}
-
-#endif
-
-template<class T> inline bool operator<(shared_array<T> const & a, shared_array<T> const & b) BOOST_NOEXCEPT
+template<class T> inline bool operator<(shared_array<T> const & a, shared_array<T> const & b) // never throws
 {
     return std::less<T*>()(a.get(), b.get());
 }
 
-template<class T> void swap(shared_array<T> & a, shared_array<T> & b) BOOST_NOEXCEPT
+template<class T> void swap(shared_array<T> & a, shared_array<T> & b) // never throws
 {
     a.swap(b);
 }
 
-template< class D, class T > D * get_deleter( shared_array<T> const & p )
-{
-    return static_cast< D * >( p._internal_get_deleter( BOOST_SP_TYPEID(D) ) );
-}
-
 } // namespace boost
 
+#endif  // #if defined(BOOST_NO_MEMBER_TEMPLATES) && !defined(BOOST_MSVC6_MEMBER_TEMPLATES)
+
 #endif  // #ifndef BOOST_SMART_PTR_SHARED_ARRAY_HPP_INCLUDED

include/boost/smart_ptr/weak_ptr.hpp

@@ -16,7 +16,11 @@
 #include <memory> // boost.TR1 include order fix
 #include <boost/smart_ptr/detail/shared_count.hpp>
 #include <boost/smart_ptr/shared_ptr.hpp>
-#include <boost/smart_ptr/detail/sp_noexcept.hpp>
+
+#ifdef BOOST_MSVC  // moved here to work around VC++ compiler crash
+# pragma warning(push)
+# pragma warning(disable:4284) // odd return type for operator->
+#endif
 
 namespace boost
 {
@@ -30,30 +34,14 @@ private:
 
 public:
 
-    typedef typename boost::detail::sp_element< T >::type element_type;
+    typedef T element_type;
 
-    weak_ptr() BOOST_SP_NOEXCEPT : px(0), pn() // never throws in 1.30+
+    weak_ptr(): px(0), pn() // never throws in 1.30+
     {
     }
 
-//  generated copy constructor, assignment, destructor are fine...
+//  generated copy constructor, assignment, destructor are fine
 
-#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
-
-// ... except in C++0x, move disables the implicit copy
-
-    weak_ptr( weak_ptr const & r ) BOOST_SP_NOEXCEPT : px( r.px ), pn( r.pn )
-    {
-    }
-
-    weak_ptr & operator=( weak_ptr const & r ) BOOST_SP_NOEXCEPT
-    {
-        px = r.px;
-        pn = r.pn;
-        return *this;
-    }
-
-#endif
 
 //
 //  The "obvious" converting constructor implementation:
@@ -82,12 +70,11 @@ public:
     weak_ptr( weak_ptr<Y> const & r )
 
 #endif
-    BOOST_NOEXCEPT : px(r.lock().get()), pn(r.pn)
+    : px(r.lock().get()), pn(r.pn) // never throws
     {
-        boost::detail::sp_assert_convertible< Y, T >();
     }
 
-#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
+#if defined( BOOST_HAS_RVALUE_REFS )
 
     template<class Y>
 #if !defined( BOOST_SP_NO_SP_CONVERTIBLE )
@@ -99,21 +86,19 @@ public:
     weak_ptr( weak_ptr<Y> && r )
 
 #endif
-    BOOST_NOEXCEPT : px( r.lock().get() ), pn( static_cast< boost::detail::weak_count && >( r.pn ) )
-    {
-        boost::detail::sp_assert_convertible< Y, T >();
-        r.px = 0;
-    }
-
-    // for better efficiency in the T == Y case
-    weak_ptr( weak_ptr && r )
-    BOOST_SP_NOEXCEPT : px( r.px ), pn( static_cast< boost::detail::weak_count && >( r.pn ) )
+    : px( r.lock().get() ), pn( static_cast< boost::detail::weak_count && >( r.pn ) ) // never throws
     {
         r.px = 0;
     }
 
     // for better efficiency in the T == Y case
-    weak_ptr & operator=( weak_ptr && r ) BOOST_SP_NOEXCEPT
+    weak_ptr( weak_ptr && r ): px( r.px ), pn( static_cast< boost::detail::weak_count && >( r.pn ) ) // never throws
+    {
+        r.px = 0;
+    }
+
+    // for better efficiency in the T == Y case
+    weak_ptr & operator=( weak_ptr && r ) // never throws
     {
         this_type( static_cast< weak_ptr && >( r ) ).swap( *this );
         return *this;
@@ -132,28 +117,24 @@ public:
     weak_ptr( shared_ptr<Y> const & r )
 
 #endif
-    BOOST_NOEXCEPT : px( r.px ), pn( r.pn )
+    : px( r.px ), pn( r.pn ) // never throws
     {
-        boost::detail::sp_assert_convertible< Y, T >();
     }
 
 #if !defined(BOOST_MSVC) || (BOOST_MSVC >= 1300)
 
     template<class Y>
-    weak_ptr & operator=( weak_ptr<Y> const & r ) BOOST_NOEXCEPT
+    weak_ptr & operator=(weak_ptr<Y> const & r) // never throws
     {
-        boost::detail::sp_assert_convertible< Y, T >();
-
         px = r.lock().get();
         pn = r.pn;
-
         return *this;
     }
 
-#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
+#if defined( BOOST_HAS_RVALUE_REFS )
 
     template<class Y>
-    weak_ptr & operator=( weak_ptr<Y> && r ) BOOST_NOEXCEPT
+    weak_ptr & operator=( weak_ptr<Y> && r )
     {
         this_type( static_cast< weak_ptr<Y> && >( r ) ).swap( *this );
         return *this;
@@ -162,29 +143,26 @@ public:
 #endif
 
     template<class Y>
-    weak_ptr & operator=( shared_ptr<Y> const & r ) BOOST_NOEXCEPT
+    weak_ptr & operator=(shared_ptr<Y> const & r) // never throws
     {
-        boost::detail::sp_assert_convertible< Y, T >();
-
         px = r.px;
         pn = r.pn;
-
         return *this;
     }
 
 #endif
 
-    shared_ptr<T> lock() const BOOST_NOEXCEPT
+    shared_ptr<T> lock() const // never throws
     {
-        return shared_ptr<T>( *this, boost::detail::sp_nothrow_tag() );
+        return shared_ptr<element_type>( *this, boost::detail::sp_nothrow_tag() );
     }
 
-    long use_count() const BOOST_NOEXCEPT
+    long use_count() const // never throws
     {
         return pn.use_count();
     }
 
-    bool expired() const BOOST_NOEXCEPT
+    bool expired() const // never throws
     {
         return pn.use_count() == 0;
     }
@@ -194,30 +172,24 @@ public:
         return pn.empty();
     }
 
-    void reset() BOOST_NOEXCEPT // never throws in 1.30+
+    void reset() // never throws in 1.30+
     {
         this_type().swap(*this);
     }
 
-    void swap(this_type & other) BOOST_NOEXCEPT
+    void swap(this_type & other) // never throws
     {
         std::swap(px, other.px);
         pn.swap(other.pn);
     }
 
-    template<typename Y>
-    void _internal_aliasing_assign(weak_ptr<Y> const & r, element_type * px2)
+    void _internal_assign(T * px2, boost::detail::shared_count const & pn2)
     {
         px = px2;
-        pn = r.pn;
+        pn = pn2;
     }
 
-    template<class Y> bool owner_before( weak_ptr<Y> const & rhs ) const BOOST_NOEXCEPT
-    {
-        return pn < rhs.pn;
-    }
-
-    template<class Y> bool owner_before( shared_ptr<Y> const & rhs ) const BOOST_NOEXCEPT
+    template<class Y> bool _internal_less(weak_ptr<Y> const & rhs) const
     {
         return pn < rhs.pn;
     }
@@ -234,21 +206,25 @@ private:
 
 #endif
 
-    element_type * px;            // contained pointer
+    T * px;                       // contained pointer
     boost::detail::weak_count pn; // reference counter
 
 };  // weak_ptr
 
-template<class T, class U> inline bool operator<(weak_ptr<T> const & a, weak_ptr<U> const & b) BOOST_NOEXCEPT
+template<class T, class U> inline bool operator<(weak_ptr<T> const & a, weak_ptr<U> const & b)
 {
-    return a.owner_before( b );
+    return a._internal_less(b);
 }
 
-template<class T> void swap(weak_ptr<T> & a, weak_ptr<T> & b) BOOST_NOEXCEPT
+template<class T> void swap(weak_ptr<T> & a, weak_ptr<T> & b)
 {
     a.swap(b);
 }
 
 } // namespace boost
 
+#ifdef BOOST_MSVC
+# pragma warning(pop)
+#endif    
+
 #endif  // #ifndef BOOST_SMART_PTR_WEAK_PTR_HPP_INCLUDED

index.html

@@ -1,17 +1,14 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 <html>
 <head>
-<title>Smart Pointers</title>
-<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
 <meta http-equiv="refresh" content="0; URL=smart_ptr.htm">
 </head>
-<body text="#000000" bgcolor="#ffffff" link="#0000ff" vlink="#0000ff">
+<body>
 Automatic redirection failed, please go to
 <a href="smart_ptr.htm">smart_ptr.htm</a>.
 </body>
 </html>
 <!--
-    (C) Copyright Beman Dawes, 2001
+	<09> Copyright Beman Dawes, 2001
 	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

intrusive_ptr.html

@@ -1,49 +1,47 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 <html>
 	<head>
 		<title>intrusive_ptr</title>
 		<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
 	</head>
-    <body text="#000000" bgcolor="#ffffff" link="#0000ff" vlink="#0000ff">
-        <h1><img height="86" alt="boost.png (6897 bytes)" src="../../boost.png" 
-            width="277" align="middle" border="0">intrusive_ptr class template</h1>
+	<body text="#000000" bgColor="#ffffff">
+		<h1><A href="../../index.htm"><IMG height="86" alt="boost.png (6897 bytes)" src="../../boost.png" width="277" align="middle"
+					border="0"></A>intrusive_ptr class template</h1>
 		<p>
-            <a href="#Introduction">Introduction</a><br>
-            <a href="#Synopsis">Synopsis</a><br>
-            <a href="#Members">Members</a><br>
-            <a href="#functions">Free Functions</a><br>
+			<A href="#Introduction">Introduction</A><br>
+			<A href="#Synopsis">Synopsis</A><br>
+			<A href="#Members">Members</A><br>
+			<A href="#functions">Free Functions</A><br>
 		</p>
 		<h2><a name="Introduction">Introduction</a></h2>
-        <p>The <code>intrusive_ptr</code> class template stores a pointer to an object with an 
-            embedded reference count. Every new <code>intrusive_ptr</code> instance increments 
-            the reference count by using an unqualified call to the function <code>intrusive_ptr_add_ref</code>, 
-            passing it the pointer as an argument. Similarly, when an <code>intrusive_ptr</code>
-            is destroyed, it calls <code>intrusive_ptr_release</code>; this function is 
+		<p>The <b>intrusive_ptr</b> class template stores a pointer to an object with an 
+			embedded reference count. Every new <b>intrusive_ptr</b> instance increments 
+			the reference count by using an unqualified call to the function <STRONG>intrusive_ptr_add_ref</STRONG>, 
+			passing it the pointer as an argument. Similarly, when an <STRONG>intrusive_ptr</STRONG>
+			is destroyed, it calls <STRONG>intrusive_ptr_release</STRONG>; this function is 
 			responsible for destroying the object when its reference count drops to zero. 
 			The user is expected to provide suitable definitions of these two functions. On 
-            compilers that support argument-dependent lookup, <code>intrusive_ptr_add_ref</code>
-            and <code>intrusive_ptr_release</code> should be defined in the namespace 
+			compilers that support argument-dependent lookup, <STRONG>intrusive_ptr_add_ref</STRONG>
+			and <STRONG>intrusive_ptr_release</STRONG> should be defined in the namespace 
 			that corresponds to their parameter; otherwise, the definitions need to go in 
-            namespace <code>boost</code>. The library provides a helper base class template
-            <code><a href="intrusive_ref_counter.html">intrusive_ref_counter</a></code> which may
-            help adding support for <code>intrusive_ptr</code> to user types.</p>
-        <p>The class template is parameterized on <code>T</code>, the type of the object pointed 
-            to. <code>intrusive_ptr&lt;T&gt;</code> can be implicitly converted to <code>intrusive_ptr&lt;U&gt;</code>
-            whenever <code>T*</code> can be implicitly converted to <code>U*</code>.</p>
-        <p>The main reasons to use <code>intrusive_ptr</code> are:</p>
-        <ul>
-            <li>
+			namespace <STRONG>boost</STRONG>.</p>
+		<p>The class template is parameterized on <b>T</b>, the type of the object pointed 
+			to. <STRONG>intrusive_ptr&lt;T&gt;</STRONG> can be implicitly converted to <STRONG>intrusive_ptr&lt;U&gt;</STRONG>
+			whenever <STRONG>T*</STRONG> can be implicitly converted to <STRONG>U*</STRONG>.</p>
+		<P>The main reasons to use <STRONG>intrusive_ptr</STRONG> are:</P>
+		<UL>
+			<LI>
 			Some existing frameworks or OSes provide objects with embedded reference 
-            counts;</li>
-            <li>
-                The memory footprint of <code>intrusive_ptr</code>
-            is the same as the corresponding raw pointer;</li>
-            <li>
-                <code>intrusive_ptr&lt;T&gt;</code> can be constructed from an arbitrary 
-                raw pointer of type <code>T *</code>.</li></ul>
-        <p>As a general rule, if it isn't obvious whether <code>intrusive_ptr</code> better 
-            fits your needs than <code>shared_ptr</code>, try a <code>shared_ptr</code>-based 
-            design first.</p>
+			counts;
+			<LI>
+				The memory footprint of <STRONG>intrusive_ptr</STRONG>
+			is the same as the corresponding raw pointer;
+			<LI>
+				<STRONG>intrusive_ptr&lt;T&gt;</STRONG> can be constructed from an arbitrary 
+				raw pointer of type <STRONG>T *</STRONG>.</LI></UL>
+		<P>As a general rule, if it isn't obvious whether <STRONG>intrusive_ptr</STRONG> better 
+			fits your needs than <STRONG>shared_ptr</STRONG>, try a <STRONG>shared_ptr</STRONG>-based 
+			design first.</P>
 		<h2><a name="Synopsis">Synopsis</a></h2>
 		<pre>namespace boost {
 
@@ -51,77 +49,75 @@
 
     public:
 
-      typedef T <a href="#element_type" >element_type</a>;
+      typedef T <A href="#element_type" >element_type</A>;
 
-      <a href="#constructors" >intrusive_ptr</a>(); // never throws
-      <a href="#constructors" >intrusive_ptr</a>(T * p, bool add_ref = true);
+      <A href="#constructors" >intrusive_ptr</A>(); // never throws
+      <A href="#constructors" >intrusive_ptr</A>(T * p, bool add_ref = true);
 
-      <a href="#constructors" >intrusive_ptr</a>(intrusive_ptr const &amp; r);
-      template&lt;class Y&gt; <a href="#constructors" >intrusive_ptr</a>(intrusive_ptr&lt;Y&gt; const &amp; r);
+      <A href="#constructors" >intrusive_ptr</A>(intrusive_ptr const &amp; r);
+      template&lt;class Y&gt; <A href="#constructors" >intrusive_ptr</A>(intrusive_ptr&lt;Y&gt; const &amp; r);
 
-      <a href="#destructor" >~intrusive_ptr</a>();
+      <A href="#destructor" >~intrusive_ptr</A>();
 
-      intrusive_ptr &amp; <a href="#assignment" >operator=</a>(intrusive_ptr const &amp; r);
-      template&lt;class Y&gt; intrusive_ptr &amp; <a href="#assignment" >operator=</a>(intrusive_ptr&lt;Y&gt; const &amp; r);
-      intrusive_ptr &amp; <a href="#assignment" >operator=</a>(T * r);
+      intrusive_ptr &amp; <A href="#assignment" >operator=</A>(intrusive_ptr const &amp; r);
+      template&lt;class Y&gt; intrusive_ptr &amp; <A href="#assignment" >operator=</A>(intrusive_ptr&lt;Y&gt; const &amp; r);
+      intrusive_ptr &amp; <A href="#assignment" >operator=</A>(T * r);
 
       void <a href="#reset" >reset</a>();
       void <a href="#reset" >reset</a>(T * r);
-      void <a href="#reset" >reset</a>(T * r, bool add_ref);
 
-      T &amp; <a href="#indirection" >operator*</a>() const; // never throws
-      T * <a href="#indirection" >operator-&gt;</a>() const; // never throws
-      T * <a href="#get" >get</a>() const; // never throws
-      T * <a href="#detach" >detach</a>(); // never throws
+      T &amp; <A href="#indirection" >operator*</A>() const; // never throws
+      T * <A href="#indirection" >operator-&gt;</A>() const; // never throws
+      T * <A href="#get" >get</A>() const; // never throws
 
-      operator <a href="#conversions" ><i>unspecified-bool-type</i></a>() const; // never throws
+      operator <A href="#conversions" ><i>unspecified-bool-type</i></A>() const; // never throws
 
-      void <a href="#swap" >swap</a>(intrusive_ptr &amp; b); // never throws
+      void <A href="#swap" >swap</A>(intrusive_ptr &amp; b); // never throws
   };
 
   template&lt;class T, class U&gt;
-    bool <a href="#comparison" >operator==</a>(intrusive_ptr&lt;T&gt; const &amp; a, intrusive_ptr&lt;U&gt; const &amp; b); // never throws
+    bool <A href="#comparison" >operator==</A>(intrusive_ptr&lt;T&gt; const &amp; a, intrusive_ptr&lt;U&gt; const &amp; b); // never throws
 
   template&lt;class T, class U&gt;
-    bool <a href="#comparison" >operator!=</a>(intrusive_ptr&lt;T&gt; const &amp; a, intrusive_ptr&lt;U&gt; const &amp; b); // never throws
+    bool <A href="#comparison" >operator!=</A>(intrusive_ptr&lt;T&gt; const &amp; a, intrusive_ptr&lt;U&gt; const &amp; b); // never throws
 
   template&lt;class T&gt;
-    bool <a href="#comparison" >operator==</a>(intrusive_ptr&lt;T&gt; const &amp; a, T * b); // never throws
+    bool <A href="#comparison" >operator==</A>(intrusive_ptr&lt;T&gt; const &amp; a, T * b); // never throws
 
   template&lt;class T&gt;
-    bool <a href="#comparison" >operator!=</a>(intrusive_ptr&lt;T&gt; const &amp; a, T * b); // never throws
+    bool <A href="#comparison" >operator!=</A>(intrusive_ptr&lt;T&gt; const &amp; a, T * b); // never throws
 
   template&lt;class T&gt;
-    bool <a href="#comparison" >operator==</a>(T * a, intrusive_ptr&lt;T&gt; const &amp; b); // never throws
+    bool <A href="#comparison" >operator==</A>(T * a, intrusive_ptr&lt;T&gt; const &amp; b); // never throws
 
   template&lt;class T&gt;
-    bool <a href="#comparison" >operator!=</a>(T * a, intrusive_ptr&lt;T&gt; const &amp; b); // never throws
+    bool <A href="#comparison" >operator!=</A>(T * a, intrusive_ptr&lt;T&gt; const &amp; b); // never throws
 
   template&lt;class T, class U&gt;
-    bool <a href="#comparison" >operator&lt;</a>(intrusive_ptr&lt;T&gt; const &amp; a, intrusive_ptr&lt;U&gt; const &amp; b); // never throws
+    bool <A href="#comparison" >operator&lt;</A>(intrusive_ptr&lt;T&gt; const &amp; a, intrusive_ptr&lt;U&gt; const &amp; b); // never throws
 
-  template&lt;class T&gt; void <a href="#free-swap" >swap</a>(intrusive_ptr&lt;T&gt; &amp; a, intrusive_ptr&lt;T&gt; &amp; b); // never throws
+  template&lt;class T&gt; void <A href="#free-swap" >swap</A>(intrusive_ptr&lt;T&gt; &amp; a, intrusive_ptr&lt;T&gt; &amp; b); // never throws
 
-  template&lt;class T&gt; T * <a href="#get_pointer" >get_pointer</a>(intrusive_ptr&lt;T&gt; const &amp; p); // never throws
+  template&lt;class T&gt; T * <A href="#get_pointer" >get_pointer</A>(intrusive_ptr&lt;T&gt; const &amp; p); // never throws
 
   template&lt;class T, class U&gt;
-    intrusive_ptr&lt;T&gt; <a href="#static_pointer_cast" >static_pointer_cast</a>(intrusive_ptr&lt;U&gt; const &amp; r); // never throws
+    intrusive_ptr&lt;T&gt; <A href="#static_pointer_cast" >static_pointer_cast</A>(intrusive_ptr&lt;U&gt; const &amp; r); // never throws
 
   template&lt;class T, class U&gt;
-    intrusive_ptr&lt;T&gt; <a href="#const_pointer_cast" >const_pointer_cast</a>(intrusive_ptr&lt;U&gt; const &amp; r); // never throws
+    intrusive_ptr&lt;T&gt; <A href="#const_pointer_cast" >const_pointer_cast</A>(intrusive_ptr&lt;U&gt; const &amp; r); // never throws
 
   template&lt;class T, class U&gt;
-    intrusive_ptr&lt;T&gt; <a href="#dynamic_pointer_cast" >dynamic_pointer_cast</a>(intrusive_ptr&lt;U&gt; const &amp; r); // never throws
+    intrusive_ptr&lt;T&gt; <A href="#dynamic_pointer_cast" >dynamic_pointer_cast</A>(intrusive_ptr&lt;U&gt; const &amp; r); // never throws
 
   template&lt;class E, class T, class Y&gt;
-    std::basic_ostream&lt;E, T&gt; &amp; <a href="#insertion-operator" >operator&lt;&lt;</a> (std::basic_ostream&lt;E, T&gt; &amp; os, intrusive_ptr&lt;Y&gt; const &amp; p);
+    std::basic_ostream&lt;E, T&gt; &amp; <A href="#insertion-operator" >operator&lt;&lt;</A> (std::basic_ostream&lt;E, T&gt; &amp; os, intrusive_ptr&lt;Y&gt; const &amp; p);
 
 }</pre>
 		<h2><a name="Members">Members</a></h2>
 		<h3><a name="element_type">element_type</a></h3>
 		<pre>typedef T element_type;</pre>
 		<blockquote>
-            <p>Provides the type of the template parameter <code>T</code>.</p>
+			<p>Provides the type of the template parameter T.</p>
 		</blockquote>
 		<h3><a name="constructors">constructors</a></h3>
 		<pre>intrusive_ptr(); // never throws</pre>
@@ -142,30 +138,26 @@ template&lt;class Y&gt; intrusive_ptr(intrusive_ptr&lt;Y&gt; const &amp; r);</pr
 		</blockquote>
 		<h3><a name="destructor">destructor</a></h3>
 		<pre>~intrusive_ptr();</pre>
-        <blockquote>
-            <p><b>Effects:</b> <code>if(get() != 0) intrusive_ptr_release(get());</code>.</p>
-        </blockquote>
-        <h3><a name="assignment">assignment</a></h3>
+		<BLOCKQUOTE>
+			<P><B>Effects:</B> <code>if(get() != 0) intrusive_ptr_release(get());</code>.</P>
+		</BLOCKQUOTE>
+		<H3><a name="assignment">assignment</a></H3>
 		<pre>intrusive_ptr &amp; operator=(intrusive_ptr const &amp; r);
 template&lt;class Y&gt; intrusive_ptr &amp; operator=(intrusive_ptr&lt;Y&gt; const &amp; r);
 intrusive_ptr &amp; operator=(T * r);</pre>
-        <blockquote>
-            <p><b>Effects:</b> Equivalent to <code>intrusive_ptr(r).swap(*this)</code>.</p>
-            <p><b>Returns:</b> <code>*this</code>.</p>
-        </blockquote>
-        <h3><a name="reset">reset</a></h3>
+		<BLOCKQUOTE>
+			<P><B>Effects:</B> Equivalent to <code>intrusive_ptr(r).swap(*this)</code>.</P>
+			<P><B>Returns:</B> <code>*this</code>.</P>
+		</BLOCKQUOTE>
+		<H3><a name="reset">reset</a></H3>
 		<pre>void reset();</pre>
-        <blockquote>
-            <p><b>Effects:</b> Equivalent to <code>intrusive_ptr().swap(*this)</code>.</p>
-        </blockquote>
+		<BLOCKQUOTE>
+			<P><B>Effects:</B> Equivalent to <code>intrusive_ptr().swap(*this)</code>.</P>
+		</BLOCKQUOTE>
 		<pre>void reset(T * r);</pre>
-        <blockquote>
-            <p><b>Effects:</b> Equivalent to <code>intrusive_ptr(r).swap(*this)</code>.</p>
-        </blockquote>
-        <pre>void reset(T * r, bool add_ref);</pre>
-        <blockquote>
-            <p><b>Effects:</b> Equivalent to <code>intrusive_ptr(r, add_ref).swap(*this)</code>.</p>
-        </blockquote>
+		<BLOCKQUOTE>
+			<P><B>Effects:</B> Equivalent to <code>intrusive_ptr(r).swap(*this)</code>.</P>
+		</BLOCKQUOTE>
 		<h3><a name="indirection">indirection</a></h3>
 		<pre>T &amp; operator*() const; // never throws</pre>
 		<blockquote>
@@ -185,32 +177,16 @@ intrusive_ptr &amp; operator=(T * r);</pre>
 			<p><b>Returns:</b> the stored pointer.</p>
 			<p><b>Throws:</b> nothing.</p>
 		</blockquote>
-        <h3><a name="detach">detach</a></h3>
-        <pre>T * detach(); // never throws</pre>
-        <blockquote>
-            <p><b>Returns:</b> the stored pointer.</p>
-            <p><b>Throws:</b> nothing.</p>
-            <p><b>Postconditions:</b> <code>get() == 0</code>.</p>
-            <p><b>Notes:</b> The returned pointer has an elevated reference count. This
-                allows conversion of an <code>intrusive_ptr</code> back to a raw pointer,
-                without the performance overhead of acquiring and dropping an extra
-                reference. It can be viewed as the complement of the
-                non-reference-incrementing constructor.</p>
-            <p><b>Caution:</b> Using <code>detach</code> escapes the safety of automatic
-                reference counting provided by <code>intrusive_ptr</code>. It should
-                by used only where strictly necessary (such as when interfacing to an
-                existing API), and when the implications are thoroughly understood.</p>
-        </blockquote>
 		<h3><a name="conversions">conversions</a></h3>
 		<pre>operator <i>unspecified-bool-type</i> () const; // never throws</pre>
 		<blockquote>
 			<p><b>Returns:</b> an unspecified value that, when used in boolean contexts, is 
 				equivalent to <code>get() != 0</code>.</p>
 			<p><b>Throws:</b> nothing.</p>
-            <p><b>Notes:</b> This conversion operator allows <code>intrusive_ptr</code> objects to be 
+			<P><B>Notes:</B> This conversion operator allows <b>intrusive_ptr</b> objects to be 
 				used in boolean contexts, like <code>if (p &amp;&amp; p-&gt;valid()) {}</code>. 
 				The actual target type is typically a pointer to a member function, avoiding 
-                many of the implicit conversion pitfalls.</p>
+				many of the implicit conversion pitfalls.</P>
 		</blockquote>
 		<h3><a name="swap">swap</a></h3>
 		<pre>void swap(intrusive_ptr &amp; b); // never throws</pre>
@@ -261,60 +237,61 @@ intrusive_ptr &amp; operator=(T * r);</pre>
 		<blockquote>
 			<p><b>Returns:</b> <code>std::less&lt;T *&gt;()(a.get(), b.get())</code>.</p>
 			<p><b>Throws:</b> nothing.</p>
-            <p><b>Notes:</b> Allows <code>intrusive_ptr</code> objects to be used as keys 
-                in associative containers.</p>
+			<P><B>Notes:</B> Allows <STRONG>intrusive_ptr</STRONG> objects to be used as keys 
+				in associative containers.</P>
 		</blockquote>
 		<h3><a name="free-swap">swap</a></h3>
 		<pre>template&lt;class T&gt;
   void swap(intrusive_ptr&lt;T&gt; &amp; a, intrusive_ptr&lt;T&gt; &amp; b); // never throws</pre>
-        <blockquote>
-            <p><b>Effects:</b> Equivalent to <code>a.swap(b)</code>.</p>
-            <p><b>Throws:</b> nothing.</p>
-            <p><b>Notes:</b> Matches the interface of <code>std::swap</code>. Provided as an aid to 
-                generic programming.</p>
-        </blockquote>
+		<BLOCKQUOTE>
+			<P><B>Effects:</B> Equivalent to <code>a.swap(b)</code>.</P>
+			<P><B>Throws:</B> nothing.</P>
+			<P><B>Notes:</B> Matches the interface of <B>std::swap</B>. Provided as an aid to 
+				generic programming.</P>
+		</BLOCKQUOTE>
 		<h3><a name="get_pointer">get_pointer</a></h3>
 		<pre>template&lt;class T&gt;
   T * get_pointer(intrusive_ptr&lt;T&gt; const &amp; p); // never throws</pre>
-        <blockquote>
-            <p><b>Returns:</b> <code>p.get()</code>.</p>
-            <p><b>Throws:</b> nothing.</p>
-            <p><b>Notes:</b> Provided as an aid to generic programming. Used by <a href="../bind/mem_fn.html">
-                    mem_fn</a>.</p>
-        </blockquote>
+		<BLOCKQUOTE>
+			<P><B>Returns:</B> <code>p.get()</code>.</P>
+			<P><B>Throws:</B> nothing.</P>
+			<P><B>Notes:</B> Provided as an aid to generic programming. Used by <A href="../bind/mem_fn.html">
+					mem_fn</A>.</P>
+		</BLOCKQUOTE>
 		<h3><a name="static_pointer_cast">static_pointer_cast</a></h3>
 		<pre>template&lt;class T, class U&gt;
   intrusive_ptr&lt;T&gt; static_pointer_cast(intrusive_ptr&lt;U&gt; const &amp; r); // never throws</pre>
-        <blockquote>
-            <p><b>Returns:</b> <code>intrusive_ptr&lt;T&gt;(static_cast&lt;T*&gt;(r.get()))</code>.</p>
-            <p><b>Throws:</b> nothing.</p>
-        </blockquote>
+		<BLOCKQUOTE>
+			<P><B>Returns:</B> <code>intrusive_ptr&lt;T&gt;(static_cast&lt;T*&gt;(r.get()))</code>.</P>
+			<P><B>Throws:</B> nothing.</P>
+		</BLOCKQUOTE>
 		<h3><a name="const_pointer_cast">const_pointer_cast</a></h3>
 		<pre>template&lt;class T, class U&gt;
   intrusive_ptr&lt;T&gt; const_pointer_cast(intrusive_ptr&lt;U&gt; const &amp; r); // never throws</pre>
-        <blockquote>
-            <p><b>Returns:</b> <code>intrusive_ptr&lt;T&gt;(const_cast&lt;T*&gt;(r.get()))</code>.</p>
-            <p><b>Throws:</b> nothing.</p>
-        </blockquote>
+		<BLOCKQUOTE>
+			<P><B>Returns:</B> <code>intrusive_ptr&lt;T&gt;(const_cast&lt;T*&gt;(r.get()))</code>.</P>
+			<P><B>Throws:</B> nothing.</P>
+		</BLOCKQUOTE>
 		<h3><a name="dynamic_pointer_cast">dynamic_pointer_cast</a></h3>
 		<pre>template&lt;class T, class U&gt;
   intrusive_ptr&lt;T&gt; dynamic_pointer_cast(intrusive_ptr&lt;U&gt; const &amp; r);</pre>
-        <blockquote>
-            <p><b>Returns:</b> <code>intrusive_ptr&lt;T&gt;(dynamic_cast&lt;T*&gt;(r.get()))</code>.</p>
-            <p><b>Throws:</b> nothing.</p>
-        </blockquote>
+		<BLOCKQUOTE>
+			<P><B>Returns:</B> <code>intrusive_ptr&lt;T&gt;(dynamic_cast&lt;T*&gt;(r.get()))</code>.</P>
+			<P><B>Throws:</B> nothing.</P>
+		</BLOCKQUOTE>
 		<h3><a name="insertion-operator">operator&lt;&lt;</a></h3>
 		<pre>template&lt;class E, class T, class Y&gt;
     std::basic_ostream&lt;E, T&gt; &amp; operator&lt;&lt; (std::basic_ostream&lt;E, T&gt; &amp; os, intrusive_ptr&lt;Y&gt; const &amp; p);</pre>
-        <blockquote>
-            <p><b>Effects:</b> <code>os &lt;&lt; p.get();</code>.</p>
-            <p><b>Returns:</b> <code>os</code>.</p>
-        </blockquote>
+		<BLOCKQUOTE>
+			<p><STRONG>Effects:</STRONG> <code>os &lt;&lt; p.get();</code>.</p>
+			<P><B>Returns:</B> <code>os</code>.</P>
+		</BLOCKQUOTE>
 		<hr>
-        <p>$Date$</p>
 		<p>
-            <small>Copyright &copy; 2003-2005, 2013 Peter Dimov. Distributed under the Boost Software License, Version 
-            1.0. See accompanying file <a href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or 
-            copy at <a href="http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</a>.</small></p>
+			$Date$</p>
+		<p>
+			<small>Copyright <20> 2003-2005 Peter Dimov. Distributed under the Boost Software License, Version 
+				1.0. See accompanying file <A href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</A> or 
+				copy at <A href="http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</A>.</small></p>
 	</body>
 </html>

intrusive_ref_counter.html

@@ -1,94 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-<html>
-    <head>
-        <title>intrusive_ref_counter</title>
-        <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
-    </head>
-    <body text="#000000" bgcolor="#ffffff" link="#0000ff" vlink="#0000ff">
-        <h1><img height="86" alt="boost.png (6897 bytes)" src="../../boost.png" 
-            width="277" align="middle" border="0">basic_intrusive_ref_counter class template</h1>
-        <p>
-            <A href="#Introduction">Introduction</A><br>
-            <A href="#Synopsis">Synopsis</A><br>
-            <A href="#Members">Members</A><br>
-        </p>
-        <h2><a name="Introduction">Introduction</a></h2>
-        <p>The <STRONG>intrusive_ref_counter</STRONG> class template implements a reference counter for a derived
-            user's class that is intended to be used with <STRONG><a href="intrusive_ptr.html">intrusive_ptr</a></STRONG>.
-            The base class has associated <STRONG>intrusive_ptr_add_ref</STRONG> and <STRONG>intrusive_ptr_release</STRONG> functions
-            which modify the reference counter as needed and destroy the user's object when the counter drops to zero.</p>
-        <p>The class template is parameterized on <STRONG>DerivedT</STRONG> and <STRONG>CounterPolicyT</STRONG> parameters.
-            The first parameter is the user's class that derives from <STRONG>intrusive_ref_counter</STRONG>. This type
-            is needed in order to destroy the object correctly when there are no references to it left.</p>
-        <p>The second parameter is a policy that defines the nature of the reference counter.
-            Boost.SmartPtr provides two such policies: <STRONG>thread_unsafe_counter</STRONG> and <STRONG>thread_safe_counter</STRONG>. The former
-            instructs the <STRONG>intrusive_ref_counter</STRONG> base class to use a counter only suitable for a single-threaded use.
-            Pointers to a single object that uses this kind of reference counter must not be used in different threads. The latter policy
-            makes the reference counter thread-safe, unless the target platform doesn't support threading. Since in modern systems support for
-            threading is common, the default counter policy is <STRONG>thread_safe_counter</STRONG>.</p>
-        <h2><a name="Synopsis">Synopsis</a></h2>
-        <pre>namespace boost {
-
-  struct thread_unsafe_counter;
-  struct thread_safe_counter;
-
-  template&lt;class DerivedT, class CounterPolicyT = thread_safe_counter&gt;
-  class intrusive_ref_counter
-  {
-  public:
-      <A href="#constructors" >intrusive_ref_counter</A>() = noexcept;
-      <A href="#constructors" >intrusive_ref_counter</A>(intrusive_ref_counter const &amp; r) = noexcept;
-
-      intrusive_ref_counter &amp; <A href="#assignment" >operator=</A>(intrusive_ref_counter const &amp; r) noexcept;
-
-      unsigned int <a href="#use_count" >use_count</a>() const noexcept;
-
-  protected:
-      <A href="#destructor" >~intrusive_ref_counter</A>() = default;
-  };
-
-}</pre>
-        <h2><a name="Members">Members</a></h2>
-        <h3><a name="constructors">constructors</a></h3>
-        <pre>intrusive_ref_counter();</pre>
-        <blockquote>
-            <p><b>Postconditions:</b> <code>use_count() == 0</code>.</p>
-            <p><b>Throws:</b> nothing.</p>
-            <P><B>Notes:</B> The pointer to the constructed object is expected to be passed to <STRONG>intrusive_ptr</STRONG>
-            constructor, assignment operator or <STRONG>reset()</STRONG> method, which would increment the reference counter.</P>
-        </blockquote>
-        <pre>intrusive_ref_counter(intrusive_ref_counter const &amp;);</pre>
-        <blockquote>
-            <p><b>Postconditions:</b> <code>use_count() == 0</code>.</p>
-            <p><b>Throws:</b> nothing.</p>
-            <P><B>Notes:</B> The pointer to the constructed object is expected to be passed to <STRONG>intrusive_ptr</STRONG>
-            constructor, assignment operator or <STRONG>reset()</STRONG> method, which would increment the reference counter.</P>
-        </blockquote>
-        <h3><a name="destructor">destructor</a></h3>
-        <pre>~intrusive_ref_counter();</pre>
-        <BLOCKQUOTE>
-            <p><b>Throws:</b> nothing.</p>
-            <P><B>Effects:</B> Destroys the counter object.</P>
-            <P><B>Notes:</B> The destructor is protected so that the object can only be destroyed through the <STRONG>DerivedT</STRONG> class.</P>
-        </BLOCKQUOTE>
-        <H3><a name="assignment">assignment</a></H3>
-        <pre>intrusive_ref_counter &amp; operator=(intrusive_ref_counter const &amp; r) noexcept;</pre>
-        <BLOCKQUOTE>
-            <P><B>Effects:</B> Does nothing, reference counter is not modified.</P>
-            <P><B>Returns:</B> <code>*this</code>.</P>
-        </BLOCKQUOTE>
-        <H3><a name="use_count">use_count</a></H3>
-        <pre>unsigned int use_count() const noexcept;</pre>
-        <BLOCKQUOTE>
-            <p><b>Returns:</b> The current value of the reference counter.</p>
-            <p><b>Throws:</b> nothing.</p>
-            <P><B>Notes:</B> The returned value may not be actual in multi-threaded applications.</P>
-        </BLOCKQUOTE>
-        <hr>
-        <p>$Date$</p>
-        <p>
-            <small>Copyright &copy; 2013 Andrey Semashev. Distributed under the Boost Software License, Version 
-            1.0. See accompanying file <A href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</A> or 
-            copy at <A href="http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</A>.</small></p>
-    </body>
-</html>

make_shared.html

@@ -1,13 +1,12 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 <html>
 	<head>
 		<title>make_shared and allocate_shared</title>
 		<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
 	</head>
-    <body text="#000000" bgcolor="#ffffff" link="#0000ff" vlink="#0000ff">
-        <h1><img height="86" alt="boost.png (6897 bytes)" src="../../boost.png" 
-            width="277" align="middle" border="0">make_shared and allocate_shared 
-            function templates</h1>
+	<body text="#000000" bgColor="#ffffff">
+		<h1><A href="../../index.htm"><IMG height="86" alt="boost.png (6897 bytes)" src="../../boost.png" width="277" align="middle"
+					border="0"></A>make_shared and allocate_shared function templates</h1>
 		<p><A href="#Introduction">Introduction</A><br>
 			<A href="#Synopsis">Synopsis</A><br>
 			<A href="#functions">Free Functions</A><br>
@@ -42,7 +41,7 @@
   template&lt;typename T, typename A&gt;
     shared_ptr&lt;T&gt; <a href="#functions">allocate_shared</a>( A const &amp; );
 
-#if !defined( BOOST_NO_CXX11_VARIADIC_TEMPLATES ) && !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )    // C++0x prototypes
+#if defined( BOOST_HAS_VARIADIC_TMPL ) && defined( BOOST_HAS_RVALUE_REFS )	// C++0x prototypes
 
   template&lt;typename T, typename... Args&gt;
     shared_ptr&lt;T&gt; <a href="#functions">make_shared</a>( Args &amp;&amp; ... args );
@@ -80,7 +79,7 @@ template&lt;class T, class A, class... Args&gt;
 				where <code>pv</code> is a <code>void*</code> pointing to storage suitable
 				to hold an object of type <code>T</code>,
 				shall be well-formed.  <code>A</code> shall be an <em>Allocator</em>,
-                as described in section 20.1.5 (<strong>Allocator requirements</strong>) of the C++ Standard.
+				as described in section 20.1.5 (<stong>Allocator requirements</strong>) of the C++ Standard.
 				The copy constructor and destructor of <code>A</code> shall not throw.</p>
 			<p><b>Effects:</b> Allocates memory suitable for an object of type <code>T</code>
 				and constructs an object in it via the placement new expression <code>new( pv ) T()</code>
@@ -110,7 +109,8 @@ template&lt;class T, class A, class... Args&gt;
 		<pre>boost::shared_ptr&lt;std::string&gt; x = boost::make_shared&lt;std::string&gt;("hello, world!");
 std::cout << *x;</pre>
 		<hr>
-        <p>$Date$</p>
+		<p>
+			$Date: 2008-05-19 15:42:39 -0400 (Mon, 19 May 2008) $</p>
 		<p><small>Copyright 2008 Peter Dimov. Copyright 2008 Frank Mori Hess.
 				Distributed under the Boost Software License,
 				Version 1.0. See accompanying file <A href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</A>

make_shared_array.html

@@ -1,393 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-<head>
-<meta charset="utf-8">
-<title>allocate_shared and make_shared for arrays</title>
-</head>
-<body>
-<h1>allocate_shared and make_shared for arrays</h1>
-<div id="navigation">
-<ul>
-<li><a href="#introduction">Introduction</a></li>
-<li><a href="#synopsis">Synopsis</a></li>
-<li><a href="#requirements">Common Requirements</a></li>
-<li><a href="#functions">Free Functions</a></li>
-<li><a href="#history">History</a></li>
-<li><a href="#references">References</a></li>
-</ul>
-</div>
-<div id="introduction">
-<h2>Introduction</h2>
-<p>
-Originally the Boost function templates <code>allocate_shared</code> and
-<code>make_shared</code> were for efficient allocation of shared scalar
-objects only. There was a need to have efficient allocation of shared
-arrays. One criticism of class template <code>shared_array</code>
-was always the lack of a utility like <code>make_shared</code> that
-uses only a single allocation.
-</p>
-<p>
-The header files &lt;boost/smart_ptr/allocate_shared_array.hpp&gt; and
-&lt;boost/smart_ptr/make_shared_array.hpp&gt; provide function
-templates, overloads of <code>allocate_shared</code> and
-<code>make_shared</code> for array types, to address this need.
-<code>allocate_shared</code> uses a user-supplied allocator for
-allocation, while <code>make_shared</code> uses
- <code>allocate_shared</code> with the Default Allocator.
-</p>
-</div>
-<div id="synopsis">
-<h2>Synopsis</h2>
-<div>
-<h3>Header &lt;boost/smart_ptr/allocate_shared_array.hpp&gt;</h3>
-<code>namespace boost {</code>
-<blockquote>
-<code>template&lt;class T, class A&gt;<br>shared_ptr&lt;T&gt;
-<a href="#functions">allocate_shared</a>(const A&amp; a,
-std::size_t n);</code>
-</blockquote>
-<blockquote>
-<code>template&lt;class T, class A&gt;<br>shared_ptr&lt;T&gt;
-<a href="#functions">allocate_shared</a>(const A&amp; a);</code>
-</blockquote>
-<blockquote>
-<code>template&lt;class T, class A&gt;<br>shared_ptr&lt;T&gt;
-<a href="#functions">allocate_shared</a>(const A&amp; a, std::size_t n,
-const <em>E</em>&amp; v);</code>
-</blockquote>
-<blockquote>
-<code>template&lt;class T, class A&gt;<br>shared_ptr&lt;T&gt;
-<a href="#functions">allocate_shared</a>(const A&amp; a,
-const <em>E</em>&amp; v);</code>
-</blockquote>
-<blockquote>
-<code>template&lt;class T, class A&gt;<br>shared_ptr&lt;T&gt;
-<a href="#functions">allocate_shared_noinit</a>(const A&amp; a,
-std::size_t n);</code>
-</blockquote>
-<blockquote>
-<code>template&lt;class T, class A&gt;<br>shared_ptr&lt;T&gt;
-<a href="#functions">allocate_shared_noinit</a>(const A&amp; a);</code>
-</blockquote>
-<code>}</code>
-</div>
-<div>
-<h3>Header &lt;boost/smart_ptr/make_shared_array.hpp&gt;</h3>
-<code>namespace boost {</code>
-<blockquote>
-<code>template&lt;class T, class A&gt;<br>shared_ptr&lt;T&gt;
-<a href="#functions">make_shared</a>(std::size_t n);</code>
-</blockquote>
-<blockquote>
-<code>template&lt;class T, class A&gt;<br>shared_ptr&lt;T&gt;
-<a href="#functions">make_shared</a>();</code>
-</blockquote>
-<blockquote>
-<code>template&lt;class T, class A&gt;<br>shared_ptr&lt;T&gt;
-<a href="#functions">make_shared</a>(std::size_t n,
-const <em>E</em>&amp; v);</code>
-</blockquote>
-<blockquote>
-<code>template&lt;class T, class A&gt;<br>shared_ptr&lt;T&gt;
-<a href="#functions">make_shared</a>(const <em>E</em>&amp; v);</code>
-</blockquote>
-<blockquote>
-<code>template&lt;class T, class A&gt;<br>shared_ptr&lt;T&gt;
-<a href="#functions">make_shared_noinit</a>(std::size_t n);</code>
-</blockquote>
-<blockquote>
-<code>template&lt;class T, class A&gt;<br>shared_ptr&lt;T&gt;
-<a href="#functions">make_shared_noinit</a>();</code>
-</blockquote>
-<code>}</code>
-</div>
-</div>
-<div id="requirements">
-<h2>Common Requirements</h2>
-<h3><code>template&lt;class T, class A&gt;<br>shared_ptr&lt;T&gt;
-allocate_shared(const A&amp; a, <em>args</em>);</code></h3>
-<dl>
-<dt><strong>Requires:</strong></dt>
-<dd><code>T</code> is of the form <code>E[N]</code> or
-<code>E[]</code>. <code>A</code> shall be an <em>Allocator</em>, as
-described in section 17.6.3.5 [Allocator requirements] of the C++
-Standard. The copy constructor and destructor of <code>A</code> shall
-not throw exceptions.</dd>
-<dt><strong>Effects:</strong></dt>
-<dd>Allocates storage for an object of type <code>E</code> (or
-<code>E[size]</code> when <code>T</code> is <code>E[]</code>, where
-<code>size</code> is determined from <code>args</code> as specified by
-the concrete overload). A copy of the allocator is used to allocate
-storage. The storage is initialized as specified by the concrete
-overload. If an exception is thrown, the functions have no effect.</dd>
-<dt><strong>Returns:</strong></dt>
-<dd>A <code>shared_ptr</code> instance that stores and owns the address
-of the newly allocated and constructed object.</dd>
-<dt><strong>Postconditions:</strong></dt>
-<dd><code>r.get() != 0</code> and <code>r.use_count() == 1</code>,
-where <code>r</code> is the return value.</dd>
-<dt><strong>Throws:</strong></dt>
-<dd>An exception thrown from <code>A::allocate()</code>, or from the
-initialization of the object.</dd>
-<dt><strong>Remarks:</strong></dt>
-<dd>
-<ul>
-<li>This implementation performs no more than one memory allocation.
-This provides efficiency to equivalent to an intrusive smart
-pointer.</li>
-<li>When an object of an array type <code>T</code> is specified to be
-initialized to a value of the same type <code>v</code>, this shall be
-interpreted to mean that each array element of the object is initialized
-to the corresponding element from <code>v</code>.</li>
-<li>When an object of an array type <code>T</code> is specified to be
-value-initialized, this shall be interpreted to mean that each array
-element of the object is value-initialized.</li>
-<li>Array elements are initialized in ascending order of their
-addresses.</li>
-<li>When a subobject of a scalar type <code>S</code> is specified to
-be initialized to a value <code>v</code>, <code>allocate_shared</code>
-shall perform this initialization via the expression
-<code>std::allocator_traits&lt;A&gt;::construct(b, p, v)</code>, where
-<code>p</code> points to storage suitable to hold an object of type
-<code>S</code> and <code>b</code> of is a copy of the allocator
-<code>a</code> passed to <code>allocate_shared</code> such that its
-<code>value_type</code> is <code>S</code>.</li>
-<li>When a subobject of scalar type <code>S</code> is specified to be
-value-initialized, <code>allocate_shared</code> shall perform this
-initialization via the expression
-<code>std::allocator_traits&lt;A&gt;::construct(b, p)</code>, where
-<code>p</code> points to storage suitable to hold an object
-of type <code>S</code> and <code>b</code> is a copy of the allocator
-<code>a</code> passed to <code>allocate_shared</code> such that its
-<code>value_type</code> is <code>S</code>.</li>
-<li>When a subobject of scalar type <code>S</code> is specified to be
-default-initialized, <code>allocate_shared_noinit</code> shall perform
-this initialization via the expression <code>::new(p) S</code>, where
-<code>p</code> has type <code>void*</code> and points to storage
-suitable to hold an object of type <code>S</code>.</li>
-<li>When the lifetime of the object managed by the return value ends,
-or when the initialization of an array element throws an exception,
-the initialized elements should be destroyed in the reverse order
-of their construction.</li>
-</ul>
-</dd>
-<dt><strong>Notes:</strong></dt>
-<dd>These functions will typically allocate more memory than the size of
-<code>sizeof(E)</code> to allow for internal bookkeeping structures such
-as the reference counts.</dd>
-</dl>
-</div>
-<div id="functions">
-<h2>Free Functions</h2>
-<div>
-<h3><code>template&lt;class T, class A&gt;<br>shared_ptr&lt;T&gt;
-allocate_shared(const A&amp; a, std::size_t n);</code></h3>
-<dl>
-<dt><strong>Returns:</strong></dt>
-<dd>A <code>shared_ptr</code> to a value-initialized object of type
-<code>E[size]</code>.</dd>
-<dt><strong>Remarks:</strong></dt>
-<dd>This overload shall only participate in overload resolution when
-<code>T</code> is of the form <code>E[]</code>.</dd>
-<dt><strong>Example:</strong></dt>
-<dd><code>boost::allocate_shared&lt;int[]<!--
--->&gt;(std::allocator&lt;int&gt;(), 8);</code></dd>
-</dl>
-</div>
-<div>
-<h3><code>template&lt;class T, class A&gt;<br>shared_ptr&lt;T&gt;
-allocate_shared(const A&amp; a);</code></h3>
-<dl>
-<dt><strong>Returns:</strong></dt>
-<dd>A <code>shared_ptr</code> to a value-initialized object of type
-<code>E[N]</code>.</dd>
-<dt><strong>Remarks:</strong></dt>
-<dd>This overload shall only participate in overload resolution when
-<code>T</code> is of the form <code>E[N]</code>.</dd>
-<dt><strong>Example:</strong></dt>
-<dd><code>boost::allocate_shared&lt;int[8]<!--
--->&gt;(std::allocator&lt;int&gt;());</code></dd>
-</dl>
-</div>
-<div>
-<h3><code>template&lt;class T, class A&gt;<br>shared_ptr&lt;T&gt;
-allocate_shared(const A&amp; a, std::size_t n,
-const <em>E</em>&amp; v);</code></h3>
-<dl>
-<dt><strong>Returns:</strong></dt>
-<dd>A <code>shared_ptr</code> to an object of type
-<code>E[size]</code>, where each array element of type <code>E</code> is
-initialized to <code>v</code>.</dd>
-<dt><strong>Remarks:</strong></dt>
-<dd>This overload shall only participate in overload resolution when
-<code>T</code> is of the form <code>E[]</code>.</dd>
-<dt><strong>Example:</strong></dt>
-<dd><code>boost::allocate_shared&lt;double[]<!--
--->&gt;(std::allocator&lt;double&gt;(), 8, 1.0);</code></dd>
-</dl>
-</div>
-<div>
-<h3><code>template&lt;class T, class A&gt;<br>shared_ptr&lt;T&gt;
-allocate_shared(const A&amp; a, const <em>E</em>&amp; v);</code></h3>
-<dl>
-<dt><strong>Returns:</strong></dt>
-<dd>A <code>shared_ptr</code> to an object of type <code>E[N]</code>,
-where each array element of type <code>E</code> is initialized to
-<code>v</code>.</dd>
-<dt><strong>Remarks:</strong></dt>
-<dd>This overload shall only participate in overload resolution when
-<code>T</code> is of the form <code>E[N]</code>.</dd>
-<dt><strong>Example:</strong></dt>
-<dd><code>boost::allocate_shared&lt;double[8]<!--
--->&gt;(std::allocator&lt;double&gt;(), 1.0);</code></dd>
-</dl>
-</div>
-<div>
-<h3><code>template&lt;class T, class A&gt;<br>shared_ptr&lt;T&gt;
-allocate_shared_noinit(const A&amp; a, std::size_t n);</code></h3>
-<dl>
-<dt><strong>Returns:</strong></dt>
-<dd>A <code>shared_ptr</code> to a default-initialized object of type
-<code>E[size]</code>.</dd>
-<dt><strong>Remarks:</strong></dt>
-<dd>This overload shall only participate in overload resolution when
-<code>T</code> is of the form <code>E[]</code>.</dd>
-<dt><strong>Example:</strong></dt>
-<dd><code>boost::allocate_shared_noinit&lt;int[]<!--
--->&gt;(std::allocator&lt;int&gt;(), 8);</code></dd>
-</dl>
-</div>
-<div>
-<h3><code>template&lt;class T, class A&gt;<br>shared_ptr&lt;T&gt;
-allocate_shared_noinit(const A&amp; a);</code></h3>
-<dl>
-<dt><strong>Returns:</strong></dt>
-<dd>A <code>shared_ptr</code> to a default-initialized object of type
-<code>E[N]</code>.</dd>
-<dt><strong>Remarks:</strong></dt>
-<dd>This overload shall only participate in overload resolution when
-<code>T</code> is of the form <code>E[N]</code>.</dd>
-<dt><strong>Example:</strong></dt>
-<dd><code>boost::allocate_shared_noinit&lt;int[8]<!--
--->&gt;(std::allocator&lt;int&gt;());</code></dd>
-</dl>
-</div>
-<div>
-<h3><code>template&lt;class T&gt;<br>shared_ptr&lt;T&gt;
-make_shared(std::size_t n);</code></h3>
-<dl>
-<dt><strong>Returns:</strong></dt>
-<dd><code>allocate_shared&lt;T&gt;(std::allocator&lt;<em>S<!--
---></em>&gt;(), n);</code></dd>
-<dt><strong>Remarks:</strong></dt>
-<dd>This overload shall only participate in overload resolution when
-<code>T</code> is of the form <code>E[]</code>.</dd>
-<dt><strong>Example:</strong></dt>
-<dd><code>boost::make_shared&lt;int[]&gt;(8);</code></dd>
-</dl>
-</div>
-<div>
-<h3><code>template&lt;class T&gt;<br>shared_ptr&lt;T&gt;
-make_shared();</code></h3>
-<dl>
-<dt><strong>Returns:</strong></dt>
-<dd><code>allocate_shared&lt;T&gt;(std::allocator&lt;<em>S<!--
---></em>&gt;());</code></dd>
-<dt><strong>Remarks:</strong></dt>
-<dd>This overload shall only participate in overload resolution when
-<code>T</code> is of the form <code>E[N]</code>.</dd>
-<dt><strong>Example:</strong></dt>
-<dd><code>boost::make_shared&lt;int[8]&gt;();</code></dd>
-</dl>
-</div>
-<div>
-<h3><code>template&lt;class T&gt;<br>shared_ptr&lt;T&gt;
-make_shared(std::size_t n, const <em>E</em>&amp; v);</code></h3>
-<dl>
-<dt><strong>Returns:</strong></dt>
-<dd><code>allocate_shared&lt;T&gt;(std::allocator&lt;<em>S<!--
---></em>&gt;(), n, v);</code></dd>
-<dt><strong>Remarks:</strong></dt>
-<dd>This overload shall only participate in overload resolution when
-<code>T</code> is of the form <code>E[]</code>.</dd>
-<dt><strong>Example:</strong></dt>
-<dd><code>boost::make_shared&lt;double[]&gt;(8, 1.0);</code></dd>
-</dl>
-</div>
-<div>
-<h3><code>template&lt;class T&gt;<br>shared_ptr&lt;T&gt;
-make_shared(const <em>E</em>&amp; v);</code></h3>
-<dl>
-<dt><strong>Returns:</strong></dt>
-<dd><code>allocate_shared&lt;T&gt;(std::allocator&lt;<em>S<!--
---></em>&gt;(), v);</code></dd>
-<dt><strong>Remarks:</strong></dt>
-<dd>This overload shall only participate in overload resolution when
-<code>T</code> is of the form <code>E[N].</code></dd>
-<dt><strong>Example:</strong></dt>
-<dd><code>boost::make_shared&lt;double[8]&gt;(1.0);</code></dd></dl>
-</div>
-<div>
-<h3><code>template&lt;class T&gt;<br>shared_ptr&lt;T&gt;
-make_shared_noinit(std::size_t n);</code></h3>
-<dl>
-<dt><strong>Returns:</strong></dt>
-<dd><code>allocate_shared_noinit&lt;T&gt;(std::allocator&lt;<em>S<!--
---></em>&gt;(), n);</code></dd>
-<dt><strong>Remarks:</strong></dt>
-<dd>This overload shall only participate in overload resolution when
-<code>T</code> is of the form <code>E[]</code>.</dd>
-<dt><strong>Example:</strong></dt>
-<dd><code>boost::make_shared_noinit&lt;int[]&gt;(8);</code></dd>
-</dl>
-</div>
-<div>
-<h3><code>template&lt;class T&gt;<br>shared_ptr&lt;T&gt;
-make_shared_noinit();</code></h3>
-<dl>
-<dt><strong>Returns:</strong></dt>
-<dd><code>allocate_shared_noinit&lt;T&gt;(std::allocator&lt;<em>S<!--
---></em>&gt;());</code></dd>
-<dt><strong>Remarks:</strong></dt>
-<dd>This overload shall only participate in overload resolution when
-<code>T</code> is of the form <code>E[N]</code>.</dd>
-<dt><strong>Example:</strong></dt>
-<dd><code>boost::make_shared_noinit&lt;int[8]&gt;();</code></dd>
-</dl>
-</div>
-</div>
-<div id="history">
-<h2>History</h2>
-<dl>
-<dt><strong>Boost 1.64</strong></dt>
-<dd>Glen Fernandes rewrote allocate_shared and make_shared for a more
-optimal and more maintainable implementation.</dd>
-<dt><strong>Boost 1.56</strong></dt>
-<dd>Glen Fernandes updated overloads of make_shared and allocate_shared
-to conform to the specification in C++ standard paper
-<a href="#N3870">N3870</a>, including resolving C++ standard library
-defect report <a href="#dr2070">DR 2070</a>.</dd>
-<dt><strong>Boost 1.53</strong></dt>
-<dd>Glen Fernandes contributed implementations of make_shared and
-allocate_shared for arrays.</dd>
-</dl>
-</div>
-<div id="references">
-<h2>References</h2>
-<ol>
-<li id="N3870"><strong>N3870</strong>, <a href=
-"http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n3870.html">
-Extending make_shared to Support Arrays, Revision 1</a>, Peter Dimov
-&amp; Glen Fernandes, January, 2014.</li>
-<li id="dr2070"><strong>DR 2070</strong>,
-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html">
-allocate_shared should use allocator_traits&lt;A&gt;::construct</a>,
-Jonathan Wakely, July, 2011.</li>
-</ol>
-</div>
-<hr>
-Copyright 2012-2017 Glen Fernandes. Distributed under the
-<a href="http://www.boost.org/LICENSE_1_0.txt">Boost Software License,
-Version 1.0</a>.
-</body>
-</html>

make_unique.html

@@ -1,184 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-<head>
-<meta charset="utf-8">
-<title>make_unique</title>
-</head>
-<body>
-<h1>make_unique</h1>
-<div id="navigation">
-<ul>
-<li><a href="#introduction">Introduction</a></li>
-<li><a href="#synopsis">Synopsis</a></li>
-<li><a href="#requirements">Common Requirements</a></li>
-<li><a href="#functions">Free Functions</a></li>
-<li><a href="#history">History</a></li>
-</ul>
-</div>
-<div id="introduction">
-<h2>Introduction</h2>
-<p>
-The header file &lt;boost/make_unique.hpp&gt; provides overloads of
-function template <code>make_unique</code> for convenient creation of
-<code>std::unique_ptr</code> objects.
-</p>
-</div>
-<div id="synopsis">
-<h2>Synopsis</h2>
-<div>
-<h3>Header &lt;boost/smart_ptr/make_unique.hpp&gt;</h3>
-<code>namespace boost {</code>
-<blockquote>
-<code>template&lt;class T&gt;<br>std::unique_ptr&lt;T&gt;
-<a href="#functions">make_unique</a>();</code>
-</blockquote>
-<blockquote>
-<code>template&lt;class T, class... Args&gt;<br>std::unique_ptr&lt;T&gt;
-<a href="#functions">make_unique</a>(Args&amp;&amp;... args);</code>
-</blockquote>
-<blockquote>
-<code>template&lt;class T&gt;<br>std::unique_ptr&lt;T&gt;
-<a href="#functions">make_unique</a>(<em>T</em>&amp;&amp; value);</code>
-</blockquote>
-<blockquote>
-<code>template&lt;class T&gt;<br>std::unique_ptr&lt;T&gt;
-<a href="#functions">make_unique</a>(std::size_t size);</code>
-</blockquote>
-<blockquote>
-<code>template&lt;class T&gt;<br>std::unique_ptr&lt;T&gt;
-<a href="#functions">make_unique_noinit</a>();</code>
-</blockquote>
-<blockquote>
-<code>template&lt;class T&gt;<br>std::unique_ptr&lt;T&gt;
-<a href="#functions">make_unique_noinit</a>(std::size_t size);</code>
-</blockquote>
-<code>}</code>
-</div>
-</div>
-<div id="requirements">
-<h2>Common Requirements</h2>
-<h3><code>template&lt;class T, <em>Args</em>&gt;<br>
-std::unique_ptr&lt;T&gt; make_unique(<em>args</em>);</code></h3>
-<dl>
-<dt><strong>Effects:</strong></dt>
-<dd>Allocates storage for an object of type <code>T</code> (or
-<code>E[size]</code> when <code>T</code> is <code>E[]</code>, where
-<code>size</code> is determined from <code>args</code> as specified by
-the concrete overload). The storage is initialized from
-<code>args</code> as specified by the concrete overload. If an exception
-is thrown, the functions have no effect.</dd>
-<dt><strong>Returns:</strong></dt>
-<dd>A <code>std::unique_ptr</code> instance that stores and owns the
-address of the newly allocated and constructed object.</dd>
-<dt><strong>Postconditions:</strong></dt>
-<dd><code>r.get() != 0</code>, where <code>r</code> is the return
-value.</dd>
-<dt><strong>Throws:</strong></dt>
-<dd><code>std::bad_alloc</code>, or an exception thrown from the
-initialization of the object.</dd>
-<dt><strong>Remarks:</strong></dt>
-<dd>
-<ul>
-<li>When an object of a scalar type T is specified to be initialized to
-a value <code>value</code>, or to <code>T(args...)</code>, where
-<code>args...</code> is a list of constructor arguments,
-<code>make_unique</code> shall perform this initialization via the
-expression <code>new T(value)</code> or <code>new T(args...)</code>
-respectively.</li>
-<li>When an object of type <code>T</code> is specified to be
-value-initialized, <code>make_unique</code> shall perform this
-initialization via the expression <code>new T()</code>.</li>
-<li>When an object of type <code>T</code> is specified to be
-default-initialized, <code>make_unique_noinit</code> shall perform this
-initialization via the expression <code>new T</code>.</li>
-</ul>
-</dd>
-</dl>
-</div>
-<div id="functions">
-<h2>Free functions</h2>
-<div>
-<h3><code>template&lt;class T, class... Args&gt;<br>
-std::unique_ptr&lt;T&gt;
-make_unique(Args&amp;&amp;... args);</code></h3>
-<dl>
-<dt><strong>Returns:</strong></dt>
-<dd>A <code>std::unique_ptr</code> to an object of type <code>T</code>,
-initialized to <code>std::forward&lt;Args&gt;(args)...</code>.</dd>
-<dt><strong>Remarks:</strong></dt>
-<dd>This overload shall only participate in overload resolution when
-<code>T</code> is not an array type.</dd>
-<dt><strong>Example:</strong></dt>
-<dd><code>boost::make_unique&lt;double&gt;(1.0);</code></dd>
-</dl>
-</div>
-<div>
-<h3><code>template&lt;class T&gt;<br>std::unique_ptr&lt;T&gt;
-make_unique(<em>T</em>&amp;&amp; value);</code></h3>
-<dl>
-<dt><strong>Returns:</strong></dt>
-<dd>A <code>std::unique_ptr</code> to an object of type <code>T</code>,
-initialized to <code>std::move(value)</code>.</dd>
-<dt><strong>Remarks:</strong></dt>
-<dd>This overload shall only participate in overload resolution when
-<code>T</code> is not an array type.</dd>
-<dt><strong>Example:</strong></dt>
-<dd><code>boost::make_unique&lt;point&gt;({1.0, -1.0});</code></dd></dl>
-</div>
-<div>
-<h3><code>template&lt;class T&gt;<br>std::unique_ptr&lt;T&gt;
-make_unique(std::size_t size);</code></h3>
-<dl>
-<dt><strong>Returns:</strong></dt>
-<dd>A <code>std::unique_ptr</code> to a value-initialized object of type
-<code>E[size]</code>.</dd>
-<dt><strong>Remarks:</strong></dt>
-<dd>This overload shall only participate in overload resolution when
-<code>T</code> is of the form <code>E[]</code>.</dd>
-<dt><strong>Example:</strong></dt>
-<dd><code>boost::make_unique&lt;int[]&gt;(8);</code></dd>
-</dl>
-</div>
-<div>
-<h3><code>template&lt;class T&gt;<br>std::unique_ptr&lt;T&gt;
-make_unique_noinit();</code></h3>
-<dl>
-<dt><strong>Returns:</strong></dt>
-<dd>A <code>std::unique_ptr</code> to a default-initialized object of
-type <code>T</code>.</dd>
-<dt><strong>Remarks:</strong></dt>
-<dd>This overload shall only participate in overload resolution when
-<code>T</code> is not an array type.</dd>
-<dt><strong>Example:</strong></dt>
-<dd><code>boost::make_unique_noinit&lt;std::tm&gt;();</code></dd>
-</dl>
-</div>
-<div>
-<h3><code>template&lt;class T&gt;<br>std::unique_ptr&lt;T&gt;
-make_unique_noinit(std::size_t size);</code></h3>
-<dl>
-<dt><strong>Returns:</strong></dt>
-<dd>A <code>std::unique_ptr</code> to a default-initialized object of
-type <code>E[size]</code>.</dd>
-<dt><strong>Remarks:</strong></dt>
-<dd>This overload shall only participate in overload resolution when
-<code>T</code> is of the form <code>E[]</code>.</dd>
-<dt><strong>Example:</strong></dt>
-<dd><code>boost::make_unique_noinit&lt;char[]&gt;(64);</code></dd>
-</dl>
-</div>
-</div>
-<div id="history">
-<h2>History</h2>
-<dl>
-<dt><strong>Boost 1.56</strong></dt>
-<dd>Glen Fernandes contributed implementations of make_unique for
-scalars and arrays</dd>
-</dl>
-</div>
-<hr>
-Copyright 2012-2014 Glen Fernandes. Distributed under the
-<a href="http://www.boost.org/LICENSE_1_0.txt">Boost Software License,
-Version 1.0</a>.
-</body>
-</html>

meta/libraries.json

@@ -1,22 +0,0 @@
-{
-    "key": "smart_ptr",
-    "name": "Smart Ptr",
-    "authors": [
-        "Greg Colvin",
-        "Beman Dawes",
-        "Peter Dimov",
-        "Darin Adler",
-        "Glen Fernandes"
-    ],
-    "description": "Smart pointer class templates.",
-    "documentation": "smart_ptr.htm",
-    "std": [
-        "tr1"
-    ],
-    "category": [
-        "Memory"
-    ],
-    "maintainers": [
-        "Peter Dimov <pdimov -at- pdimov.com>"
-    ]
-}

pointer_cast.html

@@ -1,17 +1,16 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2//EN">
 <html>
 	<head>
-        <title>pointer_cast</title>
-        <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
+		<title>pointer_cast.hpp</title>
 	</head>
-    <body text="#000000" bgcolor="#ffffff" link="#0000ff" vlink="#0000ff">
-        <h1><img height="86" alt="boost.png (6897 bytes)" src="../../boost.png" 
-            width="277" align="middle" border="0" />pointer_cast</h1>
+	<body>
+		<h1><IMG height="86" alt="C++ Boost" src="../../boost.png" width="277" align="middle" border="0">Pointer 
+			cast functions</h1>
 		<p>The pointer cast functions (<code>boost::static_pointer_cast</code> <code>boost::dynamic_pointer_cast</code>
 			<code>boost::reinterpret_pointer_cast</code> <code>boost::const_pointer_cast</code>) 
-            provide a way to write generic pointer castings for raw pointers, <code>std::shared_ptr</code> and <code>std::unique_ptr</code>. The functions 
-            are defined in <cite><a href="../../boost/pointer_cast.hpp">boost/pointer_cast.hpp</a>.</cite></p>
-        <p>There is test/example code in <cite><a href="test/pointer_cast_test.cpp">pointer_cast_test.cpp</a></cite>.</p>
+			provide a way to write generic pointer castings for raw pointers. The functions 
+			are defined in <CITE><A href="../../boost/pointer_cast.hpp">boost/pointer_cast.hpp</A>.</CITE></p>
+		<P>There is test/example code in <CITE><A href="test/pointer_cast_test.cpp">pointer_cast_test.cpp</A></CITE>.</p>
 			<h2><a name="rationale">Rationale</a></h2>
 		<P>Boost smart pointers usually overload those functions to provide a mechanism to 
 			emulate pointers casts. For example, <code>boost::shared_ptr&lt;...&gt;</code> implements 
@@ -20,15 +19,15 @@
 template&lt;class T, class U&gt;
     shared_ptr&lt;T&gt; static_pointer_cast(shared_ptr&lt;U&gt; const &amp;r);
 </pre>
-        <p>Pointer cast functions from <cite><A href="../../boost/pointer_cast.hpp">boost/pointer_cast.hpp</A></CITE>
+		<P>Pointer cast functions from <CITE><A href="../../boost/pointer_cast.hpp">boost/pointer_cast.hpp</A></CITE>
 			are overloads of <code>boost::static_pointer_cast</code>, <code>boost::dynamic_pointer_cast</code>,
 			<code>boost::reinterpret_pointer_cast</code> and <code>boost::const_pointer_cast</code>
-            for raw pointers, <code>std::shared_ptr</code> and <code>std::unique_ptr</code>. This way when developing
-            pointer type independent classes, for example, memory managers or shared memory compatible classes, the same
-            code can be used for raw and smart pointers.</p>
-            <h2><a name="synopsis">Synopsis</a></h2>
-            <blockquote>
-                <pre>
+			for raw pointers. This way when developing pointer type independent classes, 
+			for example, memory managers or shared memory compatible classes, the same code 
+			can be used for raw and smart pointers.</p>
+			<H2><A name="synopsis">Synopsis</A></H2>
+			<BLOCKQUOTE>
+				<PRE>
 namespace boost {
 
 template&lt;class T, class U&gt;
@@ -47,92 +46,14 @@ template&lt;class T, class U&gt;
 inline T* reinterpret_pointer_cast(U *ptr)
   { return reinterpret_cast&lt;T*&gt;(ptr); }
   
-template&lt;class T, class U&gt;
-inline std::shared_ptr&lt;T&gt; static_pointer_cast(std::shared_ptr&lt;U&gt; const&amp; r);
-
-template&lt;class T, class U&gt;
-inline std::shared_ptr&lt;T&gt; dynamic_pointer_cast(std::shared_ptr&lt;U&gt; const&amp; r);
-
-template&lt;class T, class U&gt;
-inline std::shared_ptr&lt;T&gt; const_pointer_cast(std::shared_ptr&lt;U&gt; const&amp; r);
-
-template&lt;class T, class U&gt;
-inline std::shared_ptr&lt;T&gt; reinterpret_pointer_cast(std::shared_ptr&lt;U&gt; const&amp; r);
-
-template&lt;class T, class U&gt;
-inline std::unique_ptr&lt;T&gt; static_pointer_cast(std::unique_ptr&lt;U&gt;&amp;&amp; r);
-
-template&lt;class T, class U&gt;
-inline std::unique_ptr&lt;T&gt; dynamic_pointer_cast(std::unique_ptr&lt;U&gt;&amp;&amp; r);
-
-template&lt;class T, class U&gt;
-inline std::unique_ptr&lt;T&gt; const_pointer_cast(std::unique_ptr&lt;U&gt;&amp;&amp; r);
-
-template&lt;class T, class U&gt;
-inline std::unique_ptr&lt;T&gt; reinterpret_pointer_cast(std::unique_ptr&lt;U&gt;&amp;&amp; r);
-  
 } // namespace boost
-</pre>
-            </blockquote>
-        <p>As you can see from the above synopsis, the pointer cast functions for raw pointers are just 
-           wrappers around standard C++ cast operators.</p>
-
-        <p>The pointer casts for <code>std::shared_ptr</code> are aliases of the corresponding standard
-           functions with the same names and equivalent to <a href="shared_ptr.htm#static_pointer_cast">the
-           functions taking <code>boost::shared_ptr</code></a>.</p>
-
-        <p>The pointer casts for <code>std::unique_ptr</code> are documented below.</p>
-
-        <h3 id="static_pointer_cast">static_pointer_cast</h3>
-        <pre>template&lt;class T, class U&gt;
-  unique_ptr&lt;T&gt; static_pointer_cast(unique_ptr&lt;U&gt;&amp;&amp; r); // never throws</pre>
-        <blockquote>
-            <p><b>Requires:</b> The expression <code>static_cast&lt;T*&gt;( (U*)0 )</code>
-                must be well-formed.</p>
-            <p><b>Returns:</b> <code>unique_ptr&lt;T&gt;( static_cast&lt;typename unique_ptr&lt;T&gt;::element_type*&gt;(r.release()) )</code>.</p>
-            <p><b>Throws:</b> nothing.</p>
-            <p><b>Notes:</b> the seemingly equivalent expression
-                <code>unique_ptr&lt;T&gt;(static_cast&lt;T*&gt;(r.get()))</code>
-                will eventually result in undefined behavior, attempting to delete the same
-                object twice.</p>
-        </blockquote>
-        <h3 id="const_pointer_cast">const_pointer_cast</h3>
-        <pre>template&lt;class T, class U&gt;
-  unique_ptr&lt;T&gt; const_pointer_cast(unique_ptr&lt;U&gt;&amp;&amp; r); // never throws</pre>
-        <blockquote>
-            <p><b>Requires:</b> The expression <code>const_cast&lt;T*&gt;( (U*)0 )</code>
-                must be well-formed.</p>
-            <p><b>Returns:</b> <code>unique_ptr&lt;T&gt;( const_cast&lt;typename unique_ptr&lt;T&gt;::element_type*&gt;(r.release()) )</code>.</p>
-            <p><b>Throws:</b> nothing.</p>
-        </blockquote>
-        <h3 id="dynamic_pointer_cast">dynamic_pointer_cast</h3>
-        <pre>template&lt;class T, class U&gt;
-  unique_ptr&lt;T&gt; dynamic_pointer_cast(unique_ptr&lt;U&gt;&amp;&amp; r);</pre>
-        <blockquote>
-            <p><b>Requires:</b> The expression <code>dynamic_cast&lt;T*&gt;( (U*)0 )</code>
-                must be well-formed. <code>T</code> must have a virtual destructor.</p>
-            <p><b>Returns:</b></p>
-            <ul>
-                <li>
-                    When <code>dynamic_cast&lt;typename unique_ptr&lt;T&gt;::element_type*&gt;(r.get())</code> returns a nonzero value,
-                    <code>unique_ptr&lt;T&gt;(dynamic_cast&lt;typename unique_ptr&lt;T&gt;::element_type*&gt;(r.release()))</code>;</li>
-                <li>
-                    Otherwise, <code>unique_ptr&lt;T&gt;()</code>.</li></ul>
-            <p><b>Throws:</b> nothing.</p>
-        </blockquote>
-        <h3 id="reinterpret_pointer_cast">reinterpret_pointer_cast</h3>
-        <pre>template&lt;class T, class U&gt;
-  unique_ptr&lt;T&gt; reinterpret_pointer_cast(unique_ptr&lt;U&gt;&amp;&amp; r); // never throws</pre>
-        <blockquote>
-            <p><b>Requires:</b> The expression <code>reinterpret_cast&lt;T*&gt;( (U*)0 )</code>
-                must be well-formed.</p>
-            <p><b>Returns:</b> <code>unique_ptr&lt;T&gt;( reinterpret_cast&lt;typename unique_ptr&lt;T&gt;::element_type*&gt;(r.release()) )</code>.</p>
-            <p><b>Throws:</b> nothing.</p>
-        </blockquote>
-
-        <h2><a name="example">Example</a></h2>
-        <blockquote>
-            <pre>
+</PRE>
+			</BLOCKQUOTE>
+		<P>As you can see from the above synopsis, the pointer cast functions are just 
+			wrappers around standard C++ cast operators.</P>
+		<H2><A name="example">Example</A></H2>
+		<BLOCKQUOTE>
+			<PRE>
 #include &lt;boost/pointer_cast.hpp&gt;
 #include &lt;boost/shared_ptr.hpp&gt;
 
@@ -157,27 +78,28 @@ void check_if_it_is_derived(const BasePtr &amp;ptr)
 
 int main()
 {
-   <em>// Create a raw and a shared_ptr</em>
+   <I>// Create a raw and a shared_ptr</I>
 
    base *ptr = new derived;
    boost::shared_ptr&lt;base&gt; sptr(new derived);
    
-   <em>// Check that base pointer points actually to derived class</em>
+   <I>// Check that base pointer points actually to derived class</I>
 
    check_if_it_is_derived(ptr);
    check_if_it_is_derived(sptr);
    
-   <em>// Ok!</em>
+   // <EM>Ok!</EM>
    
    delete ptr;
    return 0;
-}</pre>
-        </blockquote>
-        <p>The example demonstrates how the generic pointer casts help us create pointer 
-            independent code.</p>
-        <hr />
+}</PRE>
+		</BLOCKQUOTE>
+		<P>The example demonstrates how the generic pointer casts help us create pointer 
+			independent code.</P>
+		<hr>
+		<p>Revised: $Date$</p>
 		<p>Copyright 2005 Ion Gazta<74>aga. Use, modification, and distribution are subject to 
-            the Boost Software License, Version 1.0. (See accompanying file <a href="../../LICENSE_1_0.txt">
-            LICENSE_1_0.txt</a> or a copy at &lt;<a href="http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</a>&gt;.)</p>
+			the Boost Software License, Version 1.0. (See accompanying file <A href="../../LICENSE_1_0.txt">
+				LICENSE_1_0.txt</A> or a copy at &lt;<A href="http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</A>&gt;.)</p>
 	</body>
 </html>

pointer_to_other.html

@@ -1,12 +1,12 @@
 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 <html>
 	<head>
-        <title>pointer_to_other</title>
+		<title>pointer_to_other.hpp</title>
 		<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
 	</head>
-    <body text="#000000" bgcolor="#ffffff" link="#0000ff" vlink="#0000ff">
-        <h1><img height="86" alt="boost.png (6897 bytes)" src="../../boost.png" 
-            width="277" align="middle" border="0">pointer_to_other</h1>
+	<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/pointer_to_other.hpp">boost/pointer_to_other.hpp</a></h1>
 		<p>
 			The pointer to other utility provides a way, given a source pointer type, 
 			to obtain a pointer of the same type to another pointee type. The utility is 
@@ -99,7 +99,7 @@ class memory_allocator
 };</pre>
 		<p>As we can see, using pointer_to_other we can create pointer independent code.</p>
 		<hr>
-        <p>$Date$</p>
+		<p>Last revised: $Date$</p>
 		<p><small>Copyright 2005, 2006 Ion Gazta<74>aga and Peter Dimov. Use, modification, 
 				and distribution are subject to the Boost Software License, Version 1.0.<br>
 				(See accompanying file <a href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or a 

scoped_array.htm

@@ -1,12 +1,12 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 <html>
 	<head>
 		<title>scoped_array</title>
 		<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
 	</head>
-        <body text="#000000" bgcolor="#ffffff" link="#0000ff" vlink="#0000ff">
-        <h1><img height="86" alt="boost.png (6897 bytes)" src="../../boost.png" 
-            width="277" align="middle" border="0">scoped_array class template</h1>
+	<body bgcolor="#ffffff" text="#000000">
+		<h1><A href="../../index.htm"><img src="../../boost.png" alt="boost.png (6897 bytes)" align="middle" width="277" height="86"
+					border="0"></A>scoped_array class template</h1>
 		<p>The <b>scoped_array</b> class template stores a pointer to a dynamically 
 			allocated array. (Dynamically allocated arrays are allocated with the C++ <b>new[]</b>
 			expression.) The array pointed to is guaranteed to be deleted, either on 
@@ -106,7 +106,8 @@
 		<p>Equivalent to <b>a.swap(b)</b>. Matches the interface of <b>std::swap</b>. 
 			Provided as an aid to generic programming.</p>
 		<hr>
-        <p>$Date$</p>
+		<p>Revised <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B %Y" startspan--> 
+			09 January 2003<!--webbot bot="Timestamp" endspan i-checksum="32310"--></p>
 		<p><small>Copyright 1999 Greg Colvin and Beman Dawes. Copyright 2002 Darin Adler. 
 			Copyright 2002-2005 Peter Dimov. Distributed under the Boost Software License, Version 
 			1.0. See accompanying file <A href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</A> or 

scoped_ptr.htm

@@ -1,12 +1,12 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 <html>
 	<head>
 		<title>scoped_ptr</title>
 		<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
 	</head>
-        <body text="#000000" bgcolor="#ffffff" link="#0000ff" vlink="#0000ff">
-        <h1><img height="86" alt="boost.png (6897 bytes)" src="../../boost.png" 
-            width="277" align="middle" border="0">scoped_ptr class template</h1>
+	<body bgcolor="#ffffff" text="#000000">
+		<h1><A href="../../index.htm"><img src="../../boost.png" alt="boost.png (6897 bytes)" align="middle" width="277" height="86"
+					border="0"></A>scoped_ptr class template</h1>
 		<p>The <b>scoped_ptr</b> class template stores a pointer to a dynamically allocated 
 			object. (Dynamically allocated objects are allocated with the C++ <b>new</b> expression.) 
 			The object pointed to is guaranteed to be deleted, either on destruction of the <b>scoped_ptr</b>, 
@@ -171,7 +171,8 @@ Buckle my shoe</pre>
 			given context. Use <STRONG>std::auto_ptr</STRONG> where transfer of ownership 
 			is required. (supplied by Dave Abrahams)</p>
 		<hr>
-        <p>$Date</p>
+		<p>Revised <!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %B %Y" startspan --> 
+			09 January 2003<!--webbot bot="Timestamp" endspan i-checksum="32310" --></p>
 		<p><small>Copyright 1999 Greg Colvin and Beman Dawes. Copyright 2002 Darin Adler. 
 			Copyright 2002-2005 Peter Dimov. Distributed under the Boost Software License, Version 
 			1.0. See accompanying file <A href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</A> or 

shared_array.htm

@@ -1,12 +1,12 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 <html>
 	<head>
 		<title>shared_array</title>
 		<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
 	</head>
-        <body text="#000000" bgcolor="#ffffff" link="#0000ff" vlink="#0000ff">
-        <h1><img height="86" alt="boost.png (6897 bytes)" src="../../boost.png" 
-            width="277" align="middle" border="0">shared_array class template</h1>
+	<body bgcolor="#ffffff" text="#000000">
+		<h1><A href="../../index.htm"><img src="../../boost.png" alt="boost.png (6897 bytes)" align="middle" width="277" height="86"
+					border="0"></A>shared_array class template</h1>
 		<p>The <b>shared_array</b> class template stores a pointer to a dynamically 
 			allocated array. (Dynamically allocated array are allocated with the C++ <b>new[]</b>
 			expression.) The object pointed to is guaranteed to be deleted when the last <b>shared_array</b>
@@ -174,7 +174,9 @@ template&lt;class T&gt;
 		<p>Equivalent to <b>a.swap(b)</b>. Matches the interface of <b>std::swap</b>. 
 			Provided as an aid to generic programming.</p>
 		<hr>
-        <p>$Date$</p>
+		<p>Revised 
+			<!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B %Y" startspan --> 
+			09 January 2003<!--webbot bot="Timestamp" endspan i-checksum="32310" --></p>
 		<p><small>Copyright 1999 Greg Colvin and Beman Dawes. Copyright 2002 Darin Adler. 
 			Copyright 2002-2005 Peter Dimov. Distributed under the Boost Software License, Version 
 			1.0. See accompanying file <A href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</A> or 

smart_ptr.htm

@@ -4,9 +4,9 @@
 		<title>Smart Pointers</title>
 		<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
 	</head>
-    <body text="#000000" bgcolor="#ffffff" link="#0000ff" vlink="#0000ff">
-        <h1><img height="86" alt="boost.png (6897 bytes)" src="../../boost.png" 
-            width="277" align="middle" border="0">Smart Pointers</h1>
+	<body bgcolor="#ffffff" text="#000000">
+		<h1><A href="../../index.htm"><img src="../../boost.png" alt="boost.png (6897 bytes)" align="middle" width="277" height="86"
+					border="0"></A>Smart Pointers</h1>
 		<p><a href="#Introduction">Introduction</a><br>
 			<a href="#common_requirements">Common Requirements</a><br>
 			<a href="#Exception_Safety">Exception Safety</a><br>
@@ -62,24 +62,14 @@
 			described in Bjarne Stroustrup's "The C++ Programming Language", 3rd edition,
 			Section 14.4, Resource Management.</p>
 		<p>Additionally, the smart pointer library provides efficient factory functions
-            for creating smart pointer objects:</p>
+			for creating <code>shared_ptr</code> objects:</p>
 		<div align="left">
 			<table border="1" cellpadding="4" cellspacing="0">
 				<tr>
-                    <td><a href="make_shared.html"><b>make_shared, allocate_shared</b></a> for objects</td>
+					<td><a href="make_shared.html"><b>make_shared and allocate_shared</b></a></td>
 					<td><a href="../../boost/make_shared.hpp">&lt;boost/make_shared.hpp&gt;</a></td>
 					<td>Efficient creation of <code>shared_ptr</code> objects.</td>
 				</tr>
-                <tr>
-                    <td><a href="make_shared_array.html"><b>make_shared, allocate_shared</b></a> for arrays</td>
-                    <td><a href="../../boost/make_shared.hpp">&lt;boost/make_shared.hpp&gt;</a></td>
-                    <td>Efficient creation of <code>shared_ptr</code> arrays.</td>
-                </tr>
-                <tr>
-                    <td><a href="make_unique.html"><b>make_unique</b></a></td>
-                    <td><a href="../../boost/make_unique.hpp">&lt;boost/make_unique.hpp&gt;</a></td>
-                    <td>Creation of <code>unique_ptr</code> objects and arrays.</td>
-                </tr>
 			</table>
 		</div>
 		<p>A test program, <a href="test/smart_ptr_test.cpp">smart_ptr_test.cpp</a>, is
@@ -136,21 +126,6 @@
 		<p>Functions which destroy objects of the pointed to type are prohibited from
 			throwing exceptions by the <a href="#common_requirements">common requirements</a>.</p>
 		<h2><a name="History">History</a> and Acknowledgements</h2>
-        <p>February 2017. Glen Fernandes rewrote <b>allocate_shared</b>
-            and <b>make_shared</b> for arrays for a more optimal and more
-            maintainable implementation.</p>
-        <p>February 2014. Glen Fernandes updated overloads of <b>make_shared</b> and 
-            <b>allocate_shared</b> to conform to the specification in C++ standard paper 
-            <a href="#D&amp;F-14">[D&amp;F-14]</a>, and implemented <b>make_unique</b> for 
-            arrays and objects. Peter Dimov and Glen Fernandes updated the scalar and 
-            array implementations, respectively, to resolve C++ standard library defect 
-            2070.</p>
-        <p>November 2012. Glen Fernandes provided implementations of <b>make_shared</b> 
-            and <b>allocate_shared</b> for arrays. They achieve a single allocation for an
-            array that can be initialized with constructor arguments or initializer lists 
-            as well as overloads for default initialization and no value initialization. 
-            See the <a href="make_shared_array.html">make_shared and allocate_shared for 
-            arrays</a> page for more information.</p>
 		<p>January 2002. Peter Dimov reworked all four classes, adding features, fixing
 			bugs, and splitting them into four separate headers, and added <b>weak_ptr</b>.
 			See the <a href="compatibility.htm">compatibility</a> page for a summary of the
@@ -204,10 +179,7 @@
 			the full committee, <b>counted_ptr</b> was rejected and surprising
 			transfer-of-ownership semantics were added to <b>auto_ptr</b>.</p>
 		<h2><a name="References">References</a></h2>
-        <p>[<a name="D&amp;F-14">D&amp;F-14</a>] Peter Dimov &amp; Glen Fernandes, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n3870.html">
-            Extending make_shared to Support Arrays, Revision 1</a>, C++ committee document N3870,
-            January, 2014.</p>
-        <p>[<a name="Col-94">Col-94</a>] Gregory Colvin, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/1994/N0555.pdf">
+		<p>[<a name="Col-94">Col-94</a>] Gregory Colvin, <a href="http://std.dkuug.dk/jtc1/sc22/wg21/docs/papers/1994/N0555.pdf">
 				Exception Safe Smart Pointers</a>, C++ committee document 94-168/N0555,
 			July, 1994.</p>
 		<p>[<a name="E&amp;D-94">E&amp;D-94</a>] John R. Ellis &amp; David L. Detlefs, <a href="http://www.usenix.org/publications/library/proceedings/c++94/full_papers/ellis.a">

smarttests.htm

@@ -7,9 +7,9 @@
 <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
 </head>
 
-<body text="#000000" bgcolor="#ffffff" link="#0000ff" vlink="#0000ff">
+<body bgcolor="#FFFFFF">
 
-<h1><img height="86" alt="boost.png (6897 bytes)" src="../../boost.png" width="277" align="middle" border="0">Smart Pointer Timings</h1>
+<h1><img src="../../boost.png" alt="boost.png (6897 bytes)" align="middle" WIDTH="277" HEIGHT="86">Smart Pointer Timings</h1>
 
 <p>In late January 2000, Mark Borgerding put forward a suggestion to boost for 
   a new design of smart pointer whereby an intrusive doubly linked list is used 
@@ -533,8 +533,9 @@ Gavin Collings,
     spreads its information as in the case of linked pointer.</li>
 </ul>
 <hr>
-<p>$Date$</p>
-<p>&copy; Copyright Gavin Collings 2000. Permission to copy, use, modify, sell
+<p>Revised <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B %Y" startspan -->19 August 2001<!--webbot bot="Timestamp" endspan i-checksum="14767" -->
+</p>
+<p><EFBFBD> Copyright Gavin Collings 2000. Permission to copy, use, modify, sell
 and distribute this document is granted provided this copyright notice appears in all
 copies. This document is provided &quot;as is&quot; without express or implied warranty,
 and with no claim as to its suitability for any purpose.</p>

sp_techniques.html

@@ -1,12 +1,12 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 <html>
 	<head>
 		<title>Smart Pointer Programming Techniques</title>
 		<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
 	</head>
-    <body text="#000000" bgcolor="#ffffff" link="#0000ff" vlink="#0000ff">
-        <h1><img height="86" alt="boost.png (6897 bytes)" src="../../boost.png" 
-            width="277" align="middle" border="0">Smart Pointer Programming Techniques</h1>
+	<body text="#000000" bgColor="#ffffff">
+		<h1><A href="../../index.htm"><IMG height="86" alt="boost.png (6897 bytes)" src="../../boost.png" width="277" align="middle"
+					border="0"></A>Smart Pointer Programming Techniques</h1>
 		<p><A href="#incomplete">Using incomplete classes for implementation hiding</A><br>
 			<A href="#pimpl">The "Pimpl" idiom</A><br>
 			<A href="#abstract">Using abstract classes for implementation hiding</A><br>
@@ -624,7 +624,7 @@ public:
 		<h2><A name="wrapper">Using <code>shared_ptr</code> to wrap member function calls</A></h2>
 		<p><code>shared_ptr</code> implements the ownership semantics required from the <code>Wrap</code>/<code>CallProxy</code>
 			scheme described in Bjarne Stroustrup's article "Wrapping C++ Member Function 
-            Calls" (available online at <A href="http://www.stroustrup.com/wrapper.pdf">http://www.stroustrup.com/wrapper.pdf</A>). 
+			Calls" (available online at <A href="http://www.research.att.com/~bs/wrapper.pdf">http://www.research.att.com/~bs/wrapper.pdf</A>). 
 			An implementation is given below:</p>
 		<pre>template&lt;class T&gt; class pointer
 {
@@ -758,7 +758,7 @@ public:
 			all weak pointers will automatically expire.</p>
 		<hr>
 		<p>$Date$</p>
-        <p><small>Copyright &copy; 2003 Peter Dimov. Distributed under the Boost Software License, Version 
+		<p><small>Copyright <EFBFBD> 2003 Peter Dimov. Distributed under the Boost Software License, Version 
 				1.0. See accompanying file <A href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</A> or 
 				copy at <A href="http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</A>.</small></p>
 	</body>

test/Jamfile.v2

@@ -1,6 +1,6 @@
 #  Boost.SmartPtr Library test Jamfile
 #
-#  Copyright (c) 2003-2013 Peter Dimov
+#  Copyright (c) 2003-2007 Peter Dimov
 #  Copyright (c) 2003 Dave Abrahams
 #
 #  Distributed under the Boost Software License, Version 1.0. (See
@@ -21,7 +21,6 @@ import testing ;
           [ run get_deleter_test.cpp ]
           [ run intrusive_ptr_test.cpp ]
           [ run intrusive_ptr_move_test.cpp ]
-          [ run intrusive_ref_counter_test.cpp ]
           [ run atomic_count_test.cpp ]
           [ run lw_mutex_test.cpp ]
           [ compile-fail shared_ptr_assign_fail.cpp ]
@@ -29,15 +28,11 @@ import testing ;
           [ compile-fail shared_ptr_compare_fail.cpp ]
           [ run shared_ptr_alloc2_test.cpp ]
           [ run pointer_cast_test.cpp ]
-          [ run cpp11_pointer_cast_test.cpp ]
           [ compile pointer_to_other_test.cpp ]
           [ run auto_ptr_rv_test.cpp ]
           [ run shared_ptr_alias_test.cpp ]
           [ run shared_ptr_rv_test.cpp ]
-          [ run shared_ptr_rv_pointer_cast_test.cpp ]
           [ run shared_ptr_move_test.cpp ]
-          [ run shared_ptr_alias_move_test.cpp ]
-          [ run shared_ptr_reinterpret_pointer_cast_test.cpp ]
           [ compile-fail shared_ptr_pv_fail.cpp ]
           [ run sp_unary_addr_test.cpp ]
           [ compile-fail scoped_ptr_eq_fail.cpp ]
@@ -50,9 +45,8 @@ import testing ;
           [ run spinlock_try_test.cpp : : : <threading>multi : spinlock_try_test.mt ]
           [ run spinlock_pool_test.cpp ]
           [ run make_shared_test.cpp ]
-          [ run make_shared_move_emulation_test.cpp ]
           [ run make_shared_perfect_forwarding_test.cpp ]
-          [ run shared_ptr_convertible_test.cpp ]
+          [ run sp_convertible_test.cpp ]
           [ run wp_convertible_test.cpp ]
           [ run ip_convertible_test.cpp ]
           [ run allocate_shared_test.cpp ]
@@ -65,148 +59,10 @@ import testing ;
           [ run sp_recursive_assign2_test.cpp ]
           [ run sp_recursive_assign_rv_test.cpp ]
           [ run sp_recursive_assign2_rv_test.cpp ]
+          [ run esft_constructor_test.cpp ]
           [ compile-fail auto_ptr_lv_fail.cpp ]
           [ run atomic_count_test2.cpp ]
           [ run sp_typeinfo_test.cpp ]
           [ compile make_shared_fp_test.cpp ]
-          [ run sp_hash_test.cpp ]
-          [ run get_deleter_array_test.cpp ]
-          [ run ip_hash_test.cpp ]
-          [ run owner_less_test.cpp ]
-          [ run sp_unique_ptr_test.cpp ]
-          [ run sp_array_test.cpp ]
-          [ compile sp_array_cv_test.cpp ]
-          [ run sp_convertible_test.cpp ]
-          [ run sp_array_n_test.cpp ]
-          [ run sp_array_cast_test.cpp ]
-          [ run sp_zero_compare_test.cpp ]
-          [ run sp_nullptr_test.cpp ]
-          [ run sa_nullptr_test.cpp ]
-          [ run shared_ptr_alloc3_test.cpp ]
-          [ run shared_ptr_alloc11_test.cpp ]
-          [ run shared_ptr_alloc_construct11_test.cpp ]
-          [ run allocate_shared_alloc11_test.cpp ]
-          [ run allocate_shared_construct11_test.cpp ]
-          [ run sp_interlocked_test.cpp ]
-
-          [ compile-fail array_fail_spa_sp_c.cpp ]
-          [ compile-fail array_fail_sp_spa_c.cpp ]
-          [ compile-fail array_fail_spa_spa_c.cpp ]
-          [ compile-fail array_fail_spa_wp_c.cpp ]
-          [ compile-fail array_fail_sp_wpa_c.cpp ]
-          [ compile-fail array_fail_spa_wpa_c.cpp ]
-          [ compile-fail array_fail_wpa_wp_c.cpp ]
-          [ compile-fail array_fail_wp_wpa_c.cpp ]
-          [ compile-fail array_fail_wpa_wpa_c.cpp ]
-          [ compile-fail array_fail_ap_spa_c.cpp ]
-          [ compile-fail array_fail_upa_sp_c.cpp ]
-          [ compile-fail array_fail_up_spa_c.cpp ]
-
-          [ compile-fail array_fail_spa_sp_mc.cpp ]
-          [ compile-fail array_fail_sp_spa_mc.cpp ]
-          [ compile-fail array_fail_spa_spa_mc.cpp ]
-          [ compile-fail array_fail_spa_wp_mc.cpp ]
-          [ compile-fail array_fail_sp_wpa_mc.cpp ]
-          [ compile-fail array_fail_spa_wpa_mc.cpp ]
-          [ compile-fail array_fail_wpa_wp_mc.cpp ]
-          [ compile-fail array_fail_wp_wpa_mc.cpp ]
-          [ compile-fail array_fail_wpa_wpa_mc.cpp ]
-          [ compile-fail array_fail_ap_spa_mc.cpp ]
-          [ compile-fail array_fail_upa_sp_mc.cpp ]
-          [ compile-fail array_fail_up_spa_mc.cpp ]
-
-          [ compile-fail array_fail_spa_sp_a.cpp ]
-          [ compile-fail array_fail_sp_spa_a.cpp ]
-          [ compile-fail array_fail_spa_spa_a.cpp ]
-          [ compile-fail array_fail_spa_wp_a.cpp ]
-          [ compile-fail array_fail_sp_wpa_a.cpp ]
-          [ compile-fail array_fail_spa_wpa_a.cpp ]
-          [ compile-fail array_fail_wpa_wp_a.cpp ]
-          [ compile-fail array_fail_wp_wpa_a.cpp ]
-          [ compile-fail array_fail_wpa_wpa_a.cpp ]
-          [ compile-fail array_fail_ap_spa_a.cpp ]
-          [ compile-fail array_fail_upa_sp_a.cpp ]
-          [ compile-fail array_fail_up_spa_a.cpp ]
-
-          [ compile-fail array_fail_spa_sp_ma.cpp ]
-          [ compile-fail array_fail_sp_spa_ma.cpp ]
-          [ compile-fail array_fail_spa_spa_ma.cpp ]
-          [ compile-fail array_fail_spa_wp_ma.cpp ]
-          [ compile-fail array_fail_sp_wpa_ma.cpp ]
-          [ compile-fail array_fail_spa_wpa_ma.cpp ]
-          [ compile-fail array_fail_wpa_wp_ma.cpp ]
-          [ compile-fail array_fail_wp_wpa_ma.cpp ]
-          [ compile-fail array_fail_wpa_wpa_ma.cpp ]
-          [ compile-fail array_fail_ap_spa_ma.cpp ]
-          [ compile-fail array_fail_upa_sp_ma.cpp ]
-          [ compile-fail array_fail_up_spa_ma.cpp ]
-
-          [ compile-fail array_fail_dereference.cpp ]
-          [ compile-fail array_fail_member_access.cpp ]
-          [ compile-fail array_fail_array_access.cpp ]
-
-          [ run make_shared_array_test.cpp ]
-          [ run make_shared_arrays_test.cpp : : : <toolset>gcc-4.6.3_0x:<cxxflags>-fno-deduce-init-list ]
-          [ run make_shared_array_throws_test.cpp ]
-          [ run make_shared_array_esft_test.cpp ]
-          [ run make_shared_array_noinit_test.cpp ]
-          [ run make_shared_array_value_test.cpp ]
-          [ run allocate_shared_array_test.cpp ]
-          [ run allocate_shared_arrays_test.cpp : : : <toolset>gcc-4.6.3_0x:<cxxflags>-fno-deduce-init-list ]
-          [ run allocate_shared_array_throws_test.cpp ]
-          [ run allocate_shared_array_esft_test.cpp ]
-          [ run allocate_shared_array_noinit_test.cpp ]
-          [ run allocate_shared_array_value_test.cpp ]
-          [ run allocate_shared_array_construct_test.cpp ]
-
-          [ run make_unique_test.cpp ]
-          [ run make_unique_args_test.cpp ]
-          [ run make_unique_value_test.cpp ]
-          [ run make_unique_noinit_test.cpp ]
-          [ run make_unique_throws_test.cpp ]
-          [ run make_unique_array_test.cpp ]
-          [ run make_unique_array_noinit_test.cpp ]
-          [ run make_unique_array_throws_test.cpp ]
-
-          [ run shared_from_raw_test.cpp ]
-          [ run shared_from_raw_test2.cpp ]
-          [ run shared_from_raw_test3.cpp ]
-          [ run shared_from_raw_test4.cpp ]
-          [ run shared_from_raw_test5.cpp ]
-          [ run shared_from_raw_test6.cpp ]
-
-          [ run weak_from_raw_test.cpp ]
-          [ run weak_from_raw_test2.cpp ]
-          [ run weak_from_raw_test3.cpp ]
-          [ run weak_from_raw_test4.cpp ]
-          [ run weak_from_raw_test5.cpp ]
-
-          [ compile sp_explicit_inst_test.cpp ]
-
-          [ run weak_from_this_test.cpp ]
-          [ run weak_from_this_test2.cpp ]
-
-          [ run sp_bml_unique_ptr_test.cpp ]
-
-          [ run sp_hash_test2.cpp ]
-          [ run sp_hash_test3.cpp ]
-
-          [ run pointer_cast_test2.cpp ]
-
-          [ compile-fail pointer_cast_st_fail.cpp ]
-          [ compile-fail pointer_cast_st_fail2.cpp ]
-          [ compile-fail pointer_cast_st_fail3.cpp ]
-
-          [ compile-fail pointer_cast_co_fail.cpp ]
-          [ compile-fail pointer_cast_co_fail2.cpp ]
-          [ compile-fail pointer_cast_co_fail3.cpp ]
-
-          [ compile-fail pointer_cast_dy_fail.cpp ]
-          [ compile-fail pointer_cast_dy_fail2.cpp ]
-          [ compile-fail pointer_cast_dy_fail3.cpp ]
-
-          [ run sp_nothrow_test.cpp ]
-
-          [ compile make_shared_msvc_test.cpp ]
         ;
 }

test/allocate_shared_alloc11_test.cpp

@@ -1,241 +0,0 @@
-// allocate_shared_alloc11_test.cpp
-//
-// allocate_shared with a minimal C++11 allocator
-//
-// Copyright 2007-2009, 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/detail/lightweight_test.hpp>
-#include <boost/make_shared.hpp>
-#include <boost/shared_ptr.hpp>
-#include <boost/weak_ptr.hpp>
-#include <boost/config.hpp>
-#include <cstddef>
-
-#if !defined( BOOST_NO_CXX11_ALLOCATOR )
-
-template< class T > class cxx11_allocator
-{
-public:
-
-    typedef T value_type;
-
-    cxx11_allocator()
-    {
-    }
-
-    template< class Y > cxx11_allocator( cxx11_allocator<Y> const & )
-    {
-    }
-
-    T * allocate( std::size_t n )
-    {
-        return static_cast< T* >( ::operator new( n * sizeof( T ) ) );
-    }
-
-    void deallocate( T * p, std::size_t n )
-    {
-        ::operator delete( p );
-    }
-};
-
-class X
-{
-private:
-
-    X( X const & );
-    X & operator=( X const & );
-
-    void * operator new( std::size_t n )
-    {
-        BOOST_ERROR( "private X::new called" );
-        return ::operator new( n );
-    }
-
-    void operator delete( void * p )
-    {
-        BOOST_ERROR( "private X::delete called" );
-        ::operator delete( p );
-    }
-
-public:
-
-    static int instances;
-
-    int v;
-
-    explicit X( int a1 = 0, int a2 = 0, int a3 = 0, int a4 = 0, int a5 = 0, int a6 = 0, int a7 = 0, int a8 = 0, int a9 = 0 ): v( a1+a2+a3+a4+a5+a6+a7+a8+a9 )
-    {
-        ++instances;
-    }
-
-    ~X()
-    {
-        --instances;
-    }
-};
-
-int X::instances = 0;
-
-int main()
-{
-    {
-        boost::shared_ptr< int > pi = boost::allocate_shared< int >( cxx11_allocator<int>() );
-
-        BOOST_TEST( pi.get() != 0 );
-        BOOST_TEST( *pi == 0 );
-    }
-
-    {
-        boost::shared_ptr< int > pi = boost::allocate_shared< int >( cxx11_allocator<int>(), 5 );
-
-        BOOST_TEST( pi.get() != 0 );
-        BOOST_TEST( *pi == 5 );
-    }
-
-    BOOST_TEST( X::instances == 0 );
-
-    {
-        boost::shared_ptr< X > pi = boost::allocate_shared< X >( cxx11_allocator<void>() );
-        boost::weak_ptr<X> wp( pi );
-
-        BOOST_TEST( X::instances == 1 );
-        BOOST_TEST( pi.get() != 0 );
-        BOOST_TEST( pi->v == 0 );
-
-        pi.reset();
-
-        BOOST_TEST( X::instances == 0 );
-    }
-
-    {
-        boost::shared_ptr< X > pi = boost::allocate_shared< X >( cxx11_allocator<void>(), 1 );
-        boost::weak_ptr<X> wp( pi );
-
-        BOOST_TEST( X::instances == 1 );
-        BOOST_TEST( pi.get() != 0 );
-        BOOST_TEST( pi->v == 1 );
-
-        pi.reset();
-
-        BOOST_TEST( X::instances == 0 );
-    }
-
-    {
-        boost::shared_ptr< X > pi = boost::allocate_shared< X >( cxx11_allocator<void>(), 1, 2 );
-        boost::weak_ptr<X> wp( pi );
-
-        BOOST_TEST( X::instances == 1 );
-        BOOST_TEST( pi.get() != 0 );
-        BOOST_TEST( pi->v == 1+2 );
-
-        pi.reset();
-
-        BOOST_TEST( X::instances == 0 );
-    }
-
-    {
-        boost::shared_ptr< X > pi = boost::allocate_shared< X >( cxx11_allocator<void>(), 1, 2, 3 );
-        boost::weak_ptr<X> wp( pi );
-
-        BOOST_TEST( X::instances == 1 );
-        BOOST_TEST( pi.get() != 0 );
-        BOOST_TEST( pi->v == 1+2+3 );
-
-        pi.reset();
-
-        BOOST_TEST( X::instances == 0 );
-    }
-
-    {
-        boost::shared_ptr< X > pi = boost::allocate_shared< X >( cxx11_allocator<void>(), 1, 2, 3, 4 );
-        boost::weak_ptr<X> wp( pi );
-
-        BOOST_TEST( X::instances == 1 );
-        BOOST_TEST( pi.get() != 0 );
-        BOOST_TEST( pi->v == 1+2+3+4 );
-
-        pi.reset();
-
-        BOOST_TEST( X::instances == 0 );
-    }
-
-    {
-        boost::shared_ptr< X > pi = boost::allocate_shared< X >( cxx11_allocator<void>(), 1, 2, 3, 4, 5 );
-        boost::weak_ptr<X> wp( pi );
-
-        BOOST_TEST( X::instances == 1 );
-        BOOST_TEST( pi.get() != 0 );
-        BOOST_TEST( pi->v == 1+2+3+4+5 );
-
-        pi.reset();
-
-        BOOST_TEST( X::instances == 0 );
-    }
-
-    {
-        boost::shared_ptr< X > pi = boost::allocate_shared< X >( cxx11_allocator<void>(), 1, 2, 3, 4, 5, 6 );
-        boost::weak_ptr<X> wp( pi );
-
-        BOOST_TEST( X::instances == 1 );
-        BOOST_TEST( pi.get() != 0 );
-        BOOST_TEST( pi->v == 1+2+3+4+5+6 );
-
-        pi.reset();
-
-        BOOST_TEST( X::instances == 0 );
-    }
-
-    {
-        boost::shared_ptr< X > pi = boost::allocate_shared< X >( cxx11_allocator<void>(), 1, 2, 3, 4, 5, 6, 7 );
-        boost::weak_ptr<X> wp( pi );
-
-        BOOST_TEST( X::instances == 1 );
-        BOOST_TEST( pi.get() != 0 );
-        BOOST_TEST( pi->v == 1+2+3+4+5+6+7 );
-
-        pi.reset();
-
-        BOOST_TEST( X::instances == 0 );
-    }
-
-    {
-        boost::shared_ptr< X > pi = boost::allocate_shared< X >( cxx11_allocator<void>(), 1, 2, 3, 4, 5, 6, 7, 8 );
-        boost::weak_ptr<X> wp( pi );
-
-        BOOST_TEST( X::instances == 1 );
-        BOOST_TEST( pi.get() != 0 );
-        BOOST_TEST( pi->v == 1+2+3+4+5+6+7+8 );
-
-        pi.reset();
-
-        BOOST_TEST( X::instances == 0 );
-    }
-
-    {
-        boost::shared_ptr< X > pi = boost::allocate_shared< X >( cxx11_allocator<void>(), 1, 2, 3, 4, 5, 6, 7, 8, 9 );
-        boost::weak_ptr<X> wp( pi );
-
-        BOOST_TEST( X::instances == 1 );
-        BOOST_TEST( pi.get() != 0 );
-        BOOST_TEST( pi->v == 1+2+3+4+5+6+7+8+9 );
-
-        pi.reset();
-
-        BOOST_TEST( X::instances == 0 );
-    }
-
-    return boost::report_errors();
-}
-
-#else // !defined( BOOST_NO_CXX11_ALLOCATOR )
-
-int main()
-{
-    return 0;
-}
-
-#endif

test/allocate_shared_array_construct_test.cpp

@@ -1,162 +0,0 @@
-/*
-Copyright 2012-2015 Glen Joseph Fernandes
-(glenjofe@gmail.com)
-
-Distributed under the Boost Software License, Version 1.0.
-(http://www.boost.org/LICENSE_1_0.txt)
-*/
-#include <boost/core/lightweight_test.hpp>
-#include <boost/smart_ptr/make_shared.hpp>
-
-#if !defined(BOOST_NO_CXX11_ALLOCATOR)
-struct allow { };
-
-template<class T>
-struct creator {
-    typedef T value_type;
-
-    template<class U>
-    struct rebind {
-        typedef creator<U> other;
-    };
-
-    creator() { }
-
-    template<class U>
-    creator(const creator<U>&) { }
-
-    T* allocate(std::size_t size) {
-        return static_cast<T*>(::operator new(sizeof(T) * size));
-    }
-
-    void deallocate(T* ptr, std::size_t) {
-        ::operator delete(ptr);
-    }
-
-    template<class U>
-    void construct(U* ptr) {
-        ::new(static_cast<void*>(ptr)) U(allow());
-    }
-
-    template<class U>
-    void destroy(U* ptr) {
-        ptr->~U();
-    }
-
-};
-
-template<class T, class U>
-inline bool
-operator==(const creator<T>&, const creator<U>&)
-{
-    return true;
-}
-
-template<class T, class U>
-inline bool
-operator!=(const creator<T>&, const creator<U>&)
-{
-    return false;
-}
-
-class type {
-public:
-    static unsigned instances;
-
-    explicit type(allow) {
-        ++instances;
-    }
-
-    ~type() {
-        --instances;
-    }
-
-private:
-    type(const type&);
-    type& operator=(const type&);
-};
-
-unsigned type::instances = 0;
-
-int main()
-{
-    {
-        boost::shared_ptr<type[]> result =
-            boost::allocate_shared<type[]>(creator<type>(), 3);
-        BOOST_TEST(result.get() != 0);
-        BOOST_TEST(result.use_count() == 1);
-        BOOST_TEST(type::instances == 3);
-        result.reset();
-        BOOST_TEST(type::instances == 0);
-    }
-    {
-        boost::shared_ptr<type[3]> result =
-            boost::allocate_shared<type[3]>(creator<type>());
-        BOOST_TEST(result.get() != 0);
-        BOOST_TEST(result.use_count() == 1);
-        BOOST_TEST(type::instances == 3);
-        result.reset();
-        BOOST_TEST(type::instances == 0);
-    }
-    {
-        boost::shared_ptr<type[][2]> result =
-            boost::allocate_shared<type[][2]>(creator<type>(), 2);
-        BOOST_TEST(result.get() != 0);
-        BOOST_TEST(result.use_count() == 1);
-        BOOST_TEST(type::instances == 4);
-        result.reset();
-        BOOST_TEST(type::instances == 0);
-    }
-    {
-        boost::shared_ptr<type[2][2]> result =
-            boost::allocate_shared<type[2][2]>(creator<type>());
-        BOOST_TEST(result.get() != 0);
-        BOOST_TEST(result.use_count() == 1);
-        BOOST_TEST(type::instances == 4);
-        result.reset();
-        BOOST_TEST(type::instances == 0);
-    }
-    {
-        boost::shared_ptr<const type[]> result =
-            boost::allocate_shared<const type[]>(creator<type>(), 3);
-        BOOST_TEST(result.get() != 0);
-        BOOST_TEST(result.use_count() == 1);
-        BOOST_TEST(type::instances == 3);
-        result.reset();
-        BOOST_TEST(type::instances == 0);
-    }
-    {
-        boost::shared_ptr<const type[3]> result =
-            boost::allocate_shared<const type[3]>(creator<type>());
-        BOOST_TEST(result.get() != 0);
-        BOOST_TEST(result.use_count() == 1);
-        BOOST_TEST(type::instances == 3);
-        result.reset();
-        BOOST_TEST(type::instances == 0);
-    }
-    {
-        boost::shared_ptr<const type[][2]> result =
-            boost::allocate_shared<const type[][2]>(creator<type>(), 2);
-        BOOST_TEST(result.get() != 0);
-        BOOST_TEST(result.use_count() == 1);
-        BOOST_TEST(type::instances == 4);
-        result.reset();
-        BOOST_TEST(type::instances == 0);
-    }
-    {
-        boost::shared_ptr<const type[2][2]> result =
-            boost::allocate_shared<const type[2][2]>(creator<type>());
-        BOOST_TEST(result.get() != 0);
-        BOOST_TEST(result.use_count() == 1);
-        BOOST_TEST(type::instances == 4);
-        result.reset();
-        BOOST_TEST(type::instances == 0);
-    }
-    return boost::report_errors();
-}
-#else
-int main()
-{
-    return 0;
-}
-#endif

test/allocate_shared_array_esft_test.cpp

@@ -1,94 +0,0 @@
-/*
-Copyright 2012-2015 Glen Joseph Fernandes
-(glenjofe@gmail.com)
-
-Distributed under the Boost Software License, Version 1.0.
-(http://www.boost.org/LICENSE_1_0.txt)
-*/
-#include <boost/core/lightweight_test.hpp>
-#include <boost/smart_ptr/enable_shared_from_this.hpp>
-#include <boost/smart_ptr/make_shared.hpp>
-
-template<class T>
-struct creator {
-    typedef T value_type;
-
-    template<class U>
-    struct rebind {
-        typedef creator<U> other;
-    };
-
-    creator() { }
-
-    template<class U>
-    creator(const creator<U>&) { }
-
-    T* allocate(std::size_t size) {
-        return static_cast<T*>(::operator new(sizeof(T) * size));
-    }
-
-    void deallocate(T* ptr, std::size_t) {
-        ::operator delete(ptr);
-    }
-};
-
-template<class T, class U>
-inline bool
-operator==(const creator<T>&, const creator<U>&)
-{
-    return true;
-}
-
-template<class T, class U>
-inline bool
-operator!=(const creator<T>&, const creator<U>&)
-{
-    return false;
-}
-
-class type
-    : public boost::enable_shared_from_this<type> {
-public:
-    static unsigned instances;
-
-    type() {
-        ++instances;
-    }
-
-    ~type() {
-        --instances;
-    }
-
-private:
-    type(const type&);
-    type& operator=(const type&);
-};
-
-unsigned type::instances = 0;
-
-int main()
-{
-    BOOST_TEST(type::instances == 0);
-    {
-        boost::shared_ptr<type[]> result =
-            boost::allocate_shared<type[]>(creator<type>(), 3);
-        try {
-            result[0].shared_from_this();
-            BOOST_ERROR("shared_from_this did not throw");
-        } catch (...) {
-            BOOST_TEST(type::instances == 3);
-        }
-    }
-    BOOST_TEST(type::instances == 0);
-    {
-        boost::shared_ptr<type[]> result =
-            boost::allocate_shared_noinit<type[]>(creator<type>(), 3);
-        try {
-            result[0].shared_from_this();
-            BOOST_ERROR("shared_from_this did not throw");
-        } catch (...) {
-            BOOST_TEST(type::instances == 3);
-        }
-    }
-    return boost::report_errors();
-}

test/allocate_shared_array_noinit_test.cpp

@@ -1,251 +0,0 @@
-/*
-Copyright 2012-2015 Glen Joseph Fernandes
-(glenjofe@gmail.com)
-
-Distributed under the Boost Software License, Version 1.0.
-(http://www.boost.org/LICENSE_1_0.txt)
-*/
-#include <boost/align/is_aligned.hpp>
-#include <boost/core/lightweight_test.hpp>
-#include <boost/smart_ptr/make_shared.hpp>
-#include <boost/smart_ptr/weak_ptr.hpp>
-#include <boost/type_traits/alignment_of.hpp>
-
-template<class T>
-struct creator {
-    typedef T value_type;
-
-    template<class U>
-    struct rebind {
-        typedef creator<U> other;
-    };
-
-    creator() { }
-
-    template<class U>
-    creator(const creator<U>&) { }
-
-    T* allocate(std::size_t size) {
-        return static_cast<T*>(::operator new(sizeof(T) * size));
-    }
-
-    void deallocate(T* ptr, std::size_t) {
-        ::operator delete(ptr);
-    }
-};
-
-template<class T, class U>
-inline bool
-operator==(const creator<T>&, const creator<U>&)
-{
-    return true;
-}
-
-template<class T, class U>
-inline bool
-operator!=(const creator<T>&, const creator<U>&)
-{
-    return false;
-}
-
-class type {
-public:
-    static unsigned instances;
-
-    type()
-        : value_(0.0) {
-        ++instances;
-    }
-
-    ~type() {
-        --instances;
-    }
-
-    void set(long double value) {
-        value_ = value;
-    }
-
-    long double get() const {
-        return value_;
-    }
-
-private:
-    type(const type&);
-    type& operator=(const type&);
-
-    long double value_;
-};
-
-unsigned type::instances = 0;
-
-int main()
-{
-    {
-        boost::shared_ptr<int[]> result =
-            boost::allocate_shared_noinit<int[]>(creator<int>(), 3);
-        BOOST_TEST(result.get() != 0);
-        BOOST_TEST(result.use_count() == 1);
-        BOOST_TEST(boost::alignment::is_aligned(result.get(),
-            boost::alignment_of<int>::value));
-    }
-    {
-        boost::shared_ptr<int[3]> result =
-            boost::allocate_shared_noinit<int[3]>(creator<int>());
-        BOOST_TEST(result.get() != 0);
-        BOOST_TEST(result.use_count() == 1);
-        BOOST_TEST(boost::alignment::is_aligned(result.get(),
-            boost::alignment_of<int>::value));
-    }
-    {
-        boost::shared_ptr<int[][2]> result =
-            boost::allocate_shared_noinit<int[][2]>(creator<int>(), 2);
-        BOOST_TEST(result.get() != 0);
-        BOOST_TEST(result.use_count() == 1);
-        BOOST_TEST(boost::alignment::is_aligned(result.get(),
-            boost::alignment_of<int>::value));
-    }
-    {
-        boost::shared_ptr<int[2][2]> result =
-            boost::allocate_shared_noinit<int[2][2]>(creator<int>());
-        BOOST_TEST(result.get() != 0);
-        BOOST_TEST(result.use_count() == 1);
-        BOOST_TEST(boost::alignment::is_aligned(result.get(),
-            boost::alignment_of<int>::value));
-    }
-    {
-        boost::shared_ptr<const int[]> result =
-            boost::allocate_shared_noinit<const
-                int[]>(creator<int>(), 3);
-        BOOST_TEST(result.get() != 0);
-        BOOST_TEST(result.use_count() == 1);
-        BOOST_TEST(boost::alignment::is_aligned(result.get(),
-            boost::alignment_of<int>::value));
-    }
-    {
-        boost::shared_ptr<const int[3]> result =
-            boost::allocate_shared_noinit<const int[3]>(creator<int>());
-        BOOST_TEST(result.get() != 0);
-        BOOST_TEST(result.use_count() == 1);
-        BOOST_TEST(boost::alignment::is_aligned(result.get(),
-            boost::alignment_of<int>::value));
-    }
-    {
-        boost::shared_ptr<const int[][2]> result =
-            boost::allocate_shared_noinit<const
-                int[][2]>(creator<int>(), 2);
-        BOOST_TEST(result.get() != 0);
-        BOOST_TEST(result.use_count() == 1);
-        BOOST_TEST(boost::alignment::is_aligned(result.get(),
-            boost::alignment_of<int>::value));
-    }
-    {
-        boost::shared_ptr<const int[2][2]> result =
-            boost::allocate_shared_noinit<const
-                int[2][2]>(creator<int>());
-        BOOST_TEST(result.get() != 0);
-        BOOST_TEST(result.use_count() == 1);
-        BOOST_TEST(boost::alignment::is_aligned(result.get(),
-            boost::alignment_of<int>::value));
-    }
-    {
-        boost::shared_ptr<type[]> result =
-            boost::allocate_shared_noinit<type[]>(creator<type>(), 3);
-        BOOST_TEST(result.get() != 0);
-        BOOST_TEST(result.use_count() == 1);
-        BOOST_TEST(boost::alignment::is_aligned(result.get(),
-            boost::alignment_of<type>::value));
-        BOOST_TEST(type::instances == 3);
-        boost::weak_ptr<type[]> other = result;
-        result.reset();
-        BOOST_TEST(type::instances == 0);
-    }
-    {
-        boost::shared_ptr<type[3]> result =
-            boost::allocate_shared_noinit<type[3]>(creator<type>());
-        BOOST_TEST(result.get() != 0);
-        BOOST_TEST(result.use_count() == 1);
-        BOOST_TEST(boost::alignment::is_aligned(result.get(),
-            boost::alignment_of<type>::value));
-        BOOST_TEST(type::instances == 3);
-        boost::weak_ptr<type[3]> other = result;
-        result.reset();
-        BOOST_TEST(type::instances == 0);
-    }
-    {
-        boost::shared_ptr<type[][2]> result =
-            boost::allocate_shared_noinit<type[][2]>(creator<type>(), 2);
-        BOOST_TEST(result.get() != 0);
-        BOOST_TEST(result.use_count() == 1);
-        BOOST_TEST(boost::alignment::is_aligned(result.get(),
-            boost::alignment_of<type>::value));
-        BOOST_TEST(type::instances == 4);
-        boost::weak_ptr<type[][2]> other = result;
-        result.reset();
-        BOOST_TEST(type::instances == 0);
-    }
-    {
-        boost::shared_ptr<type[2][2]> result =
-            boost::allocate_shared_noinit<type[2][2]>(creator<type>());
-        BOOST_TEST(result.get() != 0);
-        BOOST_TEST(result.use_count() == 1);
-        BOOST_TEST(boost::alignment::is_aligned(result.get(),
-            boost::alignment_of<type>::value));
-        BOOST_TEST(type::instances == 4);
-        boost::weak_ptr<type[2][2]> other = result;
-        result.reset();
-        BOOST_TEST(type::instances == 0);
-    }
-    {
-        boost::shared_ptr<const type[]> result =
-            boost::allocate_shared_noinit<const
-                type[]>(creator<type>(), 3);
-        BOOST_TEST(result.get() != 0);
-        BOOST_TEST(result.use_count() == 1);
-        BOOST_TEST(boost::alignment::is_aligned(result.get(),
-            boost::alignment_of<type>::value));
-        BOOST_TEST(type::instances == 3);
-        boost::weak_ptr<const type[]> other = result;
-        result.reset();
-        BOOST_TEST(type::instances == 0);
-    }
-    {
-        boost::shared_ptr<const type[3]> result =
-            boost::allocate_shared_noinit<const
-                type[3]>(creator<type>());
-        BOOST_TEST(result.get() != 0);
-        BOOST_TEST(result.use_count() == 1);
-        BOOST_TEST(boost::alignment::is_aligned(result.get(),
-            boost::alignment_of<type>::value));
-        BOOST_TEST(type::instances == 3);
-        boost::weak_ptr<const type[3]> other = result;
-        result.reset();
-        BOOST_TEST(type::instances == 0);
-    }
-    {
-        boost::shared_ptr<const type[][2]> result =
-            boost::allocate_shared_noinit<const
-                type[][2]>(creator<type>(), 2);
-        BOOST_TEST(result.get() != 0);
-        BOOST_TEST(result.use_count() == 1);
-        BOOST_TEST(boost::alignment::is_aligned(result.get(),
-            boost::alignment_of<type>::value));
-        BOOST_TEST(type::instances == 4);
-        boost::weak_ptr<const type[][2]> other = result;
-        result.reset();
-        BOOST_TEST(type::instances == 0);
-    }
-    {
-        boost::shared_ptr<const type[2][2]> result =
-            boost::allocate_shared_noinit<const
-                type[2][2]>(creator<type>());
-        BOOST_TEST(result.get() != 0);
-        BOOST_TEST(result.use_count() == 1);
-        BOOST_TEST(boost::alignment::is_aligned(result.get(),
-            boost::alignment_of<type>::value));
-        BOOST_TEST(type::instances == 4);
-        boost::weak_ptr<const type[2][2]> other = result;
-        result.reset();
-        BOOST_TEST(type::instances == 0);
-    }
-    return boost::report_errors();
-}

test/allocate_shared_array_test.cpp

@@ -1,266 +0,0 @@
-/*
-Copyright 2012-2015 Glen Joseph Fernandes
-(glenjofe@gmail.com)
-
-Distributed under the Boost Software License, Version 1.0.
-(http://www.boost.org/LICENSE_1_0.txt)
-*/
-#include <boost/align/is_aligned.hpp>
-#include <boost/core/lightweight_test.hpp>
-#include <boost/smart_ptr/make_shared.hpp>
-#include <boost/smart_ptr/weak_ptr.hpp>
-#include <boost/type_traits/alignment_of.hpp>
-
-template<class T>
-struct creator {
-    typedef T value_type;
-
-    template<class U>
-    struct rebind {
-        typedef creator<U> other;
-    };
-
-    creator() { }
-
-    template<class U>
-    creator(const creator<U>&) { }
-
-    T* allocate(std::size_t size) {
-        return static_cast<T*>(::operator new(sizeof(T) * size));
-    }
-
-    void deallocate(T* ptr, std::size_t) {
-        ::operator delete(ptr);
-    }
-};
-
-template<class T, class U>
-inline bool
-operator==(const creator<T>&, const creator<U>&)
-{
-    return true;
-}
-
-template<class T, class U>
-inline bool
-operator!=(const creator<T>&, const creator<U>&)
-{
-    return false;
-}
-
-class type {
-public:
-    static unsigned instances;
-
-    type()
-        : value_(0.0) {
-        ++instances;
-    }
-
-    ~type() {
-        --instances;
-    }
-
-    void set(long double value) {
-        value_ = value;
-    }
-
-    long double get() const {
-        return value_;
-    }
-
-private:
-    type(const type&);
-    type& operator=(const type&);
-
-    long double value_;
-};
-
-unsigned type::instances = 0;
-
-int main()
-{
-    {
-        boost::shared_ptr<int[]> result =
-            boost::allocate_shared<int[]>(creator<int>(), 3);
-        BOOST_TEST(result.get() != 0);
-        BOOST_TEST(result.use_count() == 1);
-        BOOST_TEST(boost::alignment::is_aligned(result.get(),
-            boost::alignment_of<int>::value));
-        BOOST_TEST(result[0] == 0);
-        BOOST_TEST(result[1] == 0);
-        BOOST_TEST(result[2] == 0);
-    }
-    {
-        boost::shared_ptr<int[3]> result =
-            boost::allocate_shared<int[3]>(creator<int>());
-        BOOST_TEST(result.get() != 0);
-        BOOST_TEST(result.use_count() == 1);
-        BOOST_TEST(boost::alignment::is_aligned(result.get(),
-            boost::alignment_of<int>::value));
-        BOOST_TEST(result[0] == 0);
-        BOOST_TEST(result[1] == 0);
-        BOOST_TEST(result[2] == 0);
-    }
-    {
-        boost::shared_ptr<int[][2]> result =
-            boost::allocate_shared<int[][2]>(creator<int>(), 2);
-        BOOST_TEST(result.get() != 0);
-        BOOST_TEST(result.use_count() == 1);
-        BOOST_TEST(boost::alignment::is_aligned(result.get(),
-            boost::alignment_of<int>::value));
-        BOOST_TEST(result[0][0] == 0);
-        BOOST_TEST(result[0][1] == 0);
-        BOOST_TEST(result[1][0] == 0);
-        BOOST_TEST(result[1][1] == 0);
-    }
-    {
-        boost::shared_ptr<int[2][2]> result =
-            boost::allocate_shared<int[2][2]>(creator<int>());
-        BOOST_TEST(result.get() != 0);
-        BOOST_TEST(result.use_count() == 1);
-        BOOST_TEST(boost::alignment::is_aligned(result.get(),
-            boost::alignment_of<int>::value));
-        BOOST_TEST(result[0][0] == 0);
-        BOOST_TEST(result[0][1] == 0);
-        BOOST_TEST(result[1][0] == 0);
-        BOOST_TEST(result[1][1] == 0);
-    }
-    {
-        boost::shared_ptr<const int[]> result =
-            boost::allocate_shared<const int[]>(creator<int>(), 3);
-        BOOST_TEST(result.get() != 0);
-        BOOST_TEST(result.use_count() == 1);
-        BOOST_TEST(boost::alignment::is_aligned(result.get(),
-            boost::alignment_of<int>::value));
-        BOOST_TEST(result[0] == 0);
-        BOOST_TEST(result[1] == 0);
-        BOOST_TEST(result[2] == 0);
-    }
-    {
-        boost::shared_ptr<const int[3]> result =
-            boost::allocate_shared<const int[3]>(creator<int>());
-        BOOST_TEST(result.get() != 0);
-        BOOST_TEST(result.use_count() == 1);
-        BOOST_TEST(boost::alignment::is_aligned(result.get(),
-            boost::alignment_of<int>::value));
-        BOOST_TEST(result[0] == 0);
-        BOOST_TEST(result[1] == 0);
-        BOOST_TEST(result[2] == 0);
-    }
-    {
-        boost::shared_ptr<const int[][2]> result =
-            boost::allocate_shared<const int[][2]>(creator<int>(), 2);
-        BOOST_TEST(result.get() != 0);
-        BOOST_TEST(result.use_count() == 1);
-        BOOST_TEST(boost::alignment::is_aligned(result.get(),
-            boost::alignment_of<int>::value));
-        BOOST_TEST(result[0][0] == 0);
-        BOOST_TEST(result[0][1] == 0);
-        BOOST_TEST(result[1][0] == 0);
-        BOOST_TEST(result[1][1] == 0);
-    }
-    {
-        boost::shared_ptr<const int[2][2]> result =
-            boost::allocate_shared<const int[2][2]>(creator<int>());
-        BOOST_TEST(result.get() != 0);
-        BOOST_TEST(result.use_count() == 1);
-        BOOST_TEST(boost::alignment::is_aligned(result.get(),
-            boost::alignment_of<int>::value));
-        BOOST_TEST(result[0][0] == 0);
-        BOOST_TEST(result[0][1] == 0);
-        BOOST_TEST(result[1][0] == 0);
-        BOOST_TEST(result[1][1] == 0);
-    }
-    {
-        boost::shared_ptr<type[]> result =
-            boost::allocate_shared<type[]>(creator<type>(), 3);
-        BOOST_TEST(result.get() != 0);
-        BOOST_TEST(result.use_count() == 1);
-        BOOST_TEST(boost::alignment::is_aligned(result.get(),
-            boost::alignment_of<type>::value));
-        BOOST_TEST(type::instances == 3);
-        boost::weak_ptr<type[]> w1 = result;
-        result.reset();
-        BOOST_TEST(type::instances == 0);
-    }
-    {
-        boost::shared_ptr<type[3]> result =
-            boost::allocate_shared<type[3]>(creator<type>());
-        BOOST_TEST(result.get() != 0);
-        BOOST_TEST(result.use_count() == 1);
-        BOOST_TEST(boost::alignment::is_aligned(result.get(),
-            boost::alignment_of<type>::value));
-        BOOST_TEST(type::instances == 3);
-        boost::weak_ptr<type[3]> w1 = result;
-        result.reset();
-        BOOST_TEST(type::instances == 0);
-    }
-    {
-        boost::shared_ptr<type[][2]> result =
-            boost::allocate_shared<type[][2]>(creator<type>(), 2);
-        BOOST_TEST(result.get() != 0);
-        BOOST_TEST(result.use_count() == 1);
-        BOOST_TEST(boost::alignment::is_aligned(result.get(),
-            boost::alignment_of<type>::value));
-        BOOST_TEST(type::instances == 4);
-        result.reset();
-        BOOST_TEST(type::instances == 0);
-    }
-    {
-        boost::shared_ptr<type[2][2]> result =
-            boost::allocate_shared<type[2][2]>(creator<type>());
-        BOOST_TEST(result.get() != 0);
-        BOOST_TEST(result.use_count() == 1);
-        BOOST_TEST(boost::alignment::is_aligned(result.get(),
-            boost::alignment_of<type>::value));
-        BOOST_TEST(type::instances == 4);
-        result.reset();
-        BOOST_TEST(type::instances == 0);
-    }
-    {
-        boost::shared_ptr<const type[]> result =
-            boost::allocate_shared<const type[]>(creator<type>(), 3);
-        BOOST_TEST(result.get() != 0);
-        BOOST_TEST(result.use_count() == 1);
-        BOOST_TEST(boost::alignment::is_aligned(result.get(),
-            boost::alignment_of<type>::value));
-        BOOST_TEST(type::instances == 3);
-        result.reset();
-        BOOST_TEST(type::instances == 0);
-    }
-    {
-        boost::shared_ptr<const type[3]> result =
-            boost::allocate_shared<const type[3]>(creator<type>());
-        BOOST_TEST(result.get() != 0);
-        BOOST_TEST(result.use_count() == 1);
-        BOOST_TEST(boost::alignment::is_aligned(result.get(),
-            boost::alignment_of<type>::value));
-        BOOST_TEST(type::instances == 3);
-        result.reset();
-        BOOST_TEST(type::instances == 0);
-    }
-    {
-        boost::shared_ptr<const type[][2]> result =
-            boost::allocate_shared<const type[][2]>(creator<type>(), 2);
-        BOOST_TEST(result.get() != 0);
-        BOOST_TEST(result.use_count() == 1);
-        BOOST_TEST(boost::alignment::is_aligned(result.get(),
-            boost::alignment_of<type>::value));
-        BOOST_TEST(type::instances == 4);
-        result.reset();
-        BOOST_TEST(type::instances == 0);
-    }
-    {
-        boost::shared_ptr<const type[2][2]> result =
-            boost::allocate_shared<const type[2][2]>(creator<type>());
-        BOOST_TEST(result.get() != 0);
-        BOOST_TEST(result.use_count() == 1);
-        BOOST_TEST(boost::alignment::is_aligned(result.get(),
-            boost::alignment_of<type>::value));
-        BOOST_TEST(type::instances == 4);
-        result.reset();
-        BOOST_TEST(type::instances == 0);
-    }
-    return boost::report_errors();
-}

test/allocate_shared_array_throws_test.cpp

@@ -1,121 +0,0 @@
-/*
-Copyright 2012-2015 Glen Joseph Fernandes
-(glenjofe@gmail.com)
-
-Distributed under the Boost Software License, Version 1.0.
-(http://www.boost.org/LICENSE_1_0.txt)
-*/
-#include <boost/core/lightweight_test.hpp>
-#include <boost/smart_ptr/make_shared.hpp>
-
-template<class T>
-struct creator {
-    typedef T value_type;
-
-    template<class U>
-    struct rebind {
-        typedef creator<U> other;
-    };
-
-    creator() { }
-
-    template<class U>
-    creator(const creator<U>&) { }
-
-    T* allocate(std::size_t size) {
-        return static_cast<T*>(::operator new(sizeof(T) * size));
-    }
-
-    void deallocate(T* ptr, std::size_t) {
-        ::operator delete(ptr);
-    }
-};
-
-template<class T, class U>
-inline bool
-operator==(const creator<T>&, const creator<U>&)
-{
-    return true;
-}
-
-template<class T, class U>
-inline bool
-operator!=(const creator<T>&, const creator<U>&)
-{
-    return false;
-}
-
-class type {
-public:
-    static unsigned instances;
-
-    type() {
-        if (instances == 5) {
-            throw true;
-        }
-        ++instances;
-    }
-
-    ~type() {
-        --instances;
-    }
-
-private:
-    type(const type&);
-    type& operator=(const type&);
-};
-
-unsigned type::instances = 0;
-
-int main()
-{
-    try {
-        boost::allocate_shared<type[]>(creator<type>(), 6);
-        BOOST_ERROR("allocate_shared did not throw");
-    } catch (...) {
-        BOOST_TEST(type::instances == 0);
-    }
-    try {
-        boost::allocate_shared<type[][2]>(creator<type>(), 3);
-        BOOST_ERROR("allocate_shared did not throw");
-    } catch (...) {
-        BOOST_TEST(type::instances == 0);
-    }
-    try {
-        boost::allocate_shared<type[6]>(creator<type>());
-        BOOST_ERROR("allocate_shared did not throw");
-    } catch (...) {
-        BOOST_TEST(type::instances == 0);
-    }
-    try {
-        boost::allocate_shared<type[3][2]>(creator<type>());
-        BOOST_ERROR("allocate_shared did not throw");
-    } catch (...) {
-        BOOST_TEST(type::instances == 0);
-    }
-    try {
-        boost::allocate_shared_noinit<type[]>(creator<type>(), 6);
-        BOOST_ERROR("allocate_shared_noinit did not throw");
-    } catch (...) {
-        BOOST_TEST(type::instances == 0);
-    }
-    try {
-        boost::allocate_shared_noinit<type[][2]>(creator<type>(), 3);
-        BOOST_ERROR("allocate_shared_noinit did not throw");
-    } catch (...) {
-        BOOST_TEST(type::instances == 0);
-    }
-    try {
-        boost::allocate_shared_noinit<type[6]>(creator<type>());
-        BOOST_ERROR("allocate_shared_noinit did not throw");
-    } catch (...) {
-        BOOST_TEST(type::instances == 0);
-    }
-    try {
-        boost::allocate_shared_noinit<type[3][2]>(creator<type>());
-        BOOST_ERROR("allocate_shared_noinit did not throw");
-    } catch (...) {
-        BOOST_TEST(type::instances == 0);
-    }
-    return boost::report_errors();
-}