Merge branch 'develop' into feature/local_shared_ptr

throw() optimizes better there with older versions of GCC in C++98.

.travis.yml

@@ -1,4 +1,4 @@
-# Copyright 2016 Peter Dimov
+# Copyright 2016, 2017 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)
 
@@ -14,6 +14,7 @@ branches:
   only:
     - master
     - develop
+    - /feature\/.*/
 
 env:
   matrix:
@@ -26,9 +27,11 @@ matrix:
 
   include:
     - os: linux
+      compiler: g++
       env: TOOLSET=gcc COMPILER=g++ CXXSTD=c++03
 
     - os: linux
+      compiler: g++-4.7
       env: TOOLSET=gcc COMPILER=g++-4.7 CXXSTD=c++03
       addons:
         apt:
@@ -38,6 +41,7 @@ matrix:
             - ubuntu-toolchain-r-test
 
     - os: linux
+      compiler: g++-4.7
       env: TOOLSET=gcc COMPILER=g++-4.7 CXXSTD=c++11
       addons:
         apt:
@@ -47,6 +51,7 @@ matrix:
             - ubuntu-toolchain-r-test
 
     - os: linux
+      compiler: g++-4.8
       env: TOOLSET=gcc COMPILER=g++-4.8 CXXSTD=c++03
       addons:
         apt:
@@ -56,6 +61,7 @@ matrix:
             - ubuntu-toolchain-r-test
 
     - os: linux
+      compiler: g++-4.8
       env: TOOLSET=gcc COMPILER=g++-4.8 CXXSTD=c++11
       addons:
         apt:
@@ -65,6 +71,7 @@ matrix:
             - ubuntu-toolchain-r-test
 
     - os: linux
+      compiler: g++-4.9
       env: TOOLSET=gcc COMPILER=g++-4.9 CXXSTD=c++03
       addons:
         apt:
@@ -74,6 +81,7 @@ matrix:
             - ubuntu-toolchain-r-test
 
     - os: linux
+      compiler: g++-4.9
       env: TOOLSET=gcc COMPILER=g++-4.9 CXXSTD=c++11
       addons:
         apt:
@@ -83,6 +91,7 @@ matrix:
             - ubuntu-toolchain-r-test
 
     - os: linux
+      compiler: g++-5
       env: TOOLSET=gcc COMPILER=g++-5 CXXSTD=c++03
       addons:
         apt:
@@ -92,6 +101,7 @@ matrix:
             - ubuntu-toolchain-r-test
 
     - os: linux
+      compiler: g++-5
       env: TOOLSET=gcc COMPILER=g++-5 CXXSTD=c++11
       addons:
         apt:
@@ -101,6 +111,7 @@ matrix:
             - ubuntu-toolchain-r-test
 
     - os: linux
+      compiler: g++-5
       env: TOOLSET=gcc COMPILER=g++-5 CXXSTD=c++14
       addons:
         apt:
@@ -110,6 +121,17 @@ matrix:
             - ubuntu-toolchain-r-test
 
     - os: linux
+      compiler: g++-5
+      env: TOOLSET=gcc COMPILER=g++-5 CXXSTD=c++1z
+      addons:
+        apt:
+          packages:
+            - g++-5
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: g++-6
       env: TOOLSET=gcc COMPILER=g++-6 CXXSTD=c++03
       addons:
         apt:
@@ -119,6 +141,7 @@ matrix:
             - ubuntu-toolchain-r-test
 
     - os: linux
+      compiler: g++-6
       env: TOOLSET=gcc COMPILER=g++-6 CXXSTD=c++11
       addons:
         apt:
@@ -128,6 +151,7 @@ matrix:
             - ubuntu-toolchain-r-test
 
     - os: linux
+      compiler: g++-6
       env: TOOLSET=gcc COMPILER=g++-6 CXXSTD=c++14
       addons:
         apt:
@@ -137,6 +161,7 @@ matrix:
             - ubuntu-toolchain-r-test
 
     - os: linux
+      compiler: g++-6
       env: TOOLSET=gcc COMPILER=g++-6 CXXSTD=c++1z
       addons:
         apt:
@@ -146,12 +171,103 @@ matrix:
             - ubuntu-toolchain-r-test
 
     - os: linux
+      dist: trusty
+      compiler: g++-7
+      env: TOOLSET=gcc COMPILER=g++-7 CXXSTD=c++03
+      addons:
+        apt:
+          packages:
+            - g++-7
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      dist: trusty
+      compiler: g++-7
+      env: TOOLSET=gcc COMPILER=g++-7 CXXSTD=c++11
+      addons:
+        apt:
+          packages:
+            - g++-7
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      dist: trusty
+      compiler: g++-7
+      env: TOOLSET=gcc COMPILER=g++-7 CXXSTD=c++14
+      addons:
+        apt:
+          packages:
+            - g++-7
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      dist: trusty
+      compiler: g++-7
+      env: TOOLSET=gcc COMPILER=g++-7 CXXSTD=c++17
+      addons:
+        apt:
+          packages:
+            - g++-7
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: clang++
       env: TOOLSET=clang COMPILER=clang++ CXXSTD=c++03
 
     - os: linux
+      compiler: clang++
       env: TOOLSET=clang COMPILER=clang++ CXXSTD=c++11
 
     - os: linux
+      compiler: clang++-3.5
+      env: TOOLSET=clang COMPILER=clang++-3.5 CXXSTD=c++03
+      addons:
+        apt:
+          packages:
+            - clang-3.5
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-precise-3.5
+
+    - os: linux
+      compiler: clang++-3.5
+      env: TOOLSET=clang COMPILER=clang++-3.5 CXXSTD=c++11
+      addons:
+        apt:
+          packages:
+            - clang-3.5
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-precise-3.5
+
+    - os: linux
+      compiler: clang++-3.5
+      env: TOOLSET=clang COMPILER=clang++-3.5 CXXSTD=c++14
+      addons:
+        apt:
+          packages:
+            - clang-3.5
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-precise-3.5
+
+    - os: linux
+      compiler: clang++-3.5
+      env: TOOLSET=clang COMPILER=clang++-3.5 CXXSTD=c++1z
+      addons:
+        apt:
+          packages:
+            - clang-3.5
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-precise-3.5
+
+    - os: linux
+      compiler: clang++-3.6
       env: TOOLSET=clang COMPILER=clang++-3.6 CXXSTD=c++03
       addons:
         apt:
@@ -162,6 +278,7 @@ matrix:
             - llvm-toolchain-precise-3.6
 
     - os: linux
+      compiler: clang++-3.6
       env: TOOLSET=clang COMPILER=clang++-3.6 CXXSTD=c++11
       addons:
         apt:
@@ -172,6 +289,29 @@ matrix:
             - llvm-toolchain-precise-3.6
 
     - os: linux
+      compiler: clang++-3.6
+      env: TOOLSET=clang COMPILER=clang++-3.6 CXXSTD=c++14
+      addons:
+        apt:
+          packages:
+            - clang-3.6
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-precise-3.6
+
+    - os: linux
+      compiler: clang++-3.6
+      env: TOOLSET=clang COMPILER=clang++-3.6 CXXSTD=c++1z
+      addons:
+        apt:
+          packages:
+            - clang-3.6
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-precise-3.6
+
+    - os: linux
+      compiler: clang++-3.7
       env: TOOLSET=clang COMPILER=clang++-3.7 CXXSTD=c++03
       addons:
         apt:
@@ -182,6 +322,7 @@ matrix:
             - llvm-toolchain-precise-3.7
 
     - os: linux
+      compiler: clang++-3.7
       env: TOOLSET=clang COMPILER=clang++-3.7 CXXSTD=c++11
       addons:
         apt:
@@ -192,6 +333,29 @@ matrix:
             - llvm-toolchain-precise-3.7
 
     - os: linux
+      compiler: clang++-3.7
+      env: TOOLSET=clang COMPILER=clang++-3.7 CXXSTD=c++14
+      addons:
+        apt:
+          packages:
+            - clang-3.7
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-precise-3.7
+
+    - os: linux
+      compiler: clang++-3.7
+      env: TOOLSET=clang COMPILER=clang++-3.7 CXXSTD=c++1z
+      addons:
+        apt:
+          packages:
+            - clang-3.7
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-precise-3.7
+
+    - os: linux
+      compiler: clang++-3.8
       env: TOOLSET=clang COMPILER=clang++-3.8 CXXSTD=c++03
       addons:
         apt:
@@ -202,6 +366,7 @@ matrix:
             - llvm-toolchain-precise-3.8
 
     - os: linux
+      compiler: clang++-3.8
       env: TOOLSET=clang COMPILER=clang++-3.8 CXXSTD=c++11
       addons:
         apt:
@@ -212,6 +377,7 @@ matrix:
             - llvm-toolchain-precise-3.8
 
     - os: linux
+      compiler: clang++-3.8
       env: TOOLSET=clang COMPILER=clang++-3.8 CXXSTD=c++14
       addons:
         apt:
@@ -222,6 +388,7 @@ matrix:
             - llvm-toolchain-precise-3.8
 
     - os: linux
+      compiler: clang++-3.8
       env: TOOLSET=clang COMPILER=clang++-3.8 CXXSTD=c++1z
       addons:
         apt:
@@ -231,18 +398,114 @@ matrix:
             - ubuntu-toolchain-r-test
             - llvm-toolchain-precise-3.8
 
+    - os: linux
+      compiler: clang++-3.9
+      env: TOOLSET=clang COMPILER=clang++-3.9 CXXSTD=c++03
+      addons:
+        apt:
+          packages:
+            - clang-3.9
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-precise-3.9
+
+    - os: linux
+      compiler: clang++-3.9
+      env: TOOLSET=clang COMPILER=clang++-3.9 CXXSTD=c++11
+      addons:
+        apt:
+          packages:
+            - clang-3.9
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-precise-3.9
+
+    - os: linux
+      compiler: clang++-3.9
+      env: TOOLSET=clang COMPILER=clang++-3.9 CXXSTD=c++14
+      addons:
+        apt:
+          packages:
+            - clang-3.9
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-precise-3.9
+
+    - os: linux
+      compiler: clang++-3.9
+      env: TOOLSET=clang COMPILER=clang++-3.9 CXXSTD=c++1z
+      addons:
+        apt:
+          packages:
+            - clang-3.9
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-precise-3.9
+
+    - os: linux
+      compiler: clang++-4.0
+      env: TOOLSET=clang COMPILER=clang++-4.0 CXXSTD=c++03
+      addons:
+        apt:
+          packages:
+            - clang-4.0
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-trusty-4.0
+
+    - os: linux
+      compiler: clang++-4.0
+      env: TOOLSET=clang COMPILER=clang++-4.0 CXXSTD=c++11
+      addons:
+        apt:
+          packages:
+            - clang-4.0
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-trusty-4.0
+
+    - os: linux
+      compiler: clang++-4.0
+      env: TOOLSET=clang COMPILER=clang++-4.0 CXXSTD=c++14
+      addons:
+        apt:
+          packages:
+            - clang-4.0
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-trusty-4.0
+
+    - os: linux
+      compiler: clang++-4.0
+      env: TOOLSET=clang COMPILER=clang++-4.0 CXXSTD=c++1z
+      addons:
+        apt:
+          packages:
+            - clang-4.0
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-trusty-4.0
+
     - os: osx
+      compiler: clang++
       env: TOOLSET=clang COMPILER=clang++ CXXSTD=c++03
 
     - os: osx
+      compiler: clang++
       env: TOOLSET=clang COMPILER=clang++ CXXSTD=c++11
 
     - os: osx
+      compiler: clang++
       env: TOOLSET=clang COMPILER=clang++ CXXSTD=c++14
 
+    - os: osx
+      compiler: clang++
+      env: TOOLSET=clang COMPILER=clang++ CXXSTD=c++1z
+
 install:
+  - BOOST_BRANCH=develop && [ "$TRAVIS_BRANCH" == "master" ] && BOOST_BRANCH=master || true
   - cd ..
-  - git clone -b $TRAVIS_BRANCH https://github.com/boostorg/boost.git boost-root
+  - git clone -b $BOOST_BRANCH https://github.com/boostorg/boost.git boost-root
   - cd boost-root
   - git submodule init libs/align
   - git submodule init libs/assert

appveyor.yml

@@ -1,4 +1,4 @@
-# Copyright 2016 Peter Dimov
+# Copyright 2016, 2017 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)
 
@@ -10,10 +10,28 @@ branches:
   only:
     - master
     - develop
+    - /feature\/.*/
+
+environment:
+  matrix:
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
+      TOOLSET: msvc-9.0
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
+      TOOLSET: msvc-10.0
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
+      TOOLSET: msvc-11.0
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
+      TOOLSET: msvc-12.0
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
+      TOOLSET: msvc-14.0
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
+      TOOLSET: msvc-14.1
 
 install:
+  - set BOOST_BRANCH=develop
+  - if "%APPVEYOR_REPO_BRANCH%" == "master" set BOOST_BRANCH=master
   - cd ..
-  - git clone -b %APPVEYOR_REPO_BRANCH% https://github.com/boostorg/boost.git boost-root
+  - git clone -b %BOOST_BRANCH% https://github.com/boostorg/boost.git boost-root
   - cd boost-root
   - git submodule init libs/align
   - git submodule init libs/assert
@@ -38,4 +56,4 @@ install:
 build: off
 
 test_script:
-  - b2 libs/smart_ptr/test toolset=msvc-9.0,msvc-10.0,msvc-11.0,msvc-14.0
+  - b2 libs/smart_ptr/test toolset=%TOOLSET%

compatibility.htm

@@ -1,88 +0,0 @@
-<!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>
-        <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 
-            point of view.</p>
-        <p>Note that for compilers that don't support member templates well enough, a 
-            separate implementation is used that lacks many of the new features and is more 
-            like the old version.</p>
-        <h2>Features Requiring Code Changes to Take Advantage</h2>
-        <ul>
-            <li>
-                The smart pointer class templates now each have their own header file. For 
-                compatibility, the <a href="../../boost/smart_ptr.hpp">&lt;boost/smart_ptr.hpp&gt;</a>
-            header now includes the headers for the four classic smart pointer class 
-            templates.
-            <li>
-                The <b>weak_ptr</b>
-            template was added.
-            <li>
-                The new <b>shared_ptr</b> and <b>shared_array</b> relax the requirement that 
-                the pointed-to object's destructor must be visible when instantiating the <b>shared_ptr</b>
-            destructor. This makes it easier to have shared_ptr members in classes without 
-            explicit destructors.
-            <li>
-                A custom deallocator can be passed in when creating a <b>shared_ptr</b> or <b>shared_array</b>.
-            <li>
-                <b>shared_static_cast</b> and <b>shared_dynamic_cast</b> function templates are 
-                provided which work for <b>shared_ptr</b> and <b>weak_ptr</b> as <b>static_cast</b>
-                and <b>dynamic_cast</b>
-            do for pointers.
-            <li>
-                The self-assignment misfeature has been removed from <b>shared_ptr::reset</b>, 
-                although it is still present in <b>scoped_ptr</b>, and in <b>std::auto_ptr</b>. 
-                Calling <b>reset</b> with a pointer to the object that's already owned by the <b>shared_ptr</b>
-            results in undefined behavior (an assertion, or eventually a double-delete if 
-            assertions are off).
-            <li>
-                The <b>BOOST_SMART_PTR_CONVERSION</b>
-            feature has been removed.
-            <li>
-                <b>shared_ptr&lt;void&gt;</b> is now allowed.</li>
-        </ul>
-        <h2>Features That Improve Robustness</h2>
-        <ul>
-            <li>
-                The manipulation of use counts is now <a name="threadsafe">thread safe</a> on 
-                Windows, Linux, and platforms that support pthreads. See the <a href="../../boost/detail/atomic_count.hpp">
-                    &lt;boost/detail/atomic_count.hpp&gt;</a>
-            file for details
-            <li>
-                The new shared_ptr will always delete the object using the pointer it was 
-                originally constructed with. This prevents subtle problems that could happen if 
-                the last <b>shared_ptr</b> was a pointer to a sub-object of a class that did 
-                not have a virtual destructor.</li>
-        </ul>
-        <h2>Implementation Details</h2>
-        <ul>
-            <li>
-                Some bugs in the assignment operator implementations and in <b>reset</b>
-            have been fixed by using the "copy and swap" idiom.
-            <li>
-                Assertions have been added to check preconditions of various functions; 
-                however, since these use the new <a href="../../boost/assert.hpp">&lt;boost/assert.hpp&gt;</a>
-            header, the assertions are disabled by default.
-            <li>
-                The partial specialization of <b>std::less</b> has been replaced by <b>operator&lt;</b>
-            overloads which accomplish the same thing without relying on undefined 
-            behavior.
-            <li>
-                The incorrect overload of <b>std::swap</b> has been replaced by <b>boost::swap</b>, 
-                which has many of the same advantages for generic programming but does not 
-                violate the C++ standard.</li>
-        </ul>
-        <hr>
-        <p>$Date$</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>
-    </body>
-</html>

doc/.gitignore

@@ -0,0 +1,2 @@
+/html/
+/pdf/

doc/Jamfile

@@ -0,0 +1,26 @@
+# Copyright 2017 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
+
+project doc/smart_ptr ;
+
+import asciidoctor ;
+
+html smart_ptr.html : smart_ptr.adoc ;
+
+install html_ : smart_ptr.html : <location>html ;
+
+pdf smart_ptr.pdf : smart_ptr.adoc ;
+explicit smart_ptr.pdf ;
+
+install pdf_ : smart_ptr.pdf : <location>pdf ;
+explicit pdf_ ;
+
+###############################################################################
+alias boostdoc ;
+explicit boostdoc ;
+alias boostrelease : html_ ;
+explicit boostrelease ;

doc/asciidoctor.jam

@@ -0,0 +1,50 @@
+# Copyright 2017 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)
+
+import type ;
+import scanner ;
+import generators ;
+import boostbook ;
+
+# File type
+
+type.register ASCIIDOC : asciidoc adoc ;
+
+# Define dependency scanner
+
+class asciidoc-scanner : common-scanner
+{
+    rule pattern ( )
+    {
+        return "include::([^[]+)\\[" ;
+    }
+}
+
+scanner.register asciidoc-scanner : include ;
+type.set-scanner ASCIIDOC : asciidoc-scanner ;
+
+# Define generators
+
+generators.register-standard asciidoctor.asciidoc-to-html : ASCIIDOC : HTML ;
+generators.register-standard asciidoctor.asciidoc-to-pdf : ASCIIDOC : PDF ;
+# generators.register-standard asciidoctor.asciidoc-to-docbook : ASCIIDOC : DOCBOOK ;
+
+# Define actions
+
+actions asciidoc-to-html
+{
+    asciidoctor -b html -o $(1) $(2)
+}
+
+actions asciidoc-to-pdf
+{
+    asciidoctor -r asciidoctor-pdf -b pdf -o $(1) $(2)
+}
+
+actions asciidoc-to-docbook
+{
+    asciidoctor -b docbook -o $(1) $(2)
+}

doc/smart_ptr-docinfo-footer.html

@@ -0,0 +1,6 @@
+<style>
+
+*:not(pre)>code { background: none; color: #600000; }
+table tr.even, table tr.alt, table tr:nth-of-type(even) { background: none; }
+
+</style>

doc/smart_ptr.adoc

@@ -0,0 +1,74 @@
+////
+Copyright 2017 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
+////
+
+# Boost.SmartPtr: The Smart Pointer Library
+Greg Colvin, Beman Dawes, Peter Dimov, Glen Fernandes
+:toc: left
+:toclevels: 2
+:idprefix:
+:listing-caption: Code Example
+:docinfo: private-footer
+
+:leveloffset: +1
+
+include::smart_ptr/introduction.adoc[]
+
+include::smart_ptr/scoped_ptr.adoc[]
+
+include::smart_ptr/scoped_array.adoc[]
+
+include::smart_ptr/shared_ptr.adoc[]
+
+include::smart_ptr/weak_ptr.adoc[]
+
+include::smart_ptr/make_shared.adoc[]
+
+include::smart_ptr/enable_shared_from_this.adoc[]
+
+include::smart_ptr/make_unique.adoc[]
+
+include::smart_ptr/intrusive_ptr.adoc[]
+
+include::smart_ptr/intrusive_ref_counter.adoc[]
+
+include::smart_ptr/local_shared_ptr.adoc[]
+
+include::smart_ptr/pointer_cast.adoc[]
+
+include::smart_ptr/pointer_to_other.adoc[]
+
+include::smart_ptr/atomic_shared_ptr.adoc[]
+
+// appendix
+include::smart_ptr/techniques.adoc[]
+
+// appendix
+include::smart_ptr/history.adoc[]
+
+// appendix, deprecated
+include::smart_ptr/shared_array.adoc[]
+
+:leveloffset: -1
+
+[[copyright]]
+[appendix]
+## Copyright and License
+
+This documentation is
+
+* Copyright 1999 Greg Colvin
+* Copyright 1999 Beman Dawes
+* Copyright 2002 Darin Adler
+* Copyright 2003-2017 Peter Dimov
+* Copyright 2005, 2006 Ion Gaztañaga
+* Copyright 2008 Frank Mori Hess
+* Copyright 2012-2017 Glen Fernandes
+* Copyright 2013 Andrey Semashev
+
+and is distributed under the http://www.boost.org/LICENSE_1_0.txt[Boost Software License, Version 1.0].

doc/smart_ptr/atomic_shared_ptr.adoc

@@ -0,0 +1,170 @@
+////
+Copyright 2017 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
+////
+
+[#atomic_shared_ptr]
+# atomic_shared_ptr
+:toc:
+:toc-title:
+:idprefix: atomic_shared_ptr_
+
+## Description
+
+The class template `atomic_shared_ptr<T>` implements the interface of `std::atomic`
+for a contained value of type `shared_ptr<T>`. Concurrent access to `atomic_shared_ptr`
+is not a data race.
+
+## Synopsis
+
+`atomic_shared_ptr` is defined in `<boost/smart_ptr/atomic_shared_ptr.hpp>`.
+
+```
+namespace boost {
+
+  template<class T> class atomic_shared_ptr {
+  private:
+
+    shared_ptr<T> p_; // exposition only
+
+    atomic_shared_ptr(const atomic_shared_ptr&) = delete;
+    atomic_shared_ptr& operator=(const atomic_shared_ptr&) = delete;
+
+  public:
+
+    constexpr atomic_shared_ptr() noexcept;
+    atomic_shared_ptr( shared_ptr<T> p ) noexcept;
+
+    atomic_shared_ptr& operator=( shared_ptr<T> r ) noexcept;
+
+    bool is_lock_free() const noexcept;
+
+    shared_ptr<T> load( int = 0 ) const noexcept;
+    operator shared_ptr<T>() const noexcept;
+
+    void store( shared_ptr<T> r, int = 0 ) noexcept;
+
+    shared_ptr<T> exchange( shared_ptr<T> r, int = 0 ) noexcept;
+
+    bool compare_exchange_weak( shared_ptr<T>& v, const shared_ptr<T>& w, int, int ) noexcept;
+    bool compare_exchange_weak( shared_ptr<T>& v, const shared_ptr<T>& w, int = 0 ) noexcept;
+    bool compare_exchange_strong( shared_ptr<T>& v, const shared_ptr<T>& w, int, int ) noexcept;
+    bool compare_exchange_strong( shared_ptr<T>& v, const shared_ptr<T>& w, int = 0 ) noexcept;
+
+    bool compare_exchange_weak( shared_ptr<T>& v, shared_ptr<T>&& w, int, int ) noexcept;
+    bool compare_exchange_weak( shared_ptr<T>& v, shared_ptr<T>&& w, int = 0 ) noexcept;
+    bool compare_exchange_strong( shared_ptr<T>& v, shared_ptr<T>&& w, int, int ) noexcept;
+    bool compare_exchange_strong( shared_ptr<T>& v, shared_ptr<T>&& w, int = 0 ) noexcept;
+  };
+}
+```
+
+## Members
+
+```
+constexpr atomic_shared_ptr() noexcept;
+```
+[none]
+* {blank}
++
+Effects:: Default-initializes `p_`.
+
+```
+atomic_shared_ptr( shared_ptr<T> p ) noexcept;
+```
+[none]
+* {blank}
++
+Effects:: Initializes `p_` to `p`.
+
+```
+atomic_shared_ptr& operator=( shared_ptr<T> r ) noexcept;
+```
+[none]
+* {blank}
++
+Effects:: `p_.swap(r)`.
+Returns:: `*this`.
+
+```
+bool is_lock_free() const noexcept;
+```
+[none]
+* {blank}
++
+Returns:: `false`.
+
+NOTE: This implementation is not lock-free.
+
+```
+shared_ptr<T> load( int = 0 ) const noexcept;
+```
+```
+operator shared_ptr<T>() const noexcept;
+```
+[none]
+* {blank}
++
+Returns:: `p_`.
+
+NOTE: The `int` argument is intended to be of type `memory_order`, but is ignored.
+  This implementation is lock-based and therefore always sequentially consistent.
+
+```
+void store( shared_ptr<T> r, int = 0 ) noexcept;
+```
+[none]
+* {blank}
++
+Effects:: `p_.swap(r)`.
+
+```
+shared_ptr<T> exchange( shared_ptr<T> r, int = 0 ) noexcept;
+```
+[none]
+* {blank}
++
+Effects:: `p_.swap(r)`.
+Returns:: The old value of `p_`.
+
+```
+bool compare_exchange_weak( shared_ptr<T>& v, const shared_ptr<T>& w, int, int ) noexcept;
+```
+```
+bool compare_exchange_weak( shared_ptr<T>& v, const shared_ptr<T>& w, int = 0 ) noexcept;
+```
+```
+bool compare_exchange_strong( shared_ptr<T>& v, const shared_ptr<T>& w, int, int ) noexcept;
+```
+```
+bool compare_exchange_strong( shared_ptr<T>& v, const shared_ptr<T>& w, int = 0 ) noexcept;
+```
+[none]
+* {blank}
++
+Effects:: If `p_` is equivalent to `v`, assigns `w` to `p_`, otherwise assigns `p_` to `v`.
+Returns:: `true` if `p_` was equivalent to `v`, `false` otherwise.
+Remarks:: Two `shared_ptr` instances are equivalent if they store the same pointer value and _share ownership_.
+
+```
+bool compare_exchange_weak( shared_ptr<T>& v, shared_ptr<T>&& w, int, int ) noexcept;
+```
+```
+bool compare_exchange_weak( shared_ptr<T>& v, shared_ptr<T>&& w, int = 0 ) noexcept;
+```
+```
+bool compare_exchange_strong( shared_ptr<T>& v, shared_ptr<T>&& w, int, int ) noexcept;
+```
+```
+bool compare_exchange_strong( shared_ptr<T>& v, shared_ptr<T>&& w, int = 0 ) noexcept;
+```
+[none]
+* {blank}
++
+Effects:: If `p_` is equivalent to `v`, assigns `std::move(w)` to `p_`, otherwise assigns `p_` to `v`.
+Returns:: `true` if `p_` was equivalent to `v`, `false` otherwise.
+Remarks:: The old value of `w` is not preserved in either case.

doc/smart_ptr/enable_shared_from_this.adoc

@@ -0,0 +1,144 @@
+////
+Copyright 2002, 2003, 2015, 2017 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
+////
+
+[#enable_shared_from_this]
+# enable_shared_from_this
+:toc:
+:toc-title:
+:idprefix: enable_shared_from_this_
+
+## Description
+
+The class template `enable_shared_from_this` is used as a base class that allows
+a `shared_ptr` or a `weak_ptr` to the current object to be obtained from within a
+member function.
+
+`enable_shared_from_this<T>` defines two member functions called `shared_from_this`
+that return a `shared_ptr<T>` and `shared_ptr<T const>`, depending on constness, to
+`this`. It also defines two member functions called `weak_from_this` that return a
+corresponding `weak_ptr`.
+
+## Example
+
+```
+#include <boost/enable_shared_from_this.hpp>
+#include <boost/shared_ptr.hpp>
+#include <cassert>
+
+class Y: public boost::enable_shared_from_this<Y>
+{
+public:
+
+    boost::shared_ptr<Y> f()
+    {
+        return shared_from_this();
+    }
+};
+
+int main()
+{
+    boost::shared_ptr<Y> p(new Y);
+    boost::shared_ptr<Y> q = p->f();
+    assert(p == q);
+    assert(!(p < q || q < p)); // p and q must share ownership
+}
+```
+
+## Synopsis
+
+`enable_shared_from_this` is defined in `<boost/smart_ptr/enable_shared_from_this.hpp>`.
+
+```
+namespace boost {
+
+  template<class T> class enable_shared_from_this {
+  private:
+
+    // exposition only
+    weak_ptr<T> weak_this_;
+
+  protected:
+
+    enable_shared_from_this() = default;
+    ~enable_shared_from_this() = default;
+
+    enable_shared_from_this(const enable_shared_from_this&) noexcept;
+    enable_shared_from_this& operator=(const enable_shared_from_this&) noexcept;
+
+  public:
+
+    shared_ptr<T> shared_from_this();
+    shared_ptr<T const> shared_from_this() const;
+
+    weak_ptr<T> weak_from_this() noexcept;
+    weak_ptr<T const> weak_from_this() const noexcept;
+  }
+}
+```
+
+## Members
+
+```
+enable_shared_from_this(enable_shared_from_this const &) noexcept;
+```
+[none]
+* {blank}
++
+Effects:: Default-constructs `weak_this_`.
+
+NOTE: `weak_this_` is _not_ copied from the argument.
+
+```
+enable_shared_from_this& operator=(enable_shared_from_this const &) noexcept;
+```
+[none]
+* {blank}
++
+Returns:: `*this`.
+
+NOTE: `weak_this_` is unchanged.
+
+```
+template<class T> shared_ptr<T> shared_from_this();
+```
+```
+template<class T> shared_ptr<T const> shared_from_this() const;
+```
+[none]
+* {blank}
++
+Returns:: `shared_ptr<T>(weak_this_)`.
+
+NOTE: These members throw `bad_weak_ptr` when `*this` is not owned by a `shared_ptr`.
+
+[NOTE]
+====
+`weak_this_` is initialized by `shared_ptr` to a copy of itself when it's constructed by a pointer to `*this`.
+For example, in the following code:
+```
+class Y: public boost::enable_shared_from_this<Y> {};
+
+int main()
+{
+    boost::shared_ptr<Y> p(new Y);
+}
+```
+the construction of `p` will automatically initialize `p\->weak_this_` to `p`.
+====
+
+```
+template<class T> weak_ptr<T> weak_from_this() noexcept;
+```
+```
+template<class T> weak_ptr<T const> weak_from_this() const noexcept;
+```
+[none]
+* {blank}
++
+Returns:: `weak_this_`.

doc/smart_ptr/history.adoc

@@ -0,0 +1,113 @@
+////
+Copyright 1999 Greg Colvin and Beman Dawes
+Copyright 2002 Darin Adler
+Copyright 2017 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
+////
+
+[[history]]
+[appendix]
+# History and Acknowledgments
+:idprefix: history_
+
+## Summer 1994
+
+Greg Colvin http://www.open-std.org/jtc1/sc22/wg21/docs/papers/1994/N0555.pdf[proposed]
+to the {cpp} Standards Committee classes named `auto_ptr` and `counted_ptr` which were very
+similar to what we now call `scoped_ptr` and `shared_ptr`. In one of the very few cases
+where the Library Working Group's recommendations were not followed by the full committee,
+`counted_ptr` was rejected and surprising transfer-of-ownership semantics were added to `auto_ptr`.
+
+## October 1998
+
+Beman Dawes proposed reviving the original semantics under the names `safe_ptr` and `counted_ptr`,
+meeting of Per Andersson, Matt Austern, Greg Colvin, Sean Corfield, Pete Becker, Nico Josuttis,
+Dietmar Kühl, Nathan Myers, Chichiang Wan and Judy Ward. During the discussion, the four new class
+names were finalized, it was decided that there was no need to exactly follow the `std::auto_ptr`
+interface, and various function signatures and semantics were finalized.
+
+Over the next three months, several implementations were considered for `shared_ptr`, and discussed
+on the http://www.boost.org/[boost.org] mailing list. The implementation questions revolved around
+the reference count which must be kept, either attached to the pointed to object, or detached elsewhere.
+Each of those variants have themselves two major variants:
+
+* Direct detached: the `shared_ptr` contains a pointer to the object, and a pointer to the count. 
+* Indirect detached: the `shared_ptr` contains a pointer to a helper object, which in turn contains a pointer to the object and the count. 
+* Embedded attached: the count is a member of the object pointed to. 
+* Placement attached: the count is attached via operator new manipulations.
+
+Each implementation technique has advantages and disadvantages. We went so far as to run various timings
+of the direct and indirect approaches, and found that at least on Intel Pentium chips there was very little
+measurable difference. Kevlin Henney provided a paper he wrote on "Counted Body Techniques." Dietmar Kühl
+suggested an elegant partial template specialization technique to allow users to choose which implementation
+they preferred, and that was also experimented with.
+
+But Greg Colvin and Jerry Schwarz argued that "parameterization will discourage users", and in the end we choose
+to supply only the direct implementation.
+
+## May 1999
+
+In April and May, 1999, Valentin Bonnard and David Abrahams made a number of suggestions resulting in numerous improvements.
+
+## September 1999
+
+Luis Coelho provided `shared_ptr::swap` and `shared_array::swap`.
+
+## November 1999
+
+Darin Adler provided `operator ==`, `operator !=`, and `std::swap` and `std::less` specializations for shared types.
+
+## May 2001
+
+Vladimir Prus suggested requiring a complete type on destruction. Refinement evolved in discussions including Dave Abrahams,
+Greg Colvin, Beman Dawes, Rainer Deyke, Peter Dimov, John Maddock, Vladimir Prus, Shankar Sai, and others.
+
+## January 2002
+
+Peter Dimov reworked all four classes, adding features, fixing bugs, splitting them into four separate headers, and adding
+`weak_ptr`.
+
+## March 2003
+
+Peter Dimov, Beman Dawes and Greg Colvin http://open-std.org/jtc1/sc22/wg21/docs/papers/2003/n1450.html[proposed] `shared_ptr`
+and `weak_ptr` for inclusion in the Standard Library via the first Library Technical Report (known as TR1). The proposal was
+accepted and eventually went on to become a part of the {cpp} standard in its 2011 iteration.
+
+## July 2007
+
+Peter Dimov and Beman Dawes http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2351.htm[proposed] a number of enhancements
+to `shared_ptr` as it was entering the working paper that eventually became the {cpp}11 standard.
+
+## November 2012
+
+Glen Fernandes provided implementations of `make_shared` and `allocate_shared` 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.
+
+Peter Dimov aided this development by extending `shared_ptr` to support arrays via the syntax `shared_ptr<T[]>` and `shared_ptr<T[N]>`.
+
+## April 2013
+
+Peter Dimov http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3640.html[proposed] the extension of `shared_ptr` to support
+arrays for inclusion into the standard, and it was accepted.
+
+## February 2014
+
+Glen Fernandes updated `make_shared` and `allocate_shared` to conform to the specification in {cpp} standard paper
+http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n3870.html[N3870], and implemented `make_unique` for arrays and objects.
+
+Peter Dimov and Glen Fernandes updated the scalar and array implementations, respectively, to resolve {cpp} standard library defect 2070.
+
+## February 2017
+
+Glen Fernandes rewrote `allocate_shared` and `make_shared` for arrays for a more optimal and more maintainable implementation.
+
+## June 2017
+
+Peter Dimov and Glen Fernandes rewrote the documentation in Asciidoc format.
+
+Peter Dimov added `atomic_shared_ptr`.

doc/smart_ptr/introduction.adoc

@@ -0,0 +1,49 @@
+////
+Copyright 1999 Greg Colvin and Beman Dawes
+Copyright 2002 Darin Adler
+Copyright 2017 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
+////
+
+[#introduction]
+# Introduction
+:idprefix: intro
+
+Smart pointers are objects which store pointers to dynamically allocated (heap) objects.
+They behave much like built-in {cpp} pointers except that they automatically delete the object
+pointed to at the appropriate time. Smart pointers are particularly useful in the face of
+exceptions as they ensure proper destruction of dynamically allocated objects. They can also be
+used to keep track of dynamically allocated objects shared by multiple owners.
+
+Conceptually, smart pointers are seen as owning the object pointed to, and thus responsible for
+deletion of the object when it is no longer needed. As such, they are examples of the "resource
+acquisition is initialization" idiom described in Bjarne Stroustrup's "The C++ Programming Language",
+3rd edition, Section 14.4, Resource Management.
+
+This library provides six smart pointer class templates:
+
+* `<<scoped_ptr,scoped_ptr>>`, used to contain ownership of a dynamically allocated object to the current scope;
+* `<<scoped_array,scoped_array>>`, which provides scoped ownership for a dynamically allocated array;
+* `<<shared_ptr,shared_ptr>>`, a versatile tool for managing shared ownership of an object or array;
+* `<<weak_ptr,weak_ptr>>`, a non-owning observer to a shared_ptr-managed object that can be promoted temporarily to shared_ptr;
+* `<<intrusive_ptr,intrusive_ptr>>`, a pointer to objects with an embedded reference count;
+* `<<local_shared_ptr,local_shared_ptr>>`, providing shared ownership within a single thread.
+
+`shared_ptr` and `weak_ptr` are part of the {cpp} standard since its 2011 iteration.
+
+In addition, the library contains the following supporting utility functions and classes:
+
+* `<<make_shared,make_shared>>`, a factory function for creating objects that returns a `shared_ptr`;
+* `<<make_unique,make_unique>>`, a factory function returning `std::unique_ptr`;
+* `<<enable_shared_from_this,enable_shared_from_this>>`, a helper base class that enables the acquisition of a `shared_ptr` pointing to `this`;
+* `<<pointer_to_other,pointer_to_other>>`, a helper trait for converting one smart pointer type to another;
+* `<<pointer_cast,static_pointer_cast>>` and companions, generic smart pointer casts;
+* `<<intrusive_ref_counter,intrusive_ref_counter>>`, a helper base class containing a reference count.
+* `<<atomic_shared_ptr,atomic_shared_ptr>>`, a helper class implementing the interface of `std::atomic` for a value of type `shared_ptr`.
+
+As a general rule, the destructor or `operator delete` for an object managed by pointers in the library
+are not allowed to throw exceptions.

doc/smart_ptr/intrusive_ptr.adoc

@@ -0,0 +1,447 @@
+////
+Copyright 2003-2005, 2013, 2017 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
+////
+
+[#intrusive_ptr]
+# intrusive_ptr: Managing Objects with Embedded Counts
+:toc:
+:toc-title:
+:idprefix: intrusive_ptr_
+
+## Description
+
+The `intrusive_ptr` class template stores a pointer to an object with an embedded reference count.
+Every new `intrusive_ptr` instance increments the reference count by using an unqualified call to the
+function `intrusive_ptr_add_ref`, passing it the pointer as an argument. Similarly, when an `intrusive_ptr`
+is destroyed, it calls `intrusive_ptr_release`; 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, `intrusive_ptr_add_ref` and `intrusive_ptr_release` should
+be defined in the namespace that corresponds to their parameter; otherwise, the definitions need to go in namespace
+`boost`. The library provides a helper base class template `<<intrusive_ref_counter,intrusive_ref_counter>>` which
+may help adding support for `intrusive_ptr` to user types.
+
+The class template is parameterized on `T`, the type of the object pointed to. `intrusive_ptr<T>` can be implicitly
+converted to `intrusive_ptr<U>` whenever `T*` can be implicitly converted to `U*`.
+
+The main reasons to use `intrusive_ptr` are:
+
+* Some existing frameworks or OSes provide objects with embedded reference counts;
+* The memory footprint of `intrusive_ptr` is the same as the corresponding raw pointer;
+* `intrusive_ptr<T>` can be constructed from an arbitrary raw pointer of type `T*`.
+
+As a general rule, if it isn't obvious whether `intrusive_ptr` better fits your needs than `shared_ptr`, try a `shared_ptr`-based design first.
+
+## Synopsis
+
+`intrusive_ptr` is defined in `<boost/smart_ptr/intrusive_ptr.hpp>`.
+
+```
+namespace boost {
+
+  template<class T> class intrusive_ptr {
+  public:
+
+    typedef T element_type;
+
+    intrusive_ptr() noexcept;
+    intrusive_ptr(T * p, bool add_ref = true);
+
+    intrusive_ptr(intrusive_ptr const & r);
+    template<class Y> intrusive_ptr(intrusive_ptr<Y> const & r);
+
+    ~intrusive_ptr();
+
+    intrusive_ptr & operator=(intrusive_ptr const & r);
+    template<class Y> intrusive_ptr & operator=(intrusive_ptr<Y> const & r);
+    intrusive_ptr & operator=(T * r);
+
+    void reset();
+    void reset(T * r);
+    void reset(T * r, bool add_ref);
+
+    T & operator*() const noexcept;
+    T * operator->() const noexcept;
+    T * get() const noexcept;
+    T * detach() noexcept;
+
+    explicit operator bool () const noexcept;
+
+    void swap(intrusive_ptr & b) noexept;
+  };
+
+  template<class T, class U>
+    bool operator==(intrusive_ptr<T> const & a, intrusive_ptr<U> const & b) noexcept;
+
+  template<class T, class U>
+    bool operator!=(intrusive_ptr<T> const & a, intrusive_ptr<U> const & b) noexcept;
+
+  template<class T, class U>
+    bool operator==(intrusive_ptr<T> const & a, U * b) noexcept;
+
+  template<class T, class U>
+    bool operator!=(intrusive_ptr<T> const & a, U * b) noexcept;
+
+  template<class T, class U>
+    bool operator==(T * a, intrusive_ptr<U> const & b) noexcept;
+
+  template<class T, class U>
+    bool operator!=(T * a, intrusive_ptr<U> const & b) noexcept;
+
+  template<class T, class U>
+    bool operator<(intrusive_ptr<T> const & a, intrusive_ptr<U> const & b) noexcept;
+
+  template<class T> void swap(intrusive_ptr<T> & a, intrusive_ptr<T> & b) noexcept;
+
+  template<class T> T * get_pointer(intrusive_ptr<T> const & p) noexcept;
+
+  template<class T, class U>
+    intrusive_ptr<T> static_pointer_cast(intrusive_ptr<U> const & r) noexcept;
+
+  template<class T, class U>
+    intrusive_ptr<T> const_pointer_cast(intrusive_ptr<U> const & r) noexcept;
+
+  template<class T, class U>
+    intrusive_ptr<T> dynamic_pointer_cast(intrusive_ptr<U> const & r) noexcept;
+
+  template<class E, class T, class Y>
+    std::basic_ostream<E, T> & operator<< (std::basic_ostream<E, T> & os,
+      intrusive_ptr<Y> const & p);
+}
+```
+
+## Members
+
+### element_type
+
+```
+typedef T element_type;
+```
+
+Provides the type of the template parameter T.
+
+### constructors
+
+```
+intrusive_ptr() noexcept;
+```
+
+[none]
+* {blank}
++
+Postconditions:: `get() == 0`.
+
+```
+intrusive_ptr(T * p, bool add_ref = true);
+```
+
+[none]
+* {blank}
++
+Effects:: `if(p != 0 && add_ref) intrusive_ptr_add_ref(p);`.
+Postconditions:: `get() == p`.
+
+```
+intrusive_ptr(intrusive_ptr const & r);
+```
+```
+template<class Y> intrusive_ptr(intrusive_ptr<Y> const & r);
+```
+
+[none]
+* {blank}
++
+Effects:: `if(r.get() != 0) intrusive_ptr_add_ref(r.get());`.
+Postconditions:: `get() == r.get()`.
+
+### destructor
+
+```
+~intrusive_ptr();
+```
+
+[none]
+* {blank}
++
+Effects:: `if(get() != 0) intrusive_ptr_release(get());`.
+
+### assignment
+
+```
+intrusive_ptr & operator=(intrusive_ptr const & r);
+```
+```
+template<class Y> intrusive_ptr & operator=(intrusive_ptr<Y> const & r);
+```
+```
+intrusive_ptr & operator=(T * r);
+```
+
+[none]
+* {blank}
++
+Effects:: Equivalent to `intrusive_ptr(r).swap(*this)`.
+Returns:: `*this`.
+
+### reset
+
+```
+void reset();
+```
+
+[none]
+* {blank}
++
+Effects:: Equivalent to `intrusive_ptr().swap(*this)`.
+
+```
+void reset(T * r);
+```
+
+[none]
+* {blank}
++
+Effects:: Equivalent to `intrusive_ptr(r).swap(*this)`.
+
+```
+void reset(T * r, bool add_ref);
+```
+
+[none]
+* {blank}
++
+Effects:: Equivalent to `intrusive_ptr(r, add_ref).swap(*this)`.
+
+### indirection
+
+```
+T & operator*() const noexcept;
+```
+
+[none]
+* {blank}
++
+Requirements:: `get() != 0`.
+Returns:: `*get()`.
+
+```
+T * operator->() const noexcept;
+```
+
+[none]
+* {blank}
++
+Requirements:: `get() != 0`.
+Returns:: `get()`.
+
+### get
+
+```
+T * get() const noexcept;
+```
+
+[none]
+* {blank}
++
+Returns:: the stored pointer.
+
+### detach
+
+```
+T * detach() noexcept;
+```
+
+[none]
+* {blank}
++
+Returns:: the stored pointer.
+Postconditions:: `get() == 0`.
+
+NOTE: The returned pointer has an elevated reference count. This allows conversion of an `intrusive_ptr`
+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.
+
+CAUTION: Using `detach` escapes the safety of automatic reference counting provided by `intrusive_ptr`.
+It should by used only where strictly necessary (such as when interfacing to an existing API), and when
+the implications are thoroughly understood.
+
+### conversions
+
+```
+explicit operator bool () const noexcept;
+```
+
+[none]
+* {blank}
++
+Returns:: `get() != 0`.
+
+NOTE: This conversion operator allows `intrusive_ptr` objects to be used in boolean contexts,
+like `if (p && p\->valid()) {}`.
+
+NOTE: On C++03 compilers, the return value is of an unspecified type.
+
+### swap
+
+```
+void swap(intrusive_ptr & b) noexcept;
+```
+
+[none]
+* {blank}
++
+Effects:: Exchanges the contents of the two smart pointers.
+
+## Free Functions
+
+### comparison
+
+```
+template<class T, class U>
+  bool operator==(intrusive_ptr<T> const & a, intrusive_ptr<U> const & b) noexcept;
+```
+
+[none]
+* {blank}
++
+Returns:: `a.get() == b.get()`.
+
+```
+template<class T, class U>
+  bool operator!=(intrusive_ptr<T> const & a, intrusive_ptr<U> const & b) noexcept;
+```
+
+[none]
+* {blank}
++
+Returns:: `a.get() != b.get()`.
+
+```
+template<class T, class U>
+  bool operator==(intrusive_ptr<T> const & a, U * b) noexcept;
+```
+
+[none]
+* {blank}
++
+Returns:: `a.get() == b`.
+
+```
+template<class T, class U>
+  bool operator!=(intrusive_ptr<T> const & a, U * b) noexcept;
+```
+
+[none]
+* {blank}
++
+Returns:: `a.get() != b`.
+
+```
+template<class T, class U>
+  bool operator==(T * a, intrusive_ptr<U> const & b) noexcept;
+```
+
+[none]
+* {blank}
++
+Returns:: `a == b.get()`.
+
+```
+template<class T, class U>
+  bool operator!=(T * a, intrusive_ptr<U> const & b) noexcept;
+```
+
+[none]
+* {blank}
++
+Returns:: `a != b.get()`.
+
+```
+template<class T, class U>
+  bool operator<(intrusive_ptr<T> const & a, intrusive_ptr<U> const & b) noexcept;
+```
+
+[none]
+* {blank}
++
+Returns:: `std::less<T *>()(a.get(), b.get())`.
+
+NOTE: Allows `intrusive_ptr` objects to be used as keys in associative containers.
+
+### swap
+
+```
+template<class T> void swap(intrusive_ptr<T> & a, intrusive_ptr<T> & b) noexcept;
+```
+
+[none]
+* {blank}
++
+Effects:: Equivalent to `a.swap(b)`.
+
+### get_pointer
+
+```
+template<class T> T * get_pointer(intrusive_ptr<T> const & p) noexcept;
+```
+
+[none]
+* {blank}
++
+Returns:: `p.get()`.
+
+NOTE: Provided as an aid to generic programming. Used by `mem_fn`.
+
+### static_pointer_cast
+
+```
+template<class T, class U>
+  intrusive_ptr<T> static_pointer_cast(intrusive_ptr<U> const & r) noexcept;
+```
+
+[none]
+* {blank}
++
+Returns:: `intrusive_ptr<T>(static_cast<T*>(r.get()))`.
+
+### const_pointer_cast
+
+```
+template<class T, class U>
+  intrusive_ptr<T> const_pointer_cast(intrusive_ptr<U> const & r) noexcept;
+```
+
+[none]
+* {blank}
++
+Returns:: `intrusive_ptr<T>(const_cast<T*>(r.get()))`.
+
+### dynamic_pointer_cast
+
+```
+template<class T, class U>
+  intrusive_ptr<T> dynamic_pointer_cast(intrusive_ptr<U> const & r) noexcept;
+```
+
+[none]
+* {blank}
++
+Returns:: `intrusive_ptr<T>(dynamic_cast<T*>(r.get()))`.
+
+### operator<<
+
+```
+template<class E, class T, class Y>
+  std::basic_ostream<E, T> & operator<< (std::basic_ostream<E, T> & os,
+    intrusive_ptr<Y> const & p);
+```
+
+[none]
+* {blank}
++
+Effects:: `os << p.get();`.
+Returns:: `os`.

doc/smart_ptr/intrusive_ref_counter.adoc

@@ -0,0 +1,142 @@
+////
+Copyright 2017 Peter Dimov
+Copyright 2013 Andrey Semashev
+
+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_ref_counter]
+# intrusive_ref_counter
+:toc:
+:toc-title:
+:idprefix: intrusive_ref_counter_
+
+## Description
+
+The `intrusive_ref_counter` class template implements a reference counter for
+a derived user's class that is intended to be used with `intrusive_ptr`. The
+base class has associated `intrusive_ptr_add_ref` and `intrusive_ptr_release`
+functions which modify the reference counter as needed and destroy the user's
+object when the counter drops to zero.
+
+The class template is parameterized on `Derived` and `CounterPolicy`
+parameters. The first parameter is the user's class that derives from
+`intrusive_ref_counter`. This type is needed in order to destroy the object
+correctly when there are no references to it left.
+
+The second parameter is a policy that defines the nature of the reference
+counter. The library provides two such policies: `thread_unsafe_counter` and
+`thread_safe_counter`. The former instructs the `intrusive_ref_counter` 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
+`thread_safe_counter`.
+
+## Synopsis
+
+`intrusive_ref_counter` is defined in
+`<boost/smart_ptr/intrusive_ref_counter.hpp>`.
+
+```
+namespace boost {
+  struct thread_unsafe_counter;
+  struct thread_safe_counter;
+
+  template<class Derived, class CounterPolicy = thread_safe_counter>
+  class intrusive_ref_counter {
+  public:
+    intrusive_ref_counter() noexcept;
+    intrusive_ref_counter(const intrusive_ref_counter& v) noexcept;
+
+    intrusive_ref_counter& operator=(const intrusive_ref_counter& v) noexcept;
+
+    unsigned int use_count() const noexcept;
+
+  protected:
+    ~intrusive_ref_counter() = default;
+  };
+
+  template<class Derived, class CounterPolicy>
+    void intrusive_ptr_add_ref(
+      const intrusive_ref_counter<Derived, CounterPolicy>* p) noexcept;
+
+  template<class Derived, class CounterPolicy>
+    void intrusive_ptr_release(
+      const intrusive_ref_counter<Derived, CounterPolicy>* p) noexcept;
+}
+```
+
+## Members
+
+### Constructors
+
+```
+intrusive_ref_counter() noexcept;
+```
+::
+```
+intrusive_ref_counter(const intrusive_ref_counter&) noexcept;
+```
+::
+Postconditions::: `use_count() == 0`.
+
+NOTE: The pointer to the constructed object is expected to be passed to
+`intrusive_ptr` constructor, assignment operator or `reset` method, which
+would increment the reference counter.
+
+### Destructor
+
+```
+~intrusive_ref_counter();
+```
+::
+Effects::: Destroys the counter object.
+
+NOTE: The destructor is protected so that the object can only be destroyed
+through the `Derived` class.
+
+### Assignment
+
+```
+intrusive_ref_counter& operator=(const intrusive_ref_counter& v) noexcept;
+```
+::
+Effects::: Does nothing, reference counter is not modified.
+
+### use_count
+
+```
+unsigned int use_count() const noexcept;
+```
+::
+Returns::: The current value of the reference counter.
+
+NOTE: The returned value may not be actual in multi-threaded applications.
+
+## Free Functions
+
+### intrusive_ptr_add_ref
+
+```
+template<class Derived, class CounterPolicy>
+  void intrusive_ptr_add_ref(
+    const intrusive_ref_counter<Derived, CounterPolicy>* p) noexcept;
+```
+::
+Effects::: Increments the reference counter.
+
+### intrusive_ptr_release
+
+```
+template<class Derived, class CounterPolicy>
+  void intrusive_ptr_release(
+    const intrusive_ref_counter<Derived, CounterPolicy>* p) noexcept;
+```
+::
+Effects::: Decrements the reference counter. If the reference counter reaches
+0, calls `delete static_cast<const Derived*>(p)`.

doc/smart_ptr/local_shared_ptr.adoc

@@ -0,0 +1,719 @@
+////
+Copyright 2017 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
+////
+
+[#local_shared_ptr]
+# local_shared_ptr: Shared Ownership within a Single Thread
+:toc:
+:toc-title:
+:idprefix: local_shared_ptr_
+
+## Description
+
+`local_shared_ptr` is nearly identical to `shared_ptr`, with the only difference of note being that its reference count is
+updated with non-atomic operations. As such, a `local_shared_ptr` and all its copies must reside in (be local to) a single
+thread (hence the name.)
+
+`local_shared_ptr` can be converted to `shared_ptr` and vice versa. Creating a `local_shared_ptr` from a `shared_ptr` creates
+a new local reference count; this means that two `local_shared_ptr` instances, both created from the same `shared_ptr`, refer
+to the same object but don't share the same count, and as such, can safely be used by two different threads.
+
+.Two local_shared_ptr instances created from a shared_ptr
+```
+shared_ptr<X> p1( new X );
+
+local_shared_ptr<X> p2( p1 ); // p2.local_use_count() == 1
+local_shared_ptr<X> p3( p1 ); // p3.local_use_count() also 1
+```
+
+Creating the second `local_shared_ptr` from the first one, however, does lead to the two sharing the same count:
+
+.A local_shared_ptr created from another local_shared_ptr
+```
+shared_ptr<X> p1( new X );
+
+local_shared_ptr<X> p2( p1 ); // p2.local_use_count() == 1
+local_shared_ptr<X> p3( p2 ); // p3.local_use_count() == 2
+```
+
+Two `shared_ptr` instances created from the same `local_shared_ptr` do share ownership:
+
+.Two shared_ptr instances created from a local_shared_ptr
+```
+local_shared_ptr<X> p1( new X );
+
+shared_ptr<X> p2( p1 ); // p2.use_count() == 2
+shared_ptr<X> p3( p1 ); // p3.use_count() == 3
+```
+
+Here `p2.use_count()` is 2, because `p1` holds a reference, too.
+
+One can think of `local_shared_ptr<T>` as `shared_ptr<shared_ptr<T>>`, with the outer `shared_ptr` using non-atomic operations for
+its count. Converting from `local_shared_ptr` to `shared_ptr` gives you a copy of the inner `shared_ptr`; converting from `shared_ptr`
+wraps it into an outer `shared_ptr` with a non-atomic use count (conceptually speaking) and returns the result.
+
+## Synopsis
+
+`local_shared_ptr` is defined in `<boost/smart_ptr/local_shared_ptr.hpp>`.
+
+```
+namespace boost {
+
+  template<class T> class local_shared_ptr {
+  public:
+
+    typedef /*see below*/ element_type;
+
+    // constructors
+
+    constexpr local_shared_ptr() noexcept;
+    constexpr local_shared_ptr(std::nullptr_t) noexcept;
+
+    template<class Y> explicit local_shared_ptr(Y * p);
+
+    template<class Y, class D> local_shared_ptr(Y * p, D d);
+    template<class D> local_shared_ptr(std::nullptr_t p, D d);
+
+    template<class Y, class D, class A> local_shared_ptr(Y * p, D d, A a);
+    template<class D, class A> local_shared_ptr(std::nullptr_t p, D d, A a);
+
+    local_shared_ptr(local_shared_ptr const & r) noexcept;
+    template<class Y> local_shared_ptr(local_shared_ptr<Y> const & r) noexcept;
+
+    local_shared_ptr(local_shared_ptr && r) noexcept;
+    template<class Y> local_shared_ptr(local_shared_ptr<Y> && r) noexcept;
+
+    template<class Y> local_shared_ptr( shared_ptr<Y> const & r );
+    template<class Y> local_shared_ptr( shared_ptr<Y> && r );
+
+    template<class Y> local_shared_ptr(local_shared_ptr<Y> const & r, element_type * p) noexcept;
+    template<class Y> local_shared_ptr(local_shared_ptr<Y> && r, element_type * p) noexcept;
+
+    template<class Y, class D> local_shared_ptr(std::unique_ptr<Y, D> && r);
+    
+    // destructor
+
+    ~local_shared_ptr() noexcept;
+
+    // assignment
+
+    local_shared_ptr & operator=(local_shared_ptr const & r) noexcept;
+    template<class Y> local_shared_ptr & operator=(local_shared_ptr<Y> const & r) noexcept;
+
+    local_shared_ptr & operator=(local_shared_ptr const && r) noexcept;
+    template<class Y> local_shared_ptr & operator=(local_shared_ptr<Y> const && r) noexcept;
+
+    template<class Y, class D> local_shared_ptr & operator=(std::unique_ptr<Y, D> && r);
+
+    local_shared_ptr & operator=(std::nullptr_t) noexcept;
+
+    // reset
+	
+    void reset() noexcept;
+
+    template<class Y> void reset(Y * p);
+    template<class Y, class D> void reset(Y * p, D d);
+    template<class Y, class D, class A> void reset(Y * p, D d, A a);
+
+    template<class Y> void reset(local_shared_ptr<Y> const & r, element_type * p) noexcept;
+    template<class Y> void reset(local_shared_ptr<Y> && r, element_type * p) noexcept;
+
+    // accessors
+    
+    T & operator*() const noexcept; // only valid when T is not an array type
+    T * operator->() const noexcept; // only valid when T is not an array type
+
+    // only valid when T is an array type
+    element_type & operator[](std::ptrdiff_t i) const noexcept;
+
+    element_type * get() const noexcept;
+
+    long local_use_count() const noexcept;
+
+    // conversions
+
+    explicit operator bool() const noexcept;
+
+    template<class Y> operator shared_ptr<Y>() const noexcept;
+    template<class Y> operator weak_ptr<Y>() const noexcept;
+
+    // swap
+    
+    void swap(local_shared_ptr & b) noexcept;
+
+    // owner_before
+    
+    template<class Y> bool owner_before(local_shared_ptr<Y> const & rhs) const noexcept;
+  };
+
+  // comparisons
+  
+  template<class T, class U>
+    bool operator==(local_shared_ptr<T> const & a, local_shared_ptr<U> const & b) noexcept;
+  template<class T, class U>
+    bool operator==(local_shared_ptr<T> const & a, shared_ptr<U> const & b) noexcept;
+  template<class T, class U>
+    bool operator==(shared_ptr<T> const & a, local_shared_ptr<U> const & b) noexcept;
+
+  template<class T, class U>
+    bool operator!=(local_shared_ptr<T> const & a, local_shared_ptr<U> const & b) noexcept;
+  template<class T, class U>
+    bool operator!=(local_shared_ptr<T> const & a, shared_ptr<U> const & b) noexcept;
+  template<class T, class U>
+    bool operator!=(shared_ptr<T> const & a, local_shared_ptr<U> const & b) noexcept;
+
+  template<class T> bool operator==(local_shared_ptr<T> const & p, std::nullptr_t) noexcept;
+  template<class T> bool operator==(std::nullptr_t, local_shared_ptr<T> const & p) noexcept;
+
+  template<class T> bool operator!=(local_shared_ptr<T> const & p, std::nullptr_t) noexcept;
+  template<class T> bool operator!=(std::nullptr_t, local_shared_ptr<T> const & p) noexcept;
+
+  template<class T, class U>
+    bool operator<(local_shared_ptr<T> const & a, local_shared_ptr<U> const & b) noexcept;
+
+  // swap
+  
+  template<class T> void swap(local_shared_ptr<T> & a, local_shared_ptr<T> & b) noexcept;
+
+  // get_pointer
+  
+  template<class T>
+    typename local_shared_ptr<T>::element_type *
+      get_pointer(local_shared_ptr<T> const & p) noexcept;
+
+  // casts
+  
+  template<class T, class U>
+    local_shared_ptr<T> static_pointer_cast(local_shared_ptr<U> const & r) noexcept;
+
+  template<class T, class U>
+    local_shared_ptr<T> const_pointer_cast(local_shared_ptr<U> const & r) noexcept;
+
+  template<class T, class U>
+    local_shared_ptr<T> dynamic_pointer_cast(local_shared_ptr<U> const & r) noexcept;
+
+  template<class T, class U>
+    local_shared_ptr<T> reinterpret_pointer_cast(local_shared_ptr<U> const & r) noexcept;
+
+  // stream I/O
+
+  template<class E, class T, class Y>
+    std::basic_ostream<E, T> &
+      operator<< (std::basic_ostream<E, T> & os, local_shared_ptr<Y> const & p);
+
+  // get_deleter
+  
+  template<class D, class T> D * get_deleter(local_shared_ptr<T> const & p) noexcept;
+}
+```
+
+## Members
+
+### element_type
+```
+typedef ... element_type;
+```
+`element_type` is `T` when `T` is not an array type, and `U` when `T` is `U[]` or `U[N]`.
+
+### default constructor
+```
+constexpr local_shared_ptr() noexcept;
+```
+```
+constexpr local_shared_ptr(std::nullptr_t) noexcept;
+```
+[none]
+* {blank}
++
+Effects:: Constructs an empty `local_shared_ptr`.
+Postconditions:: `local_use_count() == 0 && get() == 0`.
+
+### pointer constructor
+```
+template<class Y> explicit local_shared_ptr(Y * p);
+```
+[none]
+* {blank}
++
+Effects:: Constructs a `local_shared_ptr` that owns `shared_ptr<T>( p )`.
+
+Postconditions:: `local_use_count() == 1 && get() == p`.
+
+Throws:: `std::bad_alloc`, or an implementation-defined exception when a resource other than memory could not be obtained.
+
+### constructors taking a deleter
+```
+template<class Y, class D> local_shared_ptr(Y * p, D d);
+```
+```
+template<class D> local_shared_ptr(std::nullptr_t p, D d);
+```
+[none]
+* {blank}
++
+Effects:: Constructs a `local_shared_ptr` that owns `shared_ptr<T>( p, d )`.
+
+Postconditions:: `local_use_count() == 1 && get() == p`.
+
+Throws:: `std::bad_alloc`, or an implementation-defined exception when a resource other than memory could not be obtained.
+
+```
+template<class Y, class D, class A> local_shared_ptr(Y * p, D d, A a);
+```
+```
+template<class D, class A> local_shared_ptr(std::nullptr_t p, D d, A a);
+```
+[none]
+* {blank}
++
+Effects:: Constructs a `local_shared_ptr` that owns `shared_ptr<T>( p, d, a )`.
+
+Postconditions:: `local_use_count() == 1 && get() == p`.
+
+Throws:: `std::bad_alloc`, or an implementation-defined exception when a resource other than memory could not be obtained.
+
+### copy and converting constructors
+```
+local_shared_ptr(local_shared_ptr const & r) noexcept;
+```
+```
+template<class Y> local_shared_ptr(local_shared_ptr<Y> const & r) noexcept;
+```
+[none]
+* {blank}
++
+Requires:: `Y*` should be convertible to `T*`.
+
+Effects:: If `r` is empty, constructs an empty `local_shared_ptr`; otherwise, constructs a `local_shared_ptr` that shares ownership with `r`.
+
+Postconditions:: `get() == r.get() && local_use_count() == r.local_use_count()`.
+
+### move constructors
+```
+local_shared_ptr(local_shared_ptr && r) noexcept;
+```
+```
+template<class Y> local_shared_ptr(local_shared_ptr<Y> && r) noexcept;
+```
+[none]
+* {blank}
++
+Requires:: `Y*` should be convertible to `T*`.
+
+Effects:: Move-constructs a `local_shared_ptr` from `r`.
+
+Postconditions:: `*this` contains the old value of `r`. `r` is empty and `r.get() == 0`.
+
+### shared_ptr constructor
+```
+template<class Y> local_shared_ptr( shared_ptr<Y> const & r );
+```
+```
+template<class Y> local_shared_ptr( shared_ptr<Y> && r );
+```
+[none]
+* {blank}
++
+Effects:: Constructs a `local_shared_ptr` that owns `r`.
+
+Postconditions:: `local_use_count() == 1`. `get()` returns the old value of `r.get()`.
+
+Throws:: `std::bad_alloc`, or an implementation-defined exception when a resource other than memory could not be obtained.
+
+### aliasing constructor
+```
+template<class Y> local_shared_ptr(local_shared_ptr<Y> const & r, element_type * p) noexcept;
+```
+[none]
+* {blank}
++
+Effects:: constructs a `local_shared_ptr` that shares ownership with `r` and stores `p`.
+
+Postconditions:: `get() == p && local_use_count() == r.local_use_count()`.
+
+### aliasing move constructor
+```
+template<class Y> local_shared_ptr(local_shared_ptr<Y> && r, element_type * p) noexcept;
+```
+[none]
+* {blank}
++
+Effects:: Move-constructs a `local_shared_ptr` from `r`, while storing `p` instead.
+
+Postconditions:: `get() == p` and `local_use_count()` equals the old count of `r`. `r` is empty and `r.get() == 0`.
+
+### unique_ptr constructor
+```
+template<class Y, class D> local_shared_ptr(std::unique_ptr<Y, D> && r);
+```
+[none]
+* {blank}
++
+Requires:: `Y*` should be convertible to `T*`.
+
+Effects::
+- When `r.get() == 0`, equivalent to `local_shared_ptr()`;
+- Otherwise, constructs a `local_shared_ptr` that owns `shared_ptr<T>( std::move(r) )`.
+
+Throws:: `std::bad_alloc`, or an implementation-defined exception when a resource other than memory could not be obtained.
+
+Exception safety:: If an exception is thrown, the constructor has no effect.
+
+### destructor
+```
+~local_shared_ptr() noexcept;
+```
+[none]
+* {blank}
++
+Effects::
+- If `*this` is empty, or shares ownership with another `local_shared_ptr` instance (`local_use_count() > 1`), there are no side effects.
+- Otherwise, destroys the owned `shared_ptr`.
+
+### assignment
+```
+local_shared_ptr & operator=(local_shared_ptr const & r) noexcept;
+```
+```
+template<class Y> local_shared_ptr & operator=(local_shared_ptr<Y> const & r) noexcept;
+```
+[none]
+* {blank}
++
+Effects:: Equivalent to `local_shared_ptr(r).swap(*this)`.
+Returns:: `*this`.
+
+```
+local_shared_ptr & operator=(local_shared_ptr && r) noexcept;
+```
+```
+template<class Y> local_shared_ptr & operator=(local_shared_ptr<Y> && r) noexcept;
+```
+```
+template<class Y, class D> local_shared_ptr & operator=(std::unique_ptr<Y, D> && r);
+```
+[none]
+* {blank}
++
+Effects:: Equivalent to `local_shared_ptr(std::move(r)).swap(*this)`.
+Returns:: `*this`.
+
+```
+local_shared_ptr & operator=(std::nullptr_t) noexcept;
+```
+[none]
+* {blank}
++
+Effects:: Equivalent to `local_shared_ptr().swap(*this)`.
+Returns:: `*this`.
+
+### reset
+```
+void reset() noexcept;
+```
+[none]
+* {blank}
++
+Effects:: Equivalent to `local_shared_ptr().swap(*this)`.
+
+```
+template<class Y> void reset(Y * p);
+```
+[none]
+* {blank}
++
+Effects:: Equivalent to `local_shared_ptr(p).swap(*this)`.
+
+```
+template<class Y, class D> void reset(Y * p, D d);
+```
+[none]
+* {blank}
++
+Effects:: Equivalent to `local_shared_ptr(p, d).swap(*this)`.
+
+```
+template<class Y, class D, class A> void reset(Y * p, D d, A a);
+```
+[none]
+* {blank}
++
+Effects:: Equivalent to `local_shared_ptr(p, d, a).swap(*this)`.
+
+```
+template<class Y> void reset(local_shared_ptr<Y> const & r, element_type * p) noexcept;
+```
+[none]
+* {blank}
++
+Effects:: Equivalent to `local_shared_ptr(r, p).swap(*this)`.
+
+```
+template<class Y> void reset(local_shared_ptr<Y> && r, element_type * p) noexcept;
+```
+[none]
+* {blank}
++
+Effects:: Equivalent to `local_shared_ptr(std::move(r), p).swap(*this)`.
+
+### indirection
+```
+T & operator*() const noexcept;
+```
+[none]
+* {blank}
++
+Requires:: `T` should not be an array type.
+Returns:: `*get()`.
+
+```
+T * operator->() const noexcept;
+```
+[none]
+* {blank}
++
+Requires:: `T` should not be an array type.
+Returns:: `get()`.
+
+```
+element_type & operator[](std::ptrdiff_t i) const noexcept;
+```
+[none]
+* {blank}
++
+Requires:: `T` should be an array type. The stored pointer must not be 0. `i >= 0`. If `T` is `U[N]`, `i < N`.
+Returns:: `get()[i]`.
+
+### get
+
+```
+element_type * get() const noexcept;
+```
+[none]
+* {blank}
++
+Returns:: The stored pointer.
+
+### local_use_count
+```
+long local_use_count() const noexcept;
+```
+[none]
+* {blank}
++
+Returns:: The number of `local_shared_ptr` objects, `*this` included, that share ownership with `*this`, or 0 when `*this` is empty.
+
+### conversions
+```
+explicit operator bool() const noexcept;
+```
+[none]
+* {blank}
++
+Returns:: `get() != 0`.
+
+NOTE: On C++03 compilers, the return value is of an unspecified type.
+
+```
+template<class Y> operator shared_ptr<Y>() const noexcept;
+```
+```
+template<class Y> operator weak_ptr<Y>() const noexcept;
+```
+[none]
+* {blank}
++
+Requires:: `T*` should be convertible to `Y*`.
+Returns:: a copy of the owned `shared_ptr`.
+
+### swap
+```
+void swap(local_shared_ptr & b) noexcept;
+```
+[none]
+* {blank}
++
+Effects:: Exchanges the contents of the two smart pointers.
+
+### owner_before
+```
+template<class Y> bool owner_before(local_shared_ptr<Y> const & rhs) const noexcept;
+```
+[none]
+* {blank}
++
+Effects:: See the description of `operator<`.
+
+## Free Functions
+
+### comparison
+```
+template<class T, class U>
+  bool operator==(local_shared_ptr<T> const & a, local_shared_ptr<U> const & b) noexcept;
+```
+```
+template<class T, class U>
+  bool operator==(local_shared_ptr<T> const & a, shared_ptr<U> const & b) noexcept;
+```
+```
+template<class T, class U>
+  bool operator==(shared_ptr<T> const & a, local_shared_ptr<U> const & b) noexcept;
+```
+[none]
+* {blank}
++
+Returns:: `a.get() == b.get()`.
+
+```
+template<class T, class U>
+  bool operator!=(local_shared_ptr<T> const & a, local_shared_ptr<U> const & b) noexcept;
+```
+```
+template<class T, class U>
+  bool operator!=(local_shared_ptr<T> const & a, shared_ptr<U> const & b) noexcept;
+```
+```
+template<class T, class U>
+  bool operator!=(shared_ptr<T> const & a, local_shared_ptr<U> const & b) noexcept;
+```
+[none]
+* {blank}
++
+Returns:: `a.get() != b.get()`.
+
+```
+template<class T> bool operator==(local_shared_ptr<T> const & p, std::nullptr_t) noexcept;
+```
+```
+template<class T> bool operator==(std::nullptr_t, local_shared_ptr<T> const & p) noexcept;
+```
+[none]
+* {blank}
++
+Returns:: `p.get() == 0`.
+
+```
+template<class T> bool operator!=(local_shared_ptr<T> const & p, std::nullptr_t) noexcept;
+```
+```
+template<class T> bool operator!=(std::nullptr_t, local_shared_ptr<T> const & p) noexcept;
+```
+[none]
+* {blank}
++
+Returns:: `p.get() != 0`.
+
+```
+template<class T, class U>
+  bool operator<(local_shared_ptr<T> const & a, local_shared_ptr<U> const & b) noexcept;
+```
+[none]
+* {blank}
++
+Returns:: An unspecified value such that
+  - `operator<` is a strict weak ordering as described in section [lib.alg.sorting] of the {cpp} standard;
+  - under the equivalence relation defined by `operator<`, `!(a < b) && !(b < a)`, two `local_shared_ptr` instances
+    are equivalent if and only if they share ownership or are both empty.
+
+NOTE: Allows `local_shared_ptr` objects to be used as keys in associative containers.
+
+NOTE: The rest of the comparison operators are omitted by design.
+
+### swap
+```
+template<class T> void swap(local_shared_ptr<T> & a, local_shared_ptr<T> & b) noexcept;
+```
+[none]
+* {blank}
++
+Effects:: Equivalent to `a.swap(b)`.
+
+### get_pointer
+```
+template<class T>
+  typename local_shared_ptr<T>::element_type *
+    get_pointer(local_shared_ptr<T> const & p) noexcept;
+```
+[none]
+* {blank}
++
+Returns:: `p.get()`.
+
+NOTE: Provided as an aid to generic programming. Used by `mem_fn`.
+
+### static_pointer_cast
+```
+template<class T, class U>
+  local_shared_ptr<T> static_pointer_cast(local_shared_ptr<U> const & r) noexcept;
+```
+[none]
+* {blank}
++
+Requires:: The expression `static_cast<T*>( (U*)0 )` must be well-formed.
+Returns:: `local_shared_ptr<T>( r, static_cast<typename local_shared_ptr<T>::element_type*>(r.get()) )`.
+
+CAUTION: The seemingly equivalent expression `local_shared_ptr<T>(static_cast<T*>(r.get()))` will eventually
+result in undefined behavior, attempting to delete the same object twice.
+
+### const_pointer_cast
+```
+template<class T, class U>
+  local_shared_ptr<T> const_pointer_cast(local_shared_ptr<U> const & r) noexcept;
+```
+[none]
+* {blank}
++
+Requires:: The expression `const_cast<T*>( (U*)0 )` must be well-formed.
+Returns:: `local_shared_ptr<T>( r, const_cast<typename local_shared_ptr<T>::element_type*>(r.get()) )`.
+
+### dynamic_pointer_cast
+```
+template<class T, class U>
+    local_shared_ptr<T> dynamic_pointer_cast(local_shared_ptr<U> const & r) noexcept;
+```
+[none]
+* {blank}
++
+Requires:: The expression `dynamic_cast<T*>( (U*)0 )` must be well-formed.
+Returns::
+  - When `dynamic_cast<typename local_shared_ptr<T>::element_type*>(r.get())` returns a nonzero value `p`, `local_shared_ptr<T>(r, p)`;
+  - Otherwise, `local_shared_ptr<T>()`.
+
+### reinterpret_pointer_cast
+```
+template<class T, class U>
+  local_shared_ptr<T> reinterpret_pointer_cast(local_shared_ptr<U> const & r) noexcept;
+```
+[none]
+* {blank}
++
+Requires:: The expression `reinterpret_cast<T*>( (U*)0 )` must be well-formed.
+Returns:: `local_shared_ptr<T>( r, reinterpret_cast<typename local_shared_ptr<T>::element_type*>(r.get()) )`.
+
+### operator<<
+```
+template<class E, class T, class Y>
+  std::basic_ostream<E, T> &
+    operator<< (std::basic_ostream<E, T> & os, local_shared_ptr<Y> const & p);
+```
+[none]
+* {blank}
++
+Effects:: `os << p.get();`.
+Returns:: `os`.
+
+### get_deleter
+```
+template<class D, class T>
+  D * get_deleter(local_shared_ptr<T> const & p) noexcept;
+```
+[none]
+* {blank}
++
+Returns:: If `*this` owns a `shared_ptr` instance `p`, `get_deleter<D>( p )`, otherwise 0.
+

doc/smart_ptr/make_shared.adoc

@@ -0,0 +1,295 @@
+////
+Copyright 2017 Peter Dimov
+Copyright 2017 Glen Joseph Fernandes (glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+
+See accompanying file LICENSE_1_0.txt or copy at
+http://www.boost.org/LICENSE_1_0.txt
+////
+
+[#make_shared]
+# make_shared: Creating shared_ptr
+:toc:
+:toc-title:
+:idprefix: make_shared_
+
+## Description
+
+The function templates `make_shared` and `allocate_shared` provide convenient,
+safe and efficient ways to create `shared_ptr` objects.
+
+## Rationale
+
+Consistent use of `shared_ptr` can eliminate the need to use an explicit
+`delete`, but alone it provides no support in avoiding explicit `new`. There
+were repeated requests from users for a factory function that creates an
+object of a given type and returns a `shared_ptr` to it. Besides convenience
+and style, such a function is also exception safe and considerably faster
+because it can use a single allocation for both the object and its
+corresponding control block, eliminating a significant portion of
+`shared_ptr` construction overhead. This eliminates one of the major
+efficiency complaints about `shared_ptr`.
+
+The family of overloaded function templates, `make_shared` and
+`allocate_shared`, were provided to address this need. `make_shared` uses the
+global `operator new` to allocate memory, whereas `allocate_shared` uses an
+user-supplied allocator, allowing finer control.
+
+The rationale for choosing the name `make_shared` is that the expression
+`make_shared<Widget>()` can be read aloud and conveys the intended meaning.
+
+Originally the Boost function templates `allocate_shared` and `make_shared`
+were provided for scalar objects only. There was a need to have efficient
+allocation of array objects. One criticism of class template `shared_array`
+was always the lack of a utility like `make_shared` that uses only a single
+allocation. When `shared_ptr` was enhanced to support array types, additional
+overloads of `allocate_shared` and `make_shared` were provided for array
+types.
+
+## Synopsis
+
+`make_shared` and `allocate_shared` are defined in
+`<boost/smart_ptr/make_shared.hpp>`.
+
+[subs=+quotes]
+```
+namespace boost {
+  `// only if T is not an array type`
+  template<class T, class... Args>
+    shared_ptr<T> make_shared(Args&&... args);
+  template<class T, class A, class... Args>
+    shared_ptr<T> allocate_shared(const A& a, Args&&... args);
+
+  `// only if T is an array type of the form U[]`
+  template<class T>
+    shared_ptr<T> make_shared(std::size_t n);
+  template<class T, class A>
+    shared_ptr<T> allocate_shared(const A& a, std::size_t n);
+
+  `// only if T is an array type of the form U[N]`
+  template<class T>
+    shared_ptr<T> make_shared();
+  template<class T, class A>
+    shared_ptr<T> allocate_shared(const A& a);
+
+  `// only if T is an array type of the form U[]`
+  template<class T> shared_ptr<T>
+    make_shared(std::size_t n, const remove_extent_t<T>& v);
+  template<class T, class A> shared_ptr<T>
+    allocate_shared(const A& a, std::size_t n, const remove_extent_t<T>& v);
+
+  `// only if T is an array type of the form U[N]`
+  template<class T>
+    shared_ptr<T> make_shared(const remove_extent_t<T>& v);
+  template<class T, class A>
+    shared_ptr<T> allocate_shared(const A& a, const remove_extent_t<T>& v);
+
+  `// only if T is not an array type of the form U[]`
+  template<class T>
+    shared_ptr<T> make_shared_noinit();
+  template<class T, class A>
+    shared_ptr<T> allocate_shared_noinit(const A& a);
+
+  `// only if T is an array type of the form U[N]`
+  template<class T>
+    shared_ptr<T> make_shared_noinit(std::size_t n);
+  template<class T, class A>
+    shared_ptr<T> allocate_shared_noinit(const A& a, std::size_t n);
+}
+```
+
+## Common Requirements
+
+The common requirements that apply to all `make_shared` and `allocate_shared`
+overloads, unless specified otherwise, are described below.
+
+Requires:: `A` shall be an _allocator_. The copy constructor and destructor
+of `A` shall not throw exceptions.
+
+Effects:: Allocates memory for an object of type `T`  or `n` objects of `U`
+(if `T` is an array type of the form `U[]` and  `n` is determined by
+arguments, as specified by the concrete overload). The object is initialized
+from arguments as specified by the concrete overload. Uses a rebound copy of
+`a` (for an unspecified `value_type`) to allocate memory. If an exception is
+thrown, the functions have no effect.
+
+Returns:: A `shared_ptr` instance that stores and owns the address of the
+newly constructed object.
+
+Postconditions:: `r.get() != 0` and `r.use_count() == 1`, where `r`
+is the return value.
+
+Throws:: `std::bad_alloc`, an exception thrown from `A::allocate`, or from the
+initialization of the object.
+
+Remarks::
+* Performs no more than one memory allocation. This provides efficiency
+equivalent to an intrusive smart pointer.
+* When an object of an array type is specified to be initialized to a value of
+the same type `v`, this shall be interpreted to mean that each array element
+of the object is initialized to the corresponding element from `v`.
+* When an object of an array type is specified to be value-initialized, this
+shall be interpreted to mean that each array element of the object is
+value-initialized.
+* When a (sub)object of non-array type `U` is specified to be initialized to
+a value `v`, or constructed from `args\...`, `make_shared` shall perform
+this initialization via the expression `::new(p) U(expr)` (where
+`_expr_` is `v` or `std::forward<Args>(args)\...)` respectively) and `p`
+has type `void*` and points to storage suitable to hold an object of type
+`U`.
+* When a (sub)object of non-array type `U` is specified to be initialized to
+a value `v`, or constructed from `args\...`, `allocate_shared` shall
+perform this initialization via the expression
+`std::allocator_traits<A2>::construct(a2, p, expr)` (where
+`_expr_` is `v` or `std::forward<Args>(args)\...)` respectively), `p`
+points to storage suitable to hold an object of type `U`, and `a2` of
+type `A2` is a rebound copy `a` such that its `value_type` is `U`.
+* When a (sub)object of non-array type `U` is specified to be
+default-initialized, `make_shared_noinit` and `allocate_shared_noinit` shall
+perform this initialization via the expression `::new(p) U`, where
+`p` has type `void*` and points to storage suitable to hold an object of
+type `U`.
+* When a (sub)object of non-array type `U` is specified to be
+value-initialized, `make_shared` shall perform this initialization via the
+expression `::new(p) U()`, where `p` has type `void*` and points to
+storage suitable to hold an object of type `U`.
+* When a (sub)object of non-array type `U` is specified to be
+value-initialized, `allocate_shared` shall perform this initialization via the
+expression `std::allocator_traits<A2>::construct(a2, p)`, where
+`p` points to storage suitable to hold an object of type `U` and `a2` of
+type `A2` is a rebound copy of `a` such that its value_type is `U`.
+* Array elements are initialized in ascending order of their addresses.
+* 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.
+
+NOTE: These functions will typically allocate more memory than the total size
+of the element objects to allow for internal bookkeeping structures such as
+the reference counts.
+
+## Free Functions
+
+```
+template<class T, class... Args>
+  shared_ptr<T> make_shared(Args&&... args);
+```
+::
+```
+template<class T, class A, class... Args>
+  shared_ptr<T> allocate_shared(const A& a, Args&&... args);
+```
+::
+Remarks::: These overloads shall only participate in overload resolution when
+`T` is not an array type.
+Returns::: A `shared_ptr` to an object of type `T`, constructed from
+`args\...`.
+Examples:::
+* `auto p = make_shared<int>();`
+* `auto p = make_shared<std::vector<int> >(16, 1);`
+
+```
+template<class T>
+  shared_ptr<T> make_shared(std::size_t n);
+```
+::
+```
+template<class T, class A>
+  shared_ptr<T> allocate_shared(const A& a, std::size_t n);
+```
+::
+Remarks::: These overloads shall only participate in overload resolution when
+`T` is an array type of the form `U[]`.
+Returns::: A `shared_ptr` to a sequence of `n` value-initialized objects of
+type `U`.
+Examples:::
+* `auto p = make_shared<double[]>(1024);`
+* `auto p = make_shared<double[][2][2]>(6);`
+
+```
+template<class T>
+  shared_ptr<T> make_shared();
+```
+::
+```
+template<class T, class A>
+  shared_ptr<T> allocate_shared(const A& a);
+```
+::
+Remarks::: These overloads shall only participate in overload resolution when
+`T` is an array type of the form `U[N]`.
+Returns::: A `shared_ptr` to a sequence of `N` value-initialized objects of
+type `U`.
+Examples:::
+* `auto p = make_shared<double[1024]>();`
+* `auto p = make_shared<double[6][2][2]>();`
+
+```
+template<class T> shared_ptr<T>
+  make_shared(std::size_t n, const remove_extent_t<T>& v);
+```
+::
+```
+template<class T, class A> shared_ptr<T>
+  allocate_shared(const A& a, std::size_t n, const remove_extent_t<T>& v);
+```
+::
+Remarks::: These overloads shall only participate in overload resolution when
+`T` is an array type of the form `U[]`.
+Returns::: A `shared_ptr` to a sequence of `n` objects of type `U`, each
+initialized to `v`.
+Examples:::
+* `auto p = make_shared<double[]>(1024, 1.0);`
+* `auto p = make_shared<double[][2]>(6, {1.0, 0.0});`
+* `auto p = make_shared<std::vector<int>[]>(4, {1, 2});`
+
+```
+template<class T>
+  shared_ptr<T> make_shared(const remove_extent_t<T>& v);
+```
+::
+```
+template<class T, class A>
+  shared_ptr<T> allocate_shared(const A& a, const remove_extent_t<T>& v);
+```
+::
+Remarks::: These overloads shall only participate in overload resolution when
+`T` is an array type of the form `U[N]`.
+Returns::: A `shared_ptr` to a sequence of `N` objects of type `U`, each
+initialized to `v`.
+Examples:::
+* `auto p = make_shared<double[1024]>(1.0);`
+* `auto p = make_shared<double[6][2]>({1.0, 0.0});`
+* `auto p = make_shared<std::vector<int>[4]>({1, 2});`
+
+```
+template<class T>
+  shared_ptr<T> make_shared_noinit();
+```
+::
+```
+template<class T, class A>
+  shared_ptr<T> allocate_shared_noinit(const A& a);
+```
+::
+Remarks::: These overloads shall only participate in overload resolution when
+`T` is not an array type, or an array type of the `U[N]`.
+Returns::: A `shared_ptr` to a default-initialized object of type `T`, or a
+sequence of `N` default-initialized objects of type `U`, respectively.
+Example::: `auto p = make_shared_noinit<double[1024]>();`
+
+```
+template<class T>
+  shared_ptr<T> make_shared_noinit(std::size_t n);
+```
+::
+```
+template<class T, class A>
+  shared_ptr<T> allocate_shared_noinit(const A& a, std::size_t n);
+```
+::
+Remarks::: These overloads shall only participate in overload resolution when
+`T` is an array type of the form `U[]`.
+Returns::: A `shared_ptr` to a sequence of `_n_` default-initialized objects
+of type `U`.
+Example::: `auto p = make_shared_noinit<double[]>(1024);`

doc/smart_ptr/make_unique.adoc

@@ -0,0 +1,115 @@
+////
+Copyright 2017 Peter Dimov
+Copyright 2017 Glen Joseph Fernandes (glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+
+See accompanying file LICENSE_1_0.txt or copy at
+http://www.boost.org/LICENSE_1_0.txt
+////
+
+[#make_unique]
+# make_unique: Creating unique_ptr
+:toc:
+:toc-title:
+:idprefix: make_unique_
+
+## Description
+
+The `make_unique` function templates provide convenient and safe ways to
+create `std::unique_ptr` objects.
+
+## Rationale
+
+The {cpp}11 standard introduced `std::unique_ptr` but did not provide any
+`make_unique` utility like `std::make_shared` that provided the same
+exception safety and facility to avoid writing `new` expressions. Before it
+was implemented by some standard library vendors (and prior to the {cpp}14
+standard introducing `std::make_unique`), this library provided it due to
+requests from users.
+
+This library also provides additional overloads of `make_unique` for
+default-initialization, when users do not need or want to incur the expense
+of value-initialization. The {cpp} standard does not yet provide this
+feature with `std::make_unique`.
+
+## Synopsis
+
+`make_unique` is defined in `<boost/smart_ptr/make_unqiue.hpp>`.
+
+[subs=+quotes]
+```
+namespace boost {
+  `// only if T is not an array type`
+  template<class T, class... Args>
+    std::unique_ptr<T> make_unique(Args&&... args);
+
+  `// only if T is not an array type`
+  template<class T>
+    std::unique_ptr<T> make_unique(remove_reference_t<T>&& v);
+
+  `// only if T is an array type of the form U[]`
+  template<class T>
+    std::unique_ptr<T> make_unique(std::size_t n);
+
+  `// only if T is not an array type`
+  template<class T>
+    std::unique_ptr<T> make_unique_noinit();
+
+  `// only if T is an array type of the form U[]`
+  template<class T>
+    std::unique_ptr<T> make_unique_noinit(std::size_t n);
+}
+```
+
+## Free Functions
+
+```
+template<class T, class... Args>
+  std::unique_ptr<T> make_unique(Args&&... args);
+```
+::
+Remarks::: These overloads shall only participate in overload resolution when
+`T` is not an array type.
+Returns::: `std::unique_ptr<T>(new T(std::forward<Args>(args)\...)`.
+Example::: `auto p = make_unique<int>();`
+
+```
+template<class T>
+  std::unique_ptr<T> make_unique(remove_reference_t<T>&& v);
+```
+::
+Remarks::: These overloads shall only participate in overload resolution when
+`T` is not an array type.
+Returns::: `std::unique_ptr<T>(new T(std::move(v))`.
+Example::: `auto p = make_unique<std::vector<int> >({1, 2});`
+
+```
+template<class T>
+  std::unique_ptr<T> make_unique(std::size_t n);
+```
+::
+Remarks::: These overloads shall only participate in overload resolution when
+`T` is an array type of the form `U[]`.
+Returns::: `std::unique_ptr<U[]>(new U[n]())`.
+Example::: `auto p = make_unique<double[]>(1024);`
+
+```
+template<class T>
+  std::unique_ptr<T> make_unique_noinit();
+```
+::
+Remarks::: These overloads shall only participate in overload resolution when
+`T` is not an array type.
+Returns::: `std::unique_ptr<T>(new T)`.
+Example::: `auto p = make_unique_noinit<double[1024]>();`
+
+```
+template<class T>
+  std::unique_ptr<T> make_unique_noinit(std::size_t n);
+```
+::
+Remarks::: These overloads shall only participate in overload resolution when
+`T` is an array type of the form `U[]`.
+Returns::: `std::unique_ptr<U[]>(new U[n])`.
+Example::: `auto p = make_unique_noinit<double[]>(1024);`

doc/smart_ptr/pointer_cast.adoc

@@ -0,0 +1,213 @@
+////
+Copyright 2017 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
+////
+
+[#pointer_cast]
+# Generic Pointer Casts
+:toc:
+:toc-title:
+:idprefix: pointer_cast_
+
+## Description
+
+The pointer cast function templates (`static_pointer_cast`,
+`dynamic_pointer_cast`, `const_pointer_cast`, and `reinterpret_pointer_cast`)
+provide a way to write generic pointer castings for raw pointers,
+`std::shared_ptr` and `std::unique_ptr`.
+
+There is test and example code in
+link:../../test/pointer_cast_test.cpp[pointer_cast_test.cpp]
+
+## Rationale
+
+Boost smart pointers usually overload those functions to provide a mechanism
+to emulate pointers casts. For example, `shared_ptr<T>` implements a static
+pointer cast this way:
+
+```
+template<class T, class U>
+  shared_ptr<T> static_pointer_cast(const shared_ptr<U>& p);
+```
+
+Pointer cast functions templates are overloads of `static_pointer_cast`,
+`dynamic_pointer_cast`, `const_pointer_cast`, and `reinterpret_pointer_cast`
+for raw pointers, `std::shared_ptr` and `std::unique_ptr`. 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.
+
+## Synopsis
+
+The generic pointer casts are defined in `<boost/pointer_cast.hpp>`.
+
+```
+namespace boost {
+  template<class T, class U> T* static_pointer_cast(U* p) noexcept;
+  template<class T, class U> T* dynamic_pointer_cast(U* p) noexcept;
+  template<class T, class U> T* const_pointer_cast(U* p) noexcept;
+  template<class T, class U> T* reinterpret_pointer_cast(U* p) noexcept;
+
+  template<class T, class U> std::shared_ptr<T>
+    static_pointer_cast(const std::shared_ptr<U>& p) noexcept;
+  template<class T, class U> std::shared_ptr<T>
+    dynamic_pointer_cast(const std::shared_ptr<U>& p) noexcept;
+  template<class T, class U> std::shared_ptr<T>
+    const_pointer_cast(const std::shared_ptr<U>& p) noexcept;
+  template<class T, class U> std::shared_ptr<T>
+    reinterpret_pointer_cast(const std::shared_ptr<U>& p) noexcept;
+
+  template<class T, class U> std::unique_ptr<T>
+    static_pointer_cast(std::unique_ptr<U>&& p) noexcept;
+  template<class T, class U> std::unique_ptr<T>
+    dynamic_pointer_cast(std::unique_ptr<U>&& p) noexcept;
+  template<class T, class U> std::unique_ptr<T>
+    const_pointer_cast(std::unique_ptr<U>&& p) noexcept;
+  template<class T, class U> std::unique_ptr<T>
+    reinterpret_pointer_cast(std::unique_ptr<U>&& p) noexcept;
+}
+```
+
+## Free Functions
+
+### static_pointer_cast
+```
+template<class T, class U> T* static_pointer_cast(U* p) noexcept;
+```
+::
+Returns::: `static_cast<T*>(p)`
+
+```
+template<class T, class U> std::shared_ptr<T>
+  static_pointer_cast(const std::shared_ptr<U>& p) noexcept;
+```
+::
+Returns::: `std::static_pointer_cast<T>(p)`
+
+```
+template<class T, class U> std::unique_ptr<T>
+  static_pointer_cast(std::unique_ptr<U>&& p) noexcept;
+```
+::
+Requires::: The expression `static_cast<T*>((U*)0)` must be well-formed.
+Returns::: `std::unique_ptr<T>(static_cast<typename
+std::unique_ptr<T>::element_type*>(p.release()))`.
+
+CAUTION: The seemingly equivalent expression
+`std::unique_ptr<T>(static_cast<T*>(p.get()))` will eventually result in
+undefined behavior, attempting to delete the same object twice.
+
+### dynamic_pointer_cast
+
+```
+template<class T, class U> T* dynamic_pointer_cast(U* p) noexcept;
+```
+::
+Returns::: `dynamic_cast<T*>(p)`
+
+```
+template<class T, class U> std::shared_ptr<T>
+  dynamic_pointer_cast(const std::shared_ptr<U>& p) noexcept;
+```
+::
+Returns::: `std::dynamic_pointer_cast<T>(p)`
+
+```
+template<class T, class U> std::unique_ptr<T>
+  dynamic_pointer_cast(std::unique_ptr<U>&& p) noexcept;
+```
+::
+Requires:::
+* The expression `static_cast<T*>((U*)0)` must be well-formed.
+* `T` must have a virtual destructor.
+Returns:::
+* When `dynamic_cast<typename std::unique_ptr<T>::element_type*>(p.get())`
+returns a non-zero value, `std::unique_ptr<T>(dynamic_cast<typename
+std::unique_ptr<T>::element_type*>(p.release()));`.
+* Otherwise, `std::unique_ptr<T>()`.
+
+### const_pointer_cast
+
+```
+template<class T, class U> T* const_pointer_cast(U* p) noexcept;
+```
+::
+Returns::: `const_cast<T*>(p)`
+
+```
+template<class T, class U> std::shared_ptr<T>
+  const_pointer_cast(const std::shared_ptr<U>& p) noexcept;
+```
+::
+Returns::: `std::const_pointer_cast<T>(p)`
+
+```
+template<class T, class U> std::unique_ptr<T>
+  const_pointer_cast(std::unique_ptr<U>&& p) noexcept;
+```
+::
+Requires::: The expression `const_cast<T*>((U*)0)` must be well-formed.
+Returns::: `std::unique_ptr<T>(const_cast<typename
+std::unique_ptr<T>::element_type*>(p.release()))`.
+
+### reinterpret_pointer_cast
+
+```
+template<class T, class U> T* reinterpret_pointer_cast(U* p) noexcept;
+```
+::
+Returns::: `reinterpret_cast<T*>(p)`
+
+```
+template<class T, class U> std::shared_ptr<T>
+  reinterpret_pointer_cast(const std::shared_ptr<U>& p) noexcept;
+```
+::
+Returns::: `std::reinterpret_pointer_cast<T>(p)`
+
+```
+template<class T, class U> std::unique_ptr<T>
+  reinterpret_pointer_cast(std::unique_ptr<U>&& p) noexcept;
+```
+::
+Requires::: The expression `reinterpret_cast<T*>((U*)0)` must be well-formed.
+Returns::: `std::unique_ptr<T>(reinterpret_cast<typename
+std::unique_ptr<T>::element_type*>(p.release()))`.
+
+## Example
+
+The following example demonstrates how the generic pointer casts help us
+create pointer independent code.
+
+```
+#include <boost/pointer_cast.hpp>
+#include <boost/shared_ptr.hpp>
+
+class base {
+public:
+  virtual ~base() { }
+};
+
+class derived : public base { };
+
+template<class Ptr>
+void check_if_it_is_derived(const Ptr& ptr)
+{
+  assert(boost::dynamic_pointer_cast<derived>(ptr) != 0);
+}
+
+int main()
+{
+  base* ptr = new derived;
+  boost::shared_ptr<base> sptr(new derived);
+
+  check_if_it_is_derived(ptr);
+  check_if_it_is_derived(sptr);
+
+  delete ptr;
+}
+```

doc/smart_ptr/pointer_to_other.adoc

@@ -0,0 +1,114 @@
+////
+Copyright 2005, 2006 Ion Gaztañaga
+Copyright 2005, 2006, 2017 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
+////
+
+[#pointer_to_other]
+# pointer_to_other
+:toc:
+:toc-title:
+:idprefix: pointer_to_other_
+
+## Description
+
+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.
+
+There is test/example code in link:../../test/pointer_to_other_test.cpp[pointer_to_other_test.cpp].
+
+## Rationale
+
+When building pointer independent classes, like memory managers, allocators, or containers, there is often a need to
+define pointers generically, so that if a template parameter represents a pointer (for example, a raw or smart pointer
+to an `int`), we can define another pointer of the same type to another pointee (a raw or smart pointer to a `float`.)
+
+```
+template <class IntPtr> class FloatPointerHolder
+{
+    // Let's define a pointer to a float
+
+    typedef typename boost::pointer_to_other
+        <IntPtr, float>::type float_ptr_t;
+
+    float_ptr_t float_ptr;
+};
+```
+
+## Synopsis
+
+`pointer_to_other` is defined in `<boost/smart_ptr/pointer_to_other.hpp>`.
+
+```
+namespace boost {
+
+  template<class T, class U> struct pointer_to_other;
+
+  template<class T, class U,
+    template <class> class Sp>
+      struct pointer_to_other< Sp<T>, U >
+  {
+    typedef Sp<U> type;
+  };
+
+  template<class T, class T2, class U,
+    template <class, class> class Sp>
+      struct pointer_to_other< Sp<T, T2>, U >
+  {
+    typedef Sp<U, T2> type;
+  };
+
+  template<class T, class T2, class T3, class U,
+    template <class, class, class> class Sp>
+      struct pointer_to_other< Sp<T, T2, T3>, U >
+  {
+    typedef Sp<U, T2, T3> type;
+  };
+
+  template<class T, class U>
+    struct pointer_to_other< T*, U > 
+  {
+    typedef U* type;
+  };
+}
+```
+
+If these definitions are not correct for a specific smart pointer, we can define a specialization of `pointer_to_other`.
+
+## Example
+
+```
+// Let's define a memory allocator that can
+// work with raw and smart pointers
+
+#include <boost/pointer_to_other.hpp>
+
+template <class VoidPtr>
+class memory_allocator
+{
+    // Predefine a memory_block
+
+    struct block;
+
+    // Define a pointer to a memory_block from a void pointer
+    // If VoidPtr is void *, block_ptr_t is block*
+    // If VoidPtr is smart_ptr<void>, block_ptr_t is smart_ptr<block>
+
+    typedef typename boost::pointer_to_other
+        <VoidPtr, block>::type block_ptr_t;
+
+    struct block
+    {
+        std::size_t size;
+        block_ptr_t next_block;
+    };
+
+    block_ptr_t free_blocks;
+};
+```
+
+As we can see, using `pointer_to_other` we can create pointer independent code.

doc/smart_ptr/scoped_array.adoc

@@ -0,0 +1,175 @@
+////
+Copyright 1999 Greg Colvin and Beman Dawes
+Copyright 2002 Darin Adler
+Copyright 2002-2005, 2017 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
+////
+
+[#scoped_array]
+# scoped_array: Scoped Array Ownership
+:toc:
+:toc-title:
+:idprefix: scoped_array_
+
+## Description
+
+The `scoped_array` class template stores a pointer to a dynamically allocated array.
+(Dynamically allocated arrays are allocated with the {cpp} `new[]` expression.) The array
+pointed to is guaranteed to be deleted, either on destruction of the `scoped_array`,
+or via an explicit `reset`.
+
+The `scoped_array` template is a simple solution for simple needs. It supplies a basic
+"resource acquisition is initialization" facility, without shared-ownership or
+transfer-of-ownership semantics. Both its name and enforcement of semantics
+(by being  noncopyable) signal its intent to retain ownership solely within the current scope.
+Because it is noncopyable, it is safer than `shared_ptr<T[]>` for pointers which should not be copied.
+
+Because `scoped_array` is so simple, in its usual implementation every operation is as fast as a
+built-in array pointer and it has no more space overhead that a built-in array pointer.
+
+It cannot be used in {cpp} standard library containers. See `shared_ptr<T[]>` if `scoped_array`
+does not meet your needs.
+
+It cannot correctly hold a pointer to a single object. See `scoped_ptr` for that usage.
+
+`std::vector` is an alternative to `scoped_array` that is a bit heavier duty but far more flexible.
+`boost::array` is an alternative that does not use dynamic allocation.
+
+The class template is parameterized on `T`, the type of the object pointed to.
+
+## Synopsis
+
+`scoped_array` is defined in `<boost/smart_ptr/scoped_array.hpp>`.
+
+```
+namespace boost {
+
+  template<class T> class scoped_array {
+  private:
+
+    scoped_array(scoped_array const &);
+    scoped_array & operator=(scoped_array const &);
+
+    void operator==( scoped_array const& ) const;
+    void operator!=( scoped_array const& ) const;
+
+  public:
+
+    typedef T element_type;
+
+    explicit scoped_array(T * p = 0) noexcept;
+    ~scoped_array() noexcept;
+
+    void reset(T * p = 0) noexcept;
+
+    T & operator[](std::ptrdiff_t i) const noexcept;
+    T * get() const noexcept;
+
+    explicit operator bool () const noexcept;
+
+    void swap(scoped_array & b) noexcept;
+  };
+
+  template<class T> void swap(scoped_array<T> & a, scoped_array<T> & b) noexcept;
+
+  template<class T>
+    bool operator==( scoped_array<T> const & p, std::nullptr_t ) noexcept;
+  template<class T>
+    bool operator==( std::nullptr_t, scoped_array<T> const & p ) noexcept;
+
+  template<class T>
+    bool operator!=( scoped_array<T> const & p, std::nullptr_t ) noexcept;
+  template<class T>
+    bool operator!=( std::nullptr_t, scoped_array<T> const & p ) noexcept;
+}
+```
+
+## Members
+
+### element_type
+
+    typedef T element_type;
+
+Provides the type of the stored pointer.
+
+### constructors
+
+    explicit scoped_array(T * p = 0) noexcept;
+
+Constructs a `scoped_array`, storing a copy of `p`, which must have been
+allocated via a {cpp} `new[]` expression or be 0. `T` is not required be a complete type.
+
+### destructor
+
+    ~scoped_array() noexcept;
+
+Deletes the array pointed to by the stored pointer. Note that `delete[]` on a pointer with
+a value of 0 is harmless. `T` must be complete, and `delete[]` on the stored pointer must
+not throw exceptions.
+
+### reset
+
+    void reset(T * p = 0) noexcept;
+
+Deletes the array pointed to by the stored pointer and then stores a copy of `p`,
+which must have been allocated via a {cpp} `new[]` expression or be 0. `T` must be complete,
+and `delete[]` on the stored pointer must not throw exceptions.
+
+### subscripting
+
+    T & operator[](std::ptrdiff_t i) const noexcept;
+
+Returns a reference to element `i` of the array pointed to by the stored pointer.
+Behavior is undefined and almost certainly undesirable if the stored pointer is 0,
+or if `i` is less than 0 or is greater than or equal to the number of elements in
+the array.
+
+### get
+
+    T * get() const noexcept;
+
+Returns the stored pointer. `T` need not be a complete type.
+
+### conversions
+
+    explicit operator bool () const noexcept;
+
+Returns `get() != 0`.
+
+NOTE: On C++03 compilers, the return value is of an unspecified type.
+
+### swap
+
+    void swap(scoped_array & b) noexcept;
+
+Exchanges the contents of the two smart pointers. `T` need not be a complete type.
+
+## Free Functions
+
+### swap
+
+    template<class T> void swap(scoped_array<T> & a, scoped_array<T> & b) noexcept;
+
+Equivalent to `a.swap(b)`.
+
+### comparisons
+
+    template<class T>
+      bool operator==( scoped_array<T> const & p, std::nullptr_t ) noexcept;
+
+    template<class T>
+      bool operator==( std::nullptr_t, scoped_array<T> const & p ) noexcept;
+
+Returns `p.get() == nullptr`.
+
+    template<class T>
+      bool operator!=( scoped_array<T> const & p, std::nullptr_t ) noexcept;
+
+    template<class T>
+      bool operator!=( std::nullptr_t, scoped_array<T> const & p ) noexcept;
+
+Returns `p.get() != nullptr`.

doc/smart_ptr/scoped_ptr.adoc

@@ -0,0 +1,234 @@
+////
+Copyright 2017 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
+////
+
+[#scoped_ptr]
+# scoped_ptr: Scoped Object Ownership
+:toc:
+:toc-title:
+:idprefix: scoped_ptr_
+
+## Description
+
+The `scoped_ptr` class template stores a pointer to a dynamically allocated object.
+(Dynamically allocated objects are allocated with the {cpp} `new` expression.) The
+object pointed to is guaranteed to be deleted, either on destruction of the `scoped_ptr`,
+or via an explicit `reset`. See the <<scoped_ptr_example,example>>.
+
+`scoped_ptr` is a simple solution for simple needs. It supplies a basic "resource acquisition
+is initialization" facility, without shared-ownership or transfer-of-ownership semantics.
+Both its name and enforcement of semantics (by being  noncopyable) signal its intent to retain
+ownership solely within the current scope. Because it is noncopyable, it is safer than `shared_ptr`
+for pointers which should not be copied.
+
+Because `scoped_ptr` is simple, in its usual implementation every operation is as fast as for a
+built-in pointer and it has no more space overhead that a built-in pointer.
+
+`scoped_ptr` cannot be used in {cpp} Standard Library containers. Use `shared_ptr` or `std::unique_ptr`
+if you need a smart pointer that can.
+
+`scoped_ptr` cannot correctly hold a pointer to a dynamically allocated array. See `scoped_array` for that usage.
+
+The class template is parameterized on `T`, the type of the object pointed to. Destroying `T` must not thow exceptions,
+and `T` must be complete at the point `scoped_ptr<T>::~scoped_ptr` is instantiated.
+
+## Synopsis
+
+`scoped_ptr` is defined in `<boost/smart_ptr/scoped_ptr.hpp>`.
+
+```
+namespace boost {
+
+  template<class T> class scoped_ptr {
+  private:
+
+    scoped_ptr(scoped_ptr const&);
+    scoped_ptr& operator=(scoped_ptr const&);
+
+    void operator==(scoped_ptr const&) const;
+    void operator!=(scoped_ptr const&) const;
+
+  public:
+
+    typedef T element_type;
+
+    explicit scoped_ptr(T * p = 0) noexcept;
+    ~scoped_ptr() noexcept;
+
+    void reset(T * p = 0) noexcept;
+
+    T & operator*() const noexcept;
+    T * operator->() const noexcept;
+    T * get() const noexcept;
+
+    explicit operator bool() const noexcept;
+
+    void swap(scoped_ptr & b) noexcept;
+  };
+
+  template<class T> void swap(scoped_ptr<T> & a, scoped_ptr<T> & b) noexcept;
+
+  template<class T>
+    bool operator==( scoped_ptr<T> const & p, std::nullptr_t ) noexcept;
+  template<class T>
+    bool operator==( std::nullptr_t, scoped_ptr<T> const & p ) noexcept;
+
+  template<class T>
+    bool operator!=( scoped_ptr<T> const & p, std::nullptr_t ) noexcept;
+  template<class T>
+    bool operator!=( std::nullptr_t, scoped_ptr<T> const & p ) noexcept;
+}
+```
+
+## Members
+
+### element_type
+
+    typedef T element_type;
+
+Provides the type of the stored pointer.
+
+### constructor
+
+    explicit scoped_ptr(T * p = 0) noexcept;
+
+Constructs a `scoped_ptr`, storing a copy of `p`, which must have been allocated via a
+{cpp} `new` expression or be 0. `T` is not required be a complete type.
+
+### destructor
+
+    ~scoped_ptr() noexcept;
+
+Destroys the object pointed to by the stored pointer, if any, as if by using
+`delete this\->get()`. `T` must be a complete type.
+
+### reset
+
+    void reset(T * p = 0) noexcept;
+
+Deletes the object pointed to by the stored pointer and then stores a copy of
+`p`, which must have been allocated via a {cpp} `new` expression or be 0.
+
+Since the previous object needs to be deleted, `T` must be a complete type.
+
+### indirection
+
+    T & operator*() const noexcept;
+
+Returns a reference to the object pointed to by the stored pointer. Behavior is undefined if the stored pointer is 0.
+
+    T * operator->() const noexcept;
+
+Returns the stored pointer. Behavior is undefined if the stored pointer is 0.
+
+### get
+
+    T * get() const noexcept;
+
+Returns the stored pointer. `T` need not be a complete type.
+
+### conversions
+
+    explicit operator bool () const noexcept; // never throws
+
+Returns `get() != 0`.
+
+NOTE: On C++03 compilers, the return value is of an unspecified type.
+
+### swap
+
+    void swap(scoped_ptr & b) noexcept;
+
+Exchanges the contents of the two smart pointers. `T` need not be a complete type.
+
+## Free Functions
+
+### swap
+
+    template<class T> void swap(scoped_ptr<T> & a, scoped_ptr<T> & b) noexcept;
+
+Equivalent to `a.swap(b)`.
+
+### comparisons
+
+    template<class T> bool operator==( scoped_ptr<T> const & p, std::nullptr_t ) noexcept;
+
+    template<class T> bool operator==( std::nullptr_t, scoped_ptr<T> const & p ) noexcept;
+
+Returns `p.get() == nullptr`.
+
+    template<class T> bool operator!=( scoped_ptr<T> const & p, std::nullptr_t ) noexcept;
+
+    template<class T> bool operator!=( std::nullptr_t, scoped_ptr<T> const & p ) noexcept;
+
+Returns `p.get() != nullptr`.
+
+## Example
+
+Here's an example that uses `scoped_ptr`.
+
+```
+#include <boost/scoped_ptr.hpp>
+#include <iostream>
+
+struct Shoe { ~Shoe() { std::cout << "Buckle my shoe\n"; } };
+
+class MyClass {
+    boost::scoped_ptr<int> ptr;
+  public:
+    MyClass() : ptr(new int) { *ptr = 0; }
+    int add_one() { return ++*ptr; }
+};
+
+int main()
+{
+    boost::scoped_ptr<Shoe> x(new Shoe);
+    MyClass my_instance;
+    std::cout << my_instance.add_one() << '\n';
+    std::cout << my_instance.add_one() << '\n';
+}
+```
+
+The example program produces the beginning of a child's nursery rhyme:
+
+```
+1
+2
+Buckle my shoe
+```
+
+## Rationale
+
+The primary reason to use `scoped_ptr` rather than `std::auto_ptr` or `std::unique_ptr` is to let readers of your code
+know that you intend "resource acquisition is initialization" to be applied only for the current scope, and have no intent to transfer ownership.
+
+A secondary reason to use `scoped_ptr` is to prevent a later maintenance programmer from adding a function that transfers
+ownership by returning the `auto_ptr`, because the maintenance programmer saw `auto_ptr`, and assumed ownership could safely be transferred.
+
+Think of `bool` vs `int`. We all know that under the covers `bool` is usually just an `int`. Indeed, some argued against including bool in the {cpp}
+standard because of that. But by coding `bool` rather than `int`, you tell your readers what your intent is. Same with `scoped_ptr`; by using it you are signaling intent.
+
+It has been suggested that `scoped_ptr<T>` is equivalent to `std::auto_ptr<T> const`. Ed Brey pointed out, however, that `reset` will not work on a `std::auto_ptr<T> const`.
+
+## Handle/Body Idiom
+
+One common usage of `scoped_ptr` is to implement a handle/body (also called pimpl) idiom which avoids exposing the body (implementation) in the header file.
+
+The `link:../../example/scoped_ptr_example_test.cpp[scoped_ptr_example_test.cpp]` sample program includes a header file,
+`link:../../example/scoped_ptr_example.hpp[scoped_ptr_example.hpp]`, which uses a `scoped_ptr<>` to an incomplete type to hide the
+implementation. The instantiation of member functions which require a complete type occurs in the `link:../../example/scoped_ptr_example.cpp[scoped_ptr_example.cpp]`
+implementation file.
+
+## Frequently Asked Questions
+
+[qanda]
+Why doesn't `scoped_ptr` have a `release()` member?::
+
+  When reading source code, it is valuable to be able to draw conclusions about program behavior based on the types being used. If `scoped_ptr` had a `release()` member,
+  it would become possible to transfer ownership of the held pointer, weakening its role as a way of limiting resource lifetime to a given context. Use `std::auto_ptr` where
+  transfer of ownership is required. (supplied by Dave Abrahams)

doc/smart_ptr/shared_array.adoc

@@ -0,0 +1,270 @@
+////
+Copyright 2017 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
+////
+
+[[shared_array]]
+[appendix]
+# shared_array (deprecated)
+:toc:
+:toc-title:
+:idprefix: shared_array_
+
+NOTE: This facility is deprecated because a `shared_ptr` to `T[]` or `T[N]`
+is now available, and is superior in every regard.
+
+## Description
+
+The `shared_array` class template stores a pointer to a dynamically allocated
+array. (Dynamically allocated array are allocated with the C++ `new[]`
+expression.) The object pointed to is guaranteed to be deleted when the last
+`shared_array` pointing to it is destroyed or reset.
+
+Every `shared_array` meets the _CopyConstructible_ and _Assignable_
+requirements of the {cpp} Standard Library, and so can be used in standard
+library containers. Comparison operators are supplied so that shared_array
+works with the standard library's associative containers.
+
+Normally, a `shared_array` cannot correctly hold a pointer to an object that
+has been allocated with the non-array form of `new`. See `shared_ptr` for that
+usage.
+
+Because the implementation uses reference counting, cycles of `shared_array`
+instances will not be reclaimed. For example, if `main` holds a shared_array
+to `A`, which directly or indirectly holds a shared_array back to `A`, the use
+count of `A` will be 2. Destruction of the original `shared_array` will leave
+`A` dangling with a use count of 1.
+
+A `shared_ptr` to a `std::vector` is an alternative to a `shared_array` that
+is a bit heavier duty but far more flexible.
+
+The class template is parameterized on `T`, the type of the object pointed to.
+`shared_array` and most of its member functions place no requirements on `T`;
+it is allowed to be an incomplete type, or `void`. Member functions that do
+place additional requirements (constructors, reset) are explicitly documented
+below.
+
+## Synopsis
+
+```
+namespace boost {
+
+  template<class T> class shared_array {
+  public:
+    typedef T element_type;
+
+    explicit shared_array(T* p = 0);
+    template<class D> shared_array(T* p, D d);
+    shared_array(const shared_array& v) noexcept;
+
+    ~shared_array() noexcept;
+
+    shared_array& operator=(const shared_array& v) noexcept;
+
+    void reset(T* p = 0);
+    template<class D> void reset(T* p, D d);
+
+    T& operator[](std::ptrdiff_t n) const noexcept;
+    T* get() const noexcept;
+
+    bool unique() const noexcept;
+    long use_count() const noexcept;
+
+    explicit operator bool() const noexcept;
+
+    void swap(shared_array<T>& v) noexcept;
+  };
+
+  template<class T> bool
+    operator==(const shared_array<T>& a, const shared_array<T>& b) noexcept;
+  template<class T> bool
+    operator!=(const shared_array<T>& a, const shared_array<T>& b) noexcept;
+  template<class T> bool
+    operator<(const shared_array<T>& a, const shared_array<T>& b) noexcept;
+
+  template<class T>
+    void swap(shared_array<T>& a, shared_array<T>& b) noexcept;
+}
+```
+
+## Members
+
+### element_type
+
+```
+typedef T element_type;
+```
+Type:: Provides the type of the stored pointer.
+
+### Constructors
+
+```
+explicit shared_array(T* p = 0);
+```
+::
+Effects::: Constructs a `shared_array`, storing a copy of `p`, which must be a
+pointer to an array that was allocated via a C++ `new[]` expression or be 0.
+Afterwards, the use count is 1 (even if `p == 0`; see `~shared_array`).
+Requires::: `T` is a complete type.
+Throws::: `std::bad_alloc`. If an exception is thrown, `delete[] p` is called.
+
+```
+template<class D> shared_array(T* p, D d);
+```
+::
+Effects::: Constructs a `shared_array`, storing a copy of `p` and of `d`.
+Afterwards, the use count is 1. When the the time comes to delete the array
+pointed to by `p`, the object `d` is used in the statement `d(p)`.
+Requires:::
+* `T` is a complete type.
+* The copy constructor and destructor of `D` must not throw.
+* Invoking the object `d` with parameter `p` must not throw.
+Throws::: `std::bad_alloc`. If an exception is thrown, `d(p)` is called.
+
+```
+shared_array(const shared_array& v) noexcept;
+```
+::
+Effects::: Constructs a `shared_array`, as if by storing a copy of the pointer
+stored in `v`. Afterwards, the use count for all copies is 1 more than the
+initial use count.
+Requires::: `T` is a complete type.
+
+### Destructor
+
+```
+~shared_array() noexcept;
+```
+::
+Effects::: Decrements the use count. Then, if the use count is 0, deletes the
+array pointed to by the stored pointer. Note that `delete[]` on a pointer with
+a value of 0 is harmless. 
+
+### Assignment
+
+```
+shared_array& operator=(const shared_array& v) noexcept;
+```
+::
+Effects::: Constructs a new `shared_array` as described above, then replaces
+this `shared_array` with the new one, destroying the replaced object.
+Requires::: `T` is a complete type.
+Returns::: `*this`.
+
+### reset
+
+```
+void reset(T* p = 0);
+```
+::
+Effects::: Constructs a new `shared_array` as described above, then replaces
+this `shared_array` with the new one, destroying the replaced object.
+Requires::: `T` is a complete type.
+Throws::: `std::bad_alloc`. If an exception is thrown, `delete[] p` is called.
+
+```
+template<class D> void reset(T* p, D d);
+```
+::
+Effects::: Constructs a new `shared_array` as described above, then replaces
+this `shared_array` with the new one, destroying the replaced object.
+Requires:::
+* `T` is a complete type.
+* The copy constructor of `D` must not throw.
+Throws::: `std::bad_alloc`. If an exception is thrown, `d(p)` is called.
+
+### Indexing
+
+```
+T& operator[](std::ptrdiff_t n) const noexcept;
+```
+Returns::: A reference to element `n` of the array pointed to by the stored
+pointer. Behavior is undefined and almost certainly undesirable if the stored
+pointer is 0, or if `n` is less than 0 or is greater than or equal to the
+number of elements in the array.
+Requires::: `T` is a complete type.
+
+### get
+
+```
+T* get() const noexcept;
+```
+::
+Returns::: The stored pointer.
+
+### unique
+
+```
+bool unique() const noexcept;
+```
+::
+Returns::: `true` if no other `shared_array` is sharing ownership of the
+stored pointer, `false` otherwise.
+
+### use_count
+
+```
+long use_count() const noexcept;
+```
+::
+Returns::: The number of `shared_array` objects sharing ownership of the
+stored pointer.
+
+### Conversions
+
+```
+explicit operator bool() const noexcept;
+```
+::
+Returns::: `get() != 0`.
+Requires::: `T` is a complete type.
+
+### swap
+
+```
+void swap(shared_array<T>& b) noexcept;
+```
+::
+Effects::: Exchanges the contents of the two smart pointers.
+
+## Free Functions
+
+### Comparison
+
+```
+template<class T> bool
+  operator==(const shared_array<T>& a, const shared_array<T>& b) noexcept;
+```
+```
+template<class T> bool
+  operator!=(const shared_array<T>& a, const shared_array<T>& b) noexcept;
+```
+```
+template<class T> bool
+  operator<(const shared_array<T>& a, const shared_array<T>& b) noexcept;
+```
+::
+Returns::: The result of comparing the stored pointers of the two smart
+pointers.
+
+NOTE: The `operator<` overload is provided to define an ordering so that
+`shared_array` objects can be used in associative containers such as
+`std::map`. The implementation uses `std::less<T*>` to perform the comparison.
+This ensures that the comparison is handled correctly, since the standard
+mandates that relational operations on pointers are unspecified (5.9
+[expr.rel] paragraph 2) but `std::less` on pointers is well-defined (20.3.3
+[lib.comparisons] paragraph 8).
+
+### swap
+
+```
+template<class T>
+  void swap(shared_array<T>& a, shared_array<T>& b) noexcept;
+```
+::
+Returns::: `a.swap(b)`.
+Requires::: `T` is a complete type.

doc/smart_ptr/techniques.adoc

@@ -0,0 +1,768 @@
+////
+Copyright 2003, 2017 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
+////
+
+[[techniques]]
+[appendix]
+# Smart Pointer Programming Techniques
+:toc:
+:toc-title:
+:idprefix: techniques_
+
+[#techniques_incomplete]
+## Using incomplete classes for implementation hiding
+
+A proven technique (that works in C, too) for separating interface from implementation is to use a pointer to an incomplete class as an opaque handle:
+
+```
+class FILE;
+
+FILE * fopen(char const * name, char const * mode);
+void fread(FILE * f, void * data, size_t size);
+void fclose(FILE * f);
+```
+
+
+It is possible to express the above interface using `shared_ptr`, eliminating the need to manually call `fclose`:
+
+```
+class FILE;
+
+shared_ptr<FILE> fopen(char const * name, char const * mode);
+void fread(shared_ptr<FILE> f, void * data, size_t size);
+```
+
+This technique relies on `shared_ptr`&#8217;s ability to execute a custom deleter, eliminating the explicit call to `fclose`, and on the fact that `shared_ptr<X>` can be copied and destroyed when `X` is incomplete.
+
+## The "Pimpl" idiom
+
+A {cpp} specific variation of the incomplete class pattern is the "Pimpl" idiom. The incomplete class is not exposed to the user; it is hidden behind a forwarding facade. `shared_ptr` can be used to implement a "Pimpl":
+
+```
+// file.hpp:
+
+class file
+{
+private:
+
+    class impl;
+    shared_ptr<impl> pimpl_;
+
+public:
+
+    file(char const * name, char const * mode);
+
+    // compiler generated members are fine and useful
+
+    void read(void * data, size_t size);
+};
+
+// file.cpp:
+
+#include "file.hpp"
+
+class file::impl
+{
+private:
+
+    impl(impl const &);
+    impl & operator=(impl const &);
+
+    // private data
+
+public:
+
+    impl(char const * name, char const * mode) { ... }
+    ~impl() { ... }
+    void read(void * data, size_t size) { ... }
+};
+
+file::file(char const * name, char const * mode): pimpl_(new impl(name, mode))
+{
+}
+
+void file::read(void * data, size_t size)
+{
+    pimpl_->read(data, size);
+}
+```
+
+The key thing to note here is that the compiler-generated copy constructor, assignment operator, and destructor all have a sensible meaning. As a result, `file` is `CopyConstructible` and `Assignable`, allowing its use in standard containers.
+
+## Using abstract classes for implementation hiding
+
+Another widely used C++ idiom for separating inteface and implementation is to use abstract base classes and factory functions.
+The abstract classes are sometimes called "interfaces" and the pattern is known as "interface-based programming". Again,
+`shared_ptr` can be used as the return type of the factory functions:
+
+```
+// X.hpp:
+
+class X
+{
+public:
+
+    virtual void f() = 0;
+    virtual void g() = 0;
+
+protected:
+
+    ~X() {}
+};
+
+shared_ptr<X> createX();
+
+// X.cpp:
+
+class X_impl: public X
+{
+private:
+
+    X_impl(X_impl const &);
+    X_impl & operator=(X_impl const &);
+
+public:
+
+    virtual void f()
+    {
+      // ...
+    }
+
+    virtual void g()
+    {
+      // ...
+    }
+};
+
+shared_ptr<X> createX()
+{
+    shared_ptr<X> px(new X_impl);
+    return px;
+}
+```
+
+A key property of `shared_ptr` is that the allocation, construction, deallocation, and destruction details are captured at the point of construction, inside the factory function.
+
+Note the protected and nonvirtual destructor in the example above. The client code cannot, and does not need to, delete a pointer to `X`; the `shared_ptr<X>` instance returned from `createX` will correctly call `~X_impl`.
+
+## Preventing `delete px.get()`
+
+It is often desirable to prevent client code from deleting a pointer that is being managed by `shared_ptr`. The previous technique showed one possible approach, using a protected destructor. Another alternative is to use a private deleter:
+
+```
+class X
+{
+private:
+
+    ~X();
+
+    class deleter;
+    friend class deleter;
+
+    class deleter
+    {
+    public:
+
+        void operator()(X * p) { delete p; }
+    };
+
+public:
+
+    static shared_ptr<X> create()
+    {
+        shared_ptr<X> px(new X, X::deleter());
+        return px;
+    }
+};
+```
+
+## Encapsulating allocation details, wrapping factory functions
+
+`shared_ptr` can be used in creating {cpp} wrappers over existing C style library interfaces that return raw pointers from their factory functions
+to encapsulate allocation details. As an example, consider this interface, where `CreateX` might allocate `X` from its own private heap, `~X` may
+be inaccessible, or `X` may be incomplete:
+
+    X * CreateX();
+    void DestroyX(X *);
+
+The only way to reliably destroy a pointer returned by `CreateX` is to call `DestroyX`.
+
+Here is how a `shared_ptr`-based wrapper may look like:
+
+    shared_ptr<X> createX()
+    {
+        shared_ptr<X> px(CreateX(), DestroyX);
+        return px;
+    }
+
+Client code that calls `createX` still does not need to know how the object has been allocated, but now the destruction is automatic.
+
+[#techniques_static]
+## Using a shared_ptr to hold a pointer to a statically allocated object
+
+Sometimes it is desirable to create a `shared_ptr` to an already existing object, so that the `shared_ptr` does not attempt to destroy the
+object when there are no more references left. As an example, the factory function:
+
+    shared_ptr<X> createX();
+
+in certain situations may need to return a pointer to a statically allocated `X` instance.
+
+The solution is to use a custom deleter that does nothing:
+
+```
+struct null_deleter
+{
+    void operator()(void const *) const
+    {
+    }
+};
+
+static X x;
+
+shared_ptr<X> createX()
+{
+    shared_ptr<X> px(&x, null_deleter());
+    return px;
+}
+```
+
+The same technique works for any object known to outlive the pointer.
+
+## Using a shared_ptr to hold a pointer to a COM Object
+
+Background: COM objects have an embedded reference count and two member functions that manipulate it. `AddRef()` increments the count.
+`Release()` decrements the count and destroys itself when the count drops to zero.
+
+It is possible to hold a pointer to a COM object in a `shared_ptr`:
+
+    shared_ptr<IWhatever> make_shared_from_COM(IWhatever * p)
+    {
+        p->AddRef();
+        shared_ptr<IWhatever> pw(p, mem_fn(&IWhatever::Release));
+        return pw;
+    }
+
+Note, however, that `shared_ptr` copies created from `pw` will not "register" in the embedded count of the COM object;
+they will share the single reference created in `make_shared_from_COM`. Weak pointers created from `pw` will be invalidated when the last
+`shared_ptr` is destroyed, regardless of whether the COM object itself is still alive.
+
+As link:../../libs/bind/mem_fn.html#Q3[explained] in the `mem_fn` documentation, you need to `#define BOOST_MEM_FN_ENABLE_STDCALL` first.
+
+[#techniques_intrusive]
+## Using a shared_ptr to hold a pointer to an object with an embedded reference count
+
+This is a generalization of the above technique. The example assumes that the object implements the two functions required by `<<intrusive_ptr,intrusive_ptr>>`,
+`intrusive_ptr_add_ref` and `intrusive_ptr_release`:
+
+```
+template<class T> struct intrusive_deleter
+{
+    void operator()(T * p)
+    {
+        if(p) intrusive_ptr_release(p);
+    }
+};
+
+shared_ptr<X> make_shared_from_intrusive(X * p)
+{
+    if(p) intrusive_ptr_add_ref(p);
+    shared_ptr<X> px(p, intrusive_deleter<X>());
+    return px;
+}
+```
+
+## Using a shared_ptr to hold another shared ownership smart pointer
+
+One of the design goals of `shared_ptr` is to be used in library interfaces. It is possible to encounter a situation where a library takes a
+`shared_ptr` argument, but the object at hand is being managed by a different reference counted or linked smart pointer.
+
+It is possible to exploit `shared_ptr`&#8217;s custom deleter feature to wrap this existing smart pointer behind a `shared_ptr` facade:
+
+```
+template<class P> struct smart_pointer_deleter
+{
+private:
+
+    P p_;
+
+public:
+
+    smart_pointer_deleter(P const & p): p_(p)
+    {
+    }
+
+    void operator()(void const *)
+    {
+        p_.reset();
+    }
+    
+    P const & get() const
+    {
+        return p_;
+    }
+};
+
+shared_ptr<X> make_shared_from_another(another_ptr<X> qx)
+{
+    shared_ptr<X> px(qx.get(), smart_pointer_deleter< another_ptr<X> >(qx));
+    return px;
+}
+```
+
+One subtle point is that deleters are not allowed to throw exceptions, and the above example as written assumes that `p_.reset()` doesn't throw.
+If this is not the case, `p_.reset();` should be wrapped in a `try {} catch(...) {}` block that ignores exceptions. In the (usually unlikely) event
+when an exception is thrown and ignored, `p_` will be released when the lifetime of the deleter ends. This happens when all references, including
+weak pointers, are destroyed or reset.
+
+Another twist is that it is possible, given the above `shared_ptr` instance, to recover the original smart pointer, using `<<shared_ptr_get_deleter,get_deleter>>`:
+
+```
+void extract_another_from_shared(shared_ptr<X> px)
+{
+    typedef smart_pointer_deleter< another_ptr<X> > deleter;
+
+    if(deleter const * pd = get_deleter<deleter>(px))
+    {
+        another_ptr<X> qx = pd->get();
+    }
+    else
+    {
+        // not one of ours
+    }
+}
+```
+
+[#techniques_from_raw]
+## Obtaining a shared_ptr from a raw pointer
+
+Sometimes it is necessary to obtain a `shared_ptr` given a raw pointer to an object that is already managed by another `shared_ptr` instance. Example:
+
+    void f(X * p)
+    {
+        shared_ptr<X> px(???);
+    }
+
+Inside `f`, we'd like to create a `shared_ptr` to `*p`.
+
+In the general case, this problem has no solution. One approach is to modify `f` to take a `shared_ptr`, if possible:
+
+    void f(shared_ptr<X> px);
+
+The same transformation can be used for nonvirtual member functions, to convert the implicit `this`:
+
+    void X::f(int m);
+
+would become a free function with a `shared_ptr` first argument:
+
+    void f(shared_ptr<X> this_, int m);
+
+If `f` cannot be changed, but `X` uses intrusive counting, use `<<techniques_intrusive,make_shared_from_intrusive>>` described above. Or, if it's known that the `shared_ptr` created in `f` will never outlive the object, use <<techniques_static,a null deleter>>.
+
+## Obtaining a shared_ptr (weak_ptr) to this in a constructor
+
+Some designs require objects to register themselves on construction with a central authority. When the registration routines take a `shared_ptr`, this leads to the question how could a constructor obtain a `shared_ptr` to `this`:
+
+```
+class X
+{
+public:
+
+    X()
+    {
+        shared_ptr<X> this_(???);
+    }
+};
+```
+
+In the general case, the problem cannot be solved. The `X` instance being constructed can be an automatic variable or a static variable; it can be created on the heap:
+
+    shared_ptr<X> px(new X);
+
+but at construction time, `px` does not exist yet, and it is impossible to create another `shared_ptr` instance that shares ownership with it.
+
+Depending on context, if the inner `shared_ptr this_` doesn't need to keep the object alive, use a `null_deleter` as explained <<techniques_static,here>> and <<techniques_weak_without_shared,here>>.
+If `X` is supposed to always live on the heap, and be managed by a `shared_ptr`, use a static factory function:
+
+```
+class X
+{
+private:
+
+    X() { ... }
+
+public:
+
+    static shared_ptr<X> create()
+    {
+        shared_ptr<X> px(new X);
+        // use px as 'this_'
+        return px;
+    }
+};
+```
+
+## Obtaining a shared_ptr to this
+
+Sometimes it is needed to obtain a `shared_ptr` from `this` in a virtual member function under the assumption that `this` is already managed by a `shared_ptr`.
+The transformations <<techniques_from_raw,described in the previous technique>> cannot be applied.
+
+A typical example:
+
+```
+class X
+{
+public:
+
+    virtual void f() = 0;
+
+protected:
+
+    ~X() {}
+};
+
+class Y
+{
+public:
+
+    virtual shared_ptr<X> getX() = 0;
+
+protected:
+
+    ~Y() {}
+};
+
+// --
+
+class impl: public X, public Y
+{
+public:
+
+    impl() { ... }
+
+    virtual void f() { ... }
+
+    virtual shared_ptr<X> getX()
+    {
+        shared_ptr<X> px(???);
+        return px;
+    }
+};
+```
+
+The solution is to keep a weak pointer to `this` as a member in `impl`:
+
+```
+class impl: public X, public Y
+{
+private:
+
+    weak_ptr<impl> weak_this;
+
+    impl(impl const &);
+    impl & operator=(impl const &);
+
+    impl() { ... }
+
+public:
+
+    static shared_ptr<impl> create()
+    {
+        shared_ptr<impl> pi(new impl);
+        pi->weak_this = pi;
+        return pi;
+    }
+
+    virtual void f() { ... }
+
+    virtual shared_ptr<X> getX()
+    {
+        shared_ptr<X> px(weak_this);
+        return px;
+    }
+};
+```
+
+The library now includes a helper class template `<<enable_shared_from_this,enable_shared_from_this>>` that can be used to encapsulate the solution:
+
+```
+class impl: public X, public Y, public enable_shared_from_this<impl>
+{
+public:
+
+    impl(impl const &);
+    impl & operator=(impl const &);
+
+public:
+
+    virtual void f() { ... }
+
+    virtual shared_ptr<X> getX()
+    {
+        return shared_from_this();
+    }
+}
+```
+
+Note that you no longer need to manually initialize the `weak_ptr` member in `enable_shared_from_this`. Constructing a `shared_ptr` to `impl` takes care of that.
+
+## Using shared_ptr as a smart counted handle
+
+Some library interfaces use opaque handles, a variation of the <<techniques_incomplete,incomplete class technique>> described above. An example:
+
+```
+typedef void * HANDLE;
+
+HANDLE CreateProcess();
+void CloseHandle(HANDLE);
+```
+
+Instead of a raw pointer, it is possible to use `shared_ptr` as the handle and get reference counting and automatic resource management for free:
+
+```
+typedef shared_ptr<void> handle;
+
+handle createProcess()
+{
+    shared_ptr<void> pv(CreateProcess(), CloseHandle);
+    return pv;
+}
+```
+
+## Using shared_ptr to execute code on block exit
+
+`shared_ptr<void>` can automatically execute cleanup code when control leaves a scope.
+
+* Executing `f(p)`, where `p` is a pointer:
++
+```
+shared_ptr<void> guard(p, f);
+```
+
+* Executing arbitrary code: `f(x, y)`:
++
+```
+shared_ptr<void> guard(static_cast<void*>(0), bind(f, x, y));
+```
+
+## Using shared_ptr<void> to hold an arbitrary object
+
+`shared_ptr<void>` can act as a generic object pointer similar to `void*`. When a `shared_ptr<void>` instance constructed as:
+
+    shared_ptr<void> pv(new X);
+
+is destroyed, it will correctly dispose of the `X` object by executing `~X`.
+
+This propery can be used in much the same manner as a raw `void*` is used to temporarily strip type information from an object pointer.
+A `shared_ptr<void>` can later be cast back to the correct type by using `<<shared_ptr_static_pointer_cast,static_pointer_cast>>`.
+
+## Associating arbitrary data with heterogeneous `shared_ptr` instances
+
+`shared_ptr` and `weak_ptr` support `operator<` comparisons required by standard associative containers such as `std::map`. This can be
+used to non-intrusively associate arbitrary data with objects managed by `shared_ptr`:
+
+```
+typedef int Data;
+
+std::map<shared_ptr<void>, Data> userData;
+// or std::map<weak_ptr<void>, Data> userData; to not affect the lifetime
+
+shared_ptr<X> px(new X);
+shared_ptr<int> pi(new int(3));
+
+userData[px] = 42;
+userData[pi] = 91;
+```
+
+## Using `shared_ptr` as a `CopyConstructible` mutex lock
+
+Sometimes it's necessary to return a mutex lock from a function, and a noncopyable lock cannot be returned by value. It is possible to use `shared_ptr` as a mutex lock:
+
+```
+class mutex
+{
+public:
+
+    void lock();
+    void unlock();
+};
+
+shared_ptr<mutex> lock(mutex & m)
+{
+    m.lock();
+    return shared_ptr<mutex>(&m, mem_fn(&mutex::unlock));
+}
+```
+
+Better yet, the `shared_ptr` instance acting as a lock can be encapsulated in a dedicated `shared_lock` class:
+
+```
+class shared_lock
+{
+private:
+
+    shared_ptr<void> pv;
+
+public:
+
+    template<class Mutex> explicit shared_lock(Mutex & m): pv((m.lock(), &m), mem_fn(&Mutex::unlock)) {}
+};
+```
+
+`shared_lock` can now be used as:
+
+    shared_lock lock(m);
+
+Note that `shared_lock` is not templated on the mutex type, thanks to `shared_ptr<void>`&#8217;s ability to hide type information.
+
+## Using shared_ptr to wrap member function calls
+
+`shared_ptr` implements the ownership semantics required from the `Wrap/CallProxy` scheme described in Bjarne Stroustrup's article
+"Wrapping C++ Member Function Calls" (available online at http://www.stroustrup.com/wrapper.pdf). An implementation is given below:
+
+```
+template<class T> class pointer
+{
+private:
+
+    T * p_;
+
+public:
+
+    explicit pointer(T * p): p_(p)
+    {
+    }
+
+    shared_ptr<T> operator->() const
+    {
+        p_->prefix();
+        return shared_ptr<T>(p_, mem_fn(&T::suffix));
+    }
+};
+
+class X
+{
+private:
+
+    void prefix();
+    void suffix();
+    friend class pointer<X>;
+    
+public:
+
+    void f();
+    void g();
+};
+
+int main()
+{
+    X x;
+
+    pointer<X> px(&x);
+
+    px->f();
+    px->g();
+}
+```
+
+## Delayed deallocation
+
+In some situations, a single `px.reset()` can trigger an expensive deallocation in a performance-critical region:
+
+```
+class X; // ~X is expensive
+
+class Y
+{
+    shared_ptr<X> px;
+
+public:
+
+    void f()
+    {
+        px.reset();
+    }
+};
+```
+
+The solution is to postpone the potential deallocation by moving `px` to a dedicated free list that can be periodically emptied when performance and response times are not an issue:
+
+```
+vector< shared_ptr<void> > free_list;
+
+class Y
+{
+    shared_ptr<X> px;
+
+public:
+
+    void f()
+    {
+        free_list.push_back(px);
+        px.reset();
+    }
+};
+
+// periodically invoke free_list.clear() when convenient
+```
+
+Another variation is to move the free list logic to the construction point by using a delayed deleter:
+
+```
+struct delayed_deleter
+{
+    template<class T> void operator()(T * p)
+    {
+        try
+        {
+            shared_ptr<void> pv(p);
+            free_list.push_back(pv);
+        }
+        catch(...)
+        {
+        }
+    }
+};
+```
+
+[#techniques_weak_without_shared]
+## Weak pointers to objects not managed by a shared_ptr
+
+Make the object hold a `shared_ptr` to itself, using a `null_deleter`:
+
+```
+class X
+{
+private:
+
+    shared_ptr<X> this_;
+    int i_;
+
+public:
+
+    explicit X(int i): this_(this, null_deleter()), i_(i)
+    {
+    }
+
+    // repeat in all constructors (including the copy constructor!)
+
+    X(X const & rhs): this_(this, null_deleter()), i_(rhs.i_)
+    {
+    }
+
+    // do not forget to not assign this_ in the copy assignment
+
+    X & operator=(X const & rhs)
+    {
+        i_ = rhs.i_;
+    }
+
+    weak_ptr<X> get_weak_ptr() const { return this_; }
+};
+```
+
+When the object's lifetime ends, `X::this_` will be destroyed, and all weak pointers will automatically expire.

doc/smart_ptr/weak_ptr.adoc

@@ -0,0 +1,298 @@
+////
+Copyright 1999 Greg Colvin and Beman Dawes
+Copyright 2002 Darin Adler
+Copyright 2002-2005, 2017 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
+////
+
+[#weak_ptr]
+# weak_ptr: Non-owning Observer
+:toc:
+:toc-title:
+:idprefix: weak_ptr_
+
+## Description
+
+The `weak_ptr` class template stores a "weak reference" to an object that's already managed by a `shared_ptr`.
+To access the object, a `weak_ptr` can be converted to a `shared_ptr` using the `shared_ptr` constructor taking
+`weak_ptr`, or the `weak_ptr` member function `lock`. When the last `shared_ptr` to the object goes away and the
+object is deleted, the attempt to obtain a `shared_ptr` from the `weak_ptr` instances that refer to the deleted
+object will fail: the constructor will throw an exception of type `boost::bad_weak_ptr`, and `weak_ptr::lock` will
+return an empty `shared_ptr`.
+
+Every `weak_ptr` meets the `CopyConstructible` and `Assignable` requirements of the {cpp} Standard Library, and so
+can be used in standard library containers. Comparison operators are supplied so that `weak_ptr` works with the standard
+library's associative containers.
+
+`weak_ptr` operations never throw exceptions.
+
+The class template is parameterized on `T`, the type of the object pointed to.
+
+Compared to `shared_ptr`, `weak_ptr` provides a very limited subset of operations since accessing its stored pointer is
+often dangerous in multithreaded programs, and sometimes unsafe even within a single thread (that is, it may invoke undefined
+behavior.) Pretend for a moment that `weak_ptr` had a get member function that returned a raw pointer, and consider this innocent
+piece of code:
+
+```
+shared_ptr<int> p(new int(5));
+weak_ptr<int> q(p);
+
+// some time later
+
+if(int * r = q.get())
+{
+    // use *r
+}
+```
+
+Imagine that after the `if`, but immediately before `r` is used, another thread executes the statement `p.reset()`. Now `r` is a dangling pointer.
+
+The solution to this problem is to create a temporary `shared_ptr` from `q`:
+
+```
+shared_ptr<int> p(new int(5));
+weak_ptr<int> q(p);
+
+// some time later
+
+if(shared_ptr<int> r = q.lock())
+{
+    // use *r
+}
+```
+
+Now `r` holds a reference to the object that was pointed by `q`. Even if `p.reset()` is executed in another thread, the object will stay alive until
+`r` goes out of scope or is reset. By obtaining a `shared_ptr` to the object, we have effectively locked it against destruction.
+
+## Synopsis
+
+`weak_ptr` is defined in `<boost/smart_ptr/weak_ptr.hpp>`.
+
+```
+namespace boost {
+
+  template<class T> class weak_ptr {
+  public:
+
+    typedef /*see below*/ element_type;
+
+    weak_ptr() noexcept;
+
+    template<class Y> weak_ptr(shared_ptr<Y> const & r) noexcept;
+    weak_ptr(weak_ptr const & r) noexcept;
+    template<class Y> weak_ptr(weak_ptr<Y> const & r) noexcept;
+
+    weak_ptr(weak_ptr && r) noexcept;
+
+    ~weak_ptr() noexcept;
+
+    weak_ptr & operator=(weak_ptr const & r) noexcept;
+    weak_ptr & operator=(weak_ptr && r) noexcept;
+    template<class Y> weak_ptr & operator=(weak_ptr<Y> const & r) noexcept;
+    template<class Y> weak_ptr & operator=(shared_ptr<Y> const & r) noexcept;
+
+    long use_count() const noexcept;
+    bool expired() const noexcept;
+
+    shared_ptr<T> lock() const noexcept;
+
+    void reset() noexcept;
+
+    void swap(weak_ptr<T> & b) noexcept;
+
+    template<class Y> bool owner_before( weak_ptr<Y> const & r ) const noexcept;
+    template<class Y> bool owner_before( shared_ptr<Y> const & r ) const noexcept;
+  };
+
+  template<class T, class U>
+    bool operator<(weak_ptr<T> const & a, weak_ptr<U> const & b) noexcept;
+
+  template<class T> void swap(weak_ptr<T> & a, weak_ptr<T> & b) noexcept;
+}
+```
+
+## Members
+
+### element_type
+```
+typedef ... element_type;
+```
+`element_type` is `T` when `T` is not an array type, and `U` when `T` is `U[]` or `U[N]`.
+
+### constructors
+```
+weak_ptr() noexcept;
+```
+[none]
+* {blank}
++
+Effects:: Constructs an empty `weak_ptr`.
+Postconditions:: `use_count() == 0`.
+
+```
+template<class Y> weak_ptr(shared_ptr<Y> const & r) noexcept;
+```
+```
+weak_ptr(weak_ptr const & r) noexcept;
+```
+```
+template<class Y> weak_ptr(weak_ptr<Y> const & r) noexcept;
+```
+[none]
+* {blank}
++
+Effects:: If `r` is empty, constructs an empty `weak_ptr`; otherwise, constructs a `weak_ptr` that shares ownership with `r` as if by storing a copy of the pointer stored in `r`.
+Postconditions:: `use_count() == r.use_count()`.
+
+```
+weak_ptr(weak_ptr && r) noexcept;
+```
+[none]
+* {blank}
++
+Effects:: Constructs a `weak_ptr` that has the value `r` held.
+Postconditions:: `r` is empty.
+
+### destructor
+```
+~weak_ptr() noexcept;
+```
+[none]
+* {blank}
++
+Effects:: Destroys this `weak_ptr` but has no effect on the object its stored pointer points to.
+
+### assignment
+```
+weak_ptr & operator=(weak_ptr const & r) noexcept;
+```
+```
+weak_ptr & operator=(weak_ptr && r) noexcept;
+```
+```
+template<class Y> weak_ptr & operator=(weak_ptr<Y> const & r) noexcept;
+```
+```
+template<class Y> weak_ptr & operator=(shared_ptr<Y> const & r) noexcept;
+```
+[none]
+* {blank}
++
+Effects:: Equivalent to `weak_ptr(r).swap(*this)`.
+
+NOTE: The implementation is free to meet the effects (and the implied guarantees) via different means, without creating a temporary.
+
+### use_count
+```
+long use_count() const noexcept;
+```
+[none]
+* {blank}
++
+Returns:: 0 if `*this` is empty; otherwise, the number of `shared_ptr` objects that share ownership with `*this`.
+
+### expired
+```
+bool expired() const noexcept;
+```
+[none]
+* {blank}
++
+Returns:: `use_count() == 0`.
+
+### lock
+```
+shared_ptr<T> lock() const noexcept;
+```
+[none]
+* {blank}
++
+Returns:: `expired()? shared_ptr<T>(): shared_ptr<T>(*this)`.
+
+### reset
+```
+void reset() noexcept;
+```
+[none]
+* {blank}
++
+Effects:: Equivalent to `weak_ptr().swap(*this)`.
+
+### swap
+```
+void swap(weak_ptr & b) noexcept;
+```
+[none]
+* {blank}
++
+Effects:: Exchanges the contents of the two smart pointers.
+
+```
+template<class Y> bool owner_before( weak_ptr<Y> const & r ) const noexcept;
+```
+```
+template<class Y> bool owner_before( shared_ptr<Y> const & r ) const noexcept;
+```
+[none]
+* {blank}
++
+Returns:: See the description of `operator<`.
+
+## Free Functions
+
+### comparison
+```
+template<class T, class U>
+  bool operator<(weak_ptr<T> const & a, weak_ptr<U> const & b) noexcept;
+```
+[none]
+* {blank}
++
+Returns:: An unspecified value such that
+- `operator<` is a strict weak ordering as described in section [lib.alg.sorting] of the {cpp} standard; 
+- under the equivalence relation defined by `operator<`, `!(a < b) && !(b < a)`, two `weak_ptr` instances
+  are equivalent if and only if they share ownership or are both empty.
+
+NOTE: Allows `weak_ptr` objects to be used as keys in associative containers.
+
+### swap
+```
+template<class T> void swap(weak_ptr<T> & a, weak_ptr<T> & b) noexcept;
+```
+[none]
+* {blank}
++
+Effects:: Equivalent to `a.swap(b)`.
+
+## Frequently Asked Questions
+
+[qanda]
+Can an object create a weak_ptr to itself in its constructor?::
+
+  No. A `weak_ptr` can only be created from a `shared_ptr`, and at object construction time no
+  `shared_ptr` to the object exists yet. Even if you could create a temporary `shared_ptr` to `this`,
+  it would go out of scope at the end of the constructor, and all `weak_ptr` instances would instantly expire.
++
+The solution is to make the constructor private, and supply a factory function that returns a `shared_ptr`:
++
+```
+class X
+{
+private:
+
+    X();
+
+public:
+
+    static shared_ptr<X> create()
+    {
+        shared_ptr<X> px(new X);
+        // create weak pointers from px here
+        return px;
+    }
+};
+```

enable_shared_from_this.html

@@ -1,110 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-<html>
-    <head>
-        <title>enable_shared_from_this</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>
-        <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.
-        </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>
-        <pre>
-#include &lt;boost/enable_shared_from_this.hpp&gt;
-#include &lt;boost/shared_ptr.hpp&gt;
-#include &lt;cassert&gt;
-
-class Y: public boost::enable_shared_from_this&lt;Y&gt;
-{
-public:
-
-    boost::shared_ptr&lt;Y&gt; f()
-    {
-        return shared_from_this();
-    }
-};
-
-int main()
-{
-    boost::shared_ptr&lt;Y&gt; p(new Y);
-    boost::shared_ptr&lt;Y&gt; q = p-&gt;f();
-    assert(p == q);
-    assert(!(p &lt; q || q &lt; p)); // p and q must share ownership
-}
-</pre>
-        <h2><a name="Synopsis">Synopsis</a></h2>
-        <pre>
-namespace boost
-{
-
-template&lt;class T&gt; class enable_shared_from_this
-{
-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>
-        <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, a <code>shared_ptr&lt;T&gt;</code> instance <code>r</code> that shares 
-                ownership with <code>p</code>.
-            </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>.
-            </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>
-    </body>
-</html>

include/boost/enable_shared_from_this.hpp

@@ -10,7 +10,7 @@
 //  See accompanying file LICENSE_1_0.txt or copy at
 //  http://www.boost.org/LICENSE_1_0.txt
 //
-//  http://www.boost.org/libs/smart_ptr/enable_shared_from_this.html
+//  See http://www.boost.org/libs/smart_ptr/ for documentation.
 //
 
 #include <boost/smart_ptr/enable_shared_from_this.hpp>

include/boost/intrusive_ptr.hpp

@@ -10,7 +10,7 @@
 //  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/intrusive_ptr.html for documentation.
+//  See http://www.boost.org/libs/smart_ptr/ for documentation.
 //
 
 #include <boost/smart_ptr/intrusive_ptr.hpp>

include/boost/make_shared.hpp

@@ -9,8 +9,7 @@
 //  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.
+//  See http://www.boost.org/libs/smart_ptr/ for documentation.
 
 #include <boost/smart_ptr/make_shared.hpp>
 

include/boost/pointer_cast.hpp

@@ -11,33 +11,34 @@
 #define BOOST_POINTER_CAST_HPP
 
 #include <boost/config.hpp>
+#include <boost/smart_ptr/detail/sp_noexcept.hpp>
 
 namespace boost { 
 
 //static_pointer_cast overload for raw pointers
 template<class T, class U>
-inline T* static_pointer_cast(U *ptr)
+inline T* static_pointer_cast(U *ptr) BOOST_SP_NOEXCEPT
 {  
    return static_cast<T*>(ptr);
 }
 
 //dynamic_pointer_cast overload for raw pointers
 template<class T, class U>
-inline T* dynamic_pointer_cast(U *ptr)
+inline T* dynamic_pointer_cast(U *ptr) BOOST_SP_NOEXCEPT
 {  
    return dynamic_cast<T*>(ptr);
 }
 
 //const_pointer_cast overload for raw pointers
 template<class T, class U>
-inline T* const_pointer_cast(U *ptr)
+inline T* const_pointer_cast(U *ptr) BOOST_SP_NOEXCEPT
 {  
    return const_cast<T*>(ptr);
 }
 
 //reinterpret_pointer_cast overload for raw pointers
 template<class T, class U>
-inline T* reinterpret_pointer_cast(U *ptr)
+inline T* reinterpret_pointer_cast(U *ptr) BOOST_SP_NOEXCEPT
 {  
    return reinterpret_cast<T*>(ptr);
 }
@@ -62,7 +63,7 @@ using std::dynamic_pointer_cast;
 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
+template<class T, class U> std::shared_ptr<T> reinterpret_pointer_cast(const std::shared_ptr<U> & r ) BOOST_SP_NOEXCEPT
 {
     (void) reinterpret_cast< T* >( static_cast< U* >( 0 ) );
 
@@ -73,7 +74,7 @@ template<class T, class U> std::shared_ptr<T> reinterpret_pointer_cast(const std
 }
 
 //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
+template<class T, class U> std::unique_ptr<T> static_pointer_cast( std::unique_ptr<U> && r ) BOOST_SP_NOEXCEPT
 {
     (void) static_cast< T* >( static_cast< U* >( 0 ) );
 
@@ -83,7 +84,7 @@ template<class T, class U> std::unique_ptr<T> static_pointer_cast( std::unique_p
 }
 
 //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
+template<class T, class U> std::unique_ptr<T> dynamic_pointer_cast( std::unique_ptr<U> && r ) BOOST_SP_NOEXCEPT
 {
     (void) dynamic_cast< T* >( static_cast< U* >( 0 ) );
 
@@ -95,7 +96,7 @@ template<class T, class U> std::unique_ptr<T> dynamic_pointer_cast( std::unique_
 }
 
 //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
+template<class T, class U> std::unique_ptr<T> const_pointer_cast( std::unique_ptr<U> && r ) BOOST_SP_NOEXCEPT
 {
     (void) const_cast< T* >( static_cast< U* >( 0 ) );
 
@@ -105,7 +106,7 @@ template<class T, class U> std::unique_ptr<T> const_pointer_cast( std::unique_pt
 }
 
 //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
+template<class T, class U> std::unique_ptr<T> reinterpret_pointer_cast( std::unique_ptr<U> && r ) BOOST_SP_NOEXCEPT
 {
     (void) reinterpret_cast< T* >( static_cast< U* >( 0 ) );
 

include/boost/pointer_to_other.hpp

@@ -12,7 +12,7 @@
 //  (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/pointer_to_other.html
+//  See http://www.boost.org/libs/smart_ptr/ for documentation.
 //
 
 namespace boost

include/boost/scoped_array.hpp

@@ -8,8 +8,7 @@
 //  accompanying file LICENSE_1_0.txt or copy at
 //  http://www.boost.org/LICENSE_1_0.txt)
 //
-//  http://www.boost.org/libs/smart_ptr/scoped_array.htm
-//
+//  See http://www.boost.org/libs/smart_ptr/ for documentation.
 
 #include <boost/smart_ptr/scoped_array.hpp>
 

include/boost/scoped_ptr.hpp

@@ -8,8 +8,7 @@
 //  accompanying file LICENSE_1_0.txt or copy at
 //  http://www.boost.org/LICENSE_1_0.txt)
 //
-//  http://www.boost.org/libs/smart_ptr/scoped_ptr.htm
-//
+//  See http://www.boost.org/libs/smart_ptr/ for documentation.
 
 #include <boost/smart_ptr/scoped_ptr.hpp>
 

include/boost/shared_array.hpp

@@ -11,7 +11,7 @@
 //  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.
+//  See http://www.boost.org/libs/smart_ptr/ for documentation.
 //
 
 #include <boost/smart_ptr/shared_array.hpp>

include/boost/shared_ptr.hpp

@@ -11,7 +11,7 @@
 //  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.
+//  See http://www.boost.org/libs/smart_ptr/ for documentation.
 //
 
 #include <boost/smart_ptr/shared_ptr.hpp>

include/boost/smart_ptr.hpp

@@ -11,21 +11,16 @@
 //  Software License, Version 1.0. (See accompanying file
 //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 //
-//  http://www.boost.org/libs/smart_ptr/smart_ptr.htm
+//  See http://www.boost.org/libs/smart_ptr/ for documentation.
 //
 
-#include <boost/config.hpp>
-
 #include <boost/scoped_ptr.hpp>
 #include <boost/scoped_array.hpp>
 #include <boost/shared_ptr.hpp>
 #include <boost/shared_array.hpp>
-
-#if !defined(BOOST_NO_MEMBER_TEMPLATES) || defined(BOOST_MSVC6_MEMBER_TEMPLATES)
-# include <boost/weak_ptr.hpp>
-# include <boost/intrusive_ptr.hpp>
-# include <boost/enable_shared_from_this.hpp>
-# include <boost/make_shared.hpp>
-#endif
+#include <boost/weak_ptr.hpp>
+#include <boost/intrusive_ptr.hpp>
+#include <boost/enable_shared_from_this.hpp>
+#include <boost/make_shared.hpp>
 
 #endif // #ifndef BOOST_SMART_PTR_HPP_INCLUDED

include/boost/smart_ptr/allocate_shared_array.hpp

@@ -9,9 +9,10 @@ Distributed under the Boost Software License, Version 1.0.
 #define BOOST_SMART_PTR_ALLOCATE_SHARED_ARRAY_HPP
 
 #include <boost/smart_ptr/shared_ptr.hpp>
-#include <boost/type_traits/has_trivial_constructor.hpp>
-#include <boost/type_traits/has_trivial_destructor.hpp>
 #include <boost/type_traits/alignment_of.hpp>
+#include <boost/type_traits/has_trivial_constructor.hpp>
+#include <boost/type_traits/has_trivial_copy.hpp>
+#include <boost/type_traits/has_trivial_destructor.hpp>
 #include <boost/type_traits/type_with_alignment.hpp>
 
 namespace boost {
@@ -110,8 +111,7 @@ struct sp_array_count<T[]> { };
 
 template<class D, class T>
 inline D*
-sp_get_deleter(const
-    boost::shared_ptr<T>& value) BOOST_NOEXCEPT_OR_NOTHROW
+sp_get_deleter(const boost::shared_ptr<T>& value) BOOST_NOEXCEPT_OR_NOTHROW
 {
     return static_cast<D*>(value._internal_get_untyped_deleter());
 }
@@ -134,8 +134,7 @@ struct sp_max_size {
 #if !defined(BOOST_NO_CXX11_ALLOCATOR)
 template<class A, class T>
 struct sp_bind_allocator {
-    typedef typename std::allocator_traits<A>::template
-        rebind_alloc<T> type;
+    typedef typename std::allocator_traits<A>::template rebind_alloc<T> type;
 };
 #else
 template<class A, class T>
@@ -153,13 +152,11 @@ struct sp_enable<true, T> {
 };
 
 template<class T>
-inline
-typename sp_enable<boost::has_trivial_destructor<T>::value>::type
-sp_array_destroy(T*, std::size_t) BOOST_NOEXCEPT { }
+inline typename sp_enable<boost::has_trivial_destructor<T>::value>::type
+sp_array_destroy(T*, std::size_t) BOOST_SP_NOEXCEPT { }
 
 template<class T>
-inline
-typename sp_enable<!boost::has_trivial_destructor<T>::value>::type
+inline typename sp_enable<!boost::has_trivial_destructor<T>::value>::type
 sp_array_destroy(T* storage, std::size_t size)
 {
     while (size > 0) {
@@ -173,15 +170,14 @@ inline void
 sp_array_destroy(A& allocator, T* storage, std::size_t size)
 {
     while (size > 0) {
-        std::allocator_traits<A>::destroy(allocator, &storage[--size]);
+        std::allocator_traits<A>::destroy(allocator, storage + --size);
     }
 }
 #endif
 
 #if !defined(BOOST_NO_EXCEPTIONS)
 template<class T>
-inline
-typename sp_enable<boost::has_trivial_constructor<T>::value ||
+inline typename sp_enable<boost::has_trivial_constructor<T>::value ||
     boost::has_trivial_destructor<T>::value>::type
 sp_array_construct(T* storage, std::size_t size)
 {
@@ -191,8 +187,7 @@ sp_array_construct(T* storage, std::size_t size)
 }
 
 template<class T>
-inline
-typename sp_enable<!boost::has_trivial_constructor<T>::value &&
+inline typename sp_enable<!boost::has_trivial_constructor<T>::value &&
     !boost::has_trivial_destructor<T>::value>::type
 sp_array_construct(T* storage, std::size_t size)
 {
@@ -202,15 +197,25 @@ sp_array_construct(T* storage, std::size_t size)
             ::new(static_cast<void*>(storage + i)) T();
         }
     } catch (...) {
-        while (i > 0) {
-            storage[--i].~T();
-        }
+        sp_array_destroy(storage, i);
         throw;
     }
 }
 
 template<class T>
-inline void
+inline typename sp_enable<boost::has_trivial_copy_constructor<T>::value ||
+    boost::has_trivial_destructor<T>::value>::type
+sp_array_construct(T* storage, std::size_t size, const T* list,
+    std::size_t count)
+{
+    for (std::size_t i = 0; i < size; ++i) {
+        ::new(static_cast<void*>(storage + i)) T(list[i % count]);
+    }
+}
+
+template<class T>
+inline typename sp_enable<!boost::has_trivial_copy_constructor<T>::value &&
+    !boost::has_trivial_destructor<T>::value>::type
 sp_array_construct(T* storage, std::size_t size, const T* list,
     std::size_t count)
 {
@@ -220,9 +225,7 @@ sp_array_construct(T* storage, std::size_t size, const T* list,
             ::new(static_cast<void*>(storage + i)) T(list[i % count]);
         }
     } catch (...) {
-        while (i > 0) {
-            storage[--i].~T();
-        }
+        sp_array_destroy(storage, i);
         throw;
     }
 }
@@ -304,14 +307,12 @@ sp_array_construct(A& allocator, T* storage, std::size_t size,
 #endif
 
 template<class T>
-inline
-typename sp_enable<boost::has_trivial_constructor<T>::value>::type
-sp_array_default(T*, std::size_t) BOOST_NOEXCEPT { }
+inline typename sp_enable<boost::has_trivial_constructor<T>::value>::type
+sp_array_default(T*, std::size_t) BOOST_SP_NOEXCEPT { }
 
 #if !defined(BOOST_NO_EXCEPTIONS)
 template<class T>
-inline
-typename sp_enable<!boost::has_trivial_constructor<T>::value &&
+inline typename sp_enable<!boost::has_trivial_constructor<T>::value &&
     boost::has_trivial_destructor<T>::value>::type
 sp_array_default(T* storage, std::size_t size)
 {
@@ -321,8 +322,7 @@ sp_array_default(T* storage, std::size_t size)
 }
 
 template<class T>
-inline
-typename sp_enable<!boost::has_trivial_constructor<T>::value &&
+inline typename sp_enable<!boost::has_trivial_constructor<T>::value &&
     !boost::has_trivial_destructor<T>::value>::type
 sp_array_default(T* storage, std::size_t size)
 {
@@ -332,16 +332,13 @@ sp_array_default(T* storage, std::size_t size)
             ::new(static_cast<void*>(storage + i)) T;
         }
     } catch (...) {
-        while (i > 0) {
-            storage[--i].~T();
-        }
+        sp_array_destroy(storage, i);
         throw;
     }
 }
 #else
 template<class T>
-inline
-typename sp_enable<!boost::has_trivial_constructor<T>::value>::type
+inline typename sp_enable<!boost::has_trivial_constructor<T>::value>::type
 sp_array_default(T* storage, std::size_t size)
 {
     for (std::size_t i = 0; i < size; ++i) {
@@ -358,24 +355,24 @@ struct sp_less_align {
 };
 
 template<class T, std::size_t N>
-BOOST_CONSTEXPR inline
-typename sp_enable<sp_less_align<T, N>::value, std::size_t>::type
-sp_align(std::size_t size) BOOST_NOEXCEPT
+BOOST_CONSTEXPR
+inline typename sp_enable<sp_less_align<T, N>::value, std::size_t>::type
+sp_align(std::size_t size) BOOST_SP_NOEXCEPT
 {
     return (sizeof(T) * size + N - 1) & ~(N - 1);
 }
 
 template<class T, std::size_t N>
-BOOST_CONSTEXPR inline
-typename sp_enable<!sp_less_align<T, N>::value, std::size_t>::type
-sp_align(std::size_t size) BOOST_NOEXCEPT
+BOOST_CONSTEXPR
+inline typename sp_enable<!sp_less_align<T, N>::value, std::size_t>::type
+sp_align(std::size_t size) BOOST_SP_NOEXCEPT
 {
     return sizeof(T) * size;
 }
 
 template<class T>
 BOOST_CONSTEXPR inline std::size_t
-sp_types(std::size_t size) BOOST_NOEXCEPT
+sp_types(std::size_t size) BOOST_SP_NOEXCEPT
 {
     return (size + sizeof(T) - 1) / sizeof(T);
 }
@@ -384,16 +381,16 @@ template<class T, std::size_t N>
 class sp_size_array_deleter {
 public:
     template<class U>
-    static void operator_fn(U) BOOST_NOEXCEPT { }
+    static void operator_fn(U) BOOST_SP_NOEXCEPT { }
 
-    sp_size_array_deleter() BOOST_NOEXCEPT
+    sp_size_array_deleter() BOOST_SP_NOEXCEPT
         : enabled_(false) { }
 
     template<class A>
-    sp_size_array_deleter(const A&) BOOST_NOEXCEPT
+    sp_size_array_deleter(const A&) BOOST_SP_NOEXCEPT
         : enabled_(false) { }
 
-    sp_size_array_deleter(const sp_size_array_deleter&) BOOST_NOEXCEPT
+    sp_size_array_deleter(const sp_size_array_deleter&) BOOST_SP_NOEXCEPT
         : enabled_(false) { }
 
     ~sp_size_array_deleter() {
@@ -417,8 +414,7 @@ public:
     }
 
     void* construct(const T* list, std::size_t count) {
-        sp_array_construct(reinterpret_cast<T*>(&storage_), N,
-            list, count);
+        sp_array_construct(reinterpret_cast<T*>(&storage_), N, list, count);
         enabled_ = true;
         return &storage_;
     }
@@ -440,49 +436,46 @@ template<class T, std::size_t N, class A>
 class sp_size_array_destroyer {
 public:
     template<class U>
-    static void operator_fn(U) BOOST_NOEXCEPT { }
+    static void operator_fn(U) BOOST_SP_NOEXCEPT { }
 
     template<class U>
-    sp_size_array_destroyer(const U& allocator) BOOST_NOEXCEPT
+    sp_size_array_destroyer(const U& allocator) BOOST_SP_NOEXCEPT
         : allocator_(allocator),
           enabled_(false) { }
 
     sp_size_array_destroyer(const sp_size_array_destroyer& other)
-        BOOST_NOEXCEPT
+        BOOST_SP_NOEXCEPT
         : allocator_(other.allocator_),
           enabled_(false) { }
 
     ~sp_size_array_destroyer() {
         if (enabled_) {
-            sp_array_destroy(allocator_,
-                reinterpret_cast<T*>(&storage_), N);
+            sp_array_destroy(allocator_, reinterpret_cast<T*>(&storage_), N);
         }
     }
 
     template<class U>
     void operator()(U) {
         if (enabled_) {
-            sp_array_destroy(allocator_,
-                reinterpret_cast<T*>(&storage_), N);
+            sp_array_destroy(allocator_, reinterpret_cast<T*>(&storage_), N);
             enabled_ = false;
         }
     }
 
     void* construct() {
-        sp_array_construct(allocator_,
-            reinterpret_cast<T*>(&storage_), N);
+        sp_array_construct(allocator_, reinterpret_cast<T*>(&storage_), N);
         enabled_ = true;
         return &storage_;
     }
 
     void* construct(const T* list, std::size_t count) {
-        sp_array_construct(allocator_,
-            reinterpret_cast<T*>(&storage_), N, list, count);
+        sp_array_construct(allocator_, reinterpret_cast<T*>(&storage_), N,
+            list, count);
         enabled_ = true;
         return &storage_;
     }
 
-    const A& allocator() const BOOST_NOEXCEPT {
+    const A& allocator() const BOOST_SP_NOEXCEPT {
         return allocator_;
     }
 
@@ -498,23 +491,23 @@ template<class T>
 class sp_array_deleter {
 public:
     template<class U>
-    static void operator_fn(U) BOOST_NOEXCEPT { }
+    static void operator_fn(U) BOOST_SP_NOEXCEPT { }
 
-    sp_array_deleter(std::size_t size) BOOST_NOEXCEPT
+    sp_array_deleter(std::size_t size) BOOST_SP_NOEXCEPT
         : address_(0),
           size_(size) { }
 
     template<class A>
-    sp_array_deleter(const A& allocator) BOOST_NOEXCEPT
+    sp_array_deleter(const A& allocator) BOOST_SP_NOEXCEPT
         : address_(0),
           size_(allocator.size()) { }
 
     template<class A>
-    sp_array_deleter(const A&, std::size_t size) BOOST_NOEXCEPT
+    sp_array_deleter(const A&, std::size_t size) BOOST_SP_NOEXCEPT
         : address_(0),
           size_(size) { }
 
-    sp_array_deleter(const sp_array_deleter& other) BOOST_NOEXCEPT
+    sp_array_deleter(const sp_array_deleter& other) BOOST_SP_NOEXCEPT
         : address_(0),
           size_(other.size_) { }
 
@@ -547,7 +540,7 @@ public:
         address_ = address;
     }
 
-    std::size_t size() const BOOST_NOEXCEPT {
+    std::size_t size() const BOOST_SP_NOEXCEPT {
         return size_;
     }
 
@@ -561,38 +554,35 @@ template<class T, class A>
 class sp_array_destroyer {
 public:
     template<class U>
-    static void operator_fn(U) BOOST_NOEXCEPT { }
+    static void operator_fn(U) BOOST_SP_NOEXCEPT { }
 
     template<class U>
-    sp_array_destroyer(const U& allocator, std::size_t size)
-        BOOST_NOEXCEPT
+    sp_array_destroyer(const U& allocator, std::size_t size) BOOST_SP_NOEXCEPT
         : allocator_(allocator),
           size_(size),
           address_(0) { }
 
     template<class U>
-    sp_array_destroyer(const U& allocator) BOOST_NOEXCEPT
+    sp_array_destroyer(const U& allocator) BOOST_SP_NOEXCEPT
         : allocator_(allocator.allocator()),
           size_(allocator.size()),
           address_(0) { }
 
-    sp_array_destroyer(const sp_array_destroyer& other) BOOST_NOEXCEPT
+    sp_array_destroyer(const sp_array_destroyer& other) BOOST_SP_NOEXCEPT
         : allocator_(other.allocator_),
           size_(other.size_),
           address_(0) { }
 
     ~sp_array_destroyer() {
         if (address_) {
-            sp_array_destroy(allocator_, static_cast<T*>(address_),
-                size_);
+            sp_array_destroy(allocator_, static_cast<T*>(address_), size_);
         }
     }
 
     template<class U>
     void operator()(U) {
         if (address_) {
-            sp_array_destroy(allocator_, static_cast<T*>(address_),
-                size_);
+            sp_array_destroy(allocator_, static_cast<T*>(address_), size_);
             address_ = 0;
         }
     }
@@ -607,11 +597,11 @@ public:
         address_ = address;
     }
 
-    const A& allocator() const BOOST_NOEXCEPT {
+    const A& allocator() const BOOST_SP_NOEXCEPT {
         return allocator_;
     }
 
-    std::size_t size() const BOOST_NOEXCEPT {
+    std::size_t size() const BOOST_SP_NOEXCEPT {
         return size_;
     }
 
@@ -646,20 +636,19 @@ public:
             typename sp_bind_allocator<A, U>::type> other;
     };
 
-    sp_array_allocator(const A& allocator, std::size_t size,
-        void** result) BOOST_NOEXCEPT
+    sp_array_allocator(const A& allocator, std::size_t size, void** result)
+        BOOST_SP_NOEXCEPT
         : allocator_(allocator),
           size_(size),
           result_(result) { }
 
-    sp_array_allocator(const A& allocator, std::size_t size)
-        BOOST_NOEXCEPT
+    sp_array_allocator(const A& allocator, std::size_t size) BOOST_SP_NOEXCEPT
         : allocator_(allocator),
           size_(size) { }
 
     template<class U>
     sp_array_allocator(const sp_array_allocator<T, U>& other)
-        BOOST_NOEXCEPT
+        BOOST_SP_NOEXCEPT
         : allocator_(other.allocator_),
           size_(other.size_),
           result_(other.result_) { }
@@ -680,11 +669,11 @@ public:
         allocator.deallocate(reinterpret_cast<type*>(value), size);
     }
 
-    const A& allocator() const BOOST_NOEXCEPT {
+    const A& allocator() const BOOST_SP_NOEXCEPT {
         return allocator_;
     }
 
-    std::size_t size() const BOOST_NOEXCEPT {
+    std::size_t size() const BOOST_SP_NOEXCEPT {
         return size_;
     }
 
@@ -697,7 +686,7 @@ private:
 template<class T, class U, class V>
 inline bool
 operator==(const sp_array_allocator<T, U>& first,
-    const sp_array_allocator<T, V>& second) BOOST_NOEXCEPT
+    const sp_array_allocator<T, V>& second) BOOST_SP_NOEXCEPT
 {
     return first.allocator() == second.allocator() &&
         first.size() == second.size();
@@ -706,7 +695,7 @@ operator==(const sp_array_allocator<T, U>& first,
 template<class T, class U, class V>
 inline bool
 operator!=(const sp_array_allocator<T, U>& first,
-    const sp_array_allocator<T, V>& second) BOOST_NOEXCEPT
+    const sp_array_allocator<T, V>& second) BOOST_SP_NOEXCEPT
 {
     return !(first == second);
 }
@@ -773,8 +762,13 @@ public:
         allocator.deallocate(this, 1);
     }
 
-    void* get_deleter(const sp_typeinfo&) {
-        return &reinterpret_cast<char&>(deleter_);
+    void* get_deleter(const sp_typeinfo& info) {
+        return info == BOOST_SP_TYPEID(deleter_type) ?
+            &reinterpret_cast<char&>(deleter_) : 0;
+    }
+
+    void* get_local_deleter(const sp_typeinfo&) {
+        return 0;
     }
 
     void* get_untyped_deleter() {
@@ -814,8 +808,13 @@ public:
         allocator.deallocate(this, 1);
     }
 
-    void* get_deleter(const sp_typeinfo&) {
-        return &reinterpret_cast<char&>(deleter_);
+    void* get_deleter(const sp_typeinfo& info) {
+        return info == BOOST_SP_TYPEID(deleter_type) ?
+            &reinterpret_cast<char&>(deleter_) : 0;
+    }
+
+    void* get_local_deleter(const sp_typeinfo&) {
+        return 0;
     }
 
     void* get_untyped_deleter() {
@@ -860,8 +859,13 @@ public:
         allocator.deallocate(this, 1);
     }
 
-    void* get_deleter(const sp_typeinfo&) {
-        return &reinterpret_cast<char&>(deleter_);
+    void* get_deleter(const sp_typeinfo& info) {
+        return info == BOOST_SP_TYPEID(deleter_type) ?
+            &reinterpret_cast<char&>(deleter_) : 0;
+    }
+
+    void* get_local_deleter(const sp_typeinfo&) {
+        return 0;
     }
 
     void* get_untyped_deleter() {
@@ -905,8 +909,13 @@ public:
         allocator.deallocate(this, 1);
     }
 
-    void* get_deleter(const sp_typeinfo&) {
-        return &reinterpret_cast<char&>(deleter_);
+    void* get_deleter(const sp_typeinfo& info) {
+        return info == BOOST_SP_TYPEID(deleter_type) ?
+            &reinterpret_cast<char&>(deleter_) : 0;
+    }
+
+    void* get_local_deleter(const sp_typeinfo&) {
+        return 0;
     }
 
     void* get_untyped_deleter() {
@@ -947,8 +956,8 @@ allocate_shared(const A& allocator,
     shared_ptr<T> result(static_cast<type*>(0),
         detail::sp_inplace_tag<deleter>(), allocator);
     deleter* state = detail::sp_get_deleter<deleter>(result);
-    void* start = state->construct(reinterpret_cast<const
-        scalar*>(&value), detail::sp_array_count<type>::value);
+    void* start = state->construct(reinterpret_cast<const scalar*>(&value),
+        detail::sp_array_count<type>::value);
     return shared_ptr<T>(result, static_cast<type*>(start));
 }
 

include/boost/smart_ptr/atomic_shared_ptr.hpp

@@ -0,0 +1,183 @@
+#ifndef BOOST_SMART_PTR_ATOMIC_SHARED_PTR_HPP_INCLUDED
+#define BOOST_SMART_PTR_ATOMIC_SHARED_PTR_HPP_INCLUDED
+
+//
+//  atomic_shared_ptr.hpp
+//
+//  Copyright 2017 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/ for documentation.
+//
+
+#include <boost/smart_ptr/shared_ptr.hpp>
+#include <boost/smart_ptr/detail/spinlock.hpp>
+#include <cstring>
+
+namespace boost
+{
+
+template<class T> class atomic_shared_ptr
+{
+private:
+
+    boost::shared_ptr<T> p_;
+
+    mutable boost::detail::spinlock l_;
+
+    atomic_shared_ptr(const atomic_shared_ptr&);
+    atomic_shared_ptr& operator=(const atomic_shared_ptr&);
+
+private:
+
+    bool compare_exchange( shared_ptr<T>& v, shared_ptr<T> w ) BOOST_SP_NOEXCEPT
+    {
+        l_.lock();
+
+        if( p_._internal_equiv( v ) )
+        {
+            p_.swap( w );
+
+            l_.unlock();
+            return true;
+        }
+        else
+        {
+            shared_ptr<T> tmp( p_ );
+
+            l_.unlock();
+
+            tmp.swap( v );
+            return false;
+        }
+    }
+
+public:
+
+#if !defined( BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX ) && !defined( BOOST_NO_CXX11_CONSTEXPR )
+
+    constexpr atomic_shared_ptr() BOOST_SP_NOEXCEPT: l_ BOOST_DETAIL_SPINLOCK_INIT
+    {
+    }
+
+#else
+
+    atomic_shared_ptr() BOOST_SP_NOEXCEPT
+    {
+        boost::detail::spinlock init = BOOST_DETAIL_SPINLOCK_INIT;
+        std::memcpy( &l_, &init, sizeof( init ) );
+    }
+
+#endif
+
+    atomic_shared_ptr( shared_ptr<T> p ) BOOST_SP_NOEXCEPT
+#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
+        : p_( std::move( p ) )
+#else
+        : p_( p )
+#endif
+    {
+        boost::detail::spinlock init = BOOST_DETAIL_SPINLOCK_INIT;
+        std::memcpy( &l_, &init, sizeof( init ) );
+    }
+
+    atomic_shared_ptr& operator=( shared_ptr<T> r ) BOOST_SP_NOEXCEPT
+    {
+        boost::detail::spinlock::scoped_lock lock( l_ );
+        p_.swap( r );
+
+        return *this;
+    }
+
+    BOOST_CONSTEXPR bool is_lock_free() const BOOST_SP_NOEXCEPT
+    {
+        return false;
+    }
+
+    shared_ptr<T> load( int = 0 ) const BOOST_SP_NOEXCEPT
+    {
+        boost::detail::spinlock::scoped_lock lock( l_ );
+        return p_;
+    }
+
+    operator shared_ptr<T>() const BOOST_SP_NOEXCEPT
+    {
+        boost::detail::spinlock::scoped_lock lock( l_ );
+        return p_;
+    }
+
+    void store( shared_ptr<T> r, int = 0 ) BOOST_SP_NOEXCEPT
+    {
+        boost::detail::spinlock::scoped_lock lock( l_ );
+        p_.swap( r );
+    }
+
+    shared_ptr<T> exchange( shared_ptr<T> r, int = 0 ) BOOST_SP_NOEXCEPT
+    {
+        {
+            boost::detail::spinlock::scoped_lock lock( l_ );
+            p_.swap( r );
+        }
+
+#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
+
+        return std::move( r );
+
+#else
+
+        return r;
+
+#endif
+    }
+
+    bool compare_exchange_weak( shared_ptr<T>& v, const shared_ptr<T>& w, int, int ) BOOST_SP_NOEXCEPT
+    {
+        return compare_exchange( v, w );
+    }
+
+    bool compare_exchange_weak( shared_ptr<T>& v, const shared_ptr<T>& w, int = 0 ) BOOST_SP_NOEXCEPT
+    {
+        return compare_exchange( v, w );
+    }
+
+    bool compare_exchange_strong( shared_ptr<T>& v, const shared_ptr<T>& w, int, int ) BOOST_SP_NOEXCEPT
+    {
+        return compare_exchange( v, w );
+    }
+
+    bool compare_exchange_strong( shared_ptr<T>& v, const shared_ptr<T>& w, int = 0 ) BOOST_SP_NOEXCEPT
+    {
+        return compare_exchange( v, w );
+    }
+
+#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
+
+    bool compare_exchange_weak( shared_ptr<T>& v, shared_ptr<T>&& w, int, int ) BOOST_SP_NOEXCEPT
+    {
+        return compare_exchange( v, std::move( w ) );
+    }
+
+    bool compare_exchange_weak( shared_ptr<T>& v, shared_ptr<T>&& w, int = 0 ) BOOST_SP_NOEXCEPT
+    {
+        return compare_exchange( v, std::move( w ) );
+    }
+
+    bool compare_exchange_strong( shared_ptr<T>& v, shared_ptr<T>&& w, int, int ) BOOST_SP_NOEXCEPT
+    {
+        return compare_exchange( v, std::move( w ) );
+    }
+
+    bool compare_exchange_strong( shared_ptr<T>& v, shared_ptr<T>&& w, int = 0 ) BOOST_SP_NOEXCEPT
+    {
+        return compare_exchange( v, std::move( w ) );
+    }
+
+#endif
+};
+
+} // namespace boost
+
+#endif  // #ifndef BOOST_SMART_PTR_ATOMIC_SHARED_PTR_HPP_INCLUDED

include/boost/smart_ptr/bad_weak_ptr.hpp

@@ -17,6 +17,7 @@
 // http://www.boost.org/LICENSE_1_0.txt)
 //
 
+#include <boost/config.hpp>
 #include <exception>
 
 #ifdef __BORLANDC__
@@ -36,7 +37,8 @@ namespace boost
 # pragma option push -pc
 #endif
 
-#if defined(__clang__)
+#if defined(BOOST_CLANG)
+// Intel C++ on Mac defines __clang__ but doesn't support the pragma
 # pragma clang diagnostic push
 # pragma clang diagnostic ignored "-Wweak-vtables"
 #endif
@@ -51,7 +53,7 @@ public:
     }
 };
 
-#if defined(__clang__)
+#if defined(BOOST_CLANG)
 # pragma clang diagnostic pop
 #endif
 

include/boost/smart_ptr/detail/atomic_count_gcc.hpp

@@ -9,7 +9,7 @@
 //  http://gcc.gnu.org/onlinedocs/porting/Thread-safety.html
 //
 //  Copyright (c) 2001, 2002 Peter Dimov and Multi Media Ltd.
-//  Copyright (c) 2002 Lars Gullik Bj<EFBFBD>nnes <larsbj@lyx.org>
+//  Copyright (c) 2002 Lars Gullik Bjønnes <larsbj@lyx.org>
 //  Copyright 2003-2005 Peter Dimov
 //
 //  Distributed under the Boost Software License, Version 1.0. (See

include/boost/smart_ptr/detail/local_counted_base.hpp

@@ -0,0 +1,147 @@
+#ifndef BOOST_SMART_PTR_DETAIL_LOCAL_COUNTED_BASE_HPP_INCLUDED
+#define BOOST_SMART_PTR_DETAIL_LOCAL_COUNTED_BASE_HPP_INCLUDED
+
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+//  detail/local_counted_base.hpp
+//
+//  Copyright 2017 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/ for documentation.
+
+#include <boost/smart_ptr/detail/shared_count.hpp>
+#include <boost/config.hpp>
+#include <utility>
+#include <climits>
+
+namespace boost
+{
+
+namespace detail
+{
+
+class local_counted_base
+{
+private:
+
+    local_counted_base & operator= ( local_counted_base const & );
+
+private:
+
+    // not 'int' or 'unsigned' to avoid aliasing and enable optimizations
+    enum count_type { min_ = 0, initial_ = 1, max_ = UINT_MAX };
+
+    count_type local_use_count_;
+
+public:
+
+    BOOST_CONSTEXPR local_counted_base() BOOST_SP_NOEXCEPT: local_use_count_( initial_ )
+    {
+    }
+
+    BOOST_CONSTEXPR local_counted_base( local_counted_base const & ) BOOST_SP_NOEXCEPT: local_use_count_( initial_ )
+    {
+    }
+
+    virtual ~local_counted_base() /*BOOST_SP_NOEXCEPT*/
+    {
+    }
+
+    virtual void local_cb_destroy() BOOST_SP_NOEXCEPT = 0;
+
+    virtual boost::detail::shared_count local_cb_get_shared_count() const BOOST_SP_NOEXCEPT = 0;
+
+    void add_ref() BOOST_SP_NOEXCEPT
+    {
+#if defined( __has_builtin )
+# if __has_builtin( __builtin_assume )
+
+        __builtin_assume( local_use_count_ >= 1 );
+
+# endif
+#endif
+
+        local_use_count_ = static_cast<count_type>( local_use_count_ + 1 );
+    }
+
+    void release() BOOST_SP_NOEXCEPT
+    {
+        local_use_count_ = static_cast<count_type>( local_use_count_ - 1 );
+
+        if( local_use_count_ == 0 )
+        {
+            local_cb_destroy();
+        }
+    }
+
+    long local_use_count() const BOOST_SP_NOEXCEPT
+    {
+        return local_use_count_;
+    }
+};
+
+class local_counted_impl: public local_counted_base
+{
+private:
+
+    local_counted_impl( local_counted_impl const & );
+
+private:
+
+    shared_count pn_;
+
+public:
+
+    explicit local_counted_impl( shared_count const& pn ): pn_( pn )
+    {
+    }
+
+#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
+
+    explicit local_counted_impl( shared_count && pn ): pn_( std::move(pn) )
+    {
+    }
+
+#endif
+
+    virtual void local_cb_destroy() BOOST_SP_NOEXCEPT
+    {
+        delete this;
+    }
+
+    virtual boost::detail::shared_count local_cb_get_shared_count() const BOOST_SP_NOEXCEPT
+    {
+        return pn_;
+    }
+};
+
+class local_counted_impl_em: public local_counted_base
+{
+public:
+
+    shared_count pn_;
+
+    virtual void local_cb_destroy() BOOST_SP_NOEXCEPT
+    {
+        shared_count().swap( pn_ );
+    }
+
+    virtual boost::detail::shared_count local_cb_get_shared_count() const BOOST_SP_NOEXCEPT
+    {
+        return pn_;
+    }
+};
+
+} // namespace detail
+
+} // namespace boost
+
+#endif  // #ifndef BOOST_SMART_PTR_DETAIL_LOCAL_COUNTED_BASE_HPP_INCLUDED

include/boost/smart_ptr/detail/local_sp_deleter.hpp

@@ -0,0 +1,91 @@
+#ifndef BOOST_SMART_PTR_DETAIL_LOCAL_SP_DELETER_HPP_INCLUDED
+#define BOOST_SMART_PTR_DETAIL_LOCAL_SP_DELETER_HPP_INCLUDED
+
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+//  detail/local_sp_deleter.hpp
+//
+//  Copyright 2017 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/ for documentation.
+
+#include <boost/smart_ptr/detail/local_counted_base.hpp>
+#include <boost/config.hpp>
+
+namespace boost
+{
+
+namespace detail
+{
+
+template<class D> class local_sp_deleter: public local_counted_impl_em
+{
+private:
+
+    D d_;
+
+public:
+
+    local_sp_deleter(): d_()
+    {
+    }
+
+    explicit local_sp_deleter( D const& d ) BOOST_SP_NOEXCEPT: d_( d )
+    {
+    }
+
+#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
+
+    explicit local_sp_deleter( D&& d ) BOOST_SP_NOEXCEPT: d_( std::move(d) )
+    {
+    }
+
+#endif
+
+    D& deleter()
+    {
+        return d_;
+    }
+
+    template<class Y> void operator()( Y* p ) BOOST_SP_NOEXCEPT
+    {
+        d_( p );
+    }
+
+#if !defined( BOOST_NO_CXX11_NULLPTR )
+
+    void operator()( boost::detail::sp_nullptr_t p ) BOOST_SP_NOEXCEPT
+    {
+        d_( p );
+    }
+
+#endif
+};
+
+template<> class local_sp_deleter<void>
+{
+};
+
+template<class D> D * get_local_deleter( local_sp_deleter<D> * p )
+{
+    return &p->deleter();
+}
+
+inline void * get_local_deleter( local_sp_deleter<void> * /*p*/ )
+{
+    return 0;
+}
+
+} // namespace detail
+
+} // namespace boost
+
+#endif  // #ifndef BOOST_SMART_PTR_DETAIL_LOCAL_SP_DELETER_HPP_INCLUDED

include/boost/smart_ptr/detail/lwm_win32_cs.hpp

@@ -21,7 +21,13 @@
 #include <boost/predef.h>
 
 #ifdef BOOST_USE_WINDOWS_H
-#  include <windows.h>
+
+#include <windows.h>
+
+#else
+
+struct _RTL_CRITICAL_SECTION;
+
 #endif
 
 namespace boost
@@ -47,13 +53,13 @@ struct critical_section
 };
 
 #if BOOST_PLAT_WINDOWS_RUNTIME
-extern "C" __declspec(dllimport) void __stdcall InitializeCriticalSectionEx(critical_section *, unsigned long, unsigned long);
+extern "C" __declspec(dllimport) void __stdcall InitializeCriticalSectionEx(::_RTL_CRITICAL_SECTION *, unsigned long, unsigned long);
 #else
-extern "C" __declspec(dllimport) void __stdcall InitializeCriticalSection(critical_section *);
+extern "C" __declspec(dllimport) void __stdcall InitializeCriticalSection(::_RTL_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 *);
+extern "C" __declspec(dllimport) void __stdcall EnterCriticalSection(::_RTL_CRITICAL_SECTION *);
+extern "C" __declspec(dllimport) void __stdcall LeaveCriticalSection(::_RTL_CRITICAL_SECTION *);
+extern "C" __declspec(dllimport) void __stdcall DeleteCriticalSection(::_RTL_CRITICAL_SECTION *);
 
 #else
 
@@ -75,15 +81,15 @@ public:
     lightweight_mutex()
     {
 #if BOOST_PLAT_WINDOWS_RUNTIME
-        InitializeCriticalSectionEx(&cs_, 4000, 0);
+        boost::detail::InitializeCriticalSectionEx(reinterpret_cast< ::_RTL_CRITICAL_SECTION* >(&cs_), 4000, 0);
 #else
-        InitializeCriticalSection(&cs_);
+        boost::detail::InitializeCriticalSection(reinterpret_cast< ::_RTL_CRITICAL_SECTION* >(&cs_));
 #endif
     }
 
     ~lightweight_mutex()
     {
-        DeleteCriticalSection(&cs_);
+        boost::detail::DeleteCriticalSection(reinterpret_cast< ::_RTL_CRITICAL_SECTION* >(&cs_));
     }
 
     class scoped_lock;
@@ -102,12 +108,12 @@ public:
 
         explicit scoped_lock(lightweight_mutex & m): m_(m)
         {
-            EnterCriticalSection(&m_.cs_);
+            boost::detail::EnterCriticalSection(reinterpret_cast< ::_RTL_CRITICAL_SECTION* >(&m_.cs_));
         }
 
         ~scoped_lock()
         {
-            LeaveCriticalSection(&m_.cs_);
+            boost::detail::LeaveCriticalSection(reinterpret_cast< ::_RTL_CRITICAL_SECTION* >(&m_.cs_));
         }
     };
 };

include/boost/smart_ptr/detail/operator_bool.hpp

@@ -9,14 +9,14 @@
 #if !defined( BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS ) && !defined( BOOST_NO_CXX11_NULLPTR )\
     && !(defined(__SUNPRO_CC) && BOOST_WORKAROUND(__SUNPRO_CC, <= 0x5130))
 
-    explicit operator bool () const BOOST_NOEXCEPT
+    explicit operator bool () const BOOST_SP_NOEXCEPT
     {
         return px != 0;
     }
 
 #elif ( defined(__SUNPRO_CC) && BOOST_WORKAROUND(__SUNPRO_CC, < 0x570) ) || defined(__CINT__)
 
-    operator bool () const BOOST_NOEXCEPT
+    operator bool () const BOOST_SP_NOEXCEPT
     {
         return px != 0;
     }
@@ -29,7 +29,7 @@
 
     typedef void (*unspecified_bool_type)( this_type*** );
 
-    operator unspecified_bool_type() const BOOST_NOEXCEPT
+    operator unspecified_bool_type() const BOOST_SP_NOEXCEPT
     {
         return px == 0? 0: unspecified_bool;
     }
@@ -41,7 +41,7 @@
 
     typedef element_type * (this_type::*unspecified_bool_type)() const;
 
-    operator unspecified_bool_type() const BOOST_NOEXCEPT
+    operator unspecified_bool_type() const BOOST_SP_NOEXCEPT
     {
         return px == 0? 0: &this_type::get;
     }
@@ -50,7 +50,7 @@
 
     typedef element_type * this_type::*unspecified_bool_type;
 
-    operator unspecified_bool_type() const BOOST_NOEXCEPT
+    operator unspecified_bool_type() const BOOST_SP_NOEXCEPT
     {
         return px == 0? 0: &this_type::px;
     }
@@ -58,7 +58,7 @@
 #endif
 
     // operator! is redundant, but some compilers need it
-    bool operator! () const BOOST_NOEXCEPT
+    bool operator! () const BOOST_SP_NOEXCEPT
     {
         return px == 0;
     }

include/boost/smart_ptr/detail/shared_count.hpp

@@ -54,7 +54,7 @@ namespace boost
 namespace movelib
 {
 
-    template< class T, class D > class unique_ptr;
+template< class T, class D > class unique_ptr;
 
 } // namespace movelib
 
@@ -118,7 +118,7 @@ private:
 
 public:
 
-    shared_count(): pi_(0) // nothrow
+    BOOST_CONSTEXPR shared_count(): pi_(0) // nothrow
 #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
         , id_(shared_count_id)
 #endif
@@ -496,6 +496,11 @@ public:
         return pi_? pi_->get_deleter( ti ): 0;
     }
 
+    void * get_local_deleter( sp_typeinfo const & ti ) const
+    {
+        return pi_? pi_->get_local_deleter( ti ): 0;
+    }
+
     void * get_untyped_deleter() const
     {
         return pi_? pi_->get_untyped_deleter(): 0;
@@ -517,7 +522,7 @@ private:
 
 public:
 
-    weak_count(): pi_(0) // nothrow
+    BOOST_CONSTEXPR weak_count(): pi_(0) // nothrow
 #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
         , id_(weak_count_id)
 #endif

include/boost/smart_ptr/detail/sp_counted_base_acc_ia64.hpp

@@ -104,6 +104,7 @@ public:
     }
 
     virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
+    virtual void * get_local_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

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

include/boost/smart_ptr/detail/sp_counted_base_clang.hpp

@@ -98,6 +98,7 @@ public:
     }
 
     virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
+    virtual void * get_local_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_ppc.hpp

@@ -124,6 +124,7 @@ public:
     }
 
     virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
+    virtual void * get_local_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,6 +112,7 @@ public:
     }
 
     virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
+    virtual void * get_local_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,6 +111,7 @@ public:
     }
 
     virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
+    virtual void * get_local_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

@@ -135,6 +135,7 @@ public:
     }
 
     virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
+    virtual void * get_local_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,6 +135,7 @@ public:
     }
 
     virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
+    virtual void * get_local_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,6 +120,7 @@ public:
     }
 
     virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
+    virtual void * get_local_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,6 +127,7 @@ public:
     }
 
     virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
+    virtual void * get_local_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,6 +59,7 @@ public:
     }
 
     virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
+    virtual void * get_local_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

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

include/boost/smart_ptr/detail/sp_counted_base_snc_ps3.hpp

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

include/boost/smart_ptr/detail/sp_counted_base_solaris.hpp

@@ -62,6 +62,7 @@ public:
     }
 
     virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
+    virtual void * get_local_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,6 +84,7 @@ public:
     }
 
     virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
+    virtual void * get_local_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

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

include/boost/smart_ptr/detail/sp_counted_base_sync.hpp

@@ -109,6 +109,7 @@ public:
     }
 
     virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
+    virtual void * get_local_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

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

include/boost/smart_ptr/detail/sp_counted_base_w32.hpp

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

include/boost/smart_ptr/detail/sp_counted_impl.hpp

@@ -26,6 +26,7 @@
 
 #include <boost/checked_delete.hpp>
 #include <boost/smart_ptr/detail/sp_counted_base.hpp>
+#include <boost/core/addressof.hpp>
 
 #if defined(BOOST_SP_USE_QUICK_ALLOCATOR)
 #include <boost/smart_ptr/detail/quick_allocator.hpp>
@@ -50,6 +51,19 @@ void sp_scalar_destructor_hook( void * px, std::size_t size, void * pn );
 namespace detail
 {
 
+// get_local_deleter
+
+template<class D> class local_sp_deleter;
+
+template<class D> D * get_local_deleter( D * /*p*/ )
+{
+    return 0;
+}
+
+template<class D> D * get_local_deleter( local_sp_deleter<D> * p );
+
+//
+
 template<class X> class sp_counted_impl_p: public sp_counted_base
 {
 private:
@@ -83,6 +97,11 @@ public:
         return 0;
     }
 
+    virtual void * get_local_deleter( sp_typeinfo const & )
+    {
+        return 0;
+    }
+
     virtual void * get_untyped_deleter()
     {
         return 0;
@@ -158,6 +177,11 @@ public:
         return ti == BOOST_SP_TYPEID(D)? &reinterpret_cast<char&>( del ): 0;
     }
 
+    virtual void * get_local_deleter( sp_typeinfo const & ti )
+    {
+        return ti == BOOST_SP_TYPEID(D)? boost::detail::get_local_deleter( boost::addressof( del ) ): 0;
+    }
+
     virtual void * get_untyped_deleter()
     {
         return &reinterpret_cast<char&>( del );
@@ -246,6 +270,11 @@ public:
         return ti == BOOST_SP_TYPEID( D )? &reinterpret_cast<char&>( d_ ): 0;
     }
 
+    virtual void * get_local_deleter( sp_typeinfo const & ti )
+    {
+        return ti == BOOST_SP_TYPEID(D)? boost::detail::get_local_deleter( boost::addressof( d_ ) ): 0;
+    }
+
     virtual void * get_untyped_deleter()
     {
         return &reinterpret_cast<char&>( d_ );

include/boost/smart_ptr/detail/sp_noexcept.hpp

@@ -9,7 +9,7 @@
 
 //  detail/sp_noexcept.hpp
 //
-//  Copyright 2016 Peter Dimov
+//  Copyright 2016, 2017 Peter Dimov
 //
 //  Distributed under the Boost Software License, Version 1.0.
 //  See accompanying file LICENSE_1_0.txt or copy at
@@ -17,13 +17,31 @@
 
 #include <boost/config.hpp>
 
+// BOOST_SP_NOEXCEPT
+
 #if defined( BOOST_MSVC ) && BOOST_MSVC >= 1700 && BOOST_MSVC < 1900
 
-#define BOOST_SP_NOEXCEPT BOOST_NOEXCEPT_OR_NOTHROW
+#  define BOOST_SP_NOEXCEPT BOOST_NOEXCEPT_OR_NOTHROW
 
 #else
 
-#define BOOST_SP_NOEXCEPT BOOST_NOEXCEPT
+#  define BOOST_SP_NOEXCEPT BOOST_NOEXCEPT
+
+#endif
+
+// BOOST_SP_NOEXCEPT_WITH_ASSERT
+
+#if defined(BOOST_DISABLE_ASSERTS) || ( defined(BOOST_ENABLE_ASSERT_DEBUG_HANDLER) && defined(NDEBUG) )
+
+#  define BOOST_SP_NOEXCEPT_WITH_ASSERT BOOST_SP_NOEXCEPT
+
+#elif defined(BOOST_ENABLE_ASSERT_HANDLER) || ( defined(BOOST_ENABLE_ASSERT_DEBUG_HANDLER) && !defined(NDEBUG) )
+
+#  define BOOST_SP_NOEXCEPT_WITH_ASSERT
+
+#else
+
+#  define BOOST_SP_NOEXCEPT_WITH_ASSERT BOOST_SP_NOEXCEPT
 
 #endif
 

include/boost/smart_ptr/enable_shared_from_this.hpp

@@ -10,7 +10,7 @@
 //  See accompanying file LICENSE_1_0.txt or copy at
 //  http://www.boost.org/LICENSE_1_0.txt
 //
-//  http://www.boost.org/libs/smart_ptr/enable_shared_from_this.html
+//  See http://www.boost.org/libs/smart_ptr/ for documentation.
 //
 
 #include <boost/smart_ptr/weak_ptr.hpp>
@@ -26,11 +26,11 @@ template<class T> class enable_shared_from_this
 {
 protected:
 
-    enable_shared_from_this() BOOST_SP_NOEXCEPT
+    BOOST_CONSTEXPR enable_shared_from_this() BOOST_SP_NOEXCEPT
     {
     }
 
-    enable_shared_from_this(enable_shared_from_this const &) BOOST_SP_NOEXCEPT
+    BOOST_CONSTEXPR enable_shared_from_this(enable_shared_from_this const &) BOOST_SP_NOEXCEPT
     {
     }
 
@@ -59,12 +59,12 @@ public:
         return p;
     }
 
-    weak_ptr<T> weak_from_this() BOOST_NOEXCEPT
+    weak_ptr<T> weak_from_this() BOOST_SP_NOEXCEPT
     {
         return weak_this_;
     }
 
-    weak_ptr<T const> weak_from_this() const BOOST_NOEXCEPT
+    weak_ptr<T const> weak_from_this() const BOOST_SP_NOEXCEPT
     {
         return weak_this_;
     }
@@ -72,7 +72,7 @@ public:
 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> const * ppx, Y * py ) const
+    template<class X, class Y> void _internal_accept_owner( shared_ptr<X> const * ppx, Y * py ) const BOOST_SP_NOEXCEPT
     {
         if( weak_this_.expired() )
         {

include/boost/smart_ptr/intrusive_ptr.hpp

@@ -6,11 +6,11 @@
 //
 //  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)
+//  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/intrusive_ptr.html for documentation.
+//  See http://www.boost.org/libs/smart_ptr/ for documentation.
 //
 
 #include <boost/config.hpp>
@@ -141,7 +141,7 @@ public:
     }
 
     template<class U>
-    intrusive_ptr & operator=(intrusive_ptr<U> && rhs) BOOST_NOEXCEPT
+    intrusive_ptr & operator=(intrusive_ptr<U> && rhs) BOOST_SP_NOEXCEPT
     {
         this_type( static_cast< intrusive_ptr<U> && >( rhs ) ).swap(*this);
         return *this;
@@ -161,7 +161,7 @@ public:
         return *this;
     }
 
-    void reset() BOOST_NOEXCEPT
+    void reset()
     {
         this_type().swap( *this );
     }
@@ -176,25 +176,25 @@ public:
         this_type( rhs, add_ref ).swap( *this );
     }
 
-    T * get() const BOOST_NOEXCEPT
+    T * get() const BOOST_SP_NOEXCEPT
     {
         return px;
     }
 
-    T * detach() BOOST_NOEXCEPT
+    T * detach() BOOST_SP_NOEXCEPT
     {
         T * ret = px;
         px = 0;
         return ret;
     }
 
-    T & operator*() const
+    T & operator*() const BOOST_SP_NOEXCEPT_WITH_ASSERT
     {
         BOOST_ASSERT( px != 0 );
         return *px;
     }
 
-    T * operator->() const
+    T * operator->() const BOOST_SP_NOEXCEPT_WITH_ASSERT
     {
         BOOST_ASSERT( px != 0 );
         return px;
@@ -203,7 +203,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) BOOST_SP_NOEXCEPT
     {
         T * tmp = px;
         px = rhs.px;
@@ -215,32 +215,32 @@ private:
     T * px;
 };
 
-template<class T, class U> inline bool operator==(intrusive_ptr<T> const & a, intrusive_ptr<U> const & b)
+template<class T, class U> inline bool operator==(intrusive_ptr<T> const & a, intrusive_ptr<U> const & b) BOOST_SP_NOEXCEPT
 {
     return a.get() == b.get();
 }
 
-template<class T, class U> inline bool operator!=(intrusive_ptr<T> const & a, intrusive_ptr<U> const & b)
+template<class T, class U> inline bool operator!=(intrusive_ptr<T> const & a, intrusive_ptr<U> const & b) BOOST_SP_NOEXCEPT
 {
     return a.get() != b.get();
 }
 
-template<class T, class U> inline bool operator==(intrusive_ptr<T> const & a, U * b)
+template<class T, class U> inline bool operator==(intrusive_ptr<T> const & a, U * b) BOOST_SP_NOEXCEPT
 {
     return a.get() == b;
 }
 
-template<class T, class U> inline bool operator!=(intrusive_ptr<T> const & a, U * b)
+template<class T, class U> inline bool operator!=(intrusive_ptr<T> const & a, U * b) BOOST_SP_NOEXCEPT
 {
     return a.get() != b;
 }
 
-template<class T, class U> inline bool operator==(T * a, intrusive_ptr<U> const & b)
+template<class T, class U> inline bool operator==(T * a, intrusive_ptr<U> const & b) BOOST_SP_NOEXCEPT
 {
     return a == b.get();
 }
 
-template<class T, class U> inline bool operator!=(T * a, intrusive_ptr<U> const & b)
+template<class T, class U> inline bool operator!=(T * a, intrusive_ptr<U> const & b) BOOST_SP_NOEXCEPT
 {
     return a != b.get();
 }
@@ -249,7 +249,7 @@ template<class T, class U> inline bool operator!=(T * a, intrusive_ptr<U> const
 
 // Resolve the ambiguity between our op!= and the one in rel_ops
 
-template<class T> inline bool operator!=(intrusive_ptr<T> const & a, intrusive_ptr<T> const & b)
+template<class T> inline bool operator!=(intrusive_ptr<T> const & a, intrusive_ptr<T> const & b) BOOST_SP_NOEXCEPT
 {
     return a.get() != b.get();
 }
@@ -258,41 +258,41 @@ template<class T> inline bool operator!=(intrusive_ptr<T> const & a, intrusive_p
 
 #if !defined( BOOST_NO_CXX11_NULLPTR )
 
-template<class T> inline bool operator==( intrusive_ptr<T> const & p, boost::detail::sp_nullptr_t ) BOOST_NOEXCEPT
+template<class T> inline bool operator==( intrusive_ptr<T> const & p, boost::detail::sp_nullptr_t ) BOOST_SP_NOEXCEPT
 {
     return p.get() == 0;
 }
 
-template<class T> inline bool operator==( boost::detail::sp_nullptr_t, intrusive_ptr<T> const & p ) BOOST_NOEXCEPT
+template<class T> inline bool operator==( boost::detail::sp_nullptr_t, intrusive_ptr<T> const & p ) BOOST_SP_NOEXCEPT
 {
     return p.get() == 0;
 }
 
-template<class T> inline bool operator!=( intrusive_ptr<T> const & p, boost::detail::sp_nullptr_t ) BOOST_NOEXCEPT
+template<class T> inline bool operator!=( intrusive_ptr<T> const & p, boost::detail::sp_nullptr_t ) BOOST_SP_NOEXCEPT
 {
     return p.get() != 0;
 }
 
-template<class T> inline bool operator!=( boost::detail::sp_nullptr_t, intrusive_ptr<T> const & p ) BOOST_NOEXCEPT
+template<class T> inline bool operator!=( boost::detail::sp_nullptr_t, intrusive_ptr<T> const & p ) BOOST_SP_NOEXCEPT
 {
     return p.get() != 0;
 }
 
 #endif
 
-template<class T> inline bool operator<(intrusive_ptr<T> const & a, intrusive_ptr<T> const & b)
+template<class T> inline bool operator<(intrusive_ptr<T> const & a, intrusive_ptr<T> const & b) BOOST_SP_NOEXCEPT
 {
     return std::less<T *>()(a.get(), b.get());
 }
 
-template<class T> void swap(intrusive_ptr<T> & lhs, intrusive_ptr<T> & rhs)
+template<class T> void swap(intrusive_ptr<T> & lhs, intrusive_ptr<T> & rhs) BOOST_SP_NOEXCEPT
 {
     lhs.swap(rhs);
 }
 
 // mem_fn support
 
-template<class T> T * get_pointer(intrusive_ptr<T> const & p)
+template<class T> T * get_pointer(intrusive_ptr<T> const & p) BOOST_SP_NOEXCEPT
 {
     return p.get();
 }
@@ -351,7 +351,7 @@ template<class E, class T, class Y> std::basic_ostream<E, T> & operator<< (std::
 
 template< class T > struct hash;
 
-template< class T > std::size_t hash_value( boost::intrusive_ptr<T> const & p )
+template< class T > std::size_t hash_value( boost::intrusive_ptr<T> const & p ) BOOST_SP_NOEXCEPT
 {
     return boost::hash< T* >()( p.get() );
 }

include/boost/smart_ptr/intrusive_ref_counter.hpp

@@ -17,6 +17,7 @@
 
 #include <boost/config.hpp>
 #include <boost/smart_ptr/detail/atomic_count.hpp>
+#include <boost/smart_ptr/detail/sp_noexcept.hpp>
 
 #ifdef BOOST_HAS_PRAGMA_ONCE
 #pragma once
@@ -45,17 +46,17 @@ struct thread_unsafe_counter
 {
     typedef unsigned int type;
 
-    static unsigned int load(unsigned int const& counter) BOOST_NOEXCEPT
+    static unsigned int load(unsigned int const& counter) BOOST_SP_NOEXCEPT
     {
         return counter;
     }
 
-    static void increment(unsigned int& counter) BOOST_NOEXCEPT
+    static void increment(unsigned int& counter) BOOST_SP_NOEXCEPT
     {
         ++counter;
     }
 
-    static unsigned int decrement(unsigned int& counter) BOOST_NOEXCEPT
+    static unsigned int decrement(unsigned int& counter) BOOST_SP_NOEXCEPT
     {
         return --counter;
     }
@@ -71,17 +72,17 @@ struct thread_safe_counter
 {
     typedef boost::detail::atomic_count type;
 
-    static unsigned int load(boost::detail::atomic_count const& counter) BOOST_NOEXCEPT
+    static unsigned int load(boost::detail::atomic_count const& counter) BOOST_SP_NOEXCEPT
     {
         return static_cast< unsigned int >(static_cast< long >(counter));
     }
 
-    static void increment(boost::detail::atomic_count& counter) BOOST_NOEXCEPT
+    static void increment(boost::detail::atomic_count& counter) BOOST_SP_NOEXCEPT
     {
         ++counter;
     }
 
-    static unsigned int decrement(boost::detail::atomic_count& counter) BOOST_NOEXCEPT
+    static unsigned int decrement(boost::detail::atomic_count& counter) BOOST_SP_NOEXCEPT
     {
         return static_cast< unsigned int >(--counter);
     }
@@ -91,9 +92,9 @@ 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;
+void intrusive_ptr_add_ref(const intrusive_ref_counter< DerivedT, CounterPolicyT >* p) BOOST_SP_NOEXCEPT;
 template< typename DerivedT, typename CounterPolicyT >
-void intrusive_ptr_release(const intrusive_ref_counter< DerivedT, CounterPolicyT >* p) BOOST_NOEXCEPT;
+void intrusive_ptr_release(const intrusive_ref_counter< DerivedT, CounterPolicyT >* p) BOOST_SP_NOEXCEPT;
 
 /*!
  * \brief A reference counter base class
@@ -121,7 +122,7 @@ public:
      *
      * \post <tt>use_count() == 0</tt>
      */
-    intrusive_ref_counter() BOOST_NOEXCEPT : m_ref_counter(0)
+    intrusive_ref_counter() BOOST_SP_NOEXCEPT : m_ref_counter(0)
     {
     }
 
@@ -130,7 +131,7 @@ public:
      *
      * \post <tt>use_count() == 0</tt>
      */
-    intrusive_ref_counter(intrusive_ref_counter const&) BOOST_NOEXCEPT : m_ref_counter(0)
+    intrusive_ref_counter(intrusive_ref_counter const&) BOOST_SP_NOEXCEPT : m_ref_counter(0)
     {
     }
 
@@ -139,12 +140,12 @@ public:
      *
      * \post The reference counter is not modified after assignment
      */
-    intrusive_ref_counter& operator= (intrusive_ref_counter const&) BOOST_NOEXCEPT { return *this; }
+    intrusive_ref_counter& operator= (intrusive_ref_counter const&) BOOST_SP_NOEXCEPT { return *this; }
 
     /*!
      * \return The reference counter
      */
-    unsigned int use_count() const BOOST_NOEXCEPT
+    unsigned int use_count() const BOOST_SP_NOEXCEPT
     {
         return CounterPolicyT::load(m_ref_counter);
     }
@@ -155,18 +156,18 @@ protected:
      */
     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;
+    friend void intrusive_ptr_add_ref< DerivedT, CounterPolicyT >(const intrusive_ref_counter< DerivedT, CounterPolicyT >* p) BOOST_SP_NOEXCEPT;
+    friend void intrusive_ptr_release< DerivedT, CounterPolicyT >(const intrusive_ref_counter< DerivedT, CounterPolicyT >* p) BOOST_SP_NOEXCEPT;
 };
 
 template< typename DerivedT, typename CounterPolicyT >
-inline void intrusive_ptr_add_ref(const intrusive_ref_counter< DerivedT, CounterPolicyT >* p) BOOST_NOEXCEPT
+inline void intrusive_ptr_add_ref(const intrusive_ref_counter< DerivedT, CounterPolicyT >* p) BOOST_SP_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
+inline void intrusive_ptr_release(const intrusive_ref_counter< DerivedT, CounterPolicyT >* p) BOOST_SP_NOEXCEPT
 {
     if (CounterPolicyT::decrement(p->m_ref_counter) == 0)
         delete static_cast< const DerivedT* >(p);

include/boost/smart_ptr/local_shared_ptr.hpp

@@ -0,0 +1,684 @@
+#ifndef BOOST_SMART_PTR_LOCAL_SHARED_PTR_HPP_INCLUDED
+#define BOOST_SMART_PTR_LOCAL_SHARED_PTR_HPP_INCLUDED
+
+//  local_shared_ptr.hpp
+//
+//  Copyright 2017 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/ for documentation.
+
+#include <boost/smart_ptr/shared_ptr.hpp>
+
+namespace boost
+{
+
+template<class T> class local_shared_ptr;
+
+namespace detail
+{
+
+template< class E, class Y > inline void lsp_pointer_construct( boost::local_shared_ptr< E > * /*ppx*/, Y * p, boost::detail::local_counted_base * & pn )
+{
+    boost::detail::sp_assert_convertible< Y, E >();
+
+    typedef boost::detail::local_sp_deleter< boost::checked_deleter<Y> > D;
+
+    boost::shared_ptr<E> p2( p, D() );
+
+    D * pd = static_cast< D * >( p2._internal_get_untyped_deleter() );
+
+    pd->pn_ = p2._internal_count();
+
+    pn = pd;
+}
+
+template< class E, class Y > inline void lsp_pointer_construct( boost::local_shared_ptr< E[] > * /*ppx*/, Y * p, boost::detail::local_counted_base * & pn )
+{
+    boost::detail::sp_assert_convertible< Y[], E[] >();
+
+    typedef boost::detail::local_sp_deleter< boost::checked_array_deleter<E> > D;
+
+    boost::shared_ptr<E[]> p2( p, D() );
+
+    D * pd = static_cast< D * >( p2._internal_get_untyped_deleter() );
+
+    pd->pn_ = p2._internal_count();
+
+    pn = pd;
+}
+
+template< class E, std::size_t N, class Y > inline void lsp_pointer_construct( boost::local_shared_ptr< E[N] > * /*ppx*/, Y * p, boost::detail::local_counted_base * & pn )
+{
+    boost::detail::sp_assert_convertible< Y[N], E[N] >();
+
+    typedef boost::detail::local_sp_deleter< boost::checked_array_deleter<E> > D;
+
+    boost::shared_ptr<E[N]> p2( p, D() );
+
+    D * pd = static_cast< D * >( p2._internal_get_untyped_deleter() );
+
+    pd->pn_ = p2._internal_count();
+
+    pn = pd;
+}
+
+template< class E, class P, class D > inline void lsp_deleter_construct( boost::local_shared_ptr< E > * /*ppx*/, P p, D const& d, boost::detail::local_counted_base * & pn )
+{
+    typedef boost::detail::local_sp_deleter<D> D2;
+
+    boost::shared_ptr<E> p2( p, D2( d ) );
+
+    D2 * pd = static_cast< D2 * >( p2._internal_get_untyped_deleter() );
+
+    pd->pn_ = p2._internal_count();
+
+    pn = pd;
+}
+
+template< class E, class P, class D, class A > inline void lsp_allocator_construct( boost::local_shared_ptr< E > * /*ppx*/, P p, D const& d, A const& a, boost::detail::local_counted_base * & pn )
+{
+    typedef boost::detail::local_sp_deleter<D> D2;
+
+    boost::shared_ptr<E> p2( p, D2( d ), a );
+
+    D2 * pd = static_cast< D2 * >( p2._internal_get_untyped_deleter() );
+
+    pd->pn_ = p2._internal_count();
+
+    pn = pd;
+}
+
+struct lsp_internal_constructor_tag
+{
+};
+
+} // namespace detail
+
+//
+// local_shared_ptr
+//
+// as shared_ptr, but local to a thread.
+// reference count manipulations are non-atomic.
+//
+
+template<class T> class local_shared_ptr
+{
+private:
+
+    typedef local_shared_ptr this_type;
+
+public:
+
+    typedef typename boost::detail::sp_element<T>::type element_type;
+
+private:
+
+    element_type * px;
+    boost::detail::local_counted_base * pn;
+
+    template<class Y> friend class local_shared_ptr;
+
+public:
+
+    // destructor
+
+    ~local_shared_ptr() BOOST_SP_NOEXCEPT
+    {
+        if( pn )
+        {
+            pn->release();
+        }
+    }
+
+    // constructors
+
+    BOOST_CONSTEXPR local_shared_ptr() BOOST_SP_NOEXCEPT : px( 0 ), pn( 0 )
+    {
+    }
+
+#if !defined( BOOST_NO_CXX11_NULLPTR )
+
+    BOOST_CONSTEXPR local_shared_ptr( boost::detail::sp_nullptr_t ) BOOST_SP_NOEXCEPT : px( 0 ), pn( 0 )
+    {
+    }
+
+#endif
+
+    // internal constructor, used by make_shared
+    BOOST_CONSTEXPR local_shared_ptr( boost::detail::lsp_internal_constructor_tag, T * px_, boost::detail::local_counted_base * pn_ ) BOOST_SP_NOEXCEPT : px( px_ ), pn( pn_ )
+    {
+    }
+
+    template<class Y>
+    explicit local_shared_ptr( Y * p ): px( p ), pn( 0 )
+    {
+        boost::detail::lsp_pointer_construct( this, p, pn );
+    }
+
+    template<class Y, class D> local_shared_ptr( Y * p, D d ): px( p ), pn( 0 )
+    {
+        boost::detail::lsp_deleter_construct( this, p, d, pn );
+    }
+
+#if !defined( BOOST_NO_CXX11_NULLPTR )
+
+    template<class D> local_shared_ptr( boost::detail::sp_nullptr_t p, D d ): px( p ), pn( 0 )
+    {
+        boost::detail::lsp_deleter_construct( this, p, d, pn );
+    }
+
+#endif
+
+    template<class Y, class D, class A> local_shared_ptr( Y * p, D d, A a ): px( p ), pn( 0 )
+    {
+        boost::detail::lsp_allocator_construct( this, p, d, a, pn );
+    }
+
+#if !defined( BOOST_NO_CXX11_NULLPTR )
+
+    template<class D, class A> local_shared_ptr( boost::detail::sp_nullptr_t p, D d, A a ): px( p ), pn( 0 )
+    {
+        boost::detail::lsp_allocator_construct( this, p, d, a, pn );
+    }
+
+#endif
+
+    // construction from shared_ptr
+
+    template<class Y> local_shared_ptr( shared_ptr<Y> const & r,
+        typename boost::detail::sp_enable_if_convertible<Y, T>::type = boost::detail::sp_empty() )
+        : px( r.get() ), pn( 0 )
+    {
+        boost::detail::sp_assert_convertible< Y, T >();
+
+        if( r.use_count() != 0 )
+        {
+            pn = new boost::detail::local_counted_impl( r._internal_count() );
+        }
+    }
+
+#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
+
+    template<class Y> local_shared_ptr( shared_ptr<Y> && r,
+        typename boost::detail::sp_enable_if_convertible<Y, T>::type = boost::detail::sp_empty() )
+        : px( r.get() ), pn( 0 )
+    {
+        boost::detail::sp_assert_convertible< Y, T >();
+
+        if( r.use_count() != 0 )
+        {
+            pn = new boost::detail::local_counted_impl( r._internal_count() );
+            r.reset();
+        }
+    }
+
+#endif
+
+    // construction from unique_ptr
+
+#if !defined( BOOST_NO_CXX11_SMART_PTR ) && !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
+
+    template< class Y, class D >
+    local_shared_ptr( std::unique_ptr< Y, D > && r,
+        typename boost::detail::sp_enable_if_convertible<Y, T>::type = boost::detail::sp_empty() )
+        : px( r.get() ), pn( 0 )
+    {
+        boost::detail::sp_assert_convertible< Y, T >();
+
+        if( px )
+        {
+            pn = new boost::detail::local_counted_impl( shared_ptr<T>( std::move(r) )._internal_count() );
+        }
+    }
+
+#endif
+
+    template< class Y, class D >
+    local_shared_ptr( boost::movelib::unique_ptr< Y, D > r ); // !
+    //	: px( r.get() ), pn( new boost::detail::local_counted_impl( shared_ptr<T>( std::move(r) ) ) )
+    //{
+    //	boost::detail::sp_assert_convertible< Y, T >();
+    //}
+
+    // copy constructor
+
+    local_shared_ptr( local_shared_ptr const & r ) BOOST_SP_NOEXCEPT : px( r.px ), pn( r.pn )
+    {
+        if( pn )
+        {
+            pn->add_ref();
+        }
+    }
+
+    // move constructor
+
+#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
+
+    local_shared_ptr( local_shared_ptr && r ) BOOST_SP_NOEXCEPT : px( r.px ), pn( r.pn )
+    {
+        r.px = 0;
+        r.pn = 0;
+    }
+
+#endif
+
+    // converting copy constructor
+
+    template<class Y> local_shared_ptr( local_shared_ptr<Y> const & r,
+        typename boost::detail::sp_enable_if_convertible<Y, T>::type = boost::detail::sp_empty() ) BOOST_SP_NOEXCEPT
+        : px( r.px ), pn( r.pn )
+    {
+        boost::detail::sp_assert_convertible< Y, T >();
+
+        if( pn )
+        {
+            pn->add_ref();
+        }
+    }
+
+    // converting move constructor
+
+#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
+
+    template<class Y> local_shared_ptr( local_shared_ptr<Y> && r,
+        typename boost::detail::sp_enable_if_convertible<Y, T>::type = boost::detail::sp_empty() ) BOOST_SP_NOEXCEPT
+        : px( r.px ), pn( r.pn )
+    {
+        boost::detail::sp_assert_convertible< Y, T >();
+
+        r.px = 0;
+        r.pn = 0;
+    }
+
+#endif
+
+    // aliasing
+
+    template<class Y>
+    local_shared_ptr( local_shared_ptr<Y> const & r, element_type * p ) BOOST_SP_NOEXCEPT : px( p ), pn( r.pn )
+    {
+        if( pn )
+        {
+            pn->add_ref();
+        }
+    }
+
+#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
+
+    template<class Y>
+    local_shared_ptr( local_shared_ptr<Y> && r, element_type * p ) BOOST_SP_NOEXCEPT : px( p ), pn( r.pn )
+    {
+        r.px = 0;
+        r.pn = 0;
+    }
+
+#endif
+
+    // assignment
+
+    local_shared_ptr & operator=( local_shared_ptr const & r ) BOOST_SP_NOEXCEPT
+    {
+        local_shared_ptr( r ).swap( *this );
+        return *this;
+    }
+
+    template<class Y> local_shared_ptr & operator=( local_shared_ptr<Y> const & r ) BOOST_SP_NOEXCEPT
+    {
+        local_shared_ptr( r ).swap( *this );
+        return *this;
+    }
+
+#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
+
+    local_shared_ptr & operator=( local_shared_ptr && r ) BOOST_SP_NOEXCEPT
+    {
+        local_shared_ptr( std::move( r ) ).swap( *this );
+        return *this;
+    }
+
+    template<class Y>
+    local_shared_ptr & operator=( local_shared_ptr<Y> && r ) BOOST_SP_NOEXCEPT
+    {
+        local_shared_ptr( std::move( r ) ).swap( *this );
+        return *this;
+    }
+
+#endif
+
+#if !defined( BOOST_NO_CXX11_NULLPTR )
+
+    local_shared_ptr & operator=( boost::detail::sp_nullptr_t ) BOOST_SP_NOEXCEPT
+    {
+        local_shared_ptr().swap(*this);
+        return *this;
+    }
+
+#endif
+
+#if !defined( BOOST_NO_CXX11_SMART_PTR ) && !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
+
+    template<class Y, class D>
+    local_shared_ptr & operator=( std::unique_ptr<Y, D> && r )
+    {
+        local_shared_ptr( std::move(r) ).swap( *this );
+        return *this;
+    }
+
+#endif
+
+    template<class Y, class D>
+    local_shared_ptr & operator=( boost::movelib::unique_ptr<Y, D> r ); // !
+
+    // reset
+
+    void reset() BOOST_SP_NOEXCEPT
+    {
+        local_shared_ptr().swap( *this );
+    }
+
+    template<class Y> void reset( Y * p ) // Y must be complete
+    {
+        local_shared_ptr( p ).swap( *this );
+    }
+
+    template<class Y, class D> void reset( Y * p, D d )
+    {
+        local_shared_ptr( p, d ).swap( *this );
+    }
+
+    template<class Y, class D, class A> void reset( Y * p, D d, A a )
+    {
+        local_shared_ptr( p, d, a ).swap( *this );
+    }
+
+    template<class Y> void reset( local_shared_ptr<Y> const & r, element_type * p ) BOOST_SP_NOEXCEPT
+    {
+        local_shared_ptr( r, p ).swap( *this );
+    }
+
+#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
+
+    template<class Y> void reset( local_shared_ptr<Y> && r, element_type * p ) BOOST_SP_NOEXCEPT
+    {
+        local_shared_ptr( std::move( r ), p ).swap( *this );
+    }
+
+#endif
+
+    // accessors
+
+    typename boost::detail::sp_dereference< T >::type operator* () const BOOST_SP_NOEXCEPT
+    {
+        return *px;
+    }
+
+    typename boost::detail::sp_member_access< T >::type operator-> () const BOOST_SP_NOEXCEPT
+    {
+        return px;
+    }
+
+    typename boost::detail::sp_array_access< T >::type operator[] ( std::ptrdiff_t i ) const BOOST_SP_NOEXCEPT_WITH_ASSERT
+    {
+        BOOST_ASSERT( px != 0 );
+        BOOST_ASSERT( i >= 0 && ( i < boost::detail::sp_extent< T >::value || boost::detail::sp_extent< T >::value == 0 ) );
+
+        return static_cast< typename boost::detail::sp_array_access< T >::type >( px[ i ] );
+    }
+
+    element_type * get() const BOOST_SP_NOEXCEPT
+    {
+        return px;
+    }
+
+    // implicit conversion to "bool"
+#include <boost/smart_ptr/detail/operator_bool.hpp>
+
+    long local_use_count() const BOOST_SP_NOEXCEPT
+    {
+        return pn? pn->local_use_count(): 0;
+    }
+
+    // conversions to shared_ptr, weak_ptr
+
+#if !defined( BOOST_SP_NO_SP_CONVERTIBLE ) && !defined(BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS)
+    template<class Y, class E = typename boost::detail::sp_enable_if_convertible<T,Y>::type> operator shared_ptr<Y>() const BOOST_SP_NOEXCEPT
+#else
+    template<class Y> operator shared_ptr<Y>() const BOOST_SP_NOEXCEPT
+#endif
+    {
+        boost::detail::sp_assert_convertible<T, Y>();
+
+        if( pn )
+        {
+            return shared_ptr<Y>( boost::detail::sp_internal_constructor_tag(), px, pn->local_cb_get_shared_count() );
+        }
+        else
+        {
+            return shared_ptr<Y>();
+        }
+    }
+
+#if !defined( BOOST_SP_NO_SP_CONVERTIBLE ) && !defined(BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS)
+    template<class Y, class E = typename boost::detail::sp_enable_if_convertible<T,Y>::type> operator weak_ptr<Y>() const BOOST_SP_NOEXCEPT
+#else
+    template<class Y> operator weak_ptr<Y>() const BOOST_SP_NOEXCEPT
+#endif
+    {
+        boost::detail::sp_assert_convertible<T, Y>();
+
+        if( pn )
+        {
+            return shared_ptr<Y>( boost::detail::sp_internal_constructor_tag(), px, pn->local_cb_get_shared_count() );
+        }
+        else
+        {
+            return weak_ptr<Y>();
+        }
+    }
+
+    // swap
+
+    void swap( local_shared_ptr & r ) BOOST_SP_NOEXCEPT
+    {
+        std::swap( px, r.px );
+        std::swap( pn, r.pn );
+    }
+
+    // owner_before
+
+    template<class Y> bool owner_before( local_shared_ptr<Y> const & r ) const BOOST_SP_NOEXCEPT
+    {
+        return std::less< boost::detail::local_counted_base* >()( pn, r.pn );
+    }
+};
+
+template<class T, class U> inline bool operator==( local_shared_ptr<T> const & a, local_shared_ptr<U> const & b ) BOOST_SP_NOEXCEPT
+{
+    return a.get() == b.get();
+}
+
+template<class T, class U> inline bool operator!=( local_shared_ptr<T> const & a, local_shared_ptr<U> const & b ) BOOST_SP_NOEXCEPT
+{
+    return a.get() != b.get();
+}
+
+#if !defined( BOOST_NO_CXX11_NULLPTR )
+
+template<class T> inline bool operator==( local_shared_ptr<T> const & p, boost::detail::sp_nullptr_t ) BOOST_SP_NOEXCEPT
+{
+    return p.get() == 0;
+}
+
+template<class T> inline bool operator==( boost::detail::sp_nullptr_t, local_shared_ptr<T> const & p ) BOOST_SP_NOEXCEPT
+{
+    return p.get() == 0;
+}
+
+template<class T> inline bool operator!=( local_shared_ptr<T> const & p, boost::detail::sp_nullptr_t ) BOOST_SP_NOEXCEPT
+{
+    return p.get() != 0;
+}
+
+template<class T> inline bool operator!=( boost::detail::sp_nullptr_t, local_shared_ptr<T> const & p ) BOOST_SP_NOEXCEPT
+{
+    return p.get() != 0;
+}
+
+#endif
+
+template<class T, class U> inline bool operator==( local_shared_ptr<T> const & a, shared_ptr<U> const & b ) BOOST_SP_NOEXCEPT
+{
+    return a.get() == b.get();
+}
+
+template<class T, class U> inline bool operator!=( local_shared_ptr<T> const & a, shared_ptr<U> const & b ) BOOST_SP_NOEXCEPT
+{
+    return a.get() != b.get();
+}
+
+template<class T, class U> inline bool operator==( shared_ptr<T> const & a, local_shared_ptr<U> const & b ) BOOST_SP_NOEXCEPT
+{
+    return a.get() == b.get();
+}
+
+template<class T, class U> inline bool operator!=( shared_ptr<T> const & a, local_shared_ptr<U> const & b ) BOOST_SP_NOEXCEPT
+{
+    return a.get() != b.get();
+}
+
+template<class T, class U> inline bool operator<(local_shared_ptr<T> const & a, local_shared_ptr<U> const & b) BOOST_SP_NOEXCEPT
+{
+    return a.owner_before( b );
+}
+
+template<class T> inline void swap( local_shared_ptr<T> & a, local_shared_ptr<T> & b ) BOOST_SP_NOEXCEPT
+{
+    a.swap( b );
+}
+
+template<class T, class U> local_shared_ptr<T> static_pointer_cast( local_shared_ptr<U> const & r ) BOOST_SP_NOEXCEPT
+{
+    (void) static_cast< T* >( static_cast< U* >( 0 ) );
+
+    typedef typename local_shared_ptr<T>::element_type E;
+
+    E * p = static_cast< E* >( r.get() );
+    return local_shared_ptr<T>( r, p );
+}
+
+template<class T, class U> local_shared_ptr<T> const_pointer_cast( local_shared_ptr<U> const & r ) BOOST_SP_NOEXCEPT
+{
+    (void) const_cast< T* >( static_cast< U* >( 0 ) );
+
+    typedef typename local_shared_ptr<T>::element_type E;
+
+    E * p = const_cast< E* >( r.get() );
+    return local_shared_ptr<T>( r, p );
+}
+
+template<class T, class U> local_shared_ptr<T> dynamic_pointer_cast( local_shared_ptr<U> const & r ) BOOST_SP_NOEXCEPT
+{
+    (void) dynamic_cast< T* >( static_cast< U* >( 0 ) );
+
+    typedef typename local_shared_ptr<T>::element_type E;
+
+    E * p = dynamic_cast< E* >( r.get() );
+    return p? local_shared_ptr<T>( r, p ): local_shared_ptr<T>();
+}
+
+template<class T, class U> local_shared_ptr<T> reinterpret_pointer_cast( local_shared_ptr<U> const & r ) BOOST_SP_NOEXCEPT
+{
+    (void) reinterpret_cast< T* >( static_cast< U* >( 0 ) );
+
+    typedef typename local_shared_ptr<T>::element_type E;
+
+    E * p = reinterpret_cast< E* >( r.get() );
+    return local_shared_ptr<T>( r, p );
+}
+
+#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
+
+template<class T, class U> local_shared_ptr<T> static_pointer_cast( local_shared_ptr<U> && r ) BOOST_SP_NOEXCEPT
+{
+    (void) static_cast< T* >( static_cast< U* >( 0 ) );
+
+    typedef typename local_shared_ptr<T>::element_type E;
+
+    E * p = static_cast< E* >( r.get() );
+    return local_shared_ptr<T>( std::move(r), p );
+}
+
+template<class T, class U> local_shared_ptr<T> const_pointer_cast( local_shared_ptr<U> && r ) BOOST_SP_NOEXCEPT
+{
+    (void) const_cast< T* >( static_cast< U* >( 0 ) );
+
+    typedef typename local_shared_ptr<T>::element_type E;
+
+    E * p = const_cast< E* >( r.get() );
+    return local_shared_ptr<T>( std::move(r), p );
+}
+
+template<class T, class U> local_shared_ptr<T> dynamic_pointer_cast( local_shared_ptr<U> && r ) BOOST_SP_NOEXCEPT
+{
+    (void) dynamic_cast< T* >( static_cast< U* >( 0 ) );
+
+    typedef typename local_shared_ptr<T>::element_type E;
+
+    E * p = dynamic_cast< E* >( r.get() );
+    return p? local_shared_ptr<T>( std::move(r), p ): local_shared_ptr<T>();
+}
+
+template<class T, class U> local_shared_ptr<T> reinterpret_pointer_cast( local_shared_ptr<U> && r ) BOOST_SP_NOEXCEPT
+{
+    (void) reinterpret_cast< T* >( static_cast< U* >( 0 ) );
+
+    typedef typename local_shared_ptr<T>::element_type E;
+
+    E * p = reinterpret_cast< E* >( r.get() );
+    return local_shared_ptr<T>( std::move(r), p );
+}
+
+#endif // !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
+
+// get_pointer() enables boost::mem_fn to recognize local_shared_ptr
+
+template<class T> inline typename local_shared_ptr<T>::element_type * get_pointer( local_shared_ptr<T> const & p ) BOOST_SP_NOEXCEPT
+{
+    return p.get();
+}
+
+// operator<<
+
+#if !defined(BOOST_NO_IOSTREAM)
+
+template<class E, class T, class Y> std::basic_ostream<E, T> & operator<< ( std::basic_ostream<E, T> & os, local_shared_ptr<Y> const & p )
+{
+    os << p.get();
+    return os;
+}
+
+#endif // !defined(BOOST_NO_IOSTREAM)
+
+// get_deleter
+
+template<class D, class T> D * get_deleter( local_shared_ptr<T> const & p ) BOOST_SP_NOEXCEPT
+{
+    return get_deleter<D>( shared_ptr<T>( p ) );
+}
+
+// hash_value
+
+template< class T > struct hash;
+
+template< class T > std::size_t hash_value( local_shared_ptr<T> const & p ) BOOST_SP_NOEXCEPT
+{
+    return boost::hash< typename local_shared_ptr<T>::element_type* >()( p.get() );
+}
+
+} // namespace boost
+
+#endif  // #ifndef BOOST_SMART_PTR_LOCAL_SHARED_PTR_HPP_INCLUDED

include/boost/smart_ptr/make_local_shared.hpp

@@ -0,0 +1,17 @@
+#ifndef BOOST_SMART_PTR_MAKE_LOCAL_SHARED_HPP_INCLUDED
+#define BOOST_SMART_PTR_MAKE_LOCAL_SHARED_HPP_INCLUDED
+
+//  make_local_shared.hpp
+//
+//  Copyright 2017 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/ for documentation.
+
+#include <boost/smart_ptr/make_local_shared_object.hpp>
+#include <boost/smart_ptr/make_local_shared_array.hpp>
+
+#endif // #ifndef BOOST_SMART_PTR_MAKE_LOCAL_SHARED_HPP_INCLUDED

include/boost/smart_ptr/make_local_shared_array.hpp

@@ -0,0 +1,63 @@
+#ifndef BOOST_SMART_PTR_MAKE_LOCAL_SHARED_ARRAY_HPP_INCLUDED
+#define BOOST_SMART_PTR_MAKE_LOCAL_SHARED_ARRAY_HPP_INCLUDED
+
+//  make_local_shared_array.hpp
+//
+//  Copyright 2017 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/ for documentation.
+
+#include <boost/config.hpp>
+#include <boost/smart_ptr/make_shared.hpp>
+#include <utility>
+#include <cstddef>
+
+namespace boost
+{
+
+namespace detail
+{
+
+template<class T> struct lsp_if_array
+{
+};
+
+template<class T> struct lsp_if_array<T[]>
+{
+    typedef boost::local_shared_ptr<T[]> type;
+};
+
+template<class T, std::size_t N> struct lsp_if_array<T[N]>
+{
+    typedef boost::local_shared_ptr<T[N]> type;
+};
+
+} // namespace detail
+
+template<class T, class... Args> typename boost::detail::lsp_if_array<T>::type make_local_shared( Args&&... args )
+{
+    return boost::make_shared<T>( std::forward<Args>(args)... );
+}
+
+template<class T, class... Args> typename boost::detail::lsp_if_array<T>::type make_local_shared_noinit( Args&&... args )
+{
+    return boost::make_shared_noinit<T>( std::forward<Args>(args)... );
+}
+
+template<class T, class A, class... Args> typename boost::detail::lsp_if_array<T>::type allocate_local_shared( A const & a, Args&&... args )
+{
+    return boost::allocate_shared<T>( a, std::forward<Args>(args)... );
+}
+
+template<class T, class A, class... Args> typename boost::detail::lsp_if_array<T>::type allocate_local_shared_noinit( A const & a, Args&&... args )
+{
+    return boost::allocate_shared_noinit<T>( a, std::forward<Args>(args)... );
+}
+
+} // namespace boost
+
+#endif // #ifndef BOOST_SMART_PTR_MAKE_SHARED_OBJECT_HPP_INCLUDED

include/boost/smart_ptr/make_local_shared_object.hpp

@@ -0,0 +1,199 @@
+#ifndef BOOST_SMART_PTR_MAKE_LOCAL_SHARED_OBJECT_HPP_INCLUDED
+#define BOOST_SMART_PTR_MAKE_LOCAL_SHARED_OBJECT_HPP_INCLUDED
+
+//  make_local_shared_object.hpp
+//
+//  Copyright 2017 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/ for documentation.
+
+#include <boost/smart_ptr/local_shared_ptr.hpp>
+#include <boost/smart_ptr/make_shared.hpp>
+#include <boost/config.hpp>
+#include <utility>
+#include <cstddef>
+
+namespace boost
+{
+
+namespace detail
+{
+
+// lsp_if_not_array
+
+template<class T> struct lsp_if_not_array
+{
+    typedef boost::local_shared_ptr<T> type;
+};
+
+template<class T> struct lsp_if_not_array<T[]>
+{
+};
+
+template<class T, std::size_t N> struct lsp_if_not_array<T[N]>
+{
+};
+
+// lsp_ms_deleter
+
+template<class T, class A> class lsp_ms_deleter: public local_counted_impl_em
+{
+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() BOOST_SP_NOEXCEPT
+    {
+        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:
+
+    explicit lsp_ms_deleter( A const & a ) BOOST_SP_NOEXCEPT : a_( a ), initialized_( false )
+    {
+    }
+
+    // optimization: do not copy storage_
+    lsp_ms_deleter( lsp_ms_deleter const & r ) BOOST_SP_NOEXCEPT : a_( r.a_), initialized_( false )
+    {
+    }
+
+    ~lsp_ms_deleter() BOOST_SP_NOEXCEPT
+    {
+        destroy();
+    }
+
+    void operator()( T * ) BOOST_SP_NOEXCEPT
+    {
+        destroy();
+    }
+
+    static void operator_fn( T* ) BOOST_SP_NOEXCEPT // operator() can't be static
+    {
+    }
+
+    void * address() BOOST_SP_NOEXCEPT
+    {
+        return storage_.data_;
+    }
+
+    void set_initialized() BOOST_SP_NOEXCEPT
+    {
+        initialized_ = true;
+    }
+};
+
+} // namespace detail
+
+template<class T, class A, class... Args> typename boost::detail::lsp_if_not_array<T>::type allocate_local_shared( A const & a, Args&&... args )
+{
+#if !defined( BOOST_NO_CXX11_ALLOCATOR )
+
+    typedef typename std::allocator_traits<A>::template rebind_alloc<T> A2;
+
+#else
+
+    typedef typename A::template rebind<T>::other A2;
+
+#endif
+
+    A2 a2( a );
+
+    typedef boost::detail::lsp_ms_deleter<T, A2> D;
+
+    boost::shared_ptr<T> pt( static_cast< T* >( 0 ), boost::detail::sp_inplace_tag<D>(), a2 );
+
+    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 ), std::forward<Args>( args )... );
+
+#else
+
+    ::new( pv ) T( std::forward<Args>( args )... );
+
+#endif
+
+    pd->set_initialized();
+
+    T * pt2 = static_cast< T* >( pv );
+    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
+
+    pd->pn_ = pt._internal_count();
+
+    return boost::local_shared_ptr<T>( boost::detail::lsp_internal_constructor_tag(), pt2, pd );
+}
+
+template<class T, class A> typename boost::detail::lsp_if_not_array<T>::type allocate_local_shared_noinit( A const & a )
+{
+#if !defined( BOOST_NO_CXX11_ALLOCATOR )
+
+    typedef typename std::allocator_traits<A>::template rebind_alloc<T> A2;
+
+#else
+
+    typedef typename A::template rebind<T>::other A2;
+
+#endif
+
+    A2 a2( a );
+
+    typedef boost::detail::lsp_ms_deleter<T, A2> D;
+
+    boost::shared_ptr<T> pt( static_cast< T* >( 0 ), boost::detail::sp_inplace_tag<D>(), a2 );
+
+    D * pd = static_cast< D* >( 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 );
+
+    pd->pn_ = pt._internal_count();
+
+    return boost::local_shared_ptr<T>( boost::detail::lsp_internal_constructor_tag(), pt2, pd );
+}
+
+template<class T, class... Args> typename boost::detail::lsp_if_not_array<T>::type make_local_shared( Args&&... args )
+{
+    return boost::allocate_local_shared<T>( std::allocator<T>(), std::forward<Args>(args)... );
+}
+
+template<class T> typename boost::detail::lsp_if_not_array<T>::type make_local_shared_noinit()
+{
+    return boost::allocate_shared_noinit<T>( std::allocator<T>() );
+}
+
+} // namespace boost
+
+#endif // #ifndef BOOST_SMART_PTR_MAKE_SHARED_OBJECT_HPP_INCLUDED

include/boost/smart_ptr/make_shared.hpp

@@ -9,8 +9,7 @@
 //  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.
+//  See http://www.boost.org/libs/smart_ptr/ for documentation.
 
 #include <boost/smart_ptr/make_shared_object.hpp>
 

include/boost/smart_ptr/make_shared_object.hpp

@@ -9,14 +9,14 @@
 //  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.
+//  See http://www.boost.org/libs/smart_ptr/ 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/smart_ptr/detail/sp_noexcept.hpp>
 #include <boost/type_traits/type_with_alignment.hpp>
 #include <boost/type_traits/alignment_of.hpp>
 #include <cstddef>
@@ -48,7 +48,7 @@ private:
 
 private:
 
-    void destroy()
+    void destroy() BOOST_SP_NOEXCEPT
     {
         if( initialized_ )
         {
@@ -70,39 +70,39 @@ private:
 
 public:
 
-    sp_ms_deleter() BOOST_NOEXCEPT : initialized_( false )
+    sp_ms_deleter() BOOST_SP_NOEXCEPT : initialized_( false )
     {
     }
 
-    template<class A> explicit sp_ms_deleter( A const & ) BOOST_NOEXCEPT : initialized_( false )
+    template<class A> explicit sp_ms_deleter( A const & ) BOOST_SP_NOEXCEPT : initialized_( false )
     {
     }
 
     // optimization: do not copy storage_
-    sp_ms_deleter( sp_ms_deleter const & ) BOOST_NOEXCEPT : initialized_( false )
+    sp_ms_deleter( sp_ms_deleter const & ) BOOST_SP_NOEXCEPT : initialized_( false )
     {
     }
 
-    ~sp_ms_deleter()
+    ~sp_ms_deleter() BOOST_SP_NOEXCEPT
     {
         destroy();
     }
 
-    void operator()( T * )
+    void operator()( T * ) BOOST_SP_NOEXCEPT
     {
         destroy();
     }
 
-    static void operator_fn( T* ) // operator() can't be static
+    static void operator_fn( T* ) BOOST_SP_NOEXCEPT // operator() can't be static
     {
     }
 
-    void * address() BOOST_NOEXCEPT
+    void * address() BOOST_SP_NOEXCEPT
     {
         return storage_.data_;
     }
 
-    void set_initialized() BOOST_NOEXCEPT
+    void set_initialized() BOOST_SP_NOEXCEPT
     {
         initialized_ = true;
     }
@@ -120,7 +120,7 @@ private:
 
 private:
 
-    void destroy()
+    void destroy() BOOST_SP_NOEXCEPT
     {
         if( initialized_ )
         {
@@ -142,35 +142,35 @@ private:
 
 public:
 
-    sp_as_deleter( A const & a ) BOOST_NOEXCEPT : a_( a ), initialized_( false )
+    sp_as_deleter( A const & a ) BOOST_SP_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( sp_as_deleter const & r ) BOOST_SP_NOEXCEPT : a_( r.a_), initialized_( false )
     {
     }
 
-    ~sp_as_deleter()
+    ~sp_as_deleter() BOOST_SP_NOEXCEPT
     {
         destroy();
     }
 
-    void operator()( T * )
+    void operator()( T * ) BOOST_SP_NOEXCEPT
     {
         destroy();
     }
 
-    static void operator_fn( T* ) // operator() can't be static
+    static void operator_fn( T* ) BOOST_SP_NOEXCEPT // operator() can't be static
     {
     }
 
-    void * address() BOOST_NOEXCEPT
+    void * address() BOOST_SP_NOEXCEPT
     {
         return storage_.data_;
     }
 
-    void set_initialized() BOOST_NOEXCEPT
+    void set_initialized() BOOST_SP_NOEXCEPT
     {
         initialized_ = true;
     }

include/boost/smart_ptr/owner_less.hpp

@@ -11,7 +11,7 @@
 //  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.
+//  See http://www.boost.org/libs/smart_ptr/ for documentation.
 //
 
 namespace boost

include/boost/smart_ptr/scoped_array.hpp

@@ -8,8 +8,7 @@
 //  accompanying file LICENSE_1_0.txt or copy at
 //  http://www.boost.org/LICENSE_1_0.txt)
 //
-//  http://www.boost.org/libs/smart_ptr/scoped_array.htm
-//
+//  See http://www.boost.org/libs/smart_ptr/ for documentation.
 
 #include <boost/config.hpp>
 #include <boost/assert.hpp>
@@ -62,7 +61,7 @@ public:
 #endif
     }
 
-    ~scoped_array() // never throws
+    ~scoped_array() BOOST_SP_NOEXCEPT
     {
 #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
         boost::sp_array_destructor_hook( px );
@@ -70,20 +69,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) BOOST_SP_NOEXCEPT_WITH_ASSERT
     {
         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 BOOST_SP_NOEXCEPT_WITH_ASSERT
     {
         BOOST_ASSERT( px != 0 );
         BOOST_ASSERT( i >= 0 );
         return px[i];
     }
 
-    T * get() const BOOST_NOEXCEPT
+    T * get() const BOOST_SP_NOEXCEPT
     {
         return px;
     }
@@ -91,7 +90,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) BOOST_SP_NOEXCEPT
     {
         T * tmp = b.px;
         b.px = px;
@@ -101,29 +100,29 @@ 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
+template<class T> inline bool operator==( scoped_array<T> const & p, boost::detail::sp_nullptr_t ) BOOST_SP_NOEXCEPT
 {
     return p.get() == 0;
 }
 
-template<class T> inline bool operator==( boost::detail::sp_nullptr_t, scoped_array<T> const & p ) BOOST_NOEXCEPT
+template<class T> inline bool operator==( boost::detail::sp_nullptr_t, scoped_array<T> const & p ) BOOST_SP_NOEXCEPT
 {
     return p.get() == 0;
 }
 
-template<class T> inline bool operator!=( scoped_array<T> const & p, boost::detail::sp_nullptr_t ) BOOST_NOEXCEPT
+template<class T> inline bool operator!=( scoped_array<T> const & p, boost::detail::sp_nullptr_t ) BOOST_SP_NOEXCEPT
 {
     return p.get() != 0;
 }
 
-template<class T> inline bool operator!=( boost::detail::sp_nullptr_t, scoped_array<T> const & p ) BOOST_NOEXCEPT
+template<class T> inline bool operator!=( boost::detail::sp_nullptr_t, scoped_array<T> const & p ) BOOST_SP_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) BOOST_SP_NOEXCEPT
 {
     a.swap(b);
 }

include/boost/smart_ptr/scoped_ptr.hpp

@@ -8,8 +8,7 @@
 //  accompanying file LICENSE_1_0.txt or copy at
 //  http://www.boost.org/LICENSE_1_0.txt)
 //
-//  http://www.boost.org/libs/smart_ptr/scoped_ptr.htm
-//
+//  See http://www.boost.org/libs/smart_ptr/ for documentation.
 
 #include <boost/config.hpp>
 #include <boost/assert.hpp>
@@ -63,7 +62,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 ) BOOST_SP_NOEXCEPT : px( p )
     {
 #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
         boost::sp_scalar_constructor_hook( px );
@@ -72,7 +71,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 ) BOOST_SP_NOEXCEPT : px( p.release() )
     {
 #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
         boost::sp_scalar_constructor_hook( px );
@@ -81,7 +80,7 @@ public:
 
 #endif
 
-    ~scoped_ptr() // never throws
+    ~scoped_ptr() BOOST_SP_NOEXCEPT
     {
 #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
         boost::sp_scalar_destructor_hook( px );
@@ -89,25 +88,25 @@ public:
         boost::checked_delete( px );
     }
 
-    void reset(T * p = 0) // never throws
+    void reset(T * p = 0) BOOST_SP_NOEXCEPT_WITH_ASSERT
     {
         BOOST_ASSERT( p == 0 || p != px ); // catch self-reset errors
         this_type(p).swap(*this);
     }
 
-    T & operator*() const // never throws
+    T & operator*() const BOOST_SP_NOEXCEPT_WITH_ASSERT
     {
         BOOST_ASSERT( px != 0 );
         return *px;
     }
 
-    T * operator->() const // never throws
+    T * operator->() const BOOST_SP_NOEXCEPT_WITH_ASSERT
     {
         BOOST_ASSERT( px != 0 );
         return px;
     }
 
-    T * get() const BOOST_NOEXCEPT
+    T * get() const BOOST_SP_NOEXCEPT
     {
         return px;
     }
@@ -115,7 +114,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) BOOST_SP_NOEXCEPT
     {
         T * tmp = b.px;
         b.px = px;
@@ -125,36 +124,36 @@ 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
+template<class T> inline bool operator==( scoped_ptr<T> const & p, boost::detail::sp_nullptr_t ) BOOST_SP_NOEXCEPT
 {
     return p.get() == 0;
 }
 
-template<class T> inline bool operator==( boost::detail::sp_nullptr_t, scoped_ptr<T> const & p ) BOOST_NOEXCEPT
+template<class T> inline bool operator==( boost::detail::sp_nullptr_t, scoped_ptr<T> const & p ) BOOST_SP_NOEXCEPT
 {
     return p.get() == 0;
 }
 
-template<class T> inline bool operator!=( scoped_ptr<T> const & p, boost::detail::sp_nullptr_t ) BOOST_NOEXCEPT
+template<class T> inline bool operator!=( scoped_ptr<T> const & p, boost::detail::sp_nullptr_t ) BOOST_SP_NOEXCEPT
 {
     return p.get() != 0;
 }
 
-template<class T> inline bool operator!=( boost::detail::sp_nullptr_t, scoped_ptr<T> const & p ) BOOST_NOEXCEPT
+template<class T> inline bool operator!=( boost::detail::sp_nullptr_t, scoped_ptr<T> const & p ) BOOST_SP_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) BOOST_SP_NOEXCEPT
 {
     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) BOOST_SP_NOEXCEPT
 {
     return p.get();
 }

include/boost/smart_ptr/shared_array.hpp

@@ -11,7 +11,7 @@
 //  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.
+//  See http://www.boost.org/libs/smart_ptr/ for documentation.
 //
 
 #include <boost/config.hpp>   // for broken compiler workarounds
@@ -120,7 +120,7 @@ public:
     shared_array( shared_array<Y> const & r )
 
 #endif
-    BOOST_NOEXCEPT : px( r.px ), pn( r.pn ) // never throws
+    BOOST_SP_NOEXCEPT : px( r.px ), pn( r.pn )
     {
         boost::detail::sp_assert_convertible< Y[], T[] >();
     }
@@ -128,7 +128,7 @@ public:
     // aliasing
 
     template< class Y >
-    shared_array( shared_array<Y> const & r, element_type * p ) BOOST_NOEXCEPT : px( p ), pn( r.pn )
+    shared_array( shared_array<Y> const & r, element_type * p ) BOOST_SP_NOEXCEPT : px( p ), pn( r.pn )
     {
     }
 
@@ -143,7 +143,7 @@ public:
 #if !defined(BOOST_MSVC) || (BOOST_MSVC >= 1400)
 
     template<class Y>
-    shared_array & operator=( shared_array<Y> const & r ) BOOST_NOEXCEPT
+    shared_array & operator=( shared_array<Y> const & r ) BOOST_SP_NOEXCEPT
     {
         this_type( r ).swap( *this );
         return *this;
@@ -160,7 +160,7 @@ public:
     }
 
     template<class Y>
-    shared_array & operator=( shared_array<Y> && r ) BOOST_NOEXCEPT
+    shared_array & operator=( shared_array<Y> && r ) BOOST_SP_NOEXCEPT
     {
         this_type( static_cast< shared_array<Y> && >( r ) ).swap( *this );
         return *this;
@@ -168,7 +168,7 @@ public:
 
 #endif
 
-    void reset() BOOST_NOEXCEPT
+    void reset() BOOST_SP_NOEXCEPT
     {
         this_type().swap( *this );
     }
@@ -189,19 +189,19 @@ public:
         this_type( p, d, a ).swap( *this );
     }
 
-    template<class Y> void reset( shared_array<Y> const & r, element_type * p )
+    template<class Y> void reset( shared_array<Y> const & r, element_type * p ) BOOST_SP_NOEXCEPT
     {
         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 BOOST_SP_NOEXCEPT_WITH_ASSERT
     {
         BOOST_ASSERT(px != 0);
         BOOST_ASSERT(i >= 0);
         return px[i];
     }
     
-    T * get() const BOOST_NOEXCEPT
+    T * get() const BOOST_SP_NOEXCEPT
     {
         return px;
     }
@@ -209,23 +209,23 @@ public:
 // implicit conversion to "bool"
 #include <boost/smart_ptr/detail/operator_bool.hpp>
 
-    bool unique() const BOOST_NOEXCEPT
+    bool unique() const BOOST_SP_NOEXCEPT
     {
         return pn.unique();
     }
 
-    long use_count() const BOOST_NOEXCEPT
+    long use_count() const BOOST_SP_NOEXCEPT
     {
         return pn.use_count();
     }
 
-    void swap(shared_array<T> & other) BOOST_NOEXCEPT
+    void swap(shared_array<T> & other) BOOST_SP_NOEXCEPT
     {
         std::swap(px, other.px);
         pn.swap(other.pn);
     }
 
-    void * _internal_get_deleter( boost::detail::sp_typeinfo const & ti ) const
+    void * _internal_get_deleter( boost::detail::sp_typeinfo const & ti ) const BOOST_SP_NOEXCEPT
     {
         return pn.get_deleter( ti );
     }
@@ -239,51 +239,51 @@ private:
 
 };  // 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) BOOST_SP_NOEXCEPT
 {
     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) BOOST_SP_NOEXCEPT
 {
     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
+template<class T> inline bool operator==( shared_array<T> const & p, boost::detail::sp_nullptr_t ) BOOST_SP_NOEXCEPT
 {
     return p.get() == 0;
 }
 
-template<class T> inline bool operator==( boost::detail::sp_nullptr_t, shared_array<T> const & p ) BOOST_NOEXCEPT
+template<class T> inline bool operator==( boost::detail::sp_nullptr_t, shared_array<T> const & p ) BOOST_SP_NOEXCEPT
 {
     return p.get() == 0;
 }
 
-template<class T> inline bool operator!=( shared_array<T> const & p, boost::detail::sp_nullptr_t ) BOOST_NOEXCEPT
+template<class T> inline bool operator!=( shared_array<T> const & p, boost::detail::sp_nullptr_t ) BOOST_SP_NOEXCEPT
 {
     return p.get() != 0;
 }
 
-template<class T> inline bool operator!=( boost::detail::sp_nullptr_t, shared_array<T> const & p ) BOOST_NOEXCEPT
+template<class T> inline bool operator!=( boost::detail::sp_nullptr_t, shared_array<T> const & p ) BOOST_SP_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) BOOST_SP_NOEXCEPT
 {
     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) BOOST_SP_NOEXCEPT
 {
     a.swap(b);
 }
 
-template< class D, class T > D * get_deleter( shared_array<T> const & p )
+template< class D, class T > D * get_deleter( shared_array<T> const & p ) BOOST_SP_NOEXCEPT
 {
     return static_cast< D * >( p._internal_get_deleter( BOOST_SP_TYPEID(D) ) );
 }

include/boost/smart_ptr/shared_ptr.hpp

@@ -11,7 +11,7 @@
 //  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.
+//  See http://www.boost.org/libs/smart_ptr/ for documentation.
 //
 
 #include <boost/config.hpp>   // for broken compiler workarounds
@@ -262,7 +262,7 @@ template< class T, class R > struct sp_enable_if_auto_ptr< std::auto_ptr< T >, R
 
 // sp_assert_convertible
 
-template< class Y, class T > inline void sp_assert_convertible()
+template< class Y, class T > inline void sp_assert_convertible() BOOST_SP_NOEXCEPT
 {
 #if !defined( BOOST_SP_NO_SP_CONVERTIBLE )
 
@@ -323,6 +323,10 @@ template< class T, std::size_t N, class Y > inline void sp_deleter_construct( bo
 
 #endif // !defined( BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION )
 
+struct sp_internal_constructor_tag
+{
+};
+
 } // namespace detail
 
 
@@ -345,13 +349,25 @@ public:
 
     typedef typename boost::detail::sp_element< T >::type element_type;
 
-    shared_ptr() BOOST_SP_NOEXCEPT : px( 0 ), pn() // never throws in 1.30+
+    BOOST_CONSTEXPR shared_ptr() BOOST_SP_NOEXCEPT : px( 0 ), pn()
     {
     }
 
 #if !defined( BOOST_NO_CXX11_NULLPTR )
 
-    shared_ptr( boost::detail::sp_nullptr_t ) BOOST_SP_NOEXCEPT : px( 0 ), pn() // never throws
+    BOOST_CONSTEXPR shared_ptr( boost::detail::sp_nullptr_t ) BOOST_SP_NOEXCEPT : px( 0 ), pn()
+    {
+    }
+
+#endif
+
+    BOOST_CONSTEXPR shared_ptr( boost::detail::sp_internal_constructor_tag, element_type * px_, boost::detail::shared_count const & pn_ ) BOOST_SP_NOEXCEPT : px( px_ ), pn( pn_ )
+    {
+    }
+
+#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
+
+    BOOST_CONSTEXPR shared_ptr( boost::detail::sp_internal_constructor_tag, element_type * px_, boost::detail::shared_count && pn_ ) BOOST_SP_NOEXCEPT : px( px_ ), pn( std::move( pn_ ) )
     {
     }
 
@@ -420,7 +436,7 @@ public:
 
     template<class Y>
     shared_ptr( weak_ptr<Y> const & r, boost::detail::sp_nothrow_tag )
-    BOOST_NOEXCEPT : px( 0 ), pn( r.pn, boost::detail::sp_nothrow_tag() )
+    BOOST_SP_NOEXCEPT : px( 0 ), pn( r.pn, boost::detail::sp_nothrow_tag() )
     {
         if( !pn.empty() )
         {
@@ -438,14 +454,14 @@ public:
     shared_ptr( shared_ptr<Y> const & r )
 
 #endif
-    BOOST_NOEXCEPT : px( r.px ), pn( r.pn )
+    BOOST_SP_NOEXCEPT : px( r.px ), pn( r.pn )
     {
         boost::detail::sp_assert_convertible< Y, T >();
     }
 
     // aliasing
     template< class Y >
-    shared_ptr( shared_ptr<Y> const & r, element_type * p ) BOOST_NOEXCEPT : px( p ), pn( r.pn )
+    shared_ptr( shared_ptr<Y> const & r, element_type * p ) BOOST_SP_NOEXCEPT : px( p ), pn( r.pn )
     {
     }
 
@@ -502,9 +518,12 @@ public:
         boost::detail::sp_assert_convertible< Y, T >();
 
         typename std::unique_ptr< Y, D >::pointer tmp = r.get();
-        pn = boost::detail::shared_count( r );
 
-        boost::detail::sp_deleter_construct( this, tmp );
+        if( tmp != 0 )
+        {
+            pn = boost::detail::shared_count( r );
+            boost::detail::sp_deleter_construct( this, tmp );
+        }
     }
 
 #endif
@@ -515,9 +534,12 @@ public:
         boost::detail::sp_assert_convertible< Y, T >();
 
         typename boost::movelib::unique_ptr< Y, D >::pointer tmp = r.get();
-        pn = boost::detail::shared_count( r );
 
-        boost::detail::sp_deleter_construct( this, tmp );
+        if( tmp != 0 )
+        {
+            pn = boost::detail::shared_count( r );
+            boost::detail::sp_deleter_construct( this, tmp );
+        }
     }
 
     // assignment
@@ -531,7 +553,7 @@ public:
 #if !defined(BOOST_MSVC) || (BOOST_MSVC >= 1400)
 
     template<class Y>
-    shared_ptr & operator=(shared_ptr<Y> const & r) BOOST_NOEXCEPT
+    shared_ptr & operator=(shared_ptr<Y> const & r) BOOST_SP_NOEXCEPT
     {
         this_type(r).swap(*this);
         return *this;
@@ -592,10 +614,13 @@ public:
 
         shared_ptr tmp;
 
-        tmp.px = p;
-        tmp.pn = boost::detail::shared_count( r );
+        if( p != 0 )
+        {
+            tmp.px = p;
+            tmp.pn = boost::detail::shared_count( r );
 
-        boost::detail::sp_deleter_construct( &tmp, p );
+            boost::detail::sp_deleter_construct( &tmp, p );
+        }
 
         tmp.swap( *this );
 
@@ -622,7 +647,7 @@ public:
     shared_ptr( shared_ptr<Y> && r )
 
 #endif
-    BOOST_NOEXCEPT : px( r.px ), pn()
+    BOOST_SP_NOEXCEPT : px( r.px ), pn()
     {
         boost::detail::sp_assert_convertible< Y, T >();
 
@@ -637,7 +662,7 @@ public:
     }
 
     template<class Y>
-    shared_ptr & operator=( shared_ptr<Y> && r ) BOOST_NOEXCEPT
+    shared_ptr & operator=( shared_ptr<Y> && r ) BOOST_SP_NOEXCEPT
     {
         this_type( static_cast< shared_ptr<Y> && >( r ) ).swap( *this );
         return *this;
@@ -645,7 +670,7 @@ public:
 
     // aliasing move
     template<class Y>
-    shared_ptr( shared_ptr<Y> && r, element_type * p ) BOOST_NOEXCEPT : px( p ), pn()
+    shared_ptr( shared_ptr<Y> && r, element_type * p ) BOOST_SP_NOEXCEPT : px( p ), pn()
     {
         pn.swap( r.pn );
         r.px = 0;
@@ -655,7 +680,7 @@ public:
 
 #if !defined( BOOST_NO_CXX11_NULLPTR )
 
-    shared_ptr & operator=( boost::detail::sp_nullptr_t ) BOOST_NOEXCEPT // never throws
+    shared_ptr & operator=( boost::detail::sp_nullptr_t ) BOOST_SP_NOEXCEPT
     {
         this_type().swap(*this);
         return *this;
@@ -663,7 +688,7 @@ public:
 
 #endif
 
-    void reset() BOOST_NOEXCEPT // never throws in 1.30+
+    void reset() BOOST_SP_NOEXCEPT
     {
         this_type().swap(*this);
     }
@@ -684,36 +709,33 @@ public:
         this_type( p, d, a ).swap( *this );
     }
 
-    template<class Y> void reset( shared_ptr<Y> const & r, element_type * p )
+    template<class Y> void reset( shared_ptr<Y> const & r, element_type * p ) BOOST_SP_NOEXCEPT
     {
         this_type( r, p ).swap( *this );
     }
 
 #if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
 
-    template<class Y> void reset( shared_ptr<Y> && r, element_type * p )
+    template<class Y> void reset( shared_ptr<Y> && r, element_type * p ) BOOST_SP_NOEXCEPT
     {
         this_type( static_cast< shared_ptr<Y> && >( r ), p ).swap( *this );
     }
 
 #endif
 
-    // never throws (but has a BOOST_ASSERT in it, so not marked with BOOST_NOEXCEPT)
-    typename boost::detail::sp_dereference< T >::type operator* () const
+    typename boost::detail::sp_dereference< T >::type operator* () const BOOST_SP_NOEXCEPT_WITH_ASSERT
     {
         BOOST_ASSERT( px != 0 );
         return *px;
     }
     
-    // never throws (but has a BOOST_ASSERT in it, so not marked with BOOST_NOEXCEPT)
-    typename boost::detail::sp_member_access< T >::type operator-> () const 
+    typename boost::detail::sp_member_access< T >::type operator-> () const BOOST_SP_NOEXCEPT_WITH_ASSERT
     {
         BOOST_ASSERT( px != 0 );
         return px;
     }
     
-    // never throws (but has a BOOST_ASSERT in it, so not marked with BOOST_NOEXCEPT)
-    typename boost::detail::sp_array_access< T >::type operator[] ( std::ptrdiff_t i ) const
+    typename boost::detail::sp_array_access< T >::type operator[] ( std::ptrdiff_t i ) const BOOST_SP_NOEXCEPT_WITH_ASSERT
     {
         BOOST_ASSERT( px != 0 );
         BOOST_ASSERT( i >= 0 && ( i < boost::detail::sp_extent< T >::value || boost::detail::sp_extent< T >::value == 0 ) );
@@ -721,7 +743,7 @@ public:
         return static_cast< typename boost::detail::sp_array_access< T >::type >( px[ i ] );
     }
 
-    element_type * get() const BOOST_NOEXCEPT
+    element_type * get() const BOOST_SP_NOEXCEPT
     {
         return px;
     }
@@ -729,47 +751,57 @@ public:
 // implicit conversion to "bool"
 #include <boost/smart_ptr/detail/operator_bool.hpp>
 
-    bool unique() const BOOST_NOEXCEPT
+    bool unique() const BOOST_SP_NOEXCEPT
     {
         return pn.unique();
     }
 
-    long use_count() const BOOST_NOEXCEPT
+    long use_count() const BOOST_SP_NOEXCEPT
     {
         return pn.use_count();
     }
 
-    void swap( shared_ptr & other ) BOOST_NOEXCEPT
+    void swap( shared_ptr & other ) BOOST_SP_NOEXCEPT
     {
         std::swap(px, other.px);
         pn.swap(other.pn);
     }
 
-    template<class Y> bool owner_before( shared_ptr<Y> const & rhs ) const BOOST_NOEXCEPT
+    template<class Y> bool owner_before( shared_ptr<Y> const & rhs ) const BOOST_SP_NOEXCEPT
     {
         return pn < rhs.pn;
     }
 
-    template<class Y> bool owner_before( weak_ptr<Y> const & rhs ) const BOOST_NOEXCEPT
+    template<class Y> bool owner_before( weak_ptr<Y> const & rhs ) const BOOST_SP_NOEXCEPT
     {
         return pn < rhs.pn;
     }
 
-    void * _internal_get_deleter( boost::detail::sp_typeinfo const & ti ) const BOOST_NOEXCEPT
+    void * _internal_get_deleter( boost::detail::sp_typeinfo const & ti ) const BOOST_SP_NOEXCEPT
     {
         return pn.get_deleter( ti );
     }
 
-    void * _internal_get_untyped_deleter() const BOOST_NOEXCEPT
+    void * _internal_get_local_deleter( boost::detail::sp_typeinfo const & ti ) const BOOST_SP_NOEXCEPT
+    {
+        return pn.get_local_deleter( ti );
+    }
+
+    void * _internal_get_untyped_deleter() const BOOST_SP_NOEXCEPT
     {
         return pn.get_untyped_deleter();
     }
 
-    bool _internal_equiv( shared_ptr const & r ) const BOOST_NOEXCEPT
+    bool _internal_equiv( shared_ptr const & r ) const BOOST_SP_NOEXCEPT
     {
         return px == r.px && pn == r.pn;
     }
 
+    boost::detail::shared_count _internal_count() const BOOST_NOEXCEPT
+    {
+        return pn;
+    }
+
 // Tasteless as this may seem, making all members public allows member templates
 // to work in the absence of member template friends. (Matthew Langston)
 
@@ -788,12 +820,12 @@ private:
 
 };  // shared_ptr
 
-template<class T, class U> inline bool operator==(shared_ptr<T> const & a, shared_ptr<U> const & b) BOOST_NOEXCEPT
+template<class T, class U> inline bool operator==(shared_ptr<T> const & a, shared_ptr<U> const & b) BOOST_SP_NOEXCEPT
 {
     return a.get() == b.get();
 }
 
-template<class T, class U> inline bool operator!=(shared_ptr<T> const & a, shared_ptr<U> const & b) BOOST_NOEXCEPT
+template<class T, class U> inline bool operator!=(shared_ptr<T> const & a, shared_ptr<U> const & b) BOOST_SP_NOEXCEPT
 {
     return a.get() != b.get();
 }
@@ -802,7 +834,7 @@ template<class T, class U> inline bool operator!=(shared_ptr<T> const & a, share
 
 // Resolve the ambiguity between our op!= and the one in rel_ops
 
-template<class T> inline bool operator!=(shared_ptr<T> const & a, shared_ptr<T> const & b) BOOST_NOEXCEPT
+template<class T> inline bool operator!=(shared_ptr<T> const & a, shared_ptr<T> const & b) BOOST_SP_NOEXCEPT
 {
     return a.get() != b.get();
 }
@@ -811,39 +843,39 @@ template<class T> inline bool operator!=(shared_ptr<T> const & a, shared_ptr<T>
 
 #if !defined( BOOST_NO_CXX11_NULLPTR )
 
-template<class T> inline bool operator==( shared_ptr<T> const & p, boost::detail::sp_nullptr_t ) BOOST_NOEXCEPT
+template<class T> inline bool operator==( shared_ptr<T> const & p, boost::detail::sp_nullptr_t ) BOOST_SP_NOEXCEPT
 {
     return p.get() == 0;
 }
 
-template<class T> inline bool operator==( boost::detail::sp_nullptr_t, shared_ptr<T> const & p ) BOOST_NOEXCEPT
+template<class T> inline bool operator==( boost::detail::sp_nullptr_t, shared_ptr<T> const & p ) BOOST_SP_NOEXCEPT
 {
     return p.get() == 0;
 }
 
-template<class T> inline bool operator!=( shared_ptr<T> const & p, boost::detail::sp_nullptr_t ) BOOST_NOEXCEPT
+template<class T> inline bool operator!=( shared_ptr<T> const & p, boost::detail::sp_nullptr_t ) BOOST_SP_NOEXCEPT
 {
     return p.get() != 0;
 }
 
-template<class T> inline bool operator!=( boost::detail::sp_nullptr_t, shared_ptr<T> const & p ) BOOST_NOEXCEPT
+template<class T> inline bool operator!=( boost::detail::sp_nullptr_t, shared_ptr<T> const & p ) BOOST_SP_NOEXCEPT
 {
     return p.get() != 0;
 }
 
 #endif
 
-template<class T, class U> inline bool operator<(shared_ptr<T> const & a, shared_ptr<U> const & b) BOOST_NOEXCEPT
+template<class T, class U> inline bool operator<(shared_ptr<T> const & a, shared_ptr<U> const & b) BOOST_SP_NOEXCEPT
 {
     return a.owner_before( b );
 }
 
-template<class T> inline void swap(shared_ptr<T> & a, shared_ptr<T> & b) BOOST_NOEXCEPT
+template<class T> inline void swap(shared_ptr<T> & a, shared_ptr<T> & b) BOOST_SP_NOEXCEPT
 {
     a.swap(b);
 }
 
-template<class T, class U> shared_ptr<T> static_pointer_cast( shared_ptr<U> const & r ) BOOST_NOEXCEPT
+template<class T, class U> shared_ptr<T> static_pointer_cast( shared_ptr<U> const & r ) BOOST_SP_NOEXCEPT
 {
     (void) static_cast< T* >( static_cast< U* >( 0 ) );
 
@@ -853,7 +885,7 @@ template<class T, class U> shared_ptr<T> static_pointer_cast( shared_ptr<U> cons
     return shared_ptr<T>( r, p );
 }
 
-template<class T, class U> shared_ptr<T> const_pointer_cast( shared_ptr<U> const & r ) BOOST_NOEXCEPT
+template<class T, class U> shared_ptr<T> const_pointer_cast( shared_ptr<U> const & r ) BOOST_SP_NOEXCEPT
 {
     (void) const_cast< T* >( static_cast< U* >( 0 ) );
 
@@ -863,7 +895,7 @@ template<class T, class U> shared_ptr<T> const_pointer_cast( shared_ptr<U> const
     return shared_ptr<T>( r, p );
 }
 
-template<class T, class U> shared_ptr<T> dynamic_pointer_cast( shared_ptr<U> const & r ) BOOST_NOEXCEPT
+template<class T, class U> shared_ptr<T> dynamic_pointer_cast( shared_ptr<U> const & r ) BOOST_SP_NOEXCEPT
 {
     (void) dynamic_cast< T* >( static_cast< U* >( 0 ) );
 
@@ -873,7 +905,7 @@ template<class T, class U> shared_ptr<T> dynamic_pointer_cast( shared_ptr<U> con
     return p? shared_ptr<T>( r, p ): shared_ptr<T>();
 }
 
-template<class T, class U> shared_ptr<T> reinterpret_pointer_cast( shared_ptr<U> const & r ) BOOST_NOEXCEPT
+template<class T, class U> shared_ptr<T> reinterpret_pointer_cast( shared_ptr<U> const & r ) BOOST_SP_NOEXCEPT
 {
     (void) reinterpret_cast< T* >( static_cast< U* >( 0 ) );
 
@@ -885,7 +917,7 @@ template<class T, class U> shared_ptr<T> reinterpret_pointer_cast( shared_ptr<U>
 
 #if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
 
-template<class T, class U> shared_ptr<T> static_pointer_cast( shared_ptr<U> && r ) BOOST_NOEXCEPT
+template<class T, class U> shared_ptr<T> static_pointer_cast( shared_ptr<U> && r ) BOOST_SP_NOEXCEPT
 {
     (void) static_cast< T* >( static_cast< U* >( 0 ) );
 
@@ -895,7 +927,7 @@ template<class T, class U> shared_ptr<T> static_pointer_cast( shared_ptr<U> && r
     return shared_ptr<T>( std::move(r), p );
 }
 
-template<class T, class U> shared_ptr<T> const_pointer_cast( shared_ptr<U> && r ) BOOST_NOEXCEPT
+template<class T, class U> shared_ptr<T> const_pointer_cast( shared_ptr<U> && r ) BOOST_SP_NOEXCEPT
 {
     (void) const_cast< T* >( static_cast< U* >( 0 ) );
 
@@ -905,7 +937,7 @@ template<class T, class U> shared_ptr<T> const_pointer_cast( shared_ptr<U> && r
     return shared_ptr<T>( std::move(r), p );
 }
 
-template<class T, class U> shared_ptr<T> dynamic_pointer_cast( shared_ptr<U> && r ) BOOST_NOEXCEPT
+template<class T, class U> shared_ptr<T> dynamic_pointer_cast( shared_ptr<U> && r ) BOOST_SP_NOEXCEPT
 {
     (void) dynamic_cast< T* >( static_cast< U* >( 0 ) );
 
@@ -915,7 +947,7 @@ template<class T, class U> shared_ptr<T> dynamic_pointer_cast( shared_ptr<U> &&
     return p? shared_ptr<T>( std::move(r), p ): shared_ptr<T>();
 }
 
-template<class T, class U> shared_ptr<T> reinterpret_pointer_cast( shared_ptr<U> && r ) BOOST_NOEXCEPT
+template<class T, class U> shared_ptr<T> reinterpret_pointer_cast( shared_ptr<U> && r ) BOOST_SP_NOEXCEPT
 {
     (void) reinterpret_cast< T* >( static_cast< U* >( 0 ) );
 
@@ -929,7 +961,7 @@ template<class T, class U> shared_ptr<T> reinterpret_pointer_cast( shared_ptr<U>
 
 // get_pointer() enables boost::mem_fn to recognize shared_ptr
 
-template<class T> inline typename shared_ptr<T>::element_type * get_pointer(shared_ptr<T> const & p) BOOST_NOEXCEPT
+template<class T> inline typename shared_ptr<T>::element_type * get_pointer(shared_ptr<T> const & p) BOOST_SP_NOEXCEPT
 {
     return p.get();
 }
@@ -974,27 +1006,13 @@ template<class E, class T, class Y> std::basic_ostream<E, T> & operator<< (std::
 namespace detail
 {
 
-#if ( defined(__GNUC__) && BOOST_WORKAROUND(__GNUC__, < 3) ) || \
-    ( defined(__EDG_VERSION__) && BOOST_WORKAROUND(__EDG_VERSION__, <= 238) ) || \
-    ( defined(__HP_aCC) && BOOST_WORKAROUND(__HP_aCC, <= 33500) )
-
-// g++ 2.9x doesn't allow static_cast<X const *>(void *)
-// apparently EDG 2.38 and HP aCC A.03.35 also don't accept it
-
-template<class D, class T> D * basic_get_deleter(shared_ptr<T> const & p)
-{
-    void const * q = p._internal_get_deleter(BOOST_SP_TYPEID(D));
-    return const_cast<D *>(static_cast<D const *>(q));
-}
-
-#else
-
-template<class D, class T> D * basic_get_deleter( shared_ptr<T> const & p ) BOOST_NOEXCEPT
+template<class D, class T> D * basic_get_deleter( shared_ptr<T> const & p ) BOOST_SP_NOEXCEPT
 {
     return static_cast<D *>( p._internal_get_deleter(BOOST_SP_TYPEID(D)) );
 }
 
-#endif
+template<class D, class T> D * basic_get_local_deleter( D *, shared_ptr<T> const & p ) BOOST_SP_NOEXCEPT;
+template<class D, class T> D const * basic_get_local_deleter( D const *, shared_ptr<T> const & p ) BOOST_SP_NOEXCEPT;
 
 class esft2_deleter_wrapper
 {
@@ -1008,17 +1026,17 @@ public:
     {
     }
 
-    template< class T > void set_deleter( shared_ptr<T> const & deleter )
+    template< class T > void set_deleter( shared_ptr<T> const & deleter ) BOOST_SP_NOEXCEPT
     {
         deleter_ = deleter;
     }
 
-    template<typename D> D* get_deleter() const BOOST_NOEXCEPT
+    template<typename D> D* get_deleter() const BOOST_SP_NOEXCEPT
     {
         return boost::detail::basic_get_deleter<D>( deleter_ );
     }
 
-    template< class T> void operator()( T* )
+    template< class T> void operator()( T* ) BOOST_SP_NOEXCEPT_WITH_ASSERT
     {
         BOOST_ASSERT( deleter_.use_count() <= 1 );
         deleter_.reset();
@@ -1027,53 +1045,58 @@ public:
 
 } // namespace detail
 
-template<class D, class T> D * get_deleter( shared_ptr<T> const & p ) BOOST_NOEXCEPT
+template<class D, class T> D * get_deleter( shared_ptr<T> const & p ) BOOST_SP_NOEXCEPT
 {
-    D *del = boost::detail::basic_get_deleter<D>(p);
+    D * d = boost::detail::basic_get_deleter<D>( p );
 
-    if(del == 0)
+    if( d == 0 )
+    {
+        d = boost::detail::basic_get_local_deleter( d, p );
+    }
+
+    if( d == 0 )
     {
         boost::detail::esft2_deleter_wrapper *del_wrapper = boost::detail::basic_get_deleter<boost::detail::esft2_deleter_wrapper>(p);
 // The following get_deleter method call is fully qualified because
 // older versions of gcc (2.95, 3.2.3) fail to compile it when written del_wrapper->get_deleter<D>()
-        if(del_wrapper) del = del_wrapper->::boost::detail::esft2_deleter_wrapper::get_deleter<D>();
+        if(del_wrapper) d = del_wrapper->::boost::detail::esft2_deleter_wrapper::get_deleter<D>();
     }
 
-    return del;
+    return d;
 }
 
 // atomic access
 
 #if !defined(BOOST_SP_NO_ATOMIC_ACCESS)
 
-template<class T> inline bool atomic_is_lock_free( shared_ptr<T> const * /*p*/ ) BOOST_NOEXCEPT
+template<class T> inline bool atomic_is_lock_free( shared_ptr<T> const * /*p*/ ) BOOST_SP_NOEXCEPT
 {
     return false;
 }
 
-template<class T> shared_ptr<T> atomic_load( shared_ptr<T> const * p )
+template<class T> shared_ptr<T> atomic_load( shared_ptr<T> const * p ) BOOST_SP_NOEXCEPT
 {
     boost::detail::spinlock_pool<2>::scoped_lock lock( p );
     return *p;
 }
 
-template<class T> inline shared_ptr<T> atomic_load_explicit( shared_ptr<T> const * p, /*memory_order mo*/ int )
+template<class T> inline shared_ptr<T> atomic_load_explicit( shared_ptr<T> const * p, /*memory_order mo*/ int ) BOOST_SP_NOEXCEPT
 {
     return atomic_load( p );
 }
 
-template<class T> void atomic_store( shared_ptr<T> * p, shared_ptr<T> r )
+template<class T> void atomic_store( shared_ptr<T> * p, shared_ptr<T> r ) BOOST_SP_NOEXCEPT
 {
     boost::detail::spinlock_pool<2>::scoped_lock lock( p );
     p->swap( r );
 }
 
-template<class T> inline void atomic_store_explicit( shared_ptr<T> * p, shared_ptr<T> r, /*memory_order mo*/ int )
+template<class T> inline void atomic_store_explicit( shared_ptr<T> * p, shared_ptr<T> r, /*memory_order mo*/ int ) BOOST_SP_NOEXCEPT
 {
     atomic_store( p, r ); // std::move( r )
 }
 
-template<class T> shared_ptr<T> atomic_exchange( shared_ptr<T> * p, shared_ptr<T> r )
+template<class T> shared_ptr<T> atomic_exchange( shared_ptr<T> * p, shared_ptr<T> r ) BOOST_SP_NOEXCEPT
 {
     boost::detail::spinlock & sp = boost::detail::spinlock_pool<2>::spinlock_for( p );
 
@@ -1084,12 +1107,12 @@ template<class T> shared_ptr<T> atomic_exchange( shared_ptr<T> * p, shared_ptr<T
     return r; // return std::move( r )
 }
 
-template<class T> shared_ptr<T> atomic_exchange_explicit( shared_ptr<T> * p, shared_ptr<T> r, /*memory_order mo*/ int )
+template<class T> shared_ptr<T> inline atomic_exchange_explicit( shared_ptr<T> * p, shared_ptr<T> r, /*memory_order mo*/ int ) BOOST_SP_NOEXCEPT
 {
     return atomic_exchange( p, r ); // std::move( r )
 }
 
-template<class T> bool atomic_compare_exchange( shared_ptr<T> * p, shared_ptr<T> * v, shared_ptr<T> w )
+template<class T> bool atomic_compare_exchange( shared_ptr<T> * p, shared_ptr<T> * v, shared_ptr<T> w ) BOOST_SP_NOEXCEPT
 {
     boost::detail::spinlock & sp = boost::detail::spinlock_pool<2>::spinlock_for( p );
 
@@ -1114,7 +1137,7 @@ template<class T> bool atomic_compare_exchange( shared_ptr<T> * p, shared_ptr<T>
     }
 }
 
-template<class T> inline bool atomic_compare_exchange_explicit( shared_ptr<T> * p, shared_ptr<T> * v, shared_ptr<T> w, /*memory_order success*/ int, /*memory_order failure*/ int )
+template<class T> inline bool atomic_compare_exchange_explicit( shared_ptr<T> * p, shared_ptr<T> * v, shared_ptr<T> w, /*memory_order success*/ int, /*memory_order failure*/ int ) BOOST_SP_NOEXCEPT
 {
     return atomic_compare_exchange( p, v, w ); // std::move( w )
 }
@@ -1125,13 +1148,35 @@ template<class T> inline bool atomic_compare_exchange_explicit( shared_ptr<T> *
 
 template< class T > struct hash;
 
-template< class T > std::size_t hash_value( boost::shared_ptr<T> const & p ) BOOST_NOEXCEPT
+template< class T > std::size_t hash_value( boost::shared_ptr<T> const & p ) BOOST_SP_NOEXCEPT
 {
     return boost::hash< typename boost::shared_ptr<T>::element_type* >()( p.get() );
 }
 
 } // namespace boost
 
+#include <boost/smart_ptr/detail/local_sp_deleter.hpp>
+
+namespace boost
+{
+
+namespace detail
+{
+
+template<class D, class T> D * basic_get_local_deleter( D *, shared_ptr<T> const & p ) BOOST_SP_NOEXCEPT
+{
+    return static_cast<D *>( p._internal_get_local_deleter( BOOST_SP_TYPEID(local_sp_deleter<D>) ) );
+}
+
+template<class D, class T> D const * basic_get_local_deleter( D const *, shared_ptr<T> const & p ) BOOST_SP_NOEXCEPT
+{
+    return static_cast<D *>( p._internal_get_local_deleter( BOOST_SP_TYPEID(local_sp_deleter<D>) ) );
+}
+
+} // namespace detail
+
+} // namespace boost
+
 #if defined( BOOST_SP_DISABLE_DEPRECATED )
 #pragma GCC diagnostic pop
 #endif

include/boost/smart_ptr/weak_ptr.hpp

@@ -6,11 +6,11 @@
 //
 //  Copyright (c) 2001, 2002, 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)
+//  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/weak_ptr.htm for documentation.
+//  See http://www.boost.org/libs/smart_ptr/ for documentation.
 //
 
 #include <memory> // boost.TR1 include order fix
@@ -32,7 +32,7 @@ public:
 
     typedef typename boost::detail::sp_element< T >::type element_type;
 
-    weak_ptr() BOOST_SP_NOEXCEPT : px(0), pn() // never throws in 1.30+
+    BOOST_CONSTEXPR weak_ptr() BOOST_SP_NOEXCEPT : px(0), pn()
     {
     }
 
@@ -59,7 +59,7 @@ public:
 //  The "obvious" converting constructor implementation:
 //
 //  template<class Y>
-//  weak_ptr(weak_ptr<Y> const & r): px(r.px), pn(r.pn) // never throws
+//  weak_ptr(weak_ptr<Y> const & r): px(r.px), pn(r.pn)
 //  {
 //  }
 //
@@ -82,7 +82,7 @@ public:
     weak_ptr( weak_ptr<Y> const & r )
 
 #endif
-    BOOST_NOEXCEPT : px(r.lock().get()), pn(r.pn)
+    BOOST_SP_NOEXCEPT : px(r.lock().get()), pn(r.pn)
     {
         boost::detail::sp_assert_convertible< Y, T >();
     }
@@ -99,7 +99,7 @@ public:
     weak_ptr( weak_ptr<Y> && r )
 
 #endif
-    BOOST_NOEXCEPT : px( r.lock().get() ), pn( static_cast< boost::detail::weak_count && >( r.pn ) )
+    BOOST_SP_NOEXCEPT : px( r.lock().get() ), pn( static_cast< boost::detail::weak_count && >( r.pn ) )
     {
         boost::detail::sp_assert_convertible< Y, T >();
         r.px = 0;
@@ -132,7 +132,7 @@ public:
     weak_ptr( shared_ptr<Y> const & r )
 
 #endif
-    BOOST_NOEXCEPT : px( r.px ), pn( r.pn )
+    BOOST_SP_NOEXCEPT : px( r.px ), pn( r.pn )
     {
         boost::detail::sp_assert_convertible< Y, T >();
     }
@@ -140,7 +140,7 @@ public:
 #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 ) BOOST_SP_NOEXCEPT
     {
         boost::detail::sp_assert_convertible< Y, T >();
 
@@ -153,7 +153,7 @@ public:
 #if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
 
     template<class Y>
-    weak_ptr & operator=( weak_ptr<Y> && r ) BOOST_NOEXCEPT
+    weak_ptr & operator=( weak_ptr<Y> && r ) BOOST_SP_NOEXCEPT
     {
         this_type( static_cast< weak_ptr<Y> && >( r ) ).swap( *this );
         return *this;
@@ -162,7 +162,7 @@ public:
 #endif
 
     template<class Y>
-    weak_ptr & operator=( shared_ptr<Y> const & r ) BOOST_NOEXCEPT
+    weak_ptr & operator=( shared_ptr<Y> const & r ) BOOST_SP_NOEXCEPT
     {
         boost::detail::sp_assert_convertible< Y, T >();
 
@@ -174,50 +174,50 @@ public:
 
 #endif
 
-    shared_ptr<T> lock() const BOOST_NOEXCEPT
+    shared_ptr<T> lock() const BOOST_SP_NOEXCEPT
     {
         return shared_ptr<T>( *this, boost::detail::sp_nothrow_tag() );
     }
 
-    long use_count() const BOOST_NOEXCEPT
+    long use_count() const BOOST_SP_NOEXCEPT
     {
         return pn.use_count();
     }
 
-    bool expired() const BOOST_NOEXCEPT
+    bool expired() const BOOST_SP_NOEXCEPT
     {
         return pn.use_count() == 0;
     }
 
-    bool _empty() const // extension, not in std::weak_ptr
+    bool _empty() const BOOST_SP_NOEXCEPT // extension, not in std::weak_ptr
     {
         return pn.empty();
     }
 
-    void reset() BOOST_NOEXCEPT // never throws in 1.30+
+    void reset() BOOST_SP_NOEXCEPT
     {
         this_type().swap(*this);
     }
 
-    void swap(this_type & other) BOOST_NOEXCEPT
+    void swap(this_type & other) BOOST_SP_NOEXCEPT
     {
         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_aliasing_assign(weak_ptr<Y> const & r, element_type * px2) BOOST_SP_NOEXCEPT
     {
         px = px2;
         pn = r.pn;
     }
 
-    template<class Y> bool owner_before( weak_ptr<Y> const & rhs ) const BOOST_NOEXCEPT
+    template<class Y> bool owner_before( weak_ptr<Y> const & rhs ) const BOOST_SP_NOEXCEPT
     {
         return pn < rhs.pn;
     }
 
-    template<class Y> bool owner_before( shared_ptr<Y> const & rhs ) const BOOST_NOEXCEPT
+    template<class Y> bool owner_before( shared_ptr<Y> const & rhs ) const BOOST_SP_NOEXCEPT
     {
         return pn < rhs.pn;
     }
@@ -239,12 +239,12 @@ private:
 
 };  // 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) BOOST_SP_NOEXCEPT
 {
     return a.owner_before( 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) BOOST_SP_NOEXCEPT
 {
     a.swap(b);
 }

include/boost/weak_ptr.hpp

@@ -10,7 +10,7 @@
 //  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/weak_ptr.htm for documentation.
+//  See http://www.boost.org/libs/smart_ptr/ for documentation.
 //
 
 #include <boost/smart_ptr/weak_ptr.hpp>

index.html

@@ -1,13 +1,13 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<!DOCTYPE html>
 <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">
+<meta http-equiv="refresh" content="0; URL=doc/html/smart_ptr.html">
 </head>
-<body text="#000000" bgcolor="#ffffff" link="#0000ff" vlink="#0000ff">
+<body>
+<p>
 Automatic redirection failed, please go to
-<a href="smart_ptr.htm">smart_ptr.htm</a>.
+<a href="doc/html/smart_ptr.html">doc/html/smart_ptr.html</a>.
+</p>
 </body>
 </html>
 <!--

intrusive_ptr.html

@@ -1,320 +0,0 @@
-<!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>
-        <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>
-        </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 
-            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 
-            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>
-            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>
-        <h2><a name="Synopsis">Synopsis</a></h2>
-        <pre>namespace boost {
-
-  template&lt;class T&gt; class intrusive_ptr {
-
-    public:
-
-      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>(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>();
-
-      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
-
-      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
-  };
-
-  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
-
-  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
-
-  template&lt;class T&gt;
-    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
-
-  template&lt;class T&gt;
-    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
-
-  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
-
-  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, 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
-
-  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
-
-  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
-
-  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);
-
-}</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>
-        </blockquote>
-        <h3><a name="constructors">constructors</a></h3>
-        <pre>intrusive_ptr(); // never throws</pre>
-        <blockquote>
-            <p><b>Postconditions:</b> <code>get() == 0</code>.</p>
-            <p><b>Throws:</b> nothing.</p>
-        </blockquote>
-        <pre>intrusive_ptr(T * p, bool add_ref = true);</pre>
-        <blockquote>
-            <p><b>Effects:</b> <code>if(p != 0 &amp;&amp; add_ref) intrusive_ptr_add_ref(p);</code>.</p>
-            <p><b>Postconditions:</b> <code>get() == p</code>.</p>
-        </blockquote>
-        <pre>intrusive_ptr(intrusive_ptr const &amp; r);
-template&lt;class Y&gt; intrusive_ptr(intrusive_ptr&lt;Y&gt; const &amp; r);</pre>
-        <blockquote>
-            <p><b>Effects:</b> <code>if(r.get() != 0) intrusive_ptr_add_ref(r.get());</code>.</p>
-            <p><b>Postconditions:</b> <code>get() == r.get()</code>.</p>
-        </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>
-        <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>
-        <pre>void reset();</pre>
-        <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>
-        <h3><a name="indirection">indirection</a></h3>
-        <pre>T &amp; operator*() const; // never throws</pre>
-        <blockquote>
-            <p><b>Requirements:</b> <code>get() != 0</code>.</p>
-            <p><b>Returns:</b> <code>*get()</code>.</p>
-            <p><b>Throws:</b> nothing.</p>
-        </blockquote>
-        <pre>T * operator-&gt;() const; // never throws</pre>
-        <blockquote>
-            <p><b>Requirements:</b> <code>get() != 0</code>.</p>
-            <p><b>Returns:</b> <code>get()</code>.</p>
-            <p><b>Throws:</b> nothing.</p>
-        </blockquote>
-        <h3><a name="get">get</a></h3>
-        <pre>T * get() const; // never throws</pre>
-        <blockquote>
-            <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 
-                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>
-        </blockquote>
-        <h3><a name="swap">swap</a></h3>
-        <pre>void swap(intrusive_ptr &amp; b); // never throws</pre>
-        <blockquote>
-            <p><b>Effects:</b> Exchanges the contents of the two smart pointers.</p>
-            <p><b>Throws:</b> nothing.</p>
-        </blockquote>
-        <h2><a name="functions">Free Functions</a></h2>
-        <h3><a name="comparison">comparison</a></h3>
-        <pre>template&lt;class T, class U&gt;
-  bool operator==(intrusive_ptr&lt;T&gt; const &amp; a, intrusive_ptr&lt;U&gt; const &amp; b); // never throws</pre>
-        <blockquote>
-            <p><b>Returns:</b> <code>a.get() == b.get()</code>.</p>
-            <p><b>Throws:</b> nothing.</p>
-        </blockquote>
-        <pre>template&lt;class T, class U&gt;
-  bool operator!=(intrusive_ptr&lt;T&gt; const &amp; a, intrusive_ptr&lt;U&gt; const &amp; b); // never throws</pre>
-        <blockquote>
-            <p><b>Returns:</b> <code>a.get() != b.get()</code>.</p>
-            <p><b>Throws:</b> nothing.</p>
-        </blockquote>
-        <pre>template&lt;class T, class U&gt;
-  bool operator==(intrusive_ptr&lt;T&gt; const &amp; a, U * b); // never throws</pre>
-        <blockquote>
-            <p><b>Returns:</b> <code>a.get() == b</code>.</p>
-            <p><b>Throws:</b> nothing.</p>
-        </blockquote>
-        <pre>template&lt;class T, class U&gt;
-  bool operator!=(intrusive_ptr&lt;T&gt; const &amp; a, U * b); // never throws</pre>
-        <blockquote>
-            <p><b>Returns:</b> <code>a.get() != b</code>.</p>
-            <p><b>Throws:</b> nothing.</p>
-        </blockquote>
-        <pre>template&lt;class T, class U&gt;
-  bool operator==(T * a, intrusive_ptr&lt;U&gt; const &amp; b); // never throws</pre>
-        <blockquote>
-            <p><b>Returns:</b> <code>a == b.get()</code>.</p>
-            <p><b>Throws:</b> nothing.</p>
-        </blockquote>
-        <pre>template&lt;class T, class U&gt;
-  bool operator!=(T * a, intrusive_ptr&lt;U&gt; const &amp; b); // never throws</pre>
-        <blockquote>
-            <p><b>Returns:</b> <code>a != b.get()</code>.</p>
-            <p><b>Throws:</b> nothing.</p>
-        </blockquote>
-        <pre>template&lt;class T, class U&gt;
-  bool operator&lt;(intrusive_ptr&lt;T&gt; const &amp; a, intrusive_ptr&lt;U&gt; const &amp; b); // never throws</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>
-        </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>
-        <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>
-        <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>
-        <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>
-        <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>
-        <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>
-        <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>
-    </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,119 +0,0 @@
-<!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>
-        <p><A href="#Introduction">Introduction</A><br>
-            <A href="#Synopsis">Synopsis</A><br>
-            <A href="#functions">Free Functions</A><br>
-            <A href="#example">Example</A><br>
-        <h2><a name="Introduction">Introduction</a></h2>
-        <p>Consistent use of <a href="shared_ptr.htm"><code>shared_ptr</code></a>
-            can eliminate the need to use an explicit <code>delete</code>,
-            but alone it provides no support in avoiding explicit <code>new</code>.
-            There have been repeated requests from users for a factory function that creates
-            an object of a given type and returns a <code>shared_ptr</code> to it.
-            Besides convenience and style, such a function is also exception safe and
-            considerably faster because it can use a single allocation for both the object
-            and its corresponding control block, eliminating a significant portion of
-            <code>shared_ptr</code>'s construction overhead.
-            This eliminates one of the major efficiency complaints about <code>shared_ptr</code>.
-        </p>
-        <p>The header file &lt;boost/make_shared.hpp&gt; provides a family of overloaded function templates,
-            <code>make_shared</code> and <code>allocate_shared</code>, to address this need.
-            <code>make_shared</code> uses the global operator <code>new</code> to allocate memory,
-            whereas <code>allocate_shared</code> uses an user-supplied allocator, allowing finer control.</p>
-        <p>
-            The rationale for choosing the name <code>make_shared</code> is that the expression
-            <code>make_shared&lt;Widget&gt;()</code> can be read aloud and conveys the intended meaning.</p>
-        <h2><a name="Synopsis">Synopsis</a></h2>
-        <pre>namespace boost {
-
-  template&lt;typename T&gt; class shared_ptr;
-
-  template&lt;typename T&gt;
-    shared_ptr&lt;T&gt; <a href="#functions">make_shared</a>();
-
-  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
-
-  template&lt;typename T, typename... Args&gt;
-    shared_ptr&lt;T&gt; <a href="#functions">make_shared</a>( Args &amp;&amp; ... args );
-
-  template&lt;typename T, typename A, typename... Args&gt;
-    shared_ptr&lt;T&gt; <a href="#functions">allocate_shared</a>( A const &amp; a, Args &amp;&amp; ... args );
-
-#else // no C++0X support
-
-  template&lt;typename T, typename Arg1 &gt;
-    shared_ptr&lt;T&gt; <a href="#functions">make_shared</a>( Arg1 const &amp; arg1 );
-  template&lt;typename T, typename Arg1, typename Arg2 &gt;
-    shared_ptr&lt;T&gt; <a href="#functions">make_shared</a>( Arg1 const &amp; arg1, Arg2 const &amp; arg2 );
-// ...
-  template&lt;typename T, typename Arg1, typename Arg2, ..., typename ArgN &gt;
-    shared_ptr&lt;T&gt; <a href="#functions">make_shared</a>( Arg1 const &amp; arg1, Arg2 const &amp; arg2, ..., ArgN const &amp; argN );
-
-  template&lt;typename T, typename A, typename Arg1 &gt;
-    shared_ptr&lt;T&gt; <a href="#functions">allocate_shared</a>( A const &amp; a, Arg1 const &amp; arg1 );
-  template&lt;typename T, typename A, typename Arg1, typename Arg2 &gt;
-    shared_ptr&lt;T&gt; <a href="#functions">allocate_shared</a>( Arg1 const &amp; arg1, Arg2 const &amp; arg2 );
-// ...
-  template&lt;typename T, typename A, typename Arg1, typename Arg2, ..., typename ArgN &gt;
-    shared_ptr&lt;T&gt; <a href="#functions">allocate_shared</a>( A const &amp; a, Arg1 const &amp; arg1, Arg2 const &amp; arg2, ..., ArgN const &amp; argN );
-
-#endif
-}</pre>
-        <h2><a name="functions">Free Functions</a></h2>
-        <pre>template&lt;class T, class... Args&gt;
-    shared_ptr&lt;T&gt; make_shared( Args &amp;&amp; ... args );
-template&lt;class T, class A, class... Args&gt;
-    shared_ptr&lt;T&gt; allocate_shared( A const &amp; a, Args &amp;&amp; ... args );</pre>
-        <blockquote>
-            <p><b>Requires:</b> The expression <code>new( pv ) T( std::forward&lt;Args&gt;(args)... )</code>,
-                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.
-                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>
-                or <code>new( pv ) T( std::forward&lt;Args&gt;(args)... )</code>.
-                <code>allocate_shared</code> uses a copy of <code>a</code> to allocate memory.
-                If an exception is thrown, has no effect.</p>
-            <p><b>Returns:</b> A <code>shared_ptr</code> instance that stores and owns the address
-                of the newly constructed object of type <code>T</code>.</p>
-            <p><b>Postconditions:</b> <code>get() != 0 &amp;&amp; use_count() == 1</code>.</p>
-            <p><b>Throws:</b> <code>bad_alloc</code>, or an exception thrown from <code>A::allocate</code>
-                or the constructor of <code>T</code>.</p>
-            <p><b>Notes:</b> This implementation allocates the memory required for the
-                returned <code>shared_ptr</code> and an object of type <code>T</code> in a single
-                allocation. This provides efficiency equivalent to an intrusive smart pointer.</p>
-            <p>The prototypes shown above are used if your compiler supports rvalue references
-                and variadic templates.  They perfectly forward the <code>args</code> parameters to
-                the constructors of <code>T</code>.</p>
-            <p>Otherwise, the implementation will fall back on
-                forwarding the arguments to the constructors of <code>T</code> as const references.
-                If you need to pass a non-const reference to a constructor of <code>T</code>,
-                you may do so by wrapping the parameter in a call to <code>boost::ref</code>.
-                In addition, you will be
-                limited to a maximum of 9 arguments (not counting the allocator argument of
-                allocate_shared).</p>
-        </blockquote>
-        <h2><a name="example">Example</a></h2>
-        <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><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>
-            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_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>

pointer_cast.html

@@ -1,183 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-<html>
-    <head>
-        <title>pointer_cast</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_cast</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>
-            <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 
-            a static pointer cast this way:</P>
-        <pre>
-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>
-            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>
-namespace boost {
-
-template&lt;class T, class U&gt;
-inline T* static_pointer_cast(U *ptr)
-  { return static_cast&lt;T*&gt;(ptr); }
-
-template&lt;class T, class U&gt;
-inline T* dynamic_pointer_cast(U *ptr)
-  { return dynamic_cast&lt;T*&gt;(ptr); }
-
-template&lt;class T, class U&gt;
-inline T* const_pointer_cast(U *ptr)
-  { return const_cast&lt;T*&gt;(ptr); }
-
-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>
-#include &lt;boost/pointer_cast.hpp&gt;
-#include &lt;boost/shared_ptr.hpp&gt;
-
-class base
-{
-public:
-
-   virtual ~base()
-   {
-   }
-};
-
-class derived: public base
-{
-};
-
-template &lt;class BasePtr&gt;
-void check_if_it_is_derived(const BasePtr &amp;ptr)
-{
-   assert(boost::dynamic_pointer_cast&lt;derived&gt;(ptr) != 0);
-}
-
-int main()
-{
-   <em>// Create a raw and a shared_ptr</em>
-
-   base *ptr = new derived;
-   boost::shared_ptr&lt;base&gt; sptr(new derived);
-   
-   <em>// Check that base pointer points actually to derived class</em>
-
-   check_if_it_is_derived(ptr);
-   check_if_it_is_derived(sptr);
-   
-   <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 />
-        <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>
-    </body>
-</html>

pointer_to_other.html

@@ -1,108 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-<html>
-    <head>
-        <title>pointer_to_other</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>
-        <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 
-            defined in <cite><a href="../../boost/pointer_to_other.hpp">boost/pointer_to_other.hpp</a>.</cite></p>
-        <p>There is test/example code in <cite><a href="test/pointer_to_other_test.cpp">pointer_to_other_test.cpp</a></cite>.</p>
-        <h2><a name="contents">Contents</a></h2>
-        <ul>
-            <li>
-                <a href="#rationale">Rationale</a>
-            <li>
-                <a href="#synopsis">Synopsis</a>
-            <li>
-                <a href="#example">Example</a></li>
-        </ul>
-        <h2><a name="rationale">Rationale</a></h2>
-        <p>When building pointer independent classes, like memory managers, allocators, or 
-            containers, there is often a need to define pointers generically, so that if a 
-            template parameter represents a pointer (for example, a raw or smart pointer to 
-            an int), we can define another pointer of the same type to another pointee (a 
-            raw or smart pointer to a float.)</p>
-        <pre>template &lt;class IntPtr&gt;
-class FloatPointerHolder
-{   
-   <em>// Let's define a pointer to a float</em>
-   typedef typename boost::pointer_to_other
-      &lt;IntPtr, float&gt;::type float_ptr_t;
-   float_ptr_t float_ptr;
-};</pre>
-        <h2><a name="synopsis">Synopsis</a></h2>
-        <pre>
-namespace boost {
-
-template&lt;class T, class U&gt;
-   struct pointer_to_other;
-
-template&lt;class T, class U, template &lt;class&gt; class Sp&gt;
-   struct pointer_to_other&lt; Sp&lt;T&gt;, U &gt;
-{
-   typedef Sp&lt;U&gt; type;
-};
-
-template&lt;class T, class T2, class U,
-        template &lt;class, class&gt; class Sp&gt;
-   struct pointer_to_other&lt; Sp&lt;T, T2&gt;, U &gt;
-{
-   typedef Sp&lt;U, T2&gt; type;
-};
-
-template&lt;class T, class T2, class T3, class U,
-        template &lt;class, class, class&gt; class Sp&gt;
-struct pointer_to_other&lt; Sp&lt;T, T2, T3&gt;, U &gt;
-{
-   typedef Sp&lt;U, T2, T3&gt; type;
-};
-
-template&lt;class T, class U&gt;
-struct pointer_to_other&lt; T*, U &gt; 
-{
-   typedef U* type;
-};
-
-} <em>// namespace boost</em></pre>
-        <p>If these definitions are not correct for a specific smart pointer, we can define 
-            a specialization of pointer_to_other.</p>
-        <h2><a name="example">Example</a></h2>
-        <pre><em>// Let's define a memory allocator that can
-// work with raw and smart pointers</em>
-
-#include &lt;boost/pointer_to_other.hpp&gt;
-
-template &lt;class VoidPtr&gt;
-class memory_allocator
-{<em>
-   // Predefine a memory_block </em>
-   struct block;<em>
-
-   // Define a pointer to a memory_block from a void pointer
-   // If VoidPtr is void *, block_ptr_t is block*
-   // If VoidPtr is smart_ptr&lt;void&gt;, block_ptr_t is smart_ptr&lt;block&gt;</em>
-   typedef typename boost::pointer_to_other      
-            &lt;VoidPtr, block&gt;::type block_ptr_t;
-            
-   struct block
-   {
-      std::size_t size;
-      block_ptr_t next_block;
-   };
-
-   block_ptr_t free_blocks;
-};</pre>
-        <p>As we can see, using pointer_to_other we can create pointer independent code.</p>
-        <hr>
-        <p>$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 
-            copy at &lt; <a href="http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</a>&gt;.)</small></p>
-    </body>
-</html>

scoped_array.htm

@@ -1,115 +0,0 @@
-<!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>
-        <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 
-            destruction of the <b>scoped_array</b>, or via an explicit <b>reset</b>.</p>
-        <p>The <b>scoped_array</b> template is a simple solution for simple needs. It 
-            supplies a basic "resource acquisition is initialization" facility, without 
-            shared-ownership or transfer-of-ownership semantics. Both its name and 
-            enforcement of semantics (by being <a href="../utility/utility.htm#Class_noncopyable">
-            noncopyable</a>) signal its intent to retain ownership solely within the 
-            current scope. Because it is <a href="../utility/utility.htm#Class_noncopyable">noncopyable</a>, 
-            it is safer than <b>shared_array</b> for pointers which should not be copied.</p>
-        <p>Because <b>scoped_array</b> is so simple, in its usual implementation every 
-            operation is as fast as a built-in array pointer and it has no more space 
-            overhead that a built-in array pointer.</p>
-        <p>It cannot be used in C++ standard library containers. See <a href="shared_array.htm">
-            <b>shared_array</b></a> if <b>scoped_array</b> does not meet your needs.</p>
-        <p>It cannot correctly hold a pointer to a single object. See <a href="scoped_ptr.htm"><b>scoped_ptr</b></a>
-            for that usage.</p>
-        <p>A <b>std::vector</b> is an alternative to a <b>scoped_array</b> that is a bit 
-            heavier duty but far more flexible. A <b>boost::array</b> is an alternative 
-            that does not use dynamic allocation.</p>
-        <p>The class template is parameterized on <b>T</b>, the type of the object pointed 
-            to. <b>T</b> must meet the smart pointer <a href="smart_ptr.htm#common_requirements">
-            common requirements</a>.</p>
-        <h2>Synopsis</h2>
-        <pre>namespace boost {
-
-  template&lt;class T&gt; class scoped_array : <a href="../utility/utility.htm#Class_noncopyable">noncopyable</a> {
-
-    public:
-      typedef T <a href="#element_type">element_type</a>;
-
-      explicit <a href="#ctor">scoped_array</a>(T * p = 0); // never throws
-      <a href="#destructor">~scoped_array</a>(); // never throws
-
-      void <a href="#reset">reset</a>(T * p = 0); // never throws
-
-      T &amp; <a href="#operator[]">operator[]</a>(std::ptrdiff_t i) 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
-
-      void <a href="#swap">swap</a>(scoped_array &amp; b); // never throws
-  };
-
-  template&lt;class T&gt; void <a href="#free-swap">swap</a>(scoped_array&lt;T&gt; &amp; a, scoped_array&lt;T&gt; &amp; b); // never throws
-
-}</pre>
-        <h2>Members</h2>
-        <h3>
-            <a name="element_type">element_type</a></h3>
-        <pre>typedef T element_type;</pre>
-        <p>Provides the type of the stored pointer.</p>
-        <h3><a name="ctor">constructors</a></h3>
-        <pre>explicit scoped_array(T * p = 0); // never throws</pre>
-        <p>Constructs a <b>scoped_array</b>, storing a copy of <b>p</b>, which must have 
-            been allocated via a C++ <b>new</b>[] expression or be 0. <b>T</b> is not 
-            required be a complete type. See the smart pointer <a href="smart_ptr.htm#common_requirements">
-            common requirements</a>.</p>
-        <h3><a name="destructor">destructor</a></h3>
-        <pre>~scoped_array(); // never throws</pre>
-        <p>Deletes the array pointed to by the stored pointer. Note that <b>delete[]</b> on 
-            a pointer with a value of 0 is harmless. The guarantee that this does not throw 
-            exceptions depends on the requirement that the deleted array's objects' 
-            destructors do not throw exceptions. See the smart pointer <a href="smart_ptr.htm#common_requirements">
-            common requirements</a>.</p>
-        <h3><a name="reset">reset</a></h3>
-        <pre>void reset(T * p = 0); // never throws</pre>
-        <p>
-            Deletes the array pointed to by the stored pointer and then stores a copy of p, 
-            which must have been allocated via a C++ <b>new[]</b> expression or be 0. The 
-            guarantee that this does not throw exceptions depends on the requirement that 
-            the deleted array's objects' destructors do not throw exceptions. See the smart 
-            pointer <a href="smart_ptr.htm#common_requirements">common requirements</a>.</p>
-        <h3><a name="operator[]">subscripting</a></h3>
-        <pre>T &amp; operator[](std::ptrdiff_t i) const; // never throws</pre>
-        <p>Returns a reference to element <b>i</b> of the array pointed to by the stored 
-            pointer. Behavior is undefined and almost certainly undesirable if the stored 
-            pointer is 0, or if <b>i</b> is less than 0 or is greater than or equal to the 
-            number of elements in the array.</p>
-        <h3><a name="get">get</a></h3>
-        <pre>T * get() const; // never throws</pre>
-        <p>Returns the stored pointer. <b>T</b> need not be a complete type. See the smart 
-            pointer <a href="smart_ptr.htm#common_requirements">common requirements</a>.</p>
-        <h3><a name="conversions">conversions</a></h3>
-        <pre>operator <i>unspecified-bool-type</i> () const; // never throws</pre>
-        <p>Returns an unspecified value that, when used in boolean contexts, is equivalent 
-            to <code>get() != 0</code>.</p>
-        <h3><a name="swap">swap</a></h3>
-        <pre>void swap(scoped_array &amp; b); // never throws</pre>
-        <p>Exchanges the contents of the two smart pointers. <b>T</b> need not be a 
-            complete type. See the smart pointer <a href="smart_ptr.htm#common_requirements">common 
-            requirements</a>.</p>
-        <h2><a name="functions">Free Functions</a></h2>
-        <h3><a name="free-swap">swap</a></h3>
-        <pre>template&lt;class T&gt; void swap(scoped_array&lt;T&gt; &amp; a, scoped_array&lt;T&gt; &amp; b); // never throws</pre>
-        <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><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 
-            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>

scoped_ptr.htm

@@ -1,180 +0,0 @@
-<!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>
-        <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>, 
-            or via an explicit <b>reset</b>. See the <a href="#example">example</a>.</p>
-        <p>The <b>scoped_ptr</b> template is a simple solution for simple needs. It 
-            supplies a basic "resource acquisition is initialization" facility, without 
-            shared-ownership or transfer-of-ownership semantics. Both its name and 
-            enforcement of semantics (by being <a href="../utility/utility.htm#Class_noncopyable">
-            noncopyable</a>) signal its intent to retain ownership solely within the 
-            current scope. Because it is <a href="../utility/utility.htm#Class_noncopyable">noncopyable</a>, 
-            it is safer than <b>shared_ptr</b> or <b>std::auto_ptr</b> for pointers which 
-            should not be copied.</p>
-        <p>Because <b>scoped_ptr</b> is simple, in its usual implementation every operation 
-            is as fast as for a built-in pointer and it has no more space overhead that a 
-            built-in pointer.</p>
-        <p><STRONG>scoped_ptr</STRONG> cannot be used in C++ Standard Library containers. 
-            Use <a href="shared_ptr.htm"><b>shared_ptr</b></a> if you need a smart pointer 
-            that can.</p>
-        <p><STRONG>scoped_ptr</STRONG> cannot correctly hold a pointer to a dynamically 
-            allocated array. See <a href="scoped_array.htm"><b>scoped_array</b></a> for 
-            that usage.</p>
-        <p>The class template is parameterized on <b>T</b>, the type of the object pointed 
-            to. <b>T</b> must meet the smart pointer <a href="smart_ptr.htm#common_requirements">
-            common requirements</a>.</p>
-        <h2>Synopsis</h2>
-        <pre>namespace boost {
-
-  template&lt;class T&gt; class scoped_ptr : <a href="../utility/utility.htm#Class_noncopyable">noncopyable</a> {
-
-   public:
-     typedef T <a href="#element_type">element_type</a>;
-
-     explicit <a href="#constructors">scoped_ptr</a>(T * p = 0); // never throws
-     <a href="#destructor">~scoped_ptr</a>(); // never throws
-
-     void <a href="#reset">reset</a>(T * p = 0); // 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
-
-     void <a href="#swap">swap</a>(scoped_ptr &amp; b); // never throws
-  };
-
-  template&lt;class T&gt; void <a href="#free-swap">swap</a>(scoped_ptr&lt;T&gt; &amp; a, scoped_ptr&lt;T&gt; &amp; b); // never throws
-
-}</pre>
-        <h2>Members</h2>
-        <h3><a name="element_type">element_type</a></h3>
-        <pre>typedef T element_type;</pre>
-        <p>Provides the type of the stored pointer.</p>
-        <h3><a name="constructors">constructors</a></h3>
-        <pre>explicit scoped_ptr(T * p = 0); // never throws</pre>
-        <p>Constructs a <b>scoped_ptr</b>, storing a copy of <b>p</b>, which must have been 
-            allocated via a C++ <b>new</b> expression or be 0. <b>T</b> is not required be 
-            a complete type. See the smart pointer <a href="smart_ptr.htm#common_requirements">common 
-            requirements</a>.</p>
-        <h3><a name="destructor">destructor</a></h3>
-        <pre>~scoped_ptr(); // never throws</pre>
-        <p>Destroys the object pointed to by the stored pointer, if any, as if by using <tt>delete 
-            this-&gt;get()</tt>.</p>
-        <P>
-            The guarantee that this does not throw exceptions depends on the requirement 
-            that the deleted object's destructor does not throw exceptions. See the smart 
-            pointer <a href="smart_ptr.htm#common_requirements">common requirements</a>.</P>
-        <h3><a name="reset">reset</a></h3>
-        <pre>void reset(T * p = 0); // never throws</pre>
-        <p>
-            Deletes the object pointed to by the stored pointer and then stores a copy of 
-            p, which must have been allocated via a C++ <b>new</b> expression or be 0. The 
-            guarantee that this does not throw exceptions depends on the requirement that 
-            the deleted object's destructor does not throw exceptions. See the smart 
-            pointer <a href="smart_ptr.htm#common_requirements">common requirements</a>.</p>
-        <h3><a name="indirection">indirection</a></h3>
-        <pre>T &amp; operator*() const; // never throws</pre>
-        <p>Returns a reference to the object pointed to by the stored pointer. Behavior is 
-            undefined if the stored pointer is 0.</p>
-        <pre>T * operator-&gt;() const; // never throws</pre>
-        <p>Returns the stored pointer. Behavior is undefined if the stored pointer is 0.</p>
-        <h3><a name="get">get</a></h3>
-        <pre>T * get() const; // never throws</pre>
-        <p>Returns the stored pointer. <b>T</b> need not be a complete type. See the smart 
-            pointer <a href="smart_ptr.htm#common_requirements">common requirements</a>.</p>
-        <h3><a name="conversions">conversions</a></h3>
-        <pre>operator <i>unspecified-bool-type</i> () const; // never throws</pre>
-        <p>Returns an unspecified value that, when used in boolean contexts, is equivalent 
-            to <code>get() != 0</code>.</p>
-        <h3><a name="swap">swap</a></h3>
-        <pre>void swap(scoped_ptr &amp; b); // never throws</pre>
-        <p>Exchanges the contents of the two smart pointers. <b>T</b> need not be a 
-            complete type. See the smart pointer <a href="smart_ptr.htm#common_requirements">common 
-            requirements</a>.</p>
-        <h2><a name="functions">Free Functions</a></h2>
-        <h3><a name="free-swap">swap</a></h3>
-        <pre>template&lt;class T&gt; void swap(scoped_ptr&lt;T&gt; &amp; a, scoped_ptr&lt;T&gt; &amp; b); // never throws</pre>
-        <p>Equivalent to <b>a.swap(b)</b>. Matches the interface of <b>std::swap</b>. 
-            Provided as an aid to generic programming.</p>
-        <h2><a name="example">Example</a></h2>
-        <p>Here's an example that uses <b>scoped_ptr</b>.</p>
-        <blockquote>
-            <pre>#include &lt;boost/scoped_ptr.hpp&gt;
-#include &lt;iostream&gt;
-
-struct Shoe { ~Shoe() { std::cout &lt;&lt; "Buckle my shoe\n"; } };
-
-class MyClass {
-    boost::scoped_ptr&lt;int&gt; ptr;
-  public:
-    MyClass() : ptr(new int) { *ptr = 0; }
-    int add_one() { return ++*ptr; }
-};
-
-int main()
-{
-    boost::scoped_ptr&lt;Shoe&gt; x(new Shoe);
-    MyClass my_instance;
-    std::cout &lt;&lt; my_instance.add_one() &lt;&lt; '\n';
-    std::cout &lt;&lt; my_instance.add_one() &lt;&lt; '\n';
-}</pre>
-        </blockquote>
-        <p>The example program produces the beginning of a child's nursery rhyme:</p>
-        <blockquote>
-            <pre>1
-2
-Buckle my shoe</pre>
-        </blockquote>
-        <h2>Rationale</h2>
-        <p>The primary reason to use <b>scoped_ptr</b> rather than <b>auto_ptr</b> is to 
-            let readers of your code know that you intend "resource acquisition is 
-            initialization" to be applied only for the current scope, and have no intent to 
-            transfer ownership.</p>
-        <p>A secondary reason to use <b>scoped_ptr</b> is to prevent a later maintenance 
-            programmer from adding a function that transfers ownership by returning the <b>auto_ptr</b>, 
-            because the maintenance programmer saw <b>auto_ptr</b>, and assumed ownership 
-            could safely be transferred.</p>
-        <p>Think of <b>bool</b> vs <b>int</b>. We all know that under the covers <b>bool</b>
-            is usually just an <b>int</b>. Indeed, some argued against including <b>bool</b>
-            in the C++ standard because of that. But by coding <b>bool</b> rather than <b>int</b>, 
-            you tell your readers what your intent is. Same with <b>scoped_ptr</b>; by 
-            using it you are signaling intent.</p>
-        <p>It has been suggested that <b>scoped_ptr&lt;T&gt;</b> is equivalent to <b>std::auto_ptr&lt;T&gt; 
-            const</b>. Ed Brey pointed out, however, that <b>reset</b> will not work on 
-            a <b>std::auto_ptr&lt;T&gt; const.</b></p>
-        <h2><a name="Handle/Body">Handle/Body</a> Idiom</h2>
-        <p>One common usage of <b>scoped_ptr</b> is to implement a handle/body (also called 
-            pimpl) idiom which avoids exposing the body (implementation) in the header 
-            file.</p>
-        <p>The <a href="example/scoped_ptr_example_test.cpp">scoped_ptr_example_test.cpp</a>
-            sample program includes a header file, <a href="example/scoped_ptr_example.hpp">scoped_ptr_example.hpp</a>, 
-            which uses a <b>scoped_ptr&lt;&gt;</b> to an incomplete type to hide the 
-            implementation. The instantiation of member functions which require a complete 
-            type occurs in the <a href="example/scoped_ptr_example.cpp">scoped_ptr_example.cpp</a>
-            implementation file.</p>
-        <h2>Frequently Asked Questions</h2>
-        <p><b>Q</b>. Why doesn't <b>scoped_ptr</b> have a release() member?<br>
-            <b>A</b>. When reading source code, it is valuable to be able to draw 
-            conclusions about program behavior based on the types being used. If <STRONG>scoped_ptr</STRONG>
-            had a release() member, it would become possible to transfer ownership of the 
-            held pointer, weakening its role as a way of limiting resource lifetime to a 
-            given context. Use <STRONG>std::auto_ptr</STRONG> where transfer of ownership 
-            is required. (supplied by Dave Abrahams)</p>
-        <hr>
-        <p>$Date</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 
-            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>

shared_array.htm

@@ -1,183 +0,0 @@
-<!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>
-        <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>
-            pointing to it is destroyed or reset.</p>
-        <p>Every <b>shared_array</b> meets the <b>CopyConstructible</b> and <b>Assignable</b>
-            requirements of the C++ Standard Library, and so can be used in standard 
-            library containers. Comparison operators are supplied so that <b>shared_array</b>
-            works with the standard library's associative containers.</p>
-        <p>Normally, a <b>shared_array</b> cannot correctly hold a pointer to an object 
-            that has been allocated with the non-array form of <STRONG>new</STRONG>. See <a href="shared_ptr.htm">
-            <b>shared_ptr</b></a> for that usage.</p>
-        <p>Because the implementation uses reference counting, cycles of <b>shared_array</b>
-            instances will not be reclaimed. For example, if <b>main()</b> holds a <b>shared_array</b>
-            to <b>A</b>, which directly or indirectly holds a <b>shared_array</b> back to <b>A</b>,
-            <b>A</b>'s use count will be 2. Destruction of the original <b>shared_array</b> 
-            will leave <b>A</b> dangling with a use count of 1.</p>
-        <p>A <b>shared_ptr</b> to a <b>std::vector</b> is an alternative to a <b>shared_array</b>
-            that is a bit heavier duty but far more flexible.</p>
-        <p>The class template is parameterized on <b>T</b>, the type of the object pointed 
-            to. <b>T</b> must meet the smart pointer <a href="smart_ptr.htm#common_requirements">
-            common requirements</a>.</p>
-        <h2>Synopsis</h2>
-        <pre>namespace boost {
-
-  template&lt;class T&gt; class shared_array {
-
-    public:
-      typedef T <a href="#element_type">element_type</a>;
-
-      explicit <a href="#constructors">shared_array</a>(T * p = 0);
-      template&lt;class D&gt; <a href="#constructors">shared_array</a>(T * p, D d);
-      <a href="#destructor">~shared_array</a>(); // never throws
-
-      <a href="#constructors">shared_array</a>(shared_array const &amp; r); // never throws
-
-      shared_array &amp; <a href="#assignment">operator=</a>(shared_array const &amp; r); // never throws
-
-      void <a href="#reset">reset</a>(T * p = 0);
-      template&lt;class D&gt; void <a href="#reset">reset</a>(T * p, D d);
-
-      T &amp; <a href="#indexing">operator[]</a>(std::ptrdiff_t i) const; // never throws
-      T * <a href="#get">get</a>() const; // never throws
-
-      bool <a href="#unique">unique</a>() const; // never throws
-      long <a href="#use_count">use_count</a>() const; // never throws
-
-      operator <A href="#conversions" ><i>unspecified-bool-type</i></A>() const; // never throws
-
-      void <a href="#swap">swap</a>(shared_array&lt;T&gt; &amp; b); // never throws
-  };
-
-  template&lt;class T&gt;
-    bool <a href="#comparison">operator==</a>(shared_array&lt;T&gt; const &amp; a, shared_array&lt;T&gt; const &amp; b); // never throws
-  template&lt;class T&gt;
-    bool <a href="#comparison">operator!=</a>(shared_array&lt;T&gt; const &amp; a, shared_array&lt;T&gt; const &amp; b); // never throws
-  template&lt;class T&gt;
-    bool <a href="#comparison">operator&lt;</a>(shared_array&lt;T&gt; const &amp; a, shared_array&lt;T&gt; const &amp; b); // never throws
-
-  template&lt;class T&gt; void <a href="#free-swap">swap</a>(shared_array&lt;T&gt; &amp; a, shared_array&lt;T&gt; &amp; b); // never throws
-
-}</pre>
-        <h2>Members</h2>
-        <h3><a name="element_type">element_type</a></h3>
-        <pre>typedef T element_type;</pre>
-        <p>Provides the type of the stored pointer.</p>
-        <h3><a name="constructors">constructors</a></h3>
-        <pre>explicit shared_array(T * p = 0);</pre>
-        <p>Constructs a <b>shared_array</b>, storing a copy of <b>p</b>, which must be a 
-            pointer to an array that was allocated via a C++ <b>new[]</b> expression or be 
-            0. Afterwards, the <a href="#use_count">use count</a> is 1 (even if p == 0; see <a href="#destructor">
-            ~shared_array</a>). The only exception which may be thrown by this 
-            constructor is <b>std::bad_alloc</b>. If an exception is thrown, <b>delete[] p</b>
-            is called.</p>
-        <pre>template&lt;class D&gt; shared_array(T * p, D d);</pre>
-        <p>Constructs a <b>shared_array</b>, storing a copy of <b>p</b> and of <b>d</b>. 
-            Afterwards, the <a href="#use_count">use count</a> is 1. <b>D</b>'s copy 
-            constructor and destructor must not throw. When the the time comes to delete 
-            the array pointed to by <b>p</b>, the object <b>d</b> is used in the statement <b>d(p)</b>. 
-            Invoking the object <b>d</b> with parameter <b>p</b> in this way must not 
-            throw. The only exception which may be thrown by this constructor is <b>std::bad_alloc</b>. 
-            If an exception is thrown, <b>d(p)</b> is called.</p>
-        <pre>shared_array(shared_array const &amp; r); // never throws</pre>
-        <p>Constructs a <b>shared_array</b>, as if by storing a copy of the pointer stored 
-            in <b>r</b>. Afterwards, the <a href="#use_count">use count</a> for all copies 
-            is 1 more than the initial use count.</p>
-        <h3><a name="destructor">destructor</a></h3>
-        <pre>~shared_array(); // never throws</pre>
-        <p>Decrements the <a href="#use_count">use count</a>. Then, if the use count is 0, 
-            deletes the array pointed to by the stored pointer. Note that <b>delete[]</b> on 
-            a pointer with a value of 0 is harmless. <b>T</b> need not be a complete type. 
-            The guarantee that this does not throw exceptions depends on the requirement 
-            that the deleted object's destructor does not throw exceptions. See the smart 
-            pointer <a href="smart_ptr.htm#common_requirements">common requirements</a>.</p>
-        <h3><a name="assignment">assignment</a></h3>
-        <pre>shared_array &amp; operator=(shared_array const &amp; r); // never throws</pre>
-        <p>Constructs a new <b>shared_array</b> as described <a href="#constructors">above</a>, 
-            then replaces this <b>shared_array</b> with the new one, destroying the 
-            replaced object.</p>
-        <h3><a name="reset">reset</a></h3>
-        <pre>void reset(T * p = 0);</pre>
-        <p>Constructs a new <b>shared_array</b> as described <a href="#constructors">above</a>, 
-            then replaces this <b>shared_array</b> with the new one, destroying the 
-            replaced object. The only exception which may be thrown is <b>std::bad_alloc</b>. 
-            If an exception is thrown, <b>delete[] p</b> is called.</p>
-        <pre>template&lt;class D&gt; void reset(T * p, D d);</pre>
-        <p>Constructs a new <b>shared_array</b> as described <a href="#constructors">above</a>, 
-            then replaces this <b>shared_array</b> with the new one, destroying the 
-            replaced object. <b>D</b>'s copy constructor must not throw. The only exception 
-            which may be thrown is <b>std::bad_alloc</b>. If an exception is thrown, <b>d(p)</b>
-            is called.</p>
-        <h3><a name="indexing">indexing</a></h3>
-        <pre>T &amp; operator[](std::ptrdiff_t i) const; // never throws</pre>
-        <p>Returns a reference to element <b>i</b> of the array pointed to by the stored 
-            pointer. Behavior is undefined and almost certainly undesirable if the stored 
-            pointer is 0, or if <b>i</b> is less than 0 or is greater than or equal to the 
-            number of elements in the array.</p>
-        <h3><a name="get">get</a></h3>
-        <pre>T * get() const; // never throws</pre>
-        <p>Returns the stored pointer. <b>T</b> need not be a complete type. See the smart 
-            pointer <a href="smart_ptr.htm#common_requirements">common requirements</a>.</p>
-        <h3><a name="unique">unique</a></h3>
-        <pre>bool unique() const; // never throws</pre>
-        <p>Returns true if no other <b>shared_array</b> is sharing ownership of the stored 
-            pointer, false otherwise. <b>T</b> need not be a complete type. See the smart 
-            pointer <a href="smart_ptr.htm#common_requirements">common requirements</a>.</p>
-        <h3><a name="use_count">use_count</a></h3>
-        <pre>long use_count() const; // never throws</pre>
-        <p>Returns the number of <b>shared_array</b> objects sharing ownership of the 
-            stored pointer. <b>T</b> need not be a complete type. See the smart pointer <a href="smart_ptr.htm#common_requirements">
-            common requirements</a>.</p>
-        <p>Because <b>use_count</b> is not necessarily efficient to implement for 
-            implementations of <b>shared_array</b> that do not use an explicit reference 
-            count, it might be removed from some future version. Thus it should be used for 
-            debugging purposes only, and not production code.</p>
-        <h3><a name="conversions">conversions</a></h3>
-        <pre>operator <i>unspecified-bool-type</i> () const; // never throws</pre>
-        <p>Returns an unspecified value that, when used in boolean contexts, is equivalent 
-            to <code>get() != 0</code>.</p>
-        <h3><a name="swap">swap</a></h3>
-        <pre>void swap(shared_ptr &amp; b); // never throws</pre>
-        <p>Exchanges the contents of the two smart pointers. <b>T</b> need not be a 
-            complete type. See the smart pointer <a href="smart_ptr.htm#common_requirements">common 
-            requirements</a>.</p>
-        <h2><a name="functions">Free Functions</a></h2>
-        <h3><a name="comparison">comparison</a></h3>
-        <pre>template&lt;class T&gt;
-  bool operator==(shared_array&lt;T&gt; const &amp; a, shared_array&lt;T&gt; const &amp; b); // never throws
-template&lt;class T&gt;
-  bool operator!=(shared_array&lt;T&gt; const &amp; a, shared_array&lt;T&gt; const &amp; b); // never throws
-template&lt;class T&gt;
-  bool operator&lt;(shared_array&lt;T&gt; const &amp; a, shared_array&lt;T&gt; const &amp; b); // never throws</pre>
-        <p>Compares the stored pointers of the two smart pointers. <b>T</b> need not be a 
-            complete type. See the smart pointer <a href="smart_ptr.htm#common_requirements">common 
-            requirements</a>.</p>
-        <p>The <b>operator&lt;</b> overload is provided to define an ordering so that <b>shared_array</b>
-            objects can be used in associative containers such as <b>std::map</b>. The 
-            implementation uses <b>std::less&lt;T *&gt;</b> to perform the comparison. This 
-            ensures that the comparison is handled correctly, since the standard mandates 
-            that relational operations on pointers are unspecified (5.9 [expr.rel] 
-            paragraph 2) but <b>std::less&lt;&gt;</b> on pointers is well-defined (20.3.3 
-            [lib.comparisons] paragraph 8).</p>
-        <h3><a name="free-swap">swap</a></h3>
-        <pre>template&lt;class T&gt;
-  void swap(shared_array&lt;T&gt; &amp; a, shared_array&lt;T&gt; &amp; b) // never throws</pre>
-        <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><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 
-            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>

shared_ptr.htm

@@ -1,858 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-<html>
-    <head>
-        <title>shared_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">shared_ptr class template</h1>
-        <p><a href="#Introduction">Introduction</a><br>
-            <a href="#BestPractices">Best Practices</a><br>
-            <a href="#Synopsis">Synopsis</a><br>
-            <a href="#Members">Members</a><br>
-            <a href="#functions">Free Functions</a><br>
-            <a href="#example">Example</a><br>
-            <a href="#HandleBody">Handle/Body Idiom</a><br>
-            <a href="#ThreadSafety">Thread Safety</a><br>
-            <a href="#FAQ">Frequently Asked Questions</a><br>
-            <a href="smarttests.htm">Smart Pointer Timings</a><br>
-            <a href="sp_techniques.html">Programming Techniques</a></p>
-        <h2 id="Introduction">Introduction</h2>
-        <p>The <code>shared_ptr</code> class template stores a pointer to a dynamically allocated
-            object, typically with a C++ <em>new-expression</em>. The object pointed to is
-            guaranteed to be deleted when the last <code>shared_ptr</code> pointing to it is
-            destroyed or reset.</p>
-        <blockquote><em>Example:</em><br><pre>shared_ptr&lt;X&gt; p1( new X );
-shared_ptr&lt;void&gt; p2( new int(5) );
-</pre></blockquote>
-
-        <p><code>shared_ptr</code> deletes the exact pointer that has been passed at construction time,
-            complete with its original type, regardless of the template parameter. In the second example above,
-            when <code>p2</code> is destroyed or reset, it will call <code>delete</code> on the original <code>int*</code>
-            that has been passed to the constructor, even though <code>p2</code> itself is of type
-            <code>shared_ptr&lt;void&gt;</code> and stores a pointer of type <code>void*</code>.</p>
-
-        <p>Every <code>shared_ptr</code> meets the <code>CopyConstructible</code>, <code>MoveConstructible</code>,
-            <code>CopyAssignable</code> and <code>MoveAssignable</code>
-            requirements of the C++ Standard Library, and can be used in standard
-            library containers. Comparison operators are supplied so that <code>shared_ptr</code>
-            works with the standard library's associative containers.</p>
-        <p>Because the implementation uses reference counting, cycles of <code>shared_ptr</code> instances
-            will not be reclaimed. For example, if <code>main()</code> holds a <code>shared_ptr</code> to
-            <code>A</code>, which directly or indirectly holds a <code>shared_ptr</code> back to <code>A</code>,
-            <code>A</code>'s use count will be 2. Destruction of the original <code>shared_ptr</code> will
-            leave <code>A</code> dangling with a use count of 1. Use <a href="weak_ptr.htm">weak_ptr</a>
-            to "break cycles."</p>
-        <p>The class template is parameterized on <code>T</code>, the type of the object pointed
-            to. <code>shared_ptr</code> and most of its member functions place no
-            requirements on <code>T</code>; it is allowed to be an incomplete type, or
-            <code>void</code>. Member functions that do place additional requirements
-            (<a href="#pointer_constructor">constructors</a>, <a href="#reset">reset</a>) are explicitly
-            documented below.</p>
-        <p><code>shared_ptr&lt;T&gt;</code> can be implicitly converted to <code>shared_ptr&lt;U&gt;</code>
-            whenever <code>T*</code> can be implicitly converted to <code>U*</code>.
-            In particular, <code>shared_ptr&lt;T&gt;</code> is implicitly convertible
-            to <code>shared_ptr&lt;T const&gt;</code>, to <code>shared_ptr&lt;U&gt;</code>
-            where <code>U</code> is an accessible base of <code>T</code>, and to <code>
-                shared_ptr&lt;void&gt;</code>.</p>
-        <p><code>shared_ptr</code> is now part of the C++11 Standard, as <code>std::shared_ptr</code>.</p>
-        <p>Starting with Boost release 1.53, <code>shared_ptr</code> can be used to hold a pointer to a dynamically
-            allocated array. This is accomplished by using an array type (<code>T[]</code> or <code>T[N]</code>) as
-            the template parameter. There is almost no difference between using an unsized array, <code>T[]</code>,
-            and a sized array, <code>T[N]</code>; the latter just enables <code>operator[]</code> to perform a range check
-            on the index.</p>
-        <blockquote><em>Example:</em><br><pre>shared_ptr&lt;double[1024]&gt; p1( new double[1024] );
-shared_ptr&lt;double[]&gt; p2( new double[n] );
-</pre></blockquote>
-
-        <h2 id="BestPractices">Best Practices</h2>
-        <p>A simple guideline that nearly eliminates the possibility of memory leaks is:
-            always use a named smart pointer variable to hold the result of <code>new</code>.
-            Every occurence of the <code>new</code> keyword in the code should have the
-            form:</p>
-        <pre>shared_ptr&lt;T&gt; p(new Y);</pre>
-        <p>It is, of course, acceptable to use another smart pointer in place of <code>shared_ptr</code>
-            above; having <code>T</code> and <code>Y</code> be the same type, or
-            passing arguments to <code>Y</code>'s constructor is also OK.</p>
-        <p>If you observe this guideline, it naturally follows that you will have no
-            explicit <code>delete</code> statements; <code>try/catch</code> constructs will
-            be rare.</p>
-        <p>Avoid using unnamed <code>shared_ptr</code> temporaries to save typing; to
-            see why this is dangerous, consider this example:</p>
-        <pre>void f(shared_ptr&lt;int&gt;, int);
-int g();
-
-void ok()
-{
-    shared_ptr&lt;int&gt; p( new int(2) );
-    f( p, g() );
-}
-
-void bad()
-{
-    f( shared_ptr&lt;int&gt;( new int(2) ), g() );
-}
-</pre>
-        <p>The function <code>ok</code> follows the guideline to the letter, whereas
-            <code>bad</code> constructs the temporary <code>shared_ptr</code> in place,
-            admitting the possibility of a memory leak. Since function arguments are
-            evaluated in unspecified order, it is possible for <code>new int(2)</code> to
-            be evaluated first, <code>g()</code> second, and we may never get to the
-            <code>shared_ptr</code>constructor if <code>g</code> throws an exception.
-            See <a href="http://www.gotw.ca/gotw/056.htm">Herb Sutter's treatment</a> (also <a href="http://www.cuj.com/reference/articles/2002/0212/0212_sutter.htm">
-            here</a>) of the issue for more information.</p>
-        <p>The exception safety problem described above may also be eliminated by using
-            the <a href="make_shared.html"><code>make_shared</code></a>
-            or <a href="make_shared.html"><code>allocate_shared</code></a>
-            factory functions defined in <code>boost/make_shared.hpp</code>.
-            These factory functions also provide an efficiency benefit by consolidating allocations.</p>
-        <h2 id="Synopsis">Synopsis</h2>
-        <pre>namespace boost {
-
-  class bad_weak_ptr: public std::exception;
-
-  template&lt;class T&gt; class <a href="weak_ptr.htm" >weak_ptr</a>;
-
-  template&lt;class T&gt; class shared_ptr {
-
-    public:
-
-      typedef <em>see below</em> <a href="#element_type" >element_type</a>;
-
-      <a href="#default_constructor" >shared_ptr</a>(); // never throws
-      <a href="#default_constructor" >shared_ptr</a>(std::nullptr_t); // never throws
-
-      template&lt;class Y&gt; explicit <a href="#pointer_constructor" >shared_ptr</a>(Y * p);
-      template&lt;class Y, class D&gt; <a href="#deleter_constructor" >shared_ptr</a>(Y * p, D d);
-      template&lt;class Y, class D, class A&gt; <a href="#deleter_constructor" >shared_ptr</a>(Y * p, D d, A a);
-      template&lt;class D&gt; <a href="#deleter_constructor" >shared_ptr</a>(std::nullptr_t p, D d);
-      template&lt;class D, class A&gt; <a href="#deleter_constructor" >shared_ptr</a>(std::nullptr_t p, D d, A a);
-
-      <a href="#destructor" >~shared_ptr</a>(); // never throws
-
-      <a href="#copy_constructor" >shared_ptr</a>(shared_ptr const &amp; r); // never throws
-      template&lt;class Y&gt; <a href="#copy_constructor" >shared_ptr</a>(shared_ptr&lt;Y&gt; const &amp; r); // never throws
-
-      <a href="#move_constructor" >shared_ptr</a>(shared_ptr &amp;&amp; r); // never throws
-      template&lt;class Y&gt; <a href="#move_constructor" >shared_ptr</a>(shared_ptr&lt;Y&gt; &amp;&amp; r); // never throws
-
-      template&lt;class Y&gt; <a href="#aliasing_constructor" >shared_ptr</a>(shared_ptr&lt;Y&gt; const &amp; r, element_type * p); // never throws
-
-      template&lt;class Y&gt; <a href="#aliasing_move_constructor" >shared_ptr</a>(shared_ptr&lt;Y&gt; &amp;&amp; r, element_type * p); // never throws
-
-      template&lt;class Y&gt; explicit <a href="#weak_ptr_constructor" >shared_ptr</a>(<a href="weak_ptr.htm" >weak_ptr</a>&lt;Y&gt; const &amp; r);
-
-      template&lt;class Y&gt; explicit <a href="#auto_ptr_constructor" >shared_ptr</a>(std::auto_ptr&lt;Y&gt; &amp; r);
-      template&lt;class Y&gt; <a href="#auto_ptr_constructor" >shared_ptr</a>(std::auto_ptr&lt;Y&gt; &amp;&amp; r);
-
-      template&lt;class Y, class D&gt; <a href="#unique_ptr_constructor" >shared_ptr</a>(std::unique_ptr&lt;Y, D&gt; &amp;&amp; r);
-
-      shared_ptr &amp; <a href="#assignment" >operator=</a>(shared_ptr const &amp; r); // never throws
-      template&lt;class Y&gt; shared_ptr &amp; <a href="#assignment" >operator=</a>(shared_ptr&lt;Y&gt; const &amp; r); // never throws
-
-      shared_ptr &amp; <a href="#assignment" >operator=</a>(shared_ptr const &amp;&amp; r); // never throws
-      template&lt;class Y&gt; shared_ptr &amp; <a href="#assignment" >operator=</a>(shared_ptr&lt;Y&gt; const &amp;&amp; r); // never throws
-
-      template&lt;class Y&gt; shared_ptr &amp; <a href="#assignment" >operator=</a>(std::auto_ptr&lt;Y&gt; &amp; r);
-      template&lt;class Y&gt; shared_ptr &amp; <a href="#assignment" >operator=</a>(std::auto_ptr&lt;Y&gt; &amp;&amp; r);
-
-      template&lt;class Y, class D&gt; shared_ptr &amp; <a href="#assignment" >operator=</a>(std::unique_ptr&lt;Y, D&gt; &amp;&amp; r);
-
-      shared_ptr &amp; <a href="#assignment" >operator=</a>(std::nullptr_t); // never throws
-
-      void <a href="#reset" >reset</a>(); // never throws
-
-      template&lt;class Y&gt; void <a href="#reset" >reset</a>(Y * p);
-      template&lt;class Y, class D&gt; void <a href="#reset" >reset</a>(Y * p, D d);
-      template&lt;class Y, class D, class A&gt; void <a href="#reset" >reset</a>(Y * p, D d, A a);
-
-      template&lt;class Y&gt; void <a href="#reset" >reset</a>(shared_ptr&lt;Y&gt; const &amp; r, element_type * p); // never throws
-
-      T &amp; <a href="#indirection" >operator*</a>() const; // never throws; only valid when T is not an array type
-      T * <a href="#indirection" >operator-&gt;</a>() const; // never throws; only valid when T is not an array type
-
-      element_type &amp; <a href="#indirection" >operator[]</a>(std::ptrdiff_t i) const; // never throws; only valid when T is an array type
-
-      element_type * <a href="#get" >get</a>() const; // never throws
-
-      bool <a href="#unique" >unique</a>() const; // never throws
-      long <a href="#use_count" >use_count</a>() const; // never throws
-
-      explicit <a href="#conversions" >operator bool</a>() const; // never throws
-
-      void <a href="#swap" >swap</a>(shared_ptr &amp; b); // never throws
-      
-      template&lt;class Y&gt; bool <a href="#owner_before" >owner_before</a>(shared_ptr&lt;Y&gt; const &amp; rhs) const; // never throws
-      template&lt;class Y&gt; bool <a href="#owner_before" >owner_before</a>(weak_ptr&lt;Y&gt; const &amp; rhs) const; // never throws
-  };
-
-  template&lt;class T, class U&gt;
-    bool <a href="#comparison" >operator==</a>(shared_ptr&lt;T&gt; const &amp; a, shared_ptr&lt;U&gt; const &amp; b); // never throws
-
-  template&lt;class T, class U&gt;
-    bool <a href="#comparison" >operator!=</a>(shared_ptr&lt;T&gt; const &amp; a, shared_ptr&lt;U&gt; const &amp; b); // never throws
-
-  template&lt;class T, class U&gt;
-    bool <a href="#comparison" >operator&lt;</a>(shared_ptr&lt;T&gt; const &amp; a, shared_ptr&lt;U&gt; const &amp; b); // never throws
-
-  template&lt;class T&gt;
-    bool <a href="#comparison" >operator==</a>(shared_ptr&lt;T&gt; const &amp; p, std::nullptr_t); // never throws
-
-  template&lt;class T&gt;
-    bool <a href="#comparison" >operator==</a>(std::nullptr_t, shared_ptr&lt;T&gt; const &amp; p); // never throws
-
-  template&lt;class T&gt;
-    bool <a href="#comparison" >operator!=</a>(shared_ptr&lt;T&gt; const &amp; p, std::nullptr_t); // never throws
-
-  template&lt;class T&gt;
-    bool <a href="#comparison" >operator!=</a>(std::nullptr_t, shared_ptr&lt;T&gt; const &amp; p); // never throws
-
-  template&lt;class T&gt; void <a href="#free-swap" >swap</a>(shared_ptr&lt;T&gt; &amp; a, shared_ptr&lt;T&gt; &amp; b); // never throws
-
-  template&lt;class T&gt; typename shared_ptr&lt;T&gt;::element_type * <a href="#get_pointer" >get_pointer</a>(shared_ptr&lt;T&gt; const &amp; p); // never throws
-
-  template&lt;class T, class U&gt;
-    shared_ptr&lt;T&gt; <a href="#static_pointer_cast" >static_pointer_cast</a>(shared_ptr&lt;U&gt; const &amp; r); // never throws
-
-  template&lt;class T, class U&gt;
-    shared_ptr&lt;T&gt; <a href="#const_pointer_cast" >const_pointer_cast</a>(shared_ptr&lt;U&gt; const &amp; r); // never throws
-
-  template&lt;class T, class U&gt;
-    shared_ptr&lt;T&gt; <a href="#dynamic_pointer_cast" >dynamic_pointer_cast</a>(shared_ptr&lt;U&gt; const &amp; r); // never throws
-
-  template&lt;class T, class U&gt;
-    shared_ptr&lt;T&gt; <a href="#reinterpret_pointer_cast" >reinterpret_pointer_cast</a>(shared_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, shared_ptr&lt;Y&gt; const &amp; p);
-
-  template&lt;class D, class T&gt;
-    D * <a href="#get_deleter">get_deleter</a>(shared_ptr&lt;T&gt; const &amp; p);
-}</pre>
-        <h2 id="Members">Members</h2>
-        <h3 id="element_type">element_type</h3>
-        <pre>typedef <em>...</em> element_type;</pre>
-        <blockquote>
-            <p><code>element_type</code> is <code>T</code> when <code>T</code> is not an array type,
-                and <code>U</code> when <code>T</code> is <code>U[]</code> or <code>U[N]</code>.</p>
-        </blockquote>
-        <h3 id="default_constructor">default constructor</h3>
-        <pre>shared_ptr(); // never throws
-shared_ptr(std::nullptr_t); // never throws</pre>
-        <blockquote>
-            <p><b>Effects:</b> Constructs an <em>empty</em> <code>shared_ptr</code>.</p>
-            <p><b>Postconditions:</b> <code>use_count() == 0 &amp;&amp; get() == 0</code>.</p>
-            <p><b>Throws:</b> nothing.</p>
-        </blockquote>
-        <p><em>[The nothrow guarantee is important, since <code>reset()</code> is specified
-            in terms of the default constructor; this implies that the constructor must not
-            allocate memory.]</em></p>
-        <h3 id="pointer_constructor">pointer constructor</h3>
-        <pre>template&lt;class Y&gt; explicit shared_ptr(Y * p);</pre>
-        <blockquote>
-            <p><b>Requirements:</b>
-                <code>Y</code> must be a complete type.
-                The expression <code>delete[] p</code>, when <code>T</code> is an array type, or <code>delete p</code>,
-                when <code>T</code> is not an array type,
-                must be well-formed, must not invoke undefined behavior, and must not throw exceptions.
-                When <code>T</code> is <code>U[N]</code>, <code>Y (*) [N]</code> must be convertible to <code>T*</code>;
-                when <code>T</code> is <code>U[]</code>, <code>Y (*) []</code> must be convertible to <code>T*</code>;
-                otherwise, <code>Y*</code> must be convertible to <code>T*</code>.
-            </p>
-            <p><b>Effects:</b>
-                When <code>T</code> is not an array type, constructs a <code>shared_ptr</code> that <em>owns</em>
-                the pointer <code>p</code>.
-                Otherwise, constructs  a <code>shared_ptr</code> that <em>owns</em>
-                <code>p</code> and a deleter of an unspecified type that calls <code>delete[] p</code>.</p>
-            <p><b>Postconditions:</b> <code>use_count() == 1 &amp;&amp; get() == p</code>.
-                If <code>T</code> is not an array type and <code>p</code> is unambiguously convertible to <code>
-                <a href="enable_shared_from_this.html">enable_shared_from_this</a>&lt;V&gt;*</code>
-                for some <code>V</code>, <code>p-&gt;shared_from_this()</code> returns a copy of
-                <code>*this</code>.</p>
-            <p><b>Throws:</b> <code>std::bad_alloc</code>, or an implementation-defined
-                exception when a resource other than memory could not be obtained.</p>
-            <p><b>Exception safety:</b> If an exception is thrown, the constructor calls
-                <code>delete[] p</code>, when <code>T</code> is an array type,
-                or <code>delete p</code>, when <code>T</code> is not an array type.</p>
-            <p><b>Notes:</b> <code>p</code> must be a pointer to an object that was
-                allocated via a C++ <code>new</code> expression or be 0. The postcondition that <a href="#use_count">
-                use count</a> is 1 holds even if <code>p</code> is 0; invoking <code>delete</code>
-                on a pointer that has a value of 0 is harmless.</p>
-        </blockquote>
-        <p><em>[This constructor is a template in order to remember the actual
-            pointer type passed. The destructor will call <code>delete</code> with the
-            same pointer, complete with its original type, even when <code>T</code> does
-            not have a virtual destructor, or is <code>void</code>.]</em></p>
-        <h3 id="deleter_constructor">constructors taking a deleter</h3>
-        <pre>template&lt;class Y, class D&gt; shared_ptr(Y * p, D d);
-template&lt;class Y, class D, class A&gt; shared_ptr(Y * p, D d, A a);
-template&lt;class D&gt; shared_ptr(std::nullptr_t p, D d);
-template&lt;class D, class A&gt; shared_ptr(std::nullptr_t p, D d, A a);</pre>
-        <blockquote>
-            <p><b>Requirements:</b>
-                <code>D</code> must be <code>CopyConstructible</code>. The copy constructor and destructor
-                of <code>D</code> must not throw. The expression <code>d(p)</code> must be
-                well-formed, must not invoke undefined behavior, and must not throw exceptions.
-                <code>A</code> must be an <em>Allocator</em>, as described in section 20.1.5
-                (<code>Allocator requirements</code>) of the C++ Standard.
-                When <code>T</code> is <code>U[N]</code>, <code>Y (*) [N]</code> must be convertible to <code>T*</code>;
-                when <code>T</code> is <code>U[]</code>, <code>Y (*) []</code> must be convertible to <code>T*</code>;
-                otherwise, <code>Y*</code> must be convertible to <code>T*</code>.
-            </p>
-            <p><b>Effects:</b> Constructs a <code>shared_ptr</code> that <em>owns</em> the pointer <code>
-                p</code> and the deleter <code>d</code>. The constructors taking an allocator <code>a</code>
-                allocate memory using a copy of <code>a</code>.</p>
-            <p><b>Postconditions:</b> <code>use_count() == 1 &amp;&amp; get() == p</code>.
-                If <code>T</code> is not an array type and <code>p</code> is unambiguously convertible to <code>
-                <a href="enable_shared_from_this.html">enable_shared_from_this</a>&lt;V&gt;*</code>
-                for some <code>V</code>, <code>p-&gt;shared_from_this()</code> returns a copy of
-                <code>*this</code>.</p>
-            <p><b>Throws:</b> <code>std::bad_alloc</code>, or an implementation-defined
-                exception when a resource other than memory could not be obtained.</p>
-            <p><b>Exception safety:</b> If an exception is thrown, <code>d(p)</code> is called.</p>
-            <p><b>Notes:</b> When the the time comes to delete the object pointed to by <code>p</code>,
-                the stored copy of <code>d</code> is invoked with the stored copy of <code>p</code>
-                as an argument.</p>
-        </blockquote>
-        <p><em>[Custom deallocators allow a factory function returning a <code>shared_ptr</code>
-                to insulate the user from its memory allocation strategy. Since the deallocator
-                is not part of the type, changing the allocation strategy does not break source
-                or binary compatibility, and does not require a client recompilation. For
-                example, a "no-op" deallocator is useful when returning a <code>shared_ptr</code>
-                to a statically allocated object, and other variations allow a <code>shared_ptr</code>
-                to be used as a wrapper for another smart pointer, easing interoperability.</em></p>
-        <p><em>The support for custom deallocators does not impose significant overhead. Other <code>
-                shared_ptr</code> features still require a deallocator to be kept.</em></p>
-        <p><em>The requirement that the copy constructor of <code>D</code> does not throw comes from
-                the pass by value. If the copy constructor throws, the pointer would leak.]</em></p>
-        <h3 id="copy_constructor">copy and converting constructors</h3>
-        <pre>shared_ptr(shared_ptr const &amp; r); // never throws
-template&lt;class Y&gt; shared_ptr(shared_ptr&lt;Y&gt; const &amp; r); // never throws</pre>
-        <blockquote>
-            <p><b>Requires:</b> <code>Y*</code> should be convertible to <code>T*</code>.</p>
-            <p><b>Effects:</b> If <code>r</code> is <em>empty</em>, constructs an <em>empty</em> <code>shared_ptr</code>;
-                otherwise, constructs a <code>shared_ptr</code> that <em>shares ownership</em> with <code>r</code>.</p>
-            <p><b>Postconditions:</b> <code>get() == r.get() &amp;&amp; use_count() ==
-                r.use_count()</code>.</p>
-            <p><b>Throws:</b> nothing.</p>
-        </blockquote>
-        <h3 id="move_constructor">move constructors</h3>
-        <pre>shared_ptr(shared_ptr &amp;&amp; r); // never throws
-template&lt;class Y&gt; shared_ptr(shared_ptr&lt;Y&gt; &amp;&amp; r); // never throws</pre>
-        <blockquote>
-            <p><b>Requires:</b> <code>Y*</code> should be convertible to <code>T*</code>.</p>
-            <p><b>Effects:</b> Move-constructs a <code>shared_ptr</code> from <code>r</code>.</p>
-            <p><b>Postconditions:</b> <code>*this</code> contains the old value of <code>r</code>. <code>r</code> is <em>empty</em> and <code>r.get() == 0</code>.</p>
-            <p><b>Throws:</b> nothing.</p>
-        </blockquote>
-        <h3 id="aliasing_constructor">aliasing constructor</h3>
-        <pre>template&lt;class Y&gt; shared_ptr(shared_ptr&lt;Y&gt; const &amp; r, element_type * p); // never throws</pre>
-        <blockquote>
-            <p><b>Effects:</b> constructs a <code>shared_ptr</code> that <em>shares ownership</em> with
-                <code>r</code> and stores <code>p</code>.</p>
-            <p><b>Postconditions:</b> <code>get() == p &amp;&amp; use_count() == r.use_count()</code>.</p>
-            <p><b>Throws:</b> nothing.</p>
-        </blockquote>
-        <h3 id="aliasing_move_constructor">aliasing move constructor</h3>
-        <pre>template&lt;class Y&gt; shared_ptr(shared_ptr&lt;Y&gt; &amp;&amp; r, element_type * p); // never throws</pre>
-        <blockquote>
-            <p>
-                <b>Effects:</b> Move-constructs a <code>shared_ptr</code> from <code>r</code>, while
-                storing <code>p</code> instead.
-            </p>
-            <p><b>Postconditions:</b> <code>get() == p</code> and <code>use_count()</code> equals the old count of <code>r</code>. <code>r</code> is <em>empty</em> and <code>r.get() == 0</code>.</p>
-            <p><b>Throws:</b> nothing.</p>
-        </blockquote>
-        <h3 id="weak_ptr_constructor">weak_ptr constructor</h3>
-        <pre>template&lt;class Y&gt; explicit shared_ptr(<a href="weak_ptr.htm" >weak_ptr</a>&lt;Y&gt; const &amp; r);</pre>
-        <blockquote>
-            <p><b>Requires:</b> <code>Y*</code> should be convertible to <code>T*</code>.</p>
-            <p><b>Effects:</b> Constructs a <code>shared_ptr</code> that <em>shares ownership</em> with
-                <code>r</code> and stores a copy of the pointer stored in <code>r</code>.</p>
-            <p><b>Postconditions:</b> <code>use_count() == r.use_count()</code>.</p>
-            <p><b>Throws:</b> <code>bad_weak_ptr</code> when <code>r.use_count() == 0</code>.</p>
-            <p><b>Exception safety:</b> If an exception is thrown, the constructor has no
-                effect.</p>
-        </blockquote>
-        <h3 id="auto_ptr_constructor">auto_ptr constructors</h3>
-        <pre>template&lt;class Y&gt; shared_ptr(std::auto_ptr&lt;Y&gt; &amp; r);
-template&lt;class Y&gt; shared_ptr(std::auto_ptr&lt;Y&gt; &amp;&amp; r);</pre>
-        <blockquote>
-            <p><b>Requires:</b> <code>Y*</code> should be convertible to <code>T*</code>.</p>
-            <p><b>Effects:</b> Constructs a <code>shared_ptr</code>, as if by storing a copy of <code>r.release()</code>.</p>
-            <p><b>Postconditions:</b> <code>use_count() == 1</code>.</p>
-            <p><b>Throws:</b> <code>std::bad_alloc</code>, or an implementation-defined
-                exception when a resource other than memory could not be obtained.</p>
-            <p><b>Exception safety:</b> If an exception is thrown, the constructor has no
-                effect.</p>
-        </blockquote>
-        <h3 id="unique_ptr_constructor">unique_ptr constructor</h3>
-        <pre>template&lt;class Y, class D&gt; shared_ptr(std::unique_ptr&lt;Y, D&gt; &amp;&amp; r);</pre>
-        <blockquote>
-            <p><b>Requires:</b> <code>Y*</code> should be convertible to <code>T*</code>.</p>
-            <p><b>Effects:</b>
-                Equivalent to <code>shared_ptr(r.release(), r.get_deleter())</code> when <code>D</code> is not a reference type.
-                Otherwise, equivalent to <code>shared_ptr(r.release(), <em>del</em>)</code>, where <em>del</em> is a deleter
-                that stores the reference <code>rd</code> returned from <code>r.get_deleter()</code> and <code>del(p)</code> calls <code>rd(p)</code>.</p>
-            <p><b>Postconditions:</b> <code>use_count() == 1</code>.</p>
-            <p><b>Throws:</b> <code>std::bad_alloc</code>, or an implementation-defined
-                exception when a resource other than memory could not be obtained.</p>
-            <p><b>Exception safety:</b> If an exception is thrown, the constructor has no
-                effect.</p>
-        </blockquote>
-        <h3 id="destructor">destructor</h3>
-        <pre>~shared_ptr(); // never throws</pre>
-        <blockquote>
-            <p><b>Effects:</b></p>
-            <ul>
-                <li>
-                    If <code>*this</code> is <em>empty</em>, or <em>shares ownership</em> with
-                    another <code>shared_ptr</code> instance (<code>use_count() &gt; 1</code>),
-                    there are no side effects.</li>
-                <li>
-                    Otherwise, if <code>*this</code> <em>owns</em> a pointer <code>p</code>
-                    and a deleter <code>d</code>, <code>d(p)</code>
-                    is called.</li>
-                <li>
-                    Otherwise, <code>*this</code> <em>owns</em> a pointer <code>p</code>,
-                    and <code>delete p</code> is called.</li>
-            </ul>
-            <p><b>Throws:</b> nothing.</p>
-        </blockquote>
-        <h3 id="assignment">assignment</h3>
-        <pre>shared_ptr &amp; operator=(shared_ptr const &amp; r); // never throws
-template&lt;class Y&gt; shared_ptr &amp; operator=(shared_ptr&lt;Y&gt; const &amp; r); // never throws
-template&lt;class Y&gt; shared_ptr &amp; operator=(std::auto_ptr&lt;Y&gt; &amp; r);</pre>
-        <blockquote>
-            <p><b>Effects:</b> Equivalent to <code>shared_ptr(r).swap(*this)</code>.</p>
-            <p><b>Returns:</b> <code>*this</code>.</p>
-            <p><b>Notes:</b> The use count updates caused by the temporary object construction
-                and destruction are not considered observable side effects, and the
-                implementation is free to meet the effects (and the implied guarantees) via
-                different means, without creating a temporary. In particular, in the example:</p>
-            <pre>shared_ptr&lt;int&gt; p(new int);
-shared_ptr&lt;void&gt; q(p);
-p = p;
-q = p;
-</pre>
-            <p>both assignments may be no-ops.</p>
-        </blockquote>
-        <pre>shared_ptr &amp; operator=(shared_ptr &amp;&amp; r); // never throws
-template&lt;class Y&gt; shared_ptr &amp; operator=(shared_ptr&lt;Y&gt; &amp;&amp; r); // never throws
-template&lt;class Y&gt; shared_ptr &amp; operator=(std::auto_ptr&lt;Y&gt; &amp;&amp; r);
-template&lt;class Y, class D&gt; shared_ptr &amp; operator=(std::unique_ptr&lt;Y, D&gt; &amp;&amp; r);</pre>
-        <blockquote>
-            <p><b>Effects:</b> Equivalent to <code>shared_ptr(std::move(r)).swap(*this)</code>.</p>
-            <p><b>Returns:</b> <code>*this</code>.</p>
-        </blockquote>
-        <pre>shared_ptr &amp; operator=(std::nullptr_t); // never throws</pre>
-        <blockquote>
-            <p><b>Effects:</b> Equivalent to <code>shared_ptr().swap(*this)</code>.</p>
-            <p><b>Returns:</b> <code>*this</code>.</p>
-        </blockquote>
-        <h3 id="reset">reset</h3>
-        <pre>void reset(); // never throws</pre>
-        <blockquote>
-            <p><b>Effects:</b> Equivalent to <code>shared_ptr().swap(*this)</code>.</p>
-        </blockquote>
-        <pre>template&lt;class Y&gt; void reset(Y * p);</pre>
-        <blockquote>
-            <p><b>Effects:</b> Equivalent to <code>shared_ptr(p).swap(*this)</code>.</p>
-        </blockquote>
-        <pre>template&lt;class Y, class D&gt; void reset(Y * p, D d);</pre>
-        <blockquote>
-            <p><b>Effects:</b> Equivalent to <code>shared_ptr(p, d).swap(*this)</code>.</p>
-        </blockquote>
-        <pre>template&lt;class Y, class D, class A&gt; void reset(Y * p, D d, A a);</pre>
-        <blockquote>
-            <p><b>Effects:</b> Equivalent to <code>shared_ptr(p, d, a).swap(*this)</code>.</p>
-        </blockquote>
-        <pre>template&lt;class Y&gt; void reset(shared_ptr&lt;Y&gt; const &amp; r, element_type * p); // never throws</pre>
-        <blockquote>
-            <p><b>Effects:</b> Equivalent to <code>shared_ptr(r, p).swap(*this)</code>.</p>
-        </blockquote>
-        <h3 id="indirection">indirection</h3>
-        <pre>T &amp; operator*() const; // never throws</pre>
-        <blockquote>
-            <p><b>Requirements:</b> <code>T</code> should not be an array type. The stored pointer must not be 0.</p>
-            <p><b>Returns:</b> a reference to the object pointed to by the stored pointer.</p>
-            <p><b>Throws:</b> nothing.</p>
-        </blockquote>
-        <pre>T * operator-&gt;() const; // never throws</pre>
-        <blockquote>
-            <p><b>Requirements:</b> <code>T</code> should not be an array type. The stored pointer must not be 0.</p>
-            <p><b>Returns:</b> the stored pointer.</p>
-            <p><b>Throws:</b> nothing.</p>
-        </blockquote>
-        <pre>element_type &amp; operator[](std::ptrdiff_t i) const; // never throws</pre>
-        <blockquote>
-            <p><b>Requirements:</b> <code>T</code> should be an array type. The stored pointer must not be 0.
-                <code>i &gt;= 0</code>. If <code>T</code> is <code>U[N]</code>, <code>i &lt; N</code>.</p>
-            <p><b>Returns:</b> <code>get()[i]</code>.</p>
-            <p><b>Throws:</b> nothing.</p>
-        </blockquote>
-        <h3 id="get">get</h3>
-        <pre>element_type * get() const; // never throws</pre>
-        <blockquote>
-            <p><b>Returns:</b> the stored pointer.</p>
-            <p><b>Throws:</b> nothing.</p>
-        </blockquote>
-        <h3 id="unique">unique</h3>
-        <pre>bool unique() const; // never throws</pre>
-        <blockquote>
-            <p><b>Returns:</b> <code>use_count() == 1</code>.</p>
-            <p><b>Throws:</b> nothing.</p>
-            <p><b>Notes:</b> <code>unique()</code> may be faster than <code>use_count()</code>.
-                If you are using <code>unique()</code> to implement copy on write, do not rely
-                on a specific value when the stored pointer is zero.</p>
-        </blockquote>
-        <h3 id="use_count">use_count</h3>
-        <pre>long use_count() const; // never throws</pre>
-        <blockquote>
-            <p><b>Returns:</b> the number of <code>shared_ptr</code> objects, <code>*this</code> included,
-                that <i>share ownership</i> with <code>*this</code>, or 0 when <code>*this</code>
-                is <em>empty</em>.</p>
-            <p><b>Throws:</b> nothing.</p>
-            <p><b>Notes:</b> <code>use_count()</code> is not necessarily efficient. Use only
-                for debugging and testing purposes, not for production code.</p>
-        </blockquote>
-        <h3 id="conversions">conversions</h3>
-        <pre>explicit operator bool() const; // never throws</pre>
-        <blockquote>
-            <p><b>Returns:</b> <code>get() != 0</code>.</p>
-            <p><b>Throws:</b> nothing.</p>
-            <p><b>Notes:</b> This conversion operator allows <code>shared_ptr</code> objects to be
-                used in boolean contexts, like <code>if(p &amp;&amp; p-&gt;valid()) {}</code>.</p>
-        </blockquote>
-        <p><em>[The conversion to bool is not merely syntactic sugar. It allows <code>shared_ptr</code>s
-            to be declared in conditions when using <a href="#dynamic_pointer_cast">dynamic_pointer_cast</a>
-            or <a href="weak_ptr.htm#lock">weak_ptr::lock</a>.]</em></p>
-        <h3 id="swap">swap</h3>
-        <pre>void swap(shared_ptr &amp; b); // never throws</pre>
-        <blockquote>
-            <p><b>Effects:</b> Exchanges the contents of the two smart pointers.</p>
-            <p><b>Throws:</b> nothing.</p>
-        </blockquote>
-        <h3 id="owner_before">swap</h3>
-        <pre>template&lt;class Y&gt; bool owner_before(shared_ptr&lt;Y&gt; const &amp; rhs) const; // never throws
-template&lt;class Y&gt; bool owner_before(weak_ptr&lt;Y&gt; const &amp; rhs) const; // never throws</pre>
-        <blockquote>
-            <p><b>Effects:</b> See the description of <a href="#comparison"><code>operator&lt;</code></a>.</p>
-            <p><b>Throws:</b> nothing.</p>
-        </blockquote>
-        <h2 id="functions">Free Functions</h2>
-        <h3 id="comparison">comparison</h3>
-        <pre>template&lt;class T, class U&gt;
-  bool operator==(shared_ptr&lt;T&gt; const &amp; a, shared_ptr&lt;U&gt; const &amp; b); // never throws</pre>
-        <blockquote>
-            <p><b>Returns:</b> <code>a.get() == b.get()</code>.</p>
-            <p><b>Throws:</b> nothing.</p>
-        </blockquote>
-        <pre>template&lt;class T, class U&gt;
-  bool operator!=(shared_ptr&lt;T&gt; const &amp; a, shared_ptr&lt;U&gt; const &amp; b); // never throws</pre>
-        <blockquote>
-            <p><b>Returns:</b> <code>a.get() != b.get()</code>.</p>
-            <p><b>Throws:</b> nothing.</p>
-        </blockquote>
-        <pre>template&lt;class T&gt;
-  bool operator==(shared_ptr&lt;T&gt; const &amp; p, std::nullptr_t); // never throws
-template&lt;class T&gt;
-  bool operator==(std::nullptr_t, shared_ptr&lt;T&gt; const &amp; p); // never throws</pre>
-        <blockquote>
-            <p><b>Returns:</b> <code>p.get() == 0</code>.</p>
-            <p><b>Throws:</b> nothing.</p>
-        </blockquote>
-        <pre>template&lt;class T&gt;
-  bool operator!=(shared_ptr&lt;T&gt; const &amp; p, std::nullptr_t); // never throws
-template&lt;class T&gt;
-  bool operator!=(std::nullptr_t, shared_ptr&lt;T&gt; const &amp; p); // never throws</pre>
-        <blockquote>
-            <p><b>Returns:</b> <code>p.get() != 0</code>.</p>
-            <p><b>Throws:</b> nothing.</p>
-        </blockquote>
-        <pre>template&lt;class T, class U&gt;
-  bool operator&lt;(shared_ptr&lt;T&gt; const &amp; a, shared_ptr&lt;U&gt; const &amp; b); // never throws</pre>
-        <blockquote>
-            <p><b>Returns:</b> an unspecified value such that</p>
-            <ul>
-                <li>
-                    <code>operator&lt;</code> is a strict weak ordering as described in section 25.3 <code>[lib.alg.sorting]</code>
-                    of the C++ standard;</li>
-                <li>
-                    under the equivalence relation defined by <code>operator&lt;</code>, <code>!(a
-                    &lt; b) &amp;&amp; !(b &lt; a)</code>, two <code>shared_ptr</code> instances
-                    are equivalent if and only if they <em>share ownership</em> or are both <em>empty</em>.</li></ul>
-            <p><b>Throws:</b> nothing.</p>
-            <p><b>Notes:</b> Allows <code>shared_ptr</code> objects to be used as keys in
-                associative containers.</p>
-        </blockquote>
-        <p><em>[<code>Operator&lt;</code> has been preferred over a <code>std::less</code>
-                specialization for consistency and legality reasons, as <code>std::less</code>
-                is required to return the results of <code>operator&lt;</code>, and many
-                standard algorithms use <code>operator&lt;</code> instead of <code>std::less</code>
-                for comparisons when a predicate is not supplied. Composite objects, like <code>std::pair</code>,
-                also implement their <code>operator&lt;</code> in terms of their contained
-                subobjects' <code>operator&lt;</code>.</em></p>
-        <p><em>The rest of the comparison operators are omitted by design.]</em></p>
-        <h3 id="free-swap">swap</h3>
-        <pre>template&lt;class T&gt;
-  void swap(shared_ptr&lt;T&gt; &amp; a, shared_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>
-        <p><em>[<code>swap</code> is defined in the same namespace as <code>shared_ptr</code>
-            as this is currently the only legal way to supply a <code>swap</code> function
-            that has a chance to be used by the standard library.]</em></p>
-        <h3 id="get_pointer">get_pointer</h3>
-        <pre>template&lt;class T&gt;
-  typename shared_ptr&lt;T&gt;::element_type * get_pointer(shared_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>
-        <h3 id="static_pointer_cast">static_pointer_cast</h3>
-        <pre>template&lt;class T, class U&gt;
-  shared_ptr&lt;T&gt; static_pointer_cast(shared_ptr&lt;U&gt; const &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>shared_ptr&lt;T&gt;( r, static_cast&lt;typename shared_ptr&lt;T&gt;::element_type*&gt;(r.get()) )</code>.</p>
-            <p><b>Throws:</b> nothing.</p>
-            <p><b>Notes:</b> the seemingly equivalent expression
-                <code>shared_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;
-  shared_ptr&lt;T&gt; const_pointer_cast(shared_ptr&lt;U&gt; const &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>shared_ptr&lt;T&gt;( r, const_cast&lt;typename shared_ptr&lt;T&gt;::element_type*&gt;(r.get()) )</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;
-  shared_ptr&lt;T&gt; dynamic_pointer_cast(shared_ptr&lt;U&gt; const &amp; r);</pre>
-        <blockquote>
-            <p><b>Requires:</b> The expression <code>dynamic_cast&lt;T*&gt;( (U*)0 )</code>
-                must be well-formed.</p>
-            <p><b>Returns:</b></p>
-            <ul>
-                <li>
-                    When <code>dynamic_cast&lt;typename shared_ptr&lt;T&gt;::element_type*&gt;(r.get())</code> returns a nonzero value <code>p</code>,
-                    <code>shared_ptr&lt;T&gt;(r, p)</code>;</li>
-                <li>
-                    Otherwise, <code>shared_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;
-  shared_ptr&lt;T&gt; reinterpret_pointer_cast(shared_ptr&lt;U&gt; const &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>shared_ptr&lt;T&gt;( r, reinterpret_cast&lt;typename shared_ptr&lt;T&gt;::element_type*&gt;(r.get()) )</code>.</p>
-            <p><b>Throws:</b> nothing.</p>
-        </blockquote>
-        <h3 id="insertion-operator">operator&lt;&lt;</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, shared_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>
-        <h3 id="get_deleter">get_deleter</h3>
-        <pre>template&lt;class D, class T&gt;
-    D * get_deleter(shared_ptr&lt;T&gt; const &amp; p);</pre>
-        <blockquote>
-            <p><b>Returns:</b> If <code>*this</code> <em>owns</em> a deleter <code>d</code>
-                of type (cv-unqualified) <code>D</code>, returns <code>&amp;d</code>;
-                otherwise returns 0.</p>
-            <p><b>Throws:</b> nothing.</p>
-        </blockquote>
-        <h2 id="example">Example</h2>
-        <p>See <a href="example/shared_ptr_example.cpp">shared_ptr_example.cpp</a> for a
-            complete example program. The program builds a <code>std::vector</code> and <code>std::set</code>
-            of <code>shared_ptr</code> objects.</p>
-        <p>Note that after the containers have been populated, some of the <code>shared_ptr</code>
-            objects will have a use count of 1 rather than a use count of 2, since the set
-            is a <code>std::set</code> rather than a <code>std::multiset</code>, and thus does not
-            contain duplicate entries. Furthermore, the use count may be even higher at
-            various times while <code>push_back</code> and <code>insert</code> container operations are
-            performed. More complicated yet, the container operations may throw exceptions
-            under a variety of circumstances. Getting the memory management and exception
-            handling in this example right without a smart pointer would be a nightmare.</p>
-        <h2 id="HandleBody">Handle/Body Idiom</h2>
-        <p>One common usage of <code>shared_ptr</code> is to implement a handle/body (also called
-            pimpl) idiom which avoids exposing the body (implementation) in the header
-            file.</p>
-        <p>The <a href="example/shared_ptr_example2_test.cpp">shared_ptr_example2_test.cpp</a>
-            sample program includes a header file, <a href="example/shared_ptr_example2.hpp">shared_ptr_example2.hpp</a>,
-            which uses a <code>shared_ptr</code> to an incomplete type to hide the
-            implementation. The instantiation of member functions which require a complete
-            type occurs in the <a href="example/shared_ptr_example2.cpp">shared_ptr_example2.cpp</a>
-            implementation file. Note that there is no need for an explicit destructor.
-            Unlike <code>~scoped_ptr</code>, <code>~shared_ptr</code> does not require that <code>T</code> be a complete
-            type.</p>
-        <h2 id="ThreadSafety">Thread Safety</h2>
-        <p><code>shared_ptr</code> objects offer the same level of thread safety as
-            built-in types. A <code>shared_ptr</code> instance can be "read" (accessed
-            using only const operations) simultaneously by multiple threads. Different <code>shared_ptr</code>
-            instances can be "written to" (accessed using mutable operations such as <code>operator=
-            </code>or <code>reset</code>) simultaneously by multiple threads (even
-            when these instances are copies, and share the same reference count
-            underneath.)</p>
-        <p>Any other simultaneous accesses result in undefined behavior.</p>
-        <p>Examples:</p>
-        <pre>shared_ptr&lt;int&gt; p(new int(42));
-
-//--- Example 1 ---
-
-// thread A
-shared_ptr&lt;int&gt; p2(p); // reads p
-
-// thread B
-shared_ptr&lt;int&gt; p3(p); // OK, multiple reads are safe
-
-//--- Example 2 ---
-
-// thread A
-p.reset(new int(1912)); // writes p
-
-// thread B
-p2.reset(); // OK, writes p2
-
-//--- Example 3 ---
-
-// thread A
-p = p3; // reads p3, writes p
-
-// thread B
-p3.reset(); // writes p3; undefined, simultaneous read/write
-
-//--- Example 4 ---
-
-// thread A
-p3 = p2; // reads p2, writes p3
-
-// thread B
-// p2 goes out of scope: undefined, the destructor is considered a "write access"
-
-//--- Example 5 ---
-
-// thread A
-p3.reset(new int(1));
-
-// thread B
-p3.reset(new int(2)); // undefined, multiple writes
-</pre>
-        <p>&nbsp;</p>
-        <p>Starting with Boost release 1.33.0, <code>shared_ptr</code> uses a lock-free
-            implementation on most common platforms.</p>
-        <p>If your program is single-threaded and does not link to any libraries that might
-            have used <code>shared_ptr</code> in its default configuration, you can <code>
-            #define</code> the macro <code>BOOST_SP_DISABLE_THREADS</code> on a
-            project-wide basis to switch to ordinary non-atomic reference count updates.</p>
-        <p>(Defining <code>BOOST_SP_DISABLE_THREADS</code> in some, but not all,
-            translation units is technically a violation of the One Definition Rule and
-            undefined behavior. Nevertheless, the implementation attempts to do its best to
-            accommodate the request to use non-atomic updates in those translation units.
-            No guarantees, though.)</p>
-        <p>You can define the macro <code>BOOST_SP_USE_PTHREADS</code> to turn off the
-            lock-free platform-specific implementation and fall back to the generic
-            <code>pthread_mutex_t</code>-based code.</p>
-        <h2 id="FAQ">Frequently Asked Questions</h2>
-        <p><b>Q.</b> There are several variations of shared pointers, with different
-            tradeoffs; why does the smart pointer library supply only a single
-            implementation? It would be useful to be able to experiment with each type so
-            as to find the most suitable for the job at hand?</p>
-        <p>
-            <b>A.</b> An important goal of <code>shared_ptr</code> is to provide a
-            standard shared-ownership pointer. Having a single pointer type is important
-            for stable library interfaces, since different shared pointers typically cannot
-            interoperate, i.e. a reference counted pointer (used by library A) cannot share
-            ownership with a linked pointer (used by library B.)
-        </p>
-        <p><b>Q.</b> Why doesn't <code>shared_ptr</code> have template parameters supplying
-            traits or policies to allow extensive user customization?</p>
-        <p>
-            <b>A.</b> Parameterization discourages users. The <code>shared_ptr</code> template is
-            carefully crafted to meet common needs without extensive parameterization. Some
-            day a highly configurable smart pointer may be invented that is also very easy
-            to use and very hard to misuse. Until then, <code>shared_ptr</code> is the smart
-            pointer of choice for a wide range of applications. (Those interested in policy
-            based smart pointers should read <a href="http://www.awprofessional.com/bookstore/product.asp?isbn=0201704315&amp;rl=1">
-            Modern C++ Design</a> by Andrei Alexandrescu.)
-        </p>
-        <p><b>Q.</b> I am not convinced. Default parameters can be used where appropriate
-            to hide the complexity. Again, why not policies?</p>
-        <p>
-            <b>A.</b> Template parameters affect the type. See the answer to the first
-            question above.
-        </p>
-        <p><b>Q.</b> Why doesn't <code>shared_ptr</code> use a linked list implementation?</p>
-        <p>
-            <b>A.</b> A linked list implementation does not offer enough advantages to
-            offset the added cost of an extra pointer. See <a href="smarttests.htm">timings</a>
-            page. In addition, it is expensive to make a linked list implementation thread
-            safe.
-        </p>
-        <p><b>Q.</b> Why doesn't <code>shared_ptr</code> (or any of the other Boost smart
-            pointers) supply an automatic conversion to <code>T*</code>?</p>
-        <p>
-            <b>A.</b> Automatic conversion is believed to be too error prone.
-        </p>
-        <p><b>Q.</b> Why does <code>shared_ptr</code> supply <code>use_count()</code>?</p>
-        <p>
-            <b>A.</b> As an aid to writing test cases and debugging displays. One of the
-            progenitors had <code>use_count()</code>, and it was useful in tracking down bugs in a
-            complex project that turned out to have cyclic-dependencies.
-        </p>
-        <p><b>Q.</b> Why doesn't <code>shared_ptr</code> specify complexity requirements?</p>
-        <p>
-            <b>A.</b> Because complexity requirements limit implementors and complicate the
-            specification without apparent benefit to <code>shared_ptr</code> users. For example,
-            error-checking implementations might become non-conforming if they had to meet
-            stringent complexity requirements.
-        </p>
-        <p><b>Q.</b> Why doesn't <code>shared_ptr</code> provide a <code>release()</code> function?</p>
-        <p>
-            <b>A.</b> <code>shared_ptr</code> cannot give away ownership unless it's <code>unique()</code>
-            because the other copy will still destroy the object.</p>
-        <p>Consider:</p>
-        <blockquote><pre>shared_ptr&lt;int&gt; a(new int);
-shared_ptr&lt;int&gt; b(a); // a.use_count() == b.use_count() == 2
-
-int * p = a.release();
-
-// Who owns p now? b will still call delete on it in its destructor.</pre>
-        </blockquote>
-        <p>Furthermore, the pointer returned by <code>release()</code> would be difficult
-            to deallocate reliably, as the source <code>shared_ptr</code> could have been created
-            with a custom deleter.
-        </p>
-        <p><b>Q.</b> Why is <code>operator-&gt;()</code> const, but its return value is a
-            non-const pointer to the element type?</p>
-        <p>
-            <b>A.</b> Shallow copy pointers, including raw pointers, typically don't
-            propagate constness. It makes little sense for them to do so, as you can always
-            obtain a non-const pointer from a const one and then proceed to modify the
-            object through it. <code>shared_ptr</code> is "as close to raw pointers as possible
-            but no closer".
-        </p>
-        <hr>
-        <p>$Date$</p>
-        <p><small>Copyright 1999 Greg Colvin and Beman Dawes. Copyright 2002 Darin Adler.
-            Copyright 2002-2005, 2012, 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>
-    </body>
-</html>

smart_ptr.htm

@@ -1,224 +0,0 @@
-<!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">
-    </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>
-        <p><a href="#Introduction">Introduction</a><br>
-            <a href="#common_requirements">Common Requirements</a><br>
-            <a href="#Exception_Safety">Exception Safety</a><br>
-            <a href="#Exception-specifications">Exception-specifications</a><br>
-            <a href="#History">History and Acknowledgements</a><br>
-            <a href="#References">References</a></p>
-        <h2><a name="Introduction">Introduction</a></h2>
-        <p>Smart pointers are objects which store pointers to dynamically allocated (heap)
-            objects. They behave much like built-in C++ pointers except that they
-            automatically delete the object pointed to at the appropriate time. Smart
-            pointers are particularly useful in the face of exceptions as they ensure
-            proper destruction of dynamically allocated objects. They can also be used to
-            keep track of dynamically allocated objects shared by multiple owners.</p>
-        <p>Conceptually, smart pointers are seen as owning the object pointed to, and thus
-            responsible for deletion of the object when it is no longer needed.</p>
-        <p>The smart pointer library provides six smart pointer class templates:</p>
-        <div align="left">
-            <table border="1" cellpadding="4" cellspacing="0">
-                <tr>
-                    <td><a href="scoped_ptr.htm"><b>scoped_ptr</b></a></td>
-                    <td><a href="../../boost/scoped_ptr.hpp">&lt;boost/scoped_ptr.hpp&gt;</a></td>
-                    <td>Simple sole ownership of single objects. Noncopyable.</td>
-                </tr>
-                <tr>
-                    <td><a href="scoped_array.htm"><b>scoped_array</b></a></td>
-                    <td><a href="../../boost/scoped_array.hpp">&lt;boost/scoped_array.hpp&gt;</a></td>
-                    <td>Simple sole ownership of arrays. Noncopyable.</td>
-                </tr>
-                <tr>
-                    <td><a href="shared_ptr.htm"><b>shared_ptr</b></a></td>
-                    <td><a href="../../boost/shared_ptr.hpp">&lt;boost/shared_ptr.hpp&gt;</a></td>
-                    <td>Object ownership shared among multiple pointers.</td>
-                </tr>
-                <tr>
-                    <td><a href="shared_array.htm"><b>shared_array</b></a></td>
-                    <td><a href="../../boost/shared_array.hpp">&lt;boost/shared_array.hpp&gt;</a></td>
-                    <td>Array ownership shared among multiple pointers.</td>
-                </tr>
-                <tr>
-                    <td><a href="weak_ptr.htm"><b>weak_ptr</b></a></td>
-                    <td><a href="../../boost/weak_ptr.hpp">&lt;boost/weak_ptr.hpp&gt;</a></td>
-                    <td>Non-owning observers of an object owned by <b>shared_ptr</b>.</td>
-                </tr>
-                <tr>
-                    <td><a href="intrusive_ptr.html"><b>intrusive_ptr</b></a></td>
-                    <td><a href="../../boost/intrusive_ptr.hpp">&lt;boost/intrusive_ptr.hpp&gt;</a></td>
-                    <td>Shared ownership of objects with an embedded reference count.</td>
-                </tr>
-            </table>
-        </div>
-        <p>These templates are designed to complement the <b>std::auto_ptr</b> template.</p>
-        <p>They are examples of the "resource acquisition is initialization" idiom
-            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>
-        <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="../../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
-            provided to verify correct operation.</p>
-        <p>A page on <a href="compatibility.htm">compatibility</a> with older versions of
-            the Boost smart pointer library describes some of the changes since earlier
-            versions of the smart pointer implementation.</p>
-        <p>A page on <a href="smarttests.htm">smart pointer timings</a> will be of interest
-            to those curious about performance issues.</p>
-        <P>A page on <A href="sp_techniques.html">smart pointer programming techniques</A> lists
-            some advanced applications of <code>shared_ptr</code> and <code>weak_ptr</code>.</P>
-        <h2><a name="common_requirements">Common Requirements</a></h2>
-        <p>These smart pointer class templates have a template parameter, <b>T</b>, which
-            specifies the type of the object pointed to by the smart pointer. The behavior
-            of the smart pointer templates is undefined if the destructor or <b>operator delete</b>
-            for objects of type <b>T</b> throw exceptions.</p>
-        <p><b>T</b> may be an incomplete type at the point of smart pointer declaration.
-            Unless otherwise specified, it is required that <b>T</b> be a complete type at
-            points of smart pointer instantiation. Implementations are required to diagnose
-            (treat as an error) all violations of this requirement, including deletion of
-            an incomplete type. See the description of the <a href="../utility/utility.htm#checked_delete">
-            <b>checked_delete</b></a> function template.</p>
-        <P>Note that <STRONG>shared_ptr</STRONG> does not have this restriction, as most of
-            its member functions do not require <STRONG>T</STRONG> to be a complete type.</P>
-        <h3>Rationale</h3>
-        <p>The requirements on <b>T</b> are carefully crafted to maximize safety yet allow
-            handle-body (also called pimpl) and similar idioms. In these idioms a smart
-            pointer may appear in translation units where <b>T</b> is an incomplete type.
-            This separates interface from implementation and hides implementation from
-            translation units which merely use the interface. Examples described in the
-            documentation for specific smart pointers illustrate use of smart pointers in
-            these idioms.</p>
-        <p>Note that <b>scoped_ptr</b> requires that <b>T</b> be a complete type at
-            destruction time, but <b>shared_ptr</b> does not.</p>
-        <h2><a name="Exception_Safety">Exception Safety</a></h2>
-        <p>Several functions in these smart pointer classes are specified as having "no
-            effect" or "no effect except such-and-such" if an exception is thrown. This
-            means that when an exception is thrown by an object of one of these classes,
-            the entire program state remains the same as it was prior to the function call
-            which resulted in the exception being thrown. This amounts to a guarantee that
-            there are no detectable side effects. Other functions never throw exceptions.
-            The only exception ever thrown by functions which do throw (assuming <b>T</b> meets
-            the <a href="#common_requirements">common requirements</a>) is <b>std::bad_alloc</b>,
-            and that is thrown only by functions which are explicitly documented as
-            possibly throwing <b>std::bad_alloc</b>.</p>
-        <h2><a name="Exception-specifications">Exception-specifications</a></h2>
-        <p>Exception-specifications are not used; see <a href="http://www.boost.org/more/lib_guide.htm#Exception-specification">
-            exception-specification rationale</a>.</p>
-        <p>All the smart pointer templates contain member functions which can never throw
-            exceptions, because they neither throw exceptions themselves nor call other
-            functions which may throw exceptions. These members are indicated by a comment: <code>
-            // never throws</code>.
-        </p>
-        <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
-            changes.</p>
-        <p>May 2001. Vladimir Prus suggested requiring a complete type on destruction.
-            Refinement evolved in discussions including Dave Abrahams, Greg Colvin, Beman
-            Dawes, Rainer Deyke, Peter Dimov, John Maddock, Vladimir Prus, Shankar Sai, and
-            others.</p>
-        <p>November 1999. Darin Adler provided <b>operator ==</b>, <b>operator !=</b>, and <b>std::swap</b>
-            and <b>std::less</b> specializations for shared types.</p>
-        <p>September 1999. Luis Coelho provided <b>shared_ptr::swap</b> and <b>shared_array::swap</b></p>
-        <p>May 1999. In April and May, 1999, Valentin Bonnard and David Abrahams made a
-            number of suggestions resulting in numerous improvements.</p>
-        <p>October 1998. Beman Dawes proposed reviving the original semantics under the
-            names <b>safe_ptr</b> and <b>counted_ptr</b>, meeting of Per Andersson, Matt
-            Austern, Greg Colvin, Sean Corfield, Pete Becker, Nico Josuttis, Dietmar K&uuml;hl,
-            Nathan Myers, Chichiang Wan and Judy Ward. During the discussion, the four new
-            class names were finalized, it was decided that there was no need to exactly
-            follow the <b>std::auto_ptr</b> interface, and various function signatures and
-            semantics were finalized.</p>
-        <p>Over the next three months, several implementations were considered for <b>shared_ptr</b>,
-            and discussed on the <a href="http://www.boost.org">boost.org</a> mailing list.
-            The implementation questions revolved around the reference count which must be
-            kept, either attached to the pointed to object, or detached elsewhere. Each of
-            those variants have themselves two major variants:
-            <ul>
-                <li>
-                Direct detached: the shared_ptr contains a pointer to the object, and a pointer
-                to the count.
-                <li>
-                Indirect detached: the shared_ptr contains a pointer to a helper object, which
-                in turn contains a pointer to the object and the count.
-                <li>
-                Embedded attached: the count is a member of the object pointed to.
-                <li>
-                Placement attached: the count is attached via operator new manipulations.</li>
-            </ul>
-        <p>Each implementation technique has advantages and disadvantages. We went so far
-            as to run various timings of the direct and indirect approaches, and found that
-            at least on Intel Pentium chips there was very little measurable difference.
-            Kevlin Henney provided a paper he wrote on "Counted Body Techniques." Dietmar
-            K&uuml;hl suggested an elegant partial template specialization technique to allow
-            users to choose which implementation they preferred, and that was also
-            experimented with.</p>
-        <p>But Greg Colvin and Jerry Schwarz argued that "parameterization will discourage
-            users", and in the end we choose to supply only the direct implementation.</p>
-        <p>Summer, 1994. Greg Colvin proposed to the C++ Standards Committee classes named <b>auto_ptr</b>
-            and <b>counted_ptr</b> which were very similar to what we now call <b>scoped_ptr</b>
-            and <b>shared_ptr</b>. <a href="#Col-94">[Col-94]</a> In one of the very few
-            cases where the Library Working Group's recommendations were not followed by
-            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">
-            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">
-            Safe, Efficient Garbage Collection for C++</a>, Usenix Proceedings,
-            February, 1994. This paper includes an extensive discussion of weak pointers
-            and an extensive bibliography.</p>
-        <hr>
-        <p>$Date$</p>
-        <p><small>Copyright 1999 Greg Colvin and Beman Dawes. 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>
-    </body>
-</html>

smarttests.htm

@@ -1,542 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-
-<html>
-
-<head>
-<title>Smart Pointer Timings</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 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 
-  to join together all instances of smart pointers sharing a given raw pointer. 
-  This allowed avoidance of the costly heap allocation of a reference count that 
-  occurred in the initial construction of the then current version of boost::shared_ptr. 
-  Of course, nothing is for free and the benefit here was gained at the expense 
-  of increased size and more costly copy operations. A debate ensued on the boost 
-  mailing list and the tests which this page describes were performed to provide 
-  a guide for current and future investigations into smart pointer implementation 
-  strategies.</p>
-<p>Thanks are due to <a href="http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a>,
-Gavin Collings,
-<a href="http://www.boost.org/people/greg_colvin.htm">Greg Colvin</a> and
-<a href="http://www.boost.org/people/beman_dawes.html">Beman Dawes</a> 
-  for test code and trial implementations, the final version of which can be found 
-  in .zip format <a href="smarttest.zip">here</a>.</p>
-<h2>Description</h2>
-<p>Two tests were run: the first aimed to obtain timings for two basic individual 
-  operations:</p>
-<ol type="i">
-  <li> Initial construction from raw pointer.</li>
-  <li> An amortized copy operation consisting of half an assignment and half a 
-    copy construction - designed to reflect average usage.</li>
-</ol>
-<p>The second attempted to gain more insight into normal usage by timing the fill 
-  and sort algorithms for vectors and lists filled with the various smart pointers.</p>
-<p>Five smart pointer implementation strategies were tested:</p>
-<ol type="i">
-  <li>Counted pointer using a heap allocated reference count, this is referred 
-    to as <b>simple counted</b>.</li>
-  <li>Counted pointer using a special purpose allocator for the reference count 
-    - <b>special counted</b>.</li>
-  <li>Counted pointer using an intrusive reference count - <b>intrusive</b>.</li>
-  <li>Linked pointer as described above - <b>linked</b>.</li>
-  <li>Cyclic pointer, a counted implementation using a std::deque for allocation 
-    with provision for weak pointers and garbage collection of cycles of pointers 
-    - <b>cyclic</b>.</li>
-</ol>
-<p>on two compilers:</p>
-<ol type="i">
-  <li>MSVC 6.0 service pack 3, using default release optimization mode (/O2 - 
-    optimized for speed, no inlining of functions defined outside a class body 
-    unless specified as inline).</li>
-  <li>gcc 2.95.2 using full optimization (-O3 -DNDEBUG).</li>
-</ol>
-<p>Additionally, generated pointer sizes (taking into account struct alignment) 
-  were compared, as were generated code sizes for MSVC mainly by manual inspection 
-  of generated assembly code - a necessity due to function inlining.</p>
-<p>All tests were run on a PII-200 running Windows NT version 4.0</p>
-<h2>&nbsp;</h2>
-<h2>Operation Timing Test Results</h2>
-<p>The following graphs show the overall time in nanoseconds to acquire a pointer 
-  (default construction) perform n amortized copy operations on it and finally 
-  release it. The initial allocation time for the contained pointer is not included, 
-  although the time for it's deallocation is. The contained pointer pointed to 
-  a trivial class, but for the inclusion of an intrusive reference count for the 
-  benefit of the intrusive counted shared pointer. A dumb pointer (i.e. a smart 
-  pointer that simply acquires and releases its contained pointer with no extra 
-  overhead) and a raw pointer were also included for comparison.</p>
-<table border="0" align="center">
-  <tr> 
-    <td width="20" height="20">&nbsp;</td>
-    <td>&nbsp;</td>
-    <td width="20">&nbsp;</td>
-  </tr>
-  <tr> 
-    <td width="20">&nbsp; </td>
-    <td><img src="msvcspeed.gif" width="560" height="355" alt="MSVC speed graph"></td>
-    <td width="20">&nbsp;</td>
-  </tr>
-  <tr> 
-    <td height="20">&nbsp;</td>
-    <td>&nbsp;</td>
-    <td>&nbsp;</td>
-  </tr>
-  <tr> 
-    <td>&nbsp;</td>
-    <td><img src="gccspeed.gif" width="560" height="355" alt="GCC speed graph"></td>
-    <td>&nbsp;</td>
-  </tr>
-  <tr> 
-    <td height="20">&nbsp;</td>
-    <td>&nbsp;</td>
-    <td>&nbsp;</td>
-  </tr>
-</table>
-<p>&nbsp;</p>
-<p>Fitting straight lines to the above plots gives the following figures for initialization 
-  and amortized copy operation for the two compilers (times in nanoseconds, errors 
-  at two standard deviations) : -</p>
-<p>&nbsp;</p>
-<h4 align="center">MSVC</h4>
-<table align="center" cellpadding="5" cellspacing="0" class="codetable" width="400">
-  <tr> 
-    <th width="120"> 
-      <div align="right"></div>
-    </th>
-    <th class="codetabletop" width="120"> 
-      <div align="center">initialization</div>
-    </th>
-    <th class="codetabletop" width="120">copy operation</th>
-  </tr>
-  <tr> 
-    <th class="codetableleft"> 
-      <div align="right">simple counted</div>
-    </th>
-    <td class="codetablecell" align="center">3000 +/- 170</td>
-    <td class="codetablecell" align="center">104 +/- 31</td>
-  </tr>
-  <tr> 
-    <th class="codetableleft"> 
-      <div align="right">special counted</div>
-    </th>
-    <td class="codetablecell" align="center">1330 +/- 50</td>
-    <td class="codetablecell" align="center">85 +/- 9</td>
-  </tr>
-  <tr> 
-    <th class="codetableleft"> 
-      <div align="right">intrusive</div>
-    </th>
-    <td class="codetablecell" align="center">1000 +/- 20</td>
-    <td class="codetablecell" align="center">71 +/- 3</td>
-  </tr>
-  <tr> 
-    <th class="codetableleft" align="right">linked</th>
-    <td class="codetablecell" align="center">970 +/- 60</td>
-    <td class="codetablecell" align="center">136 +/- 10</td>
-  </tr>
-  <tr>
-    <th class="codetableleft" align="right">cyclic</th>
-    <td class="codetablecell" align="center">1290 +/- 70</td>
-    <td class="codetablecell" align="center">112 +/- 12</td>
-  </tr>
-  <tr> 
-    <th class="codetableleft" align="right">dumb</th>
-    <td class="codetablecell" align="center">1020 +/- 20</td>
-    <td class="codetablecell" align="center">10 +/- 4</td>
-  </tr>
-  <tr> 
-    <th class="codetableleft"> 
-      <div align="right">raw</div>
-    </th>
-    <td class="codetablecell" align="center">1038 +/- 30</td>
-    <td class="codetablecell" align="center">10 +/- 5</td>
-  </tr>
-</table>
-<h4 align="center">&nbsp;</h4>
-<h4 align="center">GCC</h4>
-<table align="center" cellpadding="5" cellspacing="0" class="codetable" width="400">
-  <tr> 
-    <th width="120"> 
-      <div align="right"></div>
-    </th>
-    <th class="codetabletop" width="120"> 
-      <div align="center">initialization</div>
-    </th>
-    <th class="codetabletop" width="120">copy operation</th>
-  </tr>
-  <tr> 
-    <th class="codetableleft"> 
-      <div align="right">simple counted</div>
-    </th>
-    <td class="codetablecell" align="center">4620 +/- 150</td>
-    <td class="codetablecell" align="center">301 +/- 28</td>
-  </tr>
-  <tr> 
-    <th class="codetableleft"> 
-      <div align="right">special counted</div>
-    </th>
-    <td class="codetablecell" align="center">1990 +/- 40</td>
-    <td class="codetablecell" align="center">264 +/- 7</td>
-  </tr>
-  <tr> 
-    <th class="codetableleft"> 
-      <div align="right">intrusive</div>
-    </th>
-    <td class="codetablecell" align="center">1590 +/- 70</td>
-    <td class="codetablecell" align="center">181 +/- 12</td>
-  </tr>
-  <tr> 
-    <th class="codetableleft" align="right">linked</th>
-    <td class="codetablecell" align="center">1470 +/- 140</td>
-    <td class="codetablecell" align="center">345 +/- 26</td>
-  </tr>
-  <tr>
-    <th class="codetableleft" align="right">cyclic</th>
-    <td class="codetablecell" align="center">2180 +/- 100</td>
-    <td class="codetablecell" align="center">330 +/- 18</td>
-  </tr>
-  <tr> 
-    <th class="codetableleft" align="right">dumb</th>
-    <td class="codetablecell" align="center">1590 +/- 70</td>
-    <td class="codetablecell" align="center">74 +/- 12</td>
-  </tr>
-  <tr> 
-    <th class="codetableleft" align="right"> 
-      <div align="right">raw</div>
-    </th>
-    <td class="codetablecell" align="center">1430 +/- 60</td>
-    <td class="codetablecell" align="center">27 +/- 11</td>
-  </tr>
-</table>
-<p>Note that the above times include a certain amount of loop overhead etc. for 
-  each operation. An estimate of the pure smart pointer operation time 'overhead' 
-  can be obtained by subtracting the dumb or raw figure from the smart pointer 
-  time of interest.</p>
-<h3>Detail</h3>
-<p>The test involved iterating a loop which creates raw pointers. These were then 
-  shared among a varying number (set size) of smart pointers. A range of set sizes 
-  was used and then a line fitted to get a linear relation with number of initializations 
-  and copy-operations. A spreadsheet was used for the line fit, and to produce 
-  the performance graphs above.</p>
-<h2>&nbsp;</h2>
-<h2>Container Test Results</h2>
-<p>To gain some insight in to operation within real life programs, this test was 
-  devised. Smart pointers were used to fill standard containers which were then 
-  sorted.</p>
-<p>In this case, the contained pointer pointed to a class which initializes a 
-  private data member to a random value in its default constructor. This value 
-  is used subsequently for the sort comparison test. The class also contains an 
-  intrusive reference count for the benefit of the intrusive counted pointer.</p>
-<p> All times are in seconds for 300,000 contained pointers.</p>
-<h4 align="center">GCC</h4>
-<table align="center" cellpadding="5" cellspacing="0" class="codetable" width="500">
-  <tr> 
-    <th>&nbsp;</th>
-    <th class="codetabletop" colspan="2">vector</th>
-    <th class="codetabletop" colspan="2">list</th>
-  </tr>
-  <tr> 
-    <th width="120"> 
-      <div align="right"></div>
-    </th>
-    <th class="codetabletop2" width="80"> 
-      <div align="center">fill</div>
-    </th>
-    <th class="codetabletop2" width="80">sort</th>
-    <th class="codetabletop2" width="80">fill</th>
-    <th class="codetabletop2" width="80">sort</th>
-  </tr>
-  <tr> 
-    <th class="codetableleft"> 
-      <div align="right">simple counted</div>
-    </th>
-    <td class="codetablecell" align="center">46.54</td>
-    <td class="codetablecell" align="center">2.44</td>
-    <td class="codetablecell" align="center">47.09</td>
-    <td class="codetablecell" align="center">3.22</td>
-  </tr>
-  <tr> 
-    <th class="codetableleft"> 
-      <div align="right">special counted</div>
-    </th>
-    <td class="codetablecell" align="center">14.02</td>
-    <td class="codetablecell" align="center">2.83</td>
-    <td class="codetablecell" align="center">7.28</td>
-    <td class="codetablecell" align="center">3.21</td>
-  </tr>
-  <tr> 
-    <th class="codetableleft"> 
-      <div align="right">intrusive</div>
-    </th>
-    <td class="codetablecell" align="center">12.15</td>
-    <td class="codetablecell" align="center">1.91</td>
-    <td class="codetablecell" align="center">7.99</td>
-    <td class="codetablecell" align="center">3.08</td>
-  </tr>
-  <tr> 
-    <th class="codetableleft" align="right">linked</th>
-    <td class="codetablecell" align="center">12.46</td>
-    <td class="codetablecell" align="center">2.32</td>
-    <td class="codetablecell" align="center">8.14</td>
-    <td class="codetablecell" align="center">3.27</td>
-  </tr>
-  <tr> 
-    <th class="codetableleft" align="right">cyclic</th>
-    <td class="codetablecell" align="center">22.60</td>
-    <td class="codetablecell" align="center">3.19</td>
-    <td class="codetablecell" align="center">1.63</td>
-    <td class="codetablecell" align="center">3.18</td>
-  </tr>
-  <tr> 
-    <th class="codetableleft" align="right"> 
-      <div align="right">raw</div>
-    </th>
-    <td class="codetablecell" align="center">11.81</td>
-    <td class="codetablecell" align="center">0.24</td>
-    <td class="codetablecell" align="center">27.51</td>
-    <td class="codetablecell" align="center">0.77</td>
-  </tr>
-</table>
-<p>&nbsp;</p>
-<h4 align="center">MSVC</h4>
-<table align="center" cellpadding="5" cellspacing="0" class="codetable" width="500">
-  <tr> 
-    <th>&nbsp;</th>
-    <th class="codetabletop" colspan="2">vector</th>
-    <th class="codetabletop" colspan="2">list</th>
-  </tr>
-  <tr> 
-    <th width="120"> 
-      <div align="right"></div>
-    </th>
-    <th class="codetabletop2" width="80"> 
-      <div align="center">fill</div>
-    </th>
-    <th class="codetabletop2" width="80">sort</th>
-    <th class="codetabletop2" width="80">fill</th>
-    <th class="codetabletop2" width="80">sort</th>
-  </tr>
-  <tr> 
-    <th class="codetableleft"> 
-      <div align="right">simple counted</div>
-    </th>
-    <td class="codetablecell" align="center">1.83</td>
-    <td class="codetablecell" align="center">2.37</td>
-    <td class="codetablecell" align="center">1.86</td>
-    <td class="codetablecell" align="center">4.85</td>
-  </tr>
-  <tr> 
-    <th class="codetableleft"> 
-      <div align="right">special counted</div>
-    </th>
-    <td class="codetablecell" align="center">1.04</td>
-    <td class="codetablecell" align="center">2.35</td>
-    <td class="codetablecell" align="center">1.38</td>
-    <td class="codetablecell" align="center">4.58</td>
-  </tr>
-  <tr> 
-    <th class="codetableleft"> 
-      <div align="right">intrusive</div>
-    </th>
-    <td class="codetablecell" align="center">1.04</td>
-    <td class="codetablecell" align="center">1.84</td>
-    <td class="codetablecell" align="center">1.16</td>
-    <td class="codetablecell" align="center">4.29</td>
-  </tr>
-  <tr> 
-    <th class="codetableleft" align="right">linked</th>
-    <td class="codetablecell" align="center">1.08</td>
-    <td class="codetablecell" align="center">2.00</td>
-    <td class="codetablecell" align="center">1.21</td>
-    <td class="codetablecell" align="center">4.33</td>
-  </tr>
-  <tr> 
-    <th class="codetableleft" align="right">cyclic</th>
-    <td class="codetablecell" align="center">1.38</td>
-    <td class="codetablecell" align="center">2.84</td>
-    <td class="codetablecell" align="center">1.47</td>
-    <td class="codetablecell" align="center">4.73</td>
-  </tr>
-  <tr> 
-    <th class="codetableleft" align="right"> 
-      <div align="right">raw</div>
-    </th>
-    <td class="codetablecell" align="center">0.67</td>
-    <td class="codetablecell" align="center">0.28</td>
-    <td class="codetablecell" align="center">1.24</td>
-    <td class="codetablecell" align="center">1.81</td>
-  </tr>
-</table>
-<p>&nbsp;</p>
-<h2>Code Size</h2>
-<p>The following code sizes were determined by inspection of generated code for 
-  MSVC only. Sizes are given in the form N / M / I where:</p>
-<ul type="circle">
-  <li> N is the instruction count of the operation</li>
-  <li>M is the size of the code in bytes</li>
-  <li>I determines whether generated code was inlined or not I = inline, O = &quot;outline&quot;</li>
-</ul>
-<p>&nbsp;</p>
-<table align="center" cellpadding="5" cellspacing="0" class="codetable" width="570">
-  <tr> 
-    <th height="28" width="140"> 
-      <div align="right"></div>
-    </th>
-    <th height="28" class="codetabletop" width="80"> 
-      <div align="center">ptr()</div>
-    </th>
-    <th height="28" class="codetabletop" width="80">ptr(p)</th>
-    <th height="28" class="codetabletop" width="80">ptr(ptr)</th>
-    <th height="28" class="codetabletop" width="80">op=()</th>
-    <th height="28" class="codetabletop" width="80"> 
-      <div align="center">~ptr()</div>
-    </th>
-  </tr>
-  <tr> 
-    <th class="codetableleft"> 
-      <div align="right">simple counted</div>
-    </th>
-    <td class="codetablecell" align="center">38/110/O</td>
-    <td class="codetablecell" align="center">38/110/O</td>
-    <td class="codetablecell" align="center">9/23/I</td>
-    <td class="codetablecell" align="center">22/57/I</td>
-    <td class="codetablecell" align="center">17/40/I</td>
-  </tr>
-  <tr> 
-    <th class="codetableleft"> 
-      <div align="right">special counted</div>
-    </th>
-    <td class="codetablecell" align="center"><font size="-1">50/141/O</font></td>
-    <td class="codetablecell" align="center"><font size="-1">50/141/O</font></td>
-    <td class="codetablecell" align="center"><font size="-1">9/23/I</font></td>
-    <td class="codetablecell" align="center"><font size="-1">23/64/I</font></td>
-    <td class="codetablecell" align="center"><font size="-1">13/38/I</font></td>
-  </tr>
-  <tr> 
-    <th class="codetableleft"> 
-      <div align="right">intrusive</div>
-    </th>
-    <td class="codetablecell" align="center"><font size="-1">1/2/I</font></td>
-    <td class="codetablecell" align="center"><font size="-1">3/6/I</font></td>
-    <td class="codetablecell" align="center"><font size="-1">3/6/I</font></td>
-    <td class="codetablecell" align="center"><font size="-1">6/11/I</font></td>
-    <td class="codetablecell" align="center"><font size="-1">6/11/I</font></td>
-  </tr>
-  <tr> 
-    <th class="codetableleft"> 
-      <div align="right">linked</div>
-    </th>
-    <td class="codetablecell" align="center"><font size="-1">5/19/I</font></td>
-    <td class="codetablecell" align="center"><font size="-1">5/15/I</font></td>
-    <td class="codetablecell" align="center"><font size="-1">10/30/I</font></td>
-    <td class="codetablecell" align="center"><font size="-1">27/59/I</font></td>
-    <td class="codetablecell" align="center"><font size="-1">14/38/I</font></td>
-  </tr>
-</table>
-<p>During the code inspection, a couple of minor points were noticed: -</p>
-<ul>
-  <li>Function inlining was critical to performance.</li>
-  <li>For MSVC, at least, a &quot;delete 0&quot; caused execution of 11 assembly 
-    instructions, including a function call. So in cases where performance is 
-    at an absolute premium it can be worth inserting the extra manual test.</li>
-</ul>
-<h2>&nbsp;</h2>
-<h2>Data Size</h2>
-<p>The following smart pointer sizes were obtained in bytes</p>
-<table align="center" cellpadding="5" cellspacing="0" class="codetable" width="270">
-  <tr> 
-    <th height="28" width="150"> 
-      <div align="right"></div>
-    </th>
-    <th height="28" class="codetabletop" width="60"> 
-      <div align="center">MSVC</div>
-    </th>
-    <th height="28" class="codetabletop" width="60"> 
-      <div align="center">GCC</div>
-    </th>
-  </tr>
-  <tr> 
-    <th class="codetableleft"> 
-      <div align="right">simple counted</div>
-    </th>
-    <td class="codetablecell"> 
-      <div align="center">8</div>
-    </td>
-    <td class="codetablecell"> 
-      <div align="center">8</div>
-    </td>
-  </tr>
-  <tr> 
-    <th class="codetableleft"> 
-      <div align="right">special counted</div>
-    </th>
-    <td class="codetablecell"> 
-      <div align="center">8</div>
-    </td>
-    <td class="codetablecell"> 
-      <div align="center">12</div>
-    </td>
-  </tr>
-  <tr> 
-    <th class="codetableleft"> 
-      <div align="right">intrusive</div>
-    </th>
-    <td class="codetablecell"> 
-      <div align="center">4</div>
-    </td>
-    <td class="codetablecell"> 
-      <div align="center">4</div>
-    </td>
-  </tr>
-  <tr> 
-    <th class="codetableleft"> 
-      <div align="right">linked</div>
-    </th>
-    <td class="codetablecell"> 
-      <div align="center">12</div>
-    </td>
-    <td class="codetablecell"> 
-      <div align="center">12</div>
-    </td>
-  </tr>
-  <tr> 
-    <th class="codetableleft"> 
-      <div align="right">cyclic</div>
-    </th>
-    <td class="codetablecell"> 
-      <div align="center">8</div>
-    </td>
-    <td class="codetablecell"> 
-      <div align="center">8</div>
-    </td>
-  </tr>
-</table>
-<h2>&nbsp;</h2>
-<h2>Summary</h2>
-<p>The timing results mainly speak for themselves: clearly an intrusive pointer 
-  outperforms all others and a simple heap based counted pointer has poor performance 
-  relative to other implementations. The selection of an optimal non-intrusive 
-  smart pointer implementation is more application dependent, however. Where small 
-  numbers of copies are expected, it is likely that the linked implementation 
-  will be favoured. Conversely, for larger numbers of copies a counted pointer 
-  with some type of special purpose allocator looks like a win. Other factors 
-  to bear in mind are: -</p>
-<ul>
-  <li>Deterministic individual, as opposed to amortized, operation time. This 
-    weighs against any implementation depending on an allocator.</li>
-  <li>Multithreaded synchronization. This weighs against an implementation which 
-    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
-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>
-</body>
-</html>

sp_techniques.html

@@ -1,765 +0,0 @@
-<!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>
-        <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>
-            <A href="#preventing_delete">Preventing <code>delete px.get()</code></A><br>
-            <A href="#array">Using a <code>shared_ptr</code> to hold a pointer to an array</A><br>
-            <A href="#encapsulation">Encapsulating allocation details, wrapping factory 
-                functions</A><br>
-            <A href="#static">Using a <code>shared_ptr</code> to hold a pointer to a statically 
-                allocated object</A><br>
-            <A href="#com">Using a <code>shared_ptr</code> to hold a pointer to a COM object</A><br>
-            <A href="#intrusive">Using a <code>shared_ptr</code> to hold a pointer to an object 
-                with an embedded reference count</A><br>
-            <A href="#another_sp">Using a <code>shared_ptr</code> to hold another shared 
-                ownership smart pointer</A><br>
-            <A href="#from_raw">Obtaining a <code>shared_ptr</code> from a raw pointer</A><br>
-            <A href="#in_constructor">Obtaining a <code>shared_ptr</code> (<code>weak_ptr</code>) 
-                to <code>this</code> in a constructor</A><br>
-            <A href="#from_this">Obtaining a <code>shared_ptr</code> to <code>this</code></A><br>
-            <A href="#handle">Using <code>shared_ptr</code> as a smart counted handle</A><br>
-            <A href="#on_block_exit">Using <code>shared_ptr</code> to execute code on block 
-                exit</A><br>
-            <A href="#pvoid">Using <code>shared_ptr&lt;void&gt;</code> to hold an arbitrary 
-                object</A><br>
-            <A href="#extra_data">Associating arbitrary data with heterogeneous <code>shared_ptr</code>
-                instances</A><br>
-            <A href="#as_lock">Using <code>shared_ptr</code> as a CopyConstructible mutex lock</A><br>
-            <A href="#wrapper">Using <code>shared_ptr</code> to wrap member function calls</A><br>
-            <A href="#delayed">Delayed deallocation</A><br>
-            <A href="#weak_without_shared">Weak pointers to objects not managed by a <code>shared_ptr</code></A><br>
-        </p>
-        <h2><A name="incomplete">Using incomplete classes for implementation hiding</A></h2>
-        <p>A proven technique (that works in C, too) for separating interface from 
-            implementation is to use a pointer to an incomplete class as an opaque handle:</p>
-        <pre>class FILE;
-
-FILE * fopen(char const * name, char const * mode);
-void fread(FILE * f, void * data, size_t size);
-void fclose(FILE * f);
-</pre>
-        <p>It is possible to express the above interface using <code>shared_ptr</code>, 
-            eliminating the need to manually call <code>fclose</code>:</p>
-        <pre>class FILE;
-
-shared_ptr&lt;FILE&gt; fopen(char const * name, char const * mode);
-void fread(shared_ptr&lt;FILE&gt; f, void * data, size_t size);
-</pre>
-        <p>This technique relies on <code>shared_ptr</code>'s ability to execute a custom 
-            deleter, eliminating the explicit call to <code>fclose</code>, and on the fact 
-            that <code>shared_ptr&lt;X&gt;</code> can be copied and destroyed when <code>X</code>
-            is incomplete.</p>
-        <h2><A name="pimpl">The "Pimpl" idiom</A></h2>
-        <p>A C++ specific variation of the incomplete class pattern is the "Pimpl" idiom. 
-            The incomplete class is not exposed to the user; it is hidden behind a 
-            forwarding facade. <code>shared_ptr</code> can be used to implement a "Pimpl":</p>
-        <pre>// file.hpp:
-
-class file
-{
-private:
-
-    class impl;
-    shared_ptr&lt;impl&gt; pimpl_;
-
-public:
-
-    file(char const * name, char const * mode);
-
-    // compiler generated members are fine and useful
-
-    void read(void * data, size_t size);
-};
-</pre>
-        <pre>// file.cpp:
-
-#include "file.hpp"
-
-class file::impl
-{
-private:
-
-    impl(impl const &amp;);
-    impl &amp; operator=(impl const &amp;);
-
-    // private data
-
-public:
-
-    impl(char const * name, char const * mode) { ... }
-    ~impl() { ... }
-    void read(void * data, size_t size) { ... }
-};
-
-file::file(char const * name, char const * mode): pimpl_(new impl(name, mode))
-{
-}
-
-void file::read(void * data, size_t size)
-{
-    pimpl_-&gt;read(data, size);
-}
-</pre>
-        <p>The key thing to note here is that the compiler-generated copy constructor, 
-            assignment operator, and destructor all have a sensible meaning. As a result, <code>
-                file</code> is <code>CopyConstructible</code> and <code>Assignable</code>, 
-            allowing its use in standard containers.</p>
-        <h2><A name="abstract">Using abstract classes for implementation hiding</A></h2>
-        <p>Another widely used C++ idiom for separating inteface and implementation is to 
-            use abstract base classes and factory functions. The abstract classes are 
-            sometimes called "interfaces" and the pattern is known as "interface-based 
-            programming". Again, <code>shared_ptr</code> can be used as the return type of 
-            the factory functions:</p>
-        <pre>// X.hpp:
-
-class X
-{
-public:
-
-    virtual void f() = 0;
-    virtual void g() = 0;
-
-protected:
-
-    ~X() {}
-};
-
-shared_ptr&lt;X&gt; createX();
-</pre>
-        <pre>-- X.cpp:
-
-class X_impl: public X
-{
-private:
-
-    X_impl(X_impl const &amp;);
-    X_impl &amp; operator=(X_impl const &amp;);
-
-public:
-
-    virtual void f()
-    {
-      // ...
-    }
-
-    virtual void g()
-    {
-      // ...
-    }
-};
-
-shared_ptr&lt;X&gt; createX()
-{
-    shared_ptr&lt;X&gt; px(new X_impl);
-    return px;
-}
-</pre>
-        <p>A key property of shared_ptr is that the allocation, construction, deallocation, 
-            and destruction details are captured at the point of construction, inside the 
-            factory function. Note the protected and nonvirtual destructor in the example 
-            above. The client code cannot, and does not need to, delete a pointer to <code>X</code>; 
-            the <code>shared_ptr&lt;X&gt;</code> instance returned from <code>createX</code>
-            will correctly call <code>~X_impl</code>.</p>
-        <h2><A name="preventing_delete">Preventing <code>delete px.get()</code></A></h2>
-        <p>It is often desirable to prevent client code from deleting a pointer that is 
-            being managed by <code>shared_ptr</code>. The previous technique showed one 
-            possible approach, using a protected destructor. Another alternative is to use 
-            a private deleter:</p>
-        <pre>class X
-{
-private:
-
-    ~X();
-
-    class deleter;
-    friend class deleter;
-
-    class deleter
-    {
-    public:
-
-        void operator()(X * p) { delete p; }
-    };
-
-public:
-
-    static shared_ptr&lt;X&gt; create()
-    {
-        shared_ptr&lt;X&gt; px(new X, X::deleter());
-        return px;
-    }
-};
-</pre>
-        <h2><A name="array">Using a <code>shared_ptr</code> to hold a pointer to an array</A></h2>
-        <p>A <code>shared_ptr</code> can be used to hold a pointer to an array allocated 
-            with <code>new[]</code>:</p>
-        <pre>shared_ptr&lt;X&gt; px(new X[1], <A href="../utility/checked_delete.html" >checked_array_deleter</A>&lt;X&gt;());
-</pre>
-        <p>Note, however, that <code><A href="shared_array.htm">shared_array</A></code> is 
-            often preferable, if this is an option. It has an array-specific interface, 
-            without <code>operator*</code> and <code>operator-&gt;</code>, and does not 
-            allow pointer conversions.</p>
-        <h2><A name="encapsulation">Encapsulating allocation details, wrapping factory 
-                functions</A></h2>
-        <p><code>shared_ptr</code> can be used in creating C++ wrappers over existing C 
-            style library interfaces that return raw pointers from their factory functions 
-            to encapsulate allocation details. As an example, consider this interface, 
-            where <code>CreateX</code> might allocate <code>X</code> from its own private 
-            heap, <code>~X</code> may be inaccessible, or <code>X</code> may be incomplete:</p>
-        <pre>X * CreateX();
-void DestroyX(X *);
-</pre>
-        <p>The only way to reliably destroy a pointer returned by <code>CreateX</code> is 
-            to call <code>DestroyX</code>.</p>
-        <P>Here is how a <code>shared_ptr</code>-based wrapper may look like:</P>
-        <pre>shared_ptr&lt;X&gt; createX()
-{
-    shared_ptr&lt;X&gt; px(CreateX(), DestroyX);
-    return px;
-}
-</pre>
-        <p>Client code that calls <code>createX</code> still does not need to know how the 
-            object has been allocated, but now the destruction is automatic.</p>
-        <h2><A name="static">Using a <code>shared_ptr</code> to hold a pointer to a statically 
-                allocated object</A></h2>
-        <p>Sometimes it is desirable to create a <code>shared_ptr</code> to an already 
-            existing object, so that the <code>shared_ptr</code> does not attempt to 
-            destroy the object when there are no more references left. As an example, the 
-            factory function:</p>
-        <pre>shared_ptr&lt;X&gt; createX();
-</pre>
-        <p>in certain situations may need to return a pointer to a statically allocated <code>X</code>
-            instance.</p>
-        <P>The solution is to use a custom deleter that does nothing:</P>
-        <pre>struct null_deleter
-{
-    void operator()(void const *) const
-    {
-    }
-};
-
-static X x;
-
-shared_ptr&lt;X&gt; createX()
-{
-    shared_ptr&lt;X&gt; px(&amp;x, null_deleter());
-    return px;
-}
-</pre>
-        <p>The same technique works for any object known to outlive the pointer.</p>
-        <h2><A name="com">Using a <code>shared_ptr</code> to hold a pointer to a COM Object</A></h2>
-        <p>Background: COM objects have an embedded reference count and two member 
-            functions that manipulate it. <code>AddRef()</code> increments the count. <code>Release()</code>
-            decrements the count and destroys itself when the count drops to zero.</p>
-        <P>It is possible to hold a pointer to a COM object in a <code>shared_ptr</code>:</P>
-        <pre>shared_ptr&lt;IWhatever&gt; make_shared_from_COM(IWhatever * p)
-{
-    p-&gt;AddRef();
-    shared_ptr&lt;IWhatever&gt; pw(p, <A href="../bind/mem_fn.html" >mem_fn</A>(&amp;IWhatever::Release));
-    return pw;
-}
-</pre>
-        <p>Note, however, that <code>shared_ptr</code> copies created from <code>pw</code> will 
-            not "register" in the embedded count of the COM object; they will share the 
-            single reference created in <code>make_shared_from_COM</code>. Weak pointers 
-            created from <code>pw</code> will be invalidated when the last <code>shared_ptr</code>
-            is destroyed, regardless of whether the COM object itself is still alive.</p>
-        <P>As <A href="../bind/mem_fn.html#Q3">explained</A> in the <code>mem_fn</code> documentation, 
-            you need to <A href="../bind/mem_fn.html#stdcall">#define 
-                BOOST_MEM_FN_ENABLE_STDCALL</A> first.</P>
-        <h2><A name="intrusive">Using a <code>shared_ptr</code> to hold a pointer to an object 
-                with an embedded reference count</A></h2>
-        <p>This is a generalization of the above technique. The example assumes that the 
-            object implements the two functions required by <code><A href="intrusive_ptr.html">intrusive_ptr</A></code>,
-            <code>intrusive_ptr_add_ref</code> and <code>intrusive_ptr_release</code>:</p>
-        <pre>template&lt;class T&gt; struct intrusive_deleter
-{
-    void operator()(T * p)
-    {
-        if(p) intrusive_ptr_release(p);
-    }
-};
-
-shared_ptr&lt;X&gt; make_shared_from_intrusive(X * p)
-{
-    if(p) intrusive_ptr_add_ref(p);
-    shared_ptr&lt;X&gt; px(p, intrusive_deleter&lt;X&gt;());
-    return px;
-}
-</pre>
-        <h2><A name="another_sp">Using a <code>shared_ptr</code> to hold another shared 
-                ownership smart pointer</A></h2>
-        <p>One of the design goals of <code>shared_ptr</code> is to be used in library 
-            interfaces. It is possible to encounter a situation where a library takes a <code>shared_ptr</code>
-            argument, but the object at hand is being managed by a different reference 
-            counted or linked smart pointer.</p>
-        <P>It is possible to exploit <code>shared_ptr</code>'s custom deleter feature to 
-            wrap this existing smart pointer behind a <code>shared_ptr</code> facade:</P>
-        <pre>template&lt;class P&gt; struct smart_pointer_deleter
-{
-private:
-
-    P p_;
-
-public:
-
-    smart_pointer_deleter(P const &amp; p): p_(p)
-    {
-    }
-
-    void operator()(void const *)
-    {
-        p_.reset();
-    }
-    
-    P const &amp; get() const
-    {
-        return p_;
-    }
-};
-
-shared_ptr&lt;X&gt; make_shared_from_another(another_ptr&lt;X&gt; qx)
-{
-    shared_ptr&lt;X&gt; px(qx.get(), smart_pointer_deleter&lt; another_ptr&lt;X&gt; &gt;(qx));
-    return px;
-}
-</pre>
-        <p>One subtle point is that deleters are not allowed to throw exceptions, and the 
-            above example as written assumes that <code>p_.reset()</code> doesn't throw. If 
-            this is not the case, <code>p_.reset()</code> should be wrapped in a <code>try {} 
-                catch(...) {}</code> block that ignores exceptions. In the (usually 
-            unlikely) event when an exception is thrown and ignored, <code>p_</code> will 
-            be released when the lifetime of the deleter ends. This happens when all 
-            references, including weak pointers, are destroyed or reset.</p>
-        <P>Another twist is that it is possible, given the above <code>shared_ptr</code> instance, 
-            to recover the original smart pointer, using <code><A href="shared_ptr.htm#get_deleter">
-                    get_deleter</A></code>:</P>
-        <pre>void extract_another_from_shared(shared_ptr&lt;X&gt; px)
-{
-    typedef smart_pointer_deleter&lt; another_ptr&lt;X&gt; &gt; deleter;
-
-    if(deleter const * pd = get_deleter&lt;deleter&gt;(px))
-    {
-        another_ptr&lt;X&gt; qx = pd-&gt;get();
-    }
-    else
-    {
-        // not one of ours
-    }
-}
-</pre>
-        <h2><A name="from_raw">Obtaining a <code>shared_ptr</code> from a raw pointer</A></h2>
-        <p>Sometimes it is necessary to obtain a <code>shared_ptr</code> given a raw 
-            pointer to an object that is already managed by another <code>shared_ptr</code> 
-            instance. Example:</p>
-        <pre>void f(X * p)
-{
-    shared_ptr&lt;X&gt; px(<i>???</i>);
-}
-</pre>
-        <p>Inside <code>f</code>, we'd like to create a <code>shared_ptr</code> to <code>*p</code>.</p>
-        <P>In the general case, this problem has no solution. One approach is to modify <code>f</code>
-            to take a <code>shared_ptr</code>, if possible:</P>
-        <pre>void f(shared_ptr&lt;X&gt; px);
-</pre>
-        <p>The same transformation can be used for nonvirtual member functions, to convert 
-            the implicit <code>this</code>:</p>
-        <pre>void X::f(int m);
-</pre>
-        <p>would become a free function with a <code>shared_ptr</code> first argument:</p>
-        <pre>void f(shared_ptr&lt;X&gt; this_, int m);
-</pre>
-        <p>If <code>f</code> cannot be changed, but <code>X</code> uses intrusive counting, 
-            use <code><A href="#intrusive">make_shared_from_intrusive</A></code> described 
-            above. Or, if it's known that the <code>shared_ptr</code> created in <code>f</code>
-            will never outlive the object, use <A href="#static">a null deleter</A>.</p>
-        <h2><A name="in_constructor">Obtaining a <code>shared_ptr</code> (<code>weak_ptr</code>) 
-                to <code>this</code> in a constructor</A></h2>
-        <p>Some designs require objects to register themselves on construction with a 
-            central authority. When the registration routines take a shared_ptr, this leads 
-            to the question how could a constructor obtain a shared_ptr to this:</p>
-        <pre>class X
-{
-public:
-
-    X()
-    {
-        shared_ptr&lt;X&gt; this_(<i>???</i>);
-    }
-};
-</pre>
-        <p>In the general case, the problem cannot be solved. The <code>X</code> instance 
-            being constructed can be an automatic variable or a static variable; it can be 
-            created on the heap:</p>
-        <pre>shared_ptr&lt;X&gt; px(new X);</pre>
-        <P>but at construction time, <code>px</code> does not exist yet, and it is 
-            impossible to create another <code>shared_ptr</code> instance that shares 
-            ownership with it.</P>
-        <P>Depending on context, if the inner <code>shared_ptr</code> <code>this_</code> doesn't 
-            need to keep the object alive, use a <code>null_deleter</code> as explained <A href="#static">
-                here</A> and <A href="#weak_without_shared">here</A>. If <code>X</code> is 
-            supposed to always live on the heap, and be managed by a <code>shared_ptr</code>, 
-            use a static factory function:</P>
-        <pre>class X
-{
-private:
-
-    X() { ... }
-
-public:
-
-    static shared_ptr&lt;X&gt; create()
-    {
-        shared_ptr&lt;X&gt; px(new X);
-        // use px as 'this_'
-        return px;
-    }
-};
-</pre>
-        <h2><A name="from_this">Obtaining a <code>shared_ptr</code> to <code>this</code></A></h2>
-        <p>Sometimes it is needed to obtain a <code>shared_ptr</code> from <code>this</code>
-            in a virtual member function under the assumption that <code>this</code> is 
-            already managed by a <code>shared_ptr</code>. The transformations <A href="#from_raw">
-                described in the previous technique</A> cannot be applied.</p>
-        <P>A typical example:</P>
-        <pre>class X
-{
-public:
-
-    virtual void f() = 0;
-
-protected:
-
-    ~X() {}
-};
-
-class Y
-{
-public:
-
-    virtual shared_ptr&lt;X&gt; getX() = 0;
-
-protected:
-
-    ~Y() {}
-};
-
-// --
-
-class impl: public X, public Y
-{
-public:
-
-    impl() { ... }
-
-    virtual void f() { ... }
-
-    virtual shared_ptr&lt;X&gt; getX()
-    {
-        shared_ptr&lt;X&gt; px(<i>???</i>);
-        return px;
-    }
-};
-</pre>
-        <p>The solution is to keep a weak pointer to <code>this</code> as a member in <code>impl</code>:</p>
-        <pre>class impl: public X, public Y
-{
-private:
-
-    weak_ptr&lt;impl&gt; weak_this;
-
-    impl(impl const &amp;);
-    impl &amp; operator=(impl const &amp;);
-
-    impl() { ... }
-
-public:
-
-    static shared_ptr&lt;impl&gt; create()
-    {
-        shared_ptr&lt;impl&gt; pi(new impl);
-        pi-&gt;weak_this = pi;
-        return pi;
-    }
-
-    virtual void f() { ... }
-
-    virtual shared_ptr&lt;X&gt; getX()
-    {
-        shared_ptr&lt;X&gt; px(weak_this);
-        return px;
-    }
-};
-</pre>
-        <p>The library now includes a helper class template <code><A href="enable_shared_from_this.html">
-                    enable_shared_from_this</A></code> that can be used to encapsulate the 
-            solution:</p>
-        <pre>class impl: public X, public Y, public enable_shared_from_this&lt;impl&gt;
-{
-public:
-
-    impl(impl const &amp;);
-    impl &amp; operator=(impl const &amp;);
-
-public:
-
-    virtual void f() { ... }
-
-    virtual shared_ptr&lt;X&gt; getX()
-    {
-        return shared_from_this();
-    }
-}
-</pre>
-        <p>Note that you no longer need to manually initialize the <code>weak_ptr</code> member 
-            in <code><A href="enable_shared_from_this.html">enable_shared_from_this</A></code>. 
-            Constructing a <code>shared_ptr</code> to <code>impl</code> takes care of that.</p>
-        <h2><A name="handle">Using <code>shared_ptr</code> as a smart counted handle</A></h2>
-        <p>Some library interfaces use opaque handles, a variation of the <A href="#incomplete">
-                incomplete class technique</A> described above. An example:</p>
-        <pre>typedef void * HANDLE;
-HANDLE CreateProcess();
-void CloseHandle(HANDLE);
-</pre>
-        <p>Instead of a raw pointer, it is possible to use <code>shared_ptr</code> as the 
-            handle and get reference counting and automatic resource management for free:</p>
-        <pre>typedef shared_ptr&lt;void&gt; handle;
-
-handle createProcess()
-{
-    shared_ptr&lt;void&gt; pv(CreateProcess(), CloseHandle);
-    return pv;
-}
-</pre>
-        <h2><A name="on_block_exit">Using <code>shared_ptr</code> to execute code on block exit</A></h2>
-        <p><code>shared_ptr&lt;void&gt;</code> can automatically execute cleanup code when 
-            control leaves a scope.</p>
-        <UL>
-            <LI>
-                Executing <code>f(p)</code>, where <code>p</code> is a pointer:</LI></UL>
-        <pre>    shared_ptr&lt;void&gt; guard(p, f);
-</pre>
-        <UL>
-            <LI>
-                Executing arbitrary code: <code>f(x, y)</code>:</LI></UL>
-        <pre>    shared_ptr&lt;void&gt; guard(static_cast&lt;void*&gt;(0), <A href="../bind/bind.html" >bind</A>(f, x, y));
-</pre>
-        <P>For a more thorough treatment, see the article "Simplify Your Exception-Safe 
-            Code" by Andrei Alexandrescu and Petru Marginean, available online at <A href="http://www.cuj.com/experts/1812/alexandr.htm?topic=experts">
-                http://www.cuj.com/experts/1812/alexandr.htm?topic=experts</A>.</P>
-        <h2><A name="pvoid">Using <code>shared_ptr&lt;void&gt;</code> to hold an arbitrary 
-                object</A></h2>
-        <p><code>shared_ptr&lt;void&gt;</code> can act as a generic object pointer similar 
-            to <code>void*</code>. When a <code>shared_ptr&lt;void&gt;</code> instance 
-            constructed as:</p>
-        <pre>    shared_ptr&lt;void&gt; pv(new X);
-</pre>
-        <p>is destroyed, it will correctly dispose of the <code>X</code> object by 
-            executing <code>~X</code>.</p>
-        <p>This propery can be used in much the same manner as a raw <code>void*</code> is 
-            used to temporarily strip type information from an object pointer. A <code>shared_ptr&lt;void&gt;</code>
-            can later be cast back to the correct type by using <code><A href="shared_ptr.htm#static_pointer_cast">
-                    static_pointer_cast</A></code>.</p>
-        <h2><A name="extra_data">Associating arbitrary data with heterogeneous <code>shared_ptr</code>
-                instances</A></h2>
-        <p><code>shared_ptr</code> and <code>weak_ptr</code> support <code>operator&lt;</code>
-            comparisons required by standard associative containers such as <code>std::map</code>. 
-            This can be used to non-intrusively associate arbitrary data with objects 
-            managed by <code>shared_ptr</code>:</p>
-        <pre>typedef int Data;
-
-std::map&lt; shared_ptr&lt;void&gt;, Data &gt; userData;
-// or std::map&lt; weak_ptr&lt;void&gt;, Data &gt; userData; to not affect the lifetime
-
-shared_ptr&lt;X&gt; px(new X);
-shared_ptr&lt;int&gt; pi(new int(3));
-
-userData[px] = 42;
-userData[pi] = 91;
-</pre>
-        <h2><A name="as_lock">Using <code>shared_ptr</code> as a CopyConstructible mutex lock</A></h2>
-        <p>Sometimes it's necessary to return a mutex lock from a function, and a 
-            noncopyable lock cannot be returned by value. It is possible to use <code>shared_ptr</code>
-            as a mutex lock:</p>
-        <pre>class mutex
-{
-public:
-
-    void lock();
-    void unlock();
-};
-
-shared_ptr&lt;mutex&gt; lock(mutex &amp; m)
-{
-    m.lock();
-    return shared_ptr&lt;mutex&gt;(&amp;m, mem_fn(&amp;mutex::unlock));
-}
-</pre>
-        <p>Better yet, the <code>shared_ptr</code> instance acting as a lock can be 
-            encapsulated in a dedicated <code>shared_lock</code> class:</p>
-        <pre>class shared_lock
-{
-private:
-
-    shared_ptr&lt;void&gt; pv;
-
-public:
-
-    template&lt;class Mutex&gt; explicit shared_lock(Mutex &amp; m): pv((m.lock(), &amp;m), mem_fn(&amp;Mutex::unlock)) {}
-};
-</pre>
-        <p><code>shared_lock</code> can now be used as:</p>
-        <pre>    shared_lock lock(m);
-</pre>
-        <p>Note that <code>shared_lock</code> is not templated on the mutex type, thanks to <code>
-                shared_ptr&lt;void&gt;</code>'s ability to hide type information.</p>
-        <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>). 
-            An implementation is given below:</p>
-        <pre>template&lt;class T&gt; class pointer
-{
-private:
-
-    T * p_;
-
-public:
-
-    explicit pointer(T * p): p_(p)
-    {
-    }
-
-    shared_ptr&lt;T&gt; operator-&gt;() const
-    {
-        p_-&gt;prefix();
-        return shared_ptr&lt;T&gt;(p_, <A href="../bind/mem_fn.html" >mem_fn</A>(&amp;T::suffix));
-    }
-};
-
-class X
-{
-private:
-
-    void prefix();
-    void suffix();
-    friend class pointer&lt;X&gt;;
-    
-public:
-
-    void f();
-    void g();
-};
-
-int main()
-{
-    X x;
-
-    pointer&lt;X&gt; px(&amp;x);
-
-    px-&gt;f();
-    px-&gt;g();
-}
-</pre>
-        <h2><A name="delayed">Delayed deallocation</A></h2>
-        <p>In some situations, a single <code>px.reset()</code> can trigger an expensive 
-            deallocation in a performance-critical region:</p>
-        <pre>class X; // ~X is expensive
-
-class Y
-{
-    shared_ptr&lt;X&gt; px;
-
-public:
-
-    void f()
-    {
-        px.reset();
-    }
-};
-</pre>
-        <p>The solution is to postpone the potential deallocation by moving <code>px</code> 
-            to a dedicated free list that can be periodically emptied when performance and 
-            response times are not an issue:</p>
-        <pre>vector&lt; shared_ptr&lt;void&gt; &gt; free_list;
-
-class Y
-{
-    shared_ptr&lt;X&gt; px;
-
-public:
-
-    void f()
-    {
-        free_list.push_back(px);
-        px.reset();
-    }
-};
-
-// periodically invoke free_list.clear() when convenient
-</pre>
-        <p>Another variation is to move the free list logic to the construction point by 
-            using a delayed deleter:</p>
-        <pre>struct delayed_deleter
-{
-    template&lt;class T&gt; void operator()(T * p)
-    {
-        try
-        {
-            shared_ptr&lt;void&gt; pv(p);
-            free_list.push_back(pv);
-        }
-        catch(...)
-        {
-        }
-    }
-};
-</pre>
-        <h2><A name="weak_without_shared">Weak pointers to objects not managed by a <code>shared_ptr</code></A></h2>
-        <p>Make the object hold a <code>shared_ptr</code> to itself, using a <code>null_deleter</code>:</p>
-        <pre>class X
-{
-private:
-
-    shared_ptr&lt;X&gt; this_;
-    int i_;
-
-public:
-
-    explicit X(int i): this_(this, null_deleter()), i_(i)
-    {
-    }
-
-    // repeat in all constructors (including the copy constructor!)
-
-    X(X const &amp; rhs): this_(this, null_deleter()), i_(rhs.i_)
-    {
-    }
-
-    // do not forget to not assign this_ in the copy assignment
-
-    X &amp; operator=(X const &amp; rhs)
-    {
-        i_ = rhs.i_;
-    }
-
-    weak_ptr&lt;X&gt; get_weak_ptr() const { return this_; }
-};
-</pre>
-        <p>When the object's lifetime ends, <code>X::this_</code> will be destroyed, and 
-            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 
-            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>