Remove support for BOOST_SP_USE_QUICK_ALLOCATOR

Enable C++20 constexpr for intrusive_ptr

.drone.jsonnet

@@ -32,7 +32,8 @@ local linux_pipeline(name, image, environment, packages = "", sources = [], arch
             commands:
             [
                 'set -e',
-                'wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key | apt-key add -',
+                'uname -a',
+                'echo $DRONE_STAGE_MACHINE',
             ] +
             (if sources != [] then [ ('apt-add-repository "' + source + '"') for source in sources ] else []) +
             (if packages != "" then [ 'apt-get update', 'apt-get -y install ' + packages ] else []) +
@@ -96,40 +97,16 @@ local windows_pipeline(name, image, environment, arch = "amd64") =
 };
 
 [
-    linux_pipeline(
-        "Linux 14.04 GCC 4.4",
-        "cppalliance/droneubuntu1404:1",
-        { TOOLSET: 'gcc', COMPILER: 'g++-4.4', CXXSTD: '98,0x' },
-        "g++-4.4",
-        [ "ppa:ubuntu-toolchain-r/test" ],
-    ),
-
-    linux_pipeline(
-        "Linux 14.04 GCC 4.6",
-        "cppalliance/droneubuntu1404:1",
-        { TOOLSET: 'gcc', COMPILER: 'g++-4.6', CXXSTD: '98,0x' },
-        "g++-4.6",
-        [ "ppa:ubuntu-toolchain-r/test" ],
-    ),
-
-    linux_pipeline(
-        "Linux 14.04 GCC 4.7",
-        "cppalliance/droneubuntu1404:1",
-        { TOOLSET: 'gcc', COMPILER: 'g++-4.7', CXXSTD: '98,0x' },
-        "g++-4.7",
-        [ "ppa:ubuntu-toolchain-r/test" ],
-    ),
-
     linux_pipeline(
         "Linux 14.04 GCC 4.8*",
         "cppalliance/droneubuntu1404:1",
-        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '03,11' },
+        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '11' },
     ),
 
     linux_pipeline(
         "Linux 14.04 GCC 4.9",
         "cppalliance/droneubuntu1404:1",
-        { TOOLSET: 'gcc', COMPILER: 'g++-4.9', CXXSTD: '03,11' },
+        { TOOLSET: 'gcc', COMPILER: 'g++-4.9', CXXSTD: '11' },
         "g++-4.9",
         [ "ppa:ubuntu-toolchain-r/test" ],
     ),
@@ -137,236 +114,291 @@ local windows_pipeline(name, image, environment, arch = "amd64") =
     linux_pipeline(
         "Linux 16.04 GCC 5*",
         "cppalliance/droneubuntu1604:1",
-        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '03,11,14' },
+        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '11,14' },
     ),
 
     linux_pipeline(
         "Linux 18.04 GCC 6",
         "cppalliance/droneubuntu1804:1",
-        { TOOLSET: 'gcc', COMPILER: 'g++-6', CXXSTD: '03,11,14' },
+        { TOOLSET: 'gcc', COMPILER: 'g++-6', CXXSTD: '11,14' },
         "g++-6",
     ),
 
     linux_pipeline(
         "Linux 18.04 GCC 7* 32/64",
         "cppalliance/droneubuntu1804:1",
-        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '03,11,14,17', ADDRMD: '32,64' },
+        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '11,14,17', ADDRMD: '32,64' },
     ),
 
     linux_pipeline(
         "Linux 18.04 GCC 8 32/64",
         "cppalliance/droneubuntu1804:1",
-        { TOOLSET: 'gcc', COMPILER: 'g++-8', CXXSTD: '03,11,14,17', ADDRMD: '32,64' },
+        { TOOLSET: 'gcc', COMPILER: 'g++-8', CXXSTD: '11,14,17', ADDRMD: '32,64' },
         "g++-8-multilib",
     ),
 
     linux_pipeline(
         "Linux 20.04 GCC 9* 32/64",
         "cppalliance/droneubuntu2004:1",
-        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '03,11,14,17,2a', ADDRMD: '32,64' },
+        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '11,14,17,2a', ADDRMD: '32,64' },
     ),
 
     linux_pipeline(
         "Linux 20.04 GCC 9* ARM64",
         "cppalliance/droneubuntu2004:multiarch",
-        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '03,11,14,17,2a' },
+        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '11,14,17,2a' },
         arch="arm64",
     ),
 
     linux_pipeline(
         "Linux 20.04 GCC 9* S390x",
         "cppalliance/droneubuntu2004:multiarch",
-        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '03,11,14,17,2a' },
+        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '11,14,17,2a' },
         arch="s390x",
     ),
 
     linux_pipeline(
         "Linux 20.04 GCC 10 32/64",
         "cppalliance/droneubuntu2004:1",
-        { TOOLSET: 'gcc', COMPILER: 'g++-10', CXXSTD: '03,11,14,17,20', ADDRMD: '32,64' },
+        { TOOLSET: 'gcc', COMPILER: 'g++-10', CXXSTD: '11,14,17,20', ADDRMD: '32,64' },
         "g++-10-multilib",
     ),
 
     linux_pipeline(
         "Linux 22.04 GCC 11* 32/64",
         "cppalliance/droneubuntu2204:1",
-        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '03,11,14,17,2a', ADDRMD: '32,64' },
+        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '11,14,17,2a', ADDRMD: '32,64' },
     ),
 
     linux_pipeline(
-        "Linux 22.04 GCC 12 32 ASAN",
+        "Linux 22.04 GCC 12 32/64",
         "cppalliance/droneubuntu2204:1",
-        { TOOLSET: 'gcc', COMPILER: 'g++-12', CXXSTD: '03,11,14,17,20,2b', ADDRMD: '32' } + asan,
+        { TOOLSET: 'gcc', COMPILER: 'g++-12', CXXSTD: '11,14,17,20,2b', ADDRMD: '32,64' },
         "g++-12-multilib",
     ),
 
     linux_pipeline(
-        "Linux 22.04 GCC 12 64 ASAN",
-        "cppalliance/droneubuntu2204:1",
-        { TOOLSET: 'gcc', COMPILER: 'g++-12', CXXSTD: '03,11,14,17,20,2b', ADDRMD: '64' } + asan,
-        "g++-12-multilib",
+        "Linux 24.04 GCC 13 32 ASAN",
+        "cppalliance/droneubuntu2404:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-13', CXXSTD: '11,14,17,20,2b', ADDRMD: '32' } + asan,
+        "g++-13-multilib",
+    ),
+
+    linux_pipeline(
+        "Linux 24.04 GCC 13 32 UBSAN",
+        "cppalliance/droneubuntu2404:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-13', CXXSTD: '11,14,17,20,2b', ADDRMD: '32' } + ubsan,
+        "g++-13-multilib",
+    ),
+
+    linux_pipeline(
+        "Linux 24.04 GCC 13 64 UBSAN",
+        "cppalliance/droneubuntu2404:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-13', CXXSTD: '11,14,17,20,2b', ADDRMD: '64' } + ubsan,
+        "g++-13-multilib",
+    ),
+
+    linux_pipeline(
+        "Linux 24.04 GCC 14 UBSAN",
+        "cppalliance/droneubuntu2404:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-14', CXXSTD: '11,14,17,20,2b' } + ubsan,
+        "g++-14-multilib",
+    ),
+
+    linux_pipeline(
+        "Linux 24.04 GCC 14 ASAN",
+        "cppalliance/droneubuntu2404:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-14', CXXSTD: '11,14,17,20,2b' } + asan,
+        "g++-14-multilib",
     ),
 
     linux_pipeline(
         "Linux 16.04 Clang 3.5",
         "cppalliance/droneubuntu1604:1",
-        { TOOLSET: 'clang', COMPILER: 'clang++-3.5', CXXSTD: '03,11' },
+        { TOOLSET: 'clang', COMPILER: 'clang++-3.5', CXXSTD: '11' },
         "clang-3.5",
     ),
 
     linux_pipeline(
         "Linux 16.04 Clang 3.6",
         "cppalliance/droneubuntu1604:1",
-        { TOOLSET: 'clang', COMPILER: 'clang++-3.6', CXXSTD: '03,11,14' },
+        { TOOLSET: 'clang', COMPILER: 'clang++-3.6', CXXSTD: '11,14' },
         "clang-3.6",
     ),
 
     linux_pipeline(
         "Linux 16.04 Clang 3.7",
         "cppalliance/droneubuntu1604:1",
-        { TOOLSET: 'clang', COMPILER: 'clang++-3.7', CXXSTD: '03,11,14' },
+        { TOOLSET: 'clang', COMPILER: 'clang++-3.7', CXXSTD: '11,14' },
         "clang-3.7",
     ),
 
     linux_pipeline(
         "Linux 16.04 Clang 3.8",
         "cppalliance/droneubuntu1604:1",
-        { TOOLSET: 'clang', COMPILER: 'clang++-3.8', CXXSTD: '03,11,14' },
+        { TOOLSET: 'clang', COMPILER: 'clang++-3.8', CXXSTD: '11,14' },
         "clang-3.8",
     ),
 
     linux_pipeline(
         "Linux 18.04 Clang 3.9",
         "cppalliance/droneubuntu1804:1",
-        { TOOLSET: 'clang', COMPILER: 'clang++-3.9', CXXSTD: '03,11,14' },
+        { TOOLSET: 'clang', COMPILER: 'clang++-3.9', CXXSTD: '11,14' },
         "clang-3.9",
     ),
 
     linux_pipeline(
         "Linux 18.04 Clang 4.0",
         "cppalliance/droneubuntu1804:1",
-        { TOOLSET: 'clang', COMPILER: 'clang++-4.0', CXXSTD: '03,11,14' },
+        { TOOLSET: 'clang', COMPILER: 'clang++-4.0', CXXSTD: '11,14' },
         "clang-4.0",
     ),
 
     linux_pipeline(
         "Linux 18.04 Clang 5.0",
         "cppalliance/droneubuntu1804:1",
-        { TOOLSET: 'clang', COMPILER: 'clang++-5.0', CXXSTD: '03,11,14' },
+        { TOOLSET: 'clang', COMPILER: 'clang++-5.0', CXXSTD: '11,14' },
         "clang-5.0",
     ),
 
     linux_pipeline(
         "Linux 20.04 Clang 6.0",
         "cppalliance/droneubuntu2004:1",
-        { TOOLSET: 'clang', COMPILER: 'clang++-6.0', CXXSTD: '03,11,14,17' },
+        { TOOLSET: 'clang', COMPILER: 'clang++-6.0', CXXSTD: '11,14,17' },
         "clang-6.0",
     ),
 
     linux_pipeline(
         "Linux 20.04 Clang 7",
         "cppalliance/droneubuntu2004:1",
-        { TOOLSET: 'clang', COMPILER: 'clang++-7', CXXSTD: '03,11,14,17' },
+        { TOOLSET: 'clang', COMPILER: 'clang++-7', CXXSTD: '11,14,17' },
         "clang-7",
     ),
 
     linux_pipeline(
         "Linux 20.04 Clang 8",
         "cppalliance/droneubuntu2004:1",
-        { TOOLSET: 'clang', COMPILER: 'clang++-8', CXXSTD: '03,11,14,17' },
+        { TOOLSET: 'clang', COMPILER: 'clang++-8', CXXSTD: '11,14,17' },
         "clang-8",
     ),
 
     linux_pipeline(
         "Linux 20.04 Clang 9",
         "cppalliance/droneubuntu2004:1",
-        { TOOLSET: 'clang', COMPILER: 'clang++-9', CXXSTD: '03,11,14,17,2a' },
+        { TOOLSET: 'clang', COMPILER: 'clang++-9', CXXSTD: '11,14,17,2a' },
         "clang-9",
     ),
 
     linux_pipeline(
         "Linux 20.04 Clang 10",
         "cppalliance/droneubuntu2004:1",
-        { TOOLSET: 'clang', COMPILER: 'clang++-10', CXXSTD: '03,11,14,17,2a' },
+        { TOOLSET: 'clang', COMPILER: 'clang++-10', CXXSTD: '11,14,17,2a' },
         "clang-10",
     ),
 
     linux_pipeline(
         "Linux 20.04 Clang 11",
         "cppalliance/droneubuntu2004:1",
-        { TOOLSET: 'clang', COMPILER: 'clang++-11', CXXSTD: '03,11,14,17,2a' },
+        { TOOLSET: 'clang', COMPILER: 'clang++-11', CXXSTD: '11,14,17,2a' },
         "clang-11",
     ),
 
     linux_pipeline(
         "Linux 20.04 Clang 12",
         "cppalliance/droneubuntu2004:1",
-        { TOOLSET: 'clang', COMPILER: 'clang++-12', CXXSTD: '03,11,14,17,20' },
+        { TOOLSET: 'clang', COMPILER: 'clang++-12', CXXSTD: '11,14,17,20' },
         "clang-12",
     ),
 
     linux_pipeline(
         "Linux 22.04 Clang 13",
         "cppalliance/droneubuntu2204:1",
-        { TOOLSET: 'clang', COMPILER: 'clang++-13', CXXSTD: '03,11,14,17,20,2b' },
+        { TOOLSET: 'clang', COMPILER: 'clang++-13', CXXSTD: '11,14,17,20,2b' },
         "clang-13",
     ),
 
     linux_pipeline(
         "Linux 22.04 Clang 14",
         "cppalliance/droneubuntu2204:1",
-        { TOOLSET: 'clang', COMPILER: 'clang++-14', CXXSTD: '03,11,14,17,20,2b' },
+        { TOOLSET: 'clang', COMPILER: 'clang++-14', CXXSTD: '11,14,17,20,2b' },
         "clang-14",
     ),
 
     linux_pipeline(
-        "Linux 22.04 Clang 15 UBSAN",
+        "Linux 22.04 Clang 15",
         "cppalliance/droneubuntu2204:1",
-        { TOOLSET: 'clang', COMPILER: 'clang++-15', CXXSTD: '03,11,14,17,20,2b' } + ubsan,
+        { TOOLSET: 'clang', COMPILER: 'clang++-15', CXXSTD: '11,14,17,20,2b' },
         "clang-15",
     ),
 
     linux_pipeline(
-        "Linux 22.04 Clang 15 ASAN",
-        "cppalliance/droneubuntu2204:1",
-        { TOOLSET: 'clang', COMPILER: 'clang++-15', CXXSTD: '03,11,14,17,20,2b' } + asan,
-        "clang-15",
-    ),
-
-    linux_pipeline(
-        "Linux 22.04 Clang 16",
-        "cppalliance/droneubuntu2204:1",
-        { TOOLSET: 'clang', COMPILER: 'clang++-16', CXXSTD: '03,11,14,17,20,2b' },
+        "Linux 24.04 Clang 16",
+        "cppalliance/droneubuntu2404:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-16', CXXSTD: '11,14,17,20,2b' },
         "clang-16",
-        ["deb http://apt.llvm.org/jammy/ llvm-toolchain-jammy-16 main"],
+    ),
+
+    linux_pipeline(
+        "Linux 24.04 Clang 17",
+        "cppalliance/droneubuntu2404:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-17', CXXSTD: '11,14,17,20,2b' },
+        "clang-17",
+    ),
+
+    linux_pipeline(
+        "Linux 24.04 Clang 18",
+        "cppalliance/droneubuntu2404:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-18', CXXSTD: '11,14,17,20,2b' },
+        "clang-18",
+    ),
+
+    linux_pipeline(
+        "Linux 24.04 Clang 19",
+        "cppalliance/droneubuntu2404:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-19', CXXSTD: '11,14,17,20,2b' },
+        "clang-19",
+    ),
+
+    linux_pipeline(
+        "Linux 24.04 Clang 20 UBSAN",
+        "cppalliance/droneubuntu2404:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-20', CXXSTD: '11,14,17,20,23,2c' } + ubsan,
+        "clang-20",
+    ),
+
+    linux_pipeline(
+        "Linux 24.04 Clang 20 ASAN",
+        "cppalliance/droneubuntu2404:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-20', CXXSTD: '11,14,17,20,23,2c' } + asan,
+        "clang-20",
     ),
 
     macos_pipeline(
         "MacOS 10.15 Xcode 12.2 UBSAN",
-        { TOOLSET: 'clang', COMPILER: 'clang++', CXXSTD: '03,11,14,1z' } + ubsan,
+        { TOOLSET: 'clang', COMPILER: 'clang++', CXXSTD: '11,14,1z' } + ubsan,
     ),
 
     macos_pipeline(
         "MacOS 10.15 Xcode 12.2 ASAN",
-        { TOOLSET: 'clang', COMPILER: 'clang++', CXXSTD: '03,11,14,1z' } + asan,
+        { TOOLSET: 'clang', COMPILER: 'clang++', CXXSTD: '11,14,1z' } + asan,
     ),
 
     macos_pipeline(
         "MacOS 12.4 Xcode 13.4.1 UBSAN",
-        { TOOLSET: 'clang', COMPILER: 'clang++', CXXSTD: '03,11,14,17,20,2b' } + ubsan,
+        { TOOLSET: 'clang', COMPILER: 'clang++', CXXSTD: '11,14,17,20,2b' } + ubsan,
         xcode_version = "13.4.1", osx_version = "monterey", arch = "arm64",
     ),
 
     macos_pipeline(
         "MacOS 12.4 Xcode 13.4.1 ASAN",
-        { TOOLSET: 'clang', COMPILER: 'clang++', CXXSTD: '03,11,14,17,20,2b' } + asan,
+        { TOOLSET: 'clang', COMPILER: 'clang++', CXXSTD: '11,14,17,20,2b' } + asan,
         xcode_version = "13.4.1", osx_version = "monterey", arch = "arm64",
     ),
 
     windows_pipeline(
         "Windows VS2015 msvc-14.0",
         "cppalliance/dronevs2015",
-        { TOOLSET: 'msvc-14.0', CXXSTD: '14,latest' },
+        { TOOLSET: 'msvc-14.0', CXXSTD: '14,latest', B2_DONT_EMBED_MANIFEST: '1' },
     ),
 
     windows_pipeline(

.github/workflows/ci.yml

@@ -18,156 +18,220 @@ jobs:
       matrix:
         include:
           - toolset: gcc-4.8
-            cxxstd: "03,11"
-            os: ubuntu-latest
+            cxxstd: "11"
             container: ubuntu:18.04
+            os: ubuntu-latest
             install: g++-4.8-multilib
             address-model: 32,64
           - toolset: gcc-5
-            cxxstd: "03,11,14,1z"
-            os: ubuntu-latest
+            cxxstd: "11,14,1z"
             container: ubuntu:18.04
+            os: ubuntu-latest
             install: g++-5-multilib
             address-model: 32,64
           - toolset: gcc-6
-            cxxstd: "03,11,14,1z"
-            os: ubuntu-latest
+            cxxstd: "11,14,1z"
             container: ubuntu:18.04
+            os: ubuntu-latest
             install: g++-6-multilib
             address-model: 32,64
           - toolset: gcc-7
-            cxxstd: "03,11,14,17"
-            os: ubuntu-latest
+            cxxstd: "11,14,17"
             container: ubuntu:18.04
+            os: ubuntu-latest
             install: g++-7-multilib
             address-model: 32,64
           - toolset: gcc-8
-            cxxstd: "03,11,14,17,2a"
-            os: ubuntu-20.04
+            cxxstd: "11,14,17,2a"
+            container: ubuntu:20.04
+            os: ubuntu-latest
             install: g++-8-multilib
             address-model: 32,64
           - toolset: gcc-9
-            cxxstd: "03,11,14,17,2a"
-            os: ubuntu-20.04
+            cxxstd: "11,14,17,2a"
+            container: ubuntu:20.04
+            os: ubuntu-latest
             install: g++-9-multilib
             address-model: 32,64
           - toolset: gcc-10
-            cxxstd: "03,11,14,17,2a"
-            os: ubuntu-20.04
+            cxxstd: "11,14,17,2a"
+            container: ubuntu:20.04
+            os: ubuntu-latest
             install: g++-10-multilib
             address-model: 32,64
           - toolset: gcc-11
-            cxxstd: "03,11,14,17,20"
-            os: ubuntu-20.04
+            cxxstd: "11,14,17,20"
+            os: ubuntu-22.04
             install: g++-11-multilib
             address-model: 32,64
           - toolset: gcc-12
-            cxxstd: "03,11,14,17,20,2b"
+            cxxstd: "11,14,17,20,2b"
             os: ubuntu-22.04
             install: g++-12-multilib
             address-model: 32,64
           - toolset: gcc-13
-            cxxstd: "03,11,14,17,20,2b"
+            cxxstd: "11,14,17,20,2b"
             os: ubuntu-latest
-            container: ubuntu:23.04
+            container: ubuntu:24.04
             install: g++-13-multilib
             address-model: 32,64
+          - toolset: gcc-14
+            cxxstd: "11,14,17,20,23,2c"
+            os: ubuntu-latest
+            container: ubuntu:24.04
+            install: g++-14-multilib
+            address-model: 32,64
+          - toolset: gcc-15
+            cxxstd: "11,14,17,20,23,2c"
+            os: ubuntu-latest
+            container: ubuntu:25.04
+            install: g++-15-multilib
+            address-model: 32,64
           - toolset: clang
             compiler: clang++-3.9
-            cxxstd: "03,11,14"
-            os: ubuntu-latest
+            cxxstd: "11,14"
             container: ubuntu:18.04
+            os: ubuntu-latest
             install: clang-3.9
           - toolset: clang
             compiler: clang++-4.0
-            cxxstd: "03,11,14"
-            os: ubuntu-latest
+            cxxstd: "11,14"
             container: ubuntu:18.04
+            os: ubuntu-latest
             install: clang-4.0
           - toolset: clang
             compiler: clang++-5.0
-            cxxstd: "03,11,14,1z"
-            os: ubuntu-latest
+            cxxstd: "11,14,1z"
             container: ubuntu:18.04
+            os: ubuntu-latest
             install: clang-5.0
           - toolset: clang
             compiler: clang++-6.0
-            cxxstd: "03,11,14,17"
-            os: ubuntu-20.04
+            cxxstd: "11,14,17"
+            container: ubuntu:20.04
+            os: ubuntu-latest
             install: clang-6.0
           - toolset: clang
             compiler: clang++-7
-            cxxstd: "03,11,14,17"
-            os: ubuntu-20.04
+            cxxstd: "11,14,17"
+            container: ubuntu:20.04
+            os: ubuntu-latest
             install: clang-7
           - toolset: clang
             compiler: clang++-8
-            cxxstd: "03,11,14,17"
-            os: ubuntu-20.04
+            cxxstd: "11,14,17"
+            container: ubuntu:20.04
+            os: ubuntu-latest
             install: clang-8
           - toolset: clang
             compiler: clang++-9
-            cxxstd: "03,11,14,17,2a"
-            os: ubuntu-20.04
+            cxxstd: "11,14,17,2a"
+            container: ubuntu:20.04
+            os: ubuntu-latest
             install: clang-9
           - toolset: clang
             compiler: clang++-10
-            cxxstd: "03,11,14,17,2a"
-            os: ubuntu-20.04
+            cxxstd: "11,14,17,2a"
+            container: ubuntu:20.04
+            os: ubuntu-latest
+            install: clang-10
           - toolset: clang
             compiler: clang++-11
-            cxxstd: "03,11,14,17,2a"
-            os: ubuntu-20.04
+            cxxstd: "11,14,17,2a"
+            container: ubuntu:20.04
+            os: ubuntu-latest
+            install: clang-11
           - toolset: clang
             compiler: clang++-12
-            cxxstd: "03,11,14,17,20"
-            os: ubuntu-20.04
+            cxxstd: "11,14,17,20"
+            container: ubuntu:20.04
+            os: ubuntu-latest
+            install: clang-12
           - toolset: clang
             compiler: clang++-13
-            cxxstd: "03,11,14,17,20,2b"
-            os: ubuntu-22.04
+            cxxstd: "11,14,17,20,2b"
+            container: ubuntu:22.04
+            os: ubuntu-latest
             install: clang-13
           - toolset: clang
             compiler: clang++-14
-            cxxstd: "03,11,14,17,20,2b"
-            os: ubuntu-22.04
+            cxxstd: "11,14,17,20,2b"
+            container: ubuntu:22.04
+            os: ubuntu-latest
             install: clang-14
           - toolset: clang
             compiler: clang++-15
-            cxxstd: "03,11,14,17,20,2b"
-            os: ubuntu-22.04
+            cxxstd: "11,14,17,20,2b"
+            container: ubuntu:22.04
+            os: ubuntu-latest
             install: clang-15
           - toolset: clang
             compiler: clang++-16
-            cxxstd: "03,11,14,17,20,2b"
+            cxxstd: "11,14,17,20,2b"
+            container: ubuntu:24.04
             os: ubuntu-latest
-            container: ubuntu:23.04
             install: clang-16
           - toolset: clang
-            cxxstd: "03,11,14,17,2a"
-            os: macos-11
+            compiler: clang++-17
+            cxxstd: "11,14,17,20,2b"
+            container: ubuntu:24.04
+            os: ubuntu-latest
+            install: clang-17
           - toolset: clang
-            cxxstd: "03,11,14,17,20,2b"
-            os: macos-12
+            compiler: clang++-18
+            cxxstd: "11,14,17,20,2b"
+            container: ubuntu:24.04
+            os: ubuntu-latest
+            install: clang-18
           - toolset: clang
-            cxxstd: "03,11,14,17,20,2b"
+            compiler: clang++-19
+            cxxstd: "11,14,17,20,23,2c"
+            container: ubuntu:24.04
+            os: ubuntu-latest
+            install: clang-19
+          - toolset: clang
+            compiler: clang++-20
+            cxxstd: "11,14,17,20,23,2c"
+            container: ubuntu:25.04
+            os: ubuntu-latest
+            install: clang-20
+          - toolset: clang
+            cxxstd: "11,14,17,20,2b"
             os: macos-13
+          - toolset: clang
+            cxxstd: "11,14,17,20,2b"
+            os: macos-14
+          - toolset: clang
+            cxxstd: "11,14,17,20,2b"
+            os: macos-15
 
     runs-on: ${{matrix.os}}
-    container: ${{matrix.container}}
+
+    container:
+      image: ${{matrix.container}}
+      volumes:
+        - /node20217:/node20217:rw,rshared
+        - ${{ startsWith(matrix.container, 'ubuntu:1') && '/node20217:/__e/node20:ro,rshared' || ' ' }}
 
     defaults:
       run:
         shell: bash
 
     steps:
-      - uses: actions/checkout@v3
-
       - name: Setup container environment
         if: matrix.container
         run: |
           apt-get update
-          apt-get -y install sudo python3 git g++
+          apt-get -y install sudo python3 git g++ curl xz-utils
+
+      - name: Install nodejs20glibc2.17
+        if: ${{ startsWith( matrix.container, 'ubuntu:1' ) }}
+        run: |
+          curl -LO https://archives.boost.io/misc/node/node-v20.9.0-linux-x64-glibc-217.tar.xz
+          tar -xf node-v20.9.0-linux-x64-glibc-217.tar.xz --strip-components 1 -C /node20217
+          ldd /__e/node20/bin/node
+
+      - uses: actions/checkout@v4
 
       - name: Install packages
         if: matrix.install
@@ -212,31 +276,23 @@ jobs:
       fail-fast: false
       matrix:
         include:
-          - toolset: msvc-14.0
-            cxxstd: 14,latest
-            addrmd: 32,64
-            os: windows-2019
-          - toolset: msvc-14.2
-            cxxstd: "14,17,20,latest"
-            addrmd: 32,64
-            os: windows-2019
           - toolset: msvc-14.3
             cxxstd: "14,17,20,latest"
             addrmd: 32,64
             os: windows-2022
           - toolset: clang-win
-            cxxstd: "14,17,latest"
+            cxxstd: "14,17,20,latest"
             addrmd: 32,64
             os: windows-2022
           - toolset: gcc
-            cxxstd: "03,11,14,17,2a"
+            cxxstd: "11,14,17,2a"
             addrmd: 64
-            os: windows-2019
+            os: windows-2022
 
     runs-on: ${{matrix.os}}
 
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
 
       - name: Setup Boost
         shell: cmd
@@ -271,15 +327,16 @@ jobs:
       fail-fast: false
       matrix:
         include:
-          - os: ubuntu-20.04
           - os: ubuntu-22.04
-          - os: macos-11
-          - os: macos-12
+          - os: ubuntu-24.04
+          - os: macos-13
+          - os: macos-14
+          - os: macos-15
 
     runs-on: ${{matrix.os}}
 
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
 
       - name: Install packages
         if: matrix.install
@@ -318,15 +375,16 @@ jobs:
       fail-fast: false
       matrix:
         include:
-          - os: ubuntu-20.04
           - os: ubuntu-22.04
-          - os: macos-11
-          - os: macos-12
+          - os: ubuntu-24.04
+          - os: macos-13
+          - os: macos-14
+          - os: macos-15
 
     runs-on: ${{matrix.os}}
 
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
 
       - name: Install packages
         if: matrix.install
@@ -375,15 +433,16 @@ jobs:
       fail-fast: false
       matrix:
         include:
-          - os: ubuntu-20.04
           - os: ubuntu-22.04
-          - os: macos-11
-          - os: macos-12
+          - os: ubuntu-24.04
+          - os: macos-13
+          - os: macos-14
+          - os: macos-15
 
     runs-on: ${{matrix.os}}
 
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
 
       - name: Install packages
         if: matrix.install
@@ -430,13 +489,12 @@ jobs:
       fail-fast: false
       matrix:
         include:
-          - os: windows-2019
-          - os: windows-2022
+          - os: windows-latest
 
     runs-on: ${{matrix.os}}
 
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
 
       - name: Setup Boost
         shell: cmd
@@ -479,13 +537,12 @@ jobs:
       fail-fast: false
       matrix:
         include:
-          - os: windows-2019
-          - os: windows-2022
+          - os: windows-latest
 
     runs-on: ${{matrix.os}}
 
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
 
       - name: Setup Boost
         shell: cmd
@@ -546,13 +603,12 @@ jobs:
       fail-fast: false
       matrix:
         include:
-          - os: windows-2019
-          - os: windows-2022
+          - os: windows-latest
 
     runs-on: ${{matrix.os}}
 
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
 
       - name: Setup Boost
         shell: cmd

CMakeLists.txt

@@ -1,8 +1,9 @@
-# Copyright 2018-2020 Peter Dimov
+# Generated by `boostdep --cmake smart_ptr`
+# Copyright 2020, 2021 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
+# https://www.boost.org/LICENSE_1_0.txt
 
-cmake_minimum_required(VERSION 3.5...3.16)
+cmake_minimum_required(VERSION 3.8...3.20)
 
 project(boost_smart_ptr VERSION "${BOOST_SUPERPROJECT_VERSION}" LANGUAGES CXX)
 
@@ -16,13 +17,12 @@ target_link_libraries(boost_smart_ptr
     Boost::assert
     Boost::config
     Boost::core
-    Boost::move
-    Boost::static_assert
     Boost::throw_exception
-    Boost::type_traits
 )
 
-if(BUILD_TESTING)
+target_compile_features(boost_smart_ptr INTERFACE cxx_std_11)
+
+if(BUILD_TESTING AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/test/CMakeLists.txt")
 
   add_subdirectory(test)
 

appveyor.yml

@@ -15,15 +15,28 @@ branches:
 environment:
   matrix:
     - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
-      TOOLSET: msvc-9.0,msvc-10.0,msvc-11.0
-      ADDRMD: 32
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
-      TOOLSET: msvc-12.0,msvc-14.0
+      TOOLSET: 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 2019
+      TOOLSET: msvc-14.2
+      CXXSTD: 14
+      ADDRMD: 32,64
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
+      TOOLSET: msvc-14.2
+      CXXSTD: 17
+      ADDRMD: 32,64
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
+      TOOLSET: msvc-14.2
+      CXXSTD: 20
+      ADDRMD: 32,64
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
+      TOOLSET: msvc-14.2
+      CXXSTD: latest
+      ADDRMD: 32,64
     - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
       TOOLSET: clang-win
       CXXSTD: 14,17,latest
@@ -31,19 +44,19 @@ environment:
     - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
       ADDPATH: C:\cygwin\bin;
       TOOLSET: gcc
-      CXXSTD: 03,11,14,1z
+      CXXSTD: 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;
+      CXXSTD: 11,14,1z
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2022
+      ADDPATH: C:\mingw-w64\i686-8.1.0-posix-dwarf-rt_v6-rev0\mingw32\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;
+      CXXSTD: 11,14,17
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2022
+      ADDPATH: C:\mingw-w64\x86_64-8.1.0-posix-seh-rt_v6-rev0\mingw64\bin;
       TOOLSET: gcc
-      CXXSTD: 03,11,14,1z
+      CXXSTD: 11,14,17
 
 install:
   - set BOOST_BRANCH=develop

build.jam

@@ -0,0 +1,23 @@
+# Copyright 2023-2024 René Ferdinand Rivera Morell
+# Copyright 2024 Peter Dimov
+# Distributed under the Boost Software License, Version 1.0.
+# https://www.boost.org/LICENSE_1_0.txt
+
+require-b2 5.2 ;
+
+constant boost_dependencies :
+    /boost/assert//boost_assert
+    /boost/config//boost_config
+    /boost/core//boost_core
+    /boost/throw_exception//boost_throw_exception
+    ;
+
+project /boost/smart_ptr ;
+
+explicit
+    [ alias boost_smart_ptr : : : : <include>include <library>$(boost_dependencies) ]
+    [ alias all : boost_smart_ptr test ]
+    ;
+
+call-if : boost-library smart_ptr
+    ;

doc/smart_ptr/changelog.adoc

@@ -1,5 +1,5 @@
 ////
-Copyright 2019, 2020 Peter Dimov
+Copyright 2019-2025 Peter Dimov
 
 Distributed under the Boost Software License, Version 1.0.
 
@@ -13,6 +13,20 @@ http://www.boost.org/LICENSE_1_0.txt
 :toc-title:
 :idprefix: changelog_
 
+## Changes in 1.88.0
+
+* Fix `operator<<` for wide streams (accidentally broken in 1.87.0)
+
+## Changes in 1.87.0
+
+* {cpp}03 is no longer supported, a {cpp}11 compiler is required.
+  This includes GCC 4.8 or later, and MSVC 14.0 or later.
+* The functionality enabled by the macros `BOOST_SP_ENABLE_DEBUG_HOOKS`,
+  `BOOST_SP_USE_STD_ALLOCATOR`, `BOOST_SP_USE_QUICK_ALLOCATOR`,
+  `BOOST_AC_USE_SPINLOCK`, `BOOST_AC_USE_PTHREADS`, `BOOST_SP_USE_SPINLOCK`,
+  and `BOOST_SP_USE_PTHREADS` has been deprecated and support for it
+  will be removed in a future release.
+
 ## Changes in 1.79.0
 
 * Added `get_allocator_pointer`

doc/smart_ptr/shared_array.adoc

@@ -210,7 +210,8 @@ T* get() const noexcept;
 [none]
 * {blank}
 +
-Returns:: The stored pointer.
+Returns::
+  The stored pointer.
 
 ### unique
 
@@ -220,8 +221,8 @@ bool unique() const noexcept;
 [none]
 * {blank}
 +
-Returns:: `true` if no other `shared_array` is sharing ownership of the
-stored pointer, `false` otherwise.
+Returns::
+  `true` if no other `shared_array` is sharing ownership of the stored pointer, `false` otherwise.
 
 ### use_count
 
@@ -253,7 +254,8 @@ void swap(shared_array<T>& b) noexcept;
 [none]
 * {blank}
 +
-Effects:: Exchanges the contents of the two smart pointers.
+Effects::
+  Exchanges the contents of the two smart pointers.
 
 ## Free Functions
 

extras/src/sp_collector.cpp

@@ -1,270 +0,0 @@
-//
-//  sp_collector.cpp
-//
-//  Copyright (c) 2002, 2003 Peter Dimov
-//
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
-
-#include <boost/assert.hpp>
-#include <boost/shared_ptr.hpp>
-#include <boost/detail/lightweight_mutex.hpp>
-#include <cstdlib>
-#include <map>
-#include <deque>
-#include <iostream>
-
-typedef std::map< void const *, std::pair<void *, size_t> > map_type;
-
-static map_type & get_map()
-{
-    static map_type m;
-    return m;
-}
-
-typedef boost::detail::lightweight_mutex mutex_type;
-
-static mutex_type & get_mutex()
-{
-    static mutex_type m;
-    return m;
-}
-
-static void * init_mutex_before_main = &get_mutex();
-
-namespace
-{
-    class X;
-
-    struct count_layout
-    {
-        boost::detail::sp_counted_base * pi;
-        int id;
-    };
-
-    struct shared_ptr_layout
-    {
-        X * px;
-        count_layout pn;
-    };
-}
-
-// assume 4 byte alignment for pointers when scanning
-size_t const pointer_align = 4;
-
-typedef std::map<void const *, long> map2_type;
-
-static void scan_and_count(void const * area, size_t size, map_type const & m, map2_type & m2)
-{
-    unsigned char const * p = static_cast<unsigned char const *>(area);
-
-    for(size_t n = 0; n + sizeof(shared_ptr_layout) <= size; p += pointer_align, n += pointer_align)
-    {
-        shared_ptr_layout const * q = reinterpret_cast<shared_ptr_layout const *>(p);
-
-        if(q->pn.id == boost::detail::shared_count_id && q->pn.pi != 0 && m.count(q->pn.pi) != 0)
-        {
-            ++m2[q->pn.pi];
-        }
-    }
-}
-
-typedef std::deque<void const *> open_type;
-
-static void scan_and_mark(void const * area, size_t size, map2_type & m2, open_type & open)
-{
-    unsigned char const * p = static_cast<unsigned char const *>(area);
-
-    for(size_t n = 0; n + sizeof(shared_ptr_layout) <= size; p += pointer_align, n += pointer_align)
-    {
-        shared_ptr_layout const * q = reinterpret_cast<shared_ptr_layout const *>(p);
-
-        if(q->pn.id == boost::detail::shared_count_id && q->pn.pi != 0 && m2.count(q->pn.pi) != 0)
-        {
-            open.push_back(q->pn.pi);
-            m2.erase(q->pn.pi);
-        }
-    }
-}
-
-static void find_unreachable_objects_impl(map_type const & m, map2_type & m2)
-{
-    // scan objects for shared_ptr members, compute internal counts
-
-    {
-        std::cout << "... " << m.size() << " objects in m.\n";
-
-        for(map_type::const_iterator i = m.begin(); i != m.end(); ++i)
-        {
-            boost::detail::sp_counted_base const * p = static_cast<boost::detail::sp_counted_base const *>(i->first);
-
-            BOOST_ASSERT(p->use_count() != 0); // there should be no inactive counts in the map
-
-            m2[ i->first ];
-
-            scan_and_count(i->second.first, i->second.second, m, m2);
-        }
-
-        std::cout << "... " << m2.size() << " objects in m2.\n";
-    }
-
-    // mark reachable objects
-
-    {
-        open_type open;
-
-        for(map2_type::iterator i = m2.begin(); i != m2.end(); ++i)
-        {
-            boost::detail::sp_counted_base const * p = static_cast<boost::detail::sp_counted_base const *>(i->first);
-            if(p->use_count() != i->second) open.push_back(p);
-        }
-
-        std::cout << "... " << open.size() << " objects in open.\n";
-
-        for(open_type::iterator j = open.begin(); j != open.end(); ++j)
-        {
-            m2.erase(*j);
-        }
-
-        while(!open.empty())
-        {
-            void const * p = open.front();
-            open.pop_front();
-
-            map_type::const_iterator i = m.find(p);
-            BOOST_ASSERT(i != m.end());
-
-            scan_and_mark(i->second.first, i->second.second, m2, open);
-        }
-    }
-
-    // m2 now contains the unreachable objects
-}
-
-std::size_t find_unreachable_objects(bool report)
-{
-    map2_type m2;
-
-#ifdef BOOST_HAS_THREADS
-
-    // This will work without the #ifdef, but some compilers warn
-    // that lock is not referenced
-
-    mutex_type::scoped_lock lock(get_mutex());
-
-#endif
-
-    map_type const & m = get_map();
-
-    find_unreachable_objects_impl(m, m2);
-
-    if(report)
-    {
-        for(map2_type::iterator j = m2.begin(); j != m2.end(); ++j)
-        {
-            map_type::const_iterator i = m.find(j->first);
-            BOOST_ASSERT(i != m.end());
-            std::cout << "Unreachable object at " << i->second.first << ", " << i->second.second << " bytes long.\n";
-        }
-    }
-
-    return m2.size();
-}
-
-typedef std::deque< boost::shared_ptr<X> > free_list_type;
-
-static void scan_and_free(void * area, size_t size, map2_type const & m2, free_list_type & free)
-{
-    unsigned char * p = static_cast<unsigned char *>(area);
-
-    for(size_t n = 0; n + sizeof(shared_ptr_layout) <= size; p += pointer_align, n += pointer_align)
-    {
-        shared_ptr_layout * q = reinterpret_cast<shared_ptr_layout *>(p);
-
-        if(q->pn.id == boost::detail::shared_count_id && q->pn.pi != 0 && m2.count(q->pn.pi) != 0 && q->px != 0)
-        {
-            boost::shared_ptr<X> * ppx = reinterpret_cast< boost::shared_ptr<X> * >(p);
-            free.push_back(*ppx);
-            ppx->reset();
-        }
-    }
-}
-
-void free_unreachable_objects()
-{
-    free_list_type free;
-
-    {
-        map2_type m2;
-
-#ifdef BOOST_HAS_THREADS
-
-        mutex_type::scoped_lock lock(get_mutex());
-
-#endif
-
-        map_type const & m = get_map();
-
-        find_unreachable_objects_impl(m, m2);
-
-        for(map2_type::iterator j = m2.begin(); j != m2.end(); ++j)
-        {
-            map_type::const_iterator i = m.find(j->first);
-            BOOST_ASSERT(i != m.end());
-            scan_and_free(i->second.first, i->second.second, m2, free);
-        }
-    }
-
-    std::cout << "... about to free " << free.size() << " objects.\n";
-}
-
-// debug hooks
-
-namespace boost
-{
-
-void sp_scalar_constructor_hook(void *)
-{
-}
-
-void sp_scalar_constructor_hook(void * px, std::size_t size, void * pn)
-{
-#ifdef BOOST_HAS_THREADS
-
-    mutex_type::scoped_lock lock(get_mutex());
-
-#endif
-
-    get_map()[pn] = std::make_pair(px, size);
-}
-
-void sp_scalar_destructor_hook(void *)
-{
-}
-
-void sp_scalar_destructor_hook(void *, std::size_t, void * pn)
-{
-#ifdef BOOST_HAS_THREADS
-
-    mutex_type::scoped_lock lock(get_mutex());
-
-#endif
-
-    get_map().erase(pn);
-}
-
-void sp_array_constructor_hook(void *)
-{
-}
-
-void sp_array_destructor_hook(void *)
-{
-}
-
-} // namespace boost
-
-#endif // defined(BOOST_SP_ENABLE_DEBUG_HOOKS)

extras/src/sp_debug_hooks.cpp

@@ -1,243 +0,0 @@
-//
-//  sp_debug_hooks.cpp
-//
-//  Copyright (c) 2002, 2003 Peter Dimov
-//
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
-
-#include <boost/assert.hpp>
-#include <new>
-#include <cstdlib>
-
-int const m = 2; // m * sizeof(int) must be aligned appropriately
-
-// magic values to mark heap blocks with
-
-int const allocated_scalar  = 0x1234560C;
-int const allocated_array   = 0x1234560A;
-int const adopted_scalar    = 0x0567890C;
-int const adopted_array     = 0x0567890A;
-int const deleted           = 0x498769DE;
-
-using namespace std; // for compilers where things aren't in std
-
-// operator new
-
-static new_handler get_new_handler()
-{
-    new_handler p = set_new_handler(0);
-    set_new_handler(p);
-    return p;
-}
-
-static void * allocate(size_t n, int mark)
-{
-    int * pm;
-
-    for(;;)
-    {
-        pm = static_cast<int*>(malloc(n + m * sizeof(int)));
-
-        if(pm != 0) break;
-
-        if(new_handler pnh = get_new_handler())
-        {
-            pnh();
-        }
-        else
-        {
-            return 0;
-        }
-    }
-
-    *pm = mark;
-
-    return pm + m;
-}
-
-void * operator new(size_t n) throw(bad_alloc)
-{
-    void * p = allocate(n, allocated_scalar);
-
-#if !defined(BOOST_NO_EXCEPTIONS)
-
-    if(p == 0) throw bad_alloc();
-
-#endif
-
-    return p;
-}
-
-#if !defined(BOOST_BORLANDC) || (BOOST_BORLANDC > 0x551)
-
-void * operator new(size_t n, nothrow_t const &) throw()
-{
-    return allocate(n, allocated_scalar);
-}
-
-#endif
-
-void * operator new[](size_t n) throw(bad_alloc)
-{
-    void * p = allocate(n, allocated_array);
-
-#if !defined(BOOST_NO_EXCEPTIONS)
-
-    if(p == 0) throw bad_alloc();
-
-#endif
-
-    return p;
-}
-
-#if !defined(BOOST_BORLANDC) || (BOOST_BORLANDC > 0x551)
-
-void * operator new[](size_t n, nothrow_t const &) throw()
-{
-    return allocate(n, allocated_array);
-}
-
-#endif
-
-// debug hooks
-
-namespace boost
-{
-
-void sp_scalar_constructor_hook(void * p)
-{
-    if(p == 0) return;
-
-    int * pm = static_cast<int*>(p);
-    pm -= m;
-
-    BOOST_ASSERT(*pm != adopted_scalar);    // second smart pointer to the same address
-    BOOST_ASSERT(*pm != allocated_array);   // allocated with new[]
-    BOOST_ASSERT(*pm == allocated_scalar);  // not allocated with new
-
-    *pm = adopted_scalar;
-}
-
-void sp_scalar_constructor_hook(void * px, std::size_t, void *)
-{
-    sp_scalar_constructor_hook(px);
-}
-
-void sp_scalar_destructor_hook(void * p)
-{
-    if(p == 0) return;
-
-    int * pm = static_cast<int*>(p);
-    pm -= m;
-
-    BOOST_ASSERT(*pm == adopted_scalar);    // attempt to destroy nonmanaged block
-
-    *pm = allocated_scalar;
-}
-
-void sp_scalar_destructor_hook(void * px, std::size_t, void *)
-{
-    sp_scalar_destructor_hook(px);
-}
-
-// It is not possible to handle the array hooks in a portable manner.
-// The implementation typically reserves a bit of storage for the number
-// of objects in the array, and the argument of the array hook isn't
-// equal to the return value of operator new[].
-
-void sp_array_constructor_hook(void * /* p */)
-{
-/*
-    if(p == 0) return;
-
-    // adjust p depending on the implementation
-
-    int * pm = static_cast<int*>(p);
-    pm -= m;
-
-    BOOST_ASSERT(*pm != adopted_array);     // second smart array pointer to the same address
-    BOOST_ASSERT(*pm != allocated_scalar);  // allocated with new
-    BOOST_ASSERT(*pm == allocated_array);   // not allocated with new[]
-
-    *pm = adopted_array;
-*/
-}
-
-void sp_array_destructor_hook(void * /* p */)
-{
-/*
-    if(p == 0) return;
-
-    // adjust p depending on the implementation
-
-    int * pm = static_cast<int*>(p);
-    pm -= m;
-
-    BOOST_ASSERT(*pm == adopted_array); // attempt to destroy nonmanaged block
-
-    *pm = allocated_array;
-*/
-}
-
-} // namespace boost
-
-// operator delete
-
-void operator delete(void * p) throw()
-{
-    if(p == 0) return;
-
-    int * pm = static_cast<int*>(p);
-    pm -= m;
-
-    BOOST_ASSERT(*pm != deleted);           // double delete
-    BOOST_ASSERT(*pm != adopted_scalar);    // delete p.get();
-    BOOST_ASSERT(*pm != allocated_array);   // allocated with new[]
-    BOOST_ASSERT(*pm == allocated_scalar);  // not allocated with new
-
-    *pm = deleted;
-
-    free(pm);
-}
-
-#if !defined(BOOST_BORLANDC) || (BOOST_BORLANDC > 0x551)
-
-void operator delete(void * p, nothrow_t const &) throw()
-{
-    ::operator delete(p);
-}
-
-#endif
-
-void operator delete[](void * p) throw()
-{
-    if(p == 0) return;
-
-    int * pm = static_cast<int*>(p);
-    pm -= m;
-
-    BOOST_ASSERT(*pm != deleted);           // double delete
-    BOOST_ASSERT(*pm != adopted_scalar);    // delete p.get();
-    BOOST_ASSERT(*pm != allocated_scalar);  // allocated with new
-    BOOST_ASSERT(*pm == allocated_array);   // not allocated with new[]
-
-    *pm = deleted;
-
-    free(pm);
-}
-
-#if !defined(BOOST_BORLANDC) || (BOOST_BORLANDC > 0x551)
-
-void operator delete[](void * p, nothrow_t const &) throw()
-{
-    ::operator delete[](p);
-}
-
-#endif
-
-#endif // defined(BOOST_SP_ENABLE_DEBUG_HOOKS)

extras/test/shared_ptr_mt_test.cpp

@@ -1,12 +1,3 @@
-#include <boost/config.hpp>
-
-#if defined(BOOST_MSVC)
-#pragma warning(disable: 4786)  // identifier truncated in debug info
-#pragma warning(disable: 4710)  // function not inlined
-#pragma warning(disable: 4711)  // function selected for automatic inline expansion
-#pragma warning(disable: 4514)  // unreferenced inline removed
-#endif
-
 //  shared_ptr_mt_test.cpp - tests shared_ptr with multiple threads
 //
 //  Copyright (c) 2002 Peter Dimov and Multi Media Ltd.
@@ -18,14 +9,14 @@
 
 #include <boost/shared_ptr.hpp>
 #include <boost/bind.hpp>
+#include <boost/config.hpp>
+
+#include <boost/smart_ptr/detail/lightweight_thread.hpp>
 
 #include <vector>
-
 #include <cstdio>
 #include <ctime>
 
-#include <boost/detail/lightweight_thread.hpp>
-
 //
 
 int const n = 1024 * 1024;

extras/test/shared_ptr_timing_test.cpp

@@ -1,12 +1,3 @@
-#include <boost/config.hpp>
-
-#if defined(BOOST_MSVC)
-#pragma warning(disable: 4786)  // identifier truncated in debug info
-#pragma warning(disable: 4710)  // function not inlined
-#pragma warning(disable: 4711)  // function selected for automatic inline expansion
-#pragma warning(disable: 4514)  // unreferenced inline removed
-#endif
-
 //
 //  shared_ptr_timing_test.cpp - use to evaluate the impact of thread safety
 //

extras/test/sp_atomic_mt2_test.cpp

@@ -13,8 +13,8 @@
 #include <boost/thread/shared_mutex.hpp>
 #include <boost/thread/locks.hpp>
 
-#include <boost/detail/lightweight_mutex.hpp>
-#include <boost/detail/lightweight_thread.hpp>
+#include <boost/smart_ptr/detail/lightweight_mutex.hpp>
+#include <boost/smart_ptr/detail/lightweight_thread.hpp>
 
 #include <vector>
 #include <numeric>

extras/test/sp_atomic_mt_test.cpp

@@ -18,9 +18,9 @@
 #include <boost/thread/locks.hpp>
 #endif
 
-#include <boost/detail/lightweight_mutex.hpp>
-#include <boost/detail/lightweight_test.hpp>
-#include <boost/detail/lightweight_thread.hpp>
+#include <boost/smart_ptr/detail/lightweight_mutex.hpp>
+#include <boost/smart_ptr/detail/lightweight_thread.hpp>
+#include <boost/core/lightweight_test.hpp>
 
 #include <cstdio>
 #include <ctime>

extras/test/weak_ptr_mt_test.cpp

@@ -1,12 +1,3 @@
-#include <boost/config.hpp>
-
-#if defined(BOOST_MSVC)
-#pragma warning(disable: 4786)  // identifier truncated in debug info
-#pragma warning(disable: 4710)  // function not inlined
-#pragma warning(disable: 4711)  // function selected for automatic inline expansion
-#pragma warning(disable: 4514)  // unreferenced inline removed
-#endif
-
 //  weak_ptr_mt_test.cpp
 //
 //  Copyright (c) 2002 Peter Dimov and Multi Media Ltd.
@@ -19,15 +10,15 @@
 #include <boost/shared_ptr.hpp>
 #include <boost/weak_ptr.hpp>
 #include <boost/bind.hpp>
+#include <boost/config.hpp>
+
+#include <boost/smart_ptr/detail/lightweight_thread.hpp>
 
 #include <vector>
-
 #include <cstdio>
 #include <ctime>
 #include <cstdlib>
 
-#include <boost/detail/lightweight_thread.hpp>
-
 //
 
 int const n = 16384;

extras/test/weak_ptr_timing_test.cpp

@@ -1,12 +1,3 @@
-#include <boost/config.hpp>
-
-#if defined(BOOST_MSVC)
-#pragma warning(disable: 4786)  // identifier truncated in debug info
-#pragma warning(disable: 4710)  // function not inlined
-#pragma warning(disable: 4711)  // function selected for automatic inline expansion
-#pragma warning(disable: 4514)  // unreferenced inline removed
-#endif
-
 //
 //  weak_ptr_timing_test.cpp
 //
@@ -20,6 +11,7 @@
 
 #include <boost/shared_ptr.hpp>
 #include <boost/weak_ptr.hpp>
+#include <boost/config.hpp>
 
 #include <vector>
 #include <cstdio>

include/boost/detail/atomic_count.hpp

@@ -1,20 +1,13 @@
 #ifndef BOOST_DETAIL_ATOMIC_COUNT_HPP_INCLUDED
 #define BOOST_DETAIL_ATOMIC_COUNT_HPP_INCLUDED
 
-// MS compatible compilers support #pragma once
+// Copyright (c) 2001, 2002 Peter Dimov and Multi Media Ltd.
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
 
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
+#include <boost/config/header_deprecated.hpp>
 
-//
-//  boost/detail/atomic_count.hpp - thread/SMP safe reference counter
-//
-//  Copyright (c) 2001, 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
+BOOST_HEADER_DEPRECATED("<boost/smart_ptr/detail/atomic_count.hpp>")
 
 #include <boost/smart_ptr/detail/atomic_count.hpp>
 

include/boost/detail/lightweight_mutex.hpp

@@ -1,21 +1,13 @@
 #ifndef BOOST_DETAIL_LIGHTWEIGHT_MUTEX_HPP_INCLUDED
 #define BOOST_DETAIL_LIGHTWEIGHT_MUTEX_HPP_INCLUDED
 
-// MS compatible compilers support #pragma once
+// Copyright (c) 2002, 2003 Peter Dimov and Multi Media Ltd.
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
 
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
+#include <boost/config/header_deprecated.hpp>
 
-//
-//  boost/detail/lightweight_mutex.hpp - lightweight mutex
-//
-//  Copyright (c) 2002, 2003 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
-//
+BOOST_HEADER_DEPRECATED("<boost/smart_ptr/detail/lightweight_mutex.hpp>")
 
 #include <boost/smart_ptr/detail/lightweight_mutex.hpp>
 

include/boost/detail/lightweight_thread.hpp

@@ -1,25 +1,14 @@
 #ifndef BOOST_DETAIL_LIGHTWEIGHT_THREAD_HPP_INCLUDED
 #define BOOST_DETAIL_LIGHTWEIGHT_THREAD_HPP_INCLUDED
 
-// MS compatible compilers support #pragma once
+// Copyright (c) 2002 Peter Dimov and Multi Media Ltd.
+// Copyright (c) 2008, 2018 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
 
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
+#include <boost/config/header_deprecated.hpp>
 
-//  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 );
+BOOST_HEADER_DEPRECATED("<boost/smart_ptr/detail/lightweight_thread.hpp>")
 
 #include <boost/smart_ptr/detail/lightweight_thread.hpp>
 

include/boost/detail/quick_allocator.hpp

@@ -1,22 +1,14 @@
 #ifndef BOOST_DETAIL_QUICK_ALLOCATOR_HPP_INCLUDED
 #define BOOST_DETAIL_QUICK_ALLOCATOR_HPP_INCLUDED
 
-// MS compatible compilers support #pragma once
+// Copyright (c) 2003 David Abrahams
+// Copyright (c) 2003 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
 
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
+#include <boost/config/header_deprecated.hpp>
 
-//
-//  detail/quick_allocator.hpp
-//
-//  Copyright (c) 2003 David Abrahams
-//  Copyright (c) 2003 Peter Dimov
-//
-//  Distributed under the Boost Software License, Version 1.0.
-//  See accompanying file LICENSE_1_0.txt or copy at
-//  http://www.boost.org/LICENSE_1_0.txt
-//
+BOOST_HEADER_DEPRECATED("<boost/smart_ptr/detail/quick_allocator.hpp>")
 
 #include <boost/smart_ptr/detail/quick_allocator.hpp>
 

include/boost/pointer_cast.hpp

@@ -10,49 +10,39 @@
 #ifndef BOOST_POINTER_CAST_HPP
 #define BOOST_POINTER_CAST_HPP
 
-#include <boost/config.hpp>
-#include <boost/smart_ptr/detail/sp_noexcept.hpp>
+#include <memory>
+#include <type_traits>
 
 namespace boost { 
 
 //static_pointer_cast overload for raw pointers
 template<class T, class U>
-inline T* static_pointer_cast(U *ptr) BOOST_SP_NOEXCEPT
+inline T* static_pointer_cast(U *ptr) noexcept
 {  
    return static_cast<T*>(ptr);
 }
 
 //dynamic_pointer_cast overload for raw pointers
 template<class T, class U>
-inline T* dynamic_pointer_cast(U *ptr) BOOST_SP_NOEXCEPT
+inline T* dynamic_pointer_cast(U *ptr) noexcept
 {  
    return dynamic_cast<T*>(ptr);
 }
 
 //const_pointer_cast overload for raw pointers
 template<class T, class U>
-inline T* const_pointer_cast(U *ptr) BOOST_SP_NOEXCEPT
+inline T* const_pointer_cast(U *ptr) noexcept
 {  
    return const_cast<T*>(ptr);
 }
 
 //reinterpret_pointer_cast overload for raw pointers
 template<class T, class U>
-inline T* reinterpret_pointer_cast(U *ptr) BOOST_SP_NOEXCEPT
+inline T* reinterpret_pointer_cast(U *ptr) noexcept
 {  
    return reinterpret_cast<T*>(ptr);
 }
 
-} // namespace boost
-
-#if !defined( BOOST_NO_CXX11_SMART_PTR )
-
-#include <boost/type_traits/has_virtual_destructor.hpp>
-#include <boost/static_assert.hpp>
-#include <memory>
-
-namespace boost {
-
 //static_pointer_cast overload for std::shared_ptr
 using std::static_pointer_cast;
 
@@ -63,7 +53,7 @@ using std::dynamic_pointer_cast;
 using std::const_pointer_cast;
 
 //reinterpret_pointer_cast overload for std::shared_ptr
-template<class T, class U> std::shared_ptr<T> reinterpret_pointer_cast(const std::shared_ptr<U> & r ) BOOST_SP_NOEXCEPT
+template<class T, class U> std::shared_ptr<T> reinterpret_pointer_cast(const std::shared_ptr<U> & r ) noexcept
 {
     (void) reinterpret_cast< T* >( static_cast< U* >( 0 ) );
 
@@ -74,7 +64,7 @@ template<class T, class U> std::shared_ptr<T> reinterpret_pointer_cast(const std
 }
 
 //static_pointer_cast overload for std::unique_ptr
-template<class T, class U> std::unique_ptr<T> static_pointer_cast( std::unique_ptr<U> && r ) BOOST_SP_NOEXCEPT
+template<class T, class U> std::unique_ptr<T> static_pointer_cast( std::unique_ptr<U> && r ) noexcept
 {
     (void) static_cast< T* >( static_cast< U* >( 0 ) );
 
@@ -84,11 +74,11 @@ template<class T, class U> std::unique_ptr<T> static_pointer_cast( std::unique_p
 }
 
 //dynamic_pointer_cast overload for std::unique_ptr
-template<class T, class U> std::unique_ptr<T> dynamic_pointer_cast( std::unique_ptr<U> && r ) BOOST_SP_NOEXCEPT
+template<class T, class U> std::unique_ptr<T> dynamic_pointer_cast( std::unique_ptr<U> && r ) noexcept
 {
     (void) dynamic_cast< T* >( static_cast< U* >( 0 ) );
 
-    BOOST_STATIC_ASSERT_MSG( boost::has_virtual_destructor<T>::value, "The target of dynamic_pointer_cast must have a virtual destructor." );
+    static_assert( std::has_virtual_destructor<T>::value, "The target of dynamic_pointer_cast must have a virtual destructor." );
 
     T * p = dynamic_cast<T*>( r.get() );
     if( p ) r.release();
@@ -96,7 +86,7 @@ template<class T, class U> std::unique_ptr<T> dynamic_pointer_cast( std::unique_
 }
 
 //const_pointer_cast overload for std::unique_ptr
-template<class T, class U> std::unique_ptr<T> const_pointer_cast( std::unique_ptr<U> && r ) BOOST_SP_NOEXCEPT
+template<class T, class U> std::unique_ptr<T> const_pointer_cast( std::unique_ptr<U> && r ) noexcept
 {
     (void) const_cast< T* >( static_cast< U* >( 0 ) );
 
@@ -106,7 +96,7 @@ template<class T, class U> std::unique_ptr<T> const_pointer_cast( std::unique_pt
 }
 
 //reinterpret_pointer_cast overload for std::unique_ptr
-template<class T, class U> std::unique_ptr<T> reinterpret_pointer_cast( std::unique_ptr<U> && r ) BOOST_SP_NOEXCEPT
+template<class T, class U> std::unique_ptr<T> reinterpret_pointer_cast( std::unique_ptr<U> && r ) noexcept
 {
     (void) reinterpret_cast< T* >( static_cast< U* >( 0 ) );
 
@@ -117,6 +107,4 @@ template<class T, class U> std::unique_ptr<T> reinterpret_pointer_cast( std::uni
 
 } // namespace boost
 
-#endif // #if !defined( BOOST_NO_CXX11_SMART_PTR )
-
 #endif   //BOOST_POINTER_CAST_HPP

include/boost/smart_ptr/allocate_local_shared_array.hpp

@@ -8,9 +8,10 @@ Distributed under the Boost Software License, Version 1.0.
 #ifndef BOOST_SMART_PTR_ALLOCATE_LOCAL_SHARED_ARRAY_HPP
 #define BOOST_SMART_PTR_ALLOCATE_LOCAL_SHARED_ARRAY_HPP
 
-#include <boost/smart_ptr/detail/requires_cxx11.hpp>
 #include <boost/smart_ptr/allocate_shared_array.hpp>
 #include <boost/smart_ptr/local_shared_ptr.hpp>
+#include <boost/smart_ptr/detail/sp_type_traits.hpp>
+#include <type_traits>
 
 namespace boost {
 namespace detail {
@@ -18,16 +19,16 @@ namespace detail {
 class BOOST_SYMBOL_VISIBLE lsp_array_base
     : public local_counted_base {
 public:
-    void set(sp_counted_base* base) BOOST_SP_NOEXCEPT {
+    void set(sp_counted_base* base) noexcept {
         count_ = shared_count(base);
     }
 
-    void local_cb_destroy() BOOST_SP_NOEXCEPT BOOST_OVERRIDE {
+    void local_cb_destroy() noexcept override {
         shared_count().swap(count_);
     }
 
     shared_count local_cb_get_shared_count() const
-        BOOST_SP_NOEXCEPT BOOST_OVERRIDE {
+        noexcept override {
         return count_;
     }
 
@@ -40,10 +41,10 @@ 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
+    lsp_array_state(const U& other, std::size_t size) noexcept
         : sp_array_state<A>(other, size) { }
 
-    lsp_array_base& base() BOOST_SP_NOEXCEPT {
+    lsp_array_base& base() noexcept {
         return base_;
     }
 
@@ -56,10 +57,10 @@ 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
+    lsp_size_array_state(const U& other, std::size_t size) noexcept
         : sp_size_array_state<A, N>(other, size) { }
 
-    lsp_array_base& base() BOOST_SP_NOEXCEPT {
+    lsp_array_base& base() noexcept {
         return base_;
     }
 
@@ -70,7 +71,7 @@ private:
 } /* detail */
 
 template<class T, class A>
-inline typename enable_if_<is_unbounded_array<T>::value,
+inline typename std::enable_if<detail::sp_is_unbounded_array<T>::value,
     local_shared_ptr<T> >::type
 allocate_local_shared(const A& allocator, std::size_t count)
 {
@@ -90,12 +91,12 @@ allocate_local_shared(const A& allocator, std::size_t count)
 }
 
 template<class T, class A>
-inline typename enable_if_<is_bounded_array<T>::value,
+inline typename std::enable_if<detail::sp_is_bounded_array<T>::value,
     local_shared_ptr<T> >::type
 allocate_local_shared(const A& allocator)
 {
     enum {
-        count = extent<T>::value
+        count = std::extent<T>::value
     };
     typedef typename detail::sp_array_element<T>::type element;
     typedef typename allocator_rebind<A, element>::type other;
@@ -113,10 +114,10 @@ allocate_local_shared(const A& allocator)
 }
 
 template<class T, class A>
-inline typename enable_if_<is_unbounded_array<T>::value,
+inline typename std::enable_if<detail::sp_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)
+    const typename std::remove_extent<T>::type& value)
 {
     typedef typename detail::sp_array_element<T>::type element;
     typedef typename allocator_rebind<A, element>::type other;
@@ -134,13 +135,13 @@ allocate_local_shared(const A& allocator, std::size_t count,
 }
 
 template<class T, class A>
-inline typename enable_if_<is_bounded_array<T>::value,
+inline typename std::enable_if<detail::sp_is_bounded_array<T>::value,
     local_shared_ptr<T> >::type
 allocate_local_shared(const A& allocator,
-    const typename remove_extent<T>::type& value)
+    const typename std::remove_extent<T>::type& value)
 {
     enum {
-        count = extent<T>::value
+        count = std::extent<T>::value
     };
     typedef typename detail::sp_array_element<T>::type element;
     typedef typename allocator_rebind<A, element>::type other;
@@ -158,7 +159,7 @@ allocate_local_shared(const A& allocator,
 }
 
 template<class T, class A>
-inline typename enable_if_<is_unbounded_array<T>::value,
+inline typename std::enable_if<detail::sp_is_unbounded_array<T>::value,
     local_shared_ptr<T> >::type
 allocate_local_shared_noinit(const A& allocator, std::size_t count)
 {
@@ -167,7 +168,7 @@ allocate_local_shared_noinit(const A& allocator, std::size_t count)
 }
 
 template<class T, class A>
-inline typename enable_if_<is_bounded_array<T>::value,
+inline typename std::enable_if<detail::sp_is_bounded_array<T>::value,
     local_shared_ptr<T> >::type
 allocate_local_shared_noinit(const A& allocator)
 {

include/boost/smart_ptr/allocate_shared_array.hpp

@@ -8,27 +8,20 @@ Distributed under the Boost Software License, Version 1.0.
 #ifndef BOOST_SMART_PTR_ALLOCATE_SHARED_ARRAY_HPP
 #define BOOST_SMART_PTR_ALLOCATE_SHARED_ARRAY_HPP
 
-#include <boost/smart_ptr/detail/requires_cxx11.hpp>
 #include <boost/core/allocator_access.hpp>
 #include <boost/core/alloc_construct.hpp>
 #include <boost/core/first_scalar.hpp>
 #include <boost/smart_ptr/shared_ptr.hpp>
-#include <boost/type_traits/alignment_of.hpp>
-#include <boost/type_traits/enable_if.hpp>
-#include <boost/type_traits/extent.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_with_alignment.hpp>
+#include <boost/smart_ptr/detail/sp_type_traits.hpp>
+#include <type_traits>
 
 namespace boost {
 namespace detail {
 
 template<class T>
 struct sp_array_element {
-    typedef typename boost::remove_cv<typename
-        boost::remove_extent<T>::type>::type type;
+    typedef typename std::remove_cv<typename
+        std::remove_extent<T>::type>::type type;
 };
 
 template<class T>
@@ -60,8 +53,8 @@ struct sp_align_up {
 };
 
 template<class T>
-BOOST_CONSTEXPR inline std::size_t
-sp_objects(std::size_t size) BOOST_SP_NOEXCEPT
+constexpr inline std::size_t
+sp_objects(std::size_t size) noexcept
 {
     return (size + sizeof(T) - 1) / sizeof(T);
 }
@@ -72,15 +65,15 @@ public:
     typedef A type;
 
     template<class U>
-    sp_array_state(const U& _allocator, std::size_t _size) BOOST_SP_NOEXCEPT
+    sp_array_state(const U& _allocator, std::size_t _size) noexcept
         : allocator_(_allocator),
           size_(_size) { }
 
-    A& allocator() BOOST_SP_NOEXCEPT {
+    A& allocator() noexcept {
         return allocator_;
     }
 
-    std::size_t size() const BOOST_SP_NOEXCEPT {
+    std::size_t size() const noexcept {
         return size_;
     }
 
@@ -95,14 +88,14 @@ public:
     typedef A type;
 
     template<class U>
-    sp_size_array_state(const U& _allocator, std::size_t) BOOST_SP_NOEXCEPT
+    sp_size_array_state(const U& _allocator, std::size_t) noexcept
         : allocator_(_allocator) { }
 
-    A& allocator() BOOST_SP_NOEXCEPT {
+    A& allocator() noexcept {
         return allocator_;
     }
 
-    BOOST_CONSTEXPR std::size_t size() const BOOST_SP_NOEXCEPT {
+    constexpr std::size_t size() const noexcept {
         return N;
     }
 
@@ -113,8 +106,8 @@ private:
 template<class T, class U>
 struct sp_array_alignment {
     enum {
-        value = sp_max_size<boost::alignment_of<T>::value,
-            boost::alignment_of<U>::value>::value
+        value = sp_max_size<std::alignment_of<T>::value,
+            std::alignment_of<U>::value>::value
     };
 };
 
@@ -127,7 +120,7 @@ struct sp_array_offset {
 
 template<class U, class T>
 inline U*
-sp_array_start(T* base) BOOST_SP_NOEXCEPT
+sp_array_start(T* base) noexcept
 {
     enum {
         size = sp_array_offset<T, U>::value
@@ -143,12 +136,12 @@ class sp_array_creator {
         offset = sp_array_offset<T, element>::value
     };
 
-    typedef typename boost::type_with_alignment<sp_array_alignment<T,
+    typedef typename sp_type_with_alignment<sp_array_alignment<T,
         element>::value>::type type;
 
 public:
     template<class U>
-    sp_array_creator(const U& other, std::size_t size) BOOST_SP_NOEXCEPT
+    sp_array_creator(const U& other, std::size_t size) noexcept
         : other_(other),
           size_(sp_objects<type>(offset + sizeof(element) * size)) { }
 
@@ -192,33 +185,33 @@ public:
             boost::first_scalar(&list), count);
     }
 
-    T& state() BOOST_SP_NOEXCEPT {
+    T& state() noexcept {
         return state_;
     }
 
-    void dispose() BOOST_SP_NOEXCEPT BOOST_OVERRIDE {
+    void dispose() noexcept override {
         boost::alloc_destroy_n(state_.allocator(),
             boost::first_scalar(sp_array_start<type>(this)),
             state_.size() * sp_array_count<type>::value);
     }
 
-    void destroy() BOOST_SP_NOEXCEPT BOOST_OVERRIDE {
+    void destroy() noexcept override {
         sp_array_creator<allocator, sp_array_base> other(state_.allocator(),
             state_.size());
         this->~sp_array_base();
         other.destroy(this);
     }
 
-    void* get_deleter(const sp_typeinfo_&) BOOST_SP_NOEXCEPT BOOST_OVERRIDE {
+    void* get_deleter(const sp_typeinfo_&) noexcept override {
         return 0;
     }
 
     void* get_local_deleter(const sp_typeinfo_&)
-        BOOST_SP_NOEXCEPT BOOST_OVERRIDE {
+        noexcept override {
         return 0;
     }
 
-    void* get_untyped_deleter() BOOST_SP_NOEXCEPT BOOST_OVERRIDE {
+    void* get_untyped_deleter() noexcept override {
         return 0;
     }
 
@@ -240,11 +233,11 @@ public:
         }
     }
 
-    T* get() const BOOST_SP_NOEXCEPT {
+    T* get() const noexcept {
         return result_;
     }
 
-    void release() BOOST_SP_NOEXCEPT {
+    void release() noexcept {
         result_ = 0;
     }
 
@@ -259,7 +252,7 @@ private:
 } /* detail */
 
 template<class T, class A>
-inline typename enable_if_<is_unbounded_array<T>::value, shared_ptr<T> >::type
+inline typename std::enable_if<detail::sp_is_unbounded_array<T>::value, shared_ptr<T> >::type
 allocate_shared(const A& allocator, std::size_t count)
 {
     typedef typename detail::sp_array_element<T>::type element;
@@ -276,15 +269,15 @@ allocate_shared(const A& allocator, std::size_t count)
 }
 
 template<class T, class A>
-inline typename enable_if_<is_bounded_array<T>::value, shared_ptr<T> >::type
+inline typename std::enable_if<detail::sp_is_bounded_array<T>::value, shared_ptr<T> >::type
 allocate_shared(const A& allocator)
 {
     enum {
-        count = extent<T>::value
+        count = std::extent<T>::value
     };
     typedef typename detail::sp_array_element<T>::type element;
     typedef typename allocator_rebind<A, element>::type other;
-    typedef detail::sp_size_array_state<other, extent<T>::value> state;
+    typedef detail::sp_size_array_state<other, std::extent<T>::value> state;
     typedef detail::sp_array_base<state> base;
     detail::sp_array_result<other, base> result(allocator, count);
     base* node = result.get();
@@ -296,9 +289,9 @@ allocate_shared(const A& allocator)
 }
 
 template<class T, class A>
-inline typename enable_if_<is_unbounded_array<T>::value, shared_ptr<T> >::type
+inline typename std::enable_if<detail::sp_is_unbounded_array<T>::value, shared_ptr<T> >::type
 allocate_shared(const A& allocator, std::size_t count,
-    const typename remove_extent<T>::type& value)
+    const typename std::remove_extent<T>::type& value)
 {
     typedef typename detail::sp_array_element<T>::type element;
     typedef typename allocator_rebind<A, element>::type other;
@@ -314,16 +307,16 @@ allocate_shared(const A& allocator, std::size_t count,
 }
 
 template<class T, class A>
-inline typename enable_if_<is_bounded_array<T>::value, shared_ptr<T> >::type
+inline typename std::enable_if<detail::sp_is_bounded_array<T>::value, shared_ptr<T> >::type
 allocate_shared(const A& allocator,
-    const typename remove_extent<T>::type& value)
+    const typename std::remove_extent<T>::type& value)
 {
     enum {
-        count = extent<T>::value
+        count = std::extent<T>::value
     };
     typedef typename detail::sp_array_element<T>::type element;
     typedef typename allocator_rebind<A, element>::type other;
-    typedef detail::sp_size_array_state<other, extent<T>::value> state;
+    typedef detail::sp_size_array_state<other, std::extent<T>::value> state;
     typedef detail::sp_array_base<state> base;
     detail::sp_array_result<other, base> result(allocator, count);
     base* node = result.get();
@@ -335,14 +328,14 @@ allocate_shared(const A& allocator,
 }
 
 template<class T, class A>
-inline typename enable_if_<is_unbounded_array<T>::value, shared_ptr<T> >::type
+inline typename std::enable_if<detail::sp_is_unbounded_array<T>::value, shared_ptr<T> >::type
 allocate_shared_noinit(const A& allocator, std::size_t count)
 {
     return boost::allocate_shared<T>(boost::noinit_adapt(allocator), count);
 }
 
 template<class T, class A>
-inline typename enable_if_<is_bounded_array<T>::value, shared_ptr<T> >::type
+inline typename std::enable_if<detail::sp_is_bounded_array<T>::value, shared_ptr<T> >::type
 allocate_shared_noinit(const A& allocator)
 {
     return boost::allocate_shared<T>(boost::noinit_adapt(allocator));

include/boost/smart_ptr/allocate_unique.hpp

@@ -8,43 +8,35 @@ Distributed under the Boost Software License, Version 1.0.
 #ifndef BOOST_SMART_PTR_ALLOCATE_UNIQUE_HPP
 #define BOOST_SMART_PTR_ALLOCATE_UNIQUE_HPP
 
-#include <boost/smart_ptr/detail/requires_cxx11.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/smart_ptr/detail/sp_type_traits.hpp>
 #include <boost/config.hpp>
 #include <memory>
 #include <utility>
+#include <cstddef>
+#include <type_traits>
 
 namespace boost {
 namespace detail {
 
 template<class T>
 struct sp_alloc_size {
-    BOOST_STATIC_CONSTEXPR std::size_t value = 1;
+    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;
+    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;
+    static constexpr std::size_t value = N * sp_alloc_size<T>::value;
 };
 
 template<class T>
@@ -59,8 +51,8 @@ struct sp_alloc_result<T[N]> {
 
 template<class T>
 struct sp_alloc_value {
-    typedef typename boost::remove_cv<typename
-        boost::remove_extent<T>::type>::type type;
+    typedef typename std::remove_cv<typename
+        std::remove_extent<T>::type>::type type;
 };
 
 template<class T, class P>
@@ -68,45 +60,41 @@ class sp_alloc_ptr {
 public:
     typedef T element_type;
 
-    sp_alloc_ptr() BOOST_SP_NOEXCEPT
+    sp_alloc_ptr() 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)) { }
+    sp_alloc_ptr(T* p) noexcept
+        : p_(const_cast<typename std::remove_cv<T>::type*>(p)) { }
 #endif
 
-    sp_alloc_ptr(std::size_t, P p) BOOST_SP_NOEXCEPT
+    sp_alloc_ptr(std::size_t, P p) noexcept
         : p_(p) { }
 
-#if !defined(BOOST_NO_CXX11_NULLPTR)
-    sp_alloc_ptr(detail::sp_nullptr_t) BOOST_SP_NOEXCEPT
+    sp_alloc_ptr(std::nullptr_t) noexcept
         : p_() { }
-#endif
 
     T& operator*() const {
         return *p_;
     }
 
-    T* operator->() const BOOST_SP_NOEXCEPT {
+    T* operator->() const noexcept {
         return boost::to_address(p_);
     }
 
-#if !defined(BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS)
-    explicit operator bool() const BOOST_SP_NOEXCEPT {
+    explicit operator bool() const noexcept {
         return !!p_;
     }
-#endif
 
-    bool operator!() const BOOST_SP_NOEXCEPT {
+    bool operator!() const noexcept {
         return !p_;
     }
 
-    P ptr() const BOOST_SP_NOEXCEPT {
+    P ptr() const noexcept {
         return p_;
     }
 
-    BOOST_STATIC_CONSTEXPR std::size_t size() BOOST_SP_NOEXCEPT {
+    static constexpr std::size_t size() noexcept {
         return 1;
     }
 
@@ -114,7 +102,7 @@ public:
     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)));
+                std::remove_cv<T>::type&>(v)));
     }
 #endif
 
@@ -127,37 +115,33 @@ class sp_alloc_ptr<T[], P> {
 public:
     typedef T element_type;
 
-    sp_alloc_ptr() BOOST_SP_NOEXCEPT
+    sp_alloc_ptr() noexcept
         : p_() { }
 
-    sp_alloc_ptr(std::size_t n, P p) BOOST_SP_NOEXCEPT
+    sp_alloc_ptr(std::size_t n, P p) noexcept
         : p_(p)
         , n_(n) { }
 
-#if !defined(BOOST_NO_CXX11_NULLPTR)
-    sp_alloc_ptr(detail::sp_nullptr_t) BOOST_SP_NOEXCEPT
+    sp_alloc_ptr(std::nullptr_t) 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 {
+    explicit operator bool() const noexcept {
         return !!p_;
     }
-#endif
 
-    bool operator!() const BOOST_SP_NOEXCEPT {
+    bool operator!() const noexcept {
         return !p_;
     }
 
-    P ptr() const BOOST_SP_NOEXCEPT {
+    P ptr() const noexcept {
         return p_;
     }
 
-    std::size_t size() const BOOST_SP_NOEXCEPT {
+    std::size_t size() const noexcept {
         return n_;
     }
 
@@ -165,7 +149,7 @@ public:
     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)));
+                std::remove_cv<T>::type&>(v)));
     }
 #endif
 
@@ -179,36 +163,32 @@ class sp_alloc_ptr<T[N], P> {
 public:
     typedef T element_type;
 
-    sp_alloc_ptr() BOOST_SP_NOEXCEPT
+    sp_alloc_ptr() noexcept
         : p_() { }
 
-    sp_alloc_ptr(std::size_t, P p) BOOST_SP_NOEXCEPT
+    sp_alloc_ptr(std::size_t, P p) noexcept
         : p_(p) { }
 
-#if !defined(BOOST_NO_CXX11_NULLPTR)
-    sp_alloc_ptr(detail::sp_nullptr_t) BOOST_SP_NOEXCEPT
+    sp_alloc_ptr(std::nullptr_t) 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 {
+    explicit operator bool() const noexcept {
         return !!p_;
     }
-#endif
 
-    bool operator!() const BOOST_SP_NOEXCEPT {
+    bool operator!() const noexcept {
         return !p_;
     }
 
-    P ptr() const BOOST_SP_NOEXCEPT {
+    P ptr() const noexcept {
         return p_;
     }
 
-    BOOST_STATIC_CONSTEXPR std::size_t size() BOOST_SP_NOEXCEPT {
+    static constexpr std::size_t size() noexcept {
         return N;
     }
 
@@ -216,7 +196,7 @@ public:
     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)));
+                std::remove_cv<T>::type&>(v)));
     }
 #endif
 
@@ -238,19 +218,18 @@ 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
+    std::nullptr_t) 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
+operator==(std::nullptr_t,
+    const sp_alloc_ptr<T, P>& rhs) noexcept
 {
     return !rhs.ptr();
 }
@@ -258,24 +237,23 @@ operator==(detail::sp_nullptr_t,
 template<class T, class P>
 inline bool
 operator!=(const sp_alloc_ptr<T, P>& lhs,
-    detail::sp_nullptr_t) BOOST_SP_NOEXCEPT
+    std::nullptr_t) 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
+operator!=(std::nullptr_t,
+    const sp_alloc_ptr<T, P>& rhs) 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)
+    std::false_type)
 {
     boost::alloc_destroy(a, boost::to_address(p));
 }
@@ -283,7 +261,7 @@ sp_alloc_clear(A& a, typename boost::allocator_pointer<A>::type p, std::size_t,
 template<class A>
 inline void
 sp_alloc_clear(A& a, typename boost::allocator_pointer<A>::type p,
-    std::size_t n, boost::true_type)
+    std::size_t n, std::true_type)
 {
 #if defined(BOOST_MSVC) && BOOST_MSVC < 1800
     if (!p) {
@@ -308,19 +286,17 @@ public:
     typedef detail::sp_alloc_ptr<T,
         typename allocator_pointer<allocator>::type> pointer;
 
-    explicit alloc_deleter(const allocator& a) BOOST_SP_NOEXCEPT
+    explicit alloc_deleter(const allocator& a) noexcept
         : base(empty_init_t(), a) { }
 
     void operator()(pointer p) {
-        detail::sp_alloc_clear(base::get(), p.ptr(), p.size(), is_array<T>());
+        detail::sp_alloc_clear(base::get(), p.ptr(), p.size(), std::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 {
 
@@ -347,15 +323,15 @@ public:
         }
     }
 
-    typename allocator::value_type* get() const BOOST_SP_NOEXCEPT {
+    typename allocator::value_type* get() const noexcept {
         return boost::to_address(p_);
     }
 
-    allocator& state() BOOST_SP_NOEXCEPT {
+    allocator& state() noexcept {
         return a_;
     }
 
-    type release() BOOST_SP_NOEXCEPT {
+    type release() noexcept {
         pointer p = p_;
         p_ = pointer();
         return type(typename deleter::pointer(n_, p), deleter(a_));
@@ -372,7 +348,7 @@ private:
 } /* detail */
 
 template<class T, class A>
-inline typename enable_if_<!is_array<T>::value,
+inline typename std::enable_if<!std::is_array<T>::value,
     std::unique_ptr<T, alloc_deleter<T, A> > >::type
 allocate_unique(const A& alloc)
 {
@@ -381,9 +357,8 @@ allocate_unique(const A& alloc)
     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,
+inline typename std::enable_if<!std::is_array<T>::value,
     std::unique_ptr<T, alloc_deleter<T, A> > >::type
 allocate_unique(const A& alloc, Args&&... args)
 {
@@ -391,12 +366,11 @@ allocate_unique(const A& alloc, Args&&... args)
     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,
+inline typename std::enable_if<!std::is_array<T>::value,
     std::unique_ptr<T, alloc_deleter<T, A> > >::type
-allocate_unique(const A& alloc, typename type_identity<T>::type&& value)
+allocate_unique(const A& alloc, typename detail::sp_type_identity<T>::type&& value)
 {
     detail::sp_alloc_make<T, A> c(alloc, 1);
     boost::alloc_construct(c.state(), c.get(), std::move(value));
@@ -404,7 +378,7 @@ allocate_unique(const A& alloc, typename type_identity<T>::type&& value)
 }
 
 template<class T, class A>
-inline typename enable_if_<!is_array<T>::value,
+inline typename std::enable_if<!std::is_array<T>::value,
     std::unique_ptr<T, alloc_deleter<T, noinit_adaptor<A> > > >::type
 allocate_unique_noinit(const A& alloc)
 {
@@ -412,7 +386,7 @@ allocate_unique_noinit(const A& alloc)
 }
 
 template<class T, class A>
-inline typename enable_if_<is_unbounded_array<T>::value,
+inline typename std::enable_if<detail::sp_is_unbounded_array<T>::value,
     std::unique_ptr<T, alloc_deleter<T, A> > >::type
 allocate_unique(const A& alloc, std::size_t size)
 {
@@ -423,19 +397,19 @@ allocate_unique(const A& alloc, std::size_t size)
 }
 
 template<class T, class A>
-inline typename enable_if_<is_bounded_array<T>::value,
+inline typename std::enable_if<detail::sp_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);
+    detail::sp_alloc_make<T, A> c(alloc, std::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,
+inline typename std::enable_if<detail::sp_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)
 {
@@ -443,7 +417,7 @@ allocate_unique_noinit(const A& alloc, std::size_t size)
 }
 
 template<class T, class A>
-inline typename enable_if_<is_bounded_array<T>::value,
+inline typename std::enable_if<detail::sp_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)
@@ -452,29 +426,29 @@ allocate_unique_noinit(const A& alloc)
 }
 
 template<class T, class A>
-inline typename enable_if_<is_unbounded_array<T>::value,
+inline typename std::enable_if<detail::sp_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)
+    const typename std::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);
+        detail::sp_alloc_size<typename std::remove_extent<T>::type>::value);
     return c.release();
 }
 
 template<class T, class A>
-inline typename enable_if_<is_bounded_array<T>::value,
+inline typename std::enable_if<detail::sp_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)
+    const typename std::remove_extent<T>::type& value)
 {
-    detail::sp_alloc_make<T, A> c(alloc, extent<T>::value);
+    detail::sp_alloc_make<T, A> c(alloc, std::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);
+        detail::sp_alloc_size<typename std::remove_extent<T>::type>::value);
     return c.release();
 }
 
@@ -482,7 +456,7 @@ template<class T, class U, class A>
 inline typename allocator_pointer<typename allocator_rebind<A,
     typename detail::sp_alloc_value<T>::type>::type>::type
 get_allocator_pointer(const std::unique_ptr<T,
-    alloc_deleter<U, A> >& p) BOOST_NOEXCEPT
+    alloc_deleter<U, A> >& p) noexcept
 {
     return p.get().ptr();
 }

include/boost/smart_ptr/atomic_shared_ptr.hpp

@@ -13,7 +13,6 @@
 //  See http://www.boost.org/libs/smart_ptr/ for documentation.
 //
 
-#include <boost/smart_ptr/detail/requires_cxx11.hpp>
 #include <boost/smart_ptr/shared_ptr.hpp>
 #include <boost/smart_ptr/detail/spinlock.hpp>
 #include <cstring>
@@ -34,7 +33,7 @@ private:
 
 private:
 
-    bool compare_exchange( shared_ptr<T>& v, shared_ptr<T> w ) BOOST_SP_NOEXCEPT
+    bool compare_exchange( shared_ptr<T>& v, shared_ptr<T> w ) noexcept
     {
         l_.lock();
 
@@ -58,39 +57,16 @@ private:
 
 public:
 
-#if !defined( BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX ) && !defined( BOOST_NO_CXX11_CONSTEXPR )
-
-    constexpr atomic_shared_ptr() BOOST_SP_NOEXCEPT: l_ BOOST_DETAIL_SPINLOCK_INIT
+    constexpr atomic_shared_ptr() noexcept: l_ BOOST_DETAIL_SPINLOCK_INIT
     {
     }
 
-    atomic_shared_ptr( shared_ptr<T> p ) BOOST_SP_NOEXCEPT
+    atomic_shared_ptr( shared_ptr<T> p ) noexcept
         : p_( std::move( p ) ), l_ BOOST_DETAIL_SPINLOCK_INIT
     {
     }
 
-#else
-
-    atomic_shared_ptr() BOOST_SP_NOEXCEPT
-    {
-        boost::detail::spinlock init = BOOST_DETAIL_SPINLOCK_INIT;
-        std::memcpy( &l_, &init, sizeof( init ) );
-    }
-
-    atomic_shared_ptr( shared_ptr<T> p ) BOOST_SP_NOEXCEPT
-#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
-        : p_( std::move( p ) )
-#else
-        : p_( p )
-#endif
-    {
-        boost::detail::spinlock init = BOOST_DETAIL_SPINLOCK_INIT;
-        std::memcpy( &l_, &init, sizeof( init ) );
-    }
-
-#endif
-
-    atomic_shared_ptr& operator=( shared_ptr<T> r ) BOOST_SP_NOEXCEPT
+    atomic_shared_ptr& operator=( shared_ptr<T> r ) noexcept
     {
         boost::detail::spinlock::scoped_lock lock( l_ );
         p_.swap( r );
@@ -98,140 +74,120 @@ public:
         return *this;
     }
 
-    BOOST_CONSTEXPR bool is_lock_free() const BOOST_SP_NOEXCEPT
+    constexpr bool is_lock_free() const noexcept
     {
         return false;
     }
 
-    shared_ptr<T> load() const BOOST_SP_NOEXCEPT
+    shared_ptr<T> load() const noexcept
     {
         boost::detail::spinlock::scoped_lock lock( l_ );
         return p_;
     }
 
-    template<class M> shared_ptr<T> load( M ) const BOOST_SP_NOEXCEPT
+    template<class M> shared_ptr<T> load( M ) const noexcept
     {
         boost::detail::spinlock::scoped_lock lock( l_ );
         return p_;
     }
 
-    operator shared_ptr<T>() const BOOST_SP_NOEXCEPT
+    operator shared_ptr<T>() const noexcept
     {
         boost::detail::spinlock::scoped_lock lock( l_ );
         return p_;
     }
 
-    void store( shared_ptr<T> r ) BOOST_SP_NOEXCEPT
+    void store( shared_ptr<T> r ) noexcept
     {
         boost::detail::spinlock::scoped_lock lock( l_ );
         p_.swap( r );
     }
 
-    template<class M> void store( shared_ptr<T> r, M ) BOOST_SP_NOEXCEPT
+    template<class M> void store( shared_ptr<T> r, M ) noexcept
     {
         boost::detail::spinlock::scoped_lock lock( l_ );
         p_.swap( r );
     }
 
-    shared_ptr<T> exchange( shared_ptr<T> r ) BOOST_SP_NOEXCEPT
+    shared_ptr<T> exchange( shared_ptr<T> r ) 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> shared_ptr<T> exchange( shared_ptr<T> r, M ) BOOST_SP_NOEXCEPT
+    template<class M> shared_ptr<T> exchange( shared_ptr<T> r, M ) 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
+    template<class M> bool compare_exchange_weak( shared_ptr<T>& v, const shared_ptr<T>& w, M, M ) noexcept
     {
         return compare_exchange( v, w );
     }
 
-    template<class M> bool compare_exchange_weak( shared_ptr<T>& v, const shared_ptr<T>& w, M ) BOOST_SP_NOEXCEPT
+    template<class M> bool compare_exchange_weak( shared_ptr<T>& v, const shared_ptr<T>& w, M ) noexcept
     {
         return compare_exchange( v, w );
     }
 
-    bool compare_exchange_weak( shared_ptr<T>& v, const shared_ptr<T>& w ) BOOST_SP_NOEXCEPT
+    bool compare_exchange_weak( shared_ptr<T>& v, const shared_ptr<T>& w ) noexcept
     {
         return compare_exchange( v, w );
     }
 
-    template<class M> bool compare_exchange_strong( shared_ptr<T>& v, const shared_ptr<T>& w, M, M ) BOOST_SP_NOEXCEPT
+    template<class M> bool compare_exchange_strong( shared_ptr<T>& v, const shared_ptr<T>& w, M, M ) 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
+    template<class M> bool compare_exchange_strong( shared_ptr<T>& v, const shared_ptr<T>& w, M ) noexcept
     {
         return compare_exchange( v, w );
     }
 
-    bool compare_exchange_strong( shared_ptr<T>& v, const shared_ptr<T>& w ) BOOST_SP_NOEXCEPT
+    bool compare_exchange_strong( shared_ptr<T>& v, const shared_ptr<T>& w ) noexcept
     {
         return compare_exchange( v, w );
     }
 
-#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
-
-    template<class M> bool compare_exchange_weak( shared_ptr<T>& v, shared_ptr<T>&& w, M, M ) BOOST_SP_NOEXCEPT
+    template<class M> bool compare_exchange_weak( shared_ptr<T>& v, shared_ptr<T>&& w, M, M ) noexcept
     {
         return compare_exchange( v, std::move( w ) );
     }
 
-    template<class M> bool compare_exchange_weak( shared_ptr<T>& v, shared_ptr<T>&& w, M ) BOOST_SP_NOEXCEPT
+    template<class M> bool compare_exchange_weak( shared_ptr<T>& v, shared_ptr<T>&& w, M ) noexcept
     {
         return compare_exchange( v, std::move( w ) );
     }
 
-    bool compare_exchange_weak( shared_ptr<T>& v, shared_ptr<T>&& w ) BOOST_SP_NOEXCEPT
+    bool compare_exchange_weak( shared_ptr<T>& v, shared_ptr<T>&& w ) noexcept
     {
         return compare_exchange( v, std::move( w ) );
     }
 
-    template<class M> bool compare_exchange_strong( shared_ptr<T>& v, shared_ptr<T>&& w, M, M ) BOOST_SP_NOEXCEPT
+    template<class M> bool compare_exchange_strong( shared_ptr<T>& v, shared_ptr<T>&& w, M, M ) 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
+    template<class M> bool compare_exchange_strong( shared_ptr<T>& v, shared_ptr<T>&& w, M ) noexcept
     {
         return compare_exchange( v, std::move( w ) );
     }
 
-    bool compare_exchange_strong( shared_ptr<T>& v, shared_ptr<T>&& w ) BOOST_SP_NOEXCEPT
+    bool compare_exchange_strong( shared_ptr<T>& v, shared_ptr<T>&& w ) noexcept
     {
         return compare_exchange( v, std::move( w ) );
     }
-
-#endif
 };
 
 } // namespace boost

include/boost/smart_ptr/bad_weak_ptr.hpp

@@ -20,23 +20,9 @@
 #include <boost/config.hpp>
 #include <exception>
 
-#ifdef BOOST_BORLANDC
-# pragma warn -8026     // Functions with excep. spec. are not expanded inline
-#endif
-
 namespace boost
 {
 
-// The standard library that comes with Borland C++ 5.5.1, 5.6.4
-// defines std::exception and its members as having C calling
-// convention (-pc). When the definition of bad_weak_ptr
-// is compiled with -ps, the compiler issues an error.
-// Hence, the temporary #pragma option -pc below.
-
-#if defined(BOOST_BORLANDC) && BOOST_BORLANDC <= 0x564
-# pragma option push -pc
-#endif
-
 #if defined(BOOST_CLANG)
 // Intel C++ on Mac defines __clang__ but doesn't support the pragma
 # pragma clang diagnostic push
@@ -47,7 +33,7 @@ class bad_weak_ptr: public std::exception
 {
 public:
 
-    char const * what() const BOOST_NOEXCEPT_OR_NOTHROW BOOST_OVERRIDE
+    char const * what() const noexcept override
     {
         return "tr1::bad_weak_ptr";
     }
@@ -57,14 +43,6 @@ public:
 # pragma clang diagnostic pop
 #endif
 
-#if defined(BOOST_BORLANDC) && BOOST_BORLANDC <= 0x564
-# pragma option pop
-#endif
-
 } // namespace boost
 
-#ifdef BOOST_BORLANDC
-# pragma warn .8026     // Functions with excep. spec. are not expanded inline
-#endif
-
 #endif  // #ifndef BOOST_SMART_PTR_BAD_WEAK_PTR_HPP_INCLUDED

include/boost/smart_ptr/detail/atomic_count.hpp

@@ -45,6 +45,7 @@
 
 #include <boost/smart_ptr/detail/sp_has_gcc_intrinsics.hpp>
 #include <boost/smart_ptr/detail/sp_has_sync_intrinsics.hpp>
+#include <boost/smart_ptr/detail/deprecated_macros.hpp>
 #include <boost/config.hpp>
 
 #if defined( BOOST_AC_DISABLE_THREADS )

include/boost/smart_ptr/detail/deprecated_macros.hpp

@@ -0,0 +1,52 @@
+#ifndef BOOST_SMART_PTR_DETAIL_DEPRECATED_MACROS_HPP_INCLUDED
+#define BOOST_SMART_PTR_DETAIL_DEPRECATED_MACROS_HPP_INCLUDED
+
+// Copyright 2024 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/config/pragma_message.hpp>
+
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+
+BOOST_PRAGMA_MESSAGE("The macro BOOST_SP_ENABLE_DEBUG_HOOKS has been deprecated in 1.87 and support for it was removed in 1.90.")
+
+#endif
+
+#if defined(BOOST_SP_USE_STD_ALLOCATOR)
+
+BOOST_PRAGMA_MESSAGE("The macro BOOST_SP_USE_STD_ALLOCATOR has been deprecated in 1.87 and support for it was removed in 1.90.")
+
+#endif
+
+#if defined(BOOST_SP_USE_QUICK_ALLOCATOR)
+
+BOOST_PRAGMA_MESSAGE("The macro BOOST_SP_USE_QUICK_ALLOCATOR has been deprecated in 1.87 and support for it was removed in 1.90.")
+
+#endif
+
+#if defined(BOOST_AC_USE_SPINLOCK)
+
+BOOST_PRAGMA_MESSAGE("The macro BOOST_AC_USE_SPINLOCK has been deprecated in 1.87 and support for it will be removed.")
+
+#endif
+
+#if defined(BOOST_AC_USE_PTHREADS)
+
+BOOST_PRAGMA_MESSAGE("The macro BOOST_AC_USE_PTHREADS has been deprecated in 1.87 and support for it will be removed.")
+
+#endif
+
+#if defined(BOOST_SP_USE_SPINLOCK)
+
+BOOST_PRAGMA_MESSAGE("The macro BOOST_SP_USE_SPINLOCK has been deprecated in 1.87 and support for it will be removed.")
+
+#endif
+
+#if defined(BOOST_SP_USE_PTHREADS)
+
+BOOST_PRAGMA_MESSAGE("The macro BOOST_SP_USE_PTHREADS has been deprecated in 1.87 and support for it will be removed.")
+
+#endif
+
+#endif // #ifndef BOOST_SMART_PTR_DETAIL_DEPRECATED_MACROS_HPP_INCLUDED

include/boost/smart_ptr/detail/lightweight_thread.hpp

@@ -104,18 +104,10 @@ public:
 
 #if defined( BOOST_HAS_PTHREADS )
 
-extern "C" void * lw_thread_routine( void * pv )
+extern "C" inline 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;
@@ -123,18 +115,10 @@ extern "C" void * lw_thread_routine( void * pv )
 
 #else
 
-unsigned __stdcall lw_thread_routine( void * pv )
+inline 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;
@@ -162,16 +146,8 @@ private:
 
 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 )

include/boost/smart_ptr/detail/local_counted_base.hpp

@@ -42,23 +42,23 @@ private:
 
 public:
 
-    BOOST_CONSTEXPR local_counted_base() BOOST_SP_NOEXCEPT: local_use_count_( initial_ )
+    constexpr local_counted_base() noexcept: local_use_count_( initial_ )
     {
     }
 
-    BOOST_CONSTEXPR local_counted_base( local_counted_base const & ) BOOST_SP_NOEXCEPT: local_use_count_( initial_ )
+    constexpr local_counted_base( local_counted_base const & ) noexcept: local_use_count_( initial_ )
     {
     }
 
-    virtual ~local_counted_base() /*BOOST_SP_NOEXCEPT*/
+    virtual ~local_counted_base() /*noexcept*/
     {
     }
 
-    virtual void local_cb_destroy() BOOST_SP_NOEXCEPT = 0;
+    virtual void local_cb_destroy() noexcept = 0;
 
-    virtual boost::detail::shared_count local_cb_get_shared_count() const BOOST_SP_NOEXCEPT = 0;
+    virtual boost::detail::shared_count local_cb_get_shared_count() const noexcept = 0;
 
-    void add_ref() BOOST_SP_NOEXCEPT
+    void add_ref() noexcept
     {
 #if !defined(__NVCC__)
 #if defined( __has_builtin )
@@ -73,7 +73,7 @@ public:
         local_use_count_ = static_cast<count_type>( local_use_count_ + 1 );
     }
 
-    void release() BOOST_SP_NOEXCEPT
+    void release() noexcept
     {
         local_use_count_ = static_cast<count_type>( local_use_count_ - 1 );
 
@@ -83,7 +83,7 @@ public:
         }
     }
 
-    long local_use_count() const BOOST_SP_NOEXCEPT
+    long local_use_count() const noexcept
     {
         return local_use_count_;
     }
@@ -101,24 +101,20 @@ private:
 
 public:
 
-    explicit local_counted_impl( shared_count const& pn ) BOOST_SP_NOEXCEPT: pn_( pn )
+    explicit local_counted_impl( shared_count const& pn ) noexcept: pn_( pn )
     {
     }
 
-#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
-
-    explicit local_counted_impl( shared_count && pn ) BOOST_SP_NOEXCEPT: pn_( std::move(pn) )
+    explicit local_counted_impl( shared_count && pn ) noexcept: pn_( std::move(pn) )
     {
     }
 
-#endif
-
-    void local_cb_destroy() BOOST_SP_NOEXCEPT BOOST_OVERRIDE
+    void local_cb_destroy() noexcept override
     {
         delete this;
     }
 
-    boost::detail::shared_count local_cb_get_shared_count() const BOOST_SP_NOEXCEPT BOOST_OVERRIDE
+    boost::detail::shared_count local_cb_get_shared_count() const noexcept override
     {
         return pn_;
     }
@@ -130,12 +126,12 @@ public:
 
     shared_count pn_;
 
-    void local_cb_destroy() BOOST_SP_NOEXCEPT BOOST_OVERRIDE
+    void local_cb_destroy() noexcept override
     {
         shared_count().swap( pn_ );
     }
 
-    boost::detail::shared_count local_cb_get_shared_count() const BOOST_SP_NOEXCEPT BOOST_OVERRIDE
+    boost::detail::shared_count local_cb_get_shared_count() const noexcept override
     {
         return pn_;
     }

include/boost/smart_ptr/detail/local_sp_deleter.hpp

@@ -38,48 +38,40 @@ public:
     {
     }
 
-    explicit local_sp_deleter( D const& d ) BOOST_SP_NOEXCEPT: d_( d )
+    explicit local_sp_deleter( D const& d ) noexcept: d_( d )
     {
     }
 
-#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
-
-    explicit local_sp_deleter( D&& d ) BOOST_SP_NOEXCEPT: d_( std::move(d) )
+    explicit local_sp_deleter( D&& d ) noexcept: d_( std::move(d) )
     {
     }
 
-#endif
-
-    D& deleter() BOOST_SP_NOEXCEPT
+    D& deleter() noexcept
     {
         return d_;
     }
 
-    template<class Y> void operator()( Y* p ) BOOST_SP_NOEXCEPT
+    template<class Y> void operator()( Y* p ) noexcept
     {
         d_( p );
     }
 
-#if !defined( BOOST_NO_CXX11_NULLPTR )
-
-    void operator()( boost::detail::sp_nullptr_t p ) BOOST_SP_NOEXCEPT
+    void operator()( std::nullptr_t p ) noexcept
     {
         d_( p );
     }
-
-#endif
 };
 
 template<> class local_sp_deleter<void>
 {
 };
 
-template<class D> D * get_local_deleter( local_sp_deleter<D> * p ) BOOST_SP_NOEXCEPT
+template<class D> D * get_local_deleter( local_sp_deleter<D> * p ) noexcept
 {
     return &p->deleter();
 }
 
-inline void * get_local_deleter( local_sp_deleter<void> * /*p*/ ) BOOST_SP_NOEXCEPT
+inline void * get_local_deleter( local_sp_deleter<void> * /*p*/ ) noexcept
 {
     return 0;
 }

include/boost/smart_ptr/detail/operator_bool.hpp

@@ -1,64 +0,0 @@
-//  This header intentionally has no include guards.
-//
-//  Copyright (c) 2001-2009, 2012 Peter Dimov
-//
-//  Distributed under the Boost Software License, Version 1.0.
-//  See accompanying file LICENSE_1_0.txt or copy at
-//  http://www.boost.org/LICENSE_1_0.txt
-
-#if !defined( BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS ) && !defined( BOOST_NO_CXX11_NULLPTR )\
-    && !(defined(__SUNPRO_CC) && BOOST_WORKAROUND(__SUNPRO_CC, <= 0x5130))
-
-    explicit operator bool () const BOOST_SP_NOEXCEPT
-    {
-        return px != 0;
-    }
-
-#elif ( defined(__SUNPRO_CC) && BOOST_WORKAROUND(__SUNPRO_CC, < 0x570) ) || defined(__CINT__)
-
-    operator bool () const BOOST_SP_NOEXCEPT
-    {
-        return px != 0;
-    }
-
-#elif defined( _MANAGED )
-
-    static void unspecified_bool( this_type*** )
-    {
-    }
-
-    typedef void (*unspecified_bool_type)( this_type*** );
-
-    operator unspecified_bool_type() const BOOST_SP_NOEXCEPT
-    {
-        return px == 0? 0: unspecified_bool;
-    }
-
-#elif \
-    ( defined(__MWERKS__) && BOOST_WORKAROUND(__MWERKS__, < 0x3200) ) || \
-    ( defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__ < 304) ) || \
-    ( defined(__SUNPRO_CC) && BOOST_WORKAROUND(__SUNPRO_CC, <= 0x590) )
-
-    typedef element_type * (this_type::*unspecified_bool_type)() const;
-
-    operator unspecified_bool_type() const BOOST_SP_NOEXCEPT
-    {
-        return px == 0? 0: &this_type::get;
-    }
-
-#else
-
-    typedef element_type * this_type::*unspecified_bool_type;
-
-    operator unspecified_bool_type() const BOOST_SP_NOEXCEPT
-    {
-        return px == 0? 0: &this_type::px;
-    }
-
-#endif
-
-    // operator! is redundant, but some compilers need it
-    bool operator! () const BOOST_SP_NOEXCEPT
-    {
-        return px == 0;
-    }

include/boost/smart_ptr/detail/quick_allocator.hpp

@@ -21,21 +21,20 @@
 #include <boost/config.hpp>
 
 #include <boost/smart_ptr/detail/lightweight_mutex.hpp>
-#include <boost/type_traits/type_with_alignment.hpp>
-#include <boost/type_traits/alignment_of.hpp>
+#include <boost/smart_ptr/detail/sp_type_traits.hpp>
 
+#include <type_traits>
 #include <new>              // ::operator new, ::operator delete
 #include <cstddef>          // std::size_t
 
 namespace boost
 {
-
 namespace detail
 {
 
 template<unsigned size, unsigned align_> union freeblock
 {
-    typedef typename boost::type_with_alignment<align_>::type aligner_type;
+    typedef typename sp_type_with_alignment<align_>::type aligner_type;
     aligner_type aligner;
     char bytes[size];
     freeblock * next;
@@ -74,7 +73,7 @@ template<unsigned size, unsigned align_> struct allocator_impl
 
     static lightweight_mutex & mutex()
     {
-        static freeblock< sizeof( lightweight_mutex ), boost::alignment_of< lightweight_mutex >::value > fbm;
+        static freeblock< sizeof( lightweight_mutex ), std::alignment_of< lightweight_mutex >::value > fbm;
         static lightweight_mutex * pm = new( &fbm ) lightweight_mutex;
         return *pm;
     }
@@ -188,7 +187,7 @@ template<unsigned size, unsigned align_>
   unsigned allocator_impl<size, align_>::last = allocator_impl<size, align_>::items_per_page;
 
 template<class T>
-struct quick_allocator: public allocator_impl< sizeof(T), boost::alignment_of<T>::value >
+struct quick_allocator: public allocator_impl< sizeof(T), std::alignment_of<T>::value >
 {
 };
 

include/boost/smart_ptr/detail/requires_cxx11.hpp

@@ -1,23 +0,0 @@
-#ifndef BOOST_SMART_PTR_DETAIL_REQUIRES_CXX11_HPP_INCLUDED
-#define BOOST_SMART_PTR_DETAIL_REQUIRES_CXX11_HPP_INCLUDED
-
-// Copyright 2023 Peter Dimov
-// Distributed under the Boost Software License, Version 1.0.
-// https://www.boost.org/LICENSE_1_0.txt
-
-#include <boost/config.hpp>
-#include <boost/config/pragma_message.hpp>
-
-#if defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) || \
-    defined(BOOST_NO_CXX11_RVALUE_REFERENCES) || \
-    defined(BOOST_NO_CXX11_DECLTYPE) || \
-    defined(BOOST_NO_CXX11_CONSTEXPR) || \
-    defined(BOOST_NO_CXX11_NOEXCEPT) || \
-    defined(BOOST_NO_CXX11_NULLPTR) || \
-    defined(BOOST_NO_CXX11_SMART_PTR)
-
-BOOST_PRAGMA_MESSAGE("C++03 support was deprecated in Boost.SmartPtr 1.82 and will be removed in Boost.SmartPtr 1.84. Please open an issue in https://github.com/boostorg/smart_ptr if you want it retained.")
-
-#endif
-
-#endif // #ifndef BOOST_SMART_PTR_DETAIL_REQUIRES_CXX11_HPP_INCLUDED

include/boost/smart_ptr/detail/shared_count.hpp

@@ -18,15 +18,11 @@
 // http://www.boost.org/LICENSE_1_0.txt)
 //
 
-#if defined(__BORLANDC__) && !defined(__clang__)
-# pragma warn -8027     // Functions containing try are not expanded inline
-#endif
-
 #include <boost/smart_ptr/bad_weak_ptr.hpp>
 #include <boost/smart_ptr/detail/sp_counted_base.hpp>
 #include <boost/smart_ptr/detail/sp_counted_impl.hpp>
 #include <boost/smart_ptr/detail/sp_disable_deprecated.hpp>
-#include <boost/smart_ptr/detail/sp_noexcept.hpp>
+#include <boost/smart_ptr/detail/deprecated_macros.hpp>
 #include <boost/core/checked_delete.hpp>
 #include <boost/throw_exception.hpp>
 #include <boost/core/addressof.hpp>
@@ -59,13 +55,6 @@ template< class T, class D > class unique_ptr;
 namespace detail
 {
 
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
-
-int const shared_count_id = 0x2C35F101;
-int const   weak_count_id = 0x298C38A4;
-
-#endif
-
 struct sp_nothrow_tag {};
 
 template< class D > struct sp_inplace_tag
@@ -100,7 +89,7 @@ template< class D > struct sp_convert_reference< D& >
     typedef sp_reference_wrapper< D > type;
 };
 
-template<class T> std::size_t sp_hash_pointer( T* p ) BOOST_NOEXCEPT
+template<class T> std::size_t sp_hash_pointer( T* p ) noexcept
 {
     boost::uintptr_t v = reinterpret_cast<boost::uintptr_t>( p );
 
@@ -116,32 +105,19 @@ private:
 
     sp_counted_base * pi_;
 
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
-    int id_;
-#endif
-
     friend class weak_count;
 
 public:
 
-    BOOST_CONSTEXPR shared_count() BOOST_SP_NOEXCEPT: pi_(0)
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
-        , id_(shared_count_id)
-#endif
+    constexpr shared_count() noexcept: pi_(0)
     {
     }
 
-    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
+    constexpr explicit shared_count( sp_counted_base * pi ) noexcept: pi_( pi )
     {
     }
 
     template<class Y> explicit shared_count( Y * p ): pi_( 0 )
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
-        , id_(shared_count_id)
-#endif
     {
 #ifndef BOOST_NO_EXCEPTIONS
 
@@ -168,18 +144,8 @@ public:
 #endif
     }
 
-#if defined( BOOST_MSVC ) && BOOST_WORKAROUND( BOOST_MSVC, <= 1200 )
-    template<class Y, class D> shared_count( Y * p, D d ): pi_(0)
-#else
     template<class P, class D> shared_count( P p, D d ): pi_(0)
-#endif
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
-        , id_(shared_count_id)
-#endif
     {
-#if defined( BOOST_MSVC ) && BOOST_WORKAROUND( BOOST_MSVC, <= 1200 )
-        typedef Y* P;
-#endif
 #ifndef BOOST_NO_EXCEPTIONS
 
         try
@@ -205,12 +171,7 @@ public:
 #endif
     }
 
-#if !defined( BOOST_NO_FUNCTION_TEMPLATE_ORDERING )
-
     template< class P, class D > shared_count( P p, sp_inplace_tag<D> ): pi_( 0 )
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
-        , id_(shared_count_id)
-#endif
     {
 #ifndef BOOST_NO_EXCEPTIONS
 
@@ -237,25 +198,12 @@ public:
 #endif // #ifndef BOOST_NO_EXCEPTIONS
     }
 
-#endif // !defined( BOOST_NO_FUNCTION_TEMPLATE_ORDERING )
-
     template<class P, class D, class A> shared_count( P p, D d, A a ): pi_( 0 )
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
-        , id_(shared_count_id)
-#endif
     {
         typedef sp_counted_impl_pda<P, D, A> impl_type;
 
-#if !defined( BOOST_NO_CXX11_ALLOCATOR )
-
         typedef typename std::allocator_traits<A>::template rebind_alloc< impl_type > A2;
 
-#else
-
-        typedef typename A::template rebind< impl_type >::other A2;
-
-#endif
-
         A2 a2( a );
 
 #ifndef BOOST_NO_EXCEPTIONS
@@ -294,25 +242,12 @@ public:
 #endif
     }
 
-#if !defined( BOOST_NO_FUNCTION_TEMPLATE_ORDERING )
-
     template< class P, class D, class A > shared_count( P p, sp_inplace_tag< D >, A a ): pi_( 0 )
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
-        , id_(shared_count_id)
-#endif
     {
         typedef sp_counted_impl_pda< P, D, A > impl_type;
 
-#if !defined( BOOST_NO_CXX11_ALLOCATOR )
-
         typedef typename std::allocator_traits<A>::template rebind_alloc< impl_type > A2;
 
-#else
-
-        typedef typename A::template rebind< impl_type >::other A2;
-
-#endif
-
         A2 a2( a );
 
 #ifndef BOOST_NO_EXCEPTIONS
@@ -351,17 +286,12 @@ public:
 #endif // #ifndef BOOST_NO_EXCEPTIONS
     }
 
-#endif // !defined( BOOST_NO_FUNCTION_TEMPLATE_ORDERING )
-
 #ifndef BOOST_NO_AUTO_PTR
 
     // auto_ptr<Y> is special cased to provide the strong guarantee
 
     template<class Y>
     explicit shared_count( std::auto_ptr<Y> & r ): pi_( new sp_counted_impl_p<Y>( r.get() ) )
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
-        , id_(shared_count_id)
-#endif
     {
 #ifdef BOOST_NO_EXCEPTIONS
 
@@ -377,13 +307,8 @@ public:
 
 #endif 
 
-#if !defined( BOOST_NO_CXX11_SMART_PTR )
-
     template<class Y, class D>
     explicit shared_count( std::unique_ptr<Y, D> & r ): pi_( 0 )
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
-        , id_(shared_count_id)
-#endif
     {
         typedef typename sp_convert_reference<D>::type D2;
 
@@ -402,13 +327,8 @@ public:
         r.release();
     }
 
-#endif
-
     template<class Y, class D>
     explicit shared_count( boost::movelib::unique_ptr<Y, D> & r ): pi_( 0 )
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
-        , id_(shared_count_id)
-#endif
     {
         typedef typename sp_convert_reference<D>::type D2;
 
@@ -427,38 +347,25 @@ public:
         r.release();
     }
 
-    ~shared_count() /*BOOST_SP_NOEXCEPT*/
+    ~shared_count() /*noexcept*/
     {
         if( pi_ != 0 ) pi_->release();
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
-        id_ = 0;
-#endif
     }
 
-    shared_count(shared_count const & r) BOOST_SP_NOEXCEPT: pi_(r.pi_)
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
-        , id_(shared_count_id)
-#endif
+    shared_count(shared_count const & r) noexcept: pi_(r.pi_)
     {
         if( pi_ != 0 ) pi_->add_ref_copy();
     }
 
-#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
-
-    shared_count(shared_count && r) BOOST_SP_NOEXCEPT: pi_(r.pi_)
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
-        , id_(shared_count_id)
-#endif
+    shared_count(shared_count && r) noexcept: pi_(r.pi_)
     {
         r.pi_ = 0;
     }
 
-#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 ) BOOST_SP_NOEXCEPT; // constructs an empty *this when r.use_count() == 0
+    shared_count( weak_count const & r, sp_nothrow_tag ) noexcept; // constructs an empty *this when r.use_count() == 0
 
-    shared_count & operator= (shared_count const & r) BOOST_SP_NOEXCEPT
+    shared_count & operator= (shared_count const & r) noexcept
     {
         sp_counted_base * tmp = r.pi_;
 
@@ -472,58 +379,58 @@ public:
         return *this;
     }
 
-    void swap(shared_count & r) BOOST_SP_NOEXCEPT
+    void swap(shared_count & r) noexcept
     {
         sp_counted_base * tmp = r.pi_;
         r.pi_ = pi_;
         pi_ = tmp;
     }
 
-    long use_count() const BOOST_SP_NOEXCEPT
+    long use_count() const noexcept
     {
         return pi_ != 0? pi_->use_count(): 0;
     }
 
-    bool unique() const BOOST_SP_NOEXCEPT
+    bool unique() const noexcept
     {
         return use_count() == 1;
     }
 
-    bool empty() const BOOST_SP_NOEXCEPT
+    bool empty() const noexcept
     {
         return pi_ == 0;
     }
 
-    bool operator==( shared_count const & r ) const BOOST_SP_NOEXCEPT
+    bool operator==( shared_count const & r ) const noexcept
     {
         return pi_ == r.pi_;
     }
 
-    bool operator==( weak_count const & r ) const BOOST_SP_NOEXCEPT;
+    bool operator==( weak_count const & r ) const noexcept;
 
-    bool operator<( shared_count const & r ) const BOOST_SP_NOEXCEPT
+    bool operator<( shared_count const & r ) const noexcept
     {
         return std::less<sp_counted_base *>()( pi_, r.pi_ );
     }
 
-    bool operator<( weak_count const & r ) const BOOST_SP_NOEXCEPT;
+    bool operator<( weak_count const & r ) const noexcept;
 
-    void * get_deleter( sp_typeinfo_ const & ti ) const BOOST_SP_NOEXCEPT
+    void * get_deleter( sp_typeinfo_ const & ti ) const noexcept
     {
         return pi_? pi_->get_deleter( ti ): 0;
     }
 
-    void * get_local_deleter( sp_typeinfo_ const & ti ) const BOOST_SP_NOEXCEPT
+    void * get_local_deleter( sp_typeinfo_ const & ti ) const noexcept
     {
         return pi_? pi_->get_local_deleter( ti ): 0;
     }
 
-    void * get_untyped_deleter() const BOOST_SP_NOEXCEPT
+    void * get_untyped_deleter() const noexcept
     {
         return pi_? pi_->get_untyped_deleter(): 0;
     }
 
-    std::size_t hash_value() const BOOST_SP_NOEXCEPT
+    std::size_t hash_value() const noexcept
     {
         return sp_hash_pointer( pi_ );
     }
@@ -536,60 +443,37 @@ private:
 
     sp_counted_base * pi_;
 
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
-    int id_;
-#endif
-
     friend class shared_count;
 
 public:
 
-    BOOST_CONSTEXPR weak_count() BOOST_SP_NOEXCEPT: pi_(0)
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
-        , id_(weak_count_id)
-#endif
+    constexpr weak_count() noexcept: pi_(0)
     {
     }
 
-    weak_count(shared_count const & r) BOOST_SP_NOEXCEPT: pi_(r.pi_)
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
-        , id_(weak_count_id)
-#endif
+    weak_count(shared_count const & r) noexcept: pi_(r.pi_)
     {
         if(pi_ != 0) pi_->weak_add_ref();
     }
 
-    weak_count(weak_count const & r) BOOST_SP_NOEXCEPT: pi_(r.pi_)
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
-        , id_(weak_count_id)
-#endif
+    weak_count(weak_count const & r) noexcept: pi_(r.pi_)
     {
         if(pi_ != 0) pi_->weak_add_ref();
     }
 
 // Move support
 
-#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
-
-    weak_count(weak_count && r) BOOST_SP_NOEXCEPT: pi_(r.pi_)
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
-        , id_(weak_count_id)
-#endif
+    weak_count(weak_count && r) noexcept: pi_(r.pi_)
     {
         r.pi_ = 0;
     }
 
-#endif
-
-    ~weak_count() /*BOOST_SP_NOEXCEPT*/
+    ~weak_count() /*noexcept*/
     {
         if(pi_ != 0) pi_->weak_release();
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
-        id_ = 0;
-#endif
     }
 
-    weak_count & operator= (shared_count const & r) BOOST_SP_NOEXCEPT
+    weak_count & operator= (shared_count const & r) noexcept
     {
         sp_counted_base * tmp = r.pi_;
 
@@ -603,7 +487,7 @@ public:
         return *this;
     }
 
-    weak_count & operator= (weak_count const & r) BOOST_SP_NOEXCEPT
+    weak_count & operator= (weak_count const & r) noexcept
     {
         sp_counted_base * tmp = r.pi_;
 
@@ -617,53 +501,50 @@ public:
         return *this;
     }
 
-    void swap(weak_count & r) BOOST_SP_NOEXCEPT
+    void swap(weak_count & r) noexcept
     {
         sp_counted_base * tmp = r.pi_;
         r.pi_ = pi_;
         pi_ = tmp;
     }
 
-    long use_count() const BOOST_SP_NOEXCEPT
+    long use_count() const noexcept
     {
         return pi_ != 0? pi_->use_count(): 0;
     }
 
-    bool empty() const BOOST_SP_NOEXCEPT
+    bool empty() const noexcept
     {
         return pi_ == 0;
     }
 
-    bool operator==( weak_count const & r ) const BOOST_SP_NOEXCEPT
+    bool operator==( weak_count const & r ) const noexcept
     {
         return pi_ == r.pi_;
     }
 
-    bool operator==( shared_count const & r ) const BOOST_SP_NOEXCEPT
+    bool operator==( shared_count const & r ) const noexcept
     {
         return pi_ == r.pi_;
     }
 
-    bool operator<( weak_count const & r ) const BOOST_SP_NOEXCEPT
+    bool operator<( weak_count const & r ) const noexcept
     {
         return std::less<sp_counted_base *>()( pi_, r.pi_ );
     }
 
-    bool operator<( shared_count const & r ) const BOOST_SP_NOEXCEPT
+    bool operator<( shared_count const & r ) const noexcept
     {
         return std::less<sp_counted_base *>()( pi_, r.pi_ );
     }
 
-    std::size_t hash_value() const BOOST_SP_NOEXCEPT
+    std::size_t hash_value() const noexcept
     {
         return sp_hash_pointer( pi_ );
     }
 };
 
 inline shared_count::shared_count( weak_count const & r ): pi_( r.pi_ )
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
-        , id_(shared_count_id)
-#endif
 {
     if( pi_ == 0 || !pi_->add_ref_lock() )
     {
@@ -671,10 +552,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 ) BOOST_SP_NOEXCEPT: pi_( r.pi_ )
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
-        , id_(shared_count_id)
-#endif
+inline shared_count::shared_count( weak_count const & r, sp_nothrow_tag ) noexcept: pi_( r.pi_ )
 {
     if( pi_ != 0 && !pi_->add_ref_lock() )
     {
@@ -682,12 +560,12 @@ inline shared_count::shared_count( weak_count const & r, sp_nothrow_tag ) BOOST_
     }
 }
 
-inline bool shared_count::operator==( weak_count const & r ) const BOOST_SP_NOEXCEPT
+inline bool shared_count::operator==( weak_count const & r ) const noexcept
 {
     return pi_ == r.pi_;
 }
 
-inline bool shared_count::operator<( weak_count const & r ) const BOOST_SP_NOEXCEPT
+inline bool shared_count::operator<( weak_count const & r ) const noexcept
 {
     return std::less<sp_counted_base *>()( pi_, r.pi_ );
 }
@@ -700,8 +578,4 @@ inline bool shared_count::operator<( weak_count const & r ) const BOOST_SP_NOEXC
 #pragma GCC diagnostic pop
 #endif
 
-#if defined(__BORLANDC__) && !defined(__clang__)
-# pragma warn .8027     // Functions containing try are not expanded inline
-#endif
-
 #endif  // #ifndef BOOST_SMART_PTR_DETAIL_SHARED_COUNT_HPP_INCLUDED

include/boost/smart_ptr/detail/sp_convertible.hpp

@@ -18,20 +18,6 @@
 #include <boost/config.hpp>
 #include <cstddef>
 
-#if !defined( BOOST_SP_NO_SP_CONVERTIBLE ) && defined( BOOST_NO_SFINAE )
-# define BOOST_SP_NO_SP_CONVERTIBLE
-#endif
-
-#if !defined( BOOST_SP_NO_SP_CONVERTIBLE ) && defined( __GNUC__ ) && ( __GNUC__ * 100 + __GNUC_MINOR__ < 303 )
-# define BOOST_SP_NO_SP_CONVERTIBLE
-#endif
-
-#if !defined( BOOST_SP_NO_SP_CONVERTIBLE ) && defined( BOOST_BORLANDC ) && ( BOOST_BORLANDC < 0x630 )
-# define BOOST_SP_NO_SP_CONVERTIBLE
-#endif
-
-#if !defined( BOOST_SP_NO_SP_CONVERTIBLE )
-
 namespace boost
 {
 
@@ -87,6 +73,4 @@ template< class Y, class T > struct sp_enable_if_convertible: public sp_enable_i
 
 } // namespace boost
 
-#endif // !defined( BOOST_SP_NO_SP_CONVERTIBLE )
-
 #endif  // #ifndef BOOST_SMART_PTR_DETAIL_SP_CONVERTIBLE_HPP_INCLUDED

include/boost/smart_ptr/detail/sp_counted_base.hpp

@@ -19,6 +19,7 @@
 
 #include <boost/smart_ptr/detail/sp_has_gcc_intrinsics.hpp>
 #include <boost/smart_ptr/detail/sp_has_sync_intrinsics.hpp>
+#include <boost/smart_ptr/detail/deprecated_macros.hpp>
 #include <boost/config.hpp>
 
 #if defined( BOOST_SP_DISABLE_THREADS )

include/boost/smart_ptr/detail/sp_counted_base_nt.hpp

@@ -19,7 +19,6 @@
 //
 
 #include <boost/smart_ptr/detail/sp_typeinfo_.hpp>
-#include <boost/smart_ptr/detail/sp_noexcept.hpp>
 #include <boost/config.hpp>
 #include <boost/cstdint.hpp>
 
@@ -48,43 +47,43 @@ private:
 
 public:
 
-    sp_counted_base() BOOST_SP_NOEXCEPT: use_count_( 1 ), weak_count_( 1 )
+    sp_counted_base() noexcept: use_count_( 1 ), weak_count_( 1 )
     {
     }
 
-    virtual ~sp_counted_base() /*BOOST_SP_NOEXCEPT*/
+    virtual ~sp_counted_base() /*noexcept*/
     {
     }
 
     // dispose() is called when use_count_ drops to zero, to release
     // the resources managed by *this.
 
-    virtual void dispose() BOOST_SP_NOEXCEPT = 0; // nothrow
+    virtual void dispose() noexcept = 0; // nothrow
 
     // destroy() is called when weak_count_ drops to zero.
 
-    virtual void destroy() BOOST_SP_NOEXCEPT // nothrow
+    virtual void destroy() noexcept // nothrow
     {
         delete this;
     }
 
-    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;
+    virtual void * get_deleter( sp_typeinfo_ const & ti ) noexcept = 0;
+    virtual void * get_local_deleter( sp_typeinfo_ const & ti ) noexcept = 0;
+    virtual void * get_untyped_deleter() noexcept = 0;
 
-    void add_ref_copy() BOOST_SP_NOEXCEPT
+    void add_ref_copy() noexcept
     {
         ++use_count_;
     }
 
-    bool add_ref_lock() BOOST_SP_NOEXCEPT // true on success
+    bool add_ref_lock() noexcept // true on success
     {
         if( use_count_ == 0 ) return false;
         ++use_count_;
         return true;
     }
 
-    void release() BOOST_SP_NOEXCEPT
+    void release() noexcept
     {
         if( --use_count_ == 0 )
         {
@@ -93,12 +92,12 @@ public:
         }
     }
 
-    void weak_add_ref() BOOST_SP_NOEXCEPT
+    void weak_add_ref() noexcept
     {
         ++weak_count_;
     }
 
-    void weak_release() BOOST_SP_NOEXCEPT
+    void weak_release() noexcept
     {
         if( --weak_count_ == 0 )
         {
@@ -106,7 +105,7 @@ public:
         }
     }
 
-    long use_count() const BOOST_SP_NOEXCEPT
+    long use_count() const noexcept
     {
         return use_count_;
     }

include/boost/smart_ptr/detail/sp_counted_base_std_atomic.hpp

@@ -16,7 +16,6 @@
 //  http://www.boost.org/LICENSE_1_0.txt
 
 #include <boost/smart_ptr/detail/sp_typeinfo_.hpp>
-#include <boost/smart_ptr/detail/sp_noexcept.hpp>
 #include <boost/config.hpp>
 #include <atomic>
 #include <cstdint>
@@ -34,17 +33,17 @@ namespace boost
 namespace detail
 {
 
-inline void atomic_increment( std::atomic_int_least32_t * pw ) BOOST_SP_NOEXCEPT
+inline void atomic_increment( std::atomic_int_least32_t * pw ) noexcept
 {
     pw->fetch_add( 1, std::memory_order_relaxed );
 }
 
-inline std::int_least32_t atomic_decrement( std::atomic_int_least32_t * pw ) BOOST_SP_NOEXCEPT
+inline std::int_least32_t atomic_decrement( std::atomic_int_least32_t * pw ) 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 ) BOOST_SP_NOEXCEPT
+inline std::int_least32_t atomic_conditional_increment( std::atomic_int_least32_t * pw ) noexcept
 {
     // long r = *pw;
     // if( r != 0 ) ++*pw;
@@ -78,41 +77,41 @@ private:
 
 public:
 
-    sp_counted_base() BOOST_SP_NOEXCEPT: use_count_( 1 ), weak_count_( 1 )
+    sp_counted_base() noexcept: use_count_( 1 ), weak_count_( 1 )
     {
     }
 
-    virtual ~sp_counted_base() /*BOOST_SP_NOEXCEPT*/
+    virtual ~sp_counted_base() /*noexcept*/
     {
     }
 
     // dispose() is called when use_count_ drops to zero, to release
     // the resources managed by *this.
 
-    virtual void dispose() BOOST_SP_NOEXCEPT = 0;
+    virtual void dispose() noexcept = 0;
 
     // destroy() is called when weak_count_ drops to zero.
 
-    virtual void destroy() BOOST_SP_NOEXCEPT
+    virtual void destroy() noexcept
     {
         delete this;
     }
 
-    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;
+    virtual void * get_deleter( sp_typeinfo_ const & ti ) noexcept = 0;
+    virtual void * get_local_deleter( sp_typeinfo_ const & ti ) noexcept = 0;
+    virtual void * get_untyped_deleter() noexcept = 0;
 
-    void add_ref_copy() BOOST_SP_NOEXCEPT
+    void add_ref_copy() noexcept
     {
         atomic_increment( &use_count_ );
     }
 
-    bool add_ref_lock() BOOST_SP_NOEXCEPT // true on success
+    bool add_ref_lock() noexcept // true on success
     {
         return atomic_conditional_increment( &use_count_ ) != 0;
     }
 
-    void release() BOOST_SP_NOEXCEPT
+    void release() noexcept
     {
         if( atomic_decrement( &use_count_ ) == 1 )
         {
@@ -121,12 +120,12 @@ public:
         }
     }
 
-    void weak_add_ref() BOOST_SP_NOEXCEPT
+    void weak_add_ref() noexcept
     {
         atomic_increment( &weak_count_ );
     }
 
-    void weak_release() BOOST_SP_NOEXCEPT
+    void weak_release() noexcept
     {
         if( atomic_decrement( &weak_count_ ) == 1 )
         {
@@ -134,7 +133,7 @@ public:
         }
     }
 
-    long use_count() const BOOST_SP_NOEXCEPT
+    long use_count() const noexcept
     {
         return use_count_.load( std::memory_order_acquire );
     }

include/boost/smart_ptr/detail/sp_counted_base_w32.hpp

@@ -90,18 +90,7 @@ public:
             long tmp = static_cast< long const volatile& >( use_count_ );
             if( tmp == 0 ) return false;
 
-#if defined( BOOST_MSVC ) && BOOST_WORKAROUND( BOOST_MSVC, == 1200 )
-
-            // work around a code generation bug
-
-            long tmp2 = tmp + 1;
-            if( BOOST_SP_INTERLOCKED_COMPARE_EXCHANGE( &use_count_, tmp2, tmp ) == tmp2 - 1 ) return true;
-
-#else
-
             if( BOOST_SP_INTERLOCKED_COMPARE_EXCHANGE( &use_count_, tmp + 1, tmp ) == tmp ) return true;
-
-#endif
         }
     }
 

include/boost/smart_ptr/detail/sp_counted_impl.hpp

@@ -18,33 +18,18 @@
 // http://www.boost.org/LICENSE_1_0.txt)
 //
 
-#if defined(BOOST_SP_USE_STD_ALLOCATOR) && defined(BOOST_SP_USE_QUICK_ALLOCATOR)
-# error BOOST_SP_USE_STD_ALLOCATOR and BOOST_SP_USE_QUICK_ALLOCATOR are incompatible.
-#endif
-
 #include <boost/smart_ptr/detail/sp_counted_base.hpp>
-#include <boost/smart_ptr/detail/sp_noexcept.hpp>
+#include <boost/smart_ptr/detail/deprecated_macros.hpp>
 #include <boost/core/checked_delete.hpp>
 #include <boost/core/addressof.hpp>
 #include <boost/config.hpp>
 
-#if defined(BOOST_SP_USE_QUICK_ALLOCATOR)
-#include <boost/smart_ptr/detail/quick_allocator.hpp>
-#endif
-
 #include <memory>           // std::allocator, std::allocator_traits
 #include <cstddef>          // std::size_t
 
 namespace boost
 {
 
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
-
-void sp_scalar_constructor_hook( void * px, std::size_t size, void * pn );
-void sp_scalar_destructor_hook( void * px, std::size_t size, void * pn );
-
-#endif
-
 namespace detail
 {
 
@@ -52,12 +37,12 @@ namespace detail
 
 template<class D> class local_sp_deleter;
 
-template<class D> D * get_local_deleter( D * /*p*/ ) BOOST_SP_NOEXCEPT
+template<class D> D * get_local_deleter( D * /*p*/ ) noexcept
 {
     return 0;
 }
 
-template<class D> D * get_local_deleter( local_sp_deleter<D> * p ) BOOST_SP_NOEXCEPT;
+template<class D> D * get_local_deleter( local_sp_deleter<D> * p ) noexcept;
 
 //
 
@@ -76,70 +61,29 @@ public:
 
     explicit sp_counted_impl_p( X * px ): px_( px )
     {
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
-        boost::sp_scalar_constructor_hook( px, sizeof(X), this );
-#endif
     }
 
-    void dispose() BOOST_SP_NOEXCEPT BOOST_OVERRIDE
+    void dispose() noexcept override
     {
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
-        boost::sp_scalar_destructor_hook( px_, sizeof(X), this );
-#endif
         boost::checked_delete( px_ );
     }
 
-    void * get_deleter( sp_typeinfo_ const & ) BOOST_SP_NOEXCEPT BOOST_OVERRIDE
+    void * get_deleter( sp_typeinfo_ const & ) noexcept override
     {
         return 0;
     }
 
-    void * get_local_deleter( sp_typeinfo_ const & ) BOOST_SP_NOEXCEPT BOOST_OVERRIDE
+    void * get_local_deleter( sp_typeinfo_ const & ) noexcept override
     {
         return 0;
     }
 
-    void * get_untyped_deleter() BOOST_SP_NOEXCEPT BOOST_OVERRIDE
+    void * get_untyped_deleter() noexcept override
     {
         return 0;
     }
-
-#if defined(BOOST_SP_USE_STD_ALLOCATOR)
-
-    void * operator new( std::size_t )
-    {
-        return std::allocator<this_type>().allocate( 1, static_cast<this_type *>(0) );
-    }
-
-    void operator delete( void * p )
-    {
-        std::allocator<this_type>().deallocate( static_cast<this_type *>(p), 1 );
-    }
-
-#endif
-
-#if defined(BOOST_SP_USE_QUICK_ALLOCATOR)
-
-    void * operator new( std::size_t )
-    {
-        return quick_allocator<this_type>::alloc();
-    }
-
-    void operator delete( void * p )
-    {
-        quick_allocator<this_type>::dealloc( p );
-    }
-
-#endif
 };
 
-//
-// Borland's Codeguard trips up over the -Vx- option here:
-//
-#ifdef __CODEGUARD__
-# pragma option push -Vx-
-#endif
-
 template<class P, class D> class BOOST_SYMBOL_VISIBLE sp_counted_impl_pd: public sp_counted_base
 {
 private:
@@ -156,71 +100,33 @@ public:
 
     // pre: d(p) must not throw
 
-#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
-
     sp_counted_impl_pd( P p, D & d ): ptr( p ), del( static_cast< D&& >( d ) )
     {
     }
 
-#else
-
-    sp_counted_impl_pd( P p, D & d ): ptr( p ), del( d )
-    {
-    }
-
-#endif
-
     sp_counted_impl_pd( P p ): ptr( p ), del()
     {
     }
 
-    void dispose() BOOST_SP_NOEXCEPT BOOST_OVERRIDE
+    void dispose() noexcept override
     {
         del( ptr );
     }
 
-    void * get_deleter( sp_typeinfo_ const & ti ) BOOST_SP_NOEXCEPT BOOST_OVERRIDE
+    void * get_deleter( sp_typeinfo_ const & ti ) noexcept override
     {
         return ti == BOOST_SP_TYPEID_(D)? &reinterpret_cast<char&>( del ): 0;
     }
 
-    void * get_local_deleter( sp_typeinfo_ const & ti ) BOOST_SP_NOEXCEPT BOOST_OVERRIDE
+    void * get_local_deleter( sp_typeinfo_ const & ti ) noexcept override
     {
         return ti == BOOST_SP_TYPEID_(D)? boost::detail::get_local_deleter( boost::addressof( del ) ): 0;
     }
 
-    void * get_untyped_deleter() BOOST_SP_NOEXCEPT BOOST_OVERRIDE
+    void * get_untyped_deleter() noexcept override
     {
         return &reinterpret_cast<char&>( del );
     }
-
-#if defined(BOOST_SP_USE_STD_ALLOCATOR)
-
-    void * operator new( std::size_t )
-    {
-        return std::allocator<this_type>().allocate( 1, static_cast<this_type *>(0) );
-    }
-
-    void operator delete( void * p )
-    {
-        std::allocator<this_type>().deallocate( static_cast<this_type *>(p), 1 );
-    }
-
-#endif
-
-#if defined(BOOST_SP_USE_QUICK_ALLOCATOR)
-
-    void * operator new( std::size_t )
-    {
-        return quick_allocator<this_type>::alloc();
-    }
-
-    void operator delete( void * p )
-    {
-        quick_allocator<this_type>::dealloc( p );
-    }
-
-#endif
 };
 
 template<class P, class D, class A> class BOOST_SYMBOL_VISIBLE sp_counted_impl_pda: public sp_counted_base
@@ -240,41 +146,23 @@ public:
 
     // pre: d( p ) must not throw
 
-#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
-
     sp_counted_impl_pda( P p, D & d, A a ): p_( p ), d_( static_cast< D&& >( d ) ), a_( a )
     {
     }
 
-#else
-
-    sp_counted_impl_pda( P p, D & d, A a ): p_( p ), d_( d ), a_( a )
-    {
-    }
-
-#endif
-
     sp_counted_impl_pda( P p, A a ): p_( p ), d_( a ), a_( a )
     {
     }
 
-    void dispose() BOOST_SP_NOEXCEPT BOOST_OVERRIDE
+    void dispose() noexcept override
     {
         d_( p_ );
     }
 
-    void destroy() BOOST_SP_NOEXCEPT BOOST_OVERRIDE
+    void destroy() noexcept override
     {
-#if !defined( BOOST_NO_CXX11_ALLOCATOR )
-
         typedef typename std::allocator_traits<A>::template rebind_alloc< this_type > A2;
 
-#else
-
-        typedef typename A::template rebind< this_type >::other A2;
-
-#endif
-
         A2 a2( a_ );
 
         this->~this_type();
@@ -282,26 +170,22 @@ public:
         a2.deallocate( this, 1 );
     }
 
-    void * get_deleter( sp_typeinfo_ const & ti ) BOOST_SP_NOEXCEPT BOOST_OVERRIDE
+    void * get_deleter( sp_typeinfo_ const & ti ) noexcept override
     {
         return ti == BOOST_SP_TYPEID_( D )? &reinterpret_cast<char&>( d_ ): 0;
     }
 
-    void * get_local_deleter( sp_typeinfo_ const & ti ) BOOST_SP_NOEXCEPT BOOST_OVERRIDE
+    void * get_local_deleter( sp_typeinfo_ const & ti ) noexcept override
     {
         return ti == BOOST_SP_TYPEID_( D )? boost::detail::get_local_deleter( boost::addressof( d_ ) ): 0;
     }
 
-    void * get_untyped_deleter() BOOST_SP_NOEXCEPT BOOST_OVERRIDE
+    void * get_untyped_deleter() noexcept override
     {
         return &reinterpret_cast<char&>( d_ );
     }
 };
 
-#ifdef __CODEGUARD__
-# pragma option pop
-#endif
-
 } // namespace detail
 
 } // namespace boost

include/boost/smart_ptr/detail/sp_cxx20_constexpr.hpp

@@ -0,0 +1,37 @@
+#ifndef BOOST_SMART_PTR_DETAIL_SP_CXX20_CONSTEXPR_HPP_INCLUDED
+#define BOOST_SMART_PTR_DETAIL_SP_CXX20_CONSTEXPR_HPP_INCLUDED
+
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+#pragma once
+#endif
+
+//  detail/sp_noexcept.hpp
+//
+//  Copyright 2025 Mathias Stearn
+//
+//  Distributed under the Boost Software License, Version 1.0.
+//  See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt
+
+
+// This macro is used to mark functions as constexpr if the compiler supports
+// constexpr destructors. Since you can't have a constexpr smart pointer object,
+// everything except null constructors are guided behind this macro. Because
+// this also guards a use of dynamic_cast, we need to check for its availability
+// as well. It isn't worth splitting out since all known compilers that support
+// constexpr dynamic_cast also support constexpr destructors.
+//
+// WARNING: This does not check for changing active member of a union in
+// constant expressions which is allowed in C++20. If that is needed, we
+// need to raise the checked version to 202002L.
+#if defined(__cpp_constexpr_dynamic_alloc) && __cpp_constexpr_dynamic_alloc >= 201907L \
+    && defined(__cpp_constexpr) && __cpp_constexpr >= 201907L
+#define BOOST_SP_CXX20_CONSTEXPR constexpr
+#else
+#define BOOST_SP_CXX20_CONSTEXPR
+#define BOOST_SP_NO_CXX20_CONSTEXPR
+#endif
+
+#endif // #ifndef BOOST_SMART_PTR_DETAIL_SP_CXX20_CONSTEXPR_HPP_INCLUDED

include/boost/smart_ptr/detail/sp_forward.hpp

@@ -1,52 +0,0 @@
-#ifndef BOOST_SMART_PTR_DETAIL_SP_FORWARD_HPP_INCLUDED
-#define BOOST_SMART_PTR_DETAIL_SP_FORWARD_HPP_INCLUDED
-
-// MS compatible compilers support #pragma once
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-//  detail/sp_forward.hpp
-//
-//  Copyright 2008,2012 Peter Dimov
-//
-//  Distributed under the Boost Software License, Version 1.0.
-//  See accompanying file LICENSE_1_0.txt or copy at
-//  http://www.boost.org/LICENSE_1_0.txt
-
-#include <boost/config.hpp>
-
-namespace boost
-{
-
-namespace detail
-{
-
-#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
-
-#if defined( BOOST_GCC ) && __GNUC__ * 100 + __GNUC_MINOR__ <= 404
-
-// GCC 4.4 supports an outdated version of rvalue references and creates a copy of the forwarded object.
-// This results in warnings 'returning reference to temporary'. Therefore we use a special version similar to std::forward.
-template< class T > T&& sp_forward( T && t ) BOOST_NOEXCEPT
-{
-    return t;
-}
-
-#else
-
-template< class T > T&& sp_forward( T & t ) BOOST_NOEXCEPT
-{
-    return static_cast< T&& >( t );
-}
-
-#endif
-
-#endif
-
-} // namespace detail
-
-} // namespace boost
-
-#endif  // #ifndef BOOST_SMART_PTR_DETAIL_SP_FORWARD_HPP_INCLUDED

include/boost/smart_ptr/detail/sp_has_gcc_intrinsics.hpp

@@ -17,8 +17,11 @@
 // Defines the BOOST_SP_HAS_GCC_INTRINSICS macro if the __atomic_*
 // intrinsics are available.
 
+// Libraries (e.g. Kokkos) sometimes define the __ATOMIC_RELAXED macros,
+// leading to errors under MSVC (https://github.com/boostorg/smart_ptr/pull/112)
 
-#if defined( __ATOMIC_RELAXED ) && defined( __ATOMIC_ACQUIRE ) && defined( __ATOMIC_RELEASE ) && defined( __ATOMIC_ACQ_REL )
+#if defined( __ATOMIC_RELAXED ) && defined( __ATOMIC_ACQUIRE ) && defined( __ATOMIC_RELEASE ) && defined( __ATOMIC_ACQ_REL ) \
+    && !( defined(_MSC_VER) && !defined(__clang__) )
 
 # define BOOST_SP_HAS_GCC_INTRINSICS
 

include/boost/smart_ptr/detail/sp_noexcept.hpp

@@ -15,25 +15,16 @@
 //  See accompanying file LICENSE_1_0.txt or copy at
 //  http://www.boost.org/LICENSE_1_0.txt
 
-#include <boost/config.hpp>
 
-// BOOST_SP_NOEXCEPT
+// BOOST_SP_NOEXCEPT (obsolete, only retained for compatibility)
 
-#if defined( BOOST_MSVC ) && BOOST_MSVC >= 1700 && BOOST_MSVC < 1900
+#define BOOST_SP_NOEXCEPT noexcept
 
-#  define BOOST_SP_NOEXCEPT BOOST_NOEXCEPT_OR_NOTHROW
-
-#else
-
-#  define BOOST_SP_NOEXCEPT BOOST_NOEXCEPT
-
-#endif
-
-// BOOST_SP_NOEXCEPT_WITH_ASSERT
+// BOOST_SP_NOEXCEPT_WITH_ASSERT (noexcept, unless a user assertion handler is present)
 
 #if defined(BOOST_DISABLE_ASSERTS) || ( defined(BOOST_ENABLE_ASSERT_DEBUG_HANDLER) && defined(NDEBUG) )
 
-#  define BOOST_SP_NOEXCEPT_WITH_ASSERT BOOST_SP_NOEXCEPT
+#  define BOOST_SP_NOEXCEPT_WITH_ASSERT noexcept
 
 #elif defined(BOOST_ENABLE_ASSERT_HANDLER) || ( defined(BOOST_ENABLE_ASSERT_DEBUG_HANDLER) && !defined(NDEBUG) )
 
@@ -41,7 +32,7 @@
 
 #else
 
-#  define BOOST_SP_NOEXCEPT_WITH_ASSERT BOOST_SP_NOEXCEPT
+#  define BOOST_SP_NOEXCEPT_WITH_ASSERT noexcept
 
 #endif
 

include/boost/smart_ptr/detail/sp_nullptr_t.hpp

@@ -1,45 +0,0 @@
-#ifndef BOOST_SMART_PTR_DETAIL_SP_NULLPTR_T_HPP_INCLUDED
-#define BOOST_SMART_PTR_DETAIL_SP_NULLPTR_T_HPP_INCLUDED
-
-// MS compatible compilers support #pragma once
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-//  detail/sp_nullptr_t.hpp
-//
-//  Copyright 2013 Peter Dimov
-//
-//  Distributed under the Boost Software License, Version 1.0.
-//  See accompanying file LICENSE_1_0.txt or copy at
-//  http://www.boost.org/LICENSE_1_0.txt
-
-#include <boost/config.hpp>
-#include <cstddef>
-
-#if !defined( BOOST_NO_CXX11_NULLPTR )
-
-namespace boost
-{
-
-namespace detail
-{
-
-#if !defined( BOOST_NO_CXX11_DECLTYPE ) && ( ( defined( __clang__ ) && !defined( _LIBCPP_VERSION ) ) || defined( __INTEL_COMPILER ) )
-
-    typedef decltype(nullptr) sp_nullptr_t;
-
-#else
-
-    typedef std::nullptr_t sp_nullptr_t;
-
-#endif
-
-} // namespace detail
-
-} // namespace boost
-
-#endif // !defined( BOOST_NO_CXX11_NULLPTR )
-
-#endif  // #ifndef BOOST_SMART_PTR_DETAIL_SP_NULLPTR_T_HPP_INCLUDED

include/boost/smart_ptr/detail/sp_type_traits.hpp

@@ -0,0 +1,55 @@
+#ifndef BOOST_SMART_PTR_DETAIL_SP_TYPE_TRAITS_HPP_INCLUDED
+#define BOOST_SMART_PTR_DETAIL_SP_TYPE_TRAITS_HPP_INCLUDED
+
+// Copyright 2024 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <type_traits>
+
+namespace boost
+{
+namespace detail
+{
+
+// std::is_bounded_array (C++20)
+
+template<class T> struct sp_is_bounded_array: std::false_type
+{
+};
+
+template<class T, std::size_t N> struct sp_is_bounded_array< T[N] >: std::true_type
+{
+};
+
+// std::is_unbounded_array (C++20)
+
+template<class T> struct sp_is_unbounded_array: std::false_type
+{
+};
+
+template<class T> struct sp_is_unbounded_array< T[] >: std::true_type
+{
+};
+
+// std::type_identity (C++20)
+
+template<class T> struct sp_type_identity
+{
+    typedef T type;
+};
+
+// boost::type_with_alignment
+
+template<std::size_t A> struct sp_type_with_alignment
+{
+    struct alignas(A) type
+    {
+        unsigned char padding[ A ];
+    };
+};
+
+} // namespace detail
+} // namespace boost
+
+#endif  // #ifndef BOOST_SMART_PTR_DETAIL_SP_TYPE_TRAITS_HPP_INCLUDED

include/boost/smart_ptr/detail/spinlock.hpp

@@ -30,6 +30,7 @@
 
 #include <boost/smart_ptr/detail/sp_has_gcc_intrinsics.hpp>
 #include <boost/smart_ptr/detail/sp_has_sync_intrinsics.hpp>
+#include <boost/smart_ptr/detail/deprecated_macros.hpp>
 #include <boost/config.hpp>
 
 #if defined( BOOST_SP_USE_STD_ATOMIC )

include/boost/smart_ptr/detail/spinlock_std_atomic.hpp

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

include/boost/smart_ptr/enable_shared_from.hpp

@@ -11,9 +11,7 @@
 //
 //  See http://www.boost.org/libs/smart_ptr/ for documentation.
 
-#include <boost/smart_ptr/detail/requires_cxx11.hpp>
 #include <boost/smart_ptr/enable_shared_from_this.hpp>
-#include <boost/smart_ptr/detail/sp_noexcept.hpp>
 
 namespace boost
 {
@@ -32,7 +30,7 @@ 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
+template<class T> weak_ptr<T> weak_from( T * p ) noexcept
 {
     return weak_ptr<T>( p->enable_shared_from_this<enable_shared_from>::weak_from_this(), p );
 }

include/boost/smart_ptr/enable_shared_from_raw.hpp

@@ -71,15 +71,12 @@ private:
         }
     }
 
-#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
-public:
-#else
 private:
+
     template<class Y> friend class shared_ptr;
     template<typename T> friend boost::shared_ptr<T> shared_from_raw(T *);
     template<typename T> friend boost::weak_ptr<T> weak_from_raw(T *);
     template< class X, class Y > friend inline void detail::sp_enable_shared_from_this( boost::shared_ptr<X> * ppx, Y const * py, boost::enable_shared_from_raw const * pe );
-#endif
 
     shared_ptr<void const volatile> shared_from_this() const
     {

include/boost/smart_ptr/enable_shared_from_this.hpp

@@ -13,12 +13,9 @@
 //  See http://www.boost.org/libs/smart_ptr/ for documentation.
 //
 
-#include <boost/smart_ptr/detail/requires_cxx11.hpp>
 #include <boost/smart_ptr/weak_ptr.hpp>
 #include <boost/smart_ptr/shared_ptr.hpp>
-#include <boost/smart_ptr/detail/sp_noexcept.hpp>
 #include <boost/assert.hpp>
-#include <boost/config.hpp>
 
 namespace boost
 {
@@ -27,20 +24,20 @@ template<class T> class enable_shared_from_this
 {
 protected:
 
-    BOOST_CONSTEXPR enable_shared_from_this() BOOST_SP_NOEXCEPT
+    constexpr enable_shared_from_this() noexcept
     {
     }
 
-    BOOST_CONSTEXPR enable_shared_from_this(enable_shared_from_this const &) BOOST_SP_NOEXCEPT
+    constexpr enable_shared_from_this(enable_shared_from_this const &) noexcept
     {
     }
 
-    enable_shared_from_this & operator=(enable_shared_from_this const &) BOOST_SP_NOEXCEPT
+    enable_shared_from_this & operator=(enable_shared_from_this const &) noexcept
     {
         return *this;
     }
 
-    ~enable_shared_from_this() BOOST_SP_NOEXCEPT // ~weak_ptr<T> newer throws, so this call also must not throw
+    ~enable_shared_from_this() noexcept // ~weak_ptr<T> newer throws, so this call also must not throw
     {
     }
 
@@ -60,12 +57,12 @@ public:
         return p;
     }
 
-    weak_ptr<T> weak_from_this() BOOST_SP_NOEXCEPT
+    weak_ptr<T> weak_from_this() noexcept
     {
         return weak_this_;
     }
 
-    weak_ptr<T const> weak_from_this() const BOOST_SP_NOEXCEPT
+    weak_ptr<T const> weak_from_this() const noexcept
     {
         return weak_this_;
     }
@@ -73,7 +70,7 @@ public:
 public: // actually private, but avoids compiler template friendship issues
 
     // Note: invoked automatically by shared_ptr; do not call
-    template<class X, class Y> void _internal_accept_owner( shared_ptr<X> const * ppx, Y * py ) const BOOST_SP_NOEXCEPT
+    template<class X, class Y> void _internal_accept_owner( shared_ptr<X> const * ppx, Y * py ) const noexcept
     {
         if( weak_this_.expired() )
         {

include/boost/smart_ptr/intrusive_ptr.hpp

@@ -13,26 +13,14 @@
 //  See http://www.boost.org/libs/smart_ptr/ for documentation.
 //
 
-#include <boost/smart_ptr/detail/requires_cxx11.hpp>
-
-#include <boost/config.hpp>
-
-#include <boost/assert.hpp>
-#include <boost/config/workaround.hpp>
+#include <boost/smart_ptr/detail/sp_cxx20_constexpr.hpp>
 #include <boost/smart_ptr/detail/sp_convertible.hpp>
-#include <boost/smart_ptr/detail/sp_nullptr_t.hpp>
 #include <boost/smart_ptr/detail/sp_noexcept.hpp>
+#include <boost/assert.hpp>
 
-#include <boost/config/no_tr1/functional.hpp>           // for std::less
-
-#if !defined(BOOST_NO_IOSTREAM)
-#if !defined(BOOST_NO_IOSFWD)
+#include <functional>           // for std::less
 #include <iosfwd>               // for std::basic_ostream
-#else
-#include <ostream>
-#endif
-#endif
-
+#include <cstddef>
 
 namespace boost
 {
@@ -62,64 +50,46 @@ public:
 
     typedef T element_type;
 
-    BOOST_CONSTEXPR intrusive_ptr() BOOST_SP_NOEXCEPT : px( 0 )
+    constexpr intrusive_ptr() noexcept : px( 0 )
     {
     }
 
-    intrusive_ptr( T * p, bool add_ref = true ): px( p )
+    BOOST_SP_CXX20_CONSTEXPR intrusive_ptr( T * p, bool add_ref = true ): px( p )
     {
         if( px != 0 && add_ref ) intrusive_ptr_add_ref( px );
     }
 
-#if !defined(BOOST_NO_MEMBER_TEMPLATES) || defined(BOOST_MSVC6_MEMBER_TEMPLATES)
-
     template<class U>
-#if !defined( BOOST_SP_NO_SP_CONVERTIBLE )
-
-    intrusive_ptr( intrusive_ptr<U> const & rhs, typename boost::detail::sp_enable_if_convertible<U,T>::type = boost::detail::sp_empty() )
-
-#else
-
-    intrusive_ptr( intrusive_ptr<U> const & rhs )
-
-#endif
+    BOOST_SP_CXX20_CONSTEXPR intrusive_ptr( intrusive_ptr<U> const & rhs, typename boost::detail::sp_enable_if_convertible<U,T>::type = boost::detail::sp_empty() )
     : px( rhs.get() )
     {
         if( px != 0 ) intrusive_ptr_add_ref( px );
     }
 
-#endif
-
-    intrusive_ptr(intrusive_ptr const & rhs): px( rhs.px )
+    BOOST_SP_CXX20_CONSTEXPR intrusive_ptr(intrusive_ptr const & rhs): px( rhs.px )
     {
         if( px != 0 ) intrusive_ptr_add_ref( px );
     }
 
-    ~intrusive_ptr()
+    BOOST_SP_CXX20_CONSTEXPR ~intrusive_ptr()
     {
         if( px != 0 ) intrusive_ptr_release( px );
     }
 
-#if !defined(BOOST_NO_MEMBER_TEMPLATES) || defined(BOOST_MSVC6_MEMBER_TEMPLATES)
-
-    template<class U> intrusive_ptr & operator=(intrusive_ptr<U> const & rhs)
+    template<class U> BOOST_SP_CXX20_CONSTEXPR intrusive_ptr & operator=(intrusive_ptr<U> const & rhs)
     {
         this_type(rhs).swap(*this);
         return *this;
     }
 
-#endif
-
 // Move support
 
-#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
-
-    intrusive_ptr(intrusive_ptr && rhs) BOOST_SP_NOEXCEPT : px( rhs.px )
+    BOOST_SP_CXX20_CONSTEXPR intrusive_ptr(intrusive_ptr && rhs) noexcept : px( rhs.px )
     {
         rhs.px = 0;
     }
 
-    intrusive_ptr & operator=(intrusive_ptr && rhs) BOOST_SP_NOEXCEPT
+    BOOST_SP_CXX20_CONSTEXPR intrusive_ptr & operator=(intrusive_ptr && rhs) noexcept
     {
         this_type( static_cast< intrusive_ptr && >( rhs ) ).swap(*this);
         return *this;
@@ -128,84 +98,76 @@ public:
     template<class U> friend class intrusive_ptr;
 
     template<class U>
-#if !defined( BOOST_SP_NO_SP_CONVERTIBLE )
-
-    intrusive_ptr(intrusive_ptr<U> && rhs, typename boost::detail::sp_enable_if_convertible<U,T>::type = boost::detail::sp_empty())
-
-#else
-
-    intrusive_ptr(intrusive_ptr<U> && rhs)
-
-#endif        
+    BOOST_SP_CXX20_CONSTEXPR intrusive_ptr(intrusive_ptr<U> && rhs, typename boost::detail::sp_enable_if_convertible<U,T>::type = boost::detail::sp_empty())
     : px( rhs.px )
     {
         rhs.px = 0;
     }
 
     template<class U>
-    intrusive_ptr & operator=(intrusive_ptr<U> && rhs) BOOST_SP_NOEXCEPT
+    BOOST_SP_CXX20_CONSTEXPR intrusive_ptr & operator=(intrusive_ptr<U> && rhs) noexcept
     {
         this_type( static_cast< intrusive_ptr<U> && >( rhs ) ).swap(*this);
         return *this;
     }
 
-#endif
-
-    intrusive_ptr & operator=(intrusive_ptr const & rhs)
+    BOOST_SP_CXX20_CONSTEXPR intrusive_ptr & operator=(intrusive_ptr const & rhs)
     {
         this_type(rhs).swap(*this);
         return *this;
     }
 
-    intrusive_ptr & operator=(T * rhs)
+    BOOST_SP_CXX20_CONSTEXPR intrusive_ptr & operator=(T * rhs)
     {
         this_type(rhs).swap(*this);
         return *this;
     }
 
-    void reset()
+    BOOST_SP_CXX20_CONSTEXPR void reset()
     {
         this_type().swap( *this );
     }
 
-    void reset( T * rhs )
+    BOOST_SP_CXX20_CONSTEXPR void reset( T * rhs )
     {
         this_type( rhs ).swap( *this );
     }
 
-    void reset( T * rhs, bool add_ref )
+    BOOST_SP_CXX20_CONSTEXPR void reset( T * rhs, bool add_ref )
     {
         this_type( rhs, add_ref ).swap( *this );
     }
 
-    T * get() const BOOST_SP_NOEXCEPT
+    BOOST_SP_CXX20_CONSTEXPR T * get() const noexcept
     {
         return px;
     }
 
-    T * detach() BOOST_SP_NOEXCEPT
+    BOOST_SP_CXX20_CONSTEXPR T * detach() noexcept
     {
         T * ret = px;
         px = 0;
         return ret;
     }
 
-    T & operator*() const BOOST_SP_NOEXCEPT_WITH_ASSERT
+    BOOST_SP_CXX20_CONSTEXPR T & operator*() const BOOST_SP_NOEXCEPT_WITH_ASSERT
     {
         BOOST_ASSERT( px != 0 );
         return *px;
     }
 
-    T * operator->() const BOOST_SP_NOEXCEPT_WITH_ASSERT
+    BOOST_SP_CXX20_CONSTEXPR T * operator->() const BOOST_SP_NOEXCEPT_WITH_ASSERT
     {
         BOOST_ASSERT( px != 0 );
         return px;
     }
 
-// implicit conversion to "bool"
-#include <boost/smart_ptr/detail/operator_bool.hpp>
+    BOOST_SP_CXX20_CONSTEXPR explicit operator bool () const noexcept
+    {
+        return px != 0;
+    }
 
-    void swap(intrusive_ptr & rhs) BOOST_SP_NOEXCEPT
+    BOOST_SP_CXX20_CONSTEXPR void swap(intrusive_ptr & rhs) noexcept
     {
         T * tmp = px;
         px = rhs.px;
@@ -217,118 +179,101 @@ private:
     T * px;
 };
 
-template<class T, class U> inline bool operator==(intrusive_ptr<T> const & a, intrusive_ptr<U> const & b) BOOST_SP_NOEXCEPT
+template<class T, class U> BOOST_SP_CXX20_CONSTEXPR inline bool operator==(intrusive_ptr<T> const & a, intrusive_ptr<U> const & b) noexcept
 {
     return a.get() == b.get();
 }
 
-template<class T, class U> inline bool operator!=(intrusive_ptr<T> const & a, intrusive_ptr<U> const & b) BOOST_SP_NOEXCEPT
+template<class T, class U> BOOST_SP_CXX20_CONSTEXPR inline bool operator!=(intrusive_ptr<T> const & a, intrusive_ptr<U> const & b) noexcept
 {
     return a.get() != b.get();
 }
 
-template<class T, class U> inline bool operator==(intrusive_ptr<T> const & a, U * b) BOOST_SP_NOEXCEPT
+template<class T, class U> BOOST_SP_CXX20_CONSTEXPR inline bool operator==(intrusive_ptr<T> const & a, U * b) noexcept
 {
     return a.get() == b;
 }
 
-template<class T, class U> inline bool operator!=(intrusive_ptr<T> const & a, U * b) BOOST_SP_NOEXCEPT
+template<class T, class U> BOOST_SP_CXX20_CONSTEXPR inline bool operator!=(intrusive_ptr<T> const & a, U * b) noexcept
 {
     return a.get() != b;
 }
 
-template<class T, class U> inline bool operator==(T * a, intrusive_ptr<U> const & b) BOOST_SP_NOEXCEPT
+template<class T, class U> BOOST_SP_CXX20_CONSTEXPR inline bool operator==(T * a, intrusive_ptr<U> const & b) noexcept
 {
     return a == b.get();
 }
 
-template<class T, class U> inline bool operator!=(T * a, intrusive_ptr<U> const & b) BOOST_SP_NOEXCEPT
+template<class T, class U> BOOST_SP_CXX20_CONSTEXPR inline bool operator!=(T * a, intrusive_ptr<U> const & b) noexcept
 {
     return a != b.get();
 }
 
-#if defined(__GNUC__) && __GNUC__ == 2 && __GNUC_MINOR__ <= 96
-
-// Resolve the ambiguity between our op!= and the one in rel_ops
-
-template<class T> inline bool operator!=(intrusive_ptr<T> const & a, intrusive_ptr<T> const & b) BOOST_SP_NOEXCEPT
-{
-    return a.get() != b.get();
-}
-
-#endif
-
-#if !defined( BOOST_NO_CXX11_NULLPTR )
-
-template<class T> inline bool operator==( intrusive_ptr<T> const & p, boost::detail::sp_nullptr_t ) BOOST_SP_NOEXCEPT
+template<class T> BOOST_SP_CXX20_CONSTEXPR inline bool operator==( intrusive_ptr<T> const & p, std::nullptr_t ) noexcept
 {
     return p.get() == 0;
 }
 
-template<class T> inline bool operator==( boost::detail::sp_nullptr_t, intrusive_ptr<T> const & p ) BOOST_SP_NOEXCEPT
+template<class T> BOOST_SP_CXX20_CONSTEXPR inline bool operator==( std::nullptr_t, intrusive_ptr<T> const & p ) noexcept
 {
     return p.get() == 0;
 }
 
-template<class T> inline bool operator!=( intrusive_ptr<T> const & p, boost::detail::sp_nullptr_t ) BOOST_SP_NOEXCEPT
+template<class T> BOOST_SP_CXX20_CONSTEXPR inline bool operator!=( intrusive_ptr<T> const & p, std::nullptr_t ) noexcept
 {
     return p.get() != 0;
 }
 
-template<class T> inline bool operator!=( boost::detail::sp_nullptr_t, intrusive_ptr<T> const & p ) BOOST_SP_NOEXCEPT
+template<class T> BOOST_SP_CXX20_CONSTEXPR inline bool operator!=( std::nullptr_t, intrusive_ptr<T> const & p ) noexcept
 {
     return p.get() != 0;
 }
 
-#endif
-
-template<class T> inline bool operator<(intrusive_ptr<T> const & a, intrusive_ptr<T> const & b) BOOST_SP_NOEXCEPT
+template<class T> BOOST_SP_CXX20_CONSTEXPR inline bool operator<(intrusive_ptr<T> const & a, intrusive_ptr<T> const & b) noexcept
 {
     return std::less<T *>()(a.get(), b.get());
 }
 
-template<class T> void swap(intrusive_ptr<T> & lhs, intrusive_ptr<T> & rhs) BOOST_SP_NOEXCEPT
+template<class T> BOOST_SP_CXX20_CONSTEXPR inline void swap(intrusive_ptr<T> & lhs, intrusive_ptr<T> & rhs) noexcept
 {
     lhs.swap(rhs);
 }
 
 // mem_fn support
 
-template<class T> T * get_pointer(intrusive_ptr<T> const & p) BOOST_SP_NOEXCEPT
+template<class T> BOOST_SP_CXX20_CONSTEXPR inline T * get_pointer(intrusive_ptr<T> const & p) noexcept
 {
     return p.get();
 }
 
 // pointer casts
 
-template<class T, class U> intrusive_ptr<T> static_pointer_cast(intrusive_ptr<U> const & p)
+template<class T, class U> BOOST_SP_CXX20_CONSTEXPR inline intrusive_ptr<T> static_pointer_cast(intrusive_ptr<U> const & p)
 {
     return static_cast<T *>(p.get());
 }
 
-template<class T, class U> intrusive_ptr<T> const_pointer_cast(intrusive_ptr<U> const & p)
+template<class T, class U> BOOST_SP_CXX20_CONSTEXPR inline intrusive_ptr<T> const_pointer_cast(intrusive_ptr<U> const & p)
 {
     return const_cast<T *>(p.get());
 }
 
-template<class T, class U> intrusive_ptr<T> dynamic_pointer_cast(intrusive_ptr<U> const & p)
+template<class T, class U> BOOST_SP_CXX20_CONSTEXPR inline intrusive_ptr<T> dynamic_pointer_cast(intrusive_ptr<U> const & p)
 {
     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
+template<class T, class U> BOOST_SP_CXX20_CONSTEXPR inline intrusive_ptr<T> static_pointer_cast( intrusive_ptr<U> && p ) 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
+template<class T, class U> BOOST_SP_CXX20_CONSTEXPR inline intrusive_ptr<T> const_pointer_cast( intrusive_ptr<U> && p ) 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
+template<class T, class U> BOOST_SP_CXX20_CONSTEXPR inline intrusive_ptr<T> dynamic_pointer_cast( intrusive_ptr<U> && p ) noexcept
 {
     T * p2 = dynamic_cast<T*>( p.get() );
 
@@ -339,48 +284,19 @@ template<class T, class U> intrusive_ptr<T> dynamic_pointer_cast( intrusive_ptr<
     return r;
 }
 
-#endif // defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
-
 // operator<<
 
-#if !defined(BOOST_NO_IOSTREAM)
-
-#if defined(BOOST_NO_TEMPLATED_IOSTREAMS) || ( defined(__GNUC__) &&  (__GNUC__ < 3) )
-
-template<class Y> std::ostream & operator<< (std::ostream & os, intrusive_ptr<Y> const & p)
-{
-    os << p.get();
-    return os;
-}
-
-#else
-
-// in STLport's no-iostreams mode no iostream symbols can be used
-#ifndef _STLP_NO_IOSTREAMS
-
-# if defined(BOOST_MSVC) && BOOST_WORKAROUND(BOOST_MSVC, < 1300 && __SGI_STL_PORT)
-// MSVC6 has problems finding std::basic_ostream through the using declaration in namespace _STL
-using std::basic_ostream;
-template<class E, class T, class Y> basic_ostream<E, T> & operator<< (basic_ostream<E, T> & os, intrusive_ptr<Y> const & p)
-# else
 template<class E, class T, class Y> std::basic_ostream<E, T> & operator<< (std::basic_ostream<E, T> & os, intrusive_ptr<Y> const & p)
-# endif 
 {
     os << p.get();
     return os;
 }
 
-#endif // _STLP_NO_IOSTREAMS
-
-#endif // __GNUC__ < 3
-
-#endif // !defined(BOOST_NO_IOSTREAM)
-
 // hash_value
 
 template< class T > struct hash;
 
-template< class T > std::size_t hash_value( boost::intrusive_ptr<T> const & p ) BOOST_SP_NOEXCEPT
+template< class T > std::size_t hash_value( boost::intrusive_ptr<T> const & p ) noexcept
 {
     return boost::hash< T* >()( p.get() );
 }
@@ -389,14 +305,12 @@ template< class T > std::size_t hash_value( boost::intrusive_ptr<T> const & p )
 
 // 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
+    std::size_t operator()( ::boost::intrusive_ptr<T> const & p ) const noexcept
     {
         return std::hash< T* >()( p.get() );
     }
@@ -404,6 +318,4 @@ template<class T> struct hash< ::boost::intrusive_ptr<T> >
 
 } // namespace std
 
-#endif // #if !defined(BOOST_NO_CXX11_HDR_FUNCTIONAL)
-
 #endif  // #ifndef BOOST_SMART_PTR_INTRUSIVE_PTR_HPP_INCLUDED

include/boost/smart_ptr/intrusive_ref_counter.hpp

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

include/boost/smart_ptr/local_shared_ptr.hpp

@@ -11,8 +11,9 @@
 //
 //  See http://www.boost.org/libs/smart_ptr/ for documentation.
 
-#include <boost/smart_ptr/detail/requires_cxx11.hpp>
 #include <boost/smart_ptr/shared_ptr.hpp>
+#include <boost/smart_ptr/detail/sp_noexcept.hpp>
+#include <boost/assert.hpp>
 
 namespace boost
 {
@@ -127,7 +128,7 @@ public:
 
     // destructor
 
-    ~local_shared_ptr() BOOST_SP_NOEXCEPT
+    ~local_shared_ptr() noexcept
     {
         if( pn )
         {
@@ -137,20 +138,16 @@ public:
 
     // constructors
 
-    BOOST_CONSTEXPR local_shared_ptr() BOOST_SP_NOEXCEPT : px( 0 ), pn( 0 )
+    constexpr local_shared_ptr() noexcept : px( 0 ), pn( 0 )
     {
     }
 
-#if !defined( BOOST_NO_CXX11_NULLPTR )
-
-    BOOST_CONSTEXPR local_shared_ptr( boost::detail::sp_nullptr_t ) BOOST_SP_NOEXCEPT : px( 0 ), pn( 0 )
+    constexpr local_shared_ptr( std::nullptr_t ) noexcept : px( 0 ), pn( 0 )
     {
     }
 
-#endif
-
     // internal constructor, used by make_shared
-    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_ )
+    constexpr local_shared_ptr( boost::detail::lsp_internal_constructor_tag, element_type * px_, boost::detail::local_counted_base * pn_ ) noexcept : px( px_ ), pn( pn_ )
     {
     }
 
@@ -165,29 +162,21 @@ public:
         boost::detail::lsp_deleter_construct( this, p, d, pn );
     }
 
-#if !defined( BOOST_NO_CXX11_NULLPTR )
-
-    template<class D> local_shared_ptr( boost::detail::sp_nullptr_t p, D d ): px( p ), pn( 0 )
+    template<class D> local_shared_ptr( std::nullptr_t p, D d ): px( p ), pn( 0 )
     {
         boost::detail::lsp_deleter_construct( this, p, d, pn );
     }
 
-#endif
-
     template<class Y, class D, class A> local_shared_ptr( Y * p, D d, A a ): px( p ), pn( 0 )
     {
         boost::detail::lsp_allocator_construct( this, p, d, a, pn );
     }
 
-#if !defined( BOOST_NO_CXX11_NULLPTR )
-
-    template<class D, class A> local_shared_ptr( boost::detail::sp_nullptr_t p, D d, A a ): px( p ), pn( 0 )
+    template<class D, class A> local_shared_ptr( std::nullptr_t p, D d, A a ): px( p ), pn( 0 )
     {
         boost::detail::lsp_allocator_construct( this, p, d, a, pn );
     }
 
-#endif
-
     // construction from shared_ptr
 
     template<class Y> local_shared_ptr( shared_ptr<Y> const & r,
@@ -202,8 +191,6 @@ public:
         }
     }
 
-#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
-
     template<class Y> local_shared_ptr( shared_ptr<Y> && r,
         typename boost::detail::sp_enable_if_convertible<Y, T>::type = boost::detail::sp_empty() )
         : px( r.get() ), pn( 0 )
@@ -217,12 +204,8 @@ public:
         }
     }
 
-#endif
-
     // construction from unique_ptr
 
-#if !defined( BOOST_NO_CXX11_SMART_PTR ) && !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
-
     template< class Y, class D >
     local_shared_ptr( std::unique_ptr< Y, D > && r,
         typename boost::detail::sp_enable_if_convertible<Y, T>::type = boost::detail::sp_empty() )
@@ -236,8 +219,6 @@ public:
         }
     }
 
-#endif
-
     template< class Y, class D >
     local_shared_ptr( boost::movelib::unique_ptr< Y, D > r ); // !
     //  : px( r.get() ), pn( new boost::detail::local_counted_impl( shared_ptr<T>( std::move(r) ) ) )
@@ -247,7 +228,7 @@ public:
 
     // copy constructor
 
-    local_shared_ptr( local_shared_ptr const & r ) BOOST_SP_NOEXCEPT : px( r.px ), pn( r.pn )
+    local_shared_ptr( local_shared_ptr const & r ) noexcept : px( r.px ), pn( r.pn )
     {
         if( pn )
         {
@@ -257,20 +238,16 @@ public:
 
     // move constructor
 
-#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
-
-    local_shared_ptr( local_shared_ptr && r ) BOOST_SP_NOEXCEPT : px( r.px ), pn( r.pn )
+    local_shared_ptr( local_shared_ptr && r ) noexcept : px( r.px ), pn( r.pn )
     {
         r.px = 0;
         r.pn = 0;
     }
 
-#endif
-
     // converting copy constructor
 
     template<class Y> local_shared_ptr( local_shared_ptr<Y> const & r,
-        typename boost::detail::sp_enable_if_convertible<Y, T>::type = boost::detail::sp_empty() ) BOOST_SP_NOEXCEPT
+        typename boost::detail::sp_enable_if_convertible<Y, T>::type = boost::detail::sp_empty() ) noexcept
         : px( r.px ), pn( r.pn )
     {
         boost::detail::sp_assert_convertible< Y, T >();
@@ -283,10 +260,8 @@ public:
 
     // converting move constructor
 
-#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
-
     template<class Y> local_shared_ptr( local_shared_ptr<Y> && r,
-        typename boost::detail::sp_enable_if_convertible<Y, T>::type = boost::detail::sp_empty() ) BOOST_SP_NOEXCEPT
+        typename boost::detail::sp_enable_if_convertible<Y, T>::type = boost::detail::sp_empty() ) noexcept
         : px( r.px ), pn( r.pn )
     {
         boost::detail::sp_assert_convertible< Y, T >();
@@ -295,12 +270,10 @@ public:
         r.pn = 0;
     }
 
-#endif
-
     // aliasing
 
     template<class Y>
-    local_shared_ptr( local_shared_ptr<Y> const & r, element_type * p ) BOOST_SP_NOEXCEPT : px( p ), pn( r.pn )
+    local_shared_ptr( local_shared_ptr<Y> const & r, element_type * p ) noexcept : px( p ), pn( r.pn )
     {
         if( pn )
         {
@@ -308,60 +281,46 @@ public:
         }
     }
 
-#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
-
     template<class Y>
-    local_shared_ptr( local_shared_ptr<Y> && r, element_type * p ) BOOST_SP_NOEXCEPT : px( p ), pn( r.pn )
+    local_shared_ptr( local_shared_ptr<Y> && r, element_type * p ) noexcept : px( p ), pn( r.pn )
     {
         r.px = 0;
         r.pn = 0;
     }
 
-#endif
-
     // assignment
 
-    local_shared_ptr & operator=( local_shared_ptr const & r ) BOOST_SP_NOEXCEPT
+    local_shared_ptr & operator=( local_shared_ptr const & r ) noexcept
     {
         local_shared_ptr( r ).swap( *this );
         return *this;
     }
 
-    template<class Y> local_shared_ptr & operator=( local_shared_ptr<Y> const & r ) BOOST_SP_NOEXCEPT
+    template<class Y> local_shared_ptr & operator=( local_shared_ptr<Y> const & r ) noexcept
     {
         local_shared_ptr( r ).swap( *this );
         return *this;
     }
 
-#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
-
-    local_shared_ptr & operator=( local_shared_ptr && r ) BOOST_SP_NOEXCEPT
+    local_shared_ptr & operator=( local_shared_ptr && r ) noexcept
     {
         local_shared_ptr( std::move( r ) ).swap( *this );
         return *this;
     }
 
     template<class Y>
-    local_shared_ptr & operator=( local_shared_ptr<Y> && r ) BOOST_SP_NOEXCEPT
+    local_shared_ptr & operator=( local_shared_ptr<Y> && r ) noexcept
     {
         local_shared_ptr( std::move( r ) ).swap( *this );
         return *this;
     }
 
-#endif
-
-#if !defined( BOOST_NO_CXX11_NULLPTR )
-
-    local_shared_ptr & operator=( boost::detail::sp_nullptr_t ) BOOST_SP_NOEXCEPT
+    local_shared_ptr & operator=( std::nullptr_t ) noexcept
     {
         local_shared_ptr().swap(*this);
         return *this;
     }
 
-#endif
-
-#if !defined( BOOST_NO_CXX11_SMART_PTR ) && !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
-
     template<class Y, class D>
     local_shared_ptr & operator=( std::unique_ptr<Y, D> && r )
     {
@@ -369,14 +328,12 @@ public:
         return *this;
     }
 
-#endif
-
     template<class Y, class D>
     local_shared_ptr & operator=( boost::movelib::unique_ptr<Y, D> r ); // !
 
     // reset
 
-    void reset() BOOST_SP_NOEXCEPT
+    void reset() noexcept
     {
         local_shared_ptr().swap( *this );
     }
@@ -396,28 +353,24 @@ public:
         local_shared_ptr( p, d, a ).swap( *this );
     }
 
-    template<class Y> void reset( local_shared_ptr<Y> const & r, element_type * p ) BOOST_SP_NOEXCEPT
+    template<class Y> void reset( local_shared_ptr<Y> const & r, element_type * p ) noexcept
     {
         local_shared_ptr( r, p ).swap( *this );
     }
 
-#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
-
-    template<class Y> void reset( local_shared_ptr<Y> && r, element_type * p ) BOOST_SP_NOEXCEPT
+    template<class Y> void reset( local_shared_ptr<Y> && r, element_type * p ) noexcept
     {
         local_shared_ptr( std::move( r ), p ).swap( *this );
     }
 
-#endif
-
     // accessors
 
-    typename boost::detail::sp_dereference< T >::type operator* () const BOOST_SP_NOEXCEPT
+    typename boost::detail::sp_dereference< T >::type operator* () const noexcept
     {
         return *px;
     }
 
-    typename boost::detail::sp_member_access< T >::type operator-> () const BOOST_SP_NOEXCEPT
+    typename boost::detail::sp_member_access< T >::type operator-> () const noexcept
     {
         return px;
     }
@@ -430,26 +383,24 @@ public:
         return static_cast< typename boost::detail::sp_array_access< T >::type >( px[ i ] );
     }
 
-    element_type * get() const BOOST_SP_NOEXCEPT
+    element_type * get() const noexcept
     {
         return px;
     }
 
-    // implicit conversion to "bool"
-#include <boost/smart_ptr/detail/operator_bool.hpp>
+    explicit operator bool () const noexcept
+    {
+        return px != 0;
+    }
 
-    long local_use_count() const BOOST_SP_NOEXCEPT
+    long local_use_count() const noexcept
     {
         return pn? pn->local_use_count(): 0;
     }
 
     // conversions to shared_ptr, weak_ptr
 
-#if !defined( BOOST_SP_NO_SP_CONVERTIBLE ) && !defined(BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS)
-    template<class Y, class E = typename boost::detail::sp_enable_if_convertible<T,Y>::type> operator shared_ptr<Y>() const BOOST_SP_NOEXCEPT
-#else
-    template<class Y> operator shared_ptr<Y>() const BOOST_SP_NOEXCEPT
-#endif
+    template<class Y, class E = typename boost::detail::sp_enable_if_convertible<T,Y>::type> operator shared_ptr<Y>() const noexcept
     {
         boost::detail::sp_assert_convertible<T, Y>();
 
@@ -463,11 +414,7 @@ public:
         }
     }
 
-#if !defined( BOOST_SP_NO_SP_CONVERTIBLE ) && !defined(BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS)
-    template<class Y, class E = typename boost::detail::sp_enable_if_convertible<T,Y>::type> operator weak_ptr<Y>() const BOOST_SP_NOEXCEPT
-#else
-    template<class Y> operator weak_ptr<Y>() const BOOST_SP_NOEXCEPT
-#endif
+    template<class Y, class E = typename boost::detail::sp_enable_if_convertible<T,Y>::type> operator weak_ptr<Y>() const noexcept
     {
         boost::detail::sp_assert_convertible<T, Y>();
 
@@ -483,7 +430,7 @@ public:
 
     // swap
 
-    void swap( local_shared_ptr & r ) BOOST_SP_NOEXCEPT
+    void swap( local_shared_ptr & r ) noexcept
     {
         std::swap( px, r.px );
         std::swap( pn, r.pn );
@@ -491,84 +438,80 @@ public:
 
     // owner_before
 
-    template<class Y> bool owner_before( local_shared_ptr<Y> const & r ) const BOOST_SP_NOEXCEPT
+    template<class Y> bool owner_before( local_shared_ptr<Y> const & r ) const noexcept
     {
         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
+    template<class Y> bool owner_equals( local_shared_ptr<Y> const & r ) const 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
+template<class T, class U> inline bool operator==( local_shared_ptr<T> const & a, local_shared_ptr<U> const & b ) noexcept
 {
     return a.get() == b.get();
 }
 
-template<class T, class U> inline bool operator!=( local_shared_ptr<T> const & a, local_shared_ptr<U> const & b ) BOOST_SP_NOEXCEPT
+template<class T, class U> inline bool operator!=( local_shared_ptr<T> const & a, local_shared_ptr<U> const & b ) noexcept
 {
     return a.get() != b.get();
 }
 
-#if !defined( BOOST_NO_CXX11_NULLPTR )
-
-template<class T> inline bool operator==( local_shared_ptr<T> const & p, boost::detail::sp_nullptr_t ) BOOST_SP_NOEXCEPT
+template<class T> inline bool operator==( local_shared_ptr<T> const & p, std::nullptr_t ) noexcept
 {
     return p.get() == 0;
 }
 
-template<class T> inline bool operator==( boost::detail::sp_nullptr_t, local_shared_ptr<T> const & p ) BOOST_SP_NOEXCEPT
+template<class T> inline bool operator==( std::nullptr_t, local_shared_ptr<T> const & p ) noexcept
 {
     return p.get() == 0;
 }
 
-template<class T> inline bool operator!=( local_shared_ptr<T> const & p, boost::detail::sp_nullptr_t ) BOOST_SP_NOEXCEPT
+template<class T> inline bool operator!=( local_shared_ptr<T> const & p, std::nullptr_t ) noexcept
 {
     return p.get() != 0;
 }
 
-template<class T> inline bool operator!=( boost::detail::sp_nullptr_t, local_shared_ptr<T> const & p ) BOOST_SP_NOEXCEPT
+template<class T> inline bool operator!=( std::nullptr_t, local_shared_ptr<T> const & p ) noexcept
 {
     return p.get() != 0;
 }
 
-#endif
-
-template<class T, class U> inline bool operator==( local_shared_ptr<T> const & a, shared_ptr<U> const & b ) BOOST_SP_NOEXCEPT
+template<class T, class U> inline bool operator==( local_shared_ptr<T> const & a, shared_ptr<U> const & b ) noexcept
 {
     return a.get() == b.get();
 }
 
-template<class T, class U> inline bool operator!=( local_shared_ptr<T> const & a, shared_ptr<U> const & b ) BOOST_SP_NOEXCEPT
+template<class T, class U> inline bool operator!=( local_shared_ptr<T> const & a, shared_ptr<U> const & b ) noexcept
 {
     return a.get() != b.get();
 }
 
-template<class T, class U> inline bool operator==( shared_ptr<T> const & a, local_shared_ptr<U> const & b ) BOOST_SP_NOEXCEPT
+template<class T, class U> inline bool operator==( shared_ptr<T> const & a, local_shared_ptr<U> const & b ) noexcept
 {
     return a.get() == b.get();
 }
 
-template<class T, class U> inline bool operator!=( shared_ptr<T> const & a, local_shared_ptr<U> const & b ) BOOST_SP_NOEXCEPT
+template<class T, class U> inline bool operator!=( shared_ptr<T> const & a, local_shared_ptr<U> const & b ) noexcept
 {
     return a.get() != b.get();
 }
 
-template<class T, class U> inline bool operator<(local_shared_ptr<T> const & a, local_shared_ptr<U> const & b) BOOST_SP_NOEXCEPT
+template<class T, class U> inline bool operator<(local_shared_ptr<T> const & a, local_shared_ptr<U> const & b) noexcept
 {
     return a.owner_before( b );
 }
 
-template<class T> inline void swap( local_shared_ptr<T> & a, local_shared_ptr<T> & b ) BOOST_SP_NOEXCEPT
+template<class T> inline void swap( local_shared_ptr<T> & a, local_shared_ptr<T> & b ) noexcept
 {
     a.swap( b );
 }
 
-template<class T, class U> local_shared_ptr<T> static_pointer_cast( local_shared_ptr<U> const & r ) BOOST_SP_NOEXCEPT
+template<class T, class U> local_shared_ptr<T> static_pointer_cast( local_shared_ptr<U> const & r ) noexcept
 {
     (void) static_cast< T* >( static_cast< U* >( 0 ) );
 
@@ -578,7 +521,7 @@ template<class T, class U> local_shared_ptr<T> static_pointer_cast( local_shared
     return local_shared_ptr<T>( r, p );
 }
 
-template<class T, class U> local_shared_ptr<T> const_pointer_cast( local_shared_ptr<U> const & r ) BOOST_SP_NOEXCEPT
+template<class T, class U> local_shared_ptr<T> const_pointer_cast( local_shared_ptr<U> const & r ) noexcept
 {
     (void) const_cast< T* >( static_cast< U* >( 0 ) );
 
@@ -588,7 +531,7 @@ template<class T, class U> local_shared_ptr<T> const_pointer_cast( local_shared_
     return local_shared_ptr<T>( r, p );
 }
 
-template<class T, class U> local_shared_ptr<T> dynamic_pointer_cast( local_shared_ptr<U> const & r ) BOOST_SP_NOEXCEPT
+template<class T, class U> local_shared_ptr<T> dynamic_pointer_cast( local_shared_ptr<U> const & r ) noexcept
 {
     (void) dynamic_cast< T* >( static_cast< U* >( 0 ) );
 
@@ -598,7 +541,7 @@ template<class T, class U> local_shared_ptr<T> dynamic_pointer_cast( local_share
     return p? local_shared_ptr<T>( r, p ): local_shared_ptr<T>();
 }
 
-template<class T, class U> local_shared_ptr<T> reinterpret_pointer_cast( local_shared_ptr<U> const & r ) BOOST_SP_NOEXCEPT
+template<class T, class U> local_shared_ptr<T> reinterpret_pointer_cast( local_shared_ptr<U> const & r ) noexcept
 {
     (void) reinterpret_cast< T* >( static_cast< U* >( 0 ) );
 
@@ -608,9 +551,7 @@ template<class T, class U> local_shared_ptr<T> reinterpret_pointer_cast( local_s
     return local_shared_ptr<T>( r, p );
 }
 
-#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
-
-template<class T, class U> local_shared_ptr<T> static_pointer_cast( local_shared_ptr<U> && r ) BOOST_SP_NOEXCEPT
+template<class T, class U> local_shared_ptr<T> static_pointer_cast( local_shared_ptr<U> && r ) noexcept
 {
     (void) static_cast< T* >( static_cast< U* >( 0 ) );
 
@@ -620,7 +561,7 @@ template<class T, class U> local_shared_ptr<T> static_pointer_cast( local_shared
     return local_shared_ptr<T>( std::move(r), p );
 }
 
-template<class T, class U> local_shared_ptr<T> const_pointer_cast( local_shared_ptr<U> && r ) BOOST_SP_NOEXCEPT
+template<class T, class U> local_shared_ptr<T> const_pointer_cast( local_shared_ptr<U> && r ) noexcept
 {
     (void) const_cast< T* >( static_cast< U* >( 0 ) );
 
@@ -630,7 +571,7 @@ template<class T, class U> local_shared_ptr<T> const_pointer_cast( local_shared_
     return local_shared_ptr<T>( std::move(r), p );
 }
 
-template<class T, class U> local_shared_ptr<T> dynamic_pointer_cast( local_shared_ptr<U> && r ) BOOST_SP_NOEXCEPT
+template<class T, class U> local_shared_ptr<T> dynamic_pointer_cast( local_shared_ptr<U> && r ) noexcept
 {
     (void) dynamic_cast< T* >( static_cast< U* >( 0 ) );
 
@@ -640,7 +581,7 @@ template<class T, class U> local_shared_ptr<T> dynamic_pointer_cast( local_share
     return p? local_shared_ptr<T>( std::move(r), p ): local_shared_ptr<T>();
 }
 
-template<class T, class U> local_shared_ptr<T> reinterpret_pointer_cast( local_shared_ptr<U> && r ) BOOST_SP_NOEXCEPT
+template<class T, class U> local_shared_ptr<T> reinterpret_pointer_cast( local_shared_ptr<U> && r ) noexcept
 {
     (void) reinterpret_cast< T* >( static_cast< U* >( 0 ) );
 
@@ -650,30 +591,24 @@ template<class T, class U> local_shared_ptr<T> reinterpret_pointer_cast( local_s
     return local_shared_ptr<T>( std::move(r), p );
 }
 
-#endif // !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
-
 // get_pointer() enables boost::mem_fn to recognize local_shared_ptr
 
-template<class T> inline typename local_shared_ptr<T>::element_type * get_pointer( local_shared_ptr<T> const & p ) BOOST_SP_NOEXCEPT
+template<class T> inline typename local_shared_ptr<T>::element_type * get_pointer( local_shared_ptr<T> const & p ) noexcept
 {
     return p.get();
 }
 
 // operator<<
 
-#if !defined(BOOST_NO_IOSTREAM)
-
 template<class E, class T, class Y> std::basic_ostream<E, T> & operator<< ( std::basic_ostream<E, T> & os, local_shared_ptr<Y> const & p )
 {
     os << p.get();
     return os;
 }
 
-#endif // !defined(BOOST_NO_IOSTREAM)
-
 // get_deleter
 
-template<class D, class T> D * get_deleter( local_shared_ptr<T> const & p ) BOOST_SP_NOEXCEPT
+template<class D, class T> D * get_deleter( local_shared_ptr<T> const & p ) noexcept
 {
     return get_deleter<D>( shared_ptr<T>( p ) );
 }
@@ -682,7 +617,7 @@ template<class D, class T> D * get_deleter( local_shared_ptr<T> const & p ) BOOS
 
 template< class T > struct hash;
 
-template< class T > std::size_t hash_value( local_shared_ptr<T> const & p ) BOOST_SP_NOEXCEPT
+template< class T > std::size_t hash_value( local_shared_ptr<T> const & p ) noexcept
 {
     return boost::hash< typename local_shared_ptr<T>::element_type* >()( p.get() );
 }
@@ -691,14 +626,12 @@ template< class T > std::size_t hash_value( local_shared_ptr<T> const & p ) BOOS
 
 // 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
+    std::size_t operator()( ::boost::local_shared_ptr<T> const & p ) const noexcept
     {
         return std::hash< typename ::boost::local_shared_ptr<T>::element_type* >()( p.get() );
     }
@@ -706,6 +639,4 @@ template<class T> struct hash< ::boost::local_shared_ptr<T> >
 
 } // 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.hpp

@@ -11,7 +11,6 @@
 //
 //  See http://www.boost.org/libs/smart_ptr/ for documentation.
 
-#include <boost/smart_ptr/detail/requires_cxx11.hpp>
 #include <boost/smart_ptr/make_local_shared_object.hpp>
 #include <boost/smart_ptr/make_local_shared_array.hpp>
 

include/boost/smart_ptr/make_local_shared_array.hpp

@@ -9,14 +9,15 @@ Distributed under the Boost Software License, Version 1.0.
 #ifndef BOOST_SMART_PTR_MAKE_LOCAL_SHARED_ARRAY_HPP
 #define BOOST_SMART_PTR_MAKE_LOCAL_SHARED_ARRAY_HPP
 
-#include <boost/smart_ptr/detail/requires_cxx11.hpp>
 #include <boost/core/default_allocator.hpp>
 #include <boost/smart_ptr/allocate_local_shared_array.hpp>
+#include <boost/smart_ptr/detail/sp_type_traits.hpp>
+#include <type_traits>
 
 namespace boost {
 
 template<class T>
-inline typename enable_if_<is_bounded_array<T>::value,
+inline typename std::enable_if<detail::sp_is_bounded_array<T>::value,
     local_shared_ptr<T> >::type
 make_local_shared()
 {
@@ -25,16 +26,16 @@ make_local_shared()
 }
 
 template<class T>
-inline typename enable_if_<is_bounded_array<T>::value,
+inline typename std::enable_if<detail::sp_is_bounded_array<T>::value,
     local_shared_ptr<T> >::type
-make_local_shared(const typename remove_extent<T>::type& value)
+make_local_shared(const typename std::remove_extent<T>::type& value)
 {
     return boost::allocate_local_shared<T>(boost::default_allocator<typename
         detail::sp_array_element<T>::type>(), value);
 }
 
 template<class T>
-inline typename enable_if_<is_unbounded_array<T>::value,
+inline typename std::enable_if<detail::sp_is_unbounded_array<T>::value,
     local_shared_ptr<T> >::type
 make_local_shared(std::size_t size)
 {
@@ -43,17 +44,17 @@ make_local_shared(std::size_t size)
 }
 
 template<class T>
-inline typename enable_if_<is_unbounded_array<T>::value,
+inline typename std::enable_if<detail::sp_is_unbounded_array<T>::value,
     local_shared_ptr<T> >::type
 make_local_shared(std::size_t size,
-    const typename remove_extent<T>::type& value)
+    const typename std::remove_extent<T>::type& value)
 {
     return boost::allocate_local_shared<T>(boost::default_allocator<typename
         detail::sp_array_element<T>::type>(), size, value);
 }
 
 template<class T>
-inline typename enable_if_<is_bounded_array<T>::value,
+inline typename std::enable_if<detail::sp_is_bounded_array<T>::value,
     local_shared_ptr<T> >::type
 make_local_shared_noinit()
 {
@@ -62,7 +63,7 @@ make_local_shared_noinit()
 }
 
 template<class T>
-inline typename enable_if_<is_unbounded_array<T>::value,
+inline typename std::enable_if<detail::sp_is_unbounded_array<T>::value,
     local_shared_ptr<T> >::type
 make_local_shared_noinit(std::size_t size)
 {

include/boost/smart_ptr/make_local_shared_object.hpp

@@ -11,11 +11,10 @@
 //
 //  See http://www.boost.org/libs/smart_ptr/ for documentation.
 
-#include <boost/smart_ptr/detail/requires_cxx11.hpp>
 #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 <type_traits>
 #include <utility>
 #include <cstddef>
 
@@ -46,7 +45,7 @@ template<class T, class A> class lsp_ms_deleter: public local_counted_impl_em
 {
 private:
 
-    typedef typename sp_aligned_storage<sizeof(T), ::boost::alignment_of<T>::value>::type storage_type;
+    typedef typename sp_aligned_storage<sizeof(T), std::alignment_of<T>::value>::type storage_type;
 
     storage_type storage_;
     A a_;
@@ -54,57 +53,49 @@ private:
 
 private:
 
-    void destroy() BOOST_SP_NOEXCEPT
+    void destroy() noexcept
     {
         if( initialized_ )
         {
             T * p = reinterpret_cast< T* >( storage_.data_ );
 
-#if !defined( BOOST_NO_CXX11_ALLOCATOR )
-
             std::allocator_traits<A>::destroy( a_, p );
 
-#else
-
-            p->~T();
-
-#endif
-
             initialized_ = false;
         }
     }
 
 public:
 
-    explicit lsp_ms_deleter( A const & a ) BOOST_SP_NOEXCEPT : a_( a ), initialized_( false )
+    explicit lsp_ms_deleter( A const & a ) noexcept : a_( a ), initialized_( false )
     {
     }
 
     // optimization: do not copy storage_
-    lsp_ms_deleter( lsp_ms_deleter const & r ) BOOST_SP_NOEXCEPT : a_( r.a_), initialized_( false )
+    lsp_ms_deleter( lsp_ms_deleter const & r ) noexcept : a_( r.a_), initialized_( false )
     {
     }
 
-    ~lsp_ms_deleter() BOOST_SP_NOEXCEPT
+    ~lsp_ms_deleter() noexcept
     {
         destroy();
     }
 
-    void operator()( T * ) BOOST_SP_NOEXCEPT
+    void operator()( T * ) noexcept
     {
         destroy();
     }
 
-    static void operator_fn( T* ) BOOST_SP_NOEXCEPT // operator() can't be static
+    static void operator_fn( T* ) noexcept // operator() can't be static
     {
     }
 
-    void * address() BOOST_SP_NOEXCEPT
+    void * address() noexcept
     {
         return storage_.data_;
     }
 
-    void set_initialized() BOOST_SP_NOEXCEPT
+    void set_initialized() noexcept
     {
         initialized_ = true;
     }
@@ -114,16 +105,8 @@ public:
 
 template<class T, class A, class... Args> typename boost::detail::lsp_if_not_array<T>::type allocate_local_shared( A const & a, Args&&... args )
 {
-#if !defined( BOOST_NO_CXX11_ALLOCATOR )
-
     typedef typename std::allocator_traits<A>::template rebind_alloc<T> A2;
 
-#else
-
-    typedef typename A::template rebind<T>::other A2;
-
-#endif
-
     A2 a2( a );
 
     typedef boost::detail::lsp_ms_deleter<T, A2> D;
@@ -133,16 +116,8 @@ template<class T, class A, class... Args> typename boost::detail::lsp_if_not_arr
     D * pd = static_cast< D* >( pt._internal_get_untyped_deleter() );
     void * pv = pd->address();
 
-#if !defined( BOOST_NO_CXX11_ALLOCATOR )
-
     std::allocator_traits<A2>::construct( a2, static_cast< T* >( pv ), std::forward<Args>( args )... );
 
-#else
-
-    ::new( pv ) T( std::forward<Args>( args )... );
-
-#endif
-
     pd->set_initialized();
 
     T * pt2 = static_cast< T* >( pv );
@@ -155,16 +130,8 @@ template<class T, class A, class... Args> typename boost::detail::lsp_if_not_arr
 
 template<class T, class A> typename boost::detail::lsp_if_not_array<T>::type allocate_local_shared_noinit( A const & a )
 {
-#if !defined( BOOST_NO_CXX11_ALLOCATOR )
-
     typedef typename std::allocator_traits<A>::template rebind_alloc<T> A2;
 
-#else
-
-    typedef typename A::template rebind<T>::other A2;
-
-#endif
-
     A2 a2( a );
 
     typedef boost::detail::lsp_ms_deleter< T, std::allocator<T> > D;
@@ -188,13 +155,13 @@ 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 )
 {
-    typedef typename boost::remove_const<T>::type T2;
+    typedef typename std::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()
 {
-    typedef typename boost::remove_const<T>::type T2;
+    typedef typename std::remove_const<T>::type T2;
     return boost::allocate_shared_noinit<T2>( std::allocator<T2>() );
 }
 

include/boost/smart_ptr/make_shared.hpp

@@ -11,12 +11,8 @@
 //
 //  See http://www.boost.org/libs/smart_ptr/ for documentation.
 
-#include <boost/smart_ptr/detail/requires_cxx11.hpp>
 #include <boost/smart_ptr/make_shared_object.hpp>
-
-#if !defined( BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION ) && !defined( BOOST_NO_SFINAE )
-# include <boost/smart_ptr/make_shared_array.hpp>
-# include <boost/smart_ptr/allocate_shared_array.hpp>
-#endif
+#include <boost/smart_ptr/make_shared_array.hpp>
+#include <boost/smart_ptr/allocate_shared_array.hpp>
 
 #endif // #ifndef BOOST_SMART_PTR_MAKE_SHARED_HPP_INCLUDED

include/boost/smart_ptr/make_shared_array.hpp

@@ -8,14 +8,15 @@ 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/smart_ptr/detail/requires_cxx11.hpp>
 #include <boost/core/default_allocator.hpp>
 #include <boost/smart_ptr/allocate_shared_array.hpp>
+#include <boost/smart_ptr/detail/sp_type_traits.hpp>
+#include <type_traits>
 
 namespace boost {
 
 template<class T>
-inline typename enable_if_<is_bounded_array<T>::value, shared_ptr<T> >::type
+inline typename std::enable_if<detail::sp_is_bounded_array<T>::value, shared_ptr<T> >::type
 make_shared()
 {
     return boost::allocate_shared<T>(boost::default_allocator<typename
@@ -23,15 +24,15 @@ make_shared()
 }
 
 template<class T>
-inline typename enable_if_<is_bounded_array<T>::value, shared_ptr<T> >::type
-make_shared(const typename remove_extent<T>::type& value)
+inline typename std::enable_if<detail::sp_is_bounded_array<T>::value, shared_ptr<T> >::type
+make_shared(const typename std::remove_extent<T>::type& value)
 {
     return boost::allocate_shared<T>(boost::default_allocator<typename
         detail::sp_array_element<T>::type>(), value);
 }
 
 template<class T>
-inline typename enable_if_<is_unbounded_array<T>::value, shared_ptr<T> >::type
+inline typename std::enable_if<detail::sp_is_unbounded_array<T>::value, shared_ptr<T> >::type
 make_shared(std::size_t size)
 {
     return boost::allocate_shared<T>(boost::default_allocator<typename
@@ -39,15 +40,15 @@ make_shared(std::size_t size)
 }
 
 template<class T>
-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)
+inline typename std::enable_if<detail::sp_is_unbounded_array<T>::value, shared_ptr<T> >::type
+make_shared(std::size_t size, const typename std::remove_extent<T>::type& value)
 {
     return boost::allocate_shared<T>(boost::default_allocator<typename
         detail::sp_array_element<T>::type>(), size, value);
 }
 
 template<class T>
-inline typename enable_if_<is_bounded_array<T>::value, shared_ptr<T> >::type
+inline typename std::enable_if<detail::sp_is_bounded_array<T>::value, shared_ptr<T> >::type
 make_shared_noinit()
 {
     return boost::allocate_shared_noinit<T>(boost::default_allocator<typename
@@ -55,7 +56,7 @@ make_shared_noinit()
 }
 
 template<class T>
-inline typename enable_if_<is_unbounded_array<T>::value, shared_ptr<T> >::type
+inline typename std::enable_if<detail::sp_is_unbounded_array<T>::value, shared_ptr<T> >::type
 make_shared_noinit(std::size_t size)
 {
     return boost::allocate_shared_noinit<T>(boost::default_allocator<typename

include/boost/smart_ptr/make_shared_object.hpp

@@ -11,21 +11,16 @@
 //
 //  See http://www.boost.org/libs/smart_ptr/ for documentation.
 
-#include <boost/smart_ptr/detail/requires_cxx11.hpp>
-#include <boost/config.hpp>
-#include <boost/move/core.hpp>
-#include <boost/move/utility_core.hpp>
 #include <boost/smart_ptr/shared_ptr.hpp>
-#include <boost/smart_ptr/detail/sp_forward.hpp>
-#include <boost/smart_ptr/detail/sp_noexcept.hpp>
-#include <boost/type_traits/type_with_alignment.hpp>
-#include <boost/type_traits/alignment_of.hpp>
+#include <boost/smart_ptr/detail/sp_type_traits.hpp>
+#include <boost/config.hpp>
+#include <utility>
 #include <cstddef>
 #include <new>
+#include <type_traits>
 
 namespace boost
 {
-
 namespace detail
 {
 
@@ -34,7 +29,7 @@ template< std::size_t N, std::size_t A > struct sp_aligned_storage
     union type
     {
         char data_[ N ];
-        typename boost::type_with_alignment< A >::type align_;
+        typename sp_type_with_alignment< A >::type align_;
     };
 };
 
@@ -42,14 +37,14 @@ template< class T > class sp_ms_deleter
 {
 private:
 
-    typedef typename sp_aligned_storage< sizeof( T ), ::boost::alignment_of< T >::value >::type storage_type;
+    typedef typename sp_aligned_storage< sizeof( T ), std::alignment_of< T >::value >::type storage_type;
 
     bool initialized_;
     storage_type storage_;
 
 private:
 
-    void destroy() BOOST_SP_NOEXCEPT
+    void destroy() noexcept
     {
         if( initialized_ )
         {
@@ -71,39 +66,39 @@ private:
 
 public:
 
-    sp_ms_deleter() BOOST_SP_NOEXCEPT : initialized_( false )
+    sp_ms_deleter() noexcept : initialized_( false )
     {
     }
 
-    template<class A> explicit sp_ms_deleter( A const & ) BOOST_SP_NOEXCEPT : initialized_( false )
+    template<class A> explicit sp_ms_deleter( A const & ) noexcept : initialized_( false )
     {
     }
 
     // optimization: do not copy storage_
-    sp_ms_deleter( sp_ms_deleter const & ) BOOST_SP_NOEXCEPT : initialized_( false )
+    sp_ms_deleter( sp_ms_deleter const & ) noexcept : initialized_( false )
     {
     }
 
-    ~sp_ms_deleter() BOOST_SP_NOEXCEPT
+    ~sp_ms_deleter() noexcept
     {
         destroy();
     }
 
-    void operator()( T * ) BOOST_SP_NOEXCEPT
+    void operator()( T * ) noexcept
     {
         destroy();
     }
 
-    static void operator_fn( T* ) BOOST_SP_NOEXCEPT // operator() can't be static
+    static void operator_fn( T* ) noexcept // operator() can't be static
     {
     }
 
-    void * address() BOOST_SP_NOEXCEPT
+    void * address() noexcept
     {
         return storage_.data_;
     }
 
-    void set_initialized() BOOST_SP_NOEXCEPT
+    void set_initialized() noexcept
     {
         initialized_ = true;
     }
@@ -113,7 +108,7 @@ template< class T, class A > class sp_as_deleter
 {
 private:
 
-    typedef typename sp_aligned_storage< sizeof( T ), ::boost::alignment_of< T >::value >::type storage_type;
+    typedef typename sp_aligned_storage< sizeof( T ), std::alignment_of< T >::value >::type storage_type;
 
     storage_type storage_;
     A a_;
@@ -121,57 +116,49 @@ private:
 
 private:
 
-    void destroy() BOOST_SP_NOEXCEPT
+    void destroy() noexcept
     {
         if( initialized_ )
         {
             T * p = reinterpret_cast< T* >( storage_.data_ );
 
-#if !defined( BOOST_NO_CXX11_ALLOCATOR )
-
             std::allocator_traits<A>::destroy( a_, p );
 
-#else
-
-            p->~T();
-
-#endif
-
             initialized_ = false;
         }
     }
 
 public:
 
-    sp_as_deleter( A const & a ) BOOST_SP_NOEXCEPT : a_( a ), initialized_( false )
+    sp_as_deleter( A const & a ) noexcept : a_( a ), initialized_( false )
     {
     }
 
     // optimization: do not copy storage_
-    sp_as_deleter( sp_as_deleter const & r ) BOOST_SP_NOEXCEPT : a_( r.a_), initialized_( false )
+    sp_as_deleter( sp_as_deleter const & r ) noexcept : a_( r.a_), initialized_( false )
     {
     }
 
-    ~sp_as_deleter() BOOST_SP_NOEXCEPT
+    ~sp_as_deleter() noexcept
     {
         destroy();
     }
 
-    void operator()( T * ) BOOST_SP_NOEXCEPT
+    void operator()( T * ) noexcept
     {
         destroy();
     }
 
-    static void operator_fn( T* ) BOOST_SP_NOEXCEPT // operator() can't be static
+    static void operator_fn( T* ) noexcept // operator() can't be static
     {
     }
 
-    void * address() BOOST_SP_NOEXCEPT
+    void * address() noexcept
     {
         return storage_.data_;
     }
 
-    void set_initialized() BOOST_SP_NOEXCEPT
+    void set_initialized() noexcept
     {
         initialized_ = true;
     }
@@ -182,29 +169,17 @@ template< class T > struct sp_if_not_array
     typedef boost::shared_ptr< T > type;
 };
 
-#if !defined( BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION )
-
 template< class T > struct sp_if_not_array< T[] >
 {
 };
 
-#if !defined( BOOST_BORLANDC ) || !BOOST_WORKAROUND( BOOST_BORLANDC, < 0x600 )
-
 template< class T, std::size_t N > struct sp_if_not_array< T[N] >
 {
 };
 
-#endif
-
-#endif
-
 } // namespace detail
 
-#if !defined( BOOST_NO_FUNCTION_TEMPLATE_ORDERING )
-# define BOOST_SP_MSD( T ) boost::detail::sp_inplace_tag< boost::detail::sp_ms_deleter< T > >()
-#else
-# define BOOST_SP_MSD( T ) boost::detail::sp_ms_deleter< T >()
-#endif
+#define BOOST_SP_MSD( T ) boost::detail::sp_inplace_tag< boost::detail::sp_ms_deleter< T > >()
 
 // _noinit versions
 
@@ -242,9 +217,7 @@ template< class T, class A > typename boost::detail::sp_if_not_array< T >::type
     return boost::shared_ptr< T >( pt, pt2 );
 }
 
-#if !defined( BOOST_NO_CXX11_VARIADIC_TEMPLATES ) && !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
-
-// Variadic templates, rvalue reference
+//
 
 template< class T, class... Args > typename boost::detail::sp_if_not_array< T >::type make_shared( Args && ... args )
 {
@@ -254,7 +227,7 @@ template< class T, class... Args > typename boost::detail::sp_if_not_array< T >:
 
     void * pv = pd->address();
 
-    ::new( pv ) T( boost::detail::sp_forward<Args>( args )... );
+    ::new( pv ) T( std::forward<Args>( args )... );
     pd->set_initialized();
 
     T * pt2 = static_cast< T* >( pv );
@@ -265,8 +238,6 @@ template< class T, class... Args > typename boost::detail::sp_if_not_array< T >:
 
 template< class T, class A, class... Args > typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, Args && ... args )
 {
-#if !defined( BOOST_NO_CXX11_ALLOCATOR )
-
     typedef typename std::allocator_traits<A>::template rebind_alloc<T> A2;
     A2 a2( a );
 
@@ -274,26 +245,10 @@ template< class T, class A, class... Args > typename boost::detail::sp_if_not_ar
 
     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), boost::detail::sp_inplace_tag<D>(), a2 );
 
-#else
-
-    typedef boost::detail::sp_ms_deleter< T > D;
-
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), boost::detail::sp_inplace_tag<D>(), a );
-
-#endif
-
     D * pd = static_cast< D* >( pt._internal_get_untyped_deleter() );
     void * pv = pd->address();
 
-#if !defined( BOOST_NO_CXX11_ALLOCATOR )
-
-    std::allocator_traits<A2>::construct( a2, static_cast< T* >( pv ), boost::detail::sp_forward<Args>( args )... );
-
-#else
-
-    ::new( pv ) T( boost::detail::sp_forward<Args>( args )... );
-
-#endif
+    std::allocator_traits<A2>::construct( a2, static_cast< T* >( pv ), std::forward<Args>( args )... );
 
     pd->set_initialized();
 
@@ -303,498 +258,6 @@ template< class T, class A, class... Args > typename boost::detail::sp_if_not_ar
     return boost::shared_ptr< T >( pt, pt2 );
 }
 
-#else // !defined( BOOST_NO_CXX11_VARIADIC_TEMPLATES ) && !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
-
-// Common zero-argument versions
-
-template< class T > typename boost::detail::sp_if_not_array< T >::type make_shared()
-{
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
-
-    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
-
-    void * pv = pd->address();
-
-    ::new( pv ) T();
-    pd->set_initialized();
-
-    T * pt2 = static_cast< T* >( pv );
-
-    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
-    return boost::shared_ptr< T >( pt, pt2 );
-}
-
-template< class T, class A > typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a )
-{
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
-
-    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
-
-    void * pv = pd->address();
-
-    ::new( pv ) T();
-    pd->set_initialized();
-
-    T * pt2 = static_cast< T* >( pv );
-
-    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
-    return boost::shared_ptr< T >( pt, pt2 );
-}
-
-// C++03 version
-
-template< class T, class A1 >
-typename boost::detail::sp_if_not_array< T >::type make_shared( BOOST_FWD_REF(A1) a1 )
-{
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
-
-    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
-
-    void * pv = pd->address();
-
-    ::new( pv ) T(
-        boost::forward<A1>( a1 )
-        );
-
-    pd->set_initialized();
-
-    T * pt2 = static_cast< T* >( pv );
-
-    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
-    return boost::shared_ptr< T >( pt, pt2 );
-}
-
-template< class T, class A, class A1 >
-typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, BOOST_FWD_REF(A1) a1 )
-{
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
-
-    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
-
-    void * pv = pd->address();
-
-    ::new( pv ) T(
-        boost::forward<A1>( a1 )
-        );
-
-    pd->set_initialized();
-
-    T * pt2 = static_cast< T* >( pv );
-
-    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
-    return boost::shared_ptr< T >( pt, pt2 );
-}
-
-template< class T, class A1, class A2 >
-typename boost::detail::sp_if_not_array< T >::type make_shared( BOOST_FWD_REF(A1) a1, BOOST_FWD_REF(A2) a2 )
-{
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
-
-    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
-
-    void * pv = pd->address();
-
-    ::new( pv ) T(
-        boost::forward<A1>( a1 ),
-        boost::forward<A2>( a2 )
-        );
-
-    pd->set_initialized();
-
-    T * pt2 = static_cast< T* >( pv );
-
-    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
-    return boost::shared_ptr< T >( pt, pt2 );
-}
-
-template< class T, class A, class A1, class A2 >
-typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, BOOST_FWD_REF(A1) a1, BOOST_FWD_REF(A2) a2 )
-{
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
-
-    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
-
-    void * pv = pd->address();
-
-    ::new( pv ) T(
-        boost::forward<A1>( a1 ),
-        boost::forward<A2>( a2 )
-        );
-
-    pd->set_initialized();
-
-    T * pt2 = static_cast< T* >( pv );
-
-    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
-    return boost::shared_ptr< T >( pt, pt2 );
-}
-
-template< class T, class A1, class A2, class A3 >
-typename boost::detail::sp_if_not_array< T >::type make_shared( BOOST_FWD_REF(A1) a1, BOOST_FWD_REF(A2) a2, BOOST_FWD_REF(A3) a3 )
-{
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
-
-    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
-
-    void * pv = pd->address();
-
-    ::new( pv ) T(
-        boost::forward<A1>( a1 ),
-        boost::forward<A2>( a2 ),
-        boost::forward<A3>( a3 )
-        );
-
-    pd->set_initialized();
-
-    T * pt2 = static_cast< T* >( pv );
-
-    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
-    return boost::shared_ptr< T >( pt, pt2 );
-}
-
-template< class T, class A, class A1, class A2, class A3 >
-typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, BOOST_FWD_REF(A1) a1, BOOST_FWD_REF(A2) a2, BOOST_FWD_REF(A3) a3 )
-{
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
-
-    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
-
-    void * pv = pd->address();
-
-    ::new( pv ) T(
-        boost::forward<A1>( a1 ),
-        boost::forward<A2>( a2 ),
-        boost::forward<A3>( a3 )
-        );
-
-    pd->set_initialized();
-
-    T * pt2 = static_cast< T* >( pv );
-
-    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
-    return boost::shared_ptr< T >( pt, pt2 );
-}
-
-template< class T, class A1, class A2, class A3, class A4 >
-typename boost::detail::sp_if_not_array< T >::type make_shared( BOOST_FWD_REF(A1) a1, BOOST_FWD_REF(A2) a2, BOOST_FWD_REF(A3) a3, BOOST_FWD_REF(A4) a4 )
-{
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
-
-    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
-
-    void * pv = pd->address();
-
-    ::new( pv ) T(
-        boost::forward<A1>( a1 ),
-        boost::forward<A2>( a2 ),
-        boost::forward<A3>( a3 ),
-        boost::forward<A4>( a4 )
-        );
-
-    pd->set_initialized();
-
-    T * pt2 = static_cast< T* >( pv );
-
-    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
-    return boost::shared_ptr< T >( pt, pt2 );
-}
-
-template< class T, class A, class A1, class A2, class A3, class A4 >
-typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, BOOST_FWD_REF(A1) a1, BOOST_FWD_REF(A2) a2, BOOST_FWD_REF(A3) a3, BOOST_FWD_REF(A4) a4 )
-{
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
-
-    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
-
-    void * pv = pd->address();
-
-    ::new( pv ) T(
-        boost::forward<A1>( a1 ),
-        boost::forward<A2>( a2 ),
-        boost::forward<A3>( a3 ),
-        boost::forward<A4>( a4 )
-        );
-
-    pd->set_initialized();
-
-    T * pt2 = static_cast< T* >( pv );
-
-    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
-    return boost::shared_ptr< T >( pt, pt2 );
-}
-
-template< class T, class A1, class A2, class A3, class A4, class A5 >
-typename boost::detail::sp_if_not_array< T >::type make_shared( BOOST_FWD_REF(A1) a1, BOOST_FWD_REF(A2) a2, BOOST_FWD_REF(A3) a3, BOOST_FWD_REF(A4) a4, BOOST_FWD_REF(A5) a5 )
-{
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
-
-    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
-
-    void * pv = pd->address();
-
-    ::new( pv ) T(
-        boost::forward<A1>( a1 ),
-        boost::forward<A2>( a2 ),
-        boost::forward<A3>( a3 ),
-        boost::forward<A4>( a4 ),
-        boost::forward<A5>( a5 )
-        );
-
-    pd->set_initialized();
-
-    T * pt2 = static_cast< T* >( pv );
-
-    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
-    return boost::shared_ptr< T >( pt, pt2 );
-}
-
-template< class T, class A, class A1, class A2, class A3, class A4, class A5 >
-typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, BOOST_FWD_REF(A1) a1, BOOST_FWD_REF(A2) a2, BOOST_FWD_REF(A3) a3, BOOST_FWD_REF(A4) a4, BOOST_FWD_REF(A5) a5 )
-{
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
-
-    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
-
-    void * pv = pd->address();
-
-    ::new( pv ) T(
-        boost::forward<A1>( a1 ),
-        boost::forward<A2>( a2 ),
-        boost::forward<A3>( a3 ),
-        boost::forward<A4>( a4 ),
-        boost::forward<A5>( a5 )
-        );
-
-    pd->set_initialized();
-
-    T * pt2 = static_cast< T* >( pv );
-
-    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
-    return boost::shared_ptr< T >( pt, pt2 );
-}
-
-template< class T, class A1, class A2, class A3, class A4, class A5, class A6 >
-typename boost::detail::sp_if_not_array< T >::type make_shared( BOOST_FWD_REF(A1) a1, BOOST_FWD_REF(A2) a2, BOOST_FWD_REF(A3) a3, BOOST_FWD_REF(A4) a4, BOOST_FWD_REF(A5) a5, BOOST_FWD_REF(A6) a6 )
-{
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
-
-    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
-
-    void * pv = pd->address();
-
-    ::new( pv ) T(
-        boost::forward<A1>( a1 ),
-        boost::forward<A2>( a2 ),
-        boost::forward<A3>( a3 ),
-        boost::forward<A4>( a4 ),
-        boost::forward<A5>( a5 ),
-        boost::forward<A6>( a6 )
-        );
-
-    pd->set_initialized();
-
-    T * pt2 = static_cast< T* >( pv );
-
-    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
-    return boost::shared_ptr< T >( pt, pt2 );
-}
-
-template< class T, class A, class A1, class A2, class A3, class A4, class A5, class A6 >
-typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, BOOST_FWD_REF(A1) a1, BOOST_FWD_REF(A2) a2, BOOST_FWD_REF(A3) a3, BOOST_FWD_REF(A4) a4, BOOST_FWD_REF(A5) a5, BOOST_FWD_REF(A6) a6 )
-{
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
-
-    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
-
-    void * pv = pd->address();
-
-    ::new( pv ) T(
-        boost::forward<A1>( a1 ),
-        boost::forward<A2>( a2 ),
-        boost::forward<A3>( a3 ),
-        boost::forward<A4>( a4 ),
-        boost::forward<A5>( a5 ),
-        boost::forward<A6>( a6 )
-        );
-
-    pd->set_initialized();
-
-    T * pt2 = static_cast< T* >( pv );
-
-    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
-    return boost::shared_ptr< T >( pt, pt2 );
-}
-
-template< class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7 >
-typename boost::detail::sp_if_not_array< T >::type make_shared( BOOST_FWD_REF(A1) a1, BOOST_FWD_REF(A2) a2, BOOST_FWD_REF(A3) a3, BOOST_FWD_REF(A4) a4, BOOST_FWD_REF(A5) a5, BOOST_FWD_REF(A6) a6, BOOST_FWD_REF(A7) a7 )
-{
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
-
-    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
-
-    void * pv = pd->address();
-
-    ::new( pv ) T(
-        boost::forward<A1>( a1 ),
-        boost::forward<A2>( a2 ),
-        boost::forward<A3>( a3 ),
-        boost::forward<A4>( a4 ),
-        boost::forward<A5>( a5 ),
-        boost::forward<A6>( a6 ),
-        boost::forward<A7>( a7 )
-        );
-
-    pd->set_initialized();
-
-    T * pt2 = static_cast< T* >( pv );
-
-    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
-    return boost::shared_ptr< T >( pt, pt2 );
-}
-
-template< class T, class A, class A1, class A2, class A3, class A4, class A5, class A6, class A7 >
-typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, BOOST_FWD_REF(A1) a1, BOOST_FWD_REF(A2) a2, BOOST_FWD_REF(A3) a3, BOOST_FWD_REF(A4) a4, BOOST_FWD_REF(A5) a5, BOOST_FWD_REF(A6) a6, BOOST_FWD_REF(A7) a7 )
-{
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
-
-    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
-
-    void * pv = pd->address();
-
-    ::new( pv ) T(
-        boost::forward<A1>( a1 ),
-        boost::forward<A2>( a2 ),
-        boost::forward<A3>( a3 ),
-        boost::forward<A4>( a4 ),
-        boost::forward<A5>( a5 ),
-        boost::forward<A6>( a6 ),
-        boost::forward<A7>( a7 )
-        );
-
-    pd->set_initialized();
-
-    T * pt2 = static_cast< T* >( pv );
-
-    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
-    return boost::shared_ptr< T >( pt, pt2 );
-}
-
-template< class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8 >
-typename boost::detail::sp_if_not_array< T >::type make_shared( BOOST_FWD_REF(A1) a1, BOOST_FWD_REF(A2) a2, BOOST_FWD_REF(A3) a3, BOOST_FWD_REF(A4) a4, BOOST_FWD_REF(A5) a5, BOOST_FWD_REF(A6) a6, BOOST_FWD_REF(A7) a7, BOOST_FWD_REF(A8) a8 )
-{
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
-
-    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
-
-    void * pv = pd->address();
-
-    ::new( pv ) T(
-        boost::forward<A1>( a1 ),
-        boost::forward<A2>( a2 ),
-        boost::forward<A3>( a3 ),
-        boost::forward<A4>( a4 ),
-        boost::forward<A5>( a5 ),
-        boost::forward<A6>( a6 ),
-        boost::forward<A7>( a7 ),
-        boost::forward<A8>( a8 )
-        );
-
-    pd->set_initialized();
-
-    T * pt2 = static_cast< T* >( pv );
-
-    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
-    return boost::shared_ptr< T >( pt, pt2 );
-}
-
-template< class T, class A, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8 >
-typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, BOOST_FWD_REF(A1) a1, BOOST_FWD_REF(A2) a2, BOOST_FWD_REF(A3) a3, BOOST_FWD_REF(A4) a4, BOOST_FWD_REF(A5) a5, BOOST_FWD_REF(A6) a6, BOOST_FWD_REF(A7) a7, BOOST_FWD_REF(A8) a8 )
-{
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
-
-    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
-
-    void * pv = pd->address();
-
-    ::new( pv ) T(
-        boost::forward<A1>( a1 ),
-        boost::forward<A2>( a2 ),
-        boost::forward<A3>( a3 ),
-        boost::forward<A4>( a4 ),
-        boost::forward<A5>( a5 ),
-        boost::forward<A6>( a6 ),
-        boost::forward<A7>( a7 ),
-        boost::forward<A8>( a8 )
-        );
-
-    pd->set_initialized();
-
-    T * pt2 = static_cast< T* >( pv );
-
-    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
-    return boost::shared_ptr< T >( pt, pt2 );
-}
-
-template< class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9 >
-typename boost::detail::sp_if_not_array< T >::type make_shared( BOOST_FWD_REF(A1) a1, BOOST_FWD_REF(A2) a2, BOOST_FWD_REF(A3) a3, BOOST_FWD_REF(A4) a4, BOOST_FWD_REF(A5) a5, BOOST_FWD_REF(A6) a6, BOOST_FWD_REF(A7) a7, BOOST_FWD_REF(A8) a8, BOOST_FWD_REF(A9) a9 )
-{
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
-
-    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
-
-    void * pv = pd->address();
-
-    ::new( pv ) T(
-        boost::forward<A1>( a1 ),
-        boost::forward<A2>( a2 ),
-        boost::forward<A3>( a3 ),
-        boost::forward<A4>( a4 ),
-        boost::forward<A5>( a5 ),
-        boost::forward<A6>( a6 ),
-        boost::forward<A7>( a7 ),
-        boost::forward<A8>( a8 ),
-        boost::forward<A9>( a9 )
-        );
-
-    pd->set_initialized();
-
-    T * pt2 = static_cast< T* >( pv );
-
-    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
-    return boost::shared_ptr< T >( pt, pt2 );
-}
-
-template< class T, class A, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9 >
-typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, BOOST_FWD_REF(A1) a1, BOOST_FWD_REF(A2) a2, BOOST_FWD_REF(A3) a3, BOOST_FWD_REF(A4) a4, BOOST_FWD_REF(A5) a5, BOOST_FWD_REF(A6) a6, BOOST_FWD_REF(A7) a7, BOOST_FWD_REF(A8) a8, BOOST_FWD_REF(A9) a9 )
-{
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
-
-    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
-
-    void * pv = pd->address();
-
-    ::new( pv ) T(
-        boost::forward<A1>( a1 ),
-        boost::forward<A2>( a2 ),
-        boost::forward<A3>( a3 ),
-        boost::forward<A4>( a4 ),
-        boost::forward<A5>( a5 ),
-        boost::forward<A6>( a6 ),
-        boost::forward<A7>( a7 ),
-        boost::forward<A8>( a8 ),
-        boost::forward<A9>( a9 )
-        );
-
-    pd->set_initialized();
-
-    T * pt2 = static_cast< T* >( pv );
-
-    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
-    return boost::shared_ptr< T >( pt, pt2 );
-}
-
-#endif // !defined( BOOST_NO_CXX11_VARIADIC_TEMPLATES ) && !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
-
 #undef BOOST_SP_MSD
 
 } // namespace boost

include/boost/smart_ptr/make_unique.hpp

@@ -8,61 +8,55 @@ 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/smart_ptr/detail/requires_cxx11.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 <boost/smart_ptr/detail/sp_type_traits.hpp>
 #include <memory>
+#include <type_traits>
 #include <utility>
 
 namespace boost {
 
 template<class T>
-inline typename enable_if_<!is_array<T>::value, std::unique_ptr<T> >::type
+inline typename std::enable_if<!std::is_array<T>::value, std::unique_ptr<T> >::type
 make_unique()
 {
     return std::unique_ptr<T>(new T());
 }
 
-#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
 template<class T, class... Args>
-inline typename enable_if_<!is_array<T>::value, std::unique_ptr<T> >::type
+inline typename std::enable_if<!std::is_array<T>::value, std::unique_ptr<T> >::type
 make_unique(Args&&... args)
 {
     return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
 }
-#endif
 
 template<class T>
-inline typename enable_if_<!is_array<T>::value, std::unique_ptr<T> >::type
-make_unique(typename remove_reference<T>::type&& value)
+inline typename std::enable_if<!std::is_array<T>::value, std::unique_ptr<T> >::type
+make_unique(typename std::remove_reference<T>::type&& value)
 {
     return std::unique_ptr<T>(new T(std::move(value)));
 }
 
 template<class T>
-inline typename enable_if_<!is_array<T>::value, std::unique_ptr<T> >::type
+inline typename std::enable_if<!std::is_array<T>::value, std::unique_ptr<T> >::type
 make_unique_noinit()
 {
     return std::unique_ptr<T>(new T);
 }
 
 template<class T>
-inline typename enable_if_<is_unbounded_array<T>::value,
+inline typename std::enable_if<detail::sp_is_unbounded_array<T>::value,
     std::unique_ptr<T> >::type
 make_unique(std::size_t size)
 {
-    return std::unique_ptr<T>(new typename remove_extent<T>::type[size]());
+    return std::unique_ptr<T>(new typename std::remove_extent<T>::type[size]());
 }
 
 template<class T>
-inline typename enable_if_<is_unbounded_array<T>::value,
+inline typename std::enable_if<detail::sp_is_unbounded_array<T>::value,
     std::unique_ptr<T> >::type
 make_unique_noinit(std::size_t size)
 {
-    return std::unique_ptr<T>(new typename remove_extent<T>::type[size]);
+    return std::unique_ptr<T>(new typename std::remove_extent<T>::type[size]);
 }
 
 } /* boost */

include/boost/smart_ptr/owner_equal_to.hpp

@@ -5,8 +5,6 @@
 // Distributed under the Boost Software License, Version 1.0.
 // https://www.boost.org/LICENSE_1_0.txt
 
-#include <boost/config.hpp>
-
 namespace boost
 {
 
@@ -16,7 +14,7 @@ template<class T = void> struct owner_equal_to
     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
+    template<class U, class V> bool operator()( U const & u, V const & v ) const noexcept
     {
         return u.owner_equals( v );
     }

include/boost/smart_ptr/owner_hash.hpp

@@ -5,7 +5,6 @@
 // Distributed under the Boost Software License, Version 1.0.
 // https://www.boost.org/LICENSE_1_0.txt
 
-#include <boost/config.hpp>
 #include <cstddef>
 
 namespace boost
@@ -16,7 +15,7 @@ template<class T> struct owner_hash
     typedef std::size_t result_type;
     typedef T argument_type;
 
-    std::size_t operator()( T const & t ) const BOOST_NOEXCEPT
+    std::size_t operator()( T const & t ) const noexcept
     {
         return t.owner_hash_value();
     }

include/boost/smart_ptr/owner_less.hpp

@@ -14,8 +14,6 @@
 //  See http://www.boost.org/libs/smart_ptr/ for documentation.
 //
 
-#include <boost/config.hpp>
-
 namespace boost
 {
 
@@ -25,7 +23,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 BOOST_NOEXCEPT
+    template<class U, class V> bool operator()( U const & u, V const & v ) const noexcept
     {
         return u.owner_before( v );
     }

include/boost/smart_ptr/scoped_array.hpp

@@ -10,13 +10,11 @@
 //
 //  See http://www.boost.org/libs/smart_ptr/ for documentation.
 
-#include <boost/smart_ptr/detail/requires_cxx11.hpp>
-#include <boost/config.hpp>
-#include <boost/assert.hpp>
-#include <boost/core/checked_delete.hpp>
-#include <boost/smart_ptr/detail/sp_nullptr_t.hpp>
 #include <boost/smart_ptr/detail/sp_noexcept.hpp>
-
+#include <boost/smart_ptr/detail/deprecated_macros.hpp>
+#include <boost/core/checked_delete.hpp>
+#include <boost/assert.hpp>
+#include <boost/config.hpp>
 #include <boost/config/workaround.hpp>
 
 #include <cstddef>            // for std::ptrdiff_t
@@ -24,15 +22,6 @@
 namespace boost
 {
 
-// Debug hooks
-
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
-
-void sp_array_constructor_hook(void * p);
-void sp_array_destructor_hook(void * p);
-
-#endif
-
 //  scoped_array extends scoped_ptr to arrays. Deletion of the array pointed to
 //  is guaranteed, either on destruction of the scoped_array or via an explicit
 //  reset(). Use shared_array or std::vector if your needs are more complex.
@@ -55,18 +44,12 @@ public:
 
     typedef T element_type;
 
-    explicit scoped_array( T * p = 0 ) BOOST_SP_NOEXCEPT : px( p )
+    explicit scoped_array( T * p = 0 ) noexcept : px( p )
     {
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
-        boost::sp_array_constructor_hook( px );
-#endif
     }
 
-    ~scoped_array() BOOST_SP_NOEXCEPT
+    ~scoped_array() noexcept
     {
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
-        boost::sp_array_destructor_hook( px );
-#endif
         boost::checked_array_delete( px );
     }
 
@@ -83,15 +66,17 @@ public:
         return px[i];
     }
 
-    T * get() const BOOST_SP_NOEXCEPT
+    T * get() const noexcept
     {
         return px;
     }
 
-// implicit conversion to "bool"
-#include <boost/smart_ptr/detail/operator_bool.hpp>
+    explicit operator bool () const noexcept
+    {
+        return px != 0;
+    }
 
-    void swap(scoped_array & b) BOOST_SP_NOEXCEPT
+    void swap(scoped_array & b) noexcept
     {
         T * tmp = b.px;
         b.px = px;
@@ -99,31 +84,27 @@ public:
     }
 };
 
-#if !defined( BOOST_NO_CXX11_NULLPTR )
-
-template<class T> inline bool operator==( scoped_array<T> const & p, boost::detail::sp_nullptr_t ) BOOST_SP_NOEXCEPT
+template<class T> inline bool operator==( scoped_array<T> const & p, std::nullptr_t ) noexcept
 {
     return p.get() == 0;
 }
 
-template<class T> inline bool operator==( boost::detail::sp_nullptr_t, scoped_array<T> const & p ) BOOST_SP_NOEXCEPT
+template<class T> inline bool operator==( std::nullptr_t, scoped_array<T> const & p ) noexcept
 {
     return p.get() == 0;
 }
 
-template<class T> inline bool operator!=( scoped_array<T> const & p, boost::detail::sp_nullptr_t ) BOOST_SP_NOEXCEPT
+template<class T> inline bool operator!=( scoped_array<T> const & p, std::nullptr_t ) noexcept
 {
     return p.get() != 0;
 }
 
-template<class T> inline bool operator!=( boost::detail::sp_nullptr_t, scoped_array<T> const & p ) BOOST_SP_NOEXCEPT
+template<class T> inline bool operator!=( std::nullptr_t, scoped_array<T> const & p ) noexcept
 {
     return p.get() != 0;
 }
 
-#endif
-
-template<class T> inline void swap(scoped_array<T> & a, scoped_array<T> & b) BOOST_SP_NOEXCEPT
+template<class T> inline void swap(scoped_array<T> & a, scoped_array<T> & b) noexcept
 {
     a.swap(b);
 }

include/boost/smart_ptr/scoped_ptr.hpp

@@ -10,14 +10,14 @@
 //
 //  See http://www.boost.org/libs/smart_ptr/ for documentation.
 
-#include <boost/smart_ptr/detail/requires_cxx11.hpp>
-#include <boost/config.hpp>
-#include <boost/assert.hpp>
-#include <boost/core/checked_delete.hpp>
-#include <boost/smart_ptr/detail/sp_nullptr_t.hpp>
 #include <boost/smart_ptr/detail/sp_disable_deprecated.hpp>
 #include <boost/smart_ptr/detail/sp_noexcept.hpp>
+#include <boost/smart_ptr/detail/deprecated_macros.hpp>
+#include <boost/core/checked_delete.hpp>
+#include <boost/assert.hpp>
 #include <boost/config/workaround.hpp>
+#include <boost/config.hpp>
+#include <cstddef>
 
 #ifndef BOOST_NO_AUTO_PTR
 # include <memory>          // for std::auto_ptr
@@ -31,15 +31,6 @@
 namespace boost
 {
 
-// Debug hooks
-
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
-
-void sp_scalar_constructor_hook(void * p);
-void sp_scalar_destructor_hook(void * p);
-
-#endif
-
 //  scoped_ptr mimics a built-in pointer except that it guarantees deletion
 //  of the object pointed to, either on destruction of the scoped_ptr or via
 //  an explicit reset(). scoped_ptr is a simple solution for simple needs;
@@ -63,29 +54,20 @@ public:
 
     typedef T element_type;
 
-    explicit scoped_ptr( T * p = 0 ) BOOST_SP_NOEXCEPT : px( p )
+    explicit scoped_ptr( T * p = 0 ) noexcept : px( p )
     {
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
-        boost::sp_scalar_constructor_hook( px );
-#endif
     }
 
 #ifndef BOOST_NO_AUTO_PTR
 
-    explicit scoped_ptr( std::auto_ptr<T> p ) BOOST_SP_NOEXCEPT : px( p.release() )
+    explicit scoped_ptr( std::auto_ptr<T> p ) noexcept : px( p.release() )
     {
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
-        boost::sp_scalar_constructor_hook( px );
-#endif
     }
 
 #endif
 
-    ~scoped_ptr() BOOST_SP_NOEXCEPT
+    ~scoped_ptr() noexcept
     {
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
-        boost::sp_scalar_destructor_hook( px );
-#endif
         boost::checked_delete( px );
     }
 
@@ -107,15 +89,17 @@ public:
         return px;
     }
 
-    T * get() const BOOST_SP_NOEXCEPT
+    T * get() const noexcept
     {
         return px;
     }
 
-// implicit conversion to "bool"
-#include <boost/smart_ptr/detail/operator_bool.hpp>
+    explicit operator bool () const noexcept
+    {
+        return px != 0;
+    }
 
-    void swap(scoped_ptr & b) BOOST_SP_NOEXCEPT
+    void swap(scoped_ptr & b) noexcept
     {
         T * tmp = b.px;
         b.px = px;
@@ -123,38 +107,34 @@ public:
     }
 };
 
-#if !defined( BOOST_NO_CXX11_NULLPTR )
-
-template<class T> inline bool operator==( scoped_ptr<T> const & p, boost::detail::sp_nullptr_t ) BOOST_SP_NOEXCEPT
+template<class T> inline bool operator==( scoped_ptr<T> const & p, std::nullptr_t ) noexcept
 {
     return p.get() == 0;
 }
 
-template<class T> inline bool operator==( boost::detail::sp_nullptr_t, scoped_ptr<T> const & p ) BOOST_SP_NOEXCEPT
+template<class T> inline bool operator==( std::nullptr_t, scoped_ptr<T> const & p ) noexcept
 {
     return p.get() == 0;
 }
 
-template<class T> inline bool operator!=( scoped_ptr<T> const & p, boost::detail::sp_nullptr_t ) BOOST_SP_NOEXCEPT
+template<class T> inline bool operator!=( scoped_ptr<T> const & p, std::nullptr_t ) noexcept
 {
     return p.get() != 0;
 }
 
-template<class T> inline bool operator!=( boost::detail::sp_nullptr_t, scoped_ptr<T> const & p ) BOOST_SP_NOEXCEPT
+template<class T> inline bool operator!=( std::nullptr_t, scoped_ptr<T> const & p ) noexcept
 {
     return p.get() != 0;
 }
 
-#endif
-
-template<class T> inline void swap(scoped_ptr<T> & a, scoped_ptr<T> & b) BOOST_SP_NOEXCEPT
+template<class T> inline void swap(scoped_ptr<T> & a, scoped_ptr<T> & b) noexcept
 {
     a.swap(b);
 }
 
 // get_pointer(p) is a generic way to say p.get()
 
-template<class T> inline T * get_pointer(scoped_ptr<T> const & p) BOOST_SP_NOEXCEPT
+template<class T> inline T * get_pointer(scoped_ptr<T> const & p) noexcept
 {
     return p.get();
 }

include/boost/smart_ptr/shared_array.hpp

@@ -14,24 +14,17 @@
 //  See http://www.boost.org/libs/smart_ptr/ for documentation.
 //
 
-#include <boost/smart_ptr/detail/requires_cxx11.hpp>
-
-#include <boost/config.hpp>   // for broken compiler workarounds
-
-#include <memory>             // TR1 cyclic inclusion fix
-
-#include <boost/assert.hpp>
-#include <boost/core/checked_delete.hpp>
-
 #include <boost/smart_ptr/shared_ptr.hpp>
 #include <boost/smart_ptr/detail/shared_count.hpp>
-#include <boost/smart_ptr/detail/sp_nullptr_t.hpp>
 #include <boost/smart_ptr/detail/sp_noexcept.hpp>
+#include <boost/core/checked_delete.hpp>
+#include <boost/assert.hpp>
+#include <boost/config.hpp>
 #include <boost/config/workaround.hpp>
 
-#include <cstddef>            // for std::ptrdiff_t
 #include <algorithm>          // for std::swap
 #include <functional>         // for std::less
+#include <cstddef>            // for std::ptrdiff_t
 
 namespace boost
 {
@@ -56,18 +49,14 @@ public:
 
     typedef T element_type;
 
-    shared_array() BOOST_SP_NOEXCEPT : px( 0 ), pn()
+    shared_array() noexcept : px( 0 ), pn()
     {
     }
 
-#if !defined( BOOST_NO_CXX11_NULLPTR )
-
-    shared_array( boost::detail::sp_nullptr_t ) BOOST_SP_NOEXCEPT : px( 0 ), pn()
+    shared_array( std::nullptr_t ) noexcept : px( 0 ), pn()
     {
     }
 
-#endif
-
     template<class Y>
     explicit shared_array( Y * p ): px( p ), pn( p, checked_array_deleter<Y>() )
     {
@@ -93,36 +82,23 @@ public:
     }
 
 //  generated copy constructor, destructor are fine...
-
-#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
-
 // ... except in C++0x, move disables the implicit copy
 
-    shared_array( shared_array const & r ) BOOST_SP_NOEXCEPT : px( r.px ), pn( r.pn )
+    shared_array( shared_array const & r ) noexcept : px( r.px ), pn( r.pn )
     {
     }
 
-    shared_array( shared_array && r ) BOOST_SP_NOEXCEPT : px( r.px ), pn()
+    shared_array( shared_array && r ) noexcept : px( r.px ), pn()
     {
         pn.swap( r.pn );
         r.px = 0;
     }
 
-#endif
-
     // conversion
 
     template<class Y>
-#if !defined( BOOST_SP_NO_SP_CONVERTIBLE )
-
     shared_array( shared_array<Y> const & r, typename boost::detail::sp_enable_if_convertible< Y[], T[] >::type = boost::detail::sp_empty() )
-
-#else
-
-    shared_array( shared_array<Y> const & r )
-
-#endif
-    BOOST_SP_NOEXCEPT : px( r.px ), pn( r.pn )
+    noexcept : px( r.px ), pn( r.pn )
     {
         boost::detail::sp_assert_convertible< Y[], T[] >();
     }
@@ -130,47 +106,39 @@ public:
     // aliasing
 
     template< class Y >
-    shared_array( shared_array<Y> const & r, element_type * p ) BOOST_SP_NOEXCEPT : px( p ), pn( r.pn )
+    shared_array( shared_array<Y> const & r, element_type * p ) noexcept : px( p ), pn( r.pn )
     {
     }
 
     // assignment
 
-    shared_array & operator=( shared_array const & r ) BOOST_SP_NOEXCEPT
+    shared_array & operator=( shared_array const & r ) noexcept
     {
         this_type( r ).swap( *this );
         return *this;
     }
 
-#if !defined(BOOST_MSVC) || (BOOST_MSVC >= 1400)
-
     template<class Y>
-    shared_array & operator=( shared_array<Y> const & r ) BOOST_SP_NOEXCEPT
+    shared_array & operator=( shared_array<Y> const & r ) noexcept
     {
         this_type( r ).swap( *this );
         return *this;
     }
 
-#endif
-
-#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
-
-    shared_array & operator=( shared_array && r ) BOOST_SP_NOEXCEPT
+    shared_array & operator=( shared_array && r ) noexcept
     {
         this_type( static_cast< shared_array && >( r ) ).swap( *this );
         return *this;
     }
 
     template<class Y>
-    shared_array & operator=( shared_array<Y> && r ) BOOST_SP_NOEXCEPT
+    shared_array & operator=( shared_array<Y> && r ) noexcept
     {
         this_type( static_cast< shared_array<Y> && >( r ) ).swap( *this );
         return *this;
     }
 
-#endif
-
-    void reset() BOOST_SP_NOEXCEPT
+    void reset() noexcept
     {
         this_type().swap( *this );
     }
@@ -191,7 +159,7 @@ public:
         this_type( p, d, a ).swap( *this );
     }
 
-    template<class Y> void reset( shared_array<Y> const & r, element_type * p ) BOOST_SP_NOEXCEPT
+    template<class Y> void reset( shared_array<Y> const & r, element_type * p ) noexcept
     {
         this_type( r, p ).swap( *this );
     }
@@ -203,31 +171,33 @@ public:
         return px[i];
     }
     
-    T * get() const BOOST_SP_NOEXCEPT
+    T * get() const noexcept
     {
         return px;
     }
 
-// implicit conversion to "bool"
-#include <boost/smart_ptr/detail/operator_bool.hpp>
+    explicit operator bool () const noexcept
+    {
+        return px != 0;
+    }
 
-    bool unique() const BOOST_SP_NOEXCEPT
+    bool unique() const noexcept
     {
         return pn.unique();
     }
 
-    long use_count() const BOOST_SP_NOEXCEPT
+    long use_count() const noexcept
     {
         return pn.use_count();
     }
 
-    void swap(shared_array<T> & other) BOOST_SP_NOEXCEPT
+    void swap(shared_array<T> & other) noexcept
     {
         std::swap(px, other.px);
         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 noexcept
     {
         return pn.get_deleter( ti );
     }
@@ -241,51 +211,47 @@ private:
 
 };  // shared_array
 
-template<class T> inline bool operator==(shared_array<T> const & a, shared_array<T> const & b) BOOST_SP_NOEXCEPT
+template<class T> inline bool operator==(shared_array<T> const & a, shared_array<T> const & b) noexcept
 {
     return a.get() == b.get();
 }
 
-template<class T> inline bool operator!=(shared_array<T> const & a, shared_array<T> const & b) BOOST_SP_NOEXCEPT
+template<class T> inline bool operator!=(shared_array<T> const & a, shared_array<T> const & b) noexcept
 {
     return a.get() != b.get();
 }
 
-#if !defined( BOOST_NO_CXX11_NULLPTR )
-
-template<class T> inline bool operator==( shared_array<T> const & p, boost::detail::sp_nullptr_t ) BOOST_SP_NOEXCEPT
+template<class T> inline bool operator==( shared_array<T> const & p, std::nullptr_t ) noexcept
 {
     return p.get() == 0;
 }
 
-template<class T> inline bool operator==( boost::detail::sp_nullptr_t, shared_array<T> const & p ) BOOST_SP_NOEXCEPT
+template<class T> inline bool operator==( std::nullptr_t, shared_array<T> const & p ) noexcept
 {
     return p.get() == 0;
 }
 
-template<class T> inline bool operator!=( shared_array<T> const & p, boost::detail::sp_nullptr_t ) BOOST_SP_NOEXCEPT
+template<class T> inline bool operator!=( shared_array<T> const & p, std::nullptr_t ) noexcept
 {
     return p.get() != 0;
 }
 
-template<class T> inline bool operator!=( boost::detail::sp_nullptr_t, shared_array<T> const & p ) BOOST_SP_NOEXCEPT
+template<class T> inline bool operator!=( std::nullptr_t, shared_array<T> const & p ) noexcept
 {
     return p.get() != 0;
 }
 
-#endif
-
-template<class T> inline bool operator<(shared_array<T> const & a, shared_array<T> const & b) BOOST_SP_NOEXCEPT
+template<class T> inline bool operator<(shared_array<T> const & a, shared_array<T> const & b) noexcept
 {
     return std::less<T*>()(a.get(), b.get());
 }
 
-template<class T> void swap(shared_array<T> & a, shared_array<T> & b) BOOST_SP_NOEXCEPT
+template<class T> void swap(shared_array<T> & a, shared_array<T> & b) noexcept
 {
     a.swap(b);
 }
 
-template< class D, class T > D * get_deleter( shared_array<T> const & p ) BOOST_SP_NOEXCEPT
+template< class D, class T > D * get_deleter( shared_array<T> const & p ) noexcept
 {
     return static_cast< D * >( p._internal_get_deleter( BOOST_SP_TYPEID_(D) ) );
 }

include/boost/smart_ptr/weak_ptr.hpp

@@ -13,10 +13,8 @@
 //  See http://www.boost.org/libs/smart_ptr/ for documentation.
 //
 
-#include <boost/smart_ptr/detail/requires_cxx11.hpp>
 #include <boost/smart_ptr/detail/shared_count.hpp>
 #include <boost/smart_ptr/shared_ptr.hpp>
-#include <boost/smart_ptr/detail/sp_noexcept.hpp>
 #include <memory>
 #include <cstddef>
 
@@ -34,29 +32,24 @@ public:
 
     typedef typename boost::detail::sp_element< T >::type element_type;
 
-    BOOST_CONSTEXPR weak_ptr() BOOST_SP_NOEXCEPT : px(0), pn()
+    constexpr weak_ptr() noexcept : px(0), pn()
     {
     }
 
 //  generated copy constructor, assignment, destructor are fine...
-
-#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
-
 // ... except in C++0x, move disables the implicit copy
 
-    weak_ptr( weak_ptr const & r ) BOOST_SP_NOEXCEPT : px( r.px ), pn( r.pn )
+    weak_ptr( weak_ptr const & r ) noexcept : px( r.px ), pn( r.pn )
     {
     }
 
-    weak_ptr & operator=( weak_ptr const & r ) BOOST_SP_NOEXCEPT
+    weak_ptr & operator=( weak_ptr const & r ) noexcept
     {
         px = r.px;
         pn = r.pn;
         return *this;
     }
 
-#endif
-
 //
 //  The "obvious" converting constructor implementation:
 //
@@ -75,33 +68,15 @@ public:
 //
 
     template<class Y>
-#if !defined( BOOST_SP_NO_SP_CONVERTIBLE )
-
     weak_ptr( weak_ptr<Y> const & r, typename boost::detail::sp_enable_if_convertible<Y,T>::type = boost::detail::sp_empty() )
-
-#else
-
-    weak_ptr( weak_ptr<Y> const & r )
-
-#endif
-    BOOST_SP_NOEXCEPT : px(r.lock().get()), pn(r.pn)
+    noexcept : px(r.lock().get()), pn(r.pn)
     {
         boost::detail::sp_assert_convertible< Y, T >();
     }
 
-#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
-
     template<class Y>
-#if !defined( BOOST_SP_NO_SP_CONVERTIBLE )
-
     weak_ptr( weak_ptr<Y> && r, typename boost::detail::sp_enable_if_convertible<Y,T>::type = boost::detail::sp_empty() )
-
-#else
-
-    weak_ptr( weak_ptr<Y> && r )
-
-#endif
-    BOOST_SP_NOEXCEPT : px( r.lock().get() ), pn( static_cast< boost::detail::weak_count && >( r.pn ) )
+    noexcept : px( r.lock().get() ), pn( static_cast< boost::detail::weak_count && >( r.pn ) )
     {
         boost::detail::sp_assert_convertible< Y, T >();
         r.px = 0;
@@ -109,57 +84,41 @@ public:
 
     // for better efficiency in the T == Y case
     weak_ptr( weak_ptr && r )
-    BOOST_SP_NOEXCEPT : px( r.px ), pn( static_cast< boost::detail::weak_count && >( r.pn ) )
+    noexcept : px( r.px ), pn( static_cast< boost::detail::weak_count && >( r.pn ) )
     {
         r.px = 0;
     }
 
     // for better efficiency in the T == Y case
-    weak_ptr & operator=( weak_ptr && r ) BOOST_SP_NOEXCEPT
+    weak_ptr & operator=( weak_ptr && r ) noexcept
     {
         this_type( static_cast< weak_ptr && >( r ) ).swap( *this );
         return *this;
     }
 
 
-#endif
-
     template<class Y>
-#if !defined( BOOST_SP_NO_SP_CONVERTIBLE )
-
     weak_ptr( shared_ptr<Y> const & r, typename boost::detail::sp_enable_if_convertible<Y,T>::type = boost::detail::sp_empty() )
-
-#else
-
-    weak_ptr( shared_ptr<Y> const & r )
-
-#endif
-    BOOST_SP_NOEXCEPT : px( r.px ), pn( r.pn )
+    noexcept : px( r.px ), pn( r.pn )
     {
         boost::detail::sp_assert_convertible< Y, T >();
     }
 
     // aliasing
-    template<class Y> weak_ptr(shared_ptr<Y> const & r, element_type * p) BOOST_SP_NOEXCEPT: px( p ), pn( r.pn )
+    template<class Y> weak_ptr(shared_ptr<Y> const & r, element_type * p) noexcept: px( p ), pn( r.pn )
     {
     }
 
-    template<class Y> weak_ptr(weak_ptr<Y> const & r, element_type * p) BOOST_SP_NOEXCEPT: px( p ), pn( r.pn )
+    template<class Y> weak_ptr(weak_ptr<Y> const & r, element_type * p) noexcept: px( p ), pn( r.pn )
     {
     }
 
-#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
-
-    template<class Y> weak_ptr(weak_ptr<Y> && r, element_type * p) BOOST_SP_NOEXCEPT: px( p ), pn( std::move( r.pn ) )
+    template<class Y> weak_ptr(weak_ptr<Y> && r, element_type * p) noexcept: px( p ), pn( std::move( r.pn ) )
     {
     }
 
-#endif
-
-#if !defined(BOOST_MSVC) || (BOOST_MSVC >= 1300)
-
     template<class Y>
-    weak_ptr & operator=( weak_ptr<Y> const & r ) BOOST_SP_NOEXCEPT
+    weak_ptr & operator=( weak_ptr<Y> const & r ) noexcept
     {
         boost::detail::sp_assert_convertible< Y, T >();
 
@@ -169,19 +128,15 @@ public:
         return *this;
     }
 
-#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
-
     template<class Y>
-    weak_ptr & operator=( weak_ptr<Y> && r ) BOOST_SP_NOEXCEPT
+    weak_ptr & operator=( weak_ptr<Y> && r ) noexcept
     {
         this_type( static_cast< weak_ptr<Y> && >( r ) ).swap( *this );
         return *this;
     }
 
-#endif
-
     template<class Y>
-    weak_ptr & operator=( shared_ptr<Y> const & r ) BOOST_SP_NOEXCEPT
+    weak_ptr & operator=( shared_ptr<Y> const & r ) noexcept
     {
         boost::detail::sp_assert_convertible< Y, T >();
 
@@ -191,92 +146,83 @@ public:
         return *this;
     }
 
-#endif
-
-    shared_ptr<T> lock() const BOOST_SP_NOEXCEPT
+    shared_ptr<T> lock() const noexcept
     {
         return shared_ptr<T>( *this, boost::detail::sp_nothrow_tag() );
     }
 
-    long use_count() const BOOST_SP_NOEXCEPT
+    long use_count() const noexcept
     {
         return pn.use_count();
     }
 
-    bool expired() const BOOST_SP_NOEXCEPT
+    bool expired() const noexcept
     {
         return pn.use_count() == 0;
     }
 
-    bool _empty() const BOOST_SP_NOEXCEPT // extension, not in std::weak_ptr
+    bool _empty() const noexcept // extension, not in std::weak_ptr
     {
         return pn.empty();
     }
 
-    bool empty() const BOOST_SP_NOEXCEPT // extension, not in std::weak_ptr
+    bool empty() const noexcept // extension, not in std::weak_ptr
     {
         return pn.empty();
     }
 
-    void reset() BOOST_SP_NOEXCEPT
+    void reset() noexcept
     {
         this_type().swap(*this);
     }
 
-    void swap(this_type & other) BOOST_SP_NOEXCEPT
+    void swap(this_type & other) noexcept
     {
         std::swap(px, other.px);
         pn.swap(other.pn);
     }
 
-    template<class Y> bool owner_before( weak_ptr<Y> const & rhs ) const BOOST_SP_NOEXCEPT
+    template<class Y> bool owner_before( weak_ptr<Y> const & rhs ) const noexcept
     {
         return pn < rhs.pn;
     }
 
-    template<class Y> bool owner_before( shared_ptr<Y> const & rhs ) const BOOST_SP_NOEXCEPT
+    template<class Y> bool owner_before( shared_ptr<Y> const & rhs ) const noexcept
     {
         return pn < rhs.pn;
     }
 
-    template<class Y> bool owner_equals( weak_ptr<Y> const & rhs ) const BOOST_SP_NOEXCEPT
+    template<class Y> bool owner_equals( weak_ptr<Y> const & rhs ) const noexcept
     {
         return pn == rhs.pn;
     }
 
-    template<class Y> bool owner_equals( shared_ptr<Y> const & rhs ) const BOOST_SP_NOEXCEPT
+    template<class Y> bool owner_equals( shared_ptr<Y> const & rhs ) const noexcept
     {
         return pn == rhs.pn;
     }
 
-    std::size_t owner_hash_value() const BOOST_SP_NOEXCEPT
+    std::size_t owner_hash_value() const noexcept
     {
         return pn.hash_value();
     }
 
-// Tasteless as this may seem, making all members public allows member templates
-// to work in the absence of member template friends. (Matthew Langston)
-
-#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
-
 private:
 
     template<class Y> friend class weak_ptr;
     template<class Y> friend class shared_ptr;
 
-#endif
-
     element_type * px;            // contained pointer
     boost::detail::weak_count pn; // reference counter
 
 };  // weak_ptr
 
-template<class T, class U> inline bool operator<(weak_ptr<T> const & a, weak_ptr<U> const & b) BOOST_SP_NOEXCEPT
+template<class T, class U> inline bool operator<(weak_ptr<T> const & a, weak_ptr<U> const & b) noexcept
 {
     return a.owner_before( b );
 }
 
-template<class T> void swap(weak_ptr<T> & a, weak_ptr<T> & b) BOOST_SP_NOEXCEPT
+template<class T> void swap(weak_ptr<T> & a, weak_ptr<T> & b) noexcept
 {
     a.swap(b);
 }
@@ -289,7 +235,7 @@ template<class T> weak_ptr( shared_ptr<T> ) -> weak_ptr<T>;
 
 // hash_value
 
-template< class T > std::size_t hash_value( boost::weak_ptr<T> const & p ) BOOST_SP_NOEXCEPT
+template< class T > std::size_t hash_value( boost::weak_ptr<T> const & p ) noexcept
 {
     return p.owner_hash_value();
 }
@@ -301,21 +247,17 @@ template< class T > std::size_t hash_value( boost::weak_ptr<T> const & p ) BOOST
 namespace std
 {
 
-#if !defined(BOOST_NO_CXX11_HDR_FUNCTIONAL)
-
 template<class T> struct hash< ::boost::weak_ptr<T> >
 {
-    std::size_t operator()( ::boost::weak_ptr<T> const & p ) const BOOST_SP_NOEXCEPT
+    std::size_t operator()( ::boost::weak_ptr<T> const & p ) const noexcept
     {
         return p.owner_hash_value();
     }
 };
 
-#endif // #if !defined(BOOST_NO_CXX11_HDR_FUNCTIONAL)
-
 template<class T> struct equal_to< ::boost::weak_ptr<T> >
 {
-    bool operator()( ::boost::weak_ptr<T> const & a, ::boost::weak_ptr<T> const & b ) const BOOST_SP_NOEXCEPT
+    bool operator()( ::boost::weak_ptr<T> const & a, ::boost::weak_ptr<T> const & b ) const noexcept
     {
         return a.owner_equals( b );
     }

meta/libraries.json

@@ -18,5 +18,5 @@
     "maintainers": [
         "Peter Dimov <pdimov -at- gmail.com>"
     ],
-    "cxxstd": "03"
+    "cxxstd": "11"
 }

test/CMakeLists.txt

@@ -10,6 +10,6 @@ if(HAVE_BOOST_TEST)
 set(THREADS_PREFER_PTHREAD_FLAG ON)
 find_package(Threads)
 
-boost_test_jamfile(FILE Jamfile LINK_LIBRARIES Boost::smart_ptr Boost::core Boost::align Boost::atomic Boost::container_hash Boost::bind Threads::Threads)
+boost_test_jamfile(FILE Jamfile LINK_LIBRARIES Boost::smart_ptr Boost::core Boost::align Boost::atomic Boost::container_hash Boost::bind Boost::move Threads::Threads)
 
 endif()

test/Jamfile

@@ -7,13 +7,25 @@
 #  accompanying file LICENSE_1_0.txt or copy at
 #  http://www.boost.org/LICENSE_1_0.txt)
 
+require-b2 5.0.1 ;
+import-search /boost/config/checks ;
+import config : requires ;
 import testing ;
 
 project
     : requirements
+
+      <library>/boost/smart_ptr//boost_smart_ptr
+      <library>/boost/core//boost_core
+      <library>/boost/align//boost_align
+      <library>/boost/atomic//boost_atomic
+      <library>/boost/container_hash//boost_container_hash
+      <library>/boost/bind//boost_bind
+      <library>/boost/move//boost_move
+
       <toolset>gcc:<cxxflags>-Wno-non-virtual-dtor
       <toolset>gcc:<cxxflags>-Wno-deprecated-declarations
-      #<toolset>gcc:<cxxflags>-Wno-delete-non-virtual-dtor (not in 4.4/4.6)
+      <toolset>gcc:<cxxflags>-Wno-delete-non-virtual-dtor
     ;
 
 # quick test (for CI)
@@ -57,11 +69,7 @@ run yield_k_test.cpp : : : <threading>multi : yield_k_test.mt ;
 run spinlock_test.cpp ;
 run spinlock_try_test.cpp ;
 run spinlock_try_test.cpp : : : <threading>multi : spinlock_try_test.mt ;
-run spinlock_pool_test.cpp
-  : : :
-  # msvc-8.0, 9.0 optimizer codegen bug for `x % 41`
-  <toolset>msvc-8.0,<variant>release:<build>no
-  <toolset>msvc-9.0,<variant>release:<build>no ;
+run spinlock_pool_test.cpp ;
 
 run make_shared_test.cpp ;
 run make_shared_move_emulation_test.cpp
@@ -86,8 +94,7 @@ run sp_recursive_assign2_test.cpp ;
 run sp_recursive_assign_rv_test.cpp ;
 run sp_recursive_assign2_rv_test.cpp ;
 
-compile-fail auto_ptr_lv_fail.cpp
-  : <toolset>gcc-4.4.7:<build>no <toolset>gcc-4.4:<build>no ;
+compile-fail auto_ptr_lv_fail.cpp ;
 
 run atomic_count_test2.cpp ;
 run sp_typeinfo_test.cpp ;
@@ -168,33 +175,23 @@ compile-fail array_fail_dereference.cpp ;
 compile-fail array_fail_member_access.cpp ;
 compile-fail array_fail_array_access.cpp ;
 
-run make_shared_array_test.cpp
-  : : : <toolset>msvc-8.0:<build>no ;
+run make_shared_array_test.cpp ;
 run make_shared_arrays_test.cpp ;
-run make_shared_array_throws_test.cpp
-  : : : <toolset>msvc-8.0:<build>no ;
-run make_shared_array_esft_test.cpp
-  : : : <toolset>msvc-8.0:<build>no ;
-run make_shared_array_noinit_test.cpp
-  : : : <toolset>msvc-8.0:<build>no ;
-run make_shared_array_value_test.cpp
-  : : : <toolset>msvc-8.0:<build>no ;
+run make_shared_array_throws_test.cpp ;
+run make_shared_array_esft_test.cpp ;
+run make_shared_array_noinit_test.cpp ;
+run make_shared_array_value_test.cpp ;
 run allocate_shared_array_test.cpp ;
 run allocate_shared_arrays_test.cpp ;
-run allocate_shared_array_throws_test.cpp
-  : : : <toolset>msvc-8.0:<build>no ;
-run allocate_shared_array_esft_test.cpp
-  : : : <toolset>msvc-8.0:<build>no ;
-run allocate_shared_array_noinit_test.cpp
-  : : : <toolset>msvc-8.0:<build>no ;
-run allocate_shared_array_value_test.cpp
-  : : : <toolset>msvc-8.0:<build>no ;
+run allocate_shared_array_throws_test.cpp ;
+run allocate_shared_array_esft_test.cpp ;
+run allocate_shared_array_noinit_test.cpp ;
+run allocate_shared_array_value_test.cpp ;
 run allocate_shared_array_construct_test.cpp ;
 
 run make_unique_test.cpp ;
 run make_unique_args_test.cpp ;
-run make_unique_value_test.cpp
-  : : : <toolset>gcc-4.6:<cxxflags>-fno-deduce-init-list ;
+run make_unique_value_test.cpp ;
 run make_unique_noinit_test.cpp ;
 run make_unique_throws_test.cpp ;
 run make_unique_array_test.cpp ;
@@ -248,6 +245,7 @@ run atomic_sp_test.cpp ;
 
 run sp_constexpr_test.cpp ;
 run sp_constexpr_test2.cpp ;
+compile ip_constexpr_test.cpp ;
 
 run atomic_sp_constexpr_test.cpp ;
 
@@ -256,8 +254,7 @@ run shared_ptr_fn_test.cpp ;
 run get_deleter_test2.cpp ;
 run get_deleter_test3.cpp ;
 run get_deleter_array_test2.cpp ;
-run get_deleter_array_test3.cpp
-  : : : <toolset>msvc-8.0:<build>no ;
+run get_deleter_array_test3.cpp ;
 
 run sp_convertible_test2.cpp ;
 
@@ -279,15 +276,13 @@ run allocate_local_shared_test.cpp ;
 run allocate_local_shared_esft_test.cpp ;
 
 run make_local_shared_array_test.cpp ;
-run make_local_shared_arrays_test.cpp
-  : : : <toolset>gcc-4.6.3_0x:<cxxflags>-fno-deduce-init-list ;
+run make_local_shared_arrays_test.cpp ;
 run make_local_shared_array_throws_test.cpp ;
 run make_local_shared_array_esft_test.cpp ;
 run make_local_shared_array_noinit_test.cpp ;
 run make_local_shared_array_value_test.cpp ;
 run allocate_local_shared_array_test.cpp ;
-run allocate_local_shared_arrays_test.cpp
-  : : : <toolset>gcc-4.6.3_0x:<cxxflags>-fno-deduce-init-list ;
+run allocate_local_shared_arrays_test.cpp ;
 run allocate_local_shared_array_throws_test.cpp ;
 run allocate_local_shared_array_esft_test.cpp ;
 run allocate_local_shared_array_noinit_test.cpp ;
@@ -298,8 +293,7 @@ run local_sp_fn_test.cpp ;
 run lsp_convertible_test.cpp ;
 run lsp_convertible_test2.cpp ;
 
-run make_shared_array_tmp_test.cpp
-  : : : <toolset>msvc-8.0:<build>no ;
+run make_shared_array_tmp_test.cpp ;
 
 run lw_thread_test.cpp
   : : : <threading>multi ;
@@ -329,17 +323,17 @@ explicit abi_test_nt ;
 run abi_test_main.cpp abi_test_mt : : : <define>BOOST_DISABLE_THREADS : abi_test_nt_mt ;
 run abi_test_main.cpp abi_test_nt : : : : abi_test_mt_nt ;
 
-run abi_test_main.cpp abi_test_mt/<cxxstd>0x : : : <cxxstd>98 : abi_test_03_11 ;
-run abi_test_main.cpp abi_test_mt/<cxxstd>98 : : : <cxxstd>0x : abi_test_11_03 ;
+# run abi_test_main.cpp abi_test_mt/<cxxstd>0x : : : <cxxstd>98 : abi_test_03_11 ;
+# run abi_test_main.cpp abi_test_mt/<cxxstd>98 : : : <cxxstd>0x : abi_test_11_03 ;
 
 run weak_ptr_alias_test.cpp ;
 run weak_ptr_alias_move_test.cpp ;
 
 run sp_typeinfo_test.cpp : : : <rtti>off : sp_typeinfo_test_no_rtti ;
 
-run get_deleter_test.cpp  : : : <rtti>off <toolset>gcc-4.4.7,<cxxstd>0x:<build>no <toolset>gcc-4.4,<cxxstd>0x:<build>no : get_deleter_test_no_rtti ;
-run get_deleter_test2.cpp : : : <rtti>off <toolset>gcc-4.4.7,<cxxstd>0x:<build>no <toolset>gcc-4.4,<cxxstd>0x:<build>no : get_deleter_test2_no_rtti ;
-run get_deleter_test3.cpp : : : <rtti>off <toolset>gcc-4.4.7,<cxxstd>0x:<build>no <toolset>gcc-4.4,<cxxstd>0x:<build>no : get_deleter_test3_no_rtti ;
+run get_deleter_test.cpp  : : : <rtti>off : get_deleter_test_no_rtti ;
+run get_deleter_test2.cpp : : : <rtti>off : get_deleter_test2_no_rtti ;
+run get_deleter_test3.cpp : : : <rtti>off : get_deleter_test3_no_rtti ;
 
 run shared_from_test.cpp ;
 run weak_from_test.cpp ;
@@ -368,11 +362,16 @@ compile-fail shared_from_fail.cpp ;
 compile-fail weak_from_fail.cpp ;
 
 compile sp_override_test.cpp ;
+
+local gcc-flags = -Wundef ;
+
 compile sp_pedantic_test.cpp
   : <warnings>pedantic
     <toolset>msvc:<warnings-as-errors>on
     <toolset>gcc:<warnings-as-errors>on
+    <toolset>gcc:<cxxflags>$(gcc-flags)
     <toolset>clang:<warnings-as-errors>on
+    <toolset>clang:<cxxflags>$(gcc-flags)
     <toolset>clang-15:<cxxflags>-Wno-deprecated-builtins
     ;
 
@@ -388,6 +387,7 @@ run owner_less_test2.cpp ;
 
 run ip_hash_test2.cpp ;
 run sp_hash_test4.cpp ;
+
 run lsp_hash_test.cpp ;
 run lsp_hash_test2.cpp ;
 
@@ -420,3 +420,12 @@ run sp_unordered_test.cpp ;
 
 run sp_unique_ptr_test2.cpp ;
 run sp_move_only_deleter.cpp ;
+
+run sp_is_bounded_array_test.cpp ;
+run sp_is_unbounded_array_test.cpp ;
+run sp_type_identity_test.cpp ;
+run sp_type_with_alignment_test.cpp ;
+
+run sp_ostream_test.cpp ;
+run ip_ostream_test.cpp ;
+run lsp_ostream_test.cpp ;

test/allocate_local_shared_array_construct_test.cpp

@@ -5,12 +5,9 @@ Copyright 2017 Glen Joseph Fernandes
 Distributed under the Boost Software License, Version 1.0.
 (http://www.boost.org/LICENSE_1_0.txt)
 */
-#include <boost/config.hpp>
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && \
-    !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && \
-    !defined(BOOST_NO_CXX11_ALLOCATOR)
-#include <boost/core/lightweight_test.hpp>
 #include <boost/smart_ptr/make_local_shared.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <boost/config.hpp>
 
 struct allow { };
 
@@ -157,9 +154,3 @@ int main()
     }
     return boost::report_errors();
 }
-#else
-int main()
-{
-    return 0;
-}
-#endif

test/allocate_local_shared_array_esft_test.cpp

@@ -5,12 +5,10 @@ Copyright 2017 Glen Joseph Fernandes
 Distributed under the Boost Software License, Version 1.0.
 (http://www.boost.org/LICENSE_1_0.txt)
 */
-#include <boost/config.hpp>
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && \
-    !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-#include <boost/core/lightweight_test.hpp>
-#include <boost/smart_ptr/enable_shared_from_this.hpp>
 #include <boost/smart_ptr/make_local_shared.hpp>
+#include <boost/smart_ptr/enable_shared_from_this.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <boost/config.hpp>
 
 template<class T = void>
 struct creator {
@@ -95,9 +93,3 @@ int main()
     }
     return boost::report_errors();
 }
-#else
-int main()
-{
-    return 0;
-}
-#endif

test/allocate_local_shared_array_noinit_test.cpp

@@ -5,14 +5,12 @@ Copyright 2017 Glen Joseph Fernandes
 Distributed under the Boost Software License, Version 1.0.
 (http://www.boost.org/LICENSE_1_0.txt)
 */
-#include <boost/config.hpp>
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && \
-    !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-#include <boost/align/is_aligned.hpp>
-#include <boost/core/lightweight_test.hpp>
 #include <boost/smart_ptr/make_local_shared.hpp>
 #include <boost/smart_ptr/weak_ptr.hpp>
-#include <boost/type_traits/alignment_of.hpp>
+#include <boost/align/is_aligned.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <boost/config.hpp>
+#include <type_traits>
 
 template<class T = void>
 struct creator {
@@ -89,7 +87,7 @@ int main()
         BOOST_TEST(result.get() != 0);
         BOOST_TEST(result.local_use_count() == 1);
         BOOST_TEST(boost::alignment::is_aligned(result.get(),
-            boost::alignment_of<int>::value));
+            std::alignment_of<int>::value));
     }
     {
         boost::local_shared_ptr<int[3]> result =
@@ -97,7 +95,7 @@ int main()
         BOOST_TEST(result.get() != 0);
         BOOST_TEST(result.local_use_count() == 1);
         BOOST_TEST(boost::alignment::is_aligned(result.get(),
-            boost::alignment_of<int>::value));
+            std::alignment_of<int>::value));
     }
     {
         boost::local_shared_ptr<int[][2]> result =
@@ -105,7 +103,7 @@ int main()
         BOOST_TEST(result.get() != 0);
         BOOST_TEST(result.local_use_count() == 1);
         BOOST_TEST(boost::alignment::is_aligned(result.get(),
-            boost::alignment_of<int>::value));
+            std::alignment_of<int>::value));
     }
     {
         boost::local_shared_ptr<int[2][2]> result =
@@ -113,7 +111,7 @@ int main()
         BOOST_TEST(result.get() != 0);
         BOOST_TEST(result.local_use_count() == 1);
         BOOST_TEST(boost::alignment::is_aligned(result.get(),
-            boost::alignment_of<int>::value));
+            std::alignment_of<int>::value));
     }
     {
         boost::local_shared_ptr<const int[]> result =
@@ -121,7 +119,7 @@ int main()
         BOOST_TEST(result.get() != 0);
         BOOST_TEST(result.local_use_count() == 1);
         BOOST_TEST(boost::alignment::is_aligned(result.get(),
-            boost::alignment_of<int>::value));
+            std::alignment_of<int>::value));
     }
     {
         boost::local_shared_ptr<const int[3]> result =
@@ -129,7 +127,7 @@ int main()
         BOOST_TEST(result.get() != 0);
         BOOST_TEST(result.local_use_count() == 1);
         BOOST_TEST(boost::alignment::is_aligned(result.get(),
-            boost::alignment_of<int>::value));
+            std::alignment_of<int>::value));
     }
     {
         boost::local_shared_ptr<const int[][2]> result =
@@ -137,7 +135,7 @@ int main()
         BOOST_TEST(result.get() != 0);
         BOOST_TEST(result.local_use_count() == 1);
         BOOST_TEST(boost::alignment::is_aligned(result.get(),
-            boost::alignment_of<int>::value));
+            std::alignment_of<int>::value));
     }
     {
         boost::local_shared_ptr<const int[2][2]> result =
@@ -145,7 +143,7 @@ int main()
         BOOST_TEST(result.get() != 0);
         BOOST_TEST(result.local_use_count() == 1);
         BOOST_TEST(boost::alignment::is_aligned(result.get(),
-            boost::alignment_of<int>::value));
+            std::alignment_of<int>::value));
     }
     {
         boost::local_shared_ptr<type[]> result =
@@ -153,7 +151,7 @@ int main()
         BOOST_TEST(result.get() != 0);
         BOOST_TEST(result.local_use_count() == 1);
         BOOST_TEST(boost::alignment::is_aligned(result.get(),
-            boost::alignment_of<type>::value));
+            std::alignment_of<type>::value));
         BOOST_TEST(type::instances == 3);
         boost::weak_ptr<type[]> other = result;
         result.reset();
@@ -165,7 +163,7 @@ int main()
         BOOST_TEST(result.get() != 0);
         BOOST_TEST(result.local_use_count() == 1);
         BOOST_TEST(boost::alignment::is_aligned(result.get(),
-            boost::alignment_of<type>::value));
+            std::alignment_of<type>::value));
         BOOST_TEST(type::instances == 3);
         boost::weak_ptr<type[3]> other = result;
         result.reset();
@@ -177,7 +175,7 @@ int main()
         BOOST_TEST(result.get() != 0);
         BOOST_TEST(result.local_use_count() == 1);
         BOOST_TEST(boost::alignment::is_aligned(result.get(),
-            boost::alignment_of<type>::value));
+            std::alignment_of<type>::value));
         BOOST_TEST(type::instances == 4);
         boost::weak_ptr<type[][2]> other = result;
         result.reset();
@@ -189,7 +187,7 @@ int main()
         BOOST_TEST(result.get() != 0);
         BOOST_TEST(result.local_use_count() == 1);
         BOOST_TEST(boost::alignment::is_aligned(result.get(),
-            boost::alignment_of<type>::value));
+            std::alignment_of<type>::value));
         BOOST_TEST(type::instances == 4);
         boost::weak_ptr<type[2][2]> other = result;
         result.reset();
@@ -201,7 +199,7 @@ int main()
         BOOST_TEST(result.get() != 0);
         BOOST_TEST(result.local_use_count() == 1);
         BOOST_TEST(boost::alignment::is_aligned(result.get(),
-            boost::alignment_of<type>::value));
+            std::alignment_of<type>::value));
         BOOST_TEST(type::instances == 3);
         boost::weak_ptr<const type[]> other = result;
         result.reset();
@@ -213,7 +211,7 @@ int main()
         BOOST_TEST(result.get() != 0);
         BOOST_TEST(result.local_use_count() == 1);
         BOOST_TEST(boost::alignment::is_aligned(result.get(),
-            boost::alignment_of<type>::value));
+            std::alignment_of<type>::value));
         BOOST_TEST(type::instances == 3);
         boost::weak_ptr<const type[3]> other = result;
         result.reset();
@@ -226,7 +224,7 @@ int main()
         BOOST_TEST(result.get() != 0);
         BOOST_TEST(result.local_use_count() == 1);
         BOOST_TEST(boost::alignment::is_aligned(result.get(),
-            boost::alignment_of<type>::value));
+            std::alignment_of<type>::value));
         BOOST_TEST(type::instances == 4);
         boost::weak_ptr<const type[][2]> other = result;
         result.reset();
@@ -238,7 +236,7 @@ int main()
         BOOST_TEST(result.get() != 0);
         BOOST_TEST(result.local_use_count() == 1);
         BOOST_TEST(boost::alignment::is_aligned(result.get(),
-            boost::alignment_of<type>::value));
+            std::alignment_of<type>::value));
         BOOST_TEST(type::instances == 4);
         boost::weak_ptr<const type[2][2]> other = result;
         result.reset();
@@ -246,9 +244,3 @@ int main()
     }
     return boost::report_errors();
 }
-#else
-int main()
-{
-    return 0;
-}
-#endif

test/allocate_local_shared_array_test.cpp

@@ -5,14 +5,12 @@ Copyright 2017 Glen Joseph Fernandes
 Distributed under the Boost Software License, Version 1.0.
 (http://www.boost.org/LICENSE_1_0.txt)
 */
-#include <boost/config.hpp>
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && \
-    !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-#include <boost/align/is_aligned.hpp>
-#include <boost/core/lightweight_test.hpp>
 #include <boost/smart_ptr/make_local_shared.hpp>
 #include <boost/smart_ptr/weak_ptr.hpp>
-#include <boost/type_traits/alignment_of.hpp>
+#include <boost/align/is_aligned.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <boost/config.hpp>
+#include <type_traits>
 
 template<class T = void>
 struct creator {
@@ -89,7 +87,7 @@ int main()
         BOOST_TEST(result.get() != 0);
         BOOST_TEST(result.local_use_count() == 1);
         BOOST_TEST(boost::alignment::is_aligned(result.get(),
-            boost::alignment_of<int>::value));
+            std::alignment_of<int>::value));
         BOOST_TEST(result[0] == 0);
         BOOST_TEST(result[1] == 0);
         BOOST_TEST(result[2] == 0);
@@ -100,7 +98,7 @@ int main()
         BOOST_TEST(result.get() != 0);
         BOOST_TEST(result.local_use_count() == 1);
         BOOST_TEST(boost::alignment::is_aligned(result.get(),
-            boost::alignment_of<int>::value));
+            std::alignment_of<int>::value));
         BOOST_TEST(result[0] == 0);
         BOOST_TEST(result[1] == 0);
         BOOST_TEST(result[2] == 0);
@@ -111,7 +109,7 @@ int main()
         BOOST_TEST(result.get() != 0);
         BOOST_TEST(result.local_use_count() == 1);
         BOOST_TEST(boost::alignment::is_aligned(result.get(),
-            boost::alignment_of<int>::value));
+            std::alignment_of<int>::value));
         BOOST_TEST(result[0][0] == 0);
         BOOST_TEST(result[0][1] == 0);
         BOOST_TEST(result[1][0] == 0);
@@ -123,7 +121,7 @@ int main()
         BOOST_TEST(result.get() != 0);
         BOOST_TEST(result.local_use_count() == 1);
         BOOST_TEST(boost::alignment::is_aligned(result.get(),
-            boost::alignment_of<int>::value));
+            std::alignment_of<int>::value));
         BOOST_TEST(result[0][0] == 0);
         BOOST_TEST(result[0][1] == 0);
         BOOST_TEST(result[1][0] == 0);
@@ -135,7 +133,7 @@ int main()
         BOOST_TEST(result.get() != 0);
         BOOST_TEST(result.local_use_count() == 1);
         BOOST_TEST(boost::alignment::is_aligned(result.get(),
-            boost::alignment_of<int>::value));
+            std::alignment_of<int>::value));
         BOOST_TEST(result[0] == 0);
         BOOST_TEST(result[1] == 0);
         BOOST_TEST(result[2] == 0);
@@ -146,7 +144,7 @@ int main()
         BOOST_TEST(result.get() != 0);
         BOOST_TEST(result.local_use_count() == 1);
         BOOST_TEST(boost::alignment::is_aligned(result.get(),
-            boost::alignment_of<int>::value));
+            std::alignment_of<int>::value));
         BOOST_TEST(result[0] == 0);
         BOOST_TEST(result[1] == 0);
         BOOST_TEST(result[2] == 0);
@@ -157,7 +155,7 @@ int main()
         BOOST_TEST(result.get() != 0);
         BOOST_TEST(result.local_use_count() == 1);
         BOOST_TEST(boost::alignment::is_aligned(result.get(),
-            boost::alignment_of<int>::value));
+            std::alignment_of<int>::value));
         BOOST_TEST(result[0][0] == 0);
         BOOST_TEST(result[0][1] == 0);
         BOOST_TEST(result[1][0] == 0);
@@ -169,7 +167,7 @@ int main()
         BOOST_TEST(result.get() != 0);
         BOOST_TEST(result.local_use_count() == 1);
         BOOST_TEST(boost::alignment::is_aligned(result.get(),
-            boost::alignment_of<int>::value));
+            std::alignment_of<int>::value));
         BOOST_TEST(result[0][0] == 0);
         BOOST_TEST(result[0][1] == 0);
         BOOST_TEST(result[1][0] == 0);
@@ -181,7 +179,7 @@ int main()
         BOOST_TEST(result.get() != 0);
         BOOST_TEST(result.local_use_count() == 1);
         BOOST_TEST(boost::alignment::is_aligned(result.get(),
-            boost::alignment_of<type>::value));
+            std::alignment_of<type>::value));
         BOOST_TEST(type::instances == 3);
         boost::weak_ptr<type[]> w1 = result;
         result.reset();
@@ -193,7 +191,7 @@ int main()
         BOOST_TEST(result.get() != 0);
         BOOST_TEST(result.local_use_count() == 1);
         BOOST_TEST(boost::alignment::is_aligned(result.get(),
-            boost::alignment_of<type>::value));
+            std::alignment_of<type>::value));
         BOOST_TEST(type::instances == 3);
         boost::weak_ptr<type[3]> w1 = result;
         result.reset();
@@ -205,7 +203,7 @@ int main()
         BOOST_TEST(result.get() != 0);
         BOOST_TEST(result.local_use_count() == 1);
         BOOST_TEST(boost::alignment::is_aligned(result.get(),
-            boost::alignment_of<type>::value));
+            std::alignment_of<type>::value));
         BOOST_TEST(type::instances == 4);
         result.reset();
         BOOST_TEST(type::instances == 0);
@@ -216,7 +214,7 @@ int main()
         BOOST_TEST(result.get() != 0);
         BOOST_TEST(result.local_use_count() == 1);
         BOOST_TEST(boost::alignment::is_aligned(result.get(),
-            boost::alignment_of<type>::value));
+            std::alignment_of<type>::value));
         BOOST_TEST(type::instances == 4);
         result.reset();
         BOOST_TEST(type::instances == 0);
@@ -227,7 +225,7 @@ int main()
         BOOST_TEST(result.get() != 0);
         BOOST_TEST(result.local_use_count() == 1);
         BOOST_TEST(boost::alignment::is_aligned(result.get(),
-            boost::alignment_of<type>::value));
+            std::alignment_of<type>::value));
         BOOST_TEST(type::instances == 3);
         result.reset();
         BOOST_TEST(type::instances == 0);
@@ -238,7 +236,7 @@ int main()
         BOOST_TEST(result.get() != 0);
         BOOST_TEST(result.local_use_count() == 1);
         BOOST_TEST(boost::alignment::is_aligned(result.get(),
-            boost::alignment_of<type>::value));
+            std::alignment_of<type>::value));
         BOOST_TEST(type::instances == 3);
         result.reset();
         BOOST_TEST(type::instances == 0);
@@ -249,7 +247,7 @@ int main()
         BOOST_TEST(result.get() != 0);
         BOOST_TEST(result.local_use_count() == 1);
         BOOST_TEST(boost::alignment::is_aligned(result.get(),
-            boost::alignment_of<type>::value));
+            std::alignment_of<type>::value));
         BOOST_TEST(type::instances == 4);
         result.reset();
         BOOST_TEST(type::instances == 0);
@@ -260,16 +258,10 @@ int main()
         BOOST_TEST(result.get() != 0);
         BOOST_TEST(result.local_use_count() == 1);
         BOOST_TEST(boost::alignment::is_aligned(result.get(),
-            boost::alignment_of<type>::value));
+            std::alignment_of<type>::value));
         BOOST_TEST(type::instances == 4);
         result.reset();
         BOOST_TEST(type::instances == 0);
     }
     return boost::report_errors();
 }
-#else
-int main()
-{
-    return 0;
-}
-#endif

test/allocate_local_shared_array_throws_test.cpp

@@ -5,11 +5,9 @@ Copyright 2017 Glen Joseph Fernandes
 Distributed under the Boost Software License, Version 1.0.
 (http://www.boost.org/LICENSE_1_0.txt)
 */
-#include <boost/config.hpp>
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && \
-    !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-#include <boost/core/lightweight_test.hpp>
 #include <boost/smart_ptr/make_local_shared.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <boost/config.hpp>
 
 template<class T = void>
 struct creator {
@@ -122,9 +120,3 @@ int main()
     }
     return boost::report_errors();
 }
-#else
-int main()
-{
-    return 0;
-}
-#endif

test/allocate_local_shared_array_value_test.cpp

@@ -5,11 +5,9 @@ Copyright 2017 Glen Joseph Fernandes
 Distributed under the Boost Software License, Version 1.0.
 (http://www.boost.org/LICENSE_1_0.txt)
 */
-#include <boost/config.hpp>
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && \
-    !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-#include <boost/core/lightweight_test.hpp>
 #include <boost/smart_ptr/make_local_shared.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <boost/config.hpp>
 
 template<class T = void>
 struct creator {
@@ -84,9 +82,3 @@ int main()
     }
     return boost::report_errors();
 }
-#else
-int main()
-{
-    return 0;
-}
-#endif

test/allocate_local_shared_arrays_test.cpp

@@ -5,12 +5,9 @@ Copyright 2017 Glen Joseph Fernandes
 Distributed under the Boost Software License, Version 1.0.
 (http://www.boost.org/LICENSE_1_0.txt)
 */
-#include <boost/config.hpp>
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && \
-    !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && \
-    !defined(BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX)
-#include <boost/core/lightweight_test.hpp>
 #include <boost/smart_ptr/make_local_shared.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <boost/config.hpp>
 
 template<class T = void>
 struct creator {
@@ -85,9 +82,3 @@ int main()
     }
     return boost::report_errors();
 }
-#else
-int main()
-{
-    return 0;
-}
-#endif

test/allocate_local_shared_esft_test.cpp

@@ -6,20 +6,11 @@
 //  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_CXX11_RVALUE_REFERENCES ) || defined( BOOST_NO_CXX11_VARIADIC_TEMPLATES )
-
-int main()
-{
-}
-
-#else
-
-#include <boost/core/lightweight_test.hpp>
 #include <boost/smart_ptr/make_local_shared.hpp>
 #include <boost/shared_ptr.hpp>
 #include <boost/enable_shared_from_this.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <boost/config.hpp>
 #include <memory>
 
 class X: public boost::enable_shared_from_this<X>
@@ -294,5 +285,3 @@ int main()
 
     return boost::report_errors();
 }
-
-#endif

test/allocate_local_shared_test.cpp

@@ -6,20 +6,11 @@
 // 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_CXX11_RVALUE_REFERENCES ) || defined( BOOST_NO_CXX11_VARIADIC_TEMPLATES )
-
-int main()
-{
-}
-
-#else
-
-#include <boost/core/lightweight_test.hpp>
 #include <boost/smart_ptr/make_local_shared.hpp>
 #include <boost/smart_ptr/local_shared_ptr.hpp>
 #include <boost/weak_ptr.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <boost/config.hpp>
 #include <cstddef>
 
 class X
@@ -231,5 +222,3 @@ int main()
 
     return boost::report_errors();
 }
-
-#endif

test/allocate_shared_alloc11_test.cpp

@@ -15,8 +15,6 @@
 #include <boost/config.hpp>
 #include <cstddef>
 
-#if !defined( BOOST_NO_CXX11_ALLOCATOR )
-
 template< class T > class cxx11_allocator
 {
 public:
@@ -230,12 +228,3 @@ int main()
 
     return boost::report_errors();
 }
-
-#else // !defined( BOOST_NO_CXX11_ALLOCATOR )
-
-int main()
-{
-    return 0;
-}
-
-#endif

test/allocate_shared_array_construct_test.cpp

@@ -5,10 +5,9 @@ Copyright 2012-2015 Glen Joseph Fernandes
 Distributed under the Boost Software License, Version 1.0.
 (http://www.boost.org/LICENSE_1_0.txt)
 */
-#include <boost/config.hpp>
-#if !defined(BOOST_NO_CXX11_ALLOCATOR)
-#include <boost/core/lightweight_test.hpp>
 #include <boost/smart_ptr/make_shared.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <boost/config.hpp>
 
 struct allow { };
 
@@ -155,9 +154,3 @@ int main()
     }
     return boost::report_errors();
 }
-#else
-int main()
-{
-    return 0;
-}
-#endif

test/allocate_shared_array_noinit_test.cpp

@@ -9,7 +9,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/core/lightweight_test.hpp>
 #include <boost/smart_ptr/make_shared.hpp>
 #include <boost/smart_ptr/weak_ptr.hpp>
-#include <boost/type_traits/alignment_of.hpp>
+#include <type_traits>
 
 template<class T = void>
 struct creator {
@@ -86,7 +86,7 @@ int main()
         BOOST_TEST(result.get() != 0);
         BOOST_TEST(result.use_count() == 1);
         BOOST_TEST(boost::alignment::is_aligned(result.get(),
-            boost::alignment_of<int>::value));
+            std::alignment_of<int>::value));
     }
     {
         boost::shared_ptr<int[3]> result =
@@ -94,7 +94,7 @@ int main()
         BOOST_TEST(result.get() != 0);
         BOOST_TEST(result.use_count() == 1);
         BOOST_TEST(boost::alignment::is_aligned(result.get(),
-            boost::alignment_of<int>::value));
+            std::alignment_of<int>::value));
     }
     {
         boost::shared_ptr<int[][2]> result =
@@ -102,7 +102,7 @@ int main()
         BOOST_TEST(result.get() != 0);
         BOOST_TEST(result.use_count() == 1);
         BOOST_TEST(boost::alignment::is_aligned(result.get(),
-            boost::alignment_of<int>::value));
+            std::alignment_of<int>::value));
     }
     {
         boost::shared_ptr<int[2][2]> result =
@@ -110,7 +110,7 @@ int main()
         BOOST_TEST(result.get() != 0);
         BOOST_TEST(result.use_count() == 1);
         BOOST_TEST(boost::alignment::is_aligned(result.get(),
-            boost::alignment_of<int>::value));
+            std::alignment_of<int>::value));
     }
     {
         boost::shared_ptr<const int[]> result =
@@ -118,7 +118,7 @@ int main()
         BOOST_TEST(result.get() != 0);
         BOOST_TEST(result.use_count() == 1);
         BOOST_TEST(boost::alignment::is_aligned(result.get(),
-            boost::alignment_of<int>::value));
+            std::alignment_of<int>::value));
     }
     {
         boost::shared_ptr<const int[3]> result =
@@ -126,7 +126,7 @@ int main()
         BOOST_TEST(result.get() != 0);
         BOOST_TEST(result.use_count() == 1);
         BOOST_TEST(boost::alignment::is_aligned(result.get(),
-            boost::alignment_of<int>::value));
+            std::alignment_of<int>::value));
     }
     {
         boost::shared_ptr<const int[][2]> result =
@@ -134,7 +134,7 @@ int main()
         BOOST_TEST(result.get() != 0);
         BOOST_TEST(result.use_count() == 1);
         BOOST_TEST(boost::alignment::is_aligned(result.get(),
-            boost::alignment_of<int>::value));
+            std::alignment_of<int>::value));
     }
     {
         boost::shared_ptr<const int[2][2]> result =
@@ -142,7 +142,7 @@ int main()
         BOOST_TEST(result.get() != 0);
         BOOST_TEST(result.use_count() == 1);
         BOOST_TEST(boost::alignment::is_aligned(result.get(),
-            boost::alignment_of<int>::value));
+            std::alignment_of<int>::value));
     }
     {
         boost::shared_ptr<type[]> result =
@@ -150,7 +150,7 @@ int main()
         BOOST_TEST(result.get() != 0);
         BOOST_TEST(result.use_count() == 1);
         BOOST_TEST(boost::alignment::is_aligned(result.get(),
-            boost::alignment_of<type>::value));
+            std::alignment_of<type>::value));
         BOOST_TEST(type::instances == 3);
         boost::weak_ptr<type[]> other = result;
         result.reset();
@@ -162,7 +162,7 @@ int main()
         BOOST_TEST(result.get() != 0);
         BOOST_TEST(result.use_count() == 1);
         BOOST_TEST(boost::alignment::is_aligned(result.get(),
-            boost::alignment_of<type>::value));
+            std::alignment_of<type>::value));
         BOOST_TEST(type::instances == 3);
         boost::weak_ptr<type[3]> other = result;
         result.reset();
@@ -174,7 +174,7 @@ int main()
         BOOST_TEST(result.get() != 0);
         BOOST_TEST(result.use_count() == 1);
         BOOST_TEST(boost::alignment::is_aligned(result.get(),
-            boost::alignment_of<type>::value));
+            std::alignment_of<type>::value));
         BOOST_TEST(type::instances == 4);
         boost::weak_ptr<type[][2]> other = result;
         result.reset();
@@ -186,7 +186,7 @@ int main()
         BOOST_TEST(result.get() != 0);
         BOOST_TEST(result.use_count() == 1);
         BOOST_TEST(boost::alignment::is_aligned(result.get(),
-            boost::alignment_of<type>::value));
+            std::alignment_of<type>::value));
         BOOST_TEST(type::instances == 4);
         boost::weak_ptr<type[2][2]> other = result;
         result.reset();
@@ -198,7 +198,7 @@ int main()
         BOOST_TEST(result.get() != 0);
         BOOST_TEST(result.use_count() == 1);
         BOOST_TEST(boost::alignment::is_aligned(result.get(),
-            boost::alignment_of<type>::value));
+            std::alignment_of<type>::value));
         BOOST_TEST(type::instances == 3);
         boost::weak_ptr<const type[]> other = result;
         result.reset();
@@ -210,7 +210,7 @@ int main()
         BOOST_TEST(result.get() != 0);
         BOOST_TEST(result.use_count() == 1);
         BOOST_TEST(boost::alignment::is_aligned(result.get(),
-            boost::alignment_of<type>::value));
+            std::alignment_of<type>::value));
         BOOST_TEST(type::instances == 3);
         boost::weak_ptr<const type[3]> other = result;
         result.reset();
@@ -223,7 +223,7 @@ int main()
         BOOST_TEST(result.get() != 0);
         BOOST_TEST(result.use_count() == 1);
         BOOST_TEST(boost::alignment::is_aligned(result.get(),
-            boost::alignment_of<type>::value));
+            std::alignment_of<type>::value));
         BOOST_TEST(type::instances == 4);
         boost::weak_ptr<const type[][2]> other = result;
         result.reset();
@@ -235,7 +235,7 @@ int main()
         BOOST_TEST(result.get() != 0);
         BOOST_TEST(result.use_count() == 1);
         BOOST_TEST(boost::alignment::is_aligned(result.get(),
-            boost::alignment_of<type>::value));
+            std::alignment_of<type>::value));
         BOOST_TEST(type::instances == 4);
         boost::weak_ptr<const type[2][2]> other = result;
         result.reset();

test/allocate_shared_array_test.cpp

@@ -9,7 +9,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/core/lightweight_test.hpp>
 #include <boost/smart_ptr/make_shared.hpp>
 #include <boost/smart_ptr/weak_ptr.hpp>
-#include <boost/type_traits/alignment_of.hpp>
+#include <type_traits>
 
 template<class T = void>
 struct creator {
@@ -86,7 +86,7 @@ int main()
         BOOST_TEST(result.get() != 0);
         BOOST_TEST(result.use_count() == 1);
         BOOST_TEST(boost::alignment::is_aligned(result.get(),
-            boost::alignment_of<int>::value));
+            std::alignment_of<int>::value));
         BOOST_TEST(result[0] == 0);
         BOOST_TEST(result[1] == 0);
         BOOST_TEST(result[2] == 0);
@@ -97,7 +97,7 @@ int main()
         BOOST_TEST(result.get() != 0);
         BOOST_TEST(result.use_count() == 1);
         BOOST_TEST(boost::alignment::is_aligned(result.get(),
-            boost::alignment_of<int>::value));
+            std::alignment_of<int>::value));
         BOOST_TEST(result[0] == 0);
         BOOST_TEST(result[1] == 0);
         BOOST_TEST(result[2] == 0);
@@ -108,7 +108,7 @@ int main()
         BOOST_TEST(result.get() != 0);
         BOOST_TEST(result.use_count() == 1);
         BOOST_TEST(boost::alignment::is_aligned(result.get(),
-            boost::alignment_of<int>::value));
+            std::alignment_of<int>::value));
         BOOST_TEST(result[0][0] == 0);
         BOOST_TEST(result[0][1] == 0);
         BOOST_TEST(result[1][0] == 0);
@@ -120,7 +120,7 @@ int main()
         BOOST_TEST(result.get() != 0);
         BOOST_TEST(result.use_count() == 1);
         BOOST_TEST(boost::alignment::is_aligned(result.get(),
-            boost::alignment_of<int>::value));
+            std::alignment_of<int>::value));
         BOOST_TEST(result[0][0] == 0);
         BOOST_TEST(result[0][1] == 0);
         BOOST_TEST(result[1][0] == 0);
@@ -132,7 +132,7 @@ int main()
         BOOST_TEST(result.get() != 0);
         BOOST_TEST(result.use_count() == 1);
         BOOST_TEST(boost::alignment::is_aligned(result.get(),
-            boost::alignment_of<int>::value));
+            std::alignment_of<int>::value));
         BOOST_TEST(result[0] == 0);
         BOOST_TEST(result[1] == 0);
         BOOST_TEST(result[2] == 0);
@@ -143,7 +143,7 @@ int main()
         BOOST_TEST(result.get() != 0);
         BOOST_TEST(result.use_count() == 1);
         BOOST_TEST(boost::alignment::is_aligned(result.get(),
-            boost::alignment_of<int>::value));
+            std::alignment_of<int>::value));
         BOOST_TEST(result[0] == 0);
         BOOST_TEST(result[1] == 0);
         BOOST_TEST(result[2] == 0);
@@ -154,7 +154,7 @@ int main()
         BOOST_TEST(result.get() != 0);
         BOOST_TEST(result.use_count() == 1);
         BOOST_TEST(boost::alignment::is_aligned(result.get(),
-            boost::alignment_of<int>::value));
+            std::alignment_of<int>::value));
         BOOST_TEST(result[0][0] == 0);
         BOOST_TEST(result[0][1] == 0);
         BOOST_TEST(result[1][0] == 0);
@@ -166,7 +166,7 @@ int main()
         BOOST_TEST(result.get() != 0);
         BOOST_TEST(result.use_count() == 1);
         BOOST_TEST(boost::alignment::is_aligned(result.get(),
-            boost::alignment_of<int>::value));
+            std::alignment_of<int>::value));
         BOOST_TEST(result[0][0] == 0);
         BOOST_TEST(result[0][1] == 0);
         BOOST_TEST(result[1][0] == 0);
@@ -178,7 +178,7 @@ int main()
         BOOST_TEST(result.get() != 0);
         BOOST_TEST(result.use_count() == 1);
         BOOST_TEST(boost::alignment::is_aligned(result.get(),
-            boost::alignment_of<type>::value));
+            std::alignment_of<type>::value));
         BOOST_TEST(type::instances == 3);
         boost::weak_ptr<type[]> w1 = result;
         result.reset();
@@ -190,7 +190,7 @@ int main()
         BOOST_TEST(result.get() != 0);
         BOOST_TEST(result.use_count() == 1);
         BOOST_TEST(boost::alignment::is_aligned(result.get(),
-            boost::alignment_of<type>::value));
+            std::alignment_of<type>::value));
         BOOST_TEST(type::instances == 3);
         boost::weak_ptr<type[3]> w1 = result;
         result.reset();
@@ -202,7 +202,7 @@ int main()
         BOOST_TEST(result.get() != 0);
         BOOST_TEST(result.use_count() == 1);
         BOOST_TEST(boost::alignment::is_aligned(result.get(),
-            boost::alignment_of<type>::value));
+            std::alignment_of<type>::value));
         BOOST_TEST(type::instances == 4);
         result.reset();
         BOOST_TEST(type::instances == 0);
@@ -213,7 +213,7 @@ int main()
         BOOST_TEST(result.get() != 0);
         BOOST_TEST(result.use_count() == 1);
         BOOST_TEST(boost::alignment::is_aligned(result.get(),
-            boost::alignment_of<type>::value));
+            std::alignment_of<type>::value));
         BOOST_TEST(type::instances == 4);
         result.reset();
         BOOST_TEST(type::instances == 0);
@@ -224,7 +224,7 @@ int main()
         BOOST_TEST(result.get() != 0);
         BOOST_TEST(result.use_count() == 1);
         BOOST_TEST(boost::alignment::is_aligned(result.get(),
-            boost::alignment_of<type>::value));
+            std::alignment_of<type>::value));
         BOOST_TEST(type::instances == 3);
         result.reset();
         BOOST_TEST(type::instances == 0);
@@ -235,7 +235,7 @@ int main()
         BOOST_TEST(result.get() != 0);
         BOOST_TEST(result.use_count() == 1);
         BOOST_TEST(boost::alignment::is_aligned(result.get(),
-            boost::alignment_of<type>::value));
+            std::alignment_of<type>::value));
         BOOST_TEST(type::instances == 3);
         result.reset();
         BOOST_TEST(type::instances == 0);
@@ -246,7 +246,7 @@ int main()
         BOOST_TEST(result.get() != 0);
         BOOST_TEST(result.use_count() == 1);
         BOOST_TEST(boost::alignment::is_aligned(result.get(),
-            boost::alignment_of<type>::value));
+            std::alignment_of<type>::value));
         BOOST_TEST(type::instances == 4);
         result.reset();
         BOOST_TEST(type::instances == 0);
@@ -257,7 +257,7 @@ int main()
         BOOST_TEST(result.get() != 0);
         BOOST_TEST(result.use_count() == 1);
         BOOST_TEST(boost::alignment::is_aligned(result.get(),
-            boost::alignment_of<type>::value));
+            std::alignment_of<type>::value));
         BOOST_TEST(type::instances == 4);
         result.reset();
         BOOST_TEST(type::instances == 0);

test/allocate_shared_arrays_test.cpp

@@ -5,10 +5,9 @@ Copyright 2012-2015 Glen Joseph Fernandes
 Distributed under the Boost Software License, Version 1.0.
 (http://www.boost.org/LICENSE_1_0.txt)
 */
-#include <boost/config.hpp>
-#if !defined(BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX)
-#include <boost/core/lightweight_test.hpp>
 #include <boost/smart_ptr/make_shared.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <boost/config.hpp>
 
 template<class T = void>
 struct creator {
@@ -83,9 +82,3 @@ int main()
     }
     return boost::report_errors();
 }
-#else
-int main()
-{
-    return 0;
-}
-#endif

test/allocate_shared_construct11_test.cpp

@@ -8,14 +8,12 @@
 // See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt
 
-#include <boost/core/lightweight_test.hpp>
 #include <boost/make_shared.hpp>
 #include <boost/shared_ptr.hpp>
 #include <boost/weak_ptr.hpp>
+#include <boost/core/lightweight_test.hpp>
 #include <cstddef>
 
-#if !defined( BOOST_NO_CXX11_ALLOCATOR )
-
 template< class T > class cxx11_allocator
 {
 public:
@@ -229,12 +227,3 @@ int main()
 
     return boost::report_errors();
 }
-
-#else // !defined( BOOST_NO_CXX11_ALLOCATOR )
-
-int main()
-{
-    return 0;
-}
-
-#endif

test/allocate_unique_aggregate_test.cpp

@@ -5,13 +5,9 @@ Copyright 2019 Glen Joseph Fernandes
 Distributed under the Boost Software License, Version 1.0.
 (http://www.boost.org/LICENSE_1_0.txt)
 */
-#include <boost/config.hpp>
-#if (!defined(BOOST_LIBSTDCXX_VERSION) || \
-    BOOST_LIBSTDCXX_VERSION >= 46000) && \
-    !defined(BOOST_NO_CXX11_SMART_PTR) && \
-    !defined(BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX)
 #include <boost/smart_ptr/allocate_unique.hpp>
 #include <boost/core/lightweight_test.hpp>
+#include <boost/config.hpp>
 
 template<class T = void>
 struct creator {
@@ -76,9 +72,3 @@ int main()
     }
     return boost::report_errors();
 }
-#else
-int main()
-{
-    return 0;
-}
-#endif

test/allocate_unique_args_test.cpp

@@ -5,13 +5,9 @@ Copyright 2019 Glen Joseph Fernandes
 Distributed under the Boost Software License, Version 1.0.
 (http://www.boost.org/LICENSE_1_0.txt)
 */
-#include <boost/config.hpp>
-#if (!defined(BOOST_LIBSTDCXX_VERSION) || \
-    BOOST_LIBSTDCXX_VERSION >= 46000) && \
-    !defined(BOOST_NO_CXX11_SMART_PTR) && \
-    !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
 #include <boost/smart_ptr/allocate_unique.hpp>
 #include <boost/core/lightweight_test.hpp>
+#include <boost/config.hpp>
 
 template<class T = void>
 struct creator {
@@ -103,9 +99,3 @@ int main()
     }
     return boost::report_errors();
 }
-#else
-int main()
-{
-    return 0;
-}
-#endif

test/allocate_unique_array_construct_test.cpp

@@ -5,13 +5,9 @@ Copyright 2019 Glen Joseph Fernandes
 Distributed under the Boost Software License, Version 1.0.
 (http://www.boost.org/LICENSE_1_0.txt)
 */
-#include <boost/config.hpp>
-#if (!defined(BOOST_LIBSTDCXX_VERSION) || \
-    BOOST_LIBSTDCXX_VERSION >= 48000) && \
-    !defined(BOOST_NO_CXX11_SMART_PTR) && \
-    !defined(BOOST_NO_CXX11_ALLOCATOR)
 #include <boost/smart_ptr/allocate_unique.hpp>
 #include <boost/core/lightweight_test.hpp>
+#include <boost/config.hpp>
 
 struct allow { };
 
@@ -158,9 +154,3 @@ int main()
     }
     return boost::report_errors();
 }
-#else
-int main()
-{
-    return 0;
-}
-#endif

test/allocate_unique_array_noinit_test.cpp

@@ -5,12 +5,9 @@ Copyright 2019 Glen Joseph Fernandes
 Distributed under the Boost Software License, Version 1.0.
 (http://www.boost.org/LICENSE_1_0.txt)
 */
-#include <boost/config.hpp>
-#if (!defined(BOOST_LIBSTDCXX_VERSION) || \
-    BOOST_LIBSTDCXX_VERSION >= 48000) && \
-    !defined(BOOST_NO_CXX11_SMART_PTR)
 #include <boost/smart_ptr/allocate_unique.hpp>
 #include <boost/core/lightweight_test.hpp>
+#include <boost/config.hpp>
 
 template<class T = void>
 struct creator {
@@ -220,9 +217,3 @@ int main()
     }
     return boost::report_errors();
 }
-#else
-int main()
-{
-    return 0;
-}
-#endif

test/allocate_unique_array_test.cpp

@@ -5,12 +5,9 @@ Copyright 2019 Glen Joseph Fernandes
 Distributed under the Boost Software License, Version 1.0.
 (http://www.boost.org/LICENSE_1_0.txt)
 */
-#include <boost/config.hpp>
-#if (!defined(BOOST_LIBSTDCXX_VERSION) || \
-    BOOST_LIBSTDCXX_VERSION >= 48000) && \
-    !defined(BOOST_NO_CXX11_SMART_PTR)
 #include <boost/smart_ptr/allocate_unique.hpp>
 #include <boost/core/lightweight_test.hpp>
+#include <boost/config.hpp>
 
 template<class T = void>
 struct creator {
@@ -232,9 +229,3 @@ int main()
     }
     return boost::report_errors();
 }
-#else
-int main()
-{
-    return 0;
-}
-#endif

test/allocate_unique_array_throws_test.cpp

@@ -5,12 +5,9 @@ Copyright 2019 Glen Joseph Fernandes
 Distributed under the Boost Software License, Version 1.0.
 (http://www.boost.org/LICENSE_1_0.txt)
 */
-#include <boost/config.hpp>
-#if (!defined(BOOST_LIBSTDCXX_VERSION) || \
-    BOOST_LIBSTDCXX_VERSION >= 48000) && \
-    !defined(BOOST_NO_CXX11_SMART_PTR)
 #include <boost/smart_ptr/allocate_unique.hpp>
 #include <boost/core/lightweight_test.hpp>
+#include <boost/config.hpp>
 
 template<class T = void>
 struct creator {
@@ -124,9 +121,3 @@ int main()
     }
     return boost::report_errors();
 }
-#else
-int main()
-{
-    return 0;
-}
-#endif

test/allocate_unique_array_value_test.cpp

@@ -5,12 +5,9 @@ Copyright 2019 Glen Joseph Fernandes
 Distributed under the Boost Software License, Version 1.0.
 (http://www.boost.org/LICENSE_1_0.txt)
 */
-#include <boost/config.hpp>
-#if (!defined(BOOST_LIBSTDCXX_VERSION) || \
-    BOOST_LIBSTDCXX_VERSION >= 48000) && \
-    !defined(BOOST_NO_CXX11_SMART_PTR)
 #include <boost/smart_ptr/allocate_unique.hpp>
 #include <boost/core/lightweight_test.hpp>
+#include <boost/config.hpp>
 
 template<class T = void>
 struct creator {
@@ -90,9 +87,3 @@ int main()
     }
     return boost::report_errors();
 }
-#else
-int main()
-{
-    return 0;
-}
-#endif

test/allocate_unique_arrays_test.cpp

@@ -5,13 +5,9 @@ Copyright 2019 Glen Joseph Fernandes
 Distributed under the Boost Software License, Version 1.0.
 (http://www.boost.org/LICENSE_1_0.txt)
 */
-#include <boost/config.hpp>
-#if (!defined(BOOST_LIBSTDCXX_VERSION) || \
-    BOOST_LIBSTDCXX_VERSION >= 48000) && \
-    !defined(BOOST_NO_CXX11_SMART_PTR) && \
-    !defined(BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX)
 #include <boost/smart_ptr/allocate_unique.hpp>
 #include <boost/core/lightweight_test.hpp>
+#include <boost/config.hpp>
 
 template<class T = void>
 struct creator {
@@ -91,9 +87,3 @@ int main()
     }
     return boost::report_errors();
 }
-#else
-int main()
-{
-    return 0;
-}
-#endif

test/allocate_unique_construct_test.cpp

@@ -5,10 +5,9 @@ Copyright 2019 Glen Joseph Fernandes
 Distributed under the Boost Software License, Version 1.0.
 (http://www.boost.org/LICENSE_1_0.txt)
 */
-#include <boost/config.hpp>
-#if !defined(BOOST_NO_CXX11_SMART_PTR) && !defined(BOOST_NO_CXX11_ALLOCATOR)
 #include <boost/smart_ptr/allocate_unique.hpp>
 #include <boost/core/lightweight_test.hpp>
+#include <boost/config.hpp>
 
 struct allow { };
 
@@ -101,9 +100,3 @@ int main()
     }
     return boost::report_errors();
 }
-#else
-int main()
-{
-    return 0;
-}
-#endif

test/allocate_unique_noinit_test.cpp

@@ -5,12 +5,9 @@ Copyright 2019 Glen Joseph Fernandes
 Distributed under the Boost Software License, Version 1.0.
 (http://www.boost.org/LICENSE_1_0.txt)
 */
-#include <boost/config.hpp>
-#if (!defined(BOOST_LIBSTDCXX_VERSION) || \
-    BOOST_LIBSTDCXX_VERSION >= 46000) && \
-    !defined(BOOST_NO_CXX11_SMART_PTR)
 #include <boost/smart_ptr/allocate_unique.hpp>
 #include <boost/core/lightweight_test.hpp>
+#include <boost/config.hpp>
 
 template<class T = void>
 struct creator {
@@ -118,9 +115,3 @@ int main()
     }
     return boost::report_errors();
 }
-#else
-int main()
-{
-    return 0;
-}
-#endif

test/allocate_unique_test.cpp

@@ -5,12 +5,9 @@ Copyright 2019 Glen Joseph Fernandes
 Distributed under the Boost Software License, Version 1.0.
 (http://www.boost.org/LICENSE_1_0.txt)
 */
-#include <boost/config.hpp>
-#if (!defined(BOOST_LIBSTDCXX_VERSION) || \
-    BOOST_LIBSTDCXX_VERSION >= 46000) && \
-    !defined(BOOST_NO_CXX11_SMART_PTR)
 #include <boost/smart_ptr/allocate_unique.hpp>
 #include <boost/core/lightweight_test.hpp>
+#include <boost/config.hpp>
 
 template<class T = void>
 struct creator {
@@ -107,9 +104,3 @@ int main()
     }
     return boost::report_errors();
 }
-#else
-int main()
-{
-    return 0;
-}
-#endif

test/allocate_unique_throws_test.cpp

@@ -5,12 +5,9 @@ Copyright 2019 Glen Joseph Fernandes
 Distributed under the Boost Software License, Version 1.0.
 (http://www.boost.org/LICENSE_1_0.txt)
 */
-#include <boost/config.hpp>
-#if (!defined(BOOST_LIBSTDCXX_VERSION) || \
-    BOOST_LIBSTDCXX_VERSION >= 46000) && \
-    !defined(BOOST_NO_CXX11_SMART_PTR)
 #include <boost/smart_ptr/allocate_unique.hpp>
 #include <boost/core/lightweight_test.hpp>
+#include <boost/config.hpp>
 
 template<class T = void>
 struct creator {
@@ -88,9 +85,3 @@ int main()
     }
     return boost::report_errors();
 }
-#else
-int main()
-{
-    return 0;
-}
-#endif

test/allocate_unique_value_test.cpp

@@ -5,12 +5,9 @@ Copyright 2019 Glen Joseph Fernandes
 Distributed under the Boost Software License, Version 1.0.
 (http://www.boost.org/LICENSE_1_0.txt)
 */
-#include <boost/config.hpp>
-#if (!defined(BOOST_LIBSTDCXX_VERSION) || \
-    BOOST_LIBSTDCXX_VERSION >= 46000) && \
-    !defined(BOOST_NO_CXX11_SMART_PTR)
 #include <boost/smart_ptr/allocate_unique.hpp>
 #include <boost/core/lightweight_test.hpp>
+#include <boost/config.hpp>
 
 template<class T = void>
 struct creator {
@@ -95,9 +92,3 @@ int main()
     }
     return boost::report_errors();
 }
-#else
-int main()
-{
-    return 0;
-}
-#endif