Do not require boost::hash in the std::hash specializations

Fix Clang-tidy modernize-use-override warnings.

.travis.yml

@@ -1,14 +1,10 @@
-# Copyright 2016, 2017 Peter Dimov
+# Copyright 2016-2020 Peter Dimov
 # Distributed under the Boost Software License, Version 1.0.
 # (See accompanying file LICENSE_1_0.txt or copy at http://boost.org/LICENSE_1_0.txt)
 
 language: cpp
 
-sudo: false
-
-os:
-  - linux
-  - osx
+dist: xenial
 
 branches:
   only:
@@ -27,22 +23,47 @@ matrix:
 
   include:
     - os: linux
+      arch: arm64
       compiler: g++
-      env: TOOLSET=gcc COMPILER=g++ CXXSTD=c++03
+      env: TOOLSET=gcc COMPILER=g++ CXXSTD=03,11,14
 
     - os: linux
-      compiler: g++-4.7
-      env: TOOLSET=gcc COMPILER=g++-4.7 CXXSTD=c++03
+      arch: ppc64le
+      compiler: g++
+      env: TOOLSET=gcc COMPILER=g++ CXXSTD=03,11,14
+
+    - os: linux
+      arch: s390x
+      compiler: g++
+      env: TOOLSET=gcc COMPILER=g++ CXXSTD=03,11,14
+
+    - os: freebsd
+      compiler: clang++
+      env: TOOLSET=clang COMPILER=clang++ CXXSTD=03,11,14,17,2a
+
+    - os: linux
+      compiler: g++-4.4
+      env: TOOLSET=gcc COMPILER=g++-4.4 CXXSTD=98,0x
       addons:
         apt:
           packages:
-            - g++-4.7
+            - g++-4.4
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: g++-4.6
+      env: TOOLSET=gcc COMPILER=g++-4.6 CXXSTD=03,0x
+      addons:
+        apt:
+          packages:
+            - g++-4.6
           sources:
             - ubuntu-toolchain-r-test
 
     - os: linux
       compiler: g++-4.7
-      env: TOOLSET=gcc COMPILER=g++-4.7 CXXSTD=c++11
+      env: TOOLSET=gcc COMPILER=g++-4.7 CXXSTD=03,11
       addons:
         apt:
           packages:
@@ -52,37 +73,16 @@ matrix:
 
     - os: linux
       compiler: g++-4.8
-      env: TOOLSET=gcc COMPILER=g++-4.8 CXXSTD=c++03
+      env: TOOLSET=gcc COMPILER=g++-4.8 CXXSTD=03,11
       addons:
         apt:
           packages:
             - g++-4.8
           sources:
             - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: g++-4.8
-      env: TOOLSET=gcc COMPILER=g++-4.8 CXXSTD=c++11
-      addons:
-        apt:
-          packages:
-            - g++-4.8
-          sources:
-            - ubuntu-toolchain-r-test
-
     - os: linux
       compiler: g++-4.9
-      env: TOOLSET=gcc COMPILER=g++-4.9 CXXSTD=c++03
-      addons:
-        apt:
-          packages:
-            - g++-4.9
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: g++-4.9
-      env: TOOLSET=gcc COMPILER=g++-4.9 CXXSTD=c++11
+      env: TOOLSET=gcc COMPILER=g++-4.9 CXXSTD=03,11
       addons:
         apt:
           packages:
@@ -92,37 +92,7 @@ matrix:
 
     - os: linux
       compiler: g++-5
-      env: TOOLSET=gcc COMPILER=g++-5 CXXSTD=c++03
-      addons:
-        apt:
-          packages:
-            - g++-5
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: g++-5
-      env: TOOLSET=gcc COMPILER=g++-5 CXXSTD=c++11
-      addons:
-        apt:
-          packages:
-            - g++-5
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: g++-5
-      env: TOOLSET=gcc COMPILER=g++-5 CXXSTD=c++14
-      addons:
-        apt:
-          packages:
-            - g++-5
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: g++-5
-      env: TOOLSET=gcc COMPILER=g++-5 CXXSTD=c++1z
+      env: TOOLSET=gcc COMPILER=g++-5 CXXSTD=03,11,14,1z
       addons:
         apt:
           packages:
@@ -132,7 +102,7 @@ matrix:
 
     - os: linux
       compiler: g++-6
-      env: TOOLSET=gcc COMPILER=g++-6 CXXSTD=c++03
+      env: TOOLSET=gcc COMPILER=g++-6 CXXSTD=03,11,14,1z
       addons:
         apt:
           packages:
@@ -141,39 +111,80 @@ matrix:
             - ubuntu-toolchain-r-test
 
     - os: linux
-      compiler: g++-6
-      env: TOOLSET=gcc COMPILER=g++-6 CXXSTD=c++11
-      addons:
-        apt:
-          packages:
-            - g++-6
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: g++-6
-      env: TOOLSET=gcc COMPILER=g++-6 CXXSTD=c++14
-      addons:
-        apt:
-          packages:
-            - g++-6
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: g++-6
-      env: TOOLSET=gcc COMPILER=g++-6 CXXSTD=c++1z
-      addons:
-        apt:
-          packages:
-            - g++-6
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      dist: trusty
       compiler: g++-7
-      env: TOOLSET=gcc COMPILER=g++-7 CXXSTD=c++03
+      env: TOOLSET=gcc COMPILER=g++-7 CXXSTD=03,11,14,17
+      addons:
+        apt:
+          packages:
+            - g++-7
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: g++-8
+      env: TOOLSET=gcc COMPILER=g++-8 CXXSTD=03,11,14
+      addons:
+        apt:
+          packages:
+            - g++-8
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: g++-8
+      env: TOOLSET=gcc COMPILER=g++-8 CXXSTD=17,2a
+      addons:
+        apt:
+          packages:
+            - g++-8
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: g++-9
+      env: TOOLSET=gcc COMPILER=g++-9 CXXSTD=03,11,14
+      addons:
+        apt:
+          packages:
+            - g++-9
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: g++-9
+      env: TOOLSET=gcc COMPILER=g++-9 CXXSTD=17,2a
+      addons:
+        apt:
+          packages:
+            - g++-9
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      dist: bionic
+      compiler: g++-10
+      env: TOOLSET=gcc COMPILER=g++-10 CXXSTD=03,11,14
+      addons:
+        apt:
+          packages:
+            - g++-10
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      dist: bionic
+      compiler: g++-10
+      env: TOOLSET=gcc COMPILER=g++-10 CXXSTD=17,2a
+      addons:
+        apt:
+          packages:
+            - g++-10
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: g++-7
+      env: UBSAN=1 TOOLSET=gcc COMPILER=g++-7 CXXSTD=03,11,14,17 UBSAN_OPTIONS=print_stacktrace=1 LINKFLAGS=-fuse-ld=gold
       addons:
         apt:
           packages:
@@ -183,324 +194,213 @@ matrix:
 
     - os: linux
       dist: trusty
-      compiler: g++-7
-      env: TOOLSET=gcc COMPILER=g++-7 CXXSTD=c++11
+      compiler: /usr/bin/clang++
+      env: TOOLSET=clang COMPILER=/usr/bin/clang++ CXXSTD=03,11
       addons:
         apt:
           packages:
-            - g++-7
-          sources:
-            - ubuntu-toolchain-r-test
+            - clang-3.3
 
     - os: linux
       dist: trusty
-      compiler: g++-7
-      env: TOOLSET=gcc COMPILER=g++-7 CXXSTD=c++14
+      compiler: /usr/bin/clang++
+      env: TOOLSET=clang COMPILER=/usr/bin/clang++ CXXSTD=03,11
       addons:
         apt:
           packages:
-            - g++-7
+            - clang-3.4
+
+    - os: linux
+      compiler: clang++-3.5
+      env: TOOLSET=clang COMPILER=clang++-3.5 CXXSTD=03,11
+      addons:
+        apt:
+          packages:
+            - clang-3.5
           sources:
             - ubuntu-toolchain-r-test
 
+    - os: linux
+      compiler: clang++-3.6
+      env: TOOLSET=clang COMPILER=clang++-3.6 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - clang-3.6
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: clang++-3.7
+      env: TOOLSET=clang COMPILER=clang++-3.7 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - clang-3.7
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: clang++-3.8
+      env: TOOLSET=clang COMPILER=clang++-3.8 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - clang-3.8
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: clang++-3.9
+      env: TOOLSET=clang COMPILER=clang++-3.9 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - clang-3.9
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: clang++-4.0
+      env: TOOLSET=clang COMPILER=clang++-4.0 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - clang-4.0
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: clang++-5.0
+      env: TOOLSET=clang COMPILER=clang++-5.0 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - clang-5.0
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: clang++-6.0
+      env: TOOLSET=clang COMPILER=clang++-6.0 CXXSTD=03,11,14,17,2a
+      addons:
+        apt:
+          packages:
+            - clang-6.0
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: clang++-7
+      env: TOOLSET=clang COMPILER=clang++-7 CXXSTD=03,11,14,17,2a
+      addons:
+        apt:
+          packages:
+            - clang-7
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-xenial-7
+
+    - os: linux
+      compiler: clang++-8
+      env: TOOLSET=clang COMPILER=clang++-8 CXXSTD=03,11,14,17,2a
+      addons:
+        apt:
+          packages:
+            - clang-8
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-xenial-8
+
+    - os: linux
+      dist: xenial
+      compiler: clang++-9
+      env: TOOLSET=clang COMPILER=clang++-9 CXXSTD=03,11,14,17,2a
+      addons:
+        apt:
+          packages:
+            - clang-9
+          sources:
+            - ubuntu-toolchain-r-test
+            - sourceline: 'deb https://apt.llvm.org/xenial/ llvm-toolchain-xenial-9 main'
+              key_url: 'https://apt.llvm.org/llvm-snapshot.gpg.key'
+
+    - os: linux
+      dist: xenial
+      compiler: clang++-10
+      env: TOOLSET=clang COMPILER=clang++-10 CXXSTD=03,11,14,17,2a
+      addons:
+        apt:
+          packages:
+            - clang-10
+          sources:
+            - ubuntu-toolchain-r-test
+            - sourceline: 'deb https://apt.llvm.org/xenial/ llvm-toolchain-xenial-10 main'
+              key_url: 'https://apt.llvm.org/llvm-snapshot.gpg.key'
+
+    - os: linux
+      compiler: clang++-8
+      env: UBSAN=1 TOOLSET=clang COMPILER=clang++-8 CXXSTD=03,11,14,17,2a UBSAN_OPTIONS=print_stacktrace=1
+      addons:
+        apt:
+          packages:
+            - clang-8
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-xenial-8
+
     - os: linux
       dist: trusty
-      compiler: g++-7
-      env: TOOLSET=gcc COMPILER=g++-7 CXXSTD=c++17
+      compiler: clang++-libc++
+      env: TOOLSET=clang COMPILER=clang++-libc++ CXXSTD=03,11,14,1z
       addons:
         apt:
           packages:
-            - g++-7
-          sources:
-            - ubuntu-toolchain-r-test
+            - libc++-dev
 
     - 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
+      dist: trusty
+      compiler: clang++-libc++
+      env: UBSAN=1 TOOLSET=clang COMPILER=clang++-libc++ CXXSTD=03,11,14,1z UBSAN_OPTIONS=print_stacktrace=1
       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:
-          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++11
-      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++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:
-          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++11
-      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++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:
-          packages:
-            - clang-3.8
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-precise-3.8
-
-    - os: linux
-      compiler: clang++-3.8
-      env: TOOLSET=clang COMPILER=clang++-3.8 CXXSTD=c++11
-      addons:
-        apt:
-          packages:
-            - clang-3.8
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-precise-3.8
-
-    - os: linux
-      compiler: clang++-3.8
-      env: TOOLSET=clang COMPILER=clang++-3.8 CXXSTD=c++14
-      addons:
-        apt:
-          packages:
-            - clang-3.8
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-precise-3.8
-
-    - os: linux
-      compiler: clang++-3.8
-      env: TOOLSET=clang COMPILER=clang++-3.8 CXXSTD=c++1z
-      addons:
-        apt:
-          packages:
-            - clang-3.8
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-precise-3.8
-
-    - os: 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
+            - libc++-dev
 
     - os: osx
       compiler: clang++
-      env: TOOLSET=clang COMPILER=clang++ CXXSTD=c++03
+      env: TOOLSET=clang COMPILER=clang++ CXXSTD=03,11,14,1z
 
     - os: osx
       compiler: clang++
-      env: TOOLSET=clang COMPILER=clang++ CXXSTD=c++11
+      env: UBSAN=1 TOOLSET=clang COMPILER=clang++ CXXSTD=03,11,14,1z UBSAN_OPTIONS=print_stacktrace=1
 
-    - os: osx
-      compiler: clang++
-      env: TOOLSET=clang COMPILER=clang++ CXXSTD=c++14
+    - os: linux
+      env: CMAKE_TEST=1
+      script:
+        - mkdir __build__ && cd __build__
+        - cmake -DBOOST_ENABLE_CMAKE=1 -DBoost_VERBOSE=1 -DBOOST_INCLUDE_LIBRARIES=smart_ptr -DBUILD_TESTING=ON ..
+        - ctest --output-on-failure -R boost_smart_ptr
 
-    - os: osx
-      compiler: clang++
-      env: TOOLSET=clang COMPILER=clang++ CXXSTD=c++1z
+    - os: linux
+      compiler: g++
+      env: CMAKE_SUBDIR_TEST=1
+      script:
+      - cd libs/smart_ptr/test/cmake_subdir_test && mkdir __build__ && cd __build__
+      - cmake ..
+      - cmake --build .
+      - cmake --build . --target check
+
+    - os: linux
+      env: CMAKE_INSTALL_TEST=1
+      script:
+        - mkdir __build__ && cd __build__
+        - cmake -DBOOST_ENABLE_CMAKE=1 -DBoost_VERBOSE=1 -DBOOST_INCLUDE_LIBRARIES=smart_ptr -DBUILD_TESTING=OFF -DCMAKE_INSTALL_PREFIX=~/.local ..
+        - cmake --build . --target install
+        - cd ../libs/smart_ptr/test/cmake_install_test && mkdir __build__ && cd __build__
+        - cmake -DCMAKE_INSTALL_PREFIX=~/.local ..
+        - cmake --build .
+        - cmake --build . --target check
 
 install:
   - BOOST_BRANCH=develop && [ "$TRAVIS_BRANCH" == "master" ] && BOOST_BRANCH=master || true
@@ -511,26 +411,30 @@ install:
   - git submodule init libs/assert
   - git submodule init libs/atomic
   - git submodule init libs/config
+  - git submodule init libs/container_hash
   - git submodule init libs/core
-  - git submodule init libs/detail
-  - git submodule init libs/functional
-  - git submodule init libs/integer
   - git submodule init libs/move
   - git submodule init libs/predef
-  - git submodule init libs/preprocessor
   - git submodule init libs/static_assert
   - git submodule init libs/throw_exception
   - git submodule init libs/type_traits
+  - git submodule init libs/detail
+  - git submodule init libs/integer
   - git submodule init tools/build
-  - git submodule update
+  - git submodule init libs/headers
+  - git submodule init tools/boost_install
+  - git submodule init tools/cmake
+  - git submodule init libs/preprocessor
+  - git submodule init libs/bind
+  - git submodule update # no --jobs 3 on non-amd64
   - cp -r $TRAVIS_BUILD_DIR/* libs/smart_ptr
   - ./bootstrap.sh
   - ./b2 headers
 
 script:
   - |-
-    echo "using $TOOLSET : : $COMPILER : <cxxflags>-std=$CXXSTD ;" > ~/user-config.jam
-  - ./b2 libs/smart_ptr/test toolset=$TOOLSET
+    echo "using $TOOLSET : : $COMPILER ;" > ~/user-config.jam
+  - ./b2 -j3 libs/smart_ptr/test toolset=$TOOLSET cxxstd=$CXXSTD variant=debug,release ${UBSAN:+cxxflags=-fsanitize=undefined cxxflags=-fno-sanitize-recover=undefined linkflags=-fsanitize=undefined debug-symbols=on} ${LINKFLAGS:+linkflags=$LINKFLAGS}
 
 notifications:
   email:

CMakeLists.txt

@@ -0,0 +1,36 @@
+# Copyright 2018-2020 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
+
+cmake_minimum_required(VERSION 3.5...3.16)
+
+project(boost_smart_ptr VERSION "${BOOST_SUPERPROJECT_VERSION}" LANGUAGES CXX)
+
+add_library(boost_smart_ptr INTERFACE)
+add_library(Boost::smart_ptr ALIAS boost_smart_ptr)
+
+target_include_directories(boost_smart_ptr INTERFACE include)
+
+target_link_libraries(boost_smart_ptr
+  INTERFACE
+    Boost::assert
+    Boost::config
+    Boost::core
+    Boost::move
+    Boost::static_assert
+    Boost::throw_exception
+    Boost::type_traits
+)
+
+if(BOOST_SUPERPROJECT_VERSION)
+
+  include(BoostInstall)
+  boost_install(TARGETS boost_smart_ptr HEADER_DIRECTORY include/)
+
+endif()
+
+if(BUILD_TESTING)
+
+  add_subdirectory(test)
+
+endif()

README.md

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

appveyor.yml

@@ -1,4 +1,4 @@
-# Copyright 2016, 2017 Peter Dimov
+# Copyright 2016-2019 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,46 +14,72 @@ branches:
 
 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
+      TOOLSET: msvc-9.0,msvc-10.0,msvc-11.0
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
+      TOOLSET: msvc-12.0,msvc-14.0
+      ADDRMD: 32,64
     - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
       TOOLSET: msvc-14.1
+      CXXSTD: 14,17
+      ADDRMD: 32,64
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
+      TOOLSET: clang-win
+      CXXSTD: 14,17
+      ADDRMD: 64
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
+      TOOLSET: msvc-14.2
+      CXXSTD: 14,17
+      ADDRMD: 32,64
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
+      ADDPATH: C:\cygwin\bin;
+      TOOLSET: gcc
+      CXXSTD: 03,11,14,1z
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
+      ADDPATH: C:\cygwin64\bin;
+      TOOLSET: gcc
+      CXXSTD: 03,11,14,1z
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
+      ADDPATH: C:\mingw\bin;
+      TOOLSET: gcc
+      CXXSTD: 03,11,14,1z
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
+      ADDPATH: C:\mingw-w64\x86_64-7.2.0-posix-seh-rt_v5-rev1\mingw64\bin;
+      TOOLSET: gcc
+      CXXSTD: 03,11,14,1z
 
 install:
   - set BOOST_BRANCH=develop
   - if "%APPVEYOR_REPO_BRANCH%" == "master" set BOOST_BRANCH=master
   - cd ..
-  - git clone -b %BOOST_BRANCH% https://github.com/boostorg/boost.git boost-root
+  - git clone -b %BOOST_BRANCH% --depth 1 https://github.com/boostorg/boost.git boost-root
   - cd boost-root
   - git submodule init libs/align
   - git submodule init libs/assert
   - git submodule init libs/atomic
   - git submodule init libs/config
+  - git submodule init libs/container_hash
   - git submodule init libs/core
-  - git submodule init libs/detail
-  - git submodule init libs/functional
-  - git submodule init libs/integer
   - git submodule init libs/move
   - git submodule init libs/predef
-  - git submodule init libs/preprocessor
   - git submodule init libs/static_assert
   - git submodule init libs/throw_exception
   - git submodule init libs/type_traits
+  - git submodule init libs/detail
+  - git submodule init libs/integer
   - git submodule init tools/build
-  - git submodule update
-  - xcopy /s /e /q %APPVEYOR_BUILD_FOLDER% libs\smart_ptr
-  - bootstrap
-  - b2 headers
+  - git submodule init libs/headers
+  - git submodule init tools/boost_install
+  - git submodule init libs/bind
+  - git submodule update --jobs 3
+  - xcopy /s /e /q %APPVEYOR_BUILD_FOLDER% libs\smart_ptr\
+  - cmd /c bootstrap
+  - b2 -d0 headers
 
 build: off
 
 test_script:
-  - b2 libs/smart_ptr/test toolset=%TOOLSET%
+  - PATH=%ADDPATH%%PATH%
+  - if not "%CXXSTD%" == "" set CXXSTD=cxxstd=%CXXSTD%
+  - if not "%ADDRMD%" == "" set ADDRMD=address-model=%ADDRMD%
+  - b2 -j3 libs/smart_ptr/test toolset=%TOOLSET% %CXXSTD% %ADDRMD% variant=debug,release

doc/Jamfile

@@ -5,8 +5,6 @@
 # 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 ;

doc/asciidoctor.jam

@@ -1,50 +0,0 @@
-# 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

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

doc/smart_ptr.adoc

@@ -18,32 +18,25 @@ Greg Colvin, Beman Dawes, Peter Dimov, Glen Fernandes
 :leveloffset: +1
 
 include::smart_ptr/introduction.adoc[]
-
+include::smart_ptr/changelog.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/enable_shared_from.adoc[]
 include::smart_ptr/make_unique.adoc[]
-
+include::smart_ptr/allocate_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/make_local_shared.adoc[]
 include::smart_ptr/pointer_cast.adoc[]
-
 include::smart_ptr/pointer_to_other.adoc[]
-
 include::smart_ptr/atomic_shared_ptr.adoc[]
+include::smart_ptr/owner_less.adoc[]
+include::smart_ptr/owner_equal_to.adoc[]
 
 // appendix
 include::smart_ptr/techniques.adoc[]
@@ -65,7 +58,7 @@ This documentation is
 * Copyright 1999 Greg Colvin
 * Copyright 1999 Beman Dawes
 * Copyright 2002 Darin Adler
-* Copyright 2003-2017 Peter Dimov
+* Copyright 2003-2020 Peter Dimov
 * Copyright 2005, 2006 Ion Gaztañaga
 * Copyright 2008 Frank Mori Hess
 * Copyright 2012-2017 Glen Fernandes

doc/smart_ptr/allocate_unique.adoc

@@ -0,0 +1,318 @@
+////
+Copyright 2019 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
+////
+
+[#allocate_unique]
+# allocate_unique: Creating unique_ptr
+:toc:
+:toc-title:
+:idprefix: allocate_unique_
+
+## Description
+
+The `allocate_unique` family of function templates provide convenient and safe
+ways to obtain a `std::unique_ptr` that manages a new object created using an
+allocator.
+
+## Rationale
+
+The {cpp}14 standard introduced `std::make_unique` which used operator `new` to
+create new objects. However, there is no convenient facility in the standard
+library to use an allocator for the creation of the objects managed by
+`std::unique_ptr`. Users writing allocator aware code have often requested an
+`allocate_unique` factory function. This function is to `std::unique_ptr` what
+`std::allocate_shared` is to `std::shared_ptr`.
+
+## Synopsis
+
+`allocate_unique` is defined in `<boost/smart_ptr/allocate_unique.hpp>`.
+
+[subs=+quotes]
+```
+namespace boost {
+  template<class T, class A>
+  class alloc_deleter;
+
+  template<class T, class A>
+  using alloc_noinit_deleter = alloc_deleter<T, noinit_adaptor<A>>;
+
+  `// T is not an array`
+  template<class T, class A, class... Args>
+    std::unique_ptr<T, alloc_deleter<T, A>>
+      allocate_unique(const A& a, Args&&... args);
+
+  `// T is not an array`
+  template<class T, class A>
+    std::unique_ptr<T, alloc_deleter<T, A>>
+      allocate_unique(const A& a, type_identity_t<T>&& v);
+
+  `// T is an array of unknown bounds`
+  template<class T, class A>
+    std::unique_ptr<T, alloc_deleter<T, A>>
+      allocate_unique(const A& a, std::size_t n);
+
+  `// T is an array of known bounds`
+  template<class T, class A>
+    std::unique_ptr<remove_extent_t<T>[], alloc_deleter<T, A>>
+      allocate_unique(const A& a);
+
+  `// T is an array of unknown bounds`
+  template<class T, class A>
+    std::unique_ptr<T, alloc_deleter<T, A>>
+      allocate_unique(const A& a, std::size_t n, const remove_extent_t<T>& v);
+
+  `// T is an array of known bounds`
+  template<class T, class A>
+    std::unique_ptr<remove_extent_t<T>[], alloc_deleter<T, A>>
+      allocate_unique(const A& a, const remove_extent_t<T>& v);
+
+  `// T is not an array`
+  template<class T, class A>
+    std::unique_ptr<T, alloc_noinit_deleter<T, A>>
+      allocate_unique_noinit(const A& a);
+
+  `// T is an array of unknown bounds`
+  template<class T, class A>
+    std::unique_ptr<T, alloc_noinit_deleter<T, A>>
+      allocate_unique_noinit(const A& a, std::size_t n);
+
+  `// T is an array of known bounds`
+  template<class T, class A>
+    std::unique_ptr<remove_extent_t<T>[], alloc_noinit_deleter<T, A>>
+      allocate_unique_noinit(const A& a);
+}
+```
+
+## Common Requirements
+
+The common requirements that apply to all `allocate_unique` and
+`allocate_unique_noinit` 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 `std::unique_ptr` instance that stores and owns the address of the
+newly constructed object.
+
+Postconditions:: `r.get() != 0`, where `r` is the return value.
+
+Throws:: An exception thrown from `A::allocate`, or from the initialization of
+the object.
+
+Remarks::
+* 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\...`, `allocate_unique` 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 potentially rebound
+copy of `a`.
+* When a (sub)object of non-array type `U` is specified to be
+default-initialized, `allocate_unique_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, `allocate_unique` 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
+potentially rebound copy of `a`.
+* 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.
+
+## Free Functions
+
+```
+template<class T, class A, class... Args>
+  std::unique_ptr<T, alloc_deleter<T, A>>
+    allocate_unique(const A& a, Args&&... args);
+```
+[none]
+* {blank}
++
+Constraints:: `T` is not an array.
+Returns:: A `std::unique_ptr` to an object of type `T`, constructed from
+`args\...`.
+Examples::
+* `auto p = allocate_unique<int>(a);`
+* `auto p = allocate_unique<std::vector<int>>(a, 16, 1);`
+
+```
+template<class T, class A>
+  std::unique_ptr<T, alloc_deleter<T, A>>
+    allocate_unique(const A& a, type_identity_t<T>&& v);
+```
+[none]
+* {blank}
++
+Constraints:: `T` is not an array.
+Returns:: A `std::unique_ptr` to an object of type `T`, constructed from `v`.
+Example:: `auto p = allocate_unique<std::vector<int>>(a, {1, 2});`
+
+```
+template<class T, class A>
+  std::unique_ptr<T, alloc_deleter<T, A>>
+    allocate_unique(const A& a, std::size_t n);
+```
+[none]
+* {blank}
++
+Constraints:: `T` is an array of unknown bounds.
+Returns:: A `std::unique_ptr` to a sequence of `n` value-initialized objects of
+type `remove_extent_t<T>`.
+Examples::
+* `auto p = allocate_unique<double[]>(a, 1024);`
+* `auto p = allocate_unique<double[][2][2]>(a, 6);`
+
+```
+template<class T, class A>
+  std::unique_ptr<remove_extent_t<T>[], alloc_deleter<T, A>>
+    allocate_unique(const A& a);
+```
+[none]
+* {blank}
++
+Constraints:: `T` is an array of known bounds.
+Returns:: A `std::unique_ptr` to a sequence of `extent_v<T>` value-initialized
+objects of type `remove_extent_t<T>`.
+Examples::
+* `auto p = allocate_unique<double[1024]>(a);`
+* `auto p = allocate_unique<double[6][2][2]>(a);`
+
+```
+template<class T, class A>
+  std::unique_ptr<T, alloc_deleter<T, A>>
+    allocate_unique(const A& a, std::size_t n, const remove_extent_t<T>& v);
+```
+[none]
+* {blank}
++
+Constraints:: `T` is an array of unknown bounds.
+Returns:: A `std::unique_ptr` to a sequence of `n` objects of type
+`remove_extent_t<T>`, each initialized to `v`.
+Examples::
+* `auto p = allocate_unique<double[]>(a, 1024, 1.0);`
+* `auto p = allocate_unique<double[][2]>(a, 6, {1.0, 0.0});`
+* `auto p = allocate_unique<std::vector<int>[]>(a, 4, {1, 2});`
+
+```
+template<class T, class A>
+  std::unique_ptr<remove_extent_t<T>[], alloc_deleter<T, A>>
+    allocate_unique(const A& a, const remove_extent_t<T>& v);
+```
+[none]
+* {blank}
++
+Constraints:: `T` is an array of known bounds.
+Returns:: A `std::unique_ptr` to a sequence of `extent_v<T>` objects of type
+`remove_extent_t<T>`, each initialized to `v`.
+Examples::
+* `auto p = allocate_unique<double[1024]>(a, 1.0);`
+* `auto p = allocate_unique<double[6][2]>(a, {1.0, 0.0});`
+* `auto p = allocate_unique<std::vector<int>[4]>(a, {1, 2});`
+
+```
+template<class T, class A>
+  std::unique_ptr<T, alloc_noinit_deleter<T, A>>
+    allocate_unique_noinit(const A& a);
+```
+[none]
+* {blank}
++
+Constraints:: `T` is not an array.
+Returns:: A `std::unique_ptr` to a default-initialized object of type `T`.
+Example:: `auto p = allocate_unique_noinit<double>(a);`
+
+```
+template<class T, class A>
+  std::unique_ptr<T, alloc_noinit_deleter<T, A>>
+    allocate_unique_noinit(const A& a, std::size_t n);
+```
+[none]
+* {blank}
++
+Constraints:: `T` is an array of unknown bounds.
+Returns:: A `std::unique_ptr` to a sequence of `n` default-initialized objects
+of type `remove_extent_t<T>`.
+Example:: `auto p = allocate_unique_noinit<double[]>(a, 1024);`
+
+```
+template<class T, class A>
+  std::unique_ptr<remove_extent_t<T>, alloc_noinit_deleter<T, A>>
+    allocate_unique_noinit(const A& a);
+```
+[none]
+* {blank}
++
+Constraints:: `T` is an array of known bounds.
+Returns:: A `std::unique_ptr` to a sequence of `extent_v<T>`
+default-initialized objects of type `remove_extent_t<T>`.
+Example:: `auto p = allocate_unique_noinit<double[1024]>(a);`
+
+## Deleter
+
+Class template `alloc_deleter` is the deleter used by the `allocate_unique`
+functions.
+
+### Synopsis
+
+[subs=+quotes]
+```
+template<class T, class A>
+class alloc_deleter {
+public:
+  using pointer = `unspecified`;
+
+  explicit alloc_deleter(const A& a) noexcept;
+
+  void operator()(pointer p);
+};
+```
+
+### Members
+
+[subs=+quotes]
+```
+using pointer = `unspecified`;
+```
+[none]
+* {blank}
++
+A type that satisfies _NullablePointer_.
+
+```
+explicit alloc_deleter(const A& a) noexcept;
+```
+[none]
+* {blank}
++
+Effects:: Initializes the stored allocator from `a`.
+
+```
+void operator()(pointer p);
+```
+[none]
+* {blank}
++
+Effects:: Destroys the objects and deallocates the storage referenced by `p`,
+using the stored allocator.

doc/smart_ptr/changelog.adoc

@@ -0,0 +1,34 @@
+////
+Copyright 2019 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
+////
+
+[#changelog]
+# Revision History
+:toc:
+:toc-title:
+:idprefix: changelog_
+
+## Changes in 1.74.0
+
+* Added `owner_equals` to `shared_ptr`, `weak_ptr`, `local_shared_ptr`
+* Added `owner_equal_to`
+
+## Changes in 1.72.0
+
+* Added `allocate_unique`
+
+## Changes in 1.71.0
+
+* Added aliasing constructors to `weak_ptr`
+* Added `weak_ptr<T>::empty()`
+* Added `enable_shared_from`, `shared_from`, and `weak_from`
+
+## Changes in 1.65.0
+
+* Added `atomic_shared_ptr`
+* Added `local_shared_ptr`, `make_local_shared`

doc/smart_ptr/enable_shared_from.adoc

@@ -0,0 +1,89 @@
+////
+Copyright 2002, 2003, 2015, 2017, 2019 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]
+# enable_shared_from
+:toc:
+:toc-title:
+:idprefix: enable_shared_from_
+
+## Description
+
+`enable_shared_from` is used as a base class that allows a `shared_ptr` or a
+`weak_ptr` to be obtained given a raw pointer to the object, by using the
+functions `shared_from` and `weak_from`.
+
+`enable_shared_from` differs from `enable_shared_from_this<T>` by the fact
+that it's not a template, and is its recommended replacement for new code.
+
+## Example
+
+```
+#include <boost/smart_ptr/enable_shared_from.hpp>
+#include <boost/shared_ptr.hpp>
+#include <cassert>
+
+class Y: public boost::enable_shared_from
+{
+public:
+
+    boost::shared_ptr<Y> f()
+    {
+        return boost::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` is defined in `<boost/smart_ptr/enable_shared_from.hpp>`.
+
+```
+namespace boost {
+
+  class enable_shared_from: public enable_shared_from_this<enable_shared_from>
+  {
+  };
+
+  template<class T> shared_ptr<T> shared_from( T * p );
+  template<class T> weak_ptr<T> weak_from( T * p ) noexcept;
+}
+```
+
+## Functions
+
+```
+template<class T> shared_ptr<T> shared_from( T * p );
+```
+[none]
+* {blank}
++
+Returns:: `shared_ptr<T>( p\->enable_shared_from::shared_from_this(), p )`.
+
+NOTE: Throws `bad_weak_ptr` when `p` is not owned by a `shared_ptr`.
+
+```
+template<class T> weak_ptr<T> weak_from( T * p ) noexcept;
+```
+[none]
+* {blank}
++
+Returns:: `weak_ptr<T>( p\->enable_shared_from::weak_from_this(), p )`.
+
+NOTE: Unlike `shared_from(this)`, `weak_from(this)` is valid in a destructor
+      and returns a `weak_ptr` that is `expired()` but still shares ownership
+      with other `weak_ptr` instances (if any) that refer to the object.

doc/smart_ptr/enable_shared_from_this.adoc

@@ -142,3 +142,7 @@ template<class T> weak_ptr<T const> weak_from_this() const noexcept;
 * {blank}
 +
 Returns:: `weak_this_`.
+
+NOTE: Unlike `shared_from_this()`, `weak_from_this()` is valid in a destructor
+      and returns a `weak_ptr` that is `expired()` but still shares ownership
+      with other `weak_ptr` instances (if any) that refer to the object.

doc/smart_ptr/history.adoc

@@ -110,4 +110,8 @@ Glen Fernandes rewrote `allocate_shared` and `make_shared` for arrays for a more
 
 Peter Dimov and Glen Fernandes rewrote the documentation in Asciidoc format.
 
-Peter Dimov added `atomic_shared_ptr`.
+Peter Dimov added `atomic_shared_ptr` and `local_shared_ptr`.
+
+## August 2019
+
+Glen Fernandes implemented `allocate_unique` for scalars and arrays.

doc/smart_ptr/introduction.adoc

@@ -11,7 +11,9 @@ http://www.boost.org/LICENSE_1_0.txt
 
 [#introduction]
 # Introduction
-:idprefix: intro
+:toc:
+:toc-title:
+: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
@@ -29,7 +31,7 @@ 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;
+* `<<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.
 
@@ -37,9 +39,11 @@ This library provides six smart pointer class templates:
 
 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_shared,make_shared>>` and `allocate_shared`, factory functions for creating objects that return a `shared_ptr`;
 * `<<make_unique,make_unique>>`, a factory function returning `std::unique_ptr`;
+* `<<allocate_unique,allocate_unique>>`, a factory function for creating objects using an allocator that returns a `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`;
+* `<<enable_shared_from,enable_shared_from>>`, a newer and better replacement for `enable_shared_from_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.

doc/smart_ptr/intrusive_ptr.adoc

@@ -54,12 +54,18 @@ namespace boost {
     intrusive_ptr(intrusive_ptr const & r);
     template<class Y> intrusive_ptr(intrusive_ptr<Y> const & r);
 
+    intrusive_ptr(intrusive_ptr && r);
+    template<class Y> intrusive_ptr(intrusive_ptr<Y> && 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);
 
+    intrusive_ptr & operator=(intrusive_ptr && r);
+    template<class Y> intrusive_ptr & operator=(intrusive_ptr<Y> && r);
+
     void reset();
     void reset(T * r);
     void reset(T * r, bool add_ref);
@@ -71,7 +77,7 @@ namespace boost {
 
     explicit operator bool () const noexcept;
 
-    void swap(intrusive_ptr & b) noexept;
+    void swap(intrusive_ptr & b) noexcept;
   };
 
   template<class T, class U>
@@ -92,8 +98,8 @@ namespace boost {
   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>
+    bool operator<(intrusive_ptr<T> const & a, intrusive_ptr<T> const & b) noexcept;
 
   template<class T> void swap(intrusive_ptr<T> & a, intrusive_ptr<T> & b) noexcept;
 
@@ -155,9 +161,22 @@ template<class Y> intrusive_ptr(intrusive_ptr<Y> const & r);
 [none]
 * {blank}
 +
-Effects:: `if(r.get() != 0) intrusive_ptr_add_ref(r.get());`.
+Effects:: `T * p = r.get(); if(p != 0) intrusive_ptr_add_ref(p);`.
 Postconditions:: `get() == r.get()`.
 
+```
+intrusive_ptr(intrusive_ptr && r);
+```
+```
+template<class Y> intrusive_ptr(intrusive_ptr<Y> && r);
+```
+
+[none]
+* {blank}
++
+Postconditions::
+  `get()` equals the old value of `r.get()`. `r.get() == 0`.
+
 ### destructor
 
 ```
@@ -167,7 +186,8 @@ Postconditions:: `get() == r.get()`.
 [none]
 * {blank}
 +
-Effects:: `if(get() != 0) intrusive_ptr_release(get());`.
+Effects::
+  `if(get() != 0) intrusive_ptr_release(get());`.
 
 ### assignment
 
@@ -187,6 +207,19 @@ intrusive_ptr & operator=(T * r);
 Effects:: Equivalent to `intrusive_ptr(r).swap(*this)`.
 Returns:: `*this`.
 
+```
+intrusive_ptr & operator=(intrusive_ptr && r);
+```
+```
+template<class Y> intrusive_ptr & operator=(intrusive_ptr<Y> && r);
+```
+
+[none]
+* {blank}
++
+Effects:: Equivalent to `intrusive_ptr(std::move(r)).swap(*this)`.
+Returns:: `*this`.
+
 ### reset
 
 ```
@@ -214,7 +247,8 @@ void reset(T * r, bool add_ref);
 [none]
 * {blank}
 +
-Effects:: Equivalent to `intrusive_ptr(r, add_ref).swap(*this)`.
+Effects::
+  Equivalent to `intrusive_ptr(r, add_ref).swap(*this)`.
 
 ### indirection
 
@@ -247,7 +281,8 @@ T * get() const noexcept;
 [none]
 * {blank}
 +
-Returns:: the stored pointer.
+Returns::
+  the stored pointer.
 
 ### detach
 
@@ -294,7 +329,8 @@ void swap(intrusive_ptr & b) noexcept;
 [none]
 * {blank}
 +
-Effects:: Exchanges the contents of the two smart pointers.
+Effects::
+  Exchanges the contents of the two smart pointers.
 
 ## Free Functions
 
@@ -361,8 +397,8 @@ template<class T, class U>
 Returns:: `a != b.get()`.
 
 ```
-template<class T, class U>
-  bool operator<(intrusive_ptr<T> const & a, intrusive_ptr<U> const & b) noexcept;
+template<class T>
+  bool operator<(intrusive_ptr<T> const & a, intrusive_ptr<T> const & b) noexcept;
 ```
 
 [none]
@@ -381,7 +417,8 @@ template<class T> void swap(intrusive_ptr<T> & a, intrusive_ptr<T> & b) noexcept
 [none]
 * {blank}
 +
-Effects:: Equivalent to `a.swap(b)`.
+Effects::
+  Equivalent to `a.swap(b)`.
 
 ### get_pointer
 
@@ -406,7 +443,8 @@ template<class T, class U>
 [none]
 * {blank}
 +
-Returns:: `intrusive_ptr<T>(static_cast<T*>(r.get()))`.
+Returns::
+  `intrusive_ptr<T>(static_cast<T*>(r.get()))`.
 
 ### const_pointer_cast
 
@@ -418,7 +456,8 @@ template<class T, class U>
 [none]
 * {blank}
 +
-Returns:: `intrusive_ptr<T>(const_cast<T*>(r.get()))`.
+Returns::
+  `intrusive_ptr<T>(const_cast<T*>(r.get()))`.
 
 ### dynamic_pointer_cast
 
@@ -430,7 +469,8 @@ template<class T, class U>
 [none]
 * {blank}
 +
-Returns:: `intrusive_ptr<T>(dynamic_cast<T*>(r.get()))`.
+Returns::
+  `intrusive_ptr<T>(dynamic_cast<T*>(r.get()))`.
 
 ### operator<<
 

doc/smart_ptr/intrusive_ref_counter.adoc

@@ -78,12 +78,13 @@ namespace boost {
 ```
 intrusive_ref_counter() noexcept;
 ```
-::
 ```
 intrusive_ref_counter(const intrusive_ref_counter&) noexcept;
 ```
-::
-Postconditions::: `use_count() == 0`.
+[none]
+* {blank}
++
+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
@@ -94,8 +95,10 @@ would increment the reference counter.
 ```
 ~intrusive_ref_counter();
 ```
-::
-Effects::: Destroys the counter object.
+[none]
+* {blank}
++
+Effects:: Destroys the counter object.
 
 NOTE: The destructor is protected so that the object can only be destroyed
 through the `Derived` class.
@@ -105,16 +108,21 @@ through the `Derived` class.
 ```
 intrusive_ref_counter& operator=(const intrusive_ref_counter& v) noexcept;
 ```
-::
-Effects::: Does nothing, reference counter is not modified.
+[none]
+* {blank}
++
+Effects::
+  Does nothing, reference counter is not modified.
 
 ### use_count
 
 ```
 unsigned int use_count() const noexcept;
 ```
-::
-Returns::: The current value of the reference counter.
+[none]
+* {blank}
++
+Returns:: The current value of the reference counter.
 
 NOTE: The returned value may not be actual in multi-threaded applications.
 
@@ -127,8 +135,11 @@ template<class Derived, class CounterPolicy>
   void intrusive_ptr_add_ref(
     const intrusive_ref_counter<Derived, CounterPolicy>* p) noexcept;
 ```
-::
-Effects::: Increments the reference counter.
+[none]
+* {blank}
++
+Effects::
+  Increments the reference counter.
 
 ### intrusive_ptr_release
 
@@ -137,6 +148,8 @@ 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
+[none]
+* {blank}
++
+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

@@ -124,7 +124,7 @@ namespace boost {
     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
 
@@ -143,12 +143,16 @@ namespace boost {
     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;
+
+    template<class Y> bool owner_before(local_shared_ptr<Y> const & r) const noexcept;
+
+    // owner_equals
+
+    template<class Y> bool owner_equals(local_shared_ptr<Y> const & r) const noexcept;
   };
 
   // comparisons
@@ -459,7 +463,8 @@ template<class Y> void reset(local_shared_ptr<Y> && r, element_type * p) noexcep
 [none]
 * {blank}
 +
-Effects:: Equivalent to `local_shared_ptr(std::move(r), p).swap(*this)`.
+Effects::
+  Equivalent to `local_shared_ptr(std::move(r), p).swap(*this)`.
 
 ### indirection
 ```
@@ -497,7 +502,8 @@ element_type * get() const noexcept;
 [none]
 * {blank}
 +
-Returns:: The stored pointer.
+Returns::
+  The stored pointer.
 
 ### local_use_count
 ```
@@ -506,7 +512,8 @@ 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.
+Returns::
+  The number of `local_shared_ptr` objects, `*this` included, that share ownership with `*this`, or 0 when `*this` is empty.
 
 ### conversions
 ```
@@ -538,16 +545,28 @@ void swap(local_shared_ptr & b) noexcept;
 [none]
 * {blank}
 +
-Effects:: Exchanges the contents of the two smart pointers.
+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;
+template<class Y> bool owner_before(local_shared_ptr<Y> const & r) const noexcept;
 ```
 [none]
 * {blank}
 +
-Effects:: See the description of `operator<`.
+Returns::
+  See the description of `operator<`.
+
+### owner_equals
+```
+template<class Y> bool owner_equals(local_shared_ptr<Y> const & r) const noexcept;
+```
+[none]
+* {blank}
++
+Returns::
+  `true` if and only if `*this` and `r` share ownership or are both empty.
 
 ## Free Functions
 
@@ -631,7 +650,8 @@ template<class T> void swap(local_shared_ptr<T> & a, local_shared_ptr<T> & b) no
 [none]
 * {blank}
 +
-Effects:: Equivalent to `a.swap(b)`.
+Effects::
+  Equivalent to `a.swap(b)`.
 
 ### get_pointer
 ```
@@ -716,4 +736,3 @@ template<class D, class T>
 * {blank}
 +
 Returns:: If `*this` owns a `shared_ptr` instance `p`, `get_deleter<D>( p )`, otherwise 0.
-

doc/smart_ptr/make_local_shared.adoc

@@ -0,0 +1,81 @@
+////
+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_local_shared]
+# make_local_shared: Creating local_shared_ptr
+:toc:
+:toc-title:
+:idprefix: make_local_shared_
+
+## Description
+
+The function templates `make_local_shared` and `allocate_local_shared` provide
+convenient, safe and efficient ways to create `local_shared_ptr` objects. They
+are analogous to `make_shared` and `allocate_shared` for `shared_ptr`.
+
+## Synopsis
+
+`make_local_shared` and `allocate_local_shared` are defined in
+`<boost/smart_ptr/make_local_shared.hpp>`.
+
+[subs=+quotes]
+```
+namespace boost {
+  `// T is not an array`
+  template<class T, class... Args>
+    local_shared_ptr<T> make_local_shared(Args&&... args);
+  template<class T, class A, class... Args>
+    local_shared_ptr<T> allocate_local_shared(const A& a, Args&&... args);
+
+  `// T is an array of unknown bounds`
+  template<class T>
+    local_shared_ptr<T> make_local_shared(std::size_t n);
+  template<class T, class A>
+    local_shared_ptr<T> allocate_local_shared(const A& a, std::size_t n);
+
+  `// T is an array of known bounds`
+  template<class T>
+    local_shared_ptr<T> make_local_shared();
+  template<class T, class A>
+    local_shared_ptr<T> allocate_local_shared(const A& a);
+
+  `// T is an array of unknown bounds`
+  template<class T>
+    local_shared_ptr<T> make_local_shared(std::size_t n,
+      const remove_extent_t<T>& v);
+  template<class T, class A>
+    local_shared_ptr<T> allocate_local_shared(const A& a, std::size_t n,
+      const remove_extent_t<T>& v);
+
+  `// T is an array of known bounds`
+  template<class T>
+    local_shared_ptr<T> make_local_shared(const remove_extent_t<T>& v);
+  template<class T, class A>
+    local_shared_ptr<T> allocate_local_shared(const A& a,
+      const remove_extent_t<T>& v);
+
+  `// T is not an array of known bounds`
+  template<class T>
+    local_shared_ptr<T> make_local_shared_noinit();
+  template<class T, class A>
+    local_shared_ptr<T> allocate_local_shared_noinit(const A& a);
+
+  `// T is an array of unknown bounds`
+  template<class T>
+    local_shared_ptr<T> make_local_shared_noinit(std::size_t n);
+  template<class T, class A>
+    local_shared_ptr<T> allocate_local_shared_noinit(const A& a,
+      std::size_t n);
+}
+```
+
+## Description
+
+The requirements and effects of these functions are the same as `make_shared`
+and `allocate_shared`, except that a `local_shared_ptr` is returned.

doc/smart_ptr/make_shared.adoc

@@ -55,43 +55,43 @@ types.
 [subs=+quotes]
 ```
 namespace boost {
-  `// only if T is not an array type`
+  `// T is not an array`
   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[]`
+  `// T is an array of unknown bounds`
   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]`
+  `// T is an array of known bounds`
   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[]`
+  `// T is an array of unknown bounds`
   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]`
+  `// T is an array of known bounds`
   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[]`
+  `// T is not an array of unknown bounds`
   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]`
+  `// T is an array of unknown bounds`
   template<class T>
     shared_ptr<T> make_shared_noinit(std::size_t n);
   template<class T, class A>
@@ -144,7 +144,7 @@ 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`.
+type `A2` is a potentially rebound copy of `a`.
 * 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
@@ -158,7 +158,7 @@ storage suitable to hold an object of type `U`.
 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`.
+type `A2` is a potentially rebound copy of `a`.
 * 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
@@ -174,17 +174,17 @@ the reference counts.
 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
+[none]
+* {blank}
++
+Constraints:: `T` is not an array.
+Returns:: A `shared_ptr` to an object of type `T`, constructed from
 `args\...`.
-Examples:::
+Examples::
 * `auto p = make_shared<int>();`
 * `auto p = make_shared<std::vector<int> >(16, 1);`
 
@@ -192,17 +192,17 @@ Examples:::
 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:::
+[none]
+* {blank}
++
+Constraints:: `T` is an array of unknown bounds.
+Returns:: A `shared_ptr` to a sequence of `n` value-initialized objects of
+type `remove_extent_t<T>`.
+Examples::
 * `auto p = make_shared<double[]>(1024);`
 * `auto p = make_shared<double[][2][2]>(6);`
 
@@ -210,17 +210,17 @@ Examples:::
 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:::
+[none]
+* {blank}
++
+Constraints:: `T` is an array of known bounds.
+Returns:: A `shared_ptr` to a sequence of `extent_v<T>` value-initialized
+objects of type `remove_extent_t<T>`.
+Examples::
 * `auto p = make_shared<double[1024]>();`
 * `auto p = make_shared<double[6][2][2]>();`
 
@@ -228,17 +228,17 @@ Examples:::
 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:::
+[none]
+* {blank}
++
+Constraints:: `T` is an array of unknown bounds.
+Returns:: A `shared_ptr` to a sequence of `n` objects of type
+`remove_extent_t<T>`, 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});`
@@ -247,17 +247,17 @@ Examples:::
 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:::
+[none]
+* {blank}
++
+Constraints:: `T` is an array of known bounds.
+Returns:: A `shared_ptr` to a sequence of `extent_v<T>` objects of type
+`remove_extent_t<T>`, 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});`
@@ -266,30 +266,31 @@ Examples:::
 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]>();`
+[none]
+* {blank}
++
+Constraints:: `T` is not an array, or is an array of known bounds.
+Returns:: A `shared_ptr` to a default-initialized object of type `T`, or a
+sequence of `extent_v<T>` default-initialized objects of type
+`remove_extent_t<T>`, 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);`
+[none]
+* {blank}
++
+Constraints:: `T` is an array of unknown bounds.
+Returns:: A `shared_ptr` to a sequence of `_n_` default-initialized objects
+of type `remove_extent_t<T>`.
+Example:: `auto p = make_shared_noinit<double[]>(1024);`

doc/smart_ptr/make_unique.adoc

@@ -35,28 +35,28 @@ feature with `std::make_unique`.
 
 ## Synopsis
 
-`make_unique` is defined in `<boost/smart_ptr/make_unqiue.hpp>`.
+`make_unique` is defined in `<boost/smart_ptr/make_unique.hpp>`.
 
 [subs=+quotes]
 ```
 namespace boost {
-  `// only if T is not an array type`
+  `// T is not an array`
   template<class T, class... Args>
     std::unique_ptr<T> make_unique(Args&&... args);
 
-  `// only if T is not an array type`
+  `// T is not an array`
   template<class T>
-    std::unique_ptr<T> make_unique(remove_reference_t<T>&& v);
+    std::unique_ptr<T> make_unique(type_identity_t<T>&& v);
 
-  `// only if T is an array type of the form U[]`
+  `// T is an array of unknown bounds`
   template<class T>
     std::unique_ptr<T> make_unique(std::size_t n);
 
-  `// only if T is not an array type`
+  `// T is not an array`
   template<class T>
     std::unique_ptr<T> make_unique_noinit();
 
-  `// only if T is an array type of the form U[]`
+  `// T is an array of unknown bounds`
   template<class T>
     std::unique_ptr<T> make_unique_noinit(std::size_t n);
 }
@@ -68,48 +68,53 @@ namespace boost {
 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>();`
+[none]
+* {blank}
++
+Constraints:: `T` is not an array.
+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);
+  std::unique_ptr<T> make_unique(type_identity_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});`
+[none]
+* {blank}
++
+Constraints:: `T` is not an array.
+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);`
+[none]
+* {blank}
++
+Constraints:: `T` is an array of unknown bounds.
+Returns:: `std::unique_ptr<T>(new remove_extent_t<T>[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]>();`
+[none]
+* {blank}
++
+Constraints:: `T` is not an array.
+Returns:: `std::unique_ptr<T>(new T)`.
+Example:: `auto p = make_unique_noinit<std::array<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);`
+[none]
+* {blank}
++
+Constraints:: `T` is an array of unknown bounds.
+Returns:: `std::unique_ptr<T>(new remove_extent_t<T>[n])`.
+Example:: `auto p = make_unique_noinit<double[]>(1024);`

doc/smart_ptr/owner_equal_to.adoc

@@ -0,0 +1,45 @@
+////
+Copyright 2020 Peter Dimov
+Distributed under the Boost Software License, Version 1.0.
+https://www.boost.org/LICENSE_1_0.txt
+////
+
+[#owner_equal_to]
+# owner_equal_to
+:toc:
+:toc-title:
+:idprefix: owner_equal_to_
+
+## Description
+
+`owner_equal_to<T>` is a helper function object that compares two smart
+pointer objects using `owner_equals`.
+
+## Synopsis
+
+`owner_equal_to` is defined in `<boost/smart_ptr/owner_equal_to.hpp>`.
+
+```
+namespace boost {
+
+  template<class T = void> struct owner_equal_to
+  {
+    typedef bool result_type;
+    typedef T first_argument_type;
+    typedef T second_argument_type;
+
+    template<class U, class V> bool operator()( U const & u, V const & v ) const noexcept;
+  };
+}
+```
+
+## Members
+
+```
+template<class U, class V> bool operator()( U const & u, V const & v ) const noexcept;
+```
+[none]
+* {blank}
++
+Returns::
+  `u.owner_equals( v )`.

doc/smart_ptr/owner_less.adoc

@@ -0,0 +1,50 @@
+////
+Copyright 2020 Peter Dimov
+Distributed under the Boost Software License, Version 1.0.
+https://www.boost.org/LICENSE_1_0.txt
+////
+
+[#owner_less]
+# owner_less
+:toc:
+:toc-title:
+:idprefix: owner_less_
+
+## Description
+
+`owner_less<T>` is a helper function object that compares two smart
+pointer objects using `owner_before`. It is only provided for compatibility
+with {cpp}11 and corresponds to the standard component of the same name.
+
+When using Boost smart pointers, the use of `owner_less` is unnecessary, as
+the supplied `operator<` overloads (and, correspondingly, `std::less`) return
+the same result.
+
+## Synopsis
+
+`owner_less` is defined in `<boost/smart_ptr/owner_less.hpp>`.
+
+```
+namespace boost {
+
+  template<class T = void> struct owner_less
+  {
+    typedef bool result_type;
+    typedef T first_argument_type;
+    typedef T second_argument_type;
+
+    template<class U, class V> bool operator()( U const & u, V const & v ) const noexcept;
+  };
+}
+```
+
+## Members
+
+```
+template<class U, class V> bool operator()( U const & u, V const & v ) const noexcept;
+```
+[none]
+* {blank}
++
+Returns::
+  `u.owner_before( v )`.

doc/smart_ptr/pointer_cast.adoc

@@ -78,23 +78,29 @@ namespace boost {
 ```
 template<class T, class U> T* static_pointer_cast(U* p) noexcept;
 ```
-::
-Returns::: `static_cast<T*>(p)`
+[none]
+* {blank}
++
+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)`
+[none]
+* {blank}
++
+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
+[none]
+* {blank}
++
+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
@@ -106,25 +112,31 @@ undefined behavior, attempting to delete the same object twice.
 ```
 template<class T, class U> T* dynamic_pointer_cast(U* p) noexcept;
 ```
-::
-Returns::: `dynamic_cast<T*>(p)`
+[none]
+* {blank}
++
+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)`
+[none]
+* {blank}
++
+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:::
+[none]
+* {blank}
++
+Requires::
 * The expression `static_cast<T*>((U*)0)` must be well-formed.
 * `T` must have a virtual destructor.
-Returns:::
+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()));`.
@@ -135,23 +147,29 @@ std::unique_ptr<T>::element_type*>(p.release()));`.
 ```
 template<class T, class U> T* const_pointer_cast(U* p) noexcept;
 ```
-::
-Returns::: `const_cast<T*>(p)`
+[none]
+* {blank}
++
+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)`
+[none]
+* {blank}
++
+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
+[none]
+* {blank}
++
+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
@@ -159,23 +177,29 @@ std::unique_ptr<T>::element_type*>(p.release()))`.
 ```
 template<class T, class U> T* reinterpret_pointer_cast(U* p) noexcept;
 ```
-::
-Returns::: `reinterpret_cast<T*>(p)`
+[none]
+* {blank}
++
+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)`
+[none]
+* {blank}
++
+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
+[none]
+* {blank}
++
+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
@@ -210,4 +234,4 @@ int main()
 
   delete ptr;
 }
-```
+```

doc/smart_ptr/shared_array.adoc

@@ -105,42 +105,50 @@ Type:: Provides the type of the stored pointer.
 ```
 explicit shared_array(T* p = 0);
 ```
-::
-Effects::: Constructs a `shared_array`, storing a copy of `p`, which must be a
+[none]
+* {blank}
++
+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.
+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`.
+[none]
+* {blank}
++
+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:::
+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.
+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
+[none]
+* {blank}
++
+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.
+Requires:: `T` is a complete type.
 
 ### Destructor
 
 ```
 ~shared_array() noexcept;
 ```
-::
-Effects::: Decrements the use count. Then, if the use count is 0, deletes the
+[none]
+* {blank}
++
+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. 
 
@@ -149,60 +157,70 @@ a value of 0 is harmless.
 ```
 shared_array& operator=(const shared_array& v) noexcept;
 ```
-::
-Effects::: Constructs a new `shared_array` as described above, then replaces
+[none]
+* {blank}
++
+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`.
+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
+[none]
+* {blank}
++
+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.
+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
+[none]
+* {blank}
++
+Effects:: Constructs a new `shared_array` as described above, then replaces
 this `shared_array` with the new one, destroying the replaced object.
-Requires:::
+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.
+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
+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.
+Requires:: `T` is a complete type.
 
 ### get
 
 ```
 T* get() const noexcept;
 ```
-::
-Returns::: The stored pointer.
+[none]
+* {blank}
++
+Returns:: The stored pointer.
 
 ### unique
 
 ```
 bool unique() const noexcept;
 ```
-::
-Returns::: `true` if no other `shared_array` is sharing ownership of the
+[none]
+* {blank}
++
+Returns:: `true` if no other `shared_array` is sharing ownership of the
 stored pointer, `false` otherwise.
 
 ### use_count
@@ -210,8 +228,10 @@ stored pointer, `false` otherwise.
 ```
 long use_count() const noexcept;
 ```
-::
-Returns::: The number of `shared_array` objects sharing ownership of the
+[none]
+* {blank}
++
+Returns:: The number of `shared_array` objects sharing ownership of the
 stored pointer.
 
 ### Conversions
@@ -219,17 +239,21 @@ stored pointer.
 ```
 explicit operator bool() const noexcept;
 ```
-::
-Returns::: `get() != 0`.
-Requires::: `T` is a complete type.
+[none]
+* {blank}
++
+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.
+[none]
+* {blank}
++
+Effects:: Exchanges the contents of the two smart pointers.
 
 ## Free Functions
 
@@ -247,8 +271,10 @@ template<class T> bool
 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
+[none]
+* {blank}
++
+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
@@ -265,6 +291,8 @@ mandates that relational operations on pointers are unspecified (5.9
 template<class T>
   void swap(shared_array<T>& a, shared_array<T>& b) noexcept;
 ```
-::
-Returns::: `a.swap(b)`.
-Requires::: `T` is a complete type.
+[none]
+* {blank}
++
+Returns:: `a.swap(b)`.
+Requires:: `T` is a complete type.

doc/smart_ptr/shared_ptr.adoc

@@ -132,7 +132,6 @@ namespace boost {
     template<class Y> shared_ptr(shared_ptr<Y> && r) noexcept;
 
     template<class Y> shared_ptr(shared_ptr<Y> const & r, element_type * p) noexcept;
-
     template<class Y> shared_ptr(shared_ptr<Y> && r, element_type * p) noexcept;
 
     template<class Y> explicit shared_ptr(weak_ptr<Y> const & r);
@@ -179,8 +178,11 @@ namespace boost {
 
     void swap(shared_ptr & b) noexcept;
 
-    template<class Y> bool owner_before(shared_ptr<Y> const & rhs) const noexcept;
-    template<class Y> bool owner_before(weak_ptr<Y> const & rhs) const noexcept;
+    template<class Y> bool owner_before(shared_ptr<Y> const & r) const noexcept;
+    template<class Y> bool owner_before(weak_ptr<Y> const & r) const noexcept;
+
+    template<class Y> bool owner_equals(shared_ptr<Y> const & r) const noexcept;
+    template<class Y> bool owner_equals(weak_ptr<Y> const & r) const noexcept;
   };
 
   template<class T, class U>
@@ -373,7 +375,7 @@ template<class Y> shared_ptr(shared_ptr<Y> const & r, element_type * p) noexcept
 [none]
 * {blank}
 +
-Effects:: constructs a `shared_ptr` that shares ownership with `r` and stores `p`.
+Effects:: Copy-constructs a `shared_ptr` from `r`, while storing `p` instead.
 
 Postconditions:: `get() == p && use_count() == r.use_count()`.
 
@@ -561,7 +563,8 @@ template<class Y> void reset(shared_ptr<Y> && r, element_type * p) noexcept;
 [none]
 * {blank}
 +
-Effects:: Equivalent to `shared_ptr(std::move(r), p).swap(*this)`.
+Effects::
+  Equivalent to `shared_ptr(std::move(r), p).swap(*this)`.
 
 ### indirection
 ```
@@ -599,7 +602,8 @@ element_type * get() const noexcept;
 [none]
 * {blank}
 +
-Returns:: The stored pointer.
+Returns::
+  The stored pointer.
 
 ### unique
 ```
@@ -608,7 +612,8 @@ bool unique() const noexcept;
 [none]
 * {blank}
 +
-Returns:: `use_count() == 1`.
+Returns::
+  `use_count() == 1`.
 
 ### use_count
 ```
@@ -617,7 +622,8 @@ long use_count() const noexcept;
 [none]
 * {blank}
 +
-Returns:: The number of `shared_ptr` objects, `*this` included, that share ownership with `*this`, or 0 when `*this` is empty.
+Returns::
+  The number of `shared_ptr` objects, `*this` included, that share ownership with `*this`, or 0 when `*this` is empty.
 
 ### conversions
 ```
@@ -642,19 +648,34 @@ void swap(shared_ptr & b) noexcept;
 [none]
 * {blank}
 +
-Effects:: Exchanges the contents of the two smart pointers.
+Effects::
+  Exchanges the contents of the two smart pointers.
 
 ### owner_before
 ```
-template<class Y> bool owner_before(shared_ptr<Y> const & rhs) const noexcept;
+template<class Y> bool owner_before(shared_ptr<Y> const & r) const noexcept;
 ```
 ```
-template<class Y> bool owner_before(weak_ptr<Y> const & rhs) const noexcept;
+template<class Y> bool owner_before(weak_ptr<Y> const & r) const noexcept;
 ```
 [none]
 * {blank}
 +
-Effects:: See the description of `operator<`.
+Returns::
+  See the description of `operator<`.
+
+### owner_equals
+```
+template<class Y> bool owner_equals(shared_ptr<Y> const & r) const noexcept;
+```
+```
+template<class Y> bool owner_equals(weak_ptr<Y> const & r) const noexcept;
+```
+[none]
+* {blank}
++
+Returns::
+  `true` if and only if `*this` and `r` share ownership or are both empty.
 
 ## Free Functions
 
@@ -722,7 +743,8 @@ template<class T> void swap(shared_ptr<T> & a, shared_ptr<T> & b) noexcept;
 [none]
 * {blank}
 +
-Effects:: Equivalent to `a.swap(b)`.
+Effects::
+  Equivalent to `a.swap(b)`.
 
 ### get_pointer
 ```
@@ -806,7 +828,8 @@ template<class D, class T>
 [none]
 * {blank}
 +
-Returns:: If `*this` owns a deleter `d` of type (cv-unqualified) `D`, returns `&d`; otherwise returns 0.
+Returns::
+  If `*this` owns a deleter `d` of type (cv-unqualified) `D`, returns `&d`; otherwise returns 0.
 
 ### Atomic Access
 

doc/smart_ptr/techniques.adoc

@@ -251,7 +251,7 @@ Note, however, that `shared_ptr` copies created from `pw` will not "register" in
 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.
+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

doc/smart_ptr/weak_ptr.adoc

@@ -88,6 +88,10 @@ namespace boost {
 
     weak_ptr(weak_ptr && r) noexcept;
 
+    template<class Y> weak_ptr(shared_ptr<Y> const & r, element_type * p) noexcept;
+    template<class Y> weak_ptr(weak_ptr<Y> const & r, element_type * p) noexcept;
+    template<class Y> weak_ptr(weak_ptr<Y> && r, element_type * p) noexcept;
+
     ~weak_ptr() noexcept;
 
     weak_ptr & operator=(weak_ptr const & r) noexcept;
@@ -98,6 +102,8 @@ namespace boost {
     long use_count() const noexcept;
     bool expired() const noexcept;
 
+    bool empty() const noexcept;
+
     shared_ptr<T> lock() const noexcept;
 
     void reset() noexcept;
@@ -106,6 +112,9 @@ namespace boost {
 
     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 Y> bool owner_equals( weak_ptr<Y> const & r ) const noexcept;
+    template<class Y> bool owner_equals( shared_ptr<Y> const & r ) const noexcept;
   };
 
   template<class T, class U>
@@ -157,6 +166,21 @@ weak_ptr(weak_ptr && r) noexcept;
 Effects:: Constructs a `weak_ptr` that has the value `r` held.
 Postconditions:: `r` is empty.
 
+### aliasing constructors
+```
+template<class Y> weak_ptr(shared_ptr<Y> const & r, element_type * p) noexcept;
+```
+```
+template<class Y> weak_ptr(weak_ptr<Y> const & r, element_type * p) noexcept;
+```
+```
+template<class Y> weak_ptr(weak_ptr<Y> && r, element_type * p) noexcept;
+```
+Effects:: Constructs a `weak_ptr` from `r` as if by using the corresponding converting/copy/move constructor, but stores `p` instead.
+Postconditions:: `use_count() == r.use_count()`. When `!expired()`, `shared_ptr<T>(*this).get() == p`.
+
+NOTE: These constructors are an extension, not present in `std::weak_ptr`.
+
 ### destructor
 ```
 ~weak_ptr() noexcept;
@@ -164,7 +188,8 @@ Postconditions:: `r` is empty.
 [none]
 * {blank}
 +
-Effects:: Destroys this `weak_ptr` but has no effect on the object its stored pointer points to.
+Effects::
+  Destroys this `weak_ptr` but has no effect on the object its stored pointer points to.
 
 ### assignment
 ```
@@ -193,7 +218,8 @@ 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`.
+Returns::
+  0 if `*this` is empty; otherwise, the number of `shared_ptr` objects that share ownership with `*this`.
 
 ### expired
 ```
@@ -202,7 +228,19 @@ bool expired() const noexcept;
 [none]
 * {blank}
 +
-Returns:: `use_count() == 0`.
+Returns::
+  `use_count() == 0`.
+
+### empty
+```
+bool empty() const noexcept;
+```
+[none]
+* {blank}
++
+Returns:: `true` when `*this` is empty, `false` otherwise.
+
+NOTE: This function is an extension, not present in `std::weak_ptr`.
 
 ### lock
 ```
@@ -211,7 +249,8 @@ shared_ptr<T> lock() const noexcept;
 [none]
 * {blank}
 +
-Returns:: `expired()? shared_ptr<T>(): shared_ptr<T>(*this)`.
+Returns::
+  `expired()? shared_ptr<T>(): shared_ptr<T>(*this)`.
 
 ### reset
 ```
@@ -220,7 +259,8 @@ void reset() noexcept;
 [none]
 * {blank}
 +
-Effects:: Equivalent to `weak_ptr().swap(*this)`.
+Effects::
+  Equivalent to `weak_ptr().swap(*this)`.
 
 ### swap
 ```
@@ -229,8 +269,10 @@ void swap(weak_ptr & b) noexcept;
 [none]
 * {blank}
 +
-Effects:: Exchanges the contents of the two smart pointers.
+Effects::
+  Exchanges the contents of the two smart pointers.
 
+### owner_before
 ```
 template<class Y> bool owner_before( weak_ptr<Y> const & r ) const noexcept;
 ```
@@ -240,7 +282,21 @@ template<class Y> bool owner_before( shared_ptr<Y> const & r ) const noexcept;
 [none]
 * {blank}
 +
-Returns:: See the description of `operator<`.
+Returns::
+  See the description of `operator<`.
+
+### owner_equals
+```
+template<class Y> bool owner_equals( weak_ptr<Y> const & r ) const noexcept;
+```
+```
+template<class Y> bool owner_equals( shared_ptr<Y> const & r ) const noexcept;
+```
+[none]
+* {blank}
++
+Returns::
+  `true` if and only if `*this` and `r` share ownership or are both empty.
 
 ## Free Functions
 
@@ -266,7 +322,8 @@ template<class T> void swap(weak_ptr<T> & a, weak_ptr<T> & b) noexcept;
 [none]
 * {blank}
 +
-Effects:: Equivalent to `a.swap(b)`.
+Effects::
+  Equivalent to `a.swap(b)`.
 
 ## Frequently Asked Questions
 

extras/src/sp_debug_hooks.cpp

@@ -73,7 +73,7 @@ void * operator new(size_t n) throw(bad_alloc)
     return p;
 }
 
-#if !defined(__BORLANDC__) || (__BORLANDC__ > 0x551)
+#if !defined(BOOST_BORLANDC) || (BOOST_BORLANDC > 0x551)
 
 void * operator new(size_t n, nothrow_t const &) throw()
 {
@@ -95,7 +95,7 @@ void * operator new[](size_t n) throw(bad_alloc)
     return p;
 }
 
-#if !defined(__BORLANDC__) || (__BORLANDC__ > 0x551)
+#if !defined(BOOST_BORLANDC) || (BOOST_BORLANDC > 0x551)
 
 void * operator new[](size_t n, nothrow_t const &) throw()
 {
@@ -205,7 +205,7 @@ void operator delete(void * p) throw()
     free(pm);
 }
 
-#if !defined(__BORLANDC__) || (__BORLANDC__ > 0x551)
+#if !defined(BOOST_BORLANDC) || (BOOST_BORLANDC > 0x551)
 
 void operator delete(void * p, nothrow_t const &) throw()
 {
@@ -231,7 +231,7 @@ void operator delete[](void * p) throw()
     free(pm);
 }
 
-#if !defined(__BORLANDC__) || (__BORLANDC__ > 0x551)
+#if !defined(BOOST_BORLANDC) || (BOOST_BORLANDC > 0x551)
 
 void operator delete[](void * p, nothrow_t const &) throw()
 {

extras/test/shared_ptr_mt_test.cpp

@@ -62,7 +62,7 @@ int main()
 
     clock_t t = clock();
 
-    pthread_t a[ m ];
+    boost::detail::lw_thread_t a[ m ];
 
     for( int i = 0; i < m; ++i )
     {
@@ -71,7 +71,7 @@ int main()
 
     for( int j = 0; j < m; ++j )
     {
-        pthread_join( a[j], 0 );
+        boost::detail::lw_thread_join( a[j] );
     }
 
     t = clock() - t;

extras/test/sp_atomic_mt2_test.cpp

@@ -228,7 +228,7 @@ int main( int ac, char const * av[] )
 
     clock_t t = clock();
 
-    std::vector<pthread_t> a( m );
+    std::vector<boost::detail::lw_thread_t> a( m );
 
     for( int i = 0; i < m; ++i )
     {
@@ -237,7 +237,7 @@ int main( int ac, char const * av[] )
 
     for( int j = 0; j < m; ++j )
     {
-        pthread_join( a[ j ], 0 );
+        boost::detail::lw_thread_join( a[ j ] );
     }
 
     t = clock() - t;

extras/test/sp_atomic_mt_test.cpp

@@ -165,7 +165,7 @@ int main()
 
     clock_t t = clock();
 
-    pthread_t a[ mr+mw ];
+    boost::detail::lw_thread_t a[ mr+mw ];
 
     for( int i = 0; i < mr; ++i )
     {
@@ -179,7 +179,7 @@ int main()
 
     for( int j = 0; j < mr+mw; ++j )
     {
-        pthread_join( a[ j ], 0 );
+        boost::detail::lw_thread_join( a[ j ] );
     }
 
     t = clock() - t;

extras/test/weak_ptr_mt_test.cpp

@@ -100,7 +100,7 @@ int main()
 
     clock_t t = clock();
 
-    pthread_t a[ m ];
+    boost::detail::lw_thread_t a[ m ];
 
     for( int i = 0; i < m; ++i )
     {
@@ -111,7 +111,7 @@ int main()
 
     for( int j = 0; j < m; ++j )
     {
-        pthread_join( a[j], 0 );
+        boost::detail::lw_thread_join( a[j] );
     }
 
     t = clock() - t;

include/boost/detail/lightweight_thread.hpp

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

include/boost/smart_ptr/allocate_local_shared_array.hpp

@@ -0,0 +1,178 @@
+/*
+Copyright 2017-2019 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+*/
+#ifndef BOOST_SMART_PTR_ALLOCATE_LOCAL_SHARED_ARRAY_HPP
+#define BOOST_SMART_PTR_ALLOCATE_LOCAL_SHARED_ARRAY_HPP
+
+#include <boost/smart_ptr/allocate_shared_array.hpp>
+#include <boost/smart_ptr/local_shared_ptr.hpp>
+
+namespace boost {
+namespace detail {
+
+class BOOST_SYMBOL_VISIBLE lsp_array_base
+    : public local_counted_base {
+public:
+    void set(sp_counted_base* base) BOOST_SP_NOEXCEPT {
+        count_ = shared_count(base);
+    }
+
+    void local_cb_destroy() BOOST_SP_NOEXCEPT BOOST_OVERRIDE {
+        shared_count().swap(count_);
+    }
+
+    shared_count local_cb_get_shared_count() const
+        BOOST_SP_NOEXCEPT BOOST_OVERRIDE {
+        return count_;
+    }
+
+private:
+    shared_count count_;
+};
+
+template<class A>
+class lsp_array_state
+    : public sp_array_state<A> {
+public:
+    template<class U>
+    lsp_array_state(const U& other, std::size_t size) BOOST_SP_NOEXCEPT
+        : sp_array_state<A>(other, size) { }
+
+    lsp_array_base& base() BOOST_SP_NOEXCEPT {
+        return base_;
+    }
+
+private:
+    lsp_array_base base_;
+};
+
+template<class A, std::size_t N>
+class lsp_size_array_state
+    : public sp_size_array_state<A, N> {
+public:
+    template<class U>
+    lsp_size_array_state(const U& other, std::size_t size) BOOST_SP_NOEXCEPT
+        : sp_size_array_state<A, N>(other, size) { }
+
+    lsp_array_base& base() BOOST_SP_NOEXCEPT {
+        return base_;
+    }
+
+private:
+    lsp_array_base base_;
+};
+
+} /* detail */
+
+template<class T, class A>
+inline typename enable_if_<is_unbounded_array<T>::value,
+    local_shared_ptr<T> >::type
+allocate_local_shared(const A& allocator, std::size_t count)
+{
+    typedef typename detail::sp_array_element<T>::type element;
+    typedef typename allocator_rebind<A, element>::type other;
+    typedef detail::lsp_array_state<other> state;
+    typedef detail::sp_array_base<state> base;
+    detail::sp_array_result<other, base> result(allocator, count);
+    base* node = result.get();
+    element* start = detail::sp_array_start<element>(node);
+    ::new(static_cast<void*>(node)) base(allocator, start, count);
+    detail::lsp_array_base& local = node->state().base();
+    local.set(node);
+    result.release();
+    return local_shared_ptr<T>(detail::lsp_internal_constructor_tag(), start,
+        &local);
+}
+
+template<class T, class A>
+inline typename enable_if_<is_bounded_array<T>::value,
+    local_shared_ptr<T> >::type
+allocate_local_shared(const A& allocator)
+{
+    enum {
+        count = extent<T>::value
+    };
+    typedef typename detail::sp_array_element<T>::type element;
+    typedef typename allocator_rebind<A, element>::type other;
+    typedef detail::lsp_size_array_state<other, count> state;
+    typedef detail::sp_array_base<state> base;
+    detail::sp_array_result<other, base> result(allocator, count);
+    base* node = result.get();
+    element* start = detail::sp_array_start<element>(node);
+    ::new(static_cast<void*>(node)) base(allocator, start, count);
+    detail::lsp_array_base& local = node->state().base();
+    local.set(node);
+    result.release();
+    return local_shared_ptr<T>(detail::lsp_internal_constructor_tag(), start,
+        &local);
+}
+
+template<class T, class A>
+inline typename enable_if_<is_unbounded_array<T>::value,
+    local_shared_ptr<T> >::type
+allocate_local_shared(const A& allocator, std::size_t count,
+    const typename remove_extent<T>::type& value)
+{
+    typedef typename detail::sp_array_element<T>::type element;
+    typedef typename allocator_rebind<A, element>::type other;
+    typedef detail::lsp_array_state<other> state;
+    typedef detail::sp_array_base<state> base;
+    detail::sp_array_result<other, base> result(allocator, count);
+    base* node = result.get();
+    element* start = detail::sp_array_start<element>(node);
+    ::new(static_cast<void*>(node)) base(allocator, start, count, value);
+    detail::lsp_array_base& local = node->state().base();
+    local.set(node);
+    result.release();
+    return local_shared_ptr<T>(detail::lsp_internal_constructor_tag(), start,
+        &local);
+}
+
+template<class T, class A>
+inline typename enable_if_<is_bounded_array<T>::value,
+    local_shared_ptr<T> >::type
+allocate_local_shared(const A& allocator,
+    const typename remove_extent<T>::type& value)
+{
+    enum {
+        count = extent<T>::value
+    };
+    typedef typename detail::sp_array_element<T>::type element;
+    typedef typename allocator_rebind<A, element>::type other;
+    typedef detail::lsp_size_array_state<other, count> state;
+    typedef detail::sp_array_base<state> base;
+    detail::sp_array_result<other, base> result(allocator, count);
+    base* node = result.get();
+    element* start = detail::sp_array_start<element>(node);
+    ::new(static_cast<void*>(node)) base(allocator, start, count, value);
+    detail::lsp_array_base& local = node->state().base();
+    local.set(node);
+    result.release();
+    return local_shared_ptr<T>(detail::lsp_internal_constructor_tag(), start,
+        &local);
+}
+
+template<class T, class A>
+inline typename enable_if_<is_unbounded_array<T>::value,
+    local_shared_ptr<T> >::type
+allocate_local_shared_noinit(const A& allocator, std::size_t count)
+{
+    return boost::allocate_local_shared<T>(boost::noinit_adapt(allocator),
+        count);
+}
+
+template<class T, class A>
+inline typename enable_if_<is_bounded_array<T>::value,
+    local_shared_ptr<T> >::type
+allocate_local_shared_noinit(const A& allocator)
+{
+    return boost::allocate_local_shared<T>(boost::noinit_adapt(allocator));
+}
+
+} /* boost */
+
+#endif

include/boost/smart_ptr/allocate_unique.hpp

@@ -0,0 +1,482 @@
+/*
+Copyright 2019 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+*/
+#ifndef BOOST_SMART_PTR_ALLOCATE_UNIQUE_HPP
+#define BOOST_SMART_PTR_ALLOCATE_UNIQUE_HPP
+
+#include <boost/smart_ptr/detail/sp_noexcept.hpp>
+#include <boost/smart_ptr/detail/sp_nullptr_t.hpp>
+#include <boost/core/allocator_access.hpp>
+#include <boost/core/alloc_construct.hpp>
+#include <boost/core/empty_value.hpp>
+#include <boost/core/first_scalar.hpp>
+#include <boost/core/noinit_adaptor.hpp>
+#include <boost/core/pointer_traits.hpp>
+#include <boost/type_traits/enable_if.hpp>
+#include <boost/type_traits/extent.hpp>
+#include <boost/type_traits/is_array.hpp>
+#include <boost/type_traits/is_bounded_array.hpp>
+#include <boost/type_traits/is_unbounded_array.hpp>
+#include <boost/type_traits/remove_cv.hpp>
+#include <boost/type_traits/remove_extent.hpp>
+#include <boost/type_traits/type_identity.hpp>
+#include <boost/config.hpp>
+#include <memory>
+#include <utility>
+
+namespace boost {
+namespace detail {
+
+template<class T>
+struct sp_alloc_size {
+    BOOST_STATIC_CONSTEXPR std::size_t value = 1;
+};
+
+template<class T>
+struct sp_alloc_size<T[]> {
+    BOOST_STATIC_CONSTEXPR std::size_t value = sp_alloc_size<T>::value;
+};
+
+template<class T, std::size_t N>
+struct sp_alloc_size<T[N]> {
+    BOOST_STATIC_CONSTEXPR std::size_t value = N * sp_alloc_size<T>::value;
+};
+
+template<class T>
+struct sp_alloc_result {
+    typedef T type;
+};
+
+template<class T, std::size_t N>
+struct sp_alloc_result<T[N]> {
+    typedef T type[];
+};
+
+template<class T>
+struct sp_alloc_value {
+    typedef typename boost::remove_cv<typename
+        boost::remove_extent<T>::type>::type type;
+};
+
+template<class T, class P>
+class sp_alloc_ptr {
+public:
+    typedef T element_type;
+
+    sp_alloc_ptr() BOOST_SP_NOEXCEPT
+        : p_() { }
+
+#if defined(BOOST_MSVC) && BOOST_MSVC == 1600
+    sp_alloc_ptr(T* p) BOOST_SP_NOEXCEPT
+        : p_(const_cast<typename boost::remove_cv<T>::type*>(p)) { }
+#endif
+
+    sp_alloc_ptr(std::size_t, P p) BOOST_SP_NOEXCEPT
+        : p_(p) { }
+
+#if !defined(BOOST_NO_CXX11_NULLPTR)
+    sp_alloc_ptr(detail::sp_nullptr_t) BOOST_SP_NOEXCEPT
+        : p_() { }
+#endif
+
+    T& operator*() const {
+        return *p_;
+    }
+
+    T* operator->() const BOOST_SP_NOEXCEPT {
+        return boost::to_address(p_);
+    }
+
+#if !defined(BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS)
+    explicit operator bool() const BOOST_SP_NOEXCEPT {
+        return !!p_;
+    }
+#endif
+
+    bool operator!() const BOOST_SP_NOEXCEPT {
+        return !p_;
+    }
+
+    P ptr() const BOOST_SP_NOEXCEPT {
+        return p_;
+    }
+
+    BOOST_STATIC_CONSTEXPR std::size_t size() BOOST_SP_NOEXCEPT {
+        return 1;
+    }
+
+#if defined(BOOST_MSVC) && BOOST_MSVC < 1910
+    static sp_alloc_ptr pointer_to(T& v) {
+        return sp_alloc_ptr(1,
+            std::pointer_traits<P>::pointer_to(const_cast<typename
+                boost::remove_cv<T>::type&>(v)));
+    }
+#endif
+
+private:
+    P p_;
+};
+
+template<class T, class P>
+class sp_alloc_ptr<T[], P> {
+public:
+    typedef T element_type;
+
+    sp_alloc_ptr() BOOST_SP_NOEXCEPT
+        : p_() { }
+
+    sp_alloc_ptr(std::size_t n, P p) BOOST_SP_NOEXCEPT
+        : p_(p)
+        , n_(n) { }
+
+#if !defined(BOOST_NO_CXX11_NULLPTR)
+    sp_alloc_ptr(detail::sp_nullptr_t) BOOST_SP_NOEXCEPT
+        : p_() { }
+#endif
+
+    T& operator[](std::size_t i) const {
+        return p_[i];
+    }
+
+#if !defined(BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS)
+    explicit operator bool() const BOOST_SP_NOEXCEPT {
+        return !!p_;
+    }
+#endif
+
+    bool operator!() const BOOST_SP_NOEXCEPT {
+        return !p_;
+    }
+
+    P ptr() const BOOST_SP_NOEXCEPT {
+        return p_;
+    }
+
+    std::size_t size() const BOOST_SP_NOEXCEPT {
+        return n_;
+    }
+
+#if defined(BOOST_MSVC) && BOOST_MSVC < 1910
+    static sp_alloc_ptr pointer_to(T& v) {
+        return sp_alloc_ptr(n_,
+            std::pointer_traits<P>::pointer_to(const_cast<typename
+                boost::remove_cv<T>::type&>(v)));
+    }
+#endif
+
+private:
+    P p_;
+    std::size_t n_;
+};
+
+template<class T, std::size_t N, class P>
+class sp_alloc_ptr<T[N], P> {
+public:
+    typedef T element_type;
+
+    sp_alloc_ptr() BOOST_SP_NOEXCEPT
+        : p_() { }
+
+    sp_alloc_ptr(std::size_t, P p) BOOST_SP_NOEXCEPT
+        : p_(p) { }
+
+#if !defined(BOOST_NO_CXX11_NULLPTR)
+    sp_alloc_ptr(detail::sp_nullptr_t) BOOST_SP_NOEXCEPT
+        : p_() { }
+#endif
+
+    T& operator[](std::size_t i) const {
+        return p_[i];
+    }
+
+#if !defined(BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS)
+    explicit operator bool() const BOOST_SP_NOEXCEPT {
+        return !!p_;
+    }
+#endif
+
+    bool operator!() const BOOST_SP_NOEXCEPT {
+        return !p_;
+    }
+
+    P ptr() const BOOST_SP_NOEXCEPT {
+        return p_;
+    }
+
+    BOOST_STATIC_CONSTEXPR std::size_t size() BOOST_SP_NOEXCEPT {
+        return N;
+    }
+
+#if defined(BOOST_MSVC) && BOOST_MSVC < 1910
+    static sp_alloc_ptr pointer_to(T& v) {
+        return sp_alloc_ptr(N,
+            std::pointer_traits<P>::pointer_to(const_cast<typename
+                boost::remove_cv<T>::type&>(v)));
+    }
+#endif
+
+private:
+    P p_;
+};
+
+template<class T, class P>
+inline bool
+operator==(const sp_alloc_ptr<T, P>& lhs, const sp_alloc_ptr<T, P>& rhs)
+{
+    return lhs.ptr() == rhs.ptr();
+}
+
+template<class T, class P>
+inline bool
+operator!=(const sp_alloc_ptr<T, P>& lhs, const sp_alloc_ptr<T, P>& rhs)
+{
+    return !(lhs == rhs);
+}
+
+#if !defined(BOOST_NO_CXX11_NULLPTR)
+template<class T, class P>
+inline bool
+operator==(const sp_alloc_ptr<T, P>& lhs,
+    detail::sp_nullptr_t) BOOST_SP_NOEXCEPT
+{
+    return !lhs.ptr();
+}
+
+template<class T, class P>
+inline bool
+operator==(detail::sp_nullptr_t,
+    const sp_alloc_ptr<T, P>& rhs) BOOST_SP_NOEXCEPT
+{
+    return !rhs.ptr();
+}
+
+template<class T, class P>
+inline bool
+operator!=(const sp_alloc_ptr<T, P>& lhs,
+    detail::sp_nullptr_t) BOOST_SP_NOEXCEPT
+{
+    return !!lhs.ptr();
+}
+
+template<class T, class P>
+inline bool
+operator!=(detail::sp_nullptr_t,
+    const sp_alloc_ptr<T, P>& rhs) BOOST_SP_NOEXCEPT
+{
+    return !!rhs.ptr();
+}
+#endif
+
+template<class A>
+inline void
+sp_alloc_clear(A& a, typename boost::allocator_pointer<A>::type p, std::size_t,
+    boost::false_type)
+{
+    boost::alloc_destroy(a, boost::to_address(p));
+}
+
+template<class A>
+inline void
+sp_alloc_clear(A& a, typename boost::allocator_pointer<A>::type p,
+    std::size_t n, boost::true_type)
+{
+#if defined(BOOST_MSVC) && BOOST_MSVC < 1800
+    if (!p) {
+        return;
+    }
+#endif
+    boost::alloc_destroy_n(a, boost::first_scalar(boost::to_address(p)),
+        n * sp_alloc_size<typename A::value_type>::value);
+}
+
+} /* detail */
+
+template<class T, class A>
+class alloc_deleter
+    : empty_value<typename allocator_rebind<A,
+        typename detail::sp_alloc_value<T>::type>::type> {
+    typedef typename allocator_rebind<A,
+        typename detail::sp_alloc_value<T>::type>::type allocator;
+    typedef empty_value<allocator> base;
+
+public:
+    typedef detail::sp_alloc_ptr<T,
+        typename allocator_pointer<allocator>::type> pointer;
+
+    explicit alloc_deleter(const allocator& a) BOOST_SP_NOEXCEPT
+        : base(empty_init_t(), a) { }
+
+    void operator()(pointer p) {
+        detail::sp_alloc_clear(base::get(), p.ptr(), p.size(), is_array<T>());
+        base::get().deallocate(p.ptr(), p.size());
+    }
+};
+
+#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+template<class T, class A>
+using alloc_noinit_deleter = alloc_deleter<T, noinit_adaptor<A> >;
+#endif
+
+namespace detail {
+
+template<class T, class A>
+class sp_alloc_make {
+public:
+    typedef typename boost::allocator_rebind<A,
+        typename sp_alloc_value<T>::type>::type allocator;
+
+private:
+    typedef boost::alloc_deleter<T, A> deleter;
+
+public:
+    typedef std::unique_ptr<typename sp_alloc_result<T>::type, deleter> type;
+
+    sp_alloc_make(const A& a, std::size_t n)
+        : a_(a)
+        , n_(n)
+        , p_(a_.allocate(n)) { }
+
+    ~sp_alloc_make() {
+        if (p_) {
+            a_.deallocate(p_, n_);
+        }
+    }
+
+    typename allocator::value_type* get() const BOOST_SP_NOEXCEPT {
+        return boost::to_address(p_);
+    }
+
+    allocator& state() BOOST_SP_NOEXCEPT {
+        return a_;
+    }
+
+    type release() BOOST_SP_NOEXCEPT {
+        pointer p = p_;
+        p_ = pointer();
+        return type(typename deleter::pointer(n_, p), deleter(a_));
+    }
+
+private:
+    typedef typename boost::allocator_pointer<allocator>::type pointer;
+
+    allocator a_;
+    std::size_t n_;
+    pointer p_;
+};
+
+} /* detail */
+
+template<class T, class A>
+inline typename enable_if_<!is_array<T>::value,
+    std::unique_ptr<T, alloc_deleter<T, A> > >::type
+allocate_unique(const A& alloc)
+{
+    detail::sp_alloc_make<T, A> c(alloc, 1);
+    boost::alloc_construct(c.state(), c.get());
+    return c.release();
+}
+
+#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+template<class T, class A, class... Args>
+inline typename enable_if_<!is_array<T>::value,
+    std::unique_ptr<T, alloc_deleter<T, A> > >::type
+allocate_unique(const A& alloc, Args&&... args)
+{
+    detail::sp_alloc_make<T, A> c(alloc, 1);
+    boost::alloc_construct(c.state(), c.get(), std::forward<Args>(args)...);
+    return c.release();
+}
+#endif
+
+template<class T, class A>
+inline typename enable_if_<!is_array<T>::value,
+    std::unique_ptr<T, alloc_deleter<T, A> > >::type
+allocate_unique(const A& alloc, typename type_identity<T>::type&& value)
+{
+    detail::sp_alloc_make<T, A> c(alloc, 1);
+    boost::alloc_construct(c.state(), c.get(), std::move(value));
+    return c.release();
+}
+
+template<class T, class A>
+inline typename enable_if_<!is_array<T>::value,
+    std::unique_ptr<T, alloc_deleter<T, noinit_adaptor<A> > > >::type
+allocate_unique_noinit(const A& alloc)
+{
+    return boost::allocate_unique<T, noinit_adaptor<A> >(alloc);
+}
+
+template<class T, class A>
+inline typename enable_if_<is_unbounded_array<T>::value,
+    std::unique_ptr<T, alloc_deleter<T, A> > >::type
+allocate_unique(const A& alloc, std::size_t size)
+{
+    detail::sp_alloc_make<T, A> c(alloc, size);
+    boost::alloc_construct_n(c.state(), boost::first_scalar(c.get()),
+        size * detail::sp_alloc_size<T>::value);
+    return c.release();
+}
+
+template<class T, class A>
+inline typename enable_if_<is_bounded_array<T>::value,
+    std::unique_ptr<typename detail::sp_alloc_result<T>::type,
+        alloc_deleter<T, A> > >::type
+allocate_unique(const A& alloc)
+{
+    detail::sp_alloc_make<T, A> c(alloc, extent<T>::value);
+    boost::alloc_construct_n(c.state(), boost::first_scalar(c.get()),
+        detail::sp_alloc_size<T>::value);
+    return c.release();
+}
+
+template<class T, class A>
+inline typename enable_if_<is_unbounded_array<T>::value,
+    std::unique_ptr<T, alloc_deleter<T, noinit_adaptor<A> > > >::type
+allocate_unique_noinit(const A& alloc, std::size_t size)
+{
+    return boost::allocate_unique<T, noinit_adaptor<A> >(alloc, size);
+}
+
+template<class T, class A>
+inline typename enable_if_<is_bounded_array<T>::value,
+    std::unique_ptr<typename detail::sp_alloc_result<T>::type,
+        alloc_deleter<T, noinit_adaptor<A> > > >::type
+allocate_unique_noinit(const A& alloc)
+{
+    return boost::allocate_unique<T, noinit_adaptor<A> >(alloc);
+}
+
+template<class T, class A>
+inline typename enable_if_<is_unbounded_array<T>::value,
+    std::unique_ptr<T, alloc_deleter<T, A> > >::type
+allocate_unique(const A& alloc, std::size_t size,
+    const typename remove_extent<T>::type& value)
+{
+    detail::sp_alloc_make<T, A> c(alloc, size);
+    boost::alloc_construct_n(c.state(), boost::first_scalar(c.get()),
+        size * detail::sp_alloc_size<T>::value, boost::first_scalar(&value),
+        detail::sp_alloc_size<typename remove_extent<T>::type>::value);
+    return c.release();
+}
+
+template<class T, class A>
+inline typename enable_if_<is_bounded_array<T>::value,
+    std::unique_ptr<typename detail::sp_alloc_result<T>::type,
+        alloc_deleter<T, A> > >::type
+allocate_unique(const A& alloc,
+    const typename remove_extent<T>::type& value)
+{
+    detail::sp_alloc_make<T, A> c(alloc, extent<T>::value);
+    boost::alloc_construct_n(c.state(), boost::first_scalar(c.get()),
+        detail::sp_alloc_size<T>::value, boost::first_scalar(&value),
+        detail::sp_alloc_size<typename remove_extent<T>::type>::value);
+    return c.release();
+}
+
+} /* boost */
+
+#endif

include/boost/smart_ptr/atomic_shared_ptr.hpp

@@ -63,6 +63,11 @@ public:
     {
     }
 
+    atomic_shared_ptr( shared_ptr<T> p ) BOOST_SP_NOEXCEPT
+        : p_( std::move( p ) ), l_ BOOST_DETAIL_SPINLOCK_INIT
+    {
+    }
+
 #else
 
     atomic_shared_ptr() BOOST_SP_NOEXCEPT
@@ -71,8 +76,6 @@ public:
         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 ) )
@@ -84,6 +87,8 @@ public:
         std::memcpy( &l_, &init, sizeof( init ) );
     }
 
+#endif
+
     atomic_shared_ptr& operator=( shared_ptr<T> r ) BOOST_SP_NOEXCEPT
     {
         boost::detail::spinlock::scoped_lock lock( l_ );
@@ -97,7 +102,13 @@ public:
         return false;
     }
 
-    shared_ptr<T> load( int = 0 ) const BOOST_SP_NOEXCEPT
+    shared_ptr<T> load() const BOOST_SP_NOEXCEPT
+    {
+        boost::detail::spinlock::scoped_lock lock( l_ );
+        return p_;
+    }
+
+    template<class M> shared_ptr<T> load( M ) const BOOST_SP_NOEXCEPT
     {
         boost::detail::spinlock::scoped_lock lock( l_ );
         return p_;
@@ -109,13 +120,19 @@ public:
         return p_;
     }
 
-    void store( shared_ptr<T> r, int = 0 ) BOOST_SP_NOEXCEPT
+    void store( shared_ptr<T> r ) 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
+    template<class M> void store( shared_ptr<T> r, M ) BOOST_SP_NOEXCEPT
+    {
+        boost::detail::spinlock::scoped_lock lock( l_ );
+        p_.swap( r );
+    }
+
+    shared_ptr<T> exchange( shared_ptr<T> r ) BOOST_SP_NOEXCEPT
     {
         {
             boost::detail::spinlock::scoped_lock lock( l_ );
@@ -133,44 +150,82 @@ public:
 #endif
     }
 
-    bool compare_exchange_weak( shared_ptr<T>& v, const shared_ptr<T>& w, int, int ) BOOST_SP_NOEXCEPT
+    template<class M> shared_ptr<T> exchange( shared_ptr<T> r, M ) 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
+    }
+
+    template<class M> bool compare_exchange_weak( shared_ptr<T>& v, const shared_ptr<T>& w, M, M ) 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
+    template<class M> bool compare_exchange_weak( shared_ptr<T>& v, const shared_ptr<T>& w, M ) 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
+    bool compare_exchange_weak( shared_ptr<T>& v, const shared_ptr<T>& w ) 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
+    template<class M> bool compare_exchange_strong( shared_ptr<T>& v, const shared_ptr<T>& w, M, M ) BOOST_SP_NOEXCEPT
+    {
+        return compare_exchange( v, w );
+    }
+
+    template<class M> bool compare_exchange_strong( shared_ptr<T>& v, const shared_ptr<T>& w, M ) BOOST_SP_NOEXCEPT
+    {
+        return compare_exchange( v, w );
+    }
+
+    bool compare_exchange_strong( shared_ptr<T>& v, const shared_ptr<T>& w ) 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
+    template<class M> bool compare_exchange_weak( shared_ptr<T>& v, shared_ptr<T>&& w, M, M ) 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
+    template<class M> bool compare_exchange_weak( shared_ptr<T>& v, shared_ptr<T>&& w, M ) 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
+    bool compare_exchange_weak( shared_ptr<T>& v, shared_ptr<T>&& w ) 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
+    template<class M> bool compare_exchange_strong( shared_ptr<T>& v, shared_ptr<T>&& w, M, M ) BOOST_SP_NOEXCEPT
+    {
+        return compare_exchange( v, std::move( w ) );
+    }
+
+    template<class M> bool compare_exchange_strong( shared_ptr<T>& v, shared_ptr<T>&& w, M ) BOOST_SP_NOEXCEPT
+    {
+        return compare_exchange( v, std::move( w ) );
+    }
+
+    bool compare_exchange_strong( shared_ptr<T>& v, shared_ptr<T>&& w ) BOOST_SP_NOEXCEPT
     {
         return compare_exchange( v, std::move( w ) );
     }

include/boost/smart_ptr/bad_weak_ptr.hpp

@@ -20,7 +20,7 @@
 #include <boost/config.hpp>
 #include <exception>
 
-#ifdef __BORLANDC__
+#ifdef BOOST_BORLANDC
 # pragma warn -8026     // Functions with excep. spec. are not expanded inline
 #endif
 
@@ -33,7 +33,7 @@ namespace boost
 // is compiled with -ps, the compiler issues an error.
 // Hence, the temporary #pragma option -pc below.
 
-#if defined(__BORLANDC__) && __BORLANDC__ <= 0x564
+#if defined(BOOST_BORLANDC) && BOOST_BORLANDC <= 0x564
 # pragma option push -pc
 #endif
 
@@ -47,7 +47,7 @@ class bad_weak_ptr: public std::exception
 {
 public:
 
-    virtual char const * what() const throw()
+    char const * what() const BOOST_NOEXCEPT_OR_NOTHROW BOOST_OVERRIDE
     {
         return "tr1::bad_weak_ptr";
     }
@@ -57,13 +57,13 @@ public:
 # pragma clang diagnostic pop
 #endif
 
-#if defined(__BORLANDC__) && __BORLANDC__ <= 0x564
+#if defined(BOOST_BORLANDC) && BOOST_BORLANDC <= 0x564
 # pragma option pop
 #endif
 
 } // namespace boost
 
-#ifdef __BORLANDC__
+#ifdef BOOST_BORLANDC
 # pragma warn .8026     // Functions with excep. spec. are not expanded inline
 #endif
 

include/boost/smart_ptr/detail/atomic_count_gcc.hpp

@@ -23,6 +23,13 @@
 # include <bits/atomicity.h>
 #endif
 
+#if defined(BOOST_SP_REPORT_IMPLEMENTATION)
+
+#include <boost/config/pragma_message.hpp>
+BOOST_PRAGMA_MESSAGE("Using libstdc++ atomic_count")
+
+#endif
+
 namespace boost
 {
 

include/boost/smart_ptr/detail/atomic_count_gcc_x86.hpp

@@ -13,6 +13,13 @@
 //  http://www.boost.org/LICENSE_1_0.txt)
 //
 
+#if defined(BOOST_SP_REPORT_IMPLEMENTATION)
+
+#include <boost/config/pragma_message.hpp>
+BOOST_PRAGMA_MESSAGE("Using g++/x86 atomic_count")
+
+#endif
+
 namespace boost
 {
 

include/boost/smart_ptr/detail/atomic_count_nt.hpp

@@ -15,6 +15,13 @@
 //  http://www.boost.org/LICENSE_1_0.txt
 //
 
+#if defined(BOOST_SP_REPORT_IMPLEMENTATION)
+
+#include <boost/config/pragma_message.hpp>
+BOOST_PRAGMA_MESSAGE("Using single-threaded, non-atomic atomic_count")
+
+#endif
+
 namespace boost
 {
 

include/boost/smart_ptr/detail/atomic_count_pt.hpp

@@ -14,6 +14,13 @@
 #include <boost/assert.hpp>
 #include <pthread.h>
 
+#if defined(BOOST_SP_REPORT_IMPLEMENTATION)
+
+#include <boost/config/pragma_message.hpp>
+BOOST_PRAGMA_MESSAGE("Using pthread_mutex atomic_count")
+
+#endif
+
 //
 //  The generic pthread_mutex-based implementation sometimes leads to
 //    inefficiencies. Example: a class with two atomic_count members

include/boost/smart_ptr/detail/atomic_count_solaris.hpp

@@ -15,6 +15,13 @@
 
 #include <atomic.h>
 
+#if defined(BOOST_SP_REPORT_IMPLEMENTATION)
+
+#include <boost/config/pragma_message.hpp>
+BOOST_PRAGMA_MESSAGE("Using Solaris atomic_count")
+
+#endif
+
 namespace boost
 {
 

include/boost/smart_ptr/detail/atomic_count_spin.hpp

@@ -13,6 +13,13 @@
 
 #include <boost/smart_ptr/detail/spinlock_pool.hpp>
 
+#if defined(BOOST_SP_REPORT_IMPLEMENTATION)
+
+#include <boost/config/pragma_message.hpp>
+BOOST_PRAGMA_MESSAGE("Using spinlock-based atomic_count")
+
+#endif
+
 namespace boost
 {
 

include/boost/smart_ptr/detail/atomic_count_std_atomic.hpp

@@ -16,6 +16,13 @@
 #include <atomic>
 #include <cstdint>
 
+#if defined(BOOST_SP_REPORT_IMPLEMENTATION)
+
+#include <boost/config/pragma_message.hpp>
+BOOST_PRAGMA_MESSAGE("Using std::atomic atomic_count")
+
+#endif
+
 namespace boost
 {
 
@@ -26,7 +33,7 @@ class atomic_count
 {
 public:
 
-    explicit atomic_count( long v ): value_( v )
+    explicit atomic_count( long v ): value_( static_cast< std::int_least32_t >( v ) )
     {
     }
 

include/boost/smart_ptr/detail/atomic_count_sync.hpp

@@ -19,6 +19,13 @@
 # include <ia64intrin.h>
 #endif
 
+#if defined(BOOST_SP_REPORT_IMPLEMENTATION)
+
+#include <boost/config/pragma_message.hpp>
+BOOST_PRAGMA_MESSAGE("Using __sync atomic_count")
+
+#endif
+
 namespace boost
 {
 

include/boost/smart_ptr/detail/atomic_count_win32.hpp

@@ -19,6 +19,13 @@
 
 #include <boost/smart_ptr/detail/sp_interlocked.hpp>
 
+#if defined(BOOST_SP_REPORT_IMPLEMENTATION)
+
+#include <boost/config/pragma_message.hpp>
+BOOST_PRAGMA_MESSAGE("Using Win32 atomic_count")
+
+#endif
+
 namespace boost
 {
 

include/boost/smart_ptr/detail/lightweight_mutex.hpp

@@ -28,15 +28,12 @@
 
 #include <boost/config.hpp>
 
-#if !defined(BOOST_HAS_THREADS)
-#  include <boost/smart_ptr/detail/lwm_nop.hpp>
-#elif defined(BOOST_HAS_PTHREADS)
-#  include <boost/smart_ptr/detail/lwm_pthreads.hpp>
-#elif defined(BOOST_HAS_WINTHREADS) || defined(WIN32) || defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+#if !defined(BOOST_NO_CXX11_HDR_MUTEX )
+#  include <boost/smart_ptr/detail/lwm_std_mutex.hpp>
+#elif defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 #  include <boost/smart_ptr/detail/lwm_win32_cs.hpp>
 #else
-// Use #define BOOST_DISABLE_THREADS to avoid the error
-#  error Unrecognized threading platform
+#  include <boost/smart_ptr/detail/lwm_pthreads.hpp>
 #endif
 
 #endif // #ifndef BOOST_SMART_PTR_DETAIL_LIGHTWEIGHT_MUTEX_HPP_INCLUDED

include/boost/smart_ptr/detail/lightweight_thread.hpp

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

include/boost/smart_ptr/detail/local_counted_base.hpp

@@ -20,7 +20,6 @@
 #include <boost/smart_ptr/detail/shared_count.hpp>
 #include <boost/config.hpp>
 #include <utility>
-#include <climits>
 
 namespace boost
 {
@@ -28,7 +27,7 @@ namespace boost
 namespace detail
 {
 
-class local_counted_base
+class BOOST_SYMBOL_VISIBLE local_counted_base
 {
 private:
 
@@ -37,7 +36,7 @@ private:
 private:
 
     // not 'int' or 'unsigned' to avoid aliasing and enable optimizations
-    enum count_type { min_ = 0, initial_ = 1, max_ = UINT_MAX };
+    enum count_type { min_ = 0, initial_ = 1, max_ = 2147483647 };
 
     count_type local_use_count_;
 
@@ -61,12 +60,14 @@ public:
 
     void add_ref() BOOST_SP_NOEXCEPT
     {
+#if !defined(__NVCC__)
 #if defined( __has_builtin )
 # if __has_builtin( __builtin_assume )
 
         __builtin_assume( local_use_count_ >= 1 );
 
 # endif
+#endif
 #endif
 
         local_use_count_ = static_cast<count_type>( local_use_count_ + 1 );
@@ -88,7 +89,7 @@ public:
     }
 };
 
-class local_counted_impl: public local_counted_base
+class BOOST_SYMBOL_VISIBLE local_counted_impl: public local_counted_base
 {
 private:
 
@@ -100,41 +101,41 @@ private:
 
 public:
 
-    explicit local_counted_impl( shared_count const& pn ): pn_( pn )
+    explicit local_counted_impl( shared_count const& pn ) BOOST_SP_NOEXCEPT: pn_( pn )
     {
     }
 
 #if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
 
-    explicit local_counted_impl( shared_count && pn ): pn_( std::move(pn) )
+    explicit local_counted_impl( shared_count && pn ) BOOST_SP_NOEXCEPT: pn_( std::move(pn) )
     {
     }
 
 #endif
 
-    virtual void local_cb_destroy() BOOST_SP_NOEXCEPT
+    void local_cb_destroy() BOOST_SP_NOEXCEPT BOOST_OVERRIDE
     {
         delete this;
     }
 
-    virtual boost::detail::shared_count local_cb_get_shared_count() const BOOST_SP_NOEXCEPT
+    boost::detail::shared_count local_cb_get_shared_count() const BOOST_SP_NOEXCEPT BOOST_OVERRIDE
     {
         return pn_;
     }
 };
 
-class local_counted_impl_em: public local_counted_base
+class BOOST_SYMBOL_VISIBLE local_counted_impl_em: public local_counted_base
 {
 public:
 
     shared_count pn_;
 
-    virtual void local_cb_destroy() BOOST_SP_NOEXCEPT
+    void local_cb_destroy() BOOST_SP_NOEXCEPT BOOST_OVERRIDE
     {
         shared_count().swap( pn_ );
     }
 
-    virtual boost::detail::shared_count local_cb_get_shared_count() const BOOST_SP_NOEXCEPT
+    boost::detail::shared_count local_cb_get_shared_count() const BOOST_SP_NOEXCEPT BOOST_OVERRIDE
     {
         return pn_;
     }

include/boost/smart_ptr/detail/local_sp_deleter.hpp

@@ -50,7 +50,7 @@ public:
 
 #endif
 
-    D& deleter()
+    D& deleter() BOOST_SP_NOEXCEPT
     {
         return d_;
     }
@@ -74,12 +74,12 @@ template<> class local_sp_deleter<void>
 {
 };
 
-template<class D> D * get_local_deleter( local_sp_deleter<D> * p )
+template<class D> D * get_local_deleter( local_sp_deleter<D> * p ) BOOST_SP_NOEXCEPT
 {
     return &p->deleter();
 }
 
-inline void * get_local_deleter( local_sp_deleter<void> * /*p*/ )
+inline void * get_local_deleter( local_sp_deleter<void> * /*p*/ ) BOOST_SP_NOEXCEPT
 {
     return 0;
 }

include/boost/smart_ptr/detail/lwm_nop.hpp

@@ -1,37 +0,0 @@
-#ifndef BOOST_SMART_PTR_DETAIL_LWM_NOP_HPP_INCLUDED
-#define BOOST_SMART_PTR_DETAIL_LWM_NOP_HPP_INCLUDED
-
-// MS compatible compilers support #pragma once
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-//
-//  boost/detail/lwm_nop.hpp
-//
-//  Copyright (c) 2002 Peter Dimov and Multi Media Ltd.
-//
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-//
-
-namespace boost
-{
-
-namespace detail
-{
-
-class lightweight_mutex
-{
-public:
-
-    typedef lightweight_mutex scoped_lock;
-};
-
-} // namespace detail
-
-} // namespace boost
-
-#endif // #ifndef BOOST_SMART_PTR_DETAIL_LWM_NOP_HPP_INCLUDED

include/boost/smart_ptr/detail/lwm_std_mutex.hpp

@@ -0,0 +1,62 @@
+#ifndef BOOST_SMART_PTR_DETAIL_LWM_STD_MUTEX_HPP_INCLUDED
+#define BOOST_SMART_PTR_DETAIL_LWM_STD_MUTEX_HPP_INCLUDED
+
+// Copyright 2020 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/assert.hpp>
+#include <mutex>
+
+namespace boost
+{
+
+namespace detail
+{
+
+class lightweight_mutex
+{
+private:
+
+    std::mutex m_;
+
+    lightweight_mutex(lightweight_mutex const &);
+    lightweight_mutex & operator=(lightweight_mutex const &);
+
+public:
+
+    lightweight_mutex()
+    {
+    }
+
+    class scoped_lock;
+    friend class scoped_lock;
+
+    class scoped_lock
+    {
+    private:
+
+        std::mutex & m_;
+
+        scoped_lock(scoped_lock const &);
+        scoped_lock & operator=(scoped_lock const &);
+
+    public:
+
+        scoped_lock( lightweight_mutex & m ): m_( m.m_ )
+        {
+            m_.lock();
+        }
+
+        ~scoped_lock()
+        {
+            m_.unlock();
+        }
+    };
+};
+
+} // namespace detail
+
+} // namespace boost
+
+#endif // #ifndef BOOST_SMART_PTR_DETAIL_LWM_STD_MUTEX_HPP_INCLUDED

include/boost/smart_ptr/detail/lwm_win32_cs.hpp

@@ -11,15 +11,12 @@
 //  boost/detail/lwm_win32_cs.hpp
 //
 //  Copyright (c) 2002, 2003 Peter Dimov
-//  Copyright (c) Microsoft Corporation 2014
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 //
 
-#include <boost/predef.h>
-
 #ifdef BOOST_USE_WINDOWS_H
 
 #include <windows.h>
@@ -52,19 +49,24 @@ struct critical_section
 #endif
 };
 
-#if BOOST_PLAT_WINDOWS_RUNTIME
-extern "C" __declspec(dllimport) void __stdcall InitializeCriticalSectionEx(::_RTL_CRITICAL_SECTION *, unsigned long, unsigned long);
-#else
 extern "C" __declspec(dllimport) void __stdcall InitializeCriticalSection(::_RTL_CRITICAL_SECTION *);
-#endif
 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
+typedef ::_RTL_CRITICAL_SECTION rtl_critical_section;
+
+#else // #ifndef BOOST_USE_WINDOWS_H
 
 typedef ::CRITICAL_SECTION critical_section;
 
+using ::InitializeCriticalSection;
+using ::EnterCriticalSection;
+using ::LeaveCriticalSection;
+using ::DeleteCriticalSection;
+
+typedef ::CRITICAL_SECTION rtl_critical_section;
+
 #endif // #ifndef BOOST_USE_WINDOWS_H
 
 class lightweight_mutex
@@ -80,16 +82,12 @@ public:
 
     lightweight_mutex()
     {
-#if BOOST_PLAT_WINDOWS_RUNTIME
-        boost::detail::InitializeCriticalSectionEx(reinterpret_cast< ::_RTL_CRITICAL_SECTION* >(&cs_), 4000, 0);
-#else
-        boost::detail::InitializeCriticalSection(reinterpret_cast< ::_RTL_CRITICAL_SECTION* >(&cs_));
-#endif
+        boost::detail::InitializeCriticalSection(reinterpret_cast< rtl_critical_section* >(&cs_));
     }
 
     ~lightweight_mutex()
     {
-        boost::detail::DeleteCriticalSection(reinterpret_cast< ::_RTL_CRITICAL_SECTION* >(&cs_));
+        boost::detail::DeleteCriticalSection(reinterpret_cast< rtl_critical_section* >(&cs_));
     }
 
     class scoped_lock;
@@ -108,12 +106,12 @@ public:
 
         explicit scoped_lock(lightweight_mutex & m): m_(m)
         {
-            boost::detail::EnterCriticalSection(reinterpret_cast< ::_RTL_CRITICAL_SECTION* >(&m_.cs_));
+            boost::detail::EnterCriticalSection(reinterpret_cast< rtl_critical_section* >(&m_.cs_));
         }
 
         ~scoped_lock()
         {
-            boost::detail::LeaveCriticalSection(reinterpret_cast< ::_RTL_CRITICAL_SECTION* >(&m_.cs_));
+            boost::detail::LeaveCriticalSection(reinterpret_cast< rtl_critical_section* >(&m_.cs_));
         }
     };
 };

include/boost/smart_ptr/detail/shared_count.hpp

@@ -18,7 +18,7 @@
 // http://www.boost.org/LICENSE_1_0.txt)
 //
 
-#ifdef __BORLANDC__
+#if defined(__BORLANDC__) && !defined(__clang__)
 # pragma warn -8027     // Functions containing try are not expanded inline
 #endif
 
@@ -29,7 +29,8 @@
 #include <boost/smart_ptr/detail/sp_counted_base.hpp>
 #include <boost/smart_ptr/detail/sp_counted_impl.hpp>
 #include <boost/smart_ptr/detail/sp_disable_deprecated.hpp>
-#include <boost/detail/workaround.hpp>
+#include <boost/smart_ptr/detail/sp_noexcept.hpp>
+#include <boost/config/workaround.hpp>
 // In order to avoid circular dependencies with Boost.TR1
 // we make sure that our include of <memory> doesn't try to
 // pull in the TR1 headers: that's why we use this header 
@@ -118,7 +119,14 @@ private:
 
 public:
 
-    BOOST_CONSTEXPR shared_count(): pi_(0) // nothrow
+    BOOST_CONSTEXPR shared_count() BOOST_SP_NOEXCEPT: pi_(0)
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+        , id_(shared_count_id)
+#endif
+    {
+    }
+
+    BOOST_CONSTEXPR explicit shared_count( sp_counted_base * pi ) BOOST_SP_NOEXCEPT: pi_( pi )
 #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
         , id_(shared_count_id)
 #endif
@@ -414,7 +422,7 @@ public:
         r.release();
     }
 
-    ~shared_count() // nothrow
+    ~shared_count() /*BOOST_SP_NOEXCEPT*/
     {
         if( pi_ != 0 ) pi_->release();
 #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
@@ -422,7 +430,7 @@ public:
 #endif
     }
 
-    shared_count(shared_count const & r): pi_(r.pi_) // nothrow
+    shared_count(shared_count const & r) BOOST_SP_NOEXCEPT: pi_(r.pi_)
 #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
         , id_(shared_count_id)
 #endif
@@ -432,7 +440,7 @@ public:
 
 #if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
 
-    shared_count(shared_count && r): pi_(r.pi_) // nothrow
+    shared_count(shared_count && r) BOOST_SP_NOEXCEPT: pi_(r.pi_)
 #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
         , id_(shared_count_id)
 #endif
@@ -443,9 +451,9 @@ public:
 #endif
 
     explicit shared_count(weak_count const & r); // throws bad_weak_ptr when r.use_count() == 0
-    shared_count( weak_count const & r, sp_nothrow_tag ); // constructs an empty *this when r.use_count() == 0
+    shared_count( weak_count const & r, sp_nothrow_tag ) BOOST_SP_NOEXCEPT; // constructs an empty *this when r.use_count() == 0
 
-    shared_count & operator= (shared_count const & r) // nothrow
+    shared_count & operator= (shared_count const & r) BOOST_SP_NOEXCEPT
     {
         sp_counted_base * tmp = r.pi_;
 
@@ -459,49 +467,53 @@ public:
         return *this;
     }
 
-    void swap(shared_count & r) // nothrow
+    void swap(shared_count & r) BOOST_SP_NOEXCEPT
     {
         sp_counted_base * tmp = r.pi_;
         r.pi_ = pi_;
         pi_ = tmp;
     }
 
-    long use_count() const // nothrow
+    long use_count() const BOOST_SP_NOEXCEPT
     {
         return pi_ != 0? pi_->use_count(): 0;
     }
 
-    bool unique() const // nothrow
+    bool unique() const BOOST_SP_NOEXCEPT
     {
         return use_count() == 1;
     }
 
-    bool empty() const // nothrow
+    bool empty() const BOOST_SP_NOEXCEPT
     {
         return pi_ == 0;
     }
 
-    friend inline bool operator==(shared_count const & a, shared_count const & b)
+    bool operator==( shared_count const & r ) const BOOST_SP_NOEXCEPT
     {
-        return a.pi_ == b.pi_;
+        return pi_ == r.pi_;
     }
 
-    friend inline bool operator<(shared_count const & a, shared_count const & b)
+    bool operator==( weak_count const & r ) const BOOST_SP_NOEXCEPT;
+
+    bool operator<( shared_count const & r ) const BOOST_SP_NOEXCEPT
     {
-        return std::less<sp_counted_base *>()( a.pi_, b.pi_ );
+        return std::less<sp_counted_base *>()( pi_, r.pi_ );
     }
 
-    void * get_deleter( sp_typeinfo const & ti ) const
+    bool operator<( weak_count const & r ) const BOOST_SP_NOEXCEPT;
+
+    void * get_deleter( sp_typeinfo_ const & ti ) const BOOST_SP_NOEXCEPT
     {
         return pi_? pi_->get_deleter( ti ): 0;
     }
 
-    void * get_local_deleter( sp_typeinfo const & ti ) const
+    void * get_local_deleter( sp_typeinfo_ const & ti ) const BOOST_SP_NOEXCEPT
     {
         return pi_? pi_->get_local_deleter( ti ): 0;
     }
 
-    void * get_untyped_deleter() const
+    void * get_untyped_deleter() const BOOST_SP_NOEXCEPT
     {
         return pi_? pi_->get_untyped_deleter(): 0;
     }
@@ -522,14 +534,14 @@ private:
 
 public:
 
-    BOOST_CONSTEXPR weak_count(): pi_(0) // nothrow
+    BOOST_CONSTEXPR weak_count() BOOST_SP_NOEXCEPT: pi_(0)
 #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
         , id_(weak_count_id)
 #endif
     {
     }
 
-    weak_count(shared_count const & r): pi_(r.pi_) // nothrow
+    weak_count(shared_count const & r) BOOST_SP_NOEXCEPT: pi_(r.pi_)
 #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
         , id_(weak_count_id)
 #endif
@@ -537,7 +549,7 @@ public:
         if(pi_ != 0) pi_->weak_add_ref();
     }
 
-    weak_count(weak_count const & r): pi_(r.pi_) // nothrow
+    weak_count(weak_count const & r) BOOST_SP_NOEXCEPT: pi_(r.pi_)
 #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
         , id_(weak_count_id)
 #endif
@@ -549,7 +561,7 @@ public:
 
 #if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
 
-    weak_count(weak_count && r): pi_(r.pi_) // nothrow
+    weak_count(weak_count && r) BOOST_SP_NOEXCEPT: pi_(r.pi_)
 #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
         , id_(weak_count_id)
 #endif
@@ -559,7 +571,7 @@ public:
 
 #endif
 
-    ~weak_count() // nothrow
+    ~weak_count() /*BOOST_SP_NOEXCEPT*/
     {
         if(pi_ != 0) pi_->weak_release();
 #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
@@ -567,7 +579,7 @@ public:
 #endif
     }
 
-    weak_count & operator= (shared_count const & r) // nothrow
+    weak_count & operator= (shared_count const & r) BOOST_SP_NOEXCEPT
     {
         sp_counted_base * tmp = r.pi_;
 
@@ -581,7 +593,7 @@ public:
         return *this;
     }
 
-    weak_count & operator= (weak_count const & r) // nothrow
+    weak_count & operator= (weak_count const & r) BOOST_SP_NOEXCEPT
     {
         sp_counted_base * tmp = r.pi_;
 
@@ -595,31 +607,41 @@ public:
         return *this;
     }
 
-    void swap(weak_count & r) // nothrow
+    void swap(weak_count & r) BOOST_SP_NOEXCEPT
     {
         sp_counted_base * tmp = r.pi_;
         r.pi_ = pi_;
         pi_ = tmp;
     }
 
-    long use_count() const // nothrow
+    long use_count() const BOOST_SP_NOEXCEPT
     {
         return pi_ != 0? pi_->use_count(): 0;
     }
 
-    bool empty() const // nothrow
+    bool empty() const BOOST_SP_NOEXCEPT
     {
         return pi_ == 0;
     }
 
-    friend inline bool operator==(weak_count const & a, weak_count const & b)
+    bool operator==( weak_count const & r ) const BOOST_SP_NOEXCEPT
     {
-        return a.pi_ == b.pi_;
+        return pi_ == r.pi_;
     }
 
-    friend inline bool operator<(weak_count const & a, weak_count const & b)
+    bool operator==( shared_count const & r ) const BOOST_SP_NOEXCEPT
     {
-        return std::less<sp_counted_base *>()(a.pi_, b.pi_);
+        return pi_ == r.pi_;
+    }
+
+    bool operator<( weak_count const & r ) const BOOST_SP_NOEXCEPT
+    {
+        return std::less<sp_counted_base *>()( pi_, r.pi_ );
+    }
+
+    bool operator<( shared_count const & r ) const BOOST_SP_NOEXCEPT
+    {
+        return std::less<sp_counted_base *>()( pi_, r.pi_ );
     }
 };
 
@@ -634,7 +656,7 @@ inline shared_count::shared_count( weak_count const & r ): pi_( r.pi_ )
     }
 }
 
-inline shared_count::shared_count( weak_count const & r, sp_nothrow_tag ): pi_( r.pi_ )
+inline shared_count::shared_count( weak_count const & r, sp_nothrow_tag ) BOOST_SP_NOEXCEPT: pi_( r.pi_ )
 #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
         , id_(shared_count_id)
 #endif
@@ -645,6 +667,16 @@ inline shared_count::shared_count( weak_count const & r, sp_nothrow_tag ): pi_(
     }
 }
 
+inline bool shared_count::operator==( weak_count const & r ) const BOOST_SP_NOEXCEPT
+{
+    return pi_ == r.pi_;
+}
+
+inline bool shared_count::operator<( weak_count const & r ) const BOOST_SP_NOEXCEPT
+{
+    return std::less<sp_counted_base *>()( pi_, r.pi_ );
+}
+
 } // namespace detail
 
 } // namespace boost
@@ -653,7 +685,7 @@ inline shared_count::shared_count( weak_count const & r, sp_nothrow_tag ): pi_(
 #pragma GCC diagnostic pop
 #endif
 
-#ifdef __BORLANDC__
+#if defined(__BORLANDC__) && !defined(__clang__)
 # pragma warn .8027     // Functions containing try are not expanded inline
 #endif
 

include/boost/smart_ptr/detail/sp_convertible.hpp

@@ -26,7 +26,7 @@
 # define BOOST_SP_NO_SP_CONVERTIBLE
 #endif
 
-#if !defined( BOOST_SP_NO_SP_CONVERTIBLE ) && defined( __BORLANDC__ ) && ( __BORLANDC__ < 0x630 )
+#if !defined( BOOST_SP_NO_SP_CONVERTIBLE ) && defined( BOOST_BORLANDC ) && ( BOOST_BORLANDC < 0x630 )
 # define BOOST_SP_NO_SP_CONVERTIBLE
 #endif
 

include/boost/smart_ptr/detail/sp_counted_base_acc_ia64.hpp

@@ -15,9 +15,17 @@
 //  Lock-free algorithm by Alexander Terekhov
 //
 
-#include <boost/detail/sp_typeinfo.hpp>
+#include <boost/smart_ptr/detail/sp_typeinfo_.hpp>
+#include <boost/config.hpp>
 #include <machine/sys/inline.h>
 
+#if defined(BOOST_SP_REPORT_IMPLEMENTATION)
+
+#include <boost/config/pragma_message.hpp>
+BOOST_PRAGMA_MESSAGE("Using HP aCC++/HP-UX/IA64 sp_counted_base")
+
+#endif
+
 namespace boost
 {
 
@@ -71,7 +79,7 @@ inline int atomic_conditional_increment( int * pw )
     }
 }
 
-class sp_counted_base
+class BOOST_SYMBOL_VISIBLE sp_counted_base
 {
 private:
 
@@ -103,8 +111,8 @@ public:
         delete this;
     }
 
-    virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
-    virtual void * get_local_deleter( sp_typeinfo const & ti ) = 0;
+    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

@@ -20,10 +20,18 @@
 //  formulation
 //
 
-#include <boost/detail/sp_typeinfo.hpp>
+#include <boost/smart_ptr/detail/sp_typeinfo_.hpp>
+#include <boost/config.hpp>
 #include <builtins.h>
 #include <sys/atomic_op.h>
 
+#if defined(BOOST_SP_REPORT_IMPLEMENTATION)
+
+#include <boost/config/pragma_message.hpp>
+BOOST_PRAGMA_MESSAGE("Using AIX sp_counted_base")
+
+#endif
+
 namespace boost
 {
 
@@ -63,7 +71,7 @@ inline int32_t atomic_conditional_increment( int32_t * pw )
     }
 }
 
-class sp_counted_base
+class BOOST_SYMBOL_VISIBLE sp_counted_base
 {
 private:
 
@@ -95,8 +103,8 @@ public:
         delete this;
     }
 
-    virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
-    virtual void * get_local_deleter( sp_typeinfo const & ti ) = 0;
+    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

@@ -15,28 +15,47 @@
 //  See accompanying file LICENSE_1_0.txt or copy at
 //  http://www.boost.org/LICENSE_1_0.txt
 
-#include <boost/detail/sp_typeinfo.hpp>
+#include <boost/smart_ptr/detail/sp_typeinfo_.hpp>
+#include <boost/smart_ptr/detail/sp_noexcept.hpp>
+#include <boost/config.hpp>
 #include <boost/cstdint.hpp>
 
+#if defined(BOOST_SP_REPORT_IMPLEMENTATION)
+
+#include <boost/config/pragma_message.hpp>
+BOOST_PRAGMA_MESSAGE("Using Clang/C11 sp_counted_base")
+
+#endif
+
 namespace boost
 {
 
 namespace detail
 {
 
+#if defined(__clang__)
+# pragma clang diagnostic push
+#endif
+
+#if defined(__clang__) && defined(__has_warning)
+# if __has_warning( "-Wc11-extensions" )
+#  pragma clang diagnostic ignored "-Wc11-extensions"
+# endif
+#endif
+
 typedef _Atomic( boost::int_least32_t ) atomic_int_least32_t;
 
-inline void atomic_increment( atomic_int_least32_t * pw )
+inline void atomic_increment( atomic_int_least32_t * pw ) BOOST_SP_NOEXCEPT
 {
     __c11_atomic_fetch_add( pw, 1, __ATOMIC_RELAXED );
 }
 
-inline boost::int_least32_t atomic_decrement( atomic_int_least32_t * pw )
+inline boost::int_least32_t atomic_decrement( atomic_int_least32_t * pw ) BOOST_SP_NOEXCEPT
 {
     return __c11_atomic_fetch_sub( pw, 1, __ATOMIC_ACQ_REL );
 }
 
-inline boost::int_least32_t atomic_conditional_increment( atomic_int_least32_t * pw )
+inline boost::int_least32_t atomic_conditional_increment( atomic_int_least32_t * pw ) BOOST_SP_NOEXCEPT
 {
     // long r = *pw;
     // if( r != 0 ) ++*pw;
@@ -59,59 +78,58 @@ inline boost::int_least32_t atomic_conditional_increment( atomic_int_least32_t *
 }
 
 #if defined(__clang__)
-# pragma clang diagnostic push
 # pragma clang diagnostic ignored "-Wweak-vtables"
 #endif
 
-class sp_counted_base
+class BOOST_SYMBOL_VISIBLE sp_counted_base
 {
 private:
 
     sp_counted_base( sp_counted_base const & );
     sp_counted_base & operator= ( sp_counted_base const & );
 
-    atomic_int_least32_t use_count_;	// #shared
-    atomic_int_least32_t weak_count_;	// #weak + (#shared != 0)
+    atomic_int_least32_t use_count_;    // #shared
+    atomic_int_least32_t weak_count_;   // #weak + (#shared != 0)
 
 public:
 
-    sp_counted_base()
+    sp_counted_base() BOOST_SP_NOEXCEPT
     {
         __c11_atomic_init( &use_count_, 1 );
         __c11_atomic_init( &weak_count_, 1 );
     }
 
-    virtual ~sp_counted_base() // nothrow
+    virtual ~sp_counted_base() /*BOOST_SP_NOEXCEPT*/
     {
     }
 
     // dispose() is called when use_count_ drops to zero, to release
     // the resources managed by *this.
 
-    virtual void dispose() = 0; // nothrow
+    virtual void dispose() BOOST_SP_NOEXCEPT = 0; // nothrow
 
     // destroy() is called when weak_count_ drops to zero.
 
-    virtual void destroy() // nothrow
+    virtual void destroy() BOOST_SP_NOEXCEPT // nothrow
     {
         delete this;
     }
 
-    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;
+    virtual void * get_deleter( sp_typeinfo_ const & ti ) BOOST_SP_NOEXCEPT = 0;
+    virtual void * get_local_deleter( sp_typeinfo_ const & ti ) BOOST_SP_NOEXCEPT = 0;
+    virtual void * get_untyped_deleter() BOOST_SP_NOEXCEPT = 0;
 
-    void add_ref_copy()
+    void add_ref_copy() BOOST_SP_NOEXCEPT
     {
         atomic_increment( &use_count_ );
     }
 
-    bool add_ref_lock() // true on success
+    bool add_ref_lock() BOOST_SP_NOEXCEPT // true on success
     {
         return atomic_conditional_increment( &use_count_ ) != 0;
     }
 
-    void release() // nothrow
+    void release() BOOST_SP_NOEXCEPT
     {
         if( atomic_decrement( &use_count_ ) == 1 )
         {
@@ -120,12 +138,12 @@ public:
         }
     }
 
-    void weak_add_ref() // nothrow
+    void weak_add_ref() BOOST_SP_NOEXCEPT
     {
         atomic_increment( &weak_count_ );
     }
 
-    void weak_release() // nothrow
+    void weak_release() BOOST_SP_NOEXCEPT
     {
         if( atomic_decrement( &weak_count_ ) == 1 )
         {
@@ -133,7 +151,7 @@ public:
         }
     }
 
-    long use_count() const // nothrow
+    long use_count() const BOOST_SP_NOEXCEPT
     {
         return __c11_atomic_load( const_cast< atomic_int_least32_t* >( &use_count_ ), __ATOMIC_ACQUIRE );
     }

include/boost/smart_ptr/detail/sp_counted_base_cw_ppc.hpp

@@ -24,7 +24,15 @@
 //  formulation
 //
 
-#include <boost/detail/sp_typeinfo.hpp>
+#include <boost/smart_ptr/detail/sp_typeinfo_.hpp>
+#include <boost/config.hpp>
+
+#if defined(BOOST_SP_REPORT_IMPLEMENTATION)
+
+#include <boost/config/pragma_message.hpp>
+BOOST_PRAGMA_MESSAGE("Using CodeWarrior/PowerPC sp_counted_base")
+
+#endif
 
 namespace boost
 {
@@ -91,7 +99,7 @@ store:
     return a;
 }
 
-class sp_counted_base
+class BOOST_SYMBOL_VISIBLE sp_counted_base
 {
 private:
 
@@ -123,8 +131,8 @@ public:
         delete this;
     }
 
-    virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
-    virtual void * get_local_deleter( sp_typeinfo const & ti ) = 0;
+    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

@@ -25,7 +25,15 @@
 //  formulation
 //
 
-#include <boost/detail/sp_typeinfo.hpp>
+#include <boost/smart_ptr/detail/sp_typeinfo_.hpp>
+#include <boost/config.hpp>
+
+#if defined(BOOST_SP_REPORT_IMPLEMENTATION)
+
+#include <boost/config/pragma_message.hpp>
+BOOST_PRAGMA_MESSAGE("Using CodeWarrior/x86 sp_counted_base")
+
+#endif
 
 namespace boost
 {
@@ -79,7 +87,7 @@ inline int atomic_conditional_increment( int * pw )
     }
 }
 
-class sp_counted_base
+class BOOST_SYMBOL_VISIBLE sp_counted_base
 {
 private:
 
@@ -111,8 +119,8 @@ public:
         delete this;
     }
 
-    virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
-    virtual void * get_local_deleter( sp_typeinfo const & ti ) = 0;
+    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

@@ -16,7 +16,15 @@
 //  Lock-free algorithm by Alexander Terekhov
 //
 
-#include <boost/detail/sp_typeinfo.hpp>
+#include <boost/smart_ptr/detail/sp_typeinfo_.hpp>
+#include <boost/config.hpp>
+
+#if defined(BOOST_SP_REPORT_IMPLEMENTATION)
+
+#include <boost/config/pragma_message.hpp>
+BOOST_PRAGMA_MESSAGE("Using g++/IA64 sp_counted_base")
+
+#endif
 
 namespace boost
 {
@@ -78,7 +86,7 @@ inline int atomic_conditional_increment( int * pw )
     return rv;
 }
 
-class sp_counted_base
+class BOOST_SYMBOL_VISIBLE sp_counted_base
 {
 private:
 
@@ -110,8 +118,8 @@ public:
         delete this;
     }
 
-    virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
-    virtual void * get_local_deleter( sp_typeinfo const & ti ) = 0;
+    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

@@ -20,7 +20,15 @@
 //  Lock-free algorithm by Alexander Terekhov
 //
 
-#include <boost/detail/sp_typeinfo.hpp>
+#include <boost/smart_ptr/detail/sp_typeinfo_.hpp>
+#include <boost/config.hpp>
+
+#if defined(BOOST_SP_REPORT_IMPLEMENTATION)
+
+#include <boost/config/pragma_message.hpp>
+BOOST_PRAGMA_MESSAGE("Using g++/MIPS sp_counted_base")
+
+#endif
 
 namespace boost
 {
@@ -38,7 +46,9 @@ inline void atomic_increment( int * pw )
     (
         "0:\n\t"
         ".set push\n\t"
+#if !defined(__mips_isa_rev) || (__mips_isa_rev < 6)
         ".set mips2\n\t"
+#endif
         "ll %0, %1\n\t"
         "addiu %0, 1\n\t"
         "sc %0, %1\n\t"
@@ -59,7 +69,9 @@ inline int atomic_decrement( int * pw )
     (
         "0:\n\t"
         ".set push\n\t"
+#if !defined(__mips_isa_rev) || (__mips_isa_rev < 6)
         ".set mips2\n\t"
+#endif
         "ll %1, %2\n\t"
         "addiu %0, %1, -1\n\t"
         "sc %0, %2\n\t"
@@ -85,7 +97,9 @@ inline int atomic_conditional_increment( int * pw )
     (
         "0:\n\t"
         ".set push\n\t"
+#if !defined(__mips_isa_rev) || (__mips_isa_rev < 6)
         ".set mips2\n\t"
+#endif
         "ll %0, %2\n\t"
         "beqz %0, 1f\n\t"
         "addiu %1, %0, 1\n\t"
@@ -102,7 +116,7 @@ inline int atomic_conditional_increment( int * pw )
     return rv;
 }
 
-class sp_counted_base
+class BOOST_SYMBOL_VISIBLE sp_counted_base
 {
 private:
 
@@ -134,8 +148,8 @@ public:
         delete this;
     }
 
-    virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
-    virtual void * get_local_deleter( sp_typeinfo const & ti ) = 0;
+    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

@@ -24,7 +24,15 @@
 //  formulation
 //
 
-#include <boost/detail/sp_typeinfo.hpp>
+#include <boost/smart_ptr/detail/sp_typeinfo_.hpp>
+#include <boost/config.hpp>
+
+#if defined(BOOST_SP_REPORT_IMPLEMENTATION)
+
+#include <boost/config/pragma_message.hpp>
+BOOST_PRAGMA_MESSAGE("Using g++/PowerPC sp_counted_base")
+
+#endif
 
 namespace boost
 {
@@ -102,7 +110,7 @@ inline int atomic_conditional_increment( int * pw )
     return rv;
 }
 
-class sp_counted_base
+class BOOST_SYMBOL_VISIBLE sp_counted_base
 {
 private:
 
@@ -134,8 +142,8 @@ public:
         delete this;
     }
 
-    virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
-    virtual void * get_local_deleter( sp_typeinfo const & ti ) = 0;
+    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

@@ -19,9 +19,17 @@
 //
 //  Thanks to Michael van der Westhuizen
 
-#include <boost/detail/sp_typeinfo.hpp>
+#include <boost/smart_ptr/detail/sp_typeinfo_.hpp>
+#include <boost/config.hpp>
 #include <inttypes.h> // int32_t
 
+#if defined(BOOST_SP_REPORT_IMPLEMENTATION)
+
+#include <boost/config/pragma_message.hpp>
+BOOST_PRAGMA_MESSAGE("Using g++/Sparc sp_counted_base")
+
+#endif
+
 namespace boost
 {
 
@@ -87,7 +95,7 @@ inline int32_t atomic_conditional_increment( int32_t * pw )
     }    
 }
 
-class sp_counted_base
+class BOOST_SYMBOL_VISIBLE sp_counted_base
 {
 private:
 
@@ -119,8 +127,8 @@ public:
         delete this;
     }
 
-    virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
-    virtual void * get_local_deleter( sp_typeinfo const & ti ) = 0;
+    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

@@ -24,7 +24,15 @@
 //  formulation
 //
 
-#include <boost/detail/sp_typeinfo.hpp>
+#include <boost/smart_ptr/detail/sp_typeinfo_.hpp>
+#include <boost/config.hpp>
+
+#if defined(BOOST_SP_REPORT_IMPLEMENTATION)
+
+#include <boost/config/pragma_message.hpp>
+BOOST_PRAGMA_MESSAGE("Using g++/x86 sp_counted_base")
+
+#endif
 
 namespace boost
 {
@@ -94,7 +102,7 @@ inline int atomic_conditional_increment( int * pw )
     return rv;
 }
 
-class sp_counted_base
+class BOOST_SYMBOL_VISIBLE sp_counted_base
 {
 private:
 
@@ -126,8 +134,8 @@ public:
         delete this;
     }
 
-    virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
-    virtual void * get_local_deleter( sp_typeinfo const & ti ) = 0;
+    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

@@ -18,7 +18,17 @@
 // http://www.boost.org/LICENSE_1_0.txt)
 //
 
-#include <boost/detail/sp_typeinfo.hpp>
+#include <boost/smart_ptr/detail/sp_typeinfo_.hpp>
+#include <boost/smart_ptr/detail/sp_noexcept.hpp>
+#include <boost/config.hpp>
+#include <boost/cstdint.hpp>
+
+#if defined(BOOST_SP_REPORT_IMPLEMENTATION)
+
+#include <boost/config/pragma_message.hpp>
+BOOST_PRAGMA_MESSAGE("Using single-threaded, non-atomic sp_counted_base")
+
+#endif
 
 namespace boost
 {
@@ -26,55 +36,55 @@ namespace boost
 namespace detail
 {
 
-class sp_counted_base
+class BOOST_SYMBOL_VISIBLE sp_counted_base
 {
 private:
 
     sp_counted_base( sp_counted_base const & );
     sp_counted_base & operator= ( sp_counted_base const & );
 
-    long use_count_;        // #shared
-    long weak_count_;       // #weak + (#shared != 0)
+    boost::int_least32_t use_count_;        // #shared
+    boost::int_least32_t weak_count_;       // #weak + (#shared != 0)
 
 public:
 
-    sp_counted_base(): use_count_( 1 ), weak_count_( 1 )
+    sp_counted_base() BOOST_SP_NOEXCEPT: use_count_( 1 ), weak_count_( 1 )
     {
     }
 
-    virtual ~sp_counted_base() // nothrow
+    virtual ~sp_counted_base() /*BOOST_SP_NOEXCEPT*/
     {
     }
 
     // dispose() is called when use_count_ drops to zero, to release
     // the resources managed by *this.
 
-    virtual void dispose() = 0; // nothrow
+    virtual void dispose() BOOST_SP_NOEXCEPT = 0; // nothrow
 
     // destroy() is called when weak_count_ drops to zero.
 
-    virtual void destroy() // nothrow
+    virtual void destroy() BOOST_SP_NOEXCEPT // nothrow
     {
         delete this;
     }
 
-    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;
+    virtual void * get_deleter( sp_typeinfo_ const & ti ) BOOST_SP_NOEXCEPT = 0;
+    virtual void * get_local_deleter( sp_typeinfo_ const & ti ) BOOST_SP_NOEXCEPT = 0;
+    virtual void * get_untyped_deleter() BOOST_SP_NOEXCEPT = 0;
 
-    void add_ref_copy()
+    void add_ref_copy() BOOST_SP_NOEXCEPT
     {
         ++use_count_;
     }
 
-    bool add_ref_lock() // true on success
+    bool add_ref_lock() BOOST_SP_NOEXCEPT // true on success
     {
         if( use_count_ == 0 ) return false;
         ++use_count_;
         return true;
     }
 
-    void release() // nothrow
+    void release() BOOST_SP_NOEXCEPT
     {
         if( --use_count_ == 0 )
         {
@@ -83,12 +93,12 @@ public:
         }
     }
 
-    void weak_add_ref() // nothrow
+    void weak_add_ref() BOOST_SP_NOEXCEPT
     {
         ++weak_count_;
     }
 
-    void weak_release() // nothrow
+    void weak_release() BOOST_SP_NOEXCEPT
     {
         if( --weak_count_ == 0 )
         {
@@ -96,7 +106,7 @@ public:
         }
     }
 
-    long use_count() const // nothrow
+    long use_count() const BOOST_SP_NOEXCEPT
     {
         return use_count_;
     }

include/boost/smart_ptr/detail/sp_counted_base_pt.hpp

@@ -18,25 +18,34 @@
 // http://www.boost.org/LICENSE_1_0.txt)
 //
 
-#include <boost/detail/sp_typeinfo.hpp>
+#include <boost/smart_ptr/detail/sp_typeinfo_.hpp>
 #include <boost/assert.hpp>
+#include <boost/config.hpp>
+#include <boost/cstdint.hpp>
 #include <pthread.h>
 
+#if defined(BOOST_SP_REPORT_IMPLEMENTATION)
+
+#include <boost/config/pragma_message.hpp>
+BOOST_PRAGMA_MESSAGE("Using pthread_mutex sp_counted_base")
+
+#endif
+
 namespace boost
 {
 
 namespace detail
 {
 
-class sp_counted_base
+class BOOST_SYMBOL_VISIBLE sp_counted_base
 {
 private:
 
     sp_counted_base( sp_counted_base const & );
     sp_counted_base & operator= ( sp_counted_base const & );
 
-    long use_count_;        // #shared
-    long weak_count_;       // #weak + (#shared != 0)
+    boost::int_least32_t use_count_;        // #shared
+    boost::int_least32_t weak_count_;       // #weak + (#shared != 0)
 
     mutable pthread_mutex_t m_;
 
@@ -70,8 +79,8 @@ public:
         delete this;
     }
 
-    virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
-    virtual void * get_local_deleter( sp_typeinfo const & ti ) = 0;
+    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()
@@ -92,7 +101,7 @@ public:
     void release() // nothrow
     {
         BOOST_VERIFY( pthread_mutex_lock( &m_ ) == 0 );
-        long new_use_count = --use_count_;
+        boost::int_least32_t new_use_count = --use_count_;
         BOOST_VERIFY( pthread_mutex_unlock( &m_ ) == 0 );
 
         if( new_use_count == 0 )
@@ -112,7 +121,7 @@ public:
     void weak_release() // nothrow
     {
         BOOST_VERIFY( pthread_mutex_lock( &m_ ) == 0 );
-        long new_weak_count = --weak_count_;
+        boost::int_least32_t new_weak_count = --weak_count_;
         BOOST_VERIFY( pthread_mutex_unlock( &m_ ) == 0 );
 
         if( new_weak_count == 0 )
@@ -124,7 +133,7 @@ public:
     long use_count() const // nothrow
     {
         BOOST_VERIFY( pthread_mutex_lock( &m_ ) == 0 );
-        long r = use_count_;
+        boost::int_least32_t r = use_count_;
         BOOST_VERIFY( pthread_mutex_unlock( &m_ ) == 0 );
 
         return r;

include/boost/smart_ptr/detail/sp_counted_base_snc_ps3.hpp

@@ -6,7 +6,7 @@
 # pragma once
 #endif
 
-//  detail/sp_counted_base_gcc_sparc.hpp - g++ on Sparc V8+
+//  detail/sp_counted_base_gcc_snc_ps3.hpp - PS3 Cell
 //
 //  Copyright (c) 2006 Piotr Wyderski
 //  Copyright (c) 2006 Tomas Puverle
@@ -19,9 +19,17 @@
 //
 //  Thanks to Michael van der Westhuizen
 
-#include <boost/detail/sp_typeinfo.hpp>
+#include <boost/smart_ptr/detail/sp_typeinfo_.hpp>
+#include <boost/config.hpp>
 #include <inttypes.h> // uint32_t
 
+#if defined(BOOST_SP_REPORT_IMPLEMENTATION)
+
+#include <boost/config/pragma_message.hpp>
+BOOST_PRAGMA_MESSAGE("Using PS3 sp_counted_base")
+
+#endif
+
 namespace boost
 {
 
@@ -82,7 +90,7 @@ inline uint32_t atomic_conditional_increment( uint32_t * pw )
     }    
 }
 
-class sp_counted_base
+class BOOST_SYMBOL_VISIBLE sp_counted_base
 {
 private:
 
@@ -114,8 +122,8 @@ public:
         delete this;
     }
 
-    virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
-    virtual void * get_local_deleter( sp_typeinfo const & ti ) = 0;
+    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

@@ -20,16 +20,24 @@
 //  formulation
 //
 
-#include <boost/detail/sp_typeinfo.hpp>
+#include <boost/smart_ptr/detail/sp_typeinfo_.hpp>
+#include <boost/config.hpp>
 #include <atomic.h>
 
+#if defined(BOOST_SP_REPORT_IMPLEMENTATION)
+
+#include <boost/config/pragma_message.hpp>
+BOOST_PRAGMA_MESSAGE("Using Solaris sp_counted_base")
+
+#endif
+
 namespace boost
 {
 
 namespace detail
 {
 
-class sp_counted_base
+class BOOST_SYMBOL_VISIBLE sp_counted_base
 {
 private:
 
@@ -61,8 +69,8 @@ public:
         delete this;
     }
 
-    virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
-    virtual void * get_local_deleter( sp_typeinfo const & ti ) = 0;
+    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

@@ -18,8 +18,16 @@
 //  http://www.boost.org/LICENSE_1_0.txt)
 //
 
-#include <boost/detail/sp_typeinfo.hpp>
+#include <boost/smart_ptr/detail/sp_typeinfo_.hpp>
 #include <boost/smart_ptr/detail/spinlock_pool.hpp>
+#include <boost/config.hpp>
+
+#if defined(BOOST_SP_REPORT_IMPLEMENTATION)
+
+#include <boost/config/pragma_message.hpp>
+BOOST_PRAGMA_MESSAGE("Using spinlock-based sp_counted_base")
+
+#endif
 
 namespace boost
 {
@@ -51,7 +59,7 @@ inline int atomic_conditional_increment( int * pw )
     return rv;
 }
 
-class sp_counted_base
+class BOOST_SYMBOL_VISIBLE sp_counted_base
 {
 private:
 
@@ -83,8 +91,8 @@ public:
         delete this;
     }
 
-    virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
-    virtual void * get_local_deleter( sp_typeinfo const & ti ) = 0;
+    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

@@ -15,27 +15,36 @@
 //  See accompanying file LICENSE_1_0.txt or copy at
 //  http://www.boost.org/LICENSE_1_0.txt
 
-#include <boost/detail/sp_typeinfo.hpp>
+#include <boost/smart_ptr/detail/sp_typeinfo_.hpp>
+#include <boost/smart_ptr/detail/sp_noexcept.hpp>
+#include <boost/config.hpp>
 #include <atomic>
 #include <cstdint>
 
+#if defined(BOOST_SP_REPORT_IMPLEMENTATION)
+
+#include <boost/config/pragma_message.hpp>
+BOOST_PRAGMA_MESSAGE("Using std::atomic sp_counted_base")
+
+#endif
+
 namespace boost
 {
 
 namespace detail
 {
 
-inline void atomic_increment( std::atomic_int_least32_t * pw )
+inline void atomic_increment( std::atomic_int_least32_t * pw ) BOOST_SP_NOEXCEPT
 {
     pw->fetch_add( 1, std::memory_order_relaxed );
 }
 
-inline std::int_least32_t atomic_decrement( std::atomic_int_least32_t * pw )
+inline std::int_least32_t atomic_decrement( std::atomic_int_least32_t * pw ) BOOST_SP_NOEXCEPT
 {
     return pw->fetch_sub( 1, std::memory_order_acq_rel );
 }
 
-inline std::int_least32_t atomic_conditional_increment( std::atomic_int_least32_t * pw )
+inline std::int_least32_t atomic_conditional_increment( std::atomic_int_least32_t * pw ) BOOST_SP_NOEXCEPT
 {
     // long r = *pw;
     // if( r != 0 ) ++*pw;
@@ -57,53 +66,53 @@ inline std::int_least32_t atomic_conditional_increment( std::atomic_int_least32_
     }    
 }
 
-class sp_counted_base
+class BOOST_SYMBOL_VISIBLE sp_counted_base
 {
 private:
 
     sp_counted_base( sp_counted_base const & );
     sp_counted_base & operator= ( sp_counted_base const & );
 
-    std::atomic_int_least32_t use_count_;	// #shared
-    std::atomic_int_least32_t weak_count_;	// #weak + (#shared != 0)
+    std::atomic_int_least32_t use_count_;   // #shared
+    std::atomic_int_least32_t weak_count_;  // #weak + (#shared != 0)
 
 public:
 
-    sp_counted_base(): use_count_( 1 ), weak_count_( 1 )
+    sp_counted_base() BOOST_SP_NOEXCEPT: use_count_( 1 ), weak_count_( 1 )
     {
     }
 
-    virtual ~sp_counted_base() // nothrow
+    virtual ~sp_counted_base() /*BOOST_SP_NOEXCEPT*/
     {
     }
 
     // dispose() is called when use_count_ drops to zero, to release
     // the resources managed by *this.
 
-    virtual void dispose() = 0; // nothrow
+    virtual void dispose() BOOST_SP_NOEXCEPT = 0;
 
     // destroy() is called when weak_count_ drops to zero.
 
-    virtual void destroy() // nothrow
+    virtual void destroy() BOOST_SP_NOEXCEPT
     {
         delete this;
     }
 
-    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;
+    virtual void * get_deleter( sp_typeinfo_ const & ti ) BOOST_SP_NOEXCEPT = 0;
+    virtual void * get_local_deleter( sp_typeinfo_ const & ti ) BOOST_SP_NOEXCEPT = 0;
+    virtual void * get_untyped_deleter() BOOST_SP_NOEXCEPT = 0;
 
-    void add_ref_copy()
+    void add_ref_copy() BOOST_SP_NOEXCEPT
     {
         atomic_increment( &use_count_ );
     }
 
-    bool add_ref_lock() // true on success
+    bool add_ref_lock() BOOST_SP_NOEXCEPT // true on success
     {
         return atomic_conditional_increment( &use_count_ ) != 0;
     }
 
-    void release() // nothrow
+    void release() BOOST_SP_NOEXCEPT
     {
         if( atomic_decrement( &use_count_ ) == 1 )
         {
@@ -112,12 +121,12 @@ public:
         }
     }
 
-    void weak_add_ref() // nothrow
+    void weak_add_ref() BOOST_SP_NOEXCEPT
     {
         atomic_increment( &weak_count_ );
     }
 
-    void weak_release() // nothrow
+    void weak_release() BOOST_SP_NOEXCEPT
     {
         if( atomic_decrement( &weak_count_ ) == 1 )
         {
@@ -125,7 +134,7 @@ public:
         }
     }
 
-    long use_count() const // nothrow
+    long use_count() const BOOST_SP_NOEXCEPT
     {
         return use_count_.load( std::memory_order_acquire );
     }

include/boost/smart_ptr/detail/sp_counted_base_sync.hpp

@@ -15,13 +15,21 @@
 //  See accompanying file LICENSE_1_0.txt or copy at
 //  http://www.boost.org/LICENSE_1_0.txt
 
-#include <boost/detail/sp_typeinfo.hpp>
+#include <boost/smart_ptr/detail/sp_typeinfo_.hpp>
+#include <boost/config.hpp>
 #include <limits.h>
 
 #if defined( __ia64__ ) && defined( __INTEL_COMPILER )
 # include <ia64intrin.h>
 #endif
 
+#if defined(BOOST_SP_REPORT_IMPLEMENTATION)
+
+#include <boost/config/pragma_message.hpp>
+BOOST_PRAGMA_MESSAGE("Using __sync sp_counted_base")
+
+#endif
+
 namespace boost
 {
 
@@ -76,7 +84,7 @@ inline sp_int32_t atomic_conditional_increment( sp_int32_t * pw )
     }    
 }
 
-class sp_counted_base
+class BOOST_SYMBOL_VISIBLE sp_counted_base
 {
 private:
 
@@ -108,8 +116,8 @@ public:
         delete this;
     }
 
-    virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
-    virtual void * get_local_deleter( sp_typeinfo const & ti ) = 0;
+    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

@@ -21,7 +21,15 @@
 //  formulation
 //
 
-#include <boost/detail/sp_typeinfo.hpp>
+#include <boost/smart_ptr/detail/sp_typeinfo_.hpp>
+#include <boost/config.hpp>
+
+#if defined(BOOST_SP_REPORT_IMPLEMENTATION)
+
+#include <boost/config/pragma_message.hpp>
+BOOST_PRAGMA_MESSAGE("Using xlC/PowerPC sp_counted_base")
+
+#endif
 
 extern "builtin" void __lwsync(void);
 extern "builtin" void __isync(void);
@@ -70,7 +78,7 @@ inline int atomic_conditional_increment( int *pw )
    }
 }
 
-class sp_counted_base
+class BOOST_SYMBOL_VISIBLE sp_counted_base
 {
 private:
 
@@ -103,8 +111,8 @@ public:
         delete this;
     }
 
-    virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
-    virtual void * get_local_deleter( sp_typeinfo const & ti ) = 0;
+    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

@@ -25,8 +25,16 @@
 //
 
 #include <boost/smart_ptr/detail/sp_interlocked.hpp>
-#include <boost/detail/workaround.hpp>
-#include <boost/detail/sp_typeinfo.hpp>
+#include <boost/smart_ptr/detail/sp_typeinfo_.hpp>
+#include <boost/config/workaround.hpp>
+#include <boost/config.hpp>
+
+#if defined(BOOST_SP_REPORT_IMPLEMENTATION)
+
+#include <boost/config/pragma_message.hpp>
+BOOST_PRAGMA_MESSAGE("Using Win32 sp_counted_base")
+
+#endif
 
 namespace boost
 {
@@ -34,7 +42,7 @@ namespace boost
 namespace detail
 {
 
-class sp_counted_base
+class BOOST_SYMBOL_VISIBLE sp_counted_base
 {
 private:
 
@@ -66,8 +74,8 @@ public:
         delete this;
     }
 
-    virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
-    virtual void * get_local_deleter( sp_typeinfo const & ti ) = 0;
+    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/smart_ptr/detail/sp_noexcept.hpp>
 #include <boost/core/addressof.hpp>
 
 #if defined(BOOST_SP_USE_QUICK_ALLOCATOR)
@@ -55,16 +56,16 @@ namespace detail
 
 template<class D> class local_sp_deleter;
 
-template<class D> D * get_local_deleter( D * /*p*/ )
+template<class D> D * get_local_deleter( D * /*p*/ ) BOOST_SP_NOEXCEPT
 {
     return 0;
 }
 
-template<class D> D * get_local_deleter( local_sp_deleter<D> * p );
+template<class D> D * get_local_deleter( local_sp_deleter<D> * p ) BOOST_SP_NOEXCEPT;
 
 //
 
-template<class X> class sp_counted_impl_p: public sp_counted_base
+template<class X> class BOOST_SYMBOL_VISIBLE sp_counted_impl_p: public sp_counted_base
 {
 private:
 
@@ -84,7 +85,7 @@ public:
 #endif
     }
 
-    virtual void dispose() // nothrow
+    void dispose() BOOST_SP_NOEXCEPT BOOST_OVERRIDE
     {
 #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
         boost::sp_scalar_destructor_hook( px_, sizeof(X), this );
@@ -92,17 +93,17 @@ public:
         boost::checked_delete( px_ );
     }
 
-    virtual void * get_deleter( sp_typeinfo const & )
+    void * get_deleter( sp_typeinfo_ const & ) BOOST_SP_NOEXCEPT BOOST_OVERRIDE
     {
         return 0;
     }
 
-    virtual void * get_local_deleter( sp_typeinfo const & )
+    void * get_local_deleter( sp_typeinfo_ const & ) BOOST_SP_NOEXCEPT BOOST_OVERRIDE
     {
         return 0;
     }
 
-    virtual void * get_untyped_deleter()
+    void * get_untyped_deleter() BOOST_SP_NOEXCEPT BOOST_OVERRIDE
     {
         return 0;
     }
@@ -143,7 +144,7 @@ public:
 # pragma option push -Vx-
 #endif
 
-template<class P, class D> class sp_counted_impl_pd: public sp_counted_base
+template<class P, class D> class BOOST_SYMBOL_VISIBLE sp_counted_impl_pd: public sp_counted_base
 {
 private:
 
@@ -167,22 +168,22 @@ public:
     {
     }
 
-    virtual void dispose() // nothrow
+    void dispose() BOOST_SP_NOEXCEPT BOOST_OVERRIDE
     {
         del( ptr );
     }
 
-    virtual void * get_deleter( sp_typeinfo const & ti )
+    void * get_deleter( sp_typeinfo_ const & ti ) BOOST_SP_NOEXCEPT BOOST_OVERRIDE
     {
-        return ti == BOOST_SP_TYPEID(D)? &reinterpret_cast<char&>( del ): 0;
+        return ti == BOOST_SP_TYPEID_(D)? &reinterpret_cast<char&>( del ): 0;
     }
 
-    virtual void * get_local_deleter( sp_typeinfo const & ti )
+    void * get_local_deleter( sp_typeinfo_ const & ti ) BOOST_SP_NOEXCEPT BOOST_OVERRIDE
     {
-        return ti == BOOST_SP_TYPEID(D)? boost::detail::get_local_deleter( boost::addressof( del ) ): 0;
+        return ti == BOOST_SP_TYPEID_(D)? boost::detail::get_local_deleter( boost::addressof( del ) ): 0;
     }
 
-    virtual void * get_untyped_deleter()
+    void * get_untyped_deleter() BOOST_SP_NOEXCEPT BOOST_OVERRIDE
     {
         return &reinterpret_cast<char&>( del );
     }
@@ -216,7 +217,7 @@ public:
 #endif
 };
 
-template<class P, class D, class A> class sp_counted_impl_pda: public sp_counted_base
+template<class P, class D, class A> class BOOST_SYMBOL_VISIBLE sp_counted_impl_pda: public sp_counted_base
 {
 private:
 
@@ -241,12 +242,12 @@ public:
     {
     }
 
-    virtual void dispose() // nothrow
+    void dispose() BOOST_SP_NOEXCEPT BOOST_OVERRIDE
     {
         d_( p_ );
     }
 
-    virtual void destroy() // nothrow
+    void destroy() BOOST_SP_NOEXCEPT BOOST_OVERRIDE
     {
 #if !defined( BOOST_NO_CXX11_ALLOCATOR )
 
@@ -265,17 +266,17 @@ public:
         a2.deallocate( this, 1 );
     }
 
-    virtual void * get_deleter( sp_typeinfo const & ti )
+    void * get_deleter( sp_typeinfo_ const & ti ) BOOST_SP_NOEXCEPT BOOST_OVERRIDE
     {
-        return ti == BOOST_SP_TYPEID( D )? &reinterpret_cast<char&>( d_ ): 0;
+        return ti == BOOST_SP_TYPEID_( D )? &reinterpret_cast<char&>( d_ ): 0;
     }
 
-    virtual void * get_local_deleter( sp_typeinfo const & ti )
+    void * get_local_deleter( sp_typeinfo_ const & ti ) BOOST_SP_NOEXCEPT BOOST_OVERRIDE
     {
-        return ti == BOOST_SP_TYPEID(D)? boost::detail::get_local_deleter( boost::addressof( d_ ) ): 0;
+        return ti == BOOST_SP_TYPEID_( D )? boost::detail::get_local_deleter( boost::addressof( d_ ) ): 0;
     }
 
-    virtual void * get_untyped_deleter()
+    void * get_untyped_deleter() BOOST_SP_NOEXCEPT BOOST_OVERRIDE
     {
         return &reinterpret_cast<char&>( d_ );
     }

include/boost/smart_ptr/detail/sp_interlocked.hpp

@@ -32,11 +32,21 @@
 // MinGW-w64 provides intrin.h for both 32 and 64-bit targets.
 # define BOOST_SP_HAS_INTRIN_H
 
+#elif defined( __LP64__ )
+
+// We have to use intrin.h on Cygwin 64
+# define BOOST_SP_HAS_INTRIN_H
+
 // Intel C++ on Windows on VC10+ stdlib
 #elif defined( BOOST_INTEL_WIN ) && defined( _CPPLIB_VER ) && _CPPLIB_VER >= 520
 
 # define BOOST_SP_HAS_INTRIN_H
 
+// clang-cl on Windows on VC10+ stdlib
+#elif defined( __clang__ ) && defined( _MSC_VER ) && defined( _CPPLIB_VER ) && _CPPLIB_VER >= 520
+
+# define BOOST_SP_HAS_INTRIN_H
+
 #endif
 
 #if defined( BOOST_USE_WINDOWS_H )

include/boost/smart_ptr/detail/sp_typeinfo_.hpp

@@ -0,0 +1,58 @@
+#ifndef BOOST_SMART_PTR_DETAIL_SP_TYPEINFO_HPP_INCLUDED
+#define BOOST_SMART_PTR_DETAIL_SP_TYPEINFO_HPP_INCLUDED
+
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+//  smart_ptr/detail/sp_typeinfo_.hpp
+//
+//  Copyright 2007, 2019 Peter Dimov
+//
+//  Distributed under the Boost Software License, Version 1.0.
+//  See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/config.hpp>
+
+#if defined( BOOST_NO_TYPEID ) || defined( BOOST_NO_STD_TYPEINFO )
+
+#include <boost/core/typeinfo.hpp>
+
+namespace boost
+{
+
+namespace detail
+{
+
+typedef boost::core::typeinfo sp_typeinfo_;
+
+} // namespace detail
+
+} // namespace boost
+
+#define BOOST_SP_TYPEID_(T) BOOST_CORE_TYPEID(T)
+
+#else // defined( BOOST_NO_TYPEID ) || defined( BOOST_NO_STD_TYPEINFO )
+
+#include <typeinfo>
+
+namespace boost
+{
+
+namespace detail
+{
+
+typedef std::type_info sp_typeinfo_;
+
+} // namespace detail
+
+} // namespace boost
+
+#define BOOST_SP_TYPEID_(T) typeid(T)
+
+#endif // defined( BOOST_NO_TYPEID ) || defined( BOOST_NO_STD_TYPEINFO )
+
+#endif  // #ifndef BOOST_SMART_PTR_DETAIL_SP_TYPEINFO_HPP_INCLUDED

include/boost/smart_ptr/detail/spinlock_gcc_arm.hpp

@@ -11,6 +11,13 @@
 
 #include <boost/smart_ptr/detail/yield_k.hpp>
 
+#if defined(BOOST_SP_REPORT_IMPLEMENTATION)
+
+#include <boost/config/pragma_message.hpp>
+BOOST_PRAGMA_MESSAGE("Using g++/ARM spinlock")
+
+#endif
+
 #if defined(__ARM_ARCH_7__) || defined(__ARM_ARCH_7A__) || defined(__ARM_ARCH_7R__) || defined(__ARM_ARCH_7M__) || defined(__ARM_ARCH_7EM__) || defined(__ARM_ARCH_7S__)
 
 # define BOOST_SP_ARM_BARRIER "dmb"

include/boost/smart_ptr/detail/spinlock_nt.hpp

@@ -17,6 +17,13 @@
 
 #include <boost/assert.hpp>
 
+#if defined(BOOST_SP_REPORT_IMPLEMENTATION)
+
+#include <boost/config/pragma_message.hpp>
+BOOST_PRAGMA_MESSAGE("Using single-threaded spinlock emulation")
+
+#endif
+
 namespace boost
 {
 

include/boost/smart_ptr/detail/spinlock_pt.hpp

@@ -17,6 +17,13 @@
 
 #include <pthread.h>
 
+#if defined(BOOST_SP_REPORT_IMPLEMENTATION)
+
+#include <boost/config/pragma_message.hpp>
+BOOST_PRAGMA_MESSAGE("Using pthread_mutex spinlock emulation")
+
+#endif
+
 namespace boost
 {
 

include/boost/smart_ptr/detail/spinlock_std_atomic.hpp

@@ -16,8 +16,16 @@
 //
 
 #include <boost/smart_ptr/detail/yield_k.hpp>
+#include <boost/config.hpp>
 #include <atomic>
 
+#if defined(BOOST_SP_REPORT_IMPLEMENTATION)
+
+#include <boost/config/pragma_message.hpp>
+BOOST_PRAGMA_MESSAGE("Using std::atomic spinlock")
+
+#endif
+
 namespace boost
 {
 
@@ -32,12 +40,12 @@ public:
 
 public:
 
-    bool try_lock()
+    bool try_lock() BOOST_NOEXCEPT
     {
         return !v_.test_and_set( std::memory_order_acquire );
     }
 
-    void lock()
+    void lock() BOOST_NOEXCEPT
     {
         for( unsigned k = 0; !try_lock(); ++k )
         {
@@ -45,7 +53,7 @@ public:
         }
     }
 
-    void unlock()
+    void unlock() BOOST_NOEXCEPT
     {
         v_ .clear( std::memory_order_release );
     }
@@ -63,12 +71,12 @@ public:
 
     public:
 
-        explicit scoped_lock( spinlock & sp ): sp_( sp )
+        explicit scoped_lock( spinlock & sp ) BOOST_NOEXCEPT: sp_( sp )
         {
             sp.lock();
         }
 
-        ~scoped_lock()
+        ~scoped_lock() /*BOOST_NOEXCEPT*/
         {
             sp_.unlock();
         }

include/boost/smart_ptr/detail/spinlock_sync.hpp

@@ -21,6 +21,13 @@
 # include <ia64intrin.h>
 #endif
 
+#if defined(BOOST_SP_REPORT_IMPLEMENTATION)
+
+#include <boost/config/pragma_message.hpp>
+BOOST_PRAGMA_MESSAGE("Using __sync spinlock")
+
+#endif
+
 namespace boost
 {
 

include/boost/smart_ptr/detail/spinlock_w32.hpp

@@ -18,6 +18,13 @@
 #include <boost/smart_ptr/detail/sp_interlocked.hpp>
 #include <boost/smart_ptr/detail/yield_k.hpp>
 
+#if defined(BOOST_SP_REPORT_IMPLEMENTATION)
+
+#include <boost/config/pragma_message.hpp>
+BOOST_PRAGMA_MESSAGE("Using Win32 spinlock")
+
+#endif
+
 // BOOST_COMPILER_FENCE
 
 #if defined(__INTEL_COMPILER)

include/boost/smart_ptr/detail/yield_k.hpp

@@ -11,7 +11,6 @@
 //  yield_k.hpp
 //
 //  Copyright (c) 2008 Peter Dimov
-//  Copyright (c) Microsoft Corporation 2014
 //
 //  void yield( unsigned k );
 //
@@ -25,15 +24,10 @@
 //
 
 #include <boost/config.hpp>
-#include <boost/predef.h>
-
-#if BOOST_PLAT_WINDOWS_RUNTIME
-#include <thread>
-#endif
 
 // BOOST_SMT_PAUSE
 
-#if defined(_MSC_VER) && _MSC_VER >= 1310 && ( defined(_M_IX86) || defined(_M_X64) )
+#if defined(_MSC_VER) && _MSC_VER >= 1310 && ( defined(_M_IX86) || defined(_M_X64) ) && !defined(__c2__)
 
 extern "C" void _mm_pause();
 
@@ -59,20 +53,26 @@ namespace boost
 namespace detail
 {
 
-#if !defined( BOOST_USE_WINDOWS_H ) && !BOOST_PLAT_WINDOWS_RUNTIME
-#if !BOOST_COMP_CLANG || !defined __MINGW32__
-  extern "C" void __stdcall Sleep( unsigned long ms );
+#if !defined( BOOST_USE_WINDOWS_H )
+
+#if defined(__clang__) && defined(__x86_64__)
+// clang x64 warns that __stdcall is ignored
+# define BOOST_SP_STDCALL
 #else
-#include <_mingw.h>
-#if !defined __MINGW64_VERSION_MAJOR
-  extern "C" void __stdcall Sleep( unsigned long ms );
-#else
-  extern "C" __declspec(dllimport) void __stdcall Sleep( unsigned long ms );
-#endif
-#endif
+# define BOOST_SP_STDCALL __stdcall
 #endif
 
-inline void yield( unsigned k )
+#if defined(__LP64__) // Cygwin 64
+  extern "C" __declspec(dllimport) void BOOST_SP_STDCALL Sleep( unsigned int ms );
+#else
+  extern "C" __declspec(dllimport) void BOOST_SP_STDCALL Sleep( unsigned long ms );
+#endif
+
+#undef BOOST_SP_STDCALL
+
+#endif // !defined( BOOST_USE_WINDOWS_H )
+
+inline void yield( unsigned k ) BOOST_NOEXCEPT
 {
     if( k < 4 )
     {
@@ -83,7 +83,6 @@ inline void yield( unsigned k )
         BOOST_SMT_PAUSE
     }
 #endif
-#if !BOOST_PLAT_WINDOWS_RUNTIME
     else if( k < 32 )
     {
         Sleep( 0 );
@@ -92,13 +91,6 @@ inline void yield( unsigned k )
     {
         Sleep( 1 );
     }
-#else
-    else
-    {
-        // Sleep isn't supported on the Windows Runtime.
-        std::this_thread::yield();
-    }
-#endif
 }
 
 } // namespace detail

include/boost/smart_ptr/enable_shared_from.hpp

@@ -0,0 +1,41 @@
+#ifndef BOOST_SMART_PTR_ENABLE_SHARED_FROM_HPP_INCLUDED
+#define BOOST_SMART_PTR_ENABLE_SHARED_FROM_HPP_INCLUDED
+
+//  enable_shared_from.hpp
+//
+//  Copyright 2019, 2020 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/enable_shared_from_this.hpp>
+#include <boost/smart_ptr/detail/sp_noexcept.hpp>
+
+namespace boost
+{
+
+class enable_shared_from: public enable_shared_from_this<enable_shared_from>
+{
+private:
+
+    using enable_shared_from_this<enable_shared_from>::shared_from_this;
+    using enable_shared_from_this<enable_shared_from>::weak_from_this;
+};
+
+
+template<class T> shared_ptr<T> shared_from( T * p )
+{
+    return shared_ptr<T>( p->enable_shared_from_this<enable_shared_from>::shared_from_this(), p );
+}
+
+template<class T> weak_ptr<T> weak_from( T * p ) BOOST_SP_NOEXCEPT
+{
+    return weak_ptr<T>( p->enable_shared_from_this<enable_shared_from>::weak_from_this(), p );
+}
+
+} // namespace boost
+
+#endif  // #ifndef BOOST_SMART_PTR_ENABLE_SHARED_FROM_HPP_INCLUDED

include/boost/smart_ptr/enable_shared_from_raw.hpp

@@ -16,7 +16,7 @@
 #include <boost/shared_ptr.hpp>
 #include <boost/weak_ptr.hpp>
 #include <boost/assert.hpp>
-#include <boost/detail/workaround.hpp>
+#include <boost/config/workaround.hpp>
 
 namespace boost
 {
@@ -144,8 +144,7 @@ template<typename T>
 boost::weak_ptr<T> weak_from_raw(T *p)
 {
     BOOST_ASSERT(p != 0);
-    boost::weak_ptr<T> result;
-    result._internal_aliasing_assign(p->enable_shared_from_raw::weak_from_this(), p);
+    boost::weak_ptr<T> result(p->enable_shared_from_raw::weak_from_this(), p);
     return result;
 }
 

include/boost/smart_ptr/intrusive_ptr.hpp

@@ -16,7 +16,7 @@
 #include <boost/config.hpp>
 
 #include <boost/assert.hpp>
-#include <boost/detail/workaround.hpp>
+#include <boost/config/workaround.hpp>
 #include <boost/smart_ptr/detail/sp_convertible.hpp>
 #include <boost/smart_ptr/detail/sp_nullptr_t.hpp>
 #include <boost/smart_ptr/detail/sp_noexcept.hpp>
@@ -297,6 +297,8 @@ template<class T> T * get_pointer(intrusive_ptr<T> const & p) BOOST_SP_NOEXCEPT
     return p.get();
 }
 
+// pointer casts
+
 template<class T, class U> intrusive_ptr<T> static_pointer_cast(intrusive_ptr<U> const & p)
 {
     return static_cast<T *>(p.get());
@@ -312,6 +314,31 @@ template<class T, class U> intrusive_ptr<T> dynamic_pointer_cast(intrusive_ptr<U
     return dynamic_cast<T *>(p.get());
 }
 
+#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
+
+template<class T, class U> intrusive_ptr<T> static_pointer_cast( intrusive_ptr<U> && p ) BOOST_SP_NOEXCEPT
+{
+    return intrusive_ptr<T>( static_cast<T*>( p.detach() ), false );
+}
+
+template<class T, class U> intrusive_ptr<T> const_pointer_cast( intrusive_ptr<U> && p ) BOOST_SP_NOEXCEPT
+{
+    return intrusive_ptr<T>( const_cast<T*>( p.detach() ), false );
+}
+
+template<class T, class U> intrusive_ptr<T> dynamic_pointer_cast( intrusive_ptr<U> && p ) BOOST_SP_NOEXCEPT
+{
+    T * p2 = dynamic_cast<T*>( p.get() );
+
+    intrusive_ptr<T> r( p2, false );
+
+    if( p2 ) p.detach();
+
+    return r;
+}
+
+#endif // defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
+
 // operator<<
 
 #if !defined(BOOST_NO_IOSTREAM)
@@ -358,4 +385,23 @@ template< class T > std::size_t hash_value( boost::intrusive_ptr<T> const & p )
 
 } // namespace boost
 
+// std::hash
+
+#if !defined(BOOST_NO_CXX11_HDR_FUNCTIONAL)
+
+namespace std
+{
+
+template<class T> struct hash< ::boost::intrusive_ptr<T> >
+{
+    std::size_t operator()( ::boost::intrusive_ptr<T> const & p ) const BOOST_SP_NOEXCEPT
+    {
+        return std::hash< T* >()( p.get() );
+    }
+};
+
+} // namespace std
+
+#endif // #if !defined(BOOST_NO_CXX11_HDR_FUNCTIONAL)
+
 #endif  // #ifndef BOOST_SMART_PTR_INTRUSIVE_PTR_HPP_INCLUDED

include/boost/smart_ptr/local_shared_ptr.hpp

@@ -149,7 +149,7 @@ public:
 #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_ )
+    BOOST_CONSTEXPR local_shared_ptr( boost::detail::lsp_internal_constructor_tag, element_type * px_, boost::detail::local_counted_base * pn_ ) BOOST_SP_NOEXCEPT : px( px_ ), pn( pn_ )
     {
     }
 
@@ -239,9 +239,9 @@ public:
 
     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) ) ) )
+    //  : px( r.get() ), pn( new boost::detail::local_counted_impl( shared_ptr<T>( std::move(r) ) ) )
     //{
-    //	boost::detail::sp_assert_convertible< Y, T >();
+    //    boost::detail::sp_assert_convertible< Y, T >();
     //}
 
     // copy constructor
@@ -494,6 +494,13 @@ public:
     {
         return std::less< boost::detail::local_counted_base* >()( pn, r.pn );
     }
+
+    // owner_equals
+
+    template<class Y> bool owner_equals( local_shared_ptr<Y> const & r ) const BOOST_SP_NOEXCEPT
+    {
+        return 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
@@ -681,4 +688,23 @@ template< class T > std::size_t hash_value( local_shared_ptr<T> const & p ) BOOS
 
 } // namespace boost
 
+// std::hash
+
+#if !defined(BOOST_NO_CXX11_HDR_FUNCTIONAL)
+
+namespace std
+{
+
+template<class T> struct hash< ::boost::local_shared_ptr<T> >
+{
+    std::size_t operator()( ::boost::local_shared_ptr<T> const & p ) const BOOST_SP_NOEXCEPT
+    {
+        return std::hash< typename ::boost::local_shared_ptr<T>::element_type* >()( p.get() );
+    }
+};
+
+} // namespace std
+
+#endif // #if !defined(BOOST_NO_CXX11_HDR_FUNCTIONAL)
+
 #endif  // #ifndef BOOST_SMART_PTR_LOCAL_SHARED_PTR_HPP_INCLUDED

include/boost/smart_ptr/make_local_shared_array.hpp

@@ -1,63 +1,74 @@
-#ifndef BOOST_SMART_PTR_MAKE_LOCAL_SHARED_ARRAY_HPP_INCLUDED
-#define BOOST_SMART_PTR_MAKE_LOCAL_SHARED_ARRAY_HPP_INCLUDED
+/*
+Copyright 2017 Peter Dimov
+Copyright 2017-2019 Glen Joseph Fernandes
+(glenjofe@gmail.com)
 
-//  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.
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+*/
+#ifndef BOOST_SMART_PTR_MAKE_LOCAL_SHARED_ARRAY_HPP
+#define BOOST_SMART_PTR_MAKE_LOCAL_SHARED_ARRAY_HPP
 
-#include <boost/config.hpp>
-#include <boost/smart_ptr/make_shared.hpp>
-#include <utility>
-#include <cstddef>
+#include <boost/core/default_allocator.hpp>
+#include <boost/smart_ptr/allocate_local_shared_array.hpp>
 
-namespace boost
+namespace boost {
+
+template<class T>
+inline typename enable_if_<is_bounded_array<T>::value,
+    local_shared_ptr<T> >::type
+make_local_shared()
 {
-
-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)... );
+    return boost::allocate_local_shared<T>(boost::default_allocator<typename
+        detail::sp_array_element<T>::type>());
 }
 
-template<class T, class... Args> typename boost::detail::lsp_if_array<T>::type make_local_shared_noinit( Args&&... args )
+template<class T>
+inline typename enable_if_<is_bounded_array<T>::value,
+    local_shared_ptr<T> >::type
+make_local_shared(const typename remove_extent<T>::type& value)
 {
-    return boost::make_shared_noinit<T>( std::forward<Args>(args)... );
+    return boost::allocate_local_shared<T>(boost::default_allocator<typename
+        detail::sp_array_element<T>::type>(), value);
 }
 
-template<class T, class A, class... Args> typename boost::detail::lsp_if_array<T>::type allocate_local_shared( A const & a, Args&&... args )
+template<class T>
+inline typename enable_if_<is_unbounded_array<T>::value,
+    local_shared_ptr<T> >::type
+make_local_shared(std::size_t size)
 {
-    return boost::allocate_shared<T>( a, std::forward<Args>(args)... );
+    return boost::allocate_local_shared<T>(boost::default_allocator<typename
+        detail::sp_array_element<T>::type>(), size);
 }
 
-template<class T, class A, class... Args> typename boost::detail::lsp_if_array<T>::type allocate_local_shared_noinit( A const & a, Args&&... args )
+template<class T>
+inline typename enable_if_<is_unbounded_array<T>::value,
+    local_shared_ptr<T> >::type
+make_local_shared(std::size_t size,
+    const typename remove_extent<T>::type& value)
 {
-    return boost::allocate_shared_noinit<T>( a, std::forward<Args>(args)... );
+    return boost::allocate_local_shared<T>(boost::default_allocator<typename
+        detail::sp_array_element<T>::type>(), size, value);
 }
 
-} // namespace boost
+template<class T>
+inline typename enable_if_<is_bounded_array<T>::value,
+    local_shared_ptr<T> >::type
+make_local_shared_noinit()
+{
+    return boost::allocate_local_shared_noinit<T>(boost::
+        default_allocator<typename detail::sp_array_element<T>::type>());
+}
 
-#endif // #ifndef BOOST_SMART_PTR_MAKE_SHARED_OBJECT_HPP_INCLUDED
+template<class T>
+inline typename enable_if_<is_unbounded_array<T>::value,
+    local_shared_ptr<T> >::type
+make_local_shared_noinit(std::size_t size)
+{
+    return boost::allocate_local_shared_noinit<T>(boost::
+        default_allocator<typename detail::sp_array_element<T>::type>(), size);
+}
+
+} /* boost */
+
+#endif

include/boost/smart_ptr/make_local_shared_object.hpp

@@ -13,6 +13,7 @@
 
 #include <boost/smart_ptr/local_shared_ptr.hpp>
 #include <boost/smart_ptr/make_shared.hpp>
+#include <boost/type_traits/remove_const.hpp>
 #include <boost/config.hpp>
 #include <utility>
 #include <cstddef>
@@ -165,7 +166,7 @@ template<class T, class A> typename boost::detail::lsp_if_not_array<T>::type all
 
     A2 a2( a );
 
-    typedef boost::detail::lsp_ms_deleter<T, A2> D;
+    typedef boost::detail::lsp_ms_deleter< T, std::allocator<T> > D;
 
     boost::shared_ptr<T> pt( static_cast< T* >( 0 ), boost::detail::sp_inplace_tag<D>(), a2 );
 
@@ -186,12 +187,14 @@ template<class T, class A> typename boost::detail::lsp_if_not_array<T>::type all
 
 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)... );
+    typedef typename boost::remove_const<T>::type T2;
+    return boost::allocate_local_shared<T2>( std::allocator<T2>(), 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>() );
+    typedef typename boost::remove_const<T>::type T2;
+    return boost::allocate_shared_noinit<T2>( std::allocator<T2>() );
 }
 
 } // namespace boost

include/boost/smart_ptr/make_shared_array.hpp

@@ -1,5 +1,5 @@
 /*
-Copyright 2012-2017 Glen Joseph Fernandes
+Copyright 2012-2019 Glen Joseph Fernandes
 (glenjofe@gmail.com)
 
 Distributed under the Boost Software License, Version 1.0.
@@ -8,57 +8,57 @@ Distributed under the Boost Software License, Version 1.0.
 #ifndef BOOST_SMART_PTR_MAKE_SHARED_ARRAY_HPP
 #define BOOST_SMART_PTR_MAKE_SHARED_ARRAY_HPP
 
+#include <boost/core/default_allocator.hpp>
 #include <boost/smart_ptr/allocate_shared_array.hpp>
 
 namespace boost {
 
 template<class T>
-inline typename detail::sp_if_size_array<T>::type
+inline typename enable_if_<is_bounded_array<T>::value, shared_ptr<T> >::type
 make_shared()
 {
-    return boost::allocate_shared<T>(std::allocator<typename
-        detail::sp_array_scalar<T>::type>());
+    return boost::allocate_shared<T>(boost::default_allocator<typename
+        detail::sp_array_element<T>::type>());
 }
 
 template<class T>
-inline typename detail::sp_if_size_array<T>::type
-make_shared(const typename detail::sp_array_element<T>::type& value)
+inline typename enable_if_<is_bounded_array<T>::value, shared_ptr<T> >::type
+make_shared(const typename remove_extent<T>::type& value)
 {
-    return boost::allocate_shared<T>(std::allocator<typename
-        detail::sp_array_scalar<T>::type>(), value);
+    return boost::allocate_shared<T>(boost::default_allocator<typename
+        detail::sp_array_element<T>::type>(), value);
 }
 
 template<class T>
-inline typename detail::sp_if_array<T>::type
+inline typename enable_if_<is_unbounded_array<T>::value, shared_ptr<T> >::type
 make_shared(std::size_t size)
 {
-    return boost::allocate_shared<T>(std::allocator<typename
-        detail::sp_array_scalar<T>::type>(), size);
+    return boost::allocate_shared<T>(boost::default_allocator<typename
+        detail::sp_array_element<T>::type>(), size);
 }
 
 template<class T>
-inline typename detail::sp_if_array<T>::type
-make_shared(std::size_t size,
-    const typename detail::sp_array_element<T>::type& value)
+inline typename enable_if_<is_unbounded_array<T>::value, shared_ptr<T> >::type
+make_shared(std::size_t size, const typename remove_extent<T>::type& value)
 {
-    return boost::allocate_shared<T>(std::allocator<typename
-        detail::sp_array_scalar<T>::type>(), size, value);
+    return boost::allocate_shared<T>(boost::default_allocator<typename
+        detail::sp_array_element<T>::type>(), size, value);
 }
 
 template<class T>
-inline typename detail::sp_if_size_array<T>::type
+inline typename enable_if_<is_bounded_array<T>::value, shared_ptr<T> >::type
 make_shared_noinit()
 {
-    return allocate_shared_noinit<T>(std::allocator<typename
-        detail::sp_array_scalar<T>::type>());
+    return boost::allocate_shared_noinit<T>(boost::default_allocator<typename
+        detail::sp_array_element<T>::type>());
 }
 
 template<class T>
-inline typename detail::sp_if_array<T>::type
+inline typename enable_if_<is_unbounded_array<T>::value, shared_ptr<T> >::type
 make_shared_noinit(std::size_t size)
 {
-    return allocate_shared_noinit<T>(std::allocator<typename
-        detail::sp_array_scalar<T>::type>(), size);
+    return boost::allocate_shared_noinit<T>(boost::default_allocator<typename
+        detail::sp_array_element<T>::type>(), size);
 }
 
 } /* boost */

include/boost/smart_ptr/make_shared_object.hpp

@@ -187,7 +187,7 @@ template< class T > struct sp_if_not_array< T[] >
 {
 };
 
-#if !defined( __BORLANDC__ ) || !BOOST_WORKAROUND( __BORLANDC__, < 0x600 )
+#if !defined( BOOST_BORLANDC ) || !BOOST_WORKAROUND( BOOST_BORLANDC, < 0x600 )
 
 template< class T, std::size_t N > struct sp_if_not_array< T[N] >
 {

include/boost/smart_ptr/make_unique.hpp

@@ -1,5 +1,5 @@
 /*
-Copyright 2012-2015 Glen Joseph Fernandes
+Copyright 2012-2019 Glen Joseph Fernandes
 (glenjofe@gmail.com)
 
 Distributed under the Boost Software License, Version 1.0.
@@ -8,59 +8,18 @@ Distributed under the Boost Software License, Version 1.0.
 #ifndef BOOST_SMART_PTR_MAKE_UNIQUE_HPP
 #define BOOST_SMART_PTR_MAKE_UNIQUE_HPP
 
-#include <boost/config.hpp>
+#include <boost/type_traits/enable_if.hpp>
+#include <boost/type_traits/is_array.hpp>
+#include <boost/type_traits/is_unbounded_array.hpp>
+#include <boost/type_traits/remove_extent.hpp>
+#include <boost/type_traits/remove_reference.hpp>
 #include <memory>
 #include <utility>
 
 namespace boost {
-namespace detail {
 
 template<class T>
-struct up_if_object {
-    typedef std::unique_ptr<T> type;
-};
-
-template<class T>
-struct up_if_object<T[]> { };
-
-template<class T, std::size_t N>
-struct up_if_object<T[N]> { };
-
-template<class T>
-struct up_if_array { };
-
-template<class T>
-struct up_if_array<T[]> {
-    typedef std::unique_ptr<T[]> type;
-};
-
-template<class T>
-struct up_remove_reference {
-    typedef T type;
-};
-
-template<class T>
-struct up_remove_reference<T&> {
-    typedef T type;
-};
-
-template<class T>
-struct up_remove_reference<T&&> {
-    typedef T type;
-};
-
-template<class T>
-struct up_element { };
-
-template<class T>
-struct up_element<T[]> {
-    typedef T type;
-};
-
-} /* detail */
-
-template<class T>
-inline typename detail::up_if_object<T>::type
+inline typename enable_if_<!is_array<T>::value, std::unique_ptr<T> >::type
 make_unique()
 {
     return std::unique_ptr<T>(new T());
@@ -68,7 +27,7 @@ make_unique()
 
 #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
 template<class T, class... Args>
-inline typename detail::up_if_object<T>::type
+inline typename enable_if_<!is_array<T>::value, std::unique_ptr<T> >::type
 make_unique(Args&&... args)
 {
     return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
@@ -76,33 +35,33 @@ make_unique(Args&&... args)
 #endif
 
 template<class T>
-inline typename detail::up_if_object<T>::type
-make_unique(typename detail::up_remove_reference<T>::type&& value)
+inline typename enable_if_<!is_array<T>::value, std::unique_ptr<T> >::type
+make_unique(typename remove_reference<T>::type&& value)
 {
     return std::unique_ptr<T>(new T(std::move(value)));
 }
 
 template<class T>
-inline typename detail::up_if_object<T>::type
+inline typename enable_if_<!is_array<T>::value, std::unique_ptr<T> >::type
 make_unique_noinit()
 {
     return std::unique_ptr<T>(new T);
 }
 
 template<class T>
-inline typename detail::up_if_array<T>::type
+inline typename enable_if_<is_unbounded_array<T>::value,
+    std::unique_ptr<T> >::type
 make_unique(std::size_t size)
 {
-    return std::unique_ptr<T>(new typename
-        detail::up_element<T>::type[size]());
+    return std::unique_ptr<T>(new typename remove_extent<T>::type[size]());
 }
 
 template<class T>
-inline typename detail::up_if_array<T>::type
+inline typename enable_if_<is_unbounded_array<T>::value,
+    std::unique_ptr<T> >::type
 make_unique_noinit(std::size_t size)
 {
-    return std::unique_ptr<T>(new typename
-        detail::up_element<T>::type[size]);
+    return std::unique_ptr<T>(new typename remove_extent<T>::type[size]);
 }
 
 } /* boost */

include/boost/smart_ptr/owner_equal_to.hpp

@@ -0,0 +1,27 @@
+#ifndef BOOST_SMART_PTR_OWNER_EQUAL_TO_HPP_INCLUDED
+#define BOOST_SMART_PTR_OWNER_EQUAL_TO_HPP_INCLUDED
+
+// Copyright 2020 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/config.hpp>
+
+namespace boost
+{
+
+template<class T = void> struct owner_equal_to
+{
+    typedef bool result_type;
+    typedef T first_argument_type;
+    typedef T second_argument_type;
+
+    template<class U, class V> bool operator()( U const & u, V const & v ) const BOOST_NOEXCEPT
+    {
+        return u.owner_equals( v );
+    }
+};
+
+} // namespace boost
+
+#endif  // #ifndef BOOST_SMART_PTR_OWNER_EQUAL_TO_HPP_INCLUDED

include/boost/smart_ptr/owner_less.hpp

@@ -14,6 +14,8 @@
 //  See http://www.boost.org/libs/smart_ptr/ for documentation.
 //
 
+#include <boost/config.hpp>
+
 namespace boost
 {
 
@@ -23,7 +25,7 @@ template<class T = void> struct owner_less
     typedef T first_argument_type;
     typedef T second_argument_type;
 
-    template<class U, class V> bool operator()( U const & u, V const & v ) const
+    template<class U, class V> bool operator()( U const & u, V const & v ) const BOOST_NOEXCEPT
     {
         return u.owner_before( v );
     }

include/boost/smart_ptr/scoped_array.hpp

@@ -16,7 +16,7 @@
 #include <boost/smart_ptr/detail/sp_nullptr_t.hpp>
 #include <boost/smart_ptr/detail/sp_noexcept.hpp>
 
-#include <boost/detail/workaround.hpp>
+#include <boost/config/workaround.hpp>
 
 #include <cstddef>            // for std::ptrdiff_t
 

include/boost/smart_ptr/scoped_ptr.hpp

@@ -16,7 +16,7 @@
 #include <boost/smart_ptr/detail/sp_nullptr_t.hpp>
 #include <boost/smart_ptr/detail/sp_disable_deprecated.hpp>
 #include <boost/smart_ptr/detail/sp_noexcept.hpp>
-#include <boost/detail/workaround.hpp>
+#include <boost/config/workaround.hpp>
 
 #ifndef BOOST_NO_AUTO_PTR
 # include <memory>          // for std::auto_ptr

include/boost/smart_ptr/shared_array.hpp

@@ -25,7 +25,7 @@
 #include <boost/smart_ptr/detail/shared_count.hpp>
 #include <boost/smart_ptr/detail/sp_nullptr_t.hpp>
 #include <boost/smart_ptr/detail/sp_noexcept.hpp>
-#include <boost/detail/workaround.hpp>
+#include <boost/config/workaround.hpp>
 
 #include <cstddef>            // for std::ptrdiff_t
 #include <algorithm>          // for std::swap
@@ -225,7 +225,7 @@ public:
         pn.swap(other.pn);
     }
 
-    void * _internal_get_deleter( boost::detail::sp_typeinfo const & ti ) const BOOST_SP_NOEXCEPT
+    void * _internal_get_deleter( boost::detail::sp_typeinfo_ const & ti ) const BOOST_SP_NOEXCEPT
     {
         return pn.get_deleter( ti );
     }
@@ -285,7 +285,7 @@ template<class T> void swap(shared_array<T> & a, shared_array<T> & b) BOOST_SP_N
 
 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) ) );
+    return static_cast< D * >( p._internal_get_deleter( BOOST_SP_TYPEID_(D) ) );
 }
 
 } // namespace boost

include/boost/smart_ptr/shared_ptr.hpp

@@ -26,7 +26,7 @@
 #include <boost/checked_delete.hpp>
 #include <boost/throw_exception.hpp>
 #include <boost/smart_ptr/detail/shared_count.hpp>
-#include <boost/detail/workaround.hpp>
+#include <boost/config/workaround.hpp>
 #include <boost/smart_ptr/detail/sp_convertible.hpp>
 #include <boost/smart_ptr/detail/sp_nullptr_t.hpp>
 #include <boost/smart_ptr/detail/sp_disable_deprecated.hpp>
@@ -86,7 +86,7 @@ template< class T > struct sp_element< T[] >
     typedef T type;
 };
 
-#if !defined( __BORLANDC__ ) || !BOOST_WORKAROUND( __BORLANDC__, < 0x600 )
+#if !defined( BOOST_BORLANDC ) || !BOOST_WORKAROUND( BOOST_BORLANDC, < 0x600 )
 
 template< class T, std::size_t N > struct sp_element< T[N] >
 {
@@ -135,7 +135,7 @@ template< class T > struct sp_dereference< T[] >
     typedef void type;
 };
 
-#if !defined( __BORLANDC__ ) || !BOOST_WORKAROUND( __BORLANDC__, < 0x600 )
+#if !defined( BOOST_BORLANDC ) || !BOOST_WORKAROUND( BOOST_BORLANDC, < 0x600 )
 
 template< class T, std::size_t N > struct sp_dereference< T[N] >
 {
@@ -160,7 +160,7 @@ template< class T > struct sp_member_access< T[] >
     typedef void type;
 };
 
-#if !defined( __BORLANDC__ ) || !BOOST_WORKAROUND( __BORLANDC__, < 0x600 )
+#if !defined( BOOST_BORLANDC ) || !BOOST_WORKAROUND( BOOST_BORLANDC, < 0x600 )
 
 template< class T, std::size_t N > struct sp_member_access< T[N] >
 {
@@ -185,7 +185,7 @@ template< class T > struct sp_array_access< T[] >
     typedef T & type;
 };
 
-#if !defined( __BORLANDC__ ) || !BOOST_WORKAROUND( __BORLANDC__, < 0x600 )
+#if !defined( BOOST_BORLANDC ) || !BOOST_WORKAROUND( BOOST_BORLANDC, < 0x600 )
 
 template< class T, std::size_t N > struct sp_array_access< T[N] >
 {
@@ -777,12 +777,22 @@ public:
         return pn < rhs.pn;
     }
 
-    void * _internal_get_deleter( boost::detail::sp_typeinfo const & ti ) const BOOST_SP_NOEXCEPT
+    template<class Y> bool owner_equals( shared_ptr<Y> const & rhs ) const BOOST_SP_NOEXCEPT
+    {
+        return pn == rhs.pn;
+    }
+
+    template<class Y> bool owner_equals( 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_SP_NOEXCEPT
     {
         return pn.get_deleter( ti );
     }
 
-    void * _internal_get_local_deleter( boost::detail::sp_typeinfo const & ti ) const BOOST_SP_NOEXCEPT
+    void * _internal_get_local_deleter( boost::detail::sp_typeinfo_ const & ti ) const BOOST_SP_NOEXCEPT
     {
         return pn.get_local_deleter( ti );
     }
@@ -797,7 +807,7 @@ public:
         return px == r.px && pn == r.pn;
     }
 
-    boost::detail::shared_count _internal_count() const BOOST_NOEXCEPT
+    boost::detail::shared_count _internal_count() const BOOST_SP_NOEXCEPT
     {
         return pn;
     }
@@ -1008,7 +1018,7 @@ namespace detail
 
 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)) );
+    return static_cast<D *>( p._internal_get_deleter(BOOST_SP_TYPEID_(D)) );
 }
 
 template<class D, class T> D * basic_get_local_deleter( D *, shared_ptr<T> const & p ) BOOST_SP_NOEXCEPT;
@@ -1022,7 +1032,7 @@ private:
 
 public:
 
-    esft2_deleter_wrapper()
+    esft2_deleter_wrapper() BOOST_SP_NOEXCEPT
     {
     }
 
@@ -1080,7 +1090,7 @@ template<class T> shared_ptr<T> atomic_load( shared_ptr<T> const * p ) BOOST_SP_
     return *p;
 }
 
-template<class T> inline shared_ptr<T> atomic_load_explicit( shared_ptr<T> const * p, /*memory_order mo*/ int ) BOOST_SP_NOEXCEPT
+template<class T, class M> inline shared_ptr<T> atomic_load_explicit( shared_ptr<T> const * p, /*memory_order mo*/ M ) BOOST_SP_NOEXCEPT
 {
     return atomic_load( p );
 }
@@ -1091,7 +1101,7 @@ template<class T> void atomic_store( shared_ptr<T> * p, shared_ptr<T> r ) BOOST_
     p->swap( r );
 }
 
-template<class T> inline void atomic_store_explicit( shared_ptr<T> * p, shared_ptr<T> r, /*memory_order mo*/ int ) BOOST_SP_NOEXCEPT
+template<class T, class M> inline void atomic_store_explicit( shared_ptr<T> * p, shared_ptr<T> r, /*memory_order mo*/ M ) BOOST_SP_NOEXCEPT
 {
     atomic_store( p, r ); // std::move( r )
 }
@@ -1107,7 +1117,7 @@ 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> inline atomic_exchange_explicit( shared_ptr<T> * p, shared_ptr<T> r, /*memory_order mo*/ int ) BOOST_SP_NOEXCEPT
+template<class T, class M> shared_ptr<T> inline atomic_exchange_explicit( shared_ptr<T> * p, shared_ptr<T> r, /*memory_order mo*/ M ) BOOST_SP_NOEXCEPT
 {
     return atomic_exchange( p, r ); // std::move( r )
 }
@@ -1137,7 +1147,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 ) BOOST_SP_NOEXCEPT
+template<class T, class M> inline bool atomic_compare_exchange_explicit( shared_ptr<T> * p, shared_ptr<T> * v, shared_ptr<T> w, /*memory_order success*/ M, /*memory_order failure*/ M ) BOOST_SP_NOEXCEPT
 {
     return atomic_compare_exchange( p, v, w ); // std::move( w )
 }
@@ -1155,6 +1165,25 @@ template< class T > std::size_t hash_value( boost::shared_ptr<T> const & p ) BOO
 
 } // namespace boost
 
+// std::hash
+
+#if !defined(BOOST_NO_CXX11_HDR_FUNCTIONAL)
+
+namespace std
+{
+
+template<class T> struct hash< ::boost::shared_ptr<T> >
+{
+    std::size_t operator()( ::boost::shared_ptr<T> const & p ) const BOOST_SP_NOEXCEPT
+    {
+        return std::hash< typename ::boost::shared_ptr<T>::element_type* >()( p.get() );
+    }
+};
+
+} // namespace std
+
+#endif // #if !defined(BOOST_NO_CXX11_HDR_FUNCTIONAL)
+
 #include <boost/smart_ptr/detail/local_sp_deleter.hpp>
 
 namespace boost
@@ -1165,16 +1194,23 @@ 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>) ) );
+    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>) ) );
+    return static_cast<D *>( p._internal_get_local_deleter( BOOST_SP_TYPEID_(local_sp_deleter<D>) ) );
 }
 
 } // namespace detail
 
+#if defined(__cpp_deduction_guides)
+
+template<class T> shared_ptr( weak_ptr<T> ) -> shared_ptr<T>;
+template<class T, class D> shared_ptr( std::unique_ptr<T, D> ) -> shared_ptr<T>;
+
+#endif
+
 } // namespace boost
 
 #if defined( BOOST_SP_DISABLE_DEPRECATED )