Disable the tn_holder<wchar_t> specialization when BOOST_NO_INTRINSIC_WCHAR_T. Refs #173.

Fix deprecated warning ignores in allocator_access.hpp

.drone.jsonnet

@@ -97,41 +97,40 @@ local windows_pipeline(name, image, environment, arch = "amd64") =
 
 [
     linux_pipeline(
-        "Linux 14.04 GCC 4.4",
-        "cppalliance/droneubuntu1404:1",
+        "Linux 16.04 GCC 4.4",
+        "cppalliance/droneubuntu1604: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 32/64",
-        "cppalliance/droneubuntu1404:1",
+        "Linux 16.04 GCC 4.6 32/64",
+        "cppalliance/droneubuntu1604:1",
         { TOOLSET: 'gcc', COMPILER: 'g++-4.6', CXXSTD: '98,0x', ADDRMD: '32,64' },
         "g++-4.6-multilib",
         [ "ppa:ubuntu-toolchain-r/test" ],
     ),
 
     linux_pipeline(
-        "Linux 14.04 GCC 4.7 32/64",
-        "cppalliance/droneubuntu1404:1",
+        "Linux 16.04 GCC 4.7 32/64",
+        "cppalliance/droneubuntu1604:1",
         { TOOLSET: 'gcc', COMPILER: 'g++-4.7', CXXSTD: '98,0x', ADDRMD: '32,64' },
         "g++-4.7-multilib",
-        [ "ppa:ubuntu-toolchain-r/test" ],
     ),
 
     linux_pipeline(
-        "Linux 14.04 GCC 4.8* 32/64",
-        "cppalliance/droneubuntu1404:1",
+        "Linux 16.04 GCC 4.8 32/64",
+        "cppalliance/droneubuntu1604:1",
         { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '03,11', ADDRMD: '32,64' },
+        "g++-4.8-multilib",
     ),
 
     linux_pipeline(
-        "Linux 14.04 GCC 4.9 32/64",
-        "cppalliance/droneubuntu1404:1",
+        "Linux 16.04 GCC 4.9 32/64",
+        "cppalliance/droneubuntu1604:1",
         { TOOLSET: 'gcc', COMPILER: 'g++-4.9', CXXSTD: '03,11', ADDRMD: '32,64' },
         "g++-4.9-multilib",
-        [ "ppa:ubuntu-toolchain-r/test" ],
     ),
 
     linux_pipeline(
@@ -194,17 +193,38 @@ local windows_pipeline(name, image, environment, arch = "amd64") =
     ),
 
     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: '03,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 23.04 GCC 13 32 ASAN",
+        "cppalliance/droneubuntu2304:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-13', CXXSTD: '03,11,14,17,20,2b', ADDRMD: '32' } + asan,
+        "g++-13-multilib",
+    ),
+
+    linux_pipeline(
+        "Linux 23.04 GCC 13 64 ASAN",
+        "cppalliance/droneubuntu2304:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-13', CXXSTD: '03,11,14,17,20,2b', ADDRMD: '64' } + asan,
+        "g++-13-multilib",
+    ),
+
+    linux_pipeline(
+        "Linux 23.04 GCC 13 32 UBSAN",
+        "cppalliance/droneubuntu2304:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-13', CXXSTD: '03,11,14,17,20,2b', ADDRMD: '32' } + ubsan,
+        "g++-13-multilib",
+    ),
+
+    linux_pipeline(
+        "Linux 23.04 GCC 13 64 UBSAN",
+        "cppalliance/droneubuntu2304:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-13', CXXSTD: '03,11,14,17,20,2b', ADDRMD: '64' } + ubsan,
+        "g++-13-multilib",
     ),
 
     linux_pipeline(
@@ -313,16 +333,9 @@ local windows_pipeline(name, image, environment, arch = "amd64") =
     ),
 
     linux_pipeline(
-        "Linux 22.04 Clang 14 UBSAN",
+        "Linux 22.04 Clang 14",
         "cppalliance/droneubuntu2204:1",
-        { TOOLSET: 'clang', COMPILER: 'clang++-14', CXXSTD: '03,11,14,17,20,2b' } + ubsan,
-        "clang-14",
-    ),
-
-    linux_pipeline(
-        "Linux 22.04 Clang 14 ASAN",
-        "cppalliance/droneubuntu2204:1",
-        { TOOLSET: 'clang', COMPILER: 'clang++-14', CXXSTD: '03,11,14,17,20,2b' } + asan,
+        { TOOLSET: 'clang', COMPILER: 'clang++-14', CXXSTD: '03,11,14,17,20,2b' },
         "clang-14",
     ),
 
@@ -331,7 +344,27 @@ local windows_pipeline(name, image, environment, arch = "amd64") =
         "cppalliance/droneubuntu2204:1",
         { TOOLSET: 'clang', COMPILER: 'clang++-15', CXXSTD: '03,11,14,17,20,2b' },
         "clang-15",
-        ["deb http://apt.llvm.org/jammy/ llvm-toolchain-jammy-15 main"],
+    ),
+
+    linux_pipeline(
+        "Linux 23.04 Clang 16",
+        "cppalliance/droneubuntu2304:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-16', CXXSTD: '03,11,14,17,20,2b' },
+        "clang-16",
+    ),
+
+    linux_pipeline(
+        "Linux 23.10 Clang 17 UBSAN",
+        "cppalliance/droneubuntu2310:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-17', CXXSTD: '03,11,14,17,20,2b' } + ubsan,
+        "clang-17",
+    ),
+
+    linux_pipeline(
+        "Linux 23.10 Clang 17 ASAN",
+        "cppalliance/droneubuntu2310:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-17', CXXSTD: '03,11,14,17,20,2b' } + asan,
+        "clang-17",
     ),
 
     macos_pipeline(
@@ -359,24 +392,24 @@ local windows_pipeline(name, image, environment, arch = "amd64") =
     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(
         "Windows VS2017 msvc-14.1",
         "cppalliance/dronevs2017",
-        { TOOLSET: 'msvc-14.1', CXXSTD: '14,17,latest' },
+        { TOOLSET: 'msvc-14.1', CXXSTD: '14,17,latest', ADDRMD: '32,64' },
     ),
 
     windows_pipeline(
         "Windows VS2019 msvc-14.2",
         "cppalliance/dronevs2019",
-        { TOOLSET: 'msvc-14.2', CXXSTD: '14,17,20,latest' },
+        { TOOLSET: 'msvc-14.2', CXXSTD: '14,17,20,latest', ADDRMD: '32,64' },
     ),
 
     windows_pipeline(
         "Windows VS2022 msvc-14.3",
         "cppalliance/dronevs2022:1",
-        { TOOLSET: 'msvc-14.3', CXXSTD: '14,17,20,latest' },
+        { TOOLSET: 'msvc-14.3', CXXSTD: '14,17,20,latest', ADDRMD: '32,64' },
     ),
 ]

.github/workflows/ci.yml

@@ -1,5 +1,5 @@
 # Copyright 2020-2021 Peter Dimov
-# Copyright 2021-2022 Andrey Semashev
+# Copyright 2021-2024 Andrey Semashev
 #
 # Distributed under the Boost Software License, Version 1.0.
 # (See accompanying file LICENSE_1_0.txt or copy at http://boost.org/LICENSE_1_0.txt)
@@ -121,6 +121,13 @@ jobs:
             os: ubuntu-22.04
             install:
               - g++-12-multilib
+          - toolset: gcc-13
+            cxxstd: "03,11,14,17,20,23"
+            address-model: 32,64
+            os: ubuntu-latest
+            container: ubuntu:23.04
+            install:
+              - g++-13-multilib
           - name: UBSAN
             toolset: gcc-12
             cxxstd: "03,11,14,17,20,23"
@@ -221,34 +228,40 @@ jobs:
             os: ubuntu-22.04
             install:
               - clang-11
+              - g++-11
+            gcc_toolchain: 11
           - toolset: clang
             compiler: clang++-12
             cxxstd: "03,11,14,17,20,2b"
             os: ubuntu-22.04
             install:
               - clang-12
+              - g++-11
+            gcc_toolchain: 11
           - toolset: clang
             compiler: clang++-13
             cxxstd: "03,11,14,17,20,2b"
             os: ubuntu-22.04
             install:
               - clang-13
+              - g++-11
+            gcc_toolchain: 11
           - toolset: clang
             compiler: clang++-14
             cxxstd: "03,11,14,17,20,2b"
             os: ubuntu-22.04
             install:
               - clang-14
+              - g++-11
+            gcc_toolchain: 11
           - toolset: clang
             compiler: clang++-15
             cxxstd: "03,11,14,17,20,2b"
             os: ubuntu-22.04
             install:
               - clang-15
-            sources:
-              - "deb http://apt.llvm.org/jammy/ llvm-toolchain-jammy-15 main"
-            source_keys:
-              - "https://apt.llvm.org/llvm-snapshot.gpg.key"
+              - g++-11
+            gcc_toolchain: 11
           - toolset: clang
             compiler: clang++-15
             cxxstd: "03,11,14,17,20,2b"
@@ -257,33 +270,57 @@ jobs:
               - clang-15
               - libc++-15-dev
               - libc++abi-15-dev
+            cxxflags: -stdlib=libc++
+            linkflags: -stdlib=libc++
+          - toolset: clang
+            compiler: clang++-16
+            cxxstd: "03,11,14,17,20,2b"
+            os: ubuntu-latest
+            container: ubuntu:23.04
+            install:
+              - clang-16
+              - libc++-16-dev
+              - libc++abi-16-dev
+            cxxflags: -stdlib=libc++
+            linkflags: -stdlib=libc++
+          - toolset: clang
+            compiler: clang++-17
+            cxxstd: "03,11,14,17,20,2b"
+            os: ubuntu-22.04
+            install:
+              - clang-17
+              - libc++-17-dev
+              - libc++abi-17-dev
             sources:
-              - "deb http://apt.llvm.org/jammy/ llvm-toolchain-jammy-15 main"
+              - "deb http://apt.llvm.org/jammy/ llvm-toolchain-jammy-17 main"
             source_keys:
               - "https://apt.llvm.org/llvm-snapshot.gpg.key"
             cxxflags: -stdlib=libc++
             linkflags: -stdlib=libc++
           - name: UBSAN
             toolset: clang
-            compiler: clang++-14
+            compiler: clang++-15
             cxxstd: "03,11,14,17,20,2b"
             cxxflags: -stdlib=libc++
             linkflags: -stdlib=libc++
             ubsan: 1
             os: ubuntu-22.04
             install:
-              - clang-14
-              - libc++-14-dev
-              - libc++abi-14-dev
+              - clang-15
+              - libc++-15-dev
+              - libc++abi-15-dev
 
           - toolset: clang
-            cxxstd: "03,11,14,17,2a"
-            os: macos-11
-          - toolset: clang
-            cxxstd: "03,11,14,17,2a"
+            cxxstd: "03,11,14,17,20,2b"
             os: macos-12
+          - toolset: clang
+            cxxstd: "03,11,14,17,20,2b"
+            os: macos-13
+          - toolset: clang
+            cxxstd: "03,11,14,17,20,2b"
+            os: macos-14
 
-    timeout-minutes: 120
+    timeout-minutes: 45
     runs-on: ${{matrix.os}}
     container: ${{matrix.container}}
 
@@ -312,8 +349,6 @@ jobs:
             fi
             git config --global pack.threads 0
 
-      - uses: actions/checkout@v3
-
       - name: Install packages
         if: matrix.install
         run: |
@@ -428,11 +463,25 @@ jobs:
             then
                 DEPINST_ARGS+=("--git_args" "--jobs $GIT_FETCH_JOBS")
             fi
+            mkdir -p snapshot
+            cd snapshot
+            echo "Downloading library snapshot: https://github.com/${GITHUB_REPOSITORY}/archive/${GITHUB_SHA}.tar.gz"
+            curl -L --retry "$NET_RETRY_COUNT" -o "${LIBRARY}-${GITHUB_SHA}.tar.gz" "https://github.com/${GITHUB_REPOSITORY}/archive/${GITHUB_SHA}.tar.gz"
+            tar -xf "${LIBRARY}-${GITHUB_SHA}.tar.gz"
+            if [ ! -d "${LIBRARY}-${GITHUB_SHA}" ]
+            then
+                echo "Library snapshot does not contain the library directory ${LIBRARY}-${GITHUB_SHA}:"
+                ls -la
+                exit 1
+            fi
+            rm -f "${LIBRARY}-${GITHUB_SHA}.tar.gz"
             cd ..
             git clone -b "$BOOST_BRANCH" --depth 1 "https://github.com/boostorg/boost.git" "boost-root"
             cd boost-root
-            mkdir -p libs/$LIBRARY
-            cp -r $GITHUB_WORKSPACE/* libs/$LIBRARY
+            mkdir -p libs
+            rm -rf "libs/$LIBRARY"
+            mv -f "../snapshot/${LIBRARY}-${GITHUB_SHA}" "libs/$LIBRARY"
+            rm -rf "../snapshot"
             git submodule update --init tools/boostdep
             DEPINST_ARGS+=("$LIBRARY")
             python tools/boostdep/depinst/depinst.py "${DEPINST_ARGS[@]}"
@@ -451,7 +500,7 @@ jobs:
       - name: Run tests
         if: matrix.cmake_tests == ''
         run: |
-            cd ../boost-root
+            cd boost-root
             B2_ARGS=("-j" "$BUILD_JOBS" "toolset=${{matrix.toolset}}" "cxxstd=${{matrix.cxxstd}}")
             if [ -n "${{matrix.build_variant}}" ]
             then
@@ -510,10 +559,9 @@ jobs:
             os: windows-2019
 
     runs-on: ${{matrix.os}}
+    timeout-minutes: 45
 
     steps:
-      - uses: actions/checkout@v3
-
       - name: Setup Boost
         shell: cmd
         run: |
@@ -527,10 +575,24 @@ jobs:
             set BOOST_BRANCH=develop
             for /f %%i in ("%GITHUB_BASE_REF%") do if "%%~nxi" == "master" set BOOST_BRANCH=master
             echo BOOST_BRANCH: %BOOST_BRANCH%
+            mkdir snapshot
+            cd snapshot
+            echo Downloading library snapshot: https://github.com/%GITHUB_REPOSITORY%/archive/%GITHUB_SHA%.zip
+            curl -L --retry %NET_RETRY_COUNT% -o "%LIBRARY%-%GITHUB_SHA%.zip" "https://github.com/%GITHUB_REPOSITORY%/archive/%GITHUB_SHA%.zip"
+            tar -xf "%LIBRARY%-%GITHUB_SHA%.zip"
+            if not exist "%LIBRARY%-%GITHUB_SHA%\" (
+                echo Library snapshot does not contain the library directory %LIBRARY%-%GITHUB_SHA%:
+                dir
+                exit /b 1
+            )
+            del /f "%LIBRARY%-%GITHUB_SHA%.zip"
             cd ..
             git clone -b %BOOST_BRANCH% --depth 1 https://github.com/boostorg/boost.git boost-root
             cd boost-root
-            xcopy /s /e /q %GITHUB_WORKSPACE% libs\%LIBRARY%\
+            if not exist "libs\" mkdir libs
+            if exist "libs\%LIBRARY%\" rmdir /s /q "libs\%LIBRARY%"
+            move /Y "..\snapshot\%LIBRARY%-%GITHUB_SHA%" "libs\%LIBRARY%"
+            rmdir /s /q "..\snapshot"
             git submodule update --init tools/boostdep
             python tools/boostdep/depinst/depinst.py --git_args "--jobs %GIT_FETCH_JOBS%" %LIBRARY%
             cmd /c bootstrap
@@ -539,7 +601,7 @@ jobs:
       - name: Run tests
         shell: cmd
         run: |
-            cd ../boost-root
+            cd boost-root
             b2 -j %NUMBER_OF_PROCESSORS% libs/%LIBRARY%/test toolset=${{matrix.toolset}} cxxstd=${{matrix.cxxstd}} address-model=${{matrix.addrmd}} variant=debug,release embed-manifest-via=linker
 
   posix-cmake-subdir:
@@ -549,17 +611,19 @@ jobs:
         include:
           - os: ubuntu-20.04
           - os: ubuntu-22.04
-          - os: macos-11
           - os: macos-12
+          - os: macos-13
+          - os: macos-14
 
     runs-on: ${{matrix.os}}
+    timeout-minutes: 10
 
     steps:
-      - uses: actions/checkout@v3
-
       - name: Install packages
         if: matrix.install
-        run: sudo apt install ${{matrix.install}}
+        run: |
+          sudo apt-get -o Acquire::Retries=$NET_RETRY_COUNT update
+          sudo apt-get -o Acquire::Retries=$NET_RETRY_COUNT -y ${{join(matrix.install, ' ')}}
 
       - name: Setup Boost
         run: |
@@ -574,16 +638,34 @@ jobs:
           echo REF: $REF
           BOOST_BRANCH=develop && [ "$REF" = "master" ] && BOOST_BRANCH=master || true
           echo BOOST_BRANCH: $BOOST_BRANCH
+          BUILD_JOBS=$((nproc || sysctl -n hw.ncpu) 2> /dev/null)
+          echo "BUILD_JOBS=$BUILD_JOBS" >> $GITHUB_ENV
+          echo "CMAKE_BUILD_PARALLEL_LEVEL=$BUILD_JOBS" >> $GITHUB_ENV
+          mkdir -p snapshot
+          cd snapshot
+          echo "Downloading library snapshot: https://github.com/${GITHUB_REPOSITORY}/archive/${GITHUB_SHA}.tar.gz"
+          curl -L --retry "$NET_RETRY_COUNT" -o "${LIBRARY}-${GITHUB_SHA}.tar.gz" "https://github.com/${GITHUB_REPOSITORY}/archive/${GITHUB_SHA}.tar.gz"
+          tar -xf "${LIBRARY}-${GITHUB_SHA}.tar.gz"
+          if [ ! -d "${LIBRARY}-${GITHUB_SHA}" ]
+          then
+              echo "Library snapshot does not contain the library directory ${LIBRARY}-${GITHUB_SHA}:"
+              ls -la
+              exit 1
+          fi
+          rm -f "${LIBRARY}-${GITHUB_SHA}.tar.gz"
           cd ..
           git clone -b $BOOST_BRANCH --depth 1 https://github.com/boostorg/boost.git boost-root
           cd boost-root
-          cp -r $GITHUB_WORKSPACE/* libs/$LIBRARY
+          mkdir -p libs
+          rm -rf "libs/$LIBRARY"
+          mv -f "../snapshot/${LIBRARY}-${GITHUB_SHA}" "libs/$LIBRARY"
+          rm -rf "../snapshot"
           git submodule update --init tools/boostdep
           python tools/boostdep/depinst/depinst.py --git_args "--jobs $GIT_FETCH_JOBS" $LIBRARY
 
       - name: Use library with add_subdirectory
         run: |
-          cd ../boost-root/libs/$LIBRARY/test/cmake_subdir_test
+          cd boost-root/libs/$LIBRARY/test/cmake_subdir_test
           mkdir __build__ && cd __build__
           cmake ..
           cmake --build . -- -j $BUILD_JOBS
@@ -596,17 +678,19 @@ jobs:
         include:
           - os: ubuntu-20.04
           - os: ubuntu-22.04
-          - os: macos-11
           - os: macos-12
+          - os: macos-13
+          - os: macos-14
 
     runs-on: ${{matrix.os}}
+    timeout-minutes: 10
 
     steps:
-      - uses: actions/checkout@v3
-
       - name: Install packages
         if: matrix.install
-        run: sudo apt install ${{matrix.install}}
+        run: |
+          sudo apt-get -o Acquire::Retries=$NET_RETRY_COUNT update
+          sudo apt-get -o Acquire::Retries=$NET_RETRY_COUNT -y ${{join(matrix.install, ' ')}}
 
       - name: Setup Boost
         run: |
@@ -621,27 +705,45 @@ jobs:
           echo REF: $REF
           BOOST_BRANCH=develop && [ "$REF" = "master" ] && BOOST_BRANCH=master || true
           echo BOOST_BRANCH: $BOOST_BRANCH
+          BUILD_JOBS=$((nproc || sysctl -n hw.ncpu) 2> /dev/null)
+          echo "BUILD_JOBS=$BUILD_JOBS" >> $GITHUB_ENV
+          echo "CMAKE_BUILD_PARALLEL_LEVEL=$BUILD_JOBS" >> $GITHUB_ENV
+          mkdir -p snapshot
+          cd snapshot
+          echo "Downloading library snapshot: https://github.com/${GITHUB_REPOSITORY}/archive/${GITHUB_SHA}.tar.gz"
+          curl -L --retry "$NET_RETRY_COUNT" -o "${LIBRARY}-${GITHUB_SHA}.tar.gz" "https://github.com/${GITHUB_REPOSITORY}/archive/${GITHUB_SHA}.tar.gz"
+          tar -xf "${LIBRARY}-${GITHUB_SHA}.tar.gz"
+          if [ ! -d "${LIBRARY}-${GITHUB_SHA}" ]
+          then
+              echo "Library snapshot does not contain the library directory ${LIBRARY}-${GITHUB_SHA}:"
+              ls -la
+              exit 1
+          fi
+          rm -f "${LIBRARY}-${GITHUB_SHA}.tar.gz"
           cd ..
           git clone -b $BOOST_BRANCH --depth 1 https://github.com/boostorg/boost.git boost-root
           cd boost-root
-          cp -r $GITHUB_WORKSPACE/* libs/$LIBRARY
+          mkdir -p libs
+          rm -rf "libs/$LIBRARY"
+          mv -f "../snapshot/${LIBRARY}-${GITHUB_SHA}" "libs/$LIBRARY"
+          rm -rf "../snapshot"
           git submodule update --init tools/boostdep
           python tools/boostdep/depinst/depinst.py --git_args "--jobs $GIT_FETCH_JOBS" $LIBRARY
 
       - name: Configure
         run: |
-          cd ../boost-root
+          cd boost-root
           mkdir __build__ && cd __build__
           cmake -DBOOST_INCLUDE_LIBRARIES=$LIBRARY -DCMAKE_INSTALL_PREFIX=~/.local ..
 
       - name: Install
         run: |
-          cd ../boost-root/__build__
+          cd boost-root/__build__
           cmake --build . --target install -- -j $BUILD_JOBS
 
       - name: Use the installed library
         run: |
-          cd ../boost-root/libs/$LIBRARY/test/cmake_install_test && mkdir __build__ && cd __build__
+          cd boost-root/libs/$LIBRARY/test/cmake_install_test && mkdir __build__ && cd __build__
           cmake -DCMAKE_INSTALL_PREFIX=~/.local ..
           cmake --build . -- -j $BUILD_JOBS
           ctest --output-on-failure --no-tests=error
@@ -653,17 +755,23 @@ jobs:
         include:
           - os: ubuntu-20.04
           - os: ubuntu-22.04
-          - os: macos-11
           - os: macos-12
+          - os: macos-13
+          - os: macos-14
 
     runs-on: ${{matrix.os}}
+    timeout-minutes: 20
 
     steps:
-      - uses: actions/checkout@v3
-
       - name: Install packages
-        if: matrix.install
-        run: sudo apt install ${{matrix.install}}
+        run: |
+          if [ -f "/etc/debian_version" ]
+          then
+              sudo apt-get -o Acquire::Retries=$NET_RETRY_COUNT update
+              sudo apt-get -o Acquire::Retries=$NET_RETRY_COUNT install -y ninja-build ${{join(matrix.install, ' ')}}
+          else
+              brew install ninja ${{join(matrix.install, ' ')}}
+          fi
 
       - name: Setup Boost
         run: |
@@ -678,25 +786,264 @@ jobs:
           echo REF: $REF
           BOOST_BRANCH=develop && [ "$REF" = "master" ] && BOOST_BRANCH=master || true
           echo BOOST_BRANCH: $BOOST_BRANCH
+          BUILD_JOBS=$((nproc || sysctl -n hw.ncpu) 2> /dev/null)
+          echo BUILD_JOBS: $BUILD_JOBS
+          echo "BUILD_JOBS=$BUILD_JOBS" >> $GITHUB_ENV
+          echo "CMAKE_BUILD_PARALLEL_LEVEL=$BUILD_JOBS" >> $GITHUB_ENV
+          mkdir -p snapshot
+          cd snapshot
+          echo "Downloading library snapshot: https://github.com/${GITHUB_REPOSITORY}/archive/${GITHUB_SHA}.tar.gz"
+          curl -L --retry "$NET_RETRY_COUNT" -o "${LIBRARY}-${GITHUB_SHA}.tar.gz" "https://github.com/${GITHUB_REPOSITORY}/archive/${GITHUB_SHA}.tar.gz"
+          tar -xf "${LIBRARY}-${GITHUB_SHA}.tar.gz"
+          if [ ! -d "${LIBRARY}-${GITHUB_SHA}" ]
+          then
+              echo "Library snapshot does not contain the library directory ${LIBRARY}-${GITHUB_SHA}:"
+              ls -la
+              exit 1
+          fi
+          rm -f "${LIBRARY}-${GITHUB_SHA}.tar.gz"
           cd ..
           git clone -b $BOOST_BRANCH --depth 1 https://github.com/boostorg/boost.git boost-root
           cd boost-root
-          cp -r $GITHUB_WORKSPACE/* libs/$LIBRARY
+          mkdir -p libs
+          rm -rf "libs/$LIBRARY"
+          mv -f "../snapshot/${LIBRARY}-${GITHUB_SHA}" "libs/$LIBRARY"
+          rm -rf "../snapshot"
           git submodule update --init tools/boostdep
           python tools/boostdep/depinst/depinst.py --git_args "--jobs $GIT_FETCH_JOBS" $LIBRARY
 
       - name: Configure
         run: |
-          cd ../boost-root
+          cd boost-root
           mkdir __build__ && cd __build__
-          cmake -DBOOST_INCLUDE_LIBRARIES=$LIBRARY -DBUILD_TESTING=ON ..
+          # Building tests on Mac OS using makefiles sometimes blocks until timeout, if multiple parallel build jobs are used. Use Ninja instead.
+          cmake -G Ninja -DBOOST_INCLUDE_LIBRARIES=$LIBRARY -DBUILD_TESTING=ON ..
 
       - name: Build tests
         run: |
-          cd ../boost-root/__build__
+          cd boost-root/__build__
           cmake --build . --target tests -- -j $BUILD_JOBS
 
       - name: Run tests
         run: |
-          cd ../boost-root/__build__
+          cd boost-root/__build__
           ctest --output-on-failure --no-tests=error
+
+  windows-cmake-subdir:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: windows-2019
+          - os: windows-2022
+
+    runs-on: ${{matrix.os}}
+    timeout-minutes: 10
+
+    steps:
+      - name: Setup Boost
+        shell: cmd
+        run: |
+          echo GITHUB_REPOSITORY: %GITHUB_REPOSITORY%
+          for /f %%i in ("%GITHUB_REPOSITORY%") do set LIBRARY=%%~nxi
+          echo LIBRARY: %LIBRARY%
+          echo LIBRARY=%LIBRARY%>>%GITHUB_ENV%
+          echo GITHUB_BASE_REF: %GITHUB_BASE_REF%
+          echo GITHUB_REF: %GITHUB_REF%
+          if "%GITHUB_BASE_REF%" == "" set GITHUB_BASE_REF=%GITHUB_REF%
+          set BOOST_BRANCH=develop
+          for /f %%i in ("%GITHUB_BASE_REF%") do if "%%~nxi" == "master" set BOOST_BRANCH=master
+          echo BOOST_BRANCH: %BOOST_BRANCH%
+          mkdir snapshot
+          cd snapshot
+          echo Downloading library snapshot: https://github.com/%GITHUB_REPOSITORY%/archive/%GITHUB_SHA%.zip
+          curl -L --retry %NET_RETRY_COUNT% -o "%LIBRARY%-%GITHUB_SHA%.zip" "https://github.com/%GITHUB_REPOSITORY%/archive/%GITHUB_SHA%.zip"
+          tar -xf "%LIBRARY%-%GITHUB_SHA%.zip"
+          if not exist "%LIBRARY%-%GITHUB_SHA%\" (
+              echo Library snapshot does not contain the library directory %LIBRARY%-%GITHUB_SHA%:
+              dir
+              exit /b 1
+          )
+          del /f "%LIBRARY%-%GITHUB_SHA%.zip"
+          cd ..
+          git clone -b %BOOST_BRANCH% --depth 1 https://github.com/boostorg/boost.git boost-root
+          cd boost-root
+          if not exist "libs\" mkdir libs
+          if exist "libs\%LIBRARY%\" rmdir /s /q "libs\%LIBRARY%"
+          move /Y "..\snapshot\%LIBRARY%-%GITHUB_SHA%" "libs\%LIBRARY%"
+          rmdir /s /q "..\snapshot"
+          git submodule update --init tools/boostdep
+          python tools/boostdep/depinst/depinst.py --git_args "--jobs %GIT_FETCH_JOBS%" %LIBRARY%
+
+      - name: Use library with add_subdirectory (Debug)
+        shell: cmd
+        run: |
+          cd boost-root/libs/%LIBRARY%/test/cmake_subdir_test
+          mkdir __build__ && cd __build__
+          cmake ..
+          cmake --build . --config Debug
+          ctest --output-on-failure --no-tests=error -C Debug
+
+      - name: Use library with add_subdirectory (Release)
+        shell: cmd
+        run: |
+          cd boost-root/libs/%LIBRARY%/test/cmake_subdir_test/__build__
+          cmake --build . --config Release
+          ctest --output-on-failure --no-tests=error -C Release
+
+  windows-cmake-install:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: windows-2019
+          - os: windows-2022
+
+    runs-on: ${{matrix.os}}
+    timeout-minutes: 10
+
+    steps:
+      - name: Setup Boost
+        shell: cmd
+        run: |
+          echo GITHUB_REPOSITORY: %GITHUB_REPOSITORY%
+          for /f %%i in ("%GITHUB_REPOSITORY%") do set LIBRARY=%%~nxi
+          echo LIBRARY: %LIBRARY%
+          echo LIBRARY=%LIBRARY%>>%GITHUB_ENV%
+          echo GITHUB_BASE_REF: %GITHUB_BASE_REF%
+          echo GITHUB_REF: %GITHUB_REF%
+          if "%GITHUB_BASE_REF%" == "" set GITHUB_BASE_REF=%GITHUB_REF%
+          set BOOST_BRANCH=develop
+          for /f %%i in ("%GITHUB_BASE_REF%") do if "%%~nxi" == "master" set BOOST_BRANCH=master
+          echo BOOST_BRANCH: %BOOST_BRANCH%
+          mkdir snapshot
+          cd snapshot
+          echo Downloading library snapshot: https://github.com/%GITHUB_REPOSITORY%/archive/%GITHUB_SHA%.zip
+          curl -L --retry %NET_RETRY_COUNT% -o "%LIBRARY%-%GITHUB_SHA%.zip" "https://github.com/%GITHUB_REPOSITORY%/archive/%GITHUB_SHA%.zip"
+          tar -xf "%LIBRARY%-%GITHUB_SHA%.zip"
+          if not exist "%LIBRARY%-%GITHUB_SHA%\" (
+              echo Library snapshot does not contain the library directory %LIBRARY%-%GITHUB_SHA%:
+              dir
+              exit /b 1
+          )
+          del /f "%LIBRARY%-%GITHUB_SHA%.zip"
+          cd ..
+          git clone -b %BOOST_BRANCH% --depth 1 https://github.com/boostorg/boost.git boost-root
+          cd boost-root
+          if not exist "libs\" mkdir libs
+          if exist "libs\%LIBRARY%\" rmdir /s /q "libs\%LIBRARY%"
+          move /Y "..\snapshot\%LIBRARY%-%GITHUB_SHA%" "libs\%LIBRARY%"
+          rmdir /s /q "..\snapshot"
+          git submodule update --init tools/boostdep
+          python tools/boostdep/depinst/depinst.py --git_args "--jobs %GIT_FETCH_JOBS%" %LIBRARY%
+
+      - name: Configure
+        shell: cmd
+        run: |
+          cd boost-root
+          mkdir __build__ && cd __build__
+          cmake -DBOOST_INCLUDE_LIBRARIES=%LIBRARY% -DCMAKE_INSTALL_PREFIX=C:/cmake-prefix ..
+
+      - name: Install (Debug)
+        shell: cmd
+        run: |
+          cd boost-root/__build__
+          cmake --build . --target install --config Debug
+
+      - name: Install (Release)
+        shell: cmd
+        run: |
+          cd boost-root/__build__
+          cmake --build . --target install --config Release
+
+      - name: Use the installed library (Debug)
+        shell: cmd
+        run: |
+          cd boost-root/libs/%LIBRARY%/test/cmake_install_test && mkdir __build__ && cd __build__
+          cmake -DCMAKE_INSTALL_PREFIX=C:/cmake-prefix ..
+          cmake --build . --config Debug
+          ctest --output-on-failure --no-tests=error -C Debug
+
+      - name: Use the installed library (Release)
+        shell: cmd
+        run: |
+          cd boost-root/libs/%LIBRARY%/test/cmake_install_test/__build__
+          cmake --build . --config Release
+          ctest --output-on-failure --no-tests=error -C Release
+
+  windows-cmake-test:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: windows-2019
+          - os: windows-2022
+
+    runs-on: ${{matrix.os}}
+    timeout-minutes: 20
+
+    steps:
+      - name: Setup Boost
+        shell: cmd
+        run: |
+          echo GITHUB_REPOSITORY: %GITHUB_REPOSITORY%
+          for /f %%i in ("%GITHUB_REPOSITORY%") do set LIBRARY=%%~nxi
+          echo LIBRARY: %LIBRARY%
+          echo LIBRARY=%LIBRARY%>>%GITHUB_ENV%
+          echo GITHUB_BASE_REF: %GITHUB_BASE_REF%
+          echo GITHUB_REF: %GITHUB_REF%
+          if "%GITHUB_BASE_REF%" == "" set GITHUB_BASE_REF=%GITHUB_REF%
+          set BOOST_BRANCH=develop
+          for /f %%i in ("%GITHUB_BASE_REF%") do if "%%~nxi" == "master" set BOOST_BRANCH=master
+          echo BOOST_BRANCH: %BOOST_BRANCH%
+          mkdir snapshot
+          cd snapshot
+          echo Downloading library snapshot: https://github.com/%GITHUB_REPOSITORY%/archive/%GITHUB_SHA%.zip
+          curl -L --retry %NET_RETRY_COUNT% -o "%LIBRARY%-%GITHUB_SHA%.zip" "https://github.com/%GITHUB_REPOSITORY%/archive/%GITHUB_SHA%.zip"
+          tar -xf "%LIBRARY%-%GITHUB_SHA%.zip"
+          if not exist "%LIBRARY%-%GITHUB_SHA%\" (
+              echo Library snapshot does not contain the library directory %LIBRARY%-%GITHUB_SHA%:
+              dir
+              exit /b 1
+          )
+          del /f "%LIBRARY%-%GITHUB_SHA%.zip"
+          cd ..
+          git clone -b %BOOST_BRANCH% --depth 1 https://github.com/boostorg/boost.git boost-root
+          cd boost-root
+          if not exist "libs\" mkdir libs
+          if exist "libs\%LIBRARY%\" rmdir /s /q "libs\%LIBRARY%"
+          move /Y "..\snapshot\%LIBRARY%-%GITHUB_SHA%" "libs\%LIBRARY%"
+          rmdir /s /q "..\snapshot"
+          git submodule update --init tools/boostdep
+          python tools/boostdep/depinst/depinst.py --git_args "--jobs %GIT_FETCH_JOBS%" %LIBRARY%
+
+      - name: Configure
+        shell: cmd
+        run: |
+          cd boost-root
+          mkdir __build__ && cd __build__
+          cmake -DBOOST_INCLUDE_LIBRARIES=%LIBRARY% -DBUILD_TESTING=ON ..
+
+      - name: Build tests (Debug)
+        shell: cmd
+        run: |
+          cd boost-root/__build__
+          cmake --build . --target tests --config Debug
+
+      - name: Run tests (Debug)
+        shell: cmd
+        run: |
+          cd boost-root/__build__
+          ctest --output-on-failure --no-tests=error -C Debug
+
+      - name: Build tests (Release)
+        shell: cmd
+        run: |
+          cd boost-root/__build__
+          cmake --build . --target tests --config Release
+
+      - name: Run tests (Release)
+        shell: cmd
+        run: |
+          cd boost-root/__build__
+          ctest --output-on-failure --no-tests=error -C Release

doc/bit.qbk

@@ -33,6 +33,11 @@ namespace core
 template<class To, class From>
 To bit_cast(From const& from) noexcept;
 
+// byteswap
+
+template<class T>
+constexpr T byteswap(T x) noexcept;
+
 // Integral powers of 2
 
 template<class T>
@@ -102,6 +107,17 @@ constant expression context.
 
 [endsect]
 
+[section byteswap]
+
+`template<class T> constexpr T byteswap(T x) noexcept;`
+
+* *Requires:* `T` must be an integer type (i.e. one of `char`, `signed char`,
+  `unsigned char`, `short`, `unsigned short`, `int`, `unsigned int`, `long`,
+  `unsigned long`, `long long`, `unsigned long long`) without padding bits.
+* *Returns:* `x` with the storage bytes reversed.
+
+[endsect]
+
 [section Integral powers of 2]
 
 `template<class T> constexpr bool has_single_bit(T x) noexcept;`

doc/changes.qbk

@@ -1,12 +1,57 @@
 [/
   Copyright 2021 Peter Dimov
-  Copyright 2022 Andrey Semashev
+  Copyright 2022-2024 Andrey Semashev
   Distributed under the Boost Software License, Version 1.0.
   https://boost.org/LICENSE_1_0.txt)
 ]
 
 [section Revision History]
 
+[section Changes in 1.85.0]
+
+* Added a new [link core.functor `boost/core/functor.hpp`] header with a `functor` class template
+  for wrapping a raw function into a function object class.
+* Changed [link core.null_deleter `null_deleter`], [link core.fclose_deleter `fclose_deleter`]
+  and [link.checked_delete checked deleter] definitions so that they don't bring namespace `boost`
+  into argument-dependent lookup in cases like this:
+  ```
+  std::unique_ptr< std::FILE, boost::fclose_deleter > p1, p2;
+  swap(p1, p2); // no longer looks for boost::swap as part of ADL
+  ```
+  Users may need to either explicitly qualify the namespace of the called function or add a
+  `using`-declaration.
+
+[endsect]
+
+[section Changes in 1.84.0]
+
+* `boost::swap` utility function has been renamed to `boost::core::invoke_swap` to
+  avoid forming a potential infinite recursion when the arguments are not swappable.
+  The new function is defined in `boost/core/invoke_swap.hpp` and is functionally equivalent
+  to `boost::swap`. The old `boost::swap` name is preserved for backward compatibility
+  but deprecated and will be removed in a future release. Its `noexcept` specification
+  has been removed to avoid compile errors caused by compile-time recursion.
+  `BOOST_ALLOW_DEPRECATED_SYMBOLS` or `BOOST_ALLOW_DEPRECATED` can be defined to suppress
+  deprecation warnings for the transition period. ([@https://github.com/boostorg/core/issues/148 #148])
+* Headers `boost/swap.hpp`, `boost/utility/swap.hpp` and `boost/core/swap.hpp` are
+  deprecated and will be removed. Please, switch to `boost/core/invoke_swap.hpp`.
+  `BOOST_ALLOW_DEPRECATED_HEADERS` or `BOOST_ALLOW_DEPRECATED` can be defined to suppress
+  deprecation warnings.
+
+[endsect]
+
+[section Changes in 1.83.0]
+
+* Added support for incomplete types to [link core.type_name `boost::core::type_name`].
+* Bit manipulation functions in [link core.bit `boost/core/bit.hpp`] are now
+  `constexpr` on recent MSVC versions (VS2019 update 5 and later.)
+* Added `boost::core::byteswap` (an implementation of `std::byteswap` from
+  C++23) to [link core.bit `boost/core/bit.hpp`].
+* Moved the yield primitives `sp_thread_pause`, `sp_thread_yield`, `sp_thread_sleep`
+  from SmartPtr implementation details to `boost/core/yield_primitives.hpp`.
+
+[endsect]
+
 [section Changes in 1.82.0]
 
 * Added [link core.snprintf `boost/core/snprintf.hpp`] header with portable definitions of `snprintf`, `vsnprintf` and

doc/core.qbk

@@ -55,6 +55,7 @@ criteria for inclusion is that the utility component be:
 [include exchange.qbk]
 [include explicit_operator_bool.qbk]
 [include first_scalar.qbk]
+[include functor.qbk]
 [include identity.qbk]
 [include ignore_unused.qbk]
 [include is_same.qbk]
@@ -69,6 +70,7 @@ criteria for inclusion is that the utility component be:
 [include null_deleter.qbk]
 [include fclose_deleter.qbk]
 [include nvp.qbk]
+[include pointer_in_range.qbk]
 [include pointer_traits.qbk]
 [include quick_exit.qbk]
 [include ref.qbk]
@@ -83,3 +85,4 @@ criteria for inclusion is that the utility component be:
 [include uncaught_exceptions.qbk]
 [include use_default.qbk]
 [include verbose_terminate_handler.qbk]
+[include yield_primitives.qbk]

doc/functor.qbk

@@ -0,0 +1,101 @@
+[/
+ / Copyright (c) 2024 Andrey Semashev
+ /
+ / Distributed under the Boost Software License, Version 1.0. (See accompanying
+ / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ /]
+
+[section:functor functor]
+
+[simplesect Authors]
+
+* Andrey Semashev
+
+[endsimplesect]
+
+[section Header <boost/core/functor.hpp>]
+
+[note This component requires a compiler supporting C++17 or newer.]
+
+The header `<boost/core/functor.hpp>` defines the `boost::core::functor` class template
+that wraps a raw function specified in its template parameter into a function object class.
+The function object forwards any arguments passed to it to the wrapped function and returns
+the result of the call.
+
+The `functor` wrapper can be useful in cases when a function object class type is required,
+for example, for use with smart pointers such as `std::unique_ptr`, where the actual logic
+of the function object is already implemented as a raw function, possibly provided by a
+third party library. Since `functor` is default-constructible and does not store a pointer
+to the wrapped function internally, using `functor` is less error-prone and more efficient
+than using the pointer to function instead. For example, with `std::unique_ptr` you don't
+need to pass a pointer to the deleter function in the `std::unique_ptr` constructor, and
+the `std::unique_ptr` object does not store and invoke a pointer to the deleter function.
+With `functor`, the deleter function becomes part of the `std::unique_ptr` type, which
+prevents mixing pointers with incompatible deleters.
+
+```
+void my_deleter(void* p);
+
+using malloc_ptr = std::unique_ptr< char, boost::core::functor< std::free > >;
+using my_ptr = std::unique_ptr< char, boost::core::functor< my_deleter > >;
+
+my_ptr create_string(std::size_t size);
+void consume_string(my_ptr&& str);
+
+malloc_ptr ptr1(static_cast< char* >(std::malloc(size)));
+// ptr1 = allocate_string(size); // error, cannot convert my_ptr to malloc_ptr
+my_ptr ptr2 = create_string(size); // ok
+
+// consume_string(std::move(ptr1)); // error, cannot convert malloc_ptr&& to my_ptr
+consume_string(std::move(ptr2)); // ok
+```
+
+Using `functor` may also be beneficial for reducing generated code sizes. For example, in
+order to avoid storing and invoking a pointer to the deleter function in `std::shared_ptr`,
+one may be inclined to use lambda functions to wrap the deleter function call like this:
+
+```
+std::shared_ptr< int > ptr(static_cast< int* >(std::malloc(sizeof(int))), [](int* p) { std::free(p); });
+```
+
+The problem is that every lambda function declaration introduces a unique type, even if
+the lambda function definition matches exactly one of the previously declared lambda
+functions. Thus, if `std::shared_ptr` objects like the one above are created in multiple
+places in the program, the definition of the shared pointer counter and associated code
+and data (e.g. virtual function table) will be duplicated for each instance.
+
+Replacing the lambda function with `functor` solves this problem without sacrificing
+readability or efficiency:
+
+```
+std::shared_ptr< int > ptr(static_cast< int* >(std::malloc(sizeof(int))), boost::core::functor< std::free >());
+```
+
+[section Synopsis]
+
+```
+namespace boost::core {
+
+template< auto Function >
+struct functor
+{
+    template< typename... Args >
+    decltype(auto) operator() (Args&&... args) const noexcept(...);
+};
+
+} // namespace boost::core
+```
+
+[endsect]
+
+[section `template< typename... Args > decltype(auto) operator() (Args&&... args) const noexcept(...);`]
+
+* *Effects:* `return Function(std::forward< Args >(args)...)`.
+* *Throws:* Nothing, unless invoking `Function` throws.
+* *Note:* This function only participates in overload resolution if `Function(std::forward< Args >(args)...)` is a valid call expression.
+
+[endsect]
+
+[endsect]
+
+[endsect]

doc/pointer_in_range.qbk

@@ -0,0 +1,81 @@
+[/
+Copyright 2024 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+]
+
+[section:pointer_in_range pointer_in_range]
+
+[simplesect Authors]
+
+* Glen Fernandes
+
+[endsimplesect]
+
+[section Overview]
+
+The header <boost/core/pointer_in_range.hpp> provides the function template
+`boost::pointer_in_range` to check if a pointer is in a given range. This
+can be used in constant expressions in C++14 or higher when the compiler has a
+builtin to support `std::is_constant_evaluated`.
+
+[endsect]
+
+[section Examples]
+
+The following is an example of an allocator's deallocation function that does
+nothing if the pointer falls within a small automatically allocated buffer.
+
+```
+template<class T, class N>
+void
+Allocator<T, N>::deallocate(pointer ptr, size_type)
+{
+    if (!boost::pointer_in_range(ptr, buffer_, buffer_ + N)) {
+        ::operator delete(ptr);
+    }
+}
+```
+
+[endsect]
+
+[section Reference]
+
+```
+namespace boost {
+
+template<class T>
+constexpr bool pointer_in_range(const T* ptr, const T* begin, const T* end);
+
+} /* boost */
+```
+
+[section Functions]
+
+[variablelist
+[[`template<class T> constexpr bool pointer_in_range(const T* ptr,
+const T* begin, const T* end);`]
+[[variablelist
+[[Requires][`[begin,end)` is a valid range.]]
+[[Returns][`true` if `ptr` is in range `[begin,end)`, otherwise `false`.]]]]]]
+
+[endsect]
+
+[endsect]
+
+[section Notes]
+
+If `boost::pointer_in_range` is not usable in constant expressions the macro
+`BOOST_CORE_NO_CONSTEXPR_POINTER_IN_RANGE` is defined.
+
+[endsect]
+
+[section History]
+
+Glen Fernandes implemented `pointer_in_range`.
+
+[endsect]
+
+[endsect]

doc/swap.qbk

@@ -20,17 +20,17 @@
 
 [endsimplesect]
 
-[section Header <boost/core/swap.hpp>]
+[section Header <boost/core/invoke_swap.hpp>]
 
-[^template<class T> void swap(T& left, T& right) noexcept(['see below]);]
+[^template<class T> void invoke_swap(T& left, T& right) noexcept(['see below]);]
 
 [endsect]
 
 [section Introduction]
 
-The template function `boost::swap` allows the values of two
-variables to be swapped, using argument dependent lookup to
-select a specialized swap function if available. If no
+The template function `boost::core::invoke_swap` allows the
+values of two variables to be swapped, using argument dependent
+lookup to select a specialized swap function if available. If no
 specialized swap function is available, `std::swap` is used.
 
 [endsect]
@@ -56,9 +56,9 @@ Although this is legal C++, no Boost libraries use this method,
 whereas many Boost libraries provide specialized swap functions
 in their own namespaces.
 
-`boost::swap` also supports swapping built-in arrays. Note that
-`std::swap` originally did not do so, but a request to add an
-overload of `std::swap` for built-in arrays has been accepted
+`boost::core::invoke_swap` also supports swapping built-in arrays.
+Note that `std::swap` originally did not do so, but a request to
+add an overload of `std::swap` for built-in arrays has been accepted
 by the C++ Standards Committee[footnote
   [@http://open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#809
   LWG Defect Report 809: std::swap should be overloaded for array
@@ -68,14 +68,15 @@ by the C++ Standards Committee[footnote
 
 [section Exception Safety]
 
-`boost::swap` provides the same exception guarantee as the
-underlying swap function used, with one exception; for an array
+`boost::core::invoke_swap` provides the same exception guarantee as
+the underlying swap function used, with one exception; for an array
 of type `T[n]`, where `n > 1` and the underlying swap function
-for `T` provides the strong exception guarantee, `boost::swap`
-provides only the basic exception guarantee.
+for `T` provides the strong exception guarantee,
+`boost::core::invoke_swap` provides only the basic exception guarantee.
 
-In C++11 and later, `boost::swap` propagates the same `noexcept`
-specification as the one specified in the underlying swap function.
+In C++11 and later, `boost::core::invoke_swap` propagates the same
+`noexcept` specification as the one specified in the underlying swap
+function.
 
 [endsect]
 
@@ -104,7 +105,7 @@ Or:
 [section Portability]
 
 Several older compilers do not support argument dependent
-lookup. On these compilers `boost::swap` will call
+lookup. On these compilers `boost::core::invoke_swap` will call
 `std::swap`, ignoring any specialized swap functions that
 could be found as a result of argument dependent lookup.
 
@@ -118,7 +119,9 @@ could be found as a result of argument dependent lookup.
   tests, and documentation
 * *Steven Watanabe* - for the idea to make `boost::swap` less
   specialized than `std::swap`, thereby allowing the function
-  to have the name 'swap' without introducing ambiguity
+  to have the name 'swap' without introducing ambiguity. However,
+  later the function was renamed to `boost::core::invoke_swap`
+  to avoid potential infinite recursion.
 
 [endsect]
 

doc/yield_primitives.qbk

@@ -0,0 +1,79 @@
+[/
+  Copyright 2023 Peter Dimov
+  Distributed under the Boost Software License, Version 1.0.
+  https://boost.org/LICENSE_1_0.txt
+]
+
+[section:yield_primitives Yield Primitives]
+
+[simplesect Authors]
+
+* Peter Dimov
+
+[endsimplesect]
+
+[section Header <boost/core/yield_primitives.hpp>]
+
+The header `<boost/core/yield_primitives.hpp>` implements a
+collection of primitives that allow the current thread to
+yield the CPU in various ways.
+
+Very low level, specialized functionality, generally only useful for
+implementing spinlocks. Normal synchronization primitives should
+almost always be preferable in application code.
+
+[section Synopsis]
+
+``
+namespace boost
+{
+namespace core
+{
+
+void sp_thread_pause() noexcept;
+void sp_thread_yield() noexcept;
+void sp_thread_sleep() noexcept;
+
+} // namespace core
+} // namespace boost
+``
+
+[endsect]
+
+[section sp_thread_pause]
+
+`void sp_thread_pause() noexcept;`
+
+Emits a PAUSE instruction (on x86) or a YIELD instruction (on ARM).
+
+A portable equivalent of the GCC builtin function `__builtin_ia32_pause`.
+
+[endsect]
+
+[section sp_thread_yield]
+
+`void sp_thread_yield() noexcept;`
+
+Informs the scheduler that the current thread wishes to relinquish
+the rest of its timeslice.
+
+A portable equivalent of POSIX `sched_yield`.
+
+[endsect]
+
+[section sp_thread_sleep]
+
+`void sp_thread_sleep() noexcept;`
+
+Sleeps for a short period, as if by calling POSIX `nanosleep` with
+a small, implementation-dependent, interval (usually one microsecond).
+
+A more forcing yield primitive than `sp_thread_yield`, because it's
+generally not ignored even if all other waiting threads are of lower
+priority.
+
+[endsect]
+
+[endsect]
+
+[endsect]

include/boost/core/allocator_access.hpp

@@ -43,9 +43,17 @@ _LIBCPP_SUPPRESS_DEPRECATED_PUSH
 #if defined(_STL_DISABLE_DEPRECATED_WARNING)
 _STL_DISABLE_DEPRECATED_WARNING
 #endif
-#if defined(_MSC_VER)
-#pragma warning(push)
-#pragma warning(disable:4996)
+#if defined(__clang__) && defined(__has_warning)
+# if __has_warning("-Wdeprecated-declarations")
+#  pragma clang diagnostic push
+#  pragma clang diagnostic ignored "-Wdeprecated-declarations"
+# endif
+#elif defined(_MSC_VER)
+# pragma warning(push)
+# pragma warning(disable: 4996)
+#elif defined(BOOST_GCC) && BOOST_GCC >= 40600
+# pragma GCC diagnostic push
+# pragma GCC diagnostic ignored "-Wdeprecated-declarations"
 #endif
 
 namespace boost {
@@ -807,9 +815,15 @@ using allocator_rebind_t = typename allocator_rebind<A, T>::type;
 
 } /* boost */
 
-#if defined(_MSC_VER)
-#pragma warning(pop)
-#endif
+#if defined(__clang__) && defined(__has_warning)
+# if __has_warning("-Wdeprecated-declarations")
+#  pragma clang diagnostic pop
+# endif
+#elif defined(_MSC_VER)
+# pragma warning(pop)
+#elif defined(BOOST_GCC) && BOOST_GCC >= 40600
+# pragma GCC diagnostic pop
+#endif  
 #if defined(_STL_RESTORE_DEPRECATED_WARNING)
 _STL_RESTORE_DEPRECATED_WARNING
 #endif

include/boost/core/bit.hpp

@@ -20,6 +20,7 @@
 #include <boost/cstdint.hpp>
 #include <limits>
 #include <cstring>
+#include <cstdlib>
 
 #if defined(_MSC_VER)
 
@@ -38,6 +39,27 @@
 
 #endif // defined(_MSC_VER)
 
+#if defined(BOOST_MSVC) && BOOST_MSVC >= 1925
+# define BOOST_CORE_HAS_BUILTIN_ISCONSTEVAL
+#endif
+
+#if defined(__has_builtin)
+# if __has_builtin(__builtin_bit_cast)
+#  define BOOST_CORE_HAS_BUILTIN_BIT_CAST
+# endif
+# if __has_builtin(__builtin_bswap16)
+#  define BOOST_CORE_HAS_BUILTIN_BSWAP16
+# endif
+#endif
+
+#if !defined(BOOST_CORE_HAS_BUILTIN_BIT_CAST) && (defined(BOOST_MSVC) && BOOST_MSVC >= 1926)
+#  define BOOST_CORE_HAS_BUILTIN_BIT_CAST
+#endif
+
+#if !defined(BOOST_CORE_HAS_BUILTIN_BSWAP16) && (defined(BOOST_GCC) && BOOST_GCC >= 40800)
+#  define BOOST_CORE_HAS_BUILTIN_BSWAP16
+#endif
+
 namespace boost
 {
 namespace core
@@ -45,6 +67,16 @@ namespace core
 
 // bit_cast
 
+#if defined(BOOST_CORE_HAS_BUILTIN_BIT_CAST)
+
+template<class To, class From>
+BOOST_CONSTEXPR To bit_cast( From const & from ) BOOST_NOEXCEPT
+{
+    return __builtin_bit_cast( To, from );
+}
+
+#else
+
 template<class To, class From>
 To bit_cast( From const & from ) BOOST_NOEXCEPT
 {
@@ -55,6 +87,8 @@ To bit_cast( From const & from ) BOOST_NOEXCEPT
     return to;
 }
 
+#endif
+
 // countl
 
 #if defined(__GNUC__) || defined(__clang__)
@@ -102,10 +136,51 @@ BOOST_CONSTEXPR int countl_zero( T x ) BOOST_NOEXCEPT
 namespace detail
 {
 
+#if defined(_MSC_VER) && defined(BOOST_CORE_HAS_BUILTIN_ISCONSTEVAL)
+
+BOOST_CXX14_CONSTEXPR inline int countl_impl( boost::uint32_t x ) BOOST_NOEXCEPT
+{
+    if( __builtin_is_constant_evaluated() )
+    {
+        constexpr unsigned char mod37[ 37 ] = { 32, 31, 6, 30, 9, 5, 0, 29, 16, 8, 2, 4, 21, 0, 19, 28, 25, 15, 0, 7, 10, 1, 17, 3, 22, 20, 26, 0, 11, 18, 23, 27, 12, 24, 13, 14, 0 };
+
+        x |= x >> 1;
+        x |= x >> 2;
+        x |= x >> 4;
+        x |= x >> 8;
+        x |= x >> 16;
+
+        return mod37[ x % 37 ];
+    }
+    else
+    {
+        unsigned long r;
+
+        if( _BitScanReverse( &r, x ) )
+        {
+            return 31 - static_cast<int>( r );
+        }
+        else
+        {
+            return 32;
+        }
+    }
+}
+
+BOOST_CXX14_CONSTEXPR inline int countl_impl( boost::uint8_t x ) BOOST_NOEXCEPT
+{
+    return boost::core::detail::countl_impl( static_cast<boost::uint32_t>( x ) ) - 24;
+}
+
+BOOST_CXX14_CONSTEXPR inline int countl_impl( boost::uint16_t x ) BOOST_NOEXCEPT
+{
+    return boost::core::detail::countl_impl( static_cast<boost::uint32_t>( x ) ) - 16;
+}
+
+#elif defined(_MSC_VER)
+
 inline int countl_impl( boost::uint32_t x ) BOOST_NOEXCEPT
 {
-#if defined(_MSC_VER)
-
     unsigned long r;
 
     if( _BitScanReverse( &r, x ) )
@@ -116,44 +191,6 @@ inline int countl_impl( boost::uint32_t x ) BOOST_NOEXCEPT
     {
         return 32;
     }
-
-#else
-
-    static unsigned char const mod37[ 37 ] = { 32, 31, 6, 30, 9, 5, 0, 29, 16, 8, 2, 4, 21, 0, 19, 28, 25, 15, 0, 7, 10, 1, 17, 3, 22, 20, 26, 0, 11, 18, 23, 27, 12, 24, 13, 14, 0 };
-
-    x |= x >> 1;
-    x |= x >> 2;
-    x |= x >> 4;
-    x |= x >> 8;
-    x |= x >> 16;
-
-    return mod37[ x % 37 ];
-
-#endif
-}
-
-inline int countl_impl( boost::uint64_t x ) BOOST_NOEXCEPT
-{
-#if defined(_MSC_VER) && defined(_M_X64)
-
-    unsigned long r;
-
-    if( _BitScanReverse64( &r, x ) )
-    {
-        return 63 - static_cast<int>( r );
-    }
-    else
-    {
-        return 64;
-    }
-
-#else
-
-    return static_cast<boost::uint32_t>( x >> 32 ) != 0?
-        boost::core::detail::countl_impl( static_cast<boost::uint32_t>( x >> 32 ) ):
-        boost::core::detail::countl_impl( static_cast<boost::uint32_t>( x ) ) + 32;
-
-#endif
 }
 
 inline int countl_impl( boost::uint8_t x ) BOOST_NOEXCEPT
@@ -166,10 +203,98 @@ inline int countl_impl( boost::uint16_t x ) BOOST_NOEXCEPT
     return boost::core::detail::countl_impl( static_cast<boost::uint32_t>( x ) ) - 16;
 }
 
+#else
+
+inline int countl_impl( boost::uint32_t x ) BOOST_NOEXCEPT
+{
+    static unsigned char const mod37[ 37 ] = { 32, 31, 6, 30, 9, 5, 0, 29, 16, 8, 2, 4, 21, 0, 19, 28, 25, 15, 0, 7, 10, 1, 17, 3, 22, 20, 26, 0, 11, 18, 23, 27, 12, 24, 13, 14, 0 };
+
+    x |= x >> 1;
+    x |= x >> 2;
+    x |= x >> 4;
+    x |= x >> 8;
+    x |= x >> 16;
+
+    return mod37[ x % 37 ];
+}
+
+inline int countl_impl( boost::uint8_t x ) BOOST_NOEXCEPT
+{
+    return boost::core::detail::countl_impl( static_cast<boost::uint32_t>( x ) ) - 24;
+}
+
+inline int countl_impl( boost::uint16_t x ) BOOST_NOEXCEPT
+{
+    return boost::core::detail::countl_impl( static_cast<boost::uint32_t>( x ) ) - 16;
+}
+
+#endif
+
+#if defined(_MSC_VER) && defined(_M_X64) && defined(BOOST_CORE_HAS_BUILTIN_ISCONSTEVAL)
+
+BOOST_CXX14_CONSTEXPR inline int countl_impl( boost::uint64_t x ) BOOST_NOEXCEPT
+{
+    if( __builtin_is_constant_evaluated() )
+    {
+        return static_cast<boost::uint32_t>( x >> 32 ) != 0?
+            boost::core::detail::countl_impl( static_cast<boost::uint32_t>( x >> 32 ) ):
+            boost::core::detail::countl_impl( static_cast<boost::uint32_t>( x ) ) + 32;
+    }
+    else
+    {
+        unsigned long r;
+
+        if( _BitScanReverse64( &r, x ) )
+        {
+            return 63 - static_cast<int>( r );
+        }
+        else
+        {
+            return 64;
+        }
+    }
+}
+
+#elif defined(_MSC_VER) && defined(_M_X64)
+
+inline int countl_impl( boost::uint64_t x ) BOOST_NOEXCEPT
+{
+    unsigned long r;
+
+    if( _BitScanReverse64( &r, x ) )
+    {
+        return 63 - static_cast<int>( r );
+    }
+    else
+    {
+        return 64;
+    }
+}
+
+#elif defined(_MSC_VER) && defined(BOOST_CORE_HAS_BUILTIN_ISCONSTEVAL)
+
+BOOST_CXX14_CONSTEXPR inline int countl_impl( boost::uint64_t x ) BOOST_NOEXCEPT
+{
+    return static_cast<boost::uint32_t>( x >> 32 ) != 0?
+        boost::core::detail::countl_impl( static_cast<boost::uint32_t>( x >> 32 ) ):
+        boost::core::detail::countl_impl( static_cast<boost::uint32_t>( x ) ) + 32;
+}
+
+#else
+
+inline int countl_impl( boost::uint64_t x ) BOOST_NOEXCEPT
+{
+    return static_cast<boost::uint32_t>( x >> 32 ) != 0?
+        boost::core::detail::countl_impl( static_cast<boost::uint32_t>( x >> 32 ) ):
+        boost::core::detail::countl_impl( static_cast<boost::uint32_t>( x ) ) + 32;
+}
+
+#endif
+
 } // namespace detail
 
 template<class T>
-int countl_zero( T x ) BOOST_NOEXCEPT
+BOOST_CXX14_CONSTEXPR int countl_zero( T x ) BOOST_NOEXCEPT
 {
     BOOST_STATIC_ASSERT( std::numeric_limits<T>::is_integer && !std::numeric_limits<T>::is_signed );
 
@@ -250,10 +375,44 @@ BOOST_CONSTEXPR int countr_zero( T x ) BOOST_NOEXCEPT
 namespace detail
 {
 
+#if defined(_MSC_VER) && defined(BOOST_CORE_HAS_BUILTIN_ISCONSTEVAL)
+
+BOOST_CXX14_CONSTEXPR inline int countr_impl( boost::uint32_t x ) BOOST_NOEXCEPT
+{
+    if( __builtin_is_constant_evaluated() )
+    {
+        constexpr unsigned char mod37[ 37 ] = { 32, 0, 1, 26, 2, 23, 27, 0, 3, 16, 24, 30, 28, 11, 0, 13, 4, 7, 17, 0, 25, 22, 31, 15, 29, 10, 12, 6, 0, 21, 14, 9, 5, 20, 8, 19, 18 };
+        return mod37[ ( -(boost::int32_t)x & x ) % 37 ];
+    }
+    else
+    {
+        unsigned long r;
+
+        if( _BitScanForward( &r, x ) )
+        {
+            return static_cast<int>( r );
+        }
+        else
+        {
+            return 32;
+        }
+    }
+}
+
+BOOST_CXX14_CONSTEXPR inline int countr_impl( boost::uint8_t x ) BOOST_NOEXCEPT
+{
+    return boost::core::detail::countr_impl( static_cast<boost::uint32_t>( x ) | 0x100 );
+}
+
+BOOST_CXX14_CONSTEXPR inline int countr_impl( boost::uint16_t x ) BOOST_NOEXCEPT
+{
+    return boost::core::detail::countr_impl( static_cast<boost::uint32_t>( x ) | 0x10000 );
+}
+
+#elif defined(_MSC_VER)
+
 inline int countr_impl( boost::uint32_t x ) BOOST_NOEXCEPT
 {
-#if defined(_MSC_VER)
-
     unsigned long r;
 
     if( _BitScanForward( &r, x ) )
@@ -264,37 +423,6 @@ inline int countr_impl( boost::uint32_t x ) BOOST_NOEXCEPT
     {
         return 32;
     }
-
-#else
-
-    static unsigned char const mod37[ 37 ] = { 32, 0, 1, 26, 2, 23, 27, 0, 3, 16, 24, 30, 28, 11, 0, 13, 4, 7, 17, 0, 25, 22, 31, 15, 29, 10, 12, 6, 0, 21, 14, 9, 5, 20, 8, 19, 18 };
-    return mod37[ ( -(boost::int32_t)x & x ) % 37 ];
-
-#endif
-}
-
-inline int countr_impl( boost::uint64_t x ) BOOST_NOEXCEPT
-{
-#if defined(_MSC_VER) && defined(_M_X64)
-
-    unsigned long r;
-
-    if( _BitScanForward64( &r, x ) )
-    {
-        return static_cast<int>( r );
-    }
-    else
-    {
-        return 64;
-    }
-
-#else
-
-    return static_cast<boost::uint32_t>( x ) != 0?
-        boost::core::detail::countr_impl( static_cast<boost::uint32_t>( x ) ):
-        boost::core::detail::countr_impl( static_cast<boost::uint32_t>( x >> 32 ) ) + 32;
-
-#endif
 }
 
 inline int countr_impl( boost::uint8_t x ) BOOST_NOEXCEPT
@@ -307,10 +435,91 @@ inline int countr_impl( boost::uint16_t x ) BOOST_NOEXCEPT
     return boost::core::detail::countr_impl( static_cast<boost::uint32_t>( x ) | 0x10000 );
 }
 
+#else
+
+inline int countr_impl( boost::uint32_t x ) BOOST_NOEXCEPT
+{
+    static unsigned char const mod37[ 37 ] = { 32, 0, 1, 26, 2, 23, 27, 0, 3, 16, 24, 30, 28, 11, 0, 13, 4, 7, 17, 0, 25, 22, 31, 15, 29, 10, 12, 6, 0, 21, 14, 9, 5, 20, 8, 19, 18 };
+    return mod37[ ( -(boost::int32_t)x & x ) % 37 ];
+}
+
+inline int countr_impl( boost::uint8_t x ) BOOST_NOEXCEPT
+{
+    return boost::core::detail::countr_impl( static_cast<boost::uint32_t>( x ) | 0x100 );
+}
+
+inline int countr_impl( boost::uint16_t x ) BOOST_NOEXCEPT
+{
+    return boost::core::detail::countr_impl( static_cast<boost::uint32_t>( x ) | 0x10000 );
+}
+
+#endif
+
+#if defined(_MSC_VER) && defined(_M_X64) && defined(BOOST_CORE_HAS_BUILTIN_ISCONSTEVAL)
+
+BOOST_CXX14_CONSTEXPR inline int countr_impl( boost::uint64_t x ) BOOST_NOEXCEPT
+{
+    if( __builtin_is_constant_evaluated() )
+    {
+        return static_cast<boost::uint32_t>( x ) != 0?
+            boost::core::detail::countr_impl( static_cast<boost::uint32_t>( x ) ):
+            boost::core::detail::countr_impl( static_cast<boost::uint32_t>( x >> 32 ) ) + 32;
+    }
+    else
+    {
+        unsigned long r;
+
+        if( _BitScanForward64( &r, x ) )
+        {
+            return static_cast<int>( r );
+        }
+        else
+        {
+            return 64;
+        }
+    }
+}
+
+#elif defined(_MSC_VER) && defined(_M_X64)
+
+inline int countr_impl( boost::uint64_t x ) BOOST_NOEXCEPT
+{
+    unsigned long r;
+
+    if( _BitScanForward64( &r, x ) )
+    {
+        return static_cast<int>( r );
+    }
+    else
+    {
+        return 64;
+    }
+}
+
+#elif defined(_MSC_VER) && defined(BOOST_CORE_HAS_BUILTIN_ISCONSTEVAL)
+
+BOOST_CXX14_CONSTEXPR inline int countr_impl( boost::uint64_t x ) BOOST_NOEXCEPT
+{
+    return static_cast<boost::uint32_t>( x ) != 0?
+        boost::core::detail::countr_impl( static_cast<boost::uint32_t>( x ) ):
+        boost::core::detail::countr_impl( static_cast<boost::uint32_t>( x >> 32 ) ) + 32;
+}
+
+#else
+
+inline int countr_impl( boost::uint64_t x ) BOOST_NOEXCEPT
+{
+    return static_cast<boost::uint32_t>( x ) != 0?
+        boost::core::detail::countr_impl( static_cast<boost::uint32_t>( x ) ):
+        boost::core::detail::countr_impl( static_cast<boost::uint32_t>( x >> 32 ) ) + 32;
+}
+
+#endif
+
 } // namespace detail
 
 template<class T>
-int countr_zero( T x ) BOOST_NOEXCEPT
+BOOST_CXX14_CONSTEXPR int countr_zero( T x ) BOOST_NOEXCEPT
 {
     BOOST_STATIC_ASSERT( std::numeric_limits<T>::is_integer && !std::numeric_limits<T>::is_signed );
 
@@ -446,7 +655,7 @@ BOOST_CXX14_CONSTEXPR T rotl( T x, int s ) BOOST_NOEXCEPT
     BOOST_STATIC_ASSERT( std::numeric_limits<T>::is_integer && !std::numeric_limits<T>::is_signed );
 
     unsigned const mask = std::numeric_limits<T>::digits - 1;
-    return x << (s & mask) | x >> ((-s) & mask);
+    return static_cast<T>( x << (static_cast<unsigned>( s ) & mask) | x >> (static_cast<unsigned>( -s ) & mask) );
 }
 
 template<class T>
@@ -455,7 +664,7 @@ BOOST_CXX14_CONSTEXPR T rotr( T x, int s ) BOOST_NOEXCEPT
     BOOST_STATIC_ASSERT( std::numeric_limits<T>::is_integer && !std::numeric_limits<T>::is_signed );
 
     unsigned const mask = std::numeric_limits<T>::digits - 1;
-    return x >> (s & mask) | x << ((-s) & mask);
+    return static_cast<T>( x >> (static_cast<unsigned>( s ) & mask) | x << (static_cast<unsigned>( -s ) & mask) );
 }
 
 // integral powers of 2
@@ -484,7 +693,7 @@ BOOST_CONSTEXPR T bit_floor( T x ) BOOST_NOEXCEPT
 {
     BOOST_STATIC_ASSERT( std::numeric_limits<T>::is_integer && !std::numeric_limits<T>::is_signed );
 
-    return x == 0? 0: T(1) << ( boost::core::bit_width( x ) - 1 );
+    return x == 0? T(0): static_cast<T>( T(1) << ( boost::core::bit_width( x ) - 1 ) );
 }
 
 namespace detail
@@ -613,6 +822,128 @@ typedef endian::type endian_type;
 
 #undef BOOST_CORE_BIT_NATIVE_INITIALIZER
 
+// byteswap
+
+namespace detail
+{
+
+BOOST_CONSTEXPR inline boost::uint8_t byteswap_impl( boost::uint8_t x ) BOOST_NOEXCEPT
+{
+    return x;
+}
+
+#if defined(BOOST_CORE_HAS_BUILTIN_BSWAP16)
+
+BOOST_CONSTEXPR inline boost::uint16_t byteswap_impl( boost::uint16_t x ) BOOST_NOEXCEPT
+{
+    return __builtin_bswap16( x );
+}
+
+#else
+
+BOOST_CONSTEXPR inline boost::uint16_t byteswap_impl( boost::uint16_t x ) BOOST_NOEXCEPT
+{
+    return static_cast<boost::uint16_t>( x << 8 | x >> 8 );
+}
+
+#endif
+
+#if defined(__GNUC__) || defined(__clang__)
+
+BOOST_CXX14_CONSTEXPR inline boost::uint32_t byteswap_impl( boost::uint32_t x ) BOOST_NOEXCEPT
+{
+    return __builtin_bswap32( x );
+}
+
+BOOST_CXX14_CONSTEXPR inline boost::uint64_t byteswap_impl( boost::uint64_t x ) BOOST_NOEXCEPT
+{
+    return __builtin_bswap64( x );
+}
+
+#elif defined(_MSC_VER) && defined(BOOST_CORE_HAS_BUILTIN_ISCONSTEVAL)
+
+BOOST_CXX14_CONSTEXPR inline boost::uint32_t byteswap_impl( boost::uint32_t x ) BOOST_NOEXCEPT
+{
+    if( __builtin_is_constant_evaluated() )
+    {
+        boost::uint32_t step16 = x << 16 | x >> 16;
+        return ((step16 << 8) & 0xff00ff00) | ((step16 >> 8) & 0x00ff00ff);
+    }
+    else
+    {
+        return _byteswap_ulong( x );
+    }
+}
+
+BOOST_CXX14_CONSTEXPR inline boost::uint64_t byteswap_impl( boost::uint64_t x ) BOOST_NOEXCEPT
+{
+    if( __builtin_is_constant_evaluated() )
+    {
+        boost::uint64_t step32 = x << 32 | x >> 32;
+        boost::uint64_t step16 = (step32 & 0x0000FFFF0000FFFFULL) << 16 | (step32 & 0xFFFF0000FFFF0000ULL) >> 16;
+        return (step16 & 0x00FF00FF00FF00FFULL) << 8 | (step16 & 0xFF00FF00FF00FF00ULL) >> 8;
+    }
+    else
+    {
+        return _byteswap_uint64( x );
+    }
+}
+
+#elif defined(_MSC_VER)
+
+inline boost::uint32_t byteswap_impl( boost::uint32_t x ) BOOST_NOEXCEPT
+{
+    return _byteswap_ulong( x );
+}
+
+inline boost::uint64_t byteswap_impl( boost::uint64_t x ) BOOST_NOEXCEPT
+{
+    return _byteswap_uint64( x );
+}
+
+#else
+
+BOOST_CXX14_CONSTEXPR inline boost::uint32_t byteswap_impl( boost::uint32_t x ) BOOST_NOEXCEPT
+{
+    boost::uint32_t step16 = x << 16 | x >> 16;
+    return ((step16 << 8) & 0xff00ff00) | ((step16 >> 8) & 0x00ff00ff);
+}
+
+BOOST_CXX14_CONSTEXPR inline boost::uint64_t byteswap_impl( boost::uint64_t x ) BOOST_NOEXCEPT
+{
+    boost::uint64_t step32 = x << 32 | x >> 32;
+    boost::uint64_t step16 = (step32 & 0x0000FFFF0000FFFFULL) << 16 | (step32 & 0xFFFF0000FFFF0000ULL) >> 16;
+    return (step16 & 0x00FF00FF00FF00FFULL) << 8 | (step16 & 0xFF00FF00FF00FF00ULL) >> 8;
+}
+
+#endif
+
+} // namespace detail
+
+template<class T> BOOST_CXX14_CONSTEXPR T byteswap( T x ) BOOST_NOEXCEPT
+{
+    BOOST_STATIC_ASSERT( std::numeric_limits<T>::is_integer );
+
+    BOOST_STATIC_ASSERT( sizeof(T) == sizeof(boost::uint8_t) || sizeof(T) == sizeof(boost::uint16_t) || sizeof(T) == sizeof(boost::uint32_t) || sizeof(T) == sizeof(boost::uint64_t) );
+
+    BOOST_IF_CONSTEXPR ( sizeof(T) == sizeof(boost::uint8_t) )
+    {
+        return static_cast<T>( boost::core::detail::byteswap_impl( static_cast<boost::uint8_t>( x ) ) );
+    }
+    else BOOST_IF_CONSTEXPR ( sizeof(T) == sizeof(boost::uint16_t) )
+    {
+        return static_cast<T>( boost::core::detail::byteswap_impl( static_cast<boost::uint16_t>( x ) ) );
+    }
+    else BOOST_IF_CONSTEXPR ( sizeof(T) == sizeof(boost::uint32_t) )
+    {
+        return static_cast<T>( boost::core::detail::byteswap_impl( static_cast<boost::uint32_t>( x ) ) );
+    }
+    else
+    {
+        return static_cast<T>( boost::core::detail::byteswap_impl( static_cast<boost::uint64_t>( x ) ) );
+    }
+}
+
 } // namespace core
 } // namespace boost
 

include/boost/core/checked_delete.hpp

@@ -30,19 +30,40 @@ namespace boost
 
 template<class T> inline void checked_delete(T * x) BOOST_NOEXCEPT
 {
-    // intentionally complex - simplification causes regressions
-    typedef char type_must_be_complete[ sizeof(T)? 1: -1 ];
+#if defined(__cpp_static_assert) && __cpp_static_assert >= 200410L
+
+    static_assert( sizeof(T) != 0, "Type must be complete" );
+
+#else
+
+    typedef char type_must_be_complete[ sizeof(T) ];
     (void) sizeof(type_must_be_complete);
+
+#endif
+
     delete x;
 }
 
 template<class T> inline void checked_array_delete(T * x) BOOST_NOEXCEPT
 {
-    typedef char type_must_be_complete[ sizeof(T)? 1: -1 ];
+#if defined(__cpp_static_assert) && __cpp_static_assert >= 200410L
+
+    static_assert( sizeof(T) != 0, "Type must be complete" );
+
+#else
+
+    typedef char type_must_be_complete[ sizeof(T) ];
     (void) sizeof(type_must_be_complete);
+
+#endif
+
     delete [] x;
 }
 
+// Block unintended ADL
+namespace checked_deleters
+{
+
 template<class T> struct checked_deleter
 {
     typedef void result_type;
@@ -66,6 +87,11 @@ template<class T> struct checked_array_deleter
     }
 };
 
+} // namespace checked_deleters
+
+using checked_deleters::checked_deleter;
+using checked_deleters::checked_array_deleter;
+
 } // namespace boost
 
 #endif  // #ifndef BOOST_CORE_CHECKED_DELETE_HPP

include/boost/core/detail/minstd_rand.hpp

@@ -0,0 +1,58 @@
+#ifndef BOOST_CORE_DETAIL_MINSTD_RAND_HPP_INCLUDED
+#define BOOST_CORE_DETAIL_MINSTD_RAND_HPP_INCLUDED
+
+// Copyright 2017 Peter Dimov
+//
+// Distributed under the Boost Software License, Version 1.0.
+//
+// See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt
+//
+// An implementation of minstd_rand that does not require
+// the Random library
+
+#include <boost/cstdint.hpp>
+
+namespace boost
+{
+namespace detail
+{
+
+class minstd_rand
+{
+private:
+
+    boost::uint_least32_t x_;
+
+    enum { a = 48271, m = 2147483647 };
+
+public:
+
+    minstd_rand(): x_( 1 )
+    {
+    }
+
+    explicit minstd_rand( boost::uint_least32_t x ): x_( x % m )
+    {
+        if( x_ == 0 )
+        {
+            x_ = 1;
+        }
+    }
+
+    boost::uint_least32_t operator()()
+    {
+        boost::uint_least64_t y = x_;
+
+        y = ( a * y ) % m;
+
+        x_ = static_cast<boost::uint_least32_t>( y );
+
+        return x_;
+    }
+};
+
+} // namespace detail
+} // namespace boost
+
+#endif // #ifndef BOOST_CORE_DETAIL_MINSTD_RAND_HPP_INCLUDED

include/boost/core/detail/sp_thread_pause.hpp

@@ -0,0 +1,71 @@
+#ifndef BOOST_CORE_DETAIL_SP_THREAD_PAUSE_HPP_INCLUDED
+#define BOOST_CORE_DETAIL_SP_THREAD_PAUSE_HPP_INCLUDED
+
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+// boost/core/detail/sp_thread_pause.hpp
+//
+// inline void bost::core::sp_thread_pause();
+//
+//   Emits a "pause" instruction.
+//
+// Copyright 2008, 2020, 2023 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/config.hpp>
+
+#if defined(__has_builtin)
+# if __has_builtin(__builtin_ia32_pause) && !defined(__INTEL_COMPILER)
+#  define BOOST_CORE_HAS_BUILTIN_IA32_PAUSE
+# endif
+#endif
+
+#if defined(BOOST_CORE_HAS_BUILTIN_IA32_PAUSE)
+
+# define BOOST_CORE_SP_PAUSE() __builtin_ia32_pause()
+
+#elif defined(_MSC_VER) && ( defined(_M_IX86) || defined(_M_X64) )
+
+# include <intrin.h>
+# define BOOST_CORE_SP_PAUSE() _mm_pause()
+
+#elif defined(_MSC_VER) && ( defined(_M_ARM) || defined(_M_ARM64) )
+
+# include <intrin.h>
+# define BOOST_CORE_SP_PAUSE() __yield()
+
+#elif defined(__GNUC__) && ( defined(__i386__) || defined(__x86_64__) )
+
+# define BOOST_CORE_SP_PAUSE() __asm__ __volatile__( "rep; nop" : : : "memory" )
+
+#elif defined(__GNUC__) && ( (defined(__ARM_ARCH) && __ARM_ARCH >= 8) || defined(__ARM_ARCH_8A__) || defined(__aarch64__) )
+
+# define BOOST_CORE_SP_PAUSE() __asm__ __volatile__( "yield" : : : "memory" )
+
+#else
+
+# define BOOST_CORE_SP_PAUSE() ((void)0)
+
+#endif
+
+namespace boost
+{
+namespace core
+{
+
+BOOST_FORCEINLINE void sp_thread_pause() BOOST_NOEXCEPT
+{
+    BOOST_CORE_SP_PAUSE();
+}
+
+} // namespace core
+} // namespace boost
+
+#undef BOOST_CORE_SP_PAUSE
+
+#endif // #ifndef BOOST_CORE_DETAIL_SP_THREAD_PAUSE_HPP_INCLUDED

include/boost/core/detail/sp_thread_sleep.hpp

@@ -0,0 +1,122 @@
+#ifndef BOOST_CORE_DETAIL_SP_THREAD_SLEEP_HPP_INCLUDED
+#define BOOST_CORE_DETAIL_SP_THREAD_SLEEP_HPP_INCLUDED
+
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+// boost/core/detail/sp_thread_sleep.hpp
+//
+// inline void bost::core::sp_thread_sleep();
+//
+//   Cease execution for a while to yield to other threads,
+//   as if by calling nanosleep() with an appropriate interval.
+//
+// Copyright 2008, 2020, 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( _WIN32 ) || defined( __WIN32__ ) || defined( __CYGWIN__ )
+
+#if defined(BOOST_SP_REPORT_IMPLEMENTATION)
+  BOOST_PRAGMA_MESSAGE("Using Sleep(1) in sp_thread_sleep")
+#endif
+
+#include <boost/core/detail/sp_win32_sleep.hpp>
+
+namespace boost
+{
+namespace core
+{
+namespace detail
+{
+
+inline void sp_thread_sleep() BOOST_NOEXCEPT
+{
+    Sleep( 1 );
+}
+
+} // namespace detail
+
+using boost::core::detail::sp_thread_sleep;
+
+} // namespace core
+} // namespace boost
+
+#elif defined(BOOST_HAS_NANOSLEEP)
+
+#if defined(BOOST_SP_REPORT_IMPLEMENTATION)
+  BOOST_PRAGMA_MESSAGE("Using nanosleep() in sp_thread_sleep")
+#endif
+
+#include <time.h>
+
+#if defined(BOOST_HAS_PTHREADS) && !defined(__ANDROID__)
+# include <pthread.h>
+#endif
+
+namespace boost
+{
+namespace core
+{
+
+inline void sp_thread_sleep() BOOST_NOEXCEPT
+{
+#if defined(BOOST_HAS_PTHREADS) && !defined(__ANDROID__)
+
+    int oldst;
+    pthread_setcancelstate( PTHREAD_CANCEL_DISABLE, &oldst );
+
+#endif
+
+    // g++ -Wextra warns on {} or {0}
+    struct timespec rqtp = { 0, 0 };
+
+    // POSIX says that timespec has tv_sec and tv_nsec
+    // But it doesn't guarantee order or placement
+
+    rqtp.tv_sec = 0;
+    rqtp.tv_nsec = 1000;
+
+    nanosleep( &rqtp, 0 );
+
+#if defined(BOOST_HAS_PTHREADS) && !defined(__ANDROID__)
+
+    pthread_setcancelstate( oldst, &oldst );
+
+#endif
+
+}
+
+} // namespace core
+} // namespace boost
+
+#else
+
+#if defined(BOOST_SP_REPORT_IMPLEMENTATION)
+  BOOST_PRAGMA_MESSAGE("Using sp_thread_yield() in sp_thread_sleep")
+#endif
+
+#include <boost/core/detail/sp_thread_yield.hpp>
+
+namespace boost
+{
+namespace core
+{
+
+inline void sp_thread_sleep() BOOST_NOEXCEPT
+{
+    sp_thread_yield();
+}
+
+} // namespace core
+} // namespace boost
+
+#endif
+
+#endif // #ifndef BOOST_CORE_DETAIL_SP_THREAD_SLEEP_HPP_INCLUDED

include/boost/core/detail/sp_thread_yield.hpp

@@ -0,0 +1,100 @@
+#ifndef BOOST_CORE_DETAIL_SP_THREAD_YIELD_HPP_INCLUDED
+#define BOOST_CORE_DETAIL_SP_THREAD_YIELD_HPP_INCLUDED
+
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+// boost/core/detail/sp_thread_yield.hpp
+//
+// inline void bost::core::sp_thread_yield();
+//
+//   Gives up the remainder of the time slice,
+//   as if by calling sched_yield().
+//
+// Copyright 2008, 2020 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( _WIN32 ) || defined( __WIN32__ ) || defined( __CYGWIN__ )
+
+#if defined(BOOST_SP_REPORT_IMPLEMENTATION)
+  BOOST_PRAGMA_MESSAGE("Using SwitchToThread() in sp_thread_yield")
+#endif
+
+#include <boost/core/detail/sp_win32_sleep.hpp>
+
+namespace boost
+{
+namespace core
+{
+namespace detail
+{
+
+inline void sp_thread_yield() BOOST_NOEXCEPT
+{
+    SwitchToThread();
+}
+
+} // namespace detail
+
+using boost::core::detail::sp_thread_yield;
+
+} // namespace core
+} // namespace boost
+
+#elif defined(BOOST_HAS_SCHED_YIELD)
+
+#if defined(BOOST_SP_REPORT_IMPLEMENTATION)
+  BOOST_PRAGMA_MESSAGE("Using sched_yield() in sp_thread_yield")
+#endif
+
+#ifndef _AIX
+# include <sched.h>
+#else
+  // AIX's sched.h defines ::var which sometimes conflicts with Lambda's var
+  extern "C" int sched_yield(void);
+#endif
+
+namespace boost
+{
+namespace core
+{
+
+inline void sp_thread_yield() BOOST_NOEXCEPT
+{
+    sched_yield();
+}
+
+} // namespace core
+} // namespace boost
+
+#else
+
+#if defined(BOOST_SP_REPORT_IMPLEMENTATION)
+  BOOST_PRAGMA_MESSAGE("Using sp_thread_pause() in sp_thread_yield")
+#endif
+
+#include <boost/core/detail/sp_thread_pause.hpp>
+
+namespace boost
+{
+namespace core
+{
+
+inline void sp_thread_yield() BOOST_NOEXCEPT
+{
+    sp_thread_pause();
+}
+
+} // namespace core
+} // namespace boost
+
+#endif
+
+#endif // #ifndef BOOST_CORE_DETAIL_SP_THREAD_YIELD_HPP_INCLUDED

include/boost/core/detail/sp_win32_sleep.hpp

@@ -0,0 +1,54 @@
+#ifndef BOOST_CORE_DETAIL_SP_WIN32_SLEEP_HPP_INCLUDED
+#define BOOST_CORE_DETAIL_SP_WIN32_SLEEP_HPP_INCLUDED
+
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+// boost/core/detail/sp_win32_sleep.hpp
+//
+// Declares the Win32 Sleep() function.
+//
+// Copyright 2008, 2020 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0
+// https://www.boost.org/LICENSE_1_0.txt
+
+#if defined( BOOST_USE_WINDOWS_H )
+# include <windows.h>
+#endif
+
+namespace boost
+{
+namespace core
+{
+namespace detail
+{
+
+#if !defined( BOOST_USE_WINDOWS_H )
+
+#if defined(__clang__) && defined(__x86_64__)
+// clang x64 warns that __stdcall is ignored
+# define BOOST_CORE_SP_STDCALL
+#else
+# define BOOST_CORE_SP_STDCALL __stdcall
+#endif
+
+#if defined(__LP64__) // Cygwin 64
+  extern "C" __declspec(dllimport) void BOOST_CORE_SP_STDCALL Sleep( unsigned int ms );
+#else
+  extern "C" __declspec(dllimport) void BOOST_CORE_SP_STDCALL Sleep( unsigned long ms );
+#endif
+
+extern "C" __declspec(dllimport) int BOOST_CORE_SP_STDCALL SwitchToThread();
+
+#undef BOOST_CORE_SP_STDCALL
+
+#endif // !defined( BOOST_USE_WINDOWS_H )
+
+} // namespace detail
+} // namespace core
+} // namespace boost
+
+#endif // #ifndef BOOST_CORE_DETAIL_SP_WIN32_SLEEP_HPP_INCLUDED

include/boost/core/detail/string_view.hpp

@@ -74,7 +74,7 @@ template<class Ch> BOOST_CXX14_CONSTEXPR std::size_t find_first_of( Ch const* p_
 
     for( std::size_t j = 0; j < n; ++j )
     {
-        UCh ch = s[ j ];
+        UCh ch = static_cast<UCh>( s[ j ] );
 
         if( ch >= 0 && ch < 256 )
         {
@@ -91,7 +91,7 @@ template<class Ch> BOOST_CXX14_CONSTEXPR std::size_t find_first_of( Ch const* p_
     {
         for( std::size_t i = pos; i < n_; ++i )
         {
-            UCh ch = p_[ i ];
+            UCh ch = static_cast<UCh>( p_[ i ] );
             if( ch >= 0 && ch < 256 && table[ ch ] ) return i;
         }
     }
@@ -129,7 +129,7 @@ template<class Ch> BOOST_CXX14_CONSTEXPR std::size_t find_last_of( Ch const* p_,
 
     for( std::size_t j = 0; j < n; ++j )
     {
-        UCh ch = s[ j ];
+        UCh ch = static_cast<UCh>( s[ j ] );
 
         if( ch >= 0 && ch < 256 )
         {
@@ -150,7 +150,7 @@ template<class Ch> BOOST_CXX14_CONSTEXPR std::size_t find_last_of( Ch const* p_,
     {
         do
         {
-            UCh ch = p_[ i ];
+            UCh ch = static_cast<UCh>( p_[ i ] );
 
             if( ch >= 0 && ch < 256 && table[ ch ] ) return i;
 
@@ -199,7 +199,7 @@ template<class Ch> BOOST_CXX14_CONSTEXPR std::size_t find_first_not_of( Ch const
 
     for( std::size_t j = 0; j < n; ++j )
     {
-        UCh ch = s[ j ];
+        UCh ch = static_cast<UCh>( s[ j ] );
 
         if( ch >= 0 && ch < 256 )
         {
@@ -216,7 +216,7 @@ template<class Ch> BOOST_CXX14_CONSTEXPR std::size_t find_first_not_of( Ch const
     {
         for( std::size_t i = pos; i < n_; ++i )
         {
-            UCh ch = p_[ i ];
+            UCh ch = static_cast<UCh>( p_[ i ] );
             if( !( ch >= 0 && ch < 256 && table[ ch ] ) ) return i;
         }
     }
@@ -262,7 +262,7 @@ template<class Ch> BOOST_CXX14_CONSTEXPR std::size_t find_last_not_of( Ch const*
 
     for( std::size_t j = 0; j < n; ++j )
     {
-        UCh ch = s[ j ];
+        UCh ch = static_cast<UCh>( s[ j ] );
 
         if( ch >= 0 && ch < 256 )
         {
@@ -283,7 +283,7 @@ template<class Ch> BOOST_CXX14_CONSTEXPR std::size_t find_last_not_of( Ch const*
     {
         do
         {
-            UCh ch = p_[ i ];
+            UCh ch = static_cast<UCh>( p_[ i ] );
 
             if( !( ch >= 0 && ch < 256 && table[ ch ] ) ) return i;
 
@@ -381,7 +381,7 @@ public:
     }
 
     template<class End> BOOST_CXX14_CONSTEXPR basic_string_view( Ch const* first, End last,
-        typename boost::enable_if<boost::core::detail::is_same<End, Ch const*> >::type* = 0 ) BOOST_NOEXCEPT: p_( first ), n_( last - first )
+        typename boost::enable_if<boost::core::detail::is_same<End, Ch const*> >::type* = 0 ) BOOST_NOEXCEPT: p_( first ), n_( static_cast<size_type>( last - first ) )
     {
         BOOST_ASSERT( last - first >= 0 );
     }
@@ -392,7 +392,7 @@ public:
 
 #if !defined(BOOST_NO_CXX17_HDR_STRING_VIEW)
 
-    basic_string_view( std::basic_string_view<Ch, std::char_traits<Ch> > const& str ) BOOST_NOEXCEPT: p_( str.data() ), n_( str.size() )
+    BOOST_CONSTEXPR basic_string_view( std::basic_string_view<Ch, std::char_traits<Ch> > const& str ) BOOST_NOEXCEPT: p_( str.data() ), n_( str.size() )
     {
     }
 
@@ -681,7 +681,7 @@ public:
 
         Ch const* r = traits_type::find( data() + pos, size() - pos, c );
 
-        return r? r - data(): npos;
+        return r? static_cast<size_type>( r - data() ): npos;
     }
 
     BOOST_CXX14_CONSTEXPR size_type find( Ch const* s, size_type pos, size_type n ) const BOOST_NOEXCEPT
@@ -696,11 +696,11 @@ public:
 
         for( ;; )
         {
-            p = traits_type::find( p, last - p, s[0] );
+            p = traits_type::find( p, static_cast<size_type>( last - p ), s[0] );
 
             if( p == 0 ) break;
 
-            if( traits_type::compare( p + 1, s + 1, n - 1 ) == 0 ) return p - data();
+            if( traits_type::compare( p + 1, s + 1, n - 1 ) == 0 ) return static_cast<size_type>( p - data() );
 
             ++p;
         }
@@ -1193,7 +1193,7 @@ public:
 template<class Ch> std::basic_ostream<Ch>& operator<<( std::basic_ostream<Ch>& os, basic_string_view<Ch> str )
 {
     Ch const* p = str.data();
-    std::streamsize n = str.size();
+    std::streamsize n = static_cast<std::streamsize>( str.size() );
 
     std::streamsize m = os.width();
 

include/boost/core/fclose_deleter.hpp

@@ -26,6 +26,9 @@
 
 namespace boost {
 
+// Block unintended ADL
+namespace fclose_deleter_ns {
+
 //! A function object that closes a file
 struct fclose_deleter
 {
@@ -41,6 +44,10 @@ struct fclose_deleter
     }
 };
 
+} // namespace fclose_deleter_ns
+
+using fclose_deleter_ns::fclose_deleter;
+
 } // namespace boost
 
 #endif // BOOST_CORE_FCLOSE_DELETER_HPP

include/boost/core/functor.hpp

@@ -0,0 +1,41 @@
+/*
+ *             Copyright Andrey Semashev 2024.
+ * Distributed under the Boost Software License, Version 1.0.
+ *    (See accompanying file LICENSE_1_0.txt or copy at
+ *          http://www.boost.org/LICENSE_1_0.txt)
+ */
+/*!
+ * \file   functor.hpp
+ * \author Andrey Semashev
+ * \date   2024-01-23
+ *
+ * This header contains a \c functor implementation. This is a function object
+ * that invokes a function that is specified as its template parameter.
+ */
+
+#ifndef BOOST_CORE_FUNCTOR_HPP
+#define BOOST_CORE_FUNCTOR_HPP
+
+namespace boost::core {
+
+// Block unintended ADL
+namespace functor_ns {
+
+//! A function object that invokes a function specified as its template parameter
+template< auto Function >
+struct functor
+{
+    template< typename... Args >
+    auto operator() (Args&&... args) const noexcept(noexcept(Function(static_cast< Args&& >(args)...))) -> decltype(Function(static_cast< Args&& >(args)...))
+    {
+        return Function(static_cast< Args&& >(args)...);
+    }
+};
+
+} // namespace functor_ns
+
+using functor_ns::functor;
+
+} // namespace boost::core
+
+#endif // BOOST_CORE_FUNCTOR_HPP

include/boost/core/invoke_swap.hpp

@@ -0,0 +1,93 @@
+// Copyright (C) 2007, 2008 Steven Watanabe, Joseph Gauterin, Niels Dekker
+// Copyright (C) 2023 Andrey Semashev
+//
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+// For more information, see http://www.boost.org
+
+#ifndef BOOST_CORE_INVOKE_SWAP_HPP
+#define BOOST_CORE_INVOKE_SWAP_HPP
+
+// Note: the implementation of this utility contains various workarounds:
+// - invoke_swap_impl is put outside the boost namespace, to avoid infinite
+// recursion (causing stack overflow) when swapping objects of a primitive
+// type.
+// - std::swap is imported with a using-directive, rather than
+// a using-declaration, because some compilers (including MSVC 7.1,
+// Borland 5.9.3, and Intel 8.1) don't do argument-dependent lookup
+// when it has a using-declaration instead.
+// - The main entry function is called invoke_swap rather than swap
+// to avoid forming an infinite recursion when the arguments are not
+// swappable.
+
+#include <boost/core/enable_if.hpp>
+#include <boost/config.hpp>
+#if __cplusplus >= 201103L || defined(BOOST_DINKUMWARE_STDLIB)
+#include <utility> // for std::swap (C++11)
+#else
+#include <algorithm> // for std::swap (C++98)
+#endif
+#include <cstddef> // for std::size_t
+
+#ifdef BOOST_HAS_PRAGMA_ONCE
+#pragma once
+#endif
+
+#if defined(BOOST_GCC) && (BOOST_GCC < 40700)
+// gcc 4.6 ICEs on noexcept specifications below
+#define BOOST_CORE_SWAP_NOEXCEPT_IF(x)
+#else
+#define BOOST_CORE_SWAP_NOEXCEPT_IF(x) BOOST_NOEXCEPT_IF(x)
+#endif
+
+namespace boost_swap_impl {
+
+// we can't use type_traits here
+
+template<class T> struct is_const { enum _vt { value = 0 }; };
+template<class T> struct is_const<T const> { enum _vt { value = 1 }; };
+
+// Use std::swap if argument dependent lookup fails.
+// We need to have this at namespace scope to be able to use unqualified swap() call
+// in noexcept specification.
+using namespace std;
+
+template<class T>
+BOOST_GPU_ENABLED
+inline void invoke_swap_impl(T& left, T& right) BOOST_CORE_SWAP_NOEXCEPT_IF(BOOST_NOEXCEPT_EXPR(swap(left, right)))
+{
+    swap(left, right);
+}
+
+template<class T, std::size_t N>
+BOOST_GPU_ENABLED
+inline void invoke_swap_impl(T (& left)[N], T (& right)[N])
+    BOOST_CORE_SWAP_NOEXCEPT_IF(BOOST_NOEXCEPT_EXPR(::boost_swap_impl::invoke_swap_impl(left[0], right[0])))
+{
+    for (std::size_t i = 0; i < N; ++i)
+    {
+        ::boost_swap_impl::invoke_swap_impl(left[i], right[i]);
+    }
+}
+
+} // namespace boost_swap_impl
+
+namespace boost {
+namespace core {
+
+template<class T>
+BOOST_GPU_ENABLED
+inline typename enable_if_c< !::boost_swap_impl::is_const<T>::value >::type
+invoke_swap(T& left, T& right)
+    BOOST_CORE_SWAP_NOEXCEPT_IF(BOOST_NOEXCEPT_EXPR(::boost_swap_impl::invoke_swap_impl(left, right)))
+{
+    ::boost_swap_impl::invoke_swap_impl(left, right);
+}
+
+} // namespace core
+} // namespace boost
+
+#undef BOOST_CORE_SWAP_NOEXCEPT_IF
+
+#endif // BOOST_CORE_INVOKE_SWAP_HPP

include/boost/core/launder.hpp

@@ -11,14 +11,28 @@
 //  Distributed under the Boost Software License, Version 1.0.
 //  https://www.boost.org/LICENSE_1_0.txt
 
+#include <boost/config.hpp>
+
 #if defined(__has_builtin)
 # if __has_builtin(__builtin_launder)
 #  define BOOST_CORE_HAS_BUILTIN_LAUNDER
 # endif
 #endif
 
-#if (__cplusplus >= 201703L || (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L)) && !defined(BOOST_CORE_HAS_BUILTIN_LAUNDER)
-# include <new>
+#if defined(BOOST_MSVC) && BOOST_MSVC < 1920
+
+// msvc-14.1 suffers from internal compiler errors when using std::launder
+// https://github.com/boostorg/core/issues/160
+// https://github.com/boostorg/optional/issues/122
+
+#elif (BOOST_CXX_VERSION >= 201703L) && !defined(BOOST_CORE_HAS_BUILTIN_LAUNDER)
+
+#include <new>
+
+#if defined(__cpp_lib_launder)
+# define BOOST_CORE_HAS_STD_LAUNDER
+#endif
+
 #endif
 
 namespace boost
@@ -33,7 +47,7 @@ template<class T> T* launder( T* p )
     return __builtin_launder( p );
 }
 
-#elif (__cplusplus >= 201703L || (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L)) && defined(__cpp_lib_launder)
+#elif defined(BOOST_CORE_HAS_STD_LAUNDER)
 
 template<class T> T* launder( T* p )
 {

include/boost/core/lightweight_test.hpp

@@ -153,6 +153,7 @@ inline void no_throw_failed_impl(const char* expr, const char* what, const char*
 #elif defined(__GNUC__) && !(defined(__INTEL_COMPILER) || defined(__ICL) || defined(__ICC) || defined(__ECC)) && (__GNUC__ * 100 + __GNUC_MINOR__) >= 406
 # pragma GCC diagnostic push
 # pragma GCC diagnostic ignored "-Wsign-compare"
+# pragma GCC diagnostic ignored "-Wsign-conversion"
 #endif
 
 // specialize test output for char pointers to avoid printing as cstring

include/boost/core/null_deleter.hpp

@@ -27,6 +27,9 @@
 
 namespace boost {
 
+// Block unintended ADL
+namespace null_deleter_ns {
+
 //! A function object that does nothing and can be used as an empty deleter for \c shared_ptr
 struct null_deleter
 {
@@ -39,6 +42,10 @@ struct null_deleter
     void operator() (T*) const BOOST_NOEXCEPT {}
 };
 
+} // namespace null_deleter_ns
+
+using null_deleter_ns::null_deleter;
+
 } // namespace boost
 
 #endif // BOOST_CORE_NULL_DELETER_HPP

include/boost/core/pointer_in_range.hpp

@@ -0,0 +1,49 @@
+/*
+Copyright 2024 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+*/
+#ifndef BOOST_CORE_POINTER_IN_RANGE_HPP
+#define BOOST_CORE_POINTER_IN_RANGE_HPP
+
+#include <boost/config.hpp>
+#include <functional>
+
+#if !defined(BOOST_NO_CXX14_CONSTEXPR)
+#if defined(BOOST_MSVC) && BOOST_MSVC >= 1925
+#define BOOST_CORE_DETAIL_HAS_IS_CONSTEVAL
+#elif defined(__has_builtin)
+#if __has_builtin(__builtin_is_constant_evaluated)
+#define BOOST_CORE_DETAIL_HAS_IS_CONSTEVAL
+#endif
+#endif
+#endif
+
+#if !defined(BOOST_CORE_DETAIL_HAS_IS_CONSTEVAL)
+#define BOOST_CORE_NO_CONSTEXPR_POINTER_IN_RANGE
+#endif
+
+namespace boost {
+
+template<class T>
+inline BOOST_CONSTEXPR bool
+pointer_in_range(const T* p, const T* b, const T* e)
+{
+#if defined(BOOST_CORE_DETAIL_HAS_IS_CONSTEVAL)
+    if ( __builtin_is_constant_evaluated()) {
+        for (; b != e; ++b) {
+            if (b == p) {
+                return true;
+            }
+        }
+        return false;
+    }
+#endif
+    return std::less_equal<const T*>()(b, p) && std::less<const T*>()(p, e);
+}
+
+} /* boost */
+
+#endif

include/boost/core/span.hpp

@@ -351,8 +351,10 @@ private:
     detail::span_store<T, E> s_;
 };
 
+#if defined(BOOST_NO_CXX17_INLINE_VARIABLES)
 template<class T, std::size_t E>
 constexpr std::size_t span<T, E>::extent;
+#endif
 
 #ifdef __cpp_deduction_guides
 template<class I, class L>

include/boost/core/swap.hpp

@@ -10,80 +10,31 @@
 #define BOOST_CORE_SWAP_HPP
 
 // Note: the implementation of this utility contains various workarounds:
-// - swap_impl is put outside the boost namespace, to avoid infinite
-// recursion (causing stack overflow) when swapping objects of a primitive
-// type.
-// - std::swap is imported with a using-directive, rather than
-// a using-declaration, because some compilers (including MSVC 7.1,
-// Borland 5.9.3, and Intel 8.1) don't do argument-dependent lookup
-// when it has a using-declaration instead.
 // - boost::swap has two template arguments, instead of one, to
 // avoid ambiguity when swapping objects of a Boost type that does
 // not have its own boost::swap overload.
 
 #include <boost/core/enable_if.hpp>
 #include <boost/config.hpp>
-#if __cplusplus >= 201103L || defined(BOOST_DINKUMWARE_STDLIB)
-#include <utility> // for std::swap (C++11)
-#else
-#include <algorithm> // for std::swap (C++98)
-#endif
-#include <cstddef> // for std::size_t
+#include <boost/config/header_deprecated.hpp>
+#include <boost/core/invoke_swap.hpp>
 
 #ifdef BOOST_HAS_PRAGMA_ONCE
 #pragma once
 #endif
 
-#if defined(BOOST_GCC) && (BOOST_GCC < 40700)
-// gcc 4.6 ICEs on noexcept specifications below
-#define BOOST_CORE_SWAP_NOEXCEPT_IF(x)
-#else
-#define BOOST_CORE_SWAP_NOEXCEPT_IF(x) BOOST_NOEXCEPT_IF(x)
-#endif
-
-namespace boost_swap_impl
-{
-  // we can't use type_traits here
-
-  template<class T> struct is_const { enum _vt { value = 0 }; };
-  template<class T> struct is_const<T const> { enum _vt { value = 1 }; };
-
-  // Use std::swap if argument dependent lookup fails.
-  // We need to have this at namespace scope to be able to use unqualified swap() call
-  // in noexcept specification.
-  using namespace std;
-
-  template<class T>
-  BOOST_GPU_ENABLED
-  void swap_impl(T& left, T& right) BOOST_CORE_SWAP_NOEXCEPT_IF(BOOST_NOEXCEPT_EXPR(swap(left, right)))
-  {
-    swap(left, right);
-  }
-
-  template<class T, std::size_t N>
-  BOOST_GPU_ENABLED
-  void swap_impl(T (& left)[N], T (& right)[N])
-    BOOST_CORE_SWAP_NOEXCEPT_IF(BOOST_NOEXCEPT_EXPR(::boost_swap_impl::swap_impl(left[0], right[0])))
-  {
-    for (std::size_t i = 0; i < N; ++i)
-    {
-      ::boost_swap_impl::swap_impl(left[i], right[i]);
-    }
-  }
-}
+BOOST_HEADER_DEPRECATED("boost/core/invoke_swap.hpp")
 
 namespace boost
 {
   template<class T1, class T2>
   BOOST_GPU_ENABLED
-  typename enable_if_c< !boost_swap_impl::is_const<T1>::value && !boost_swap_impl::is_const<T2>::value >::type
+  BOOST_DEPRECATED("This function is deprecated, use boost::core::invoke_swap instead.")
+  inline typename enable_if_c< !boost_swap_impl::is_const<T1>::value && !boost_swap_impl::is_const<T2>::value >::type
   swap(T1& left, T2& right)
-    BOOST_CORE_SWAP_NOEXCEPT_IF(BOOST_NOEXCEPT_EXPR(::boost_swap_impl::swap_impl(left, right)))
   {
-    ::boost_swap_impl::swap_impl(left, right);
+    boost::core::invoke_swap(left, right);
   }
 }
 
-#undef BOOST_CORE_SWAP_NOEXCEPT_IF
-
 #endif // BOOST_CORE_SWAP_HPP

include/boost/core/type_name.hpp

@@ -102,11 +102,24 @@ inline std::string fix_typeid_name( char const* n )
     return r;
 }
 
-template<class T> std::string typeid_name()
+// class types can be incomplete
+// but also abstract (T[1] doesn't form)
+template<class T> std::string typeid_name_impl( int T::*, T(*)[1] )
+{
+    std::string r = fix_typeid_name( typeid(T[1]).name() );
+    return r.substr( 0, r.size() - 4 ); // remove ' [1]' suffix
+}
+
+template<class T> std::string typeid_name_impl( ... )
 {
     return fix_typeid_name( typeid(T).name() );
 }
 
+template<class T> std::string typeid_name()
+{
+    return typeid_name_impl<T>( 0, 0 );
+}
+
 // template names
 
 template<class T> std::string class_template_name()
@@ -333,6 +346,8 @@ template<> struct tn_holder<boost::uint128_type>
 
 #endif
 
+#if !defined(BOOST_NO_INTRINSIC_WCHAR_T)
+
 template<> struct tn_holder<wchar_t>
 {
     static std::string type_name( std::string const& suffix )
@@ -341,6 +356,8 @@ template<> struct tn_holder<wchar_t>
     }
 };
 
+#endif
+
 #if !defined(BOOST_NO_CXX11_CHAR16_T)
 
 template<> struct tn_holder<char16_t>
@@ -862,6 +879,8 @@ template<class T, std::size_t N> struct tn_holder<T const volatile[N]>
 
 // pointers to members
 
+#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+
 template<class R, class T> struct tn_holder<R T::*>
 {
     static std::string type_name( std::string const& suffix )
@@ -870,7 +889,7 @@ template<class R, class T> struct tn_holder<R T::*>
     }
 };
 
-#if defined(BOOST_MSVC) && BOOST_MSVC < 1900 && !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+#if defined(BOOST_MSVC) && BOOST_MSVC < 1900
 
 template<class R, class T, class... A> struct tn_holder<R(T::*)(A...)>
 {
@@ -904,7 +923,9 @@ template<class R, class T, class... A> struct tn_holder<R(T::*)(A...) const vola
     }
 };
 
-#endif
+#endif // #if defined(BOOST_MSVC) && BOOST_MSVC < 1900
+
+#endif // #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
 
 // strings
 

include/boost/core/yield_primitives.hpp

@@ -0,0 +1,12 @@
+#ifndef BOOST_CORE_YIELD_PRIMITIVES_HPP_INCLUDED
+#define BOOST_CORE_YIELD_PRIMITIVES_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/core/detail/sp_thread_pause.hpp>
+#include <boost/core/detail/sp_thread_yield.hpp>
+#include <boost/core/detail/sp_thread_sleep.hpp>
+
+#endif  // #ifndef BOOST_CORE_YIELD_PRIMITIVES_HPP_INCLUDED

include/boost/swap.hpp

@@ -10,8 +10,11 @@
 #define BOOST_SWAP_HPP
 
 // The header file at this path is deprecated;
-// use boost/core/swap.hpp instead.
+// use boost/core/invoke_swap.hpp instead.
 
+#include <boost/config/header_deprecated.hpp>
 #include <boost/core/swap.hpp>
 
+BOOST_HEADER_DEPRECATED("boost/core/invoke_swap.hpp")
+
 #endif

include/boost/utility/swap.hpp

@@ -10,8 +10,11 @@
 #define BOOST_UTILITY_SWAP_HPP
 
 // The header file at this path is deprecated;
-// use boost/core/swap.hpp instead.
+// use boost/core/invoke_swap.hpp instead.
 
+#include <boost/config/header_deprecated.hpp>
 #include <boost/core/swap.hpp>
 
+BOOST_HEADER_DEPRECATED("boost/core/invoke_swap.hpp")
+
 #endif

test/CMakeLists.txt

@@ -38,6 +38,13 @@ boost_test(TYPE run SOURCES serialization_split_free_test.cpp)
 boost_test(TYPE run SOURCES serialization_split_member_test.cpp)
 boost_test(TYPE run SOURCES serialization_construct_data_test.cpp)
 
+set(THREADS_PREFER_PTHREAD_FLAG ON)
+find_package(Threads REQUIRED)
+
+set(BOOST_TEST_LINK_LIBRARIES Boost::core Threads::Threads)
+
+boost_test(TYPE run SOURCES yield_prim_pthread_cancel_test.cpp)
+
 endif()
 
 add_subdirectory(swap)

test/Jamfile.v2

@@ -17,11 +17,20 @@ project : requirements
   <toolset>gcc:<warnings-as-errors>on
   <toolset>gcc-4.4:<cxxflags>-Wno-sign-compare ;
 
-local warning-as-errors-off =
+local warnings-as-errors-off =
     "-<toolset>msvc:<warnings-as-errors>on"
     "-<toolset>gcc:<warnings-as-errors>on"
     "-<toolset>clang:<warnings-as-errors>on" ;
 
+local pedantic-errors = <warnings>pedantic
+    <toolset>gcc:<cxxflags>"-Wconversion"
+    <toolset>gcc:<cxxflags>"-Wsign-conversion"
+    <toolset>clang:<cxxflags>"-Wconversion"
+    <toolset>clang:<cxxflags>"-Wsign-conversion"
+    <toolset>msvc:<warnings-as-errors>on
+    <toolset>gcc:<warnings-as-errors>on
+    <toolset>clang:<warnings-as-errors>on ;
+
 # quick test (for CI)
 run quick.cpp ;
 
@@ -32,36 +41,41 @@ run addressof_np_test.cpp ;
 run addressof_fn_test.cpp ;
 compile addressof_constexpr_test.cpp ;
 compile-fail addressof_fail_rvalue.cpp
-  : $(warning-as-errors-off) ;
+  : $(warnings-as-errors-off) ;
 
-run checked_delete_test.cpp ;
+run checked_delete_test.cpp
+  : : : $(pedantic-errors) ;
 compile-fail checked_delete_fail.cpp
-  : $(warning-as-errors-off) ;
+  : $(warnings-as-errors-off) ;
 compile-fail checked_delete_fail2.cpp
-  : $(warning-as-errors-off) ;
+  : $(warnings-as-errors-off) ;
+compile-fail checked_deleter_compile_fail_adl.cpp
+  : $(warnings-as-errors-off) ;
+compile-fail checked_array_deleter_compile_fail_adl.cpp
+  : $(warnings-as-errors-off) ;
 
 compile ref_ct_test.cpp ;
 run ref_test.cpp ;
 run ref_ref_test.cpp ;
 run ref_fn_test.cpp ;
 compile-fail ref_rv_fail1.cpp
-  : $(warning-as-errors-off) ;
+  : $(warnings-as-errors-off) ;
 compile-fail ref_rv_fail2.cpp
-  : $(warning-as-errors-off) ;
+  : $(warnings-as-errors-off) ;
 compile-fail ref_rv_fail3.cpp
-  : $(warning-as-errors-off) ;
+  : $(warnings-as-errors-off) ;
 compile-fail ref_rv_fail4.cpp
-  : $(warning-as-errors-off) ;
+  : $(warnings-as-errors-off) ;
 compile-fail ref_rv_fail5.cpp
-  : $(warning-as-errors-off) ;
+  : $(warnings-as-errors-off) ;
 compile-fail ref_implicit_fail.cpp
-  : $(warning-as-errors-off) ;
+  : $(warnings-as-errors-off) ;
 compile-fail ref_implicit_fail2.cpp
-  : $(warning-as-errors-off) ;
+  : $(warnings-as-errors-off) ;
 compile-fail ref_implicit_fail3.cpp
-  : $(warning-as-errors-off) ;
+  : $(warnings-as-errors-off) ;
 compile-fail ref_implicit_fail4.cpp
-  : $(warning-as-errors-off) ;
+  : $(warnings-as-errors-off) ;
 run ref_cv_test.cpp ;
 run ref_conversion_test.cpp ;
 
@@ -75,18 +89,18 @@ run eif_no_disambiguation.cpp : ;
 run eif_partial_specializations.cpp : ;
 
 compile-fail noncopyable_compile_fail.cpp
-  : $(warning-as-errors-off) ;
+  : $(warnings-as-errors-off) ;
 
 run explicit_operator_bool.cpp ;
 run explicit_operator_bool_noexcept.cpp ;
 compile-fail explicit_operator_bool_compile_fail_conv_int.cpp
-  : $(warning-as-errors-off) ;
+  : $(warnings-as-errors-off) ;
 compile-fail explicit_operator_bool_compile_fail_conv_pvoid.cpp
-  : $(warning-as-errors-off) ;
+  : $(warnings-as-errors-off) ;
 compile-fail explicit_operator_bool_compile_fail_delete.cpp
-  : $(warning-as-errors-off) ;
+  : $(warnings-as-errors-off) ;
 compile-fail explicit_operator_bool_compile_fail_shift.cpp
-  : $(warning-as-errors-off) ;
+  : $(warnings-as-errors-off) ;
 
 compile ignore_unused_test.cpp ;
 
@@ -97,11 +111,6 @@ run visit_each_test.cpp ;
 
 run get_pointer_test.cpp ;
 
-local pedantic-errors = <warnings>pedantic
-    <toolset>msvc:<warnings-as-errors>on
-    <toolset>gcc:<warnings-as-errors>on
-    <toolset>clang:<warnings-as-errors>on ;
-
 run lightweight_test_test.cpp
   : : : $(pedantic-errors) ;
 run lightweight_test_test.cpp : : :
@@ -179,13 +188,23 @@ run demangled_name_test.cpp : : : <rtti>off <test-info>always_show_run_output :
 
 run scoped_enum.cpp ;
 compile-fail scoped_enum_compile_fail_conv_from_int.cpp
-  : $(warning-as-errors-off) ;
+  : $(warnings-as-errors-off) ;
 compile-fail scoped_enum_compile_fail_conv_to_int.cpp
-  : $(warning-as-errors-off) ;
+  : $(warnings-as-errors-off) ;
 
 run underlying_type.cpp ;
 
+compile-fail null_deleter_compile_fail_adl.cpp
+  : $(warnings-as-errors-off) ;
+
 run fclose_deleter_test.cpp : : : <target-os>windows:<define>_CRT_SECURE_NO_WARNINGS <target-os>windows:<define>_CRT_SECURE_NO_DEPRECATE ;
+compile-fail fclose_deleter_compile_fail_adl.cpp
+  : <target-os>windows:<define>_CRT_SECURE_NO_WARNINGS <target-os>windows:<define>_CRT_SECURE_NO_DEPRECATE $(warnings-as-errors-off) ;
+
+run functor_test.cpp ;
+compile-fail functor_compile_fail_adl.cpp
+  : $(warnings-as-errors-off) ;
+
 
 run pointer_traits_pointer_test.cpp ;
 run pointer_traits_element_type_test.cpp ;
@@ -249,6 +268,7 @@ run allocator_destroy_test.cpp ;
 run allocator_construct_n_test.cpp ;
 run allocator_destroy_n_test.cpp ;
 run allocator_traits_test.cpp ;
+compile allocator_pmr_test.cpp ;
 
 lib lib_typeid : lib_typeid.cpp : <link>shared:<define>LIB_TYPEID_DYN_LINK=1 ;
 
@@ -296,45 +316,79 @@ run bit_popcount_test.cpp
   : : : $(pedantic-errors) ;
 run bit_endian_test.cpp
   : : : $(pedantic-errors) ;
+run bit_byteswap_test.cpp
+  : : : $(pedantic-errors) ;
 
 compile-fail bit_width_fail.cpp
   : <warnings>off ;
 
+compile bit_cast_test_cx.cpp ;
+compile bit_rotate_test_cx.cpp ;
+compile bit_countr_test_cx.cpp ;
+compile bit_countl_test_cx.cpp ;
+compile bit_width_test_cx.cpp ;
+compile has_single_bit_test_cx.cpp ;
+compile bit_floor_test_cx.cpp ;
+compile bit_ceil_test_cx.cpp ;
+compile bit_popcount_test_cx.cpp ;
+compile bit_byteswap_test_cx.cpp ;
+
 run type_name_test.cpp ;
 
 run snprintf_test.cpp ;
 
-run sv_types_test.cpp ;
-run sv_construct_test.cpp ;
-run sv_iteration_test.cpp ;
-run sv_element_access_test.cpp ;
-run sv_modifiers_test.cpp ;
-run sv_copy_test.cpp ;
-run sv_substr_test.cpp ;
-run sv_compare_test.cpp ;
-run sv_starts_with_test.cpp ;
-run sv_ends_with_test.cpp ;
-run sv_find_test.cpp ;
-run sv_rfind_test.cpp ;
+run sv_types_test.cpp
+  : : : $(pedantic-errors) ;
+run sv_construct_test.cpp
+  : : : $(pedantic-errors) ;
+run sv_iteration_test.cpp
+  : : : $(pedantic-errors) ;
+run sv_element_access_test.cpp
+  : : : $(pedantic-errors) ;
+run sv_modifiers_test.cpp
+  : : : $(pedantic-errors) ;
+run sv_copy_test.cpp
+  : : : $(pedantic-errors) ;
+run sv_substr_test.cpp
+  : : : $(pedantic-errors) ;
+run sv_compare_test.cpp
+  : : : $(pedantic-errors) ;
+run sv_starts_with_test.cpp
+  : : : $(pedantic-errors) ;
+run sv_ends_with_test.cpp
+  : : : $(pedantic-errors) ;
+run sv_find_test.cpp
+  : : : $(pedantic-errors) ;
+run sv_rfind_test.cpp
+  : : : $(pedantic-errors) ;
 run sv_find_first_of_test.cpp
-  : : : <toolset>gcc-4.4:<cxxflags>-Wno-type-limits ;
+  : : : $(pedantic-errors) <toolset>gcc-4.4:<cxxflags>-Wno-type-limits ;
 run sv_find_last_of_test.cpp
-  : : : <toolset>gcc-4.4:<cxxflags>-Wno-type-limits ;
+  : : : $(pedantic-errors) <toolset>gcc-4.4:<cxxflags>-Wno-type-limits ;
 run sv_find_first_not_of_test.cpp
-  : : : <toolset>gcc-4.4:<cxxflags>-Wno-type-limits ;
+  : : : $(pedantic-errors) <toolset>gcc-4.4:<cxxflags>-Wno-type-limits ;
 run sv_find_last_not_of_test.cpp
-  : : : <toolset>gcc-4.4:<cxxflags>-Wno-type-limits ;
-run sv_contains_test.cpp ;
-run sv_eq_test.cpp ;
-run sv_lt_test.cpp ;
-run sv_stream_insert_test.cpp ;
-run sv_conversion_test.cpp ;
+  : : : $(pedantic-errors) <toolset>gcc-4.4:<cxxflags>-Wno-type-limits ;
+run sv_contains_test.cpp
+  : : : $(pedantic-errors) ;
+run sv_eq_test.cpp
+  : : : $(pedantic-errors) ;
+run sv_lt_test.cpp
+  : : : $(pedantic-errors) ;
+run sv_stream_insert_test.cpp
+  : : : $(pedantic-errors) ;
+run sv_conversion_test.cpp
+  : : : $(pedantic-errors) ;
 run sv_conversion_test2.cpp : ;
-run sv_common_reference_test.cpp ;
+run sv_common_reference_test.cpp
+  : : : $(pedantic-errors) ;
 compile sv_common_reference_test2.cpp ;
 compile sv_windows_h_test.cpp ;
 compile-fail sv_nullptr_fail.cpp
-  : $(warning-as-errors-off) ;
+  : $(warnings-as-errors-off) ;
+
+compile sv_construct_test_cx.cpp ;
+compile sv_construct_test_cx2.cpp ;
 
 run span_test.cpp ;
 run span_types_test.cpp ;
@@ -363,13 +417,31 @@ run memory_resource_test.cpp ;
 run data_test.cpp ;
 run size_test.cpp ;
 
-run serialization_nvp_test.cpp : : : <library>/boost//serialization/<warnings>off <undefined-sanitizer>norecover:<build>no ;
-run serialization_split_free_test.cpp : : : <library>/boost//serialization/<warnings>off <undefined-sanitizer>norecover:<link>static ;
-run serialization_split_member_test.cpp : : : <library>/boost//serialization/<warnings>off <undefined-sanitizer>norecover:<link>static ;
-run serialization_construct_data_test.cpp : : : <library>/boost//serialization/<warnings>off <undefined-sanitizer>norecover:<link>static ;
+import ../../config/checks/config : requires ;
+
+local CPP11 = [ requires cxx11_variadic_templates cxx11_template_aliases cxx11_decltype cxx11_constexpr cxx11_noexcept ] ;
+
+local with-serialization = <library>/boost//serialization/<warnings>off $(warnings-as-errors-off) <undefined-sanitizer>norecover:<link>static $(CPP11) ;
+
+run serialization_nvp_test.cpp : : : $(with-serialization) <undefined-sanitizer>norecover:<build>no ;
+run serialization_split_free_test.cpp : : : $(with-serialization) ;
+run serialization_split_member_test.cpp : : : $(with-serialization) ;
+run serialization_construct_data_test.cpp : : : $(with-serialization) ;
 
 run identity_test.cpp ;
 run identity_rvalue_test.cpp ;
 
+run sp_thread_pause_test.cpp ;
+run sp_thread_yield_test.cpp ;
+run sp_thread_sleep_test.cpp ;
+run yield_prim_windows_h_test.cpp ;
+run yield_prim_pthread_cancel_test.cpp : ;
+
+run pointer_in_range_test.cpp ;
+compile pointer_in_range_constexpr_test.cpp ;
+
+run minstd_rand_test.cpp
+  : : : $(pedantic-errors) ;
+
 use-project /boost/core/swap : ./swap ;
 build-project ./swap ;

test/allocator_pmr_test.cpp

@@ -0,0 +1,22 @@
+//
+// Testing stdlib polymorphic allocators
+//
+// Copyright 2024 Braden Ganetsky
+//
+// 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/core/allocator_access.hpp>
+#include <boost/config.hpp>
+
+#ifndef BOOST_NO_CXX17_HDR_MEMORY_RESOURCE
+#include <memory_resource>
+
+void pmr_allocator_destroy_compiles(std::pmr::polymorphic_allocator<int>& alloc, int* p)
+{
+    boost::allocator_destroy(alloc, p);
+}
+
+#endif // !defined(BOOST_NO_CXX17_HDR_MEMORY_RESOURCE)

test/bit_byteswap_test.cpp

@@ -0,0 +1,26 @@
+// Test for boost/core/bit.hpp (byteswap)
+//
+// Copyright 2023 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/core/bit.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <boost/cstdint.hpp>
+
+int main()
+{
+    BOOST_TEST_EQ( boost::core::byteswap( (boost::int8_t)0x01 ), 0x01 );
+    BOOST_TEST_EQ( boost::core::byteswap( (boost::uint8_t)0xF1 ), 0xF1 );
+
+    BOOST_TEST_EQ( boost::core::byteswap( (boost::int16_t)0x0102 ), 0x0201 );
+    BOOST_TEST_EQ( boost::core::byteswap( (boost::uint16_t)0xF1E2 ), 0xE2F1 );
+
+    BOOST_TEST_EQ( boost::core::byteswap( (boost::int32_t)0x01020304 ), 0x04030201 );
+    BOOST_TEST_EQ( boost::core::byteswap( (boost::uint32_t)0xF1E2D3C4u ), 0xC4D3E2F1u );
+
+    BOOST_TEST_EQ( boost::core::byteswap( (boost::int64_t)0x01020304 << 32 | 0x05060708 ), (boost::int64_t)0x08070605 << 32 | 0x04030201 );
+    BOOST_TEST_EQ( boost::core::byteswap( (boost::uint64_t)0xF1E2D3C4u << 32 | 0xB5A69788u ), (boost::uint64_t)0x8897A6B5u << 32 | 0xC4D3E2F1u );
+
+    return boost::report_errors();
+}

test/bit_byteswap_test_cx.cpp

@@ -0,0 +1,37 @@
+// constexpr test for boost/core/bit.hpp (bit_width)
+//
+// 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_CXX14_CONSTEXPR)
+
+BOOST_PRAGMA_MESSAGE( "Test skipped because BOOST_NO_CXX14_CONSTEXPR is defined" )
+
+#elif defined(BOOST_MSVC) && BOOST_MSVC / 10 == 191
+
+BOOST_PRAGMA_MESSAGE( "Test skipped because BOOST_MSVC is " BOOST_STRINGIZE(BOOST_MSVC) )
+
+#else
+
+#include <boost/core/bit.hpp>
+#include <cstdint>
+
+#define STATIC_ASSERT(...) static_assert(__VA_ARGS__, #__VA_ARGS__)
+
+STATIC_ASSERT( boost::core::byteswap( (std::int8_t)0x01 ) == 0x01 );
+STATIC_ASSERT( boost::core::byteswap( (std::uint8_t)0xF1 ) == 0xF1 );
+
+STATIC_ASSERT( boost::core::byteswap( (std::int16_t)0x0102 ) == 0x0201 );
+STATIC_ASSERT( boost::core::byteswap( (std::uint16_t)0xF1E2 ) == 0xE2F1 );
+
+STATIC_ASSERT( boost::core::byteswap( (std::int32_t)0x01020304 ) == 0x04030201 );
+STATIC_ASSERT( boost::core::byteswap( (std::uint32_t)0xF1E2D3C4u ) == 0xC4D3E2F1u );
+
+STATIC_ASSERT( boost::core::byteswap( (std::int64_t)0x0102030405060708ll ) == 0x0807060504030201ll );
+STATIC_ASSERT( boost::core::byteswap( (std::uint64_t)0xF1E2D3C4B5A69788ull ) == 0x8897A6B5C4D3E2F1ull );
+
+#endif

test/bit_cast_test_cx.cpp

@@ -0,0 +1,28 @@
+// constexpr test for boost/core/bit.hpp (bit_cast)
+//
+// Copyright 2023 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/core/bit.hpp>
+#include <boost/cstdint.hpp>
+
+#include <boost/config.hpp>
+#include <boost/config/pragma_message.hpp>
+
+#if defined(BOOST_NO_CXX11_CONSTEXPR)
+
+BOOST_PRAGMA_MESSAGE( "Test skipped because BOOST_NO_CXX11_CONSTEXPR is defined" )
+
+#elif !defined(BOOST_CORE_HAS_BUILTIN_BIT_CAST)
+
+BOOST_PRAGMA_MESSAGE( "Test skipped because BOOST_CORE_HAS_BUILTIN_BIT_CAST is not defined" )
+
+#else
+
+#define STATIC_ASSERT(...) static_assert(__VA_ARGS__, #__VA_ARGS__)
+
+STATIC_ASSERT( boost::core::bit_cast<boost::uint32_t>( 1.0f ) == 0x3F800000u );
+STATIC_ASSERT( boost::core::bit_cast<boost::uint64_t>( 1.0 ) == 0x3FF0000000000000ull );
+
+#endif

test/bit_ceil_test.cpp

@@ -14,7 +14,7 @@ template<class T> void test_bit_ceil( T x )
 {
     if( !boost::core::has_single_bit( x ) )
     {
-        x >>= 1;
+        x = static_cast<T>( x >> 1 );
     }
 
     T y = boost::core::bit_ceil( x );

test/bit_ceil_test_cx.cpp

@@ -0,0 +1,26 @@
+// constexpr test for boost/core/bit.hpp (bit_ceil)
+//
+// 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_CXX14_CONSTEXPR)
+
+BOOST_PRAGMA_MESSAGE( "Test skipped because BOOST_NO_CXX14_CONSTEXPR is defined" )
+
+#else
+
+#include <boost/core/bit.hpp>
+
+#define STATIC_ASSERT(...) static_assert(__VA_ARGS__, #__VA_ARGS__)
+
+STATIC_ASSERT( boost::core::bit_ceil( (unsigned char)0x74 ) == 0x80 );
+STATIC_ASSERT( boost::core::bit_ceil( (unsigned short)0x7400 ) == 0x8000 );
+STATIC_ASSERT( boost::core::bit_ceil( 0x740000u ) == 0x800000u );
+STATIC_ASSERT( boost::core::bit_ceil( 0x74000000ul ) == 0x80000000ul );
+STATIC_ASSERT( boost::core::bit_ceil( 0x7400000000ull ) == 0x8000000000ull );
+
+#endif

test/bit_countl_test.cpp

@@ -14,7 +14,7 @@ template<class T> void test_countl( T x )
 {
     x |= static_cast<T>( 1 ) << ( std::numeric_limits<T>::digits - 1 );
 
-    for( int i = 0; i <= std::numeric_limits<T>::digits; ++i, x >>= 1 )
+    for( int i = 0; i <= std::numeric_limits<T>::digits; ++i, x = static_cast<T>( x >> 1 ) )
     {
         BOOST_TEST_EQ( boost::core::countl_zero( x ), i );
         BOOST_TEST_EQ( boost::core::countl_one( static_cast<T>( ~x ) ), i );

test/bit_countl_test_cx.cpp

@@ -0,0 +1,41 @@
+// constexpr test for boost/core/bit.hpp (countl_zero, countl_one)
+//
+// Copyright 2023 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#if defined(_MSC_VER)
+# pragma warning(disable: 4310) // cast truncates constant value
+#endif
+
+#include <boost/config.hpp>
+#include <boost/config/pragma_message.hpp>
+
+#if defined(BOOST_NO_CXX14_CONSTEXPR)
+
+BOOST_PRAGMA_MESSAGE( "Test skipped because BOOST_NO_CXX14_CONSTEXPR is defined" )
+
+#elif defined(BOOST_MSVC) && BOOST_MSVC / 10 == 191
+
+BOOST_PRAGMA_MESSAGE( "Test skipped because BOOST_MSVC is " BOOST_STRINGIZE(BOOST_MSVC) )
+
+#else
+
+#include <boost/core/bit.hpp>
+#include <climits>
+
+#define STATIC_ASSERT(...) static_assert(__VA_ARGS__, #__VA_ARGS__)
+
+STATIC_ASSERT( boost::core::countl_zero( (unsigned char)0x1F ) == CHAR_BIT - 5 );
+STATIC_ASSERT( boost::core::countl_zero( (unsigned short)0x1F ) == sizeof(unsigned short) * CHAR_BIT - 5 );
+STATIC_ASSERT( boost::core::countl_zero( 0x1Fu ) == sizeof(unsigned int) * CHAR_BIT - 5 );
+STATIC_ASSERT( boost::core::countl_zero( 0x1Ful ) == sizeof(unsigned long) * CHAR_BIT - 5 );
+STATIC_ASSERT( boost::core::countl_zero( 0x1Full ) == sizeof(unsigned long long) * CHAR_BIT - 5 );
+
+STATIC_ASSERT( boost::core::countl_one( (unsigned char)~0x1Fu ) == CHAR_BIT - 5 );
+STATIC_ASSERT( boost::core::countl_one( (unsigned short)~0x1Fu ) == sizeof(unsigned short) * CHAR_BIT - 5 );
+STATIC_ASSERT( boost::core::countl_one( ~0x1Fu ) == sizeof(unsigned int) * CHAR_BIT - 5 );
+STATIC_ASSERT( boost::core::countl_one( ~0x1Ful ) == sizeof(unsigned long) * CHAR_BIT - 5 );
+STATIC_ASSERT( boost::core::countl_one( ~0x1Full ) == sizeof(unsigned long long) * CHAR_BIT - 5 );
+
+#endif

test/bit_countr_test.cpp

@@ -14,7 +14,7 @@ template<class T> void test_countr( T x )
 {
     x |= 1;
 
-    for( int i = 0; i <= std::numeric_limits<T>::digits; ++i, x <<= 1 )
+    for( int i = 0; i <= std::numeric_limits<T>::digits; ++i, x = static_cast<T>( x << 1 ) )
     {
         BOOST_TEST_EQ( boost::core::countr_zero( x ), i );
         BOOST_TEST_EQ( boost::core::countr_one( static_cast<T>( ~x ) ), i );

test/bit_countr_test_cx.cpp

@@ -0,0 +1,41 @@
+// constexpr test for boost/core/bit.hpp (countr_zero, countr_one)
+//
+// Copyright 2023 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#if defined(_MSC_VER)
+# pragma warning(disable: 4310) // cast truncates constant value
+#endif
+
+#include <boost/config.hpp>
+#include <boost/config/pragma_message.hpp>
+
+#if defined(BOOST_NO_CXX14_CONSTEXPR)
+
+BOOST_PRAGMA_MESSAGE( "Test skipped because BOOST_NO_CXX14_CONSTEXPR is defined" )
+
+#elif defined(BOOST_MSVC) && BOOST_MSVC / 10 == 191
+
+BOOST_PRAGMA_MESSAGE( "Test skipped because BOOST_MSVC is " BOOST_STRINGIZE(BOOST_MSVC) )
+
+#else
+
+#include <boost/core/bit.hpp>
+#include <climits>
+
+#define STATIC_ASSERT(...) static_assert(__VA_ARGS__, #__VA_ARGS__)
+
+STATIC_ASSERT( boost::core::countr_zero( (unsigned char)0xF8 ) == 3 );
+STATIC_ASSERT( boost::core::countr_zero( (unsigned short)0xF800 ) == 11 );
+STATIC_ASSERT( boost::core::countr_zero( 0xF80000u ) == 19 );
+STATIC_ASSERT( boost::core::countr_zero( 0xF8000000ul ) == 27 );
+STATIC_ASSERT( boost::core::countr_zero( 0xF800000000ull ) == 35 );
+
+STATIC_ASSERT( boost::core::countr_one( (unsigned char)~0xF8u ) == 3 );
+STATIC_ASSERT( boost::core::countr_one( (unsigned short)~0xF800u ) == 11 );
+STATIC_ASSERT( boost::core::countr_one( ~0xF80000u ) == 19 );
+STATIC_ASSERT( boost::core::countr_one( ~0xF8000000ul ) == 27 );
+STATIC_ASSERT( boost::core::countr_one( ~0xF800000000ull ) == 35 );
+
+#endif

test/bit_floor_test_cx.cpp

@@ -0,0 +1,30 @@
+// constexpr test for boost/core/bit.hpp (bit_floor)
+//
+// 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_CXX14_CONSTEXPR)
+
+BOOST_PRAGMA_MESSAGE( "Test skipped because BOOST_NO_CXX14_CONSTEXPR is defined" )
+
+#elif defined(BOOST_MSVC) && BOOST_MSVC / 10 == 191
+
+BOOST_PRAGMA_MESSAGE( "Test skipped because BOOST_MSVC is " BOOST_STRINGIZE(BOOST_MSVC) )
+
+#else
+
+#include <boost/core/bit.hpp>
+
+#define STATIC_ASSERT(...) static_assert(__VA_ARGS__, #__VA_ARGS__)
+
+STATIC_ASSERT( boost::core::bit_floor( (unsigned char)0x74 ) == 0x40 );
+STATIC_ASSERT( boost::core::bit_floor( (unsigned short)0x7400 ) == 0x4000 );
+STATIC_ASSERT( boost::core::bit_floor( 0x740000u ) == 0x400000u );
+STATIC_ASSERT( boost::core::bit_floor( 0x74000000ul ) == 0x40000000ul );
+STATIC_ASSERT( boost::core::bit_floor( 0x7400000000ull ) == 0x4000000000ull );
+
+#endif

test/bit_popcount_test.cpp

@@ -1,4 +1,4 @@
-// Test for boost/core/bit.hpp (bit_ceil)
+// Test for boost/core/bit.hpp (popcount)
 //
 // Copyright 2020 Peter Dimov
 // Distributed under the Boost Software License, Version 1.0.
@@ -14,7 +14,7 @@
 template<class T> void test_popcount( T x )
 {
     int k = 0;
-    for( T y = x; y; y &= y - 1, ++k );
+    for( T y = x; y; y = static_cast<T>( y & (y - 1) ), ++k );
 
     BOOST_TEST_EQ( boost::core::popcount( x ), k ) || ( std::cerr << "x: " << +x << std::endl );
 }

test/bit_popcount_test_cx.cpp

@@ -0,0 +1,30 @@
+// constexpr test for boost/core/bit.hpp (popcount)
+//
+// Copyright 2023 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 / 10 == 191
+# pragma warning(disable: 4307) // '*': integral constant overflow
+#endif
+
+#include <boost/config.hpp>
+#include <boost/config/pragma_message.hpp>
+
+#if defined(BOOST_NO_CXX14_CONSTEXPR)
+
+BOOST_PRAGMA_MESSAGE( "Test skipped because BOOST_NO_CXX14_CONSTEXPR is defined" )
+
+#else
+
+#include <boost/core/bit.hpp>
+
+#define STATIC_ASSERT(...) static_assert(__VA_ARGS__, #__VA_ARGS__)
+
+STATIC_ASSERT( boost::core::popcount( (unsigned char)0x74 ) == 4 );
+STATIC_ASSERT( boost::core::popcount( (unsigned short)0x7400 ) == 4 );
+STATIC_ASSERT( boost::core::popcount( 0x740000u ) == 4 );
+STATIC_ASSERT( boost::core::popcount( 0x74000000ul ) == 4 );
+STATIC_ASSERT( boost::core::popcount( 0x7400000000ull ) == 4 );
+
+#endif

test/bit_rotate_test.cpp

@@ -20,7 +20,7 @@ template<class T> void test_rotate( T x )
         BOOST_TEST_EQ( +boost::core::rotl( x, -i ), +boost::core::rotr( x, i ) );
 
         unsigned const width = std::numeric_limits<T>::digits;
-        unsigned r = i & ( width - 1 );
+        unsigned r = static_cast<unsigned>( i ) & ( width - 1 );
 
         if( r == 0 )
         {

test/bit_rotate_test_cx.cpp

@@ -0,0 +1,33 @@
+// constexpr test for boost/core/bit.hpp (rotl, rotr)
+//
+// 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_CXX14_CONSTEXPR)
+
+BOOST_PRAGMA_MESSAGE( "Test skipped because BOOST_NO_CXX14_CONSTEXPR is defined" )
+
+#else
+
+#include <boost/core/bit.hpp>
+#include <cstdint>
+
+#define STATIC_ASSERT(...) static_assert(__VA_ARGS__, #__VA_ARGS__)
+
+STATIC_ASSERT( boost::core::rotl( (std::uint8_t)0x11, 1 ) == 0x22 );
+STATIC_ASSERT( boost::core::rotr( (std::uint8_t)0x11, 1 ) == 0x88 );
+
+STATIC_ASSERT( boost::core::rotl( (std::uint16_t)0x1111, 1 ) == 0x2222 );
+STATIC_ASSERT( boost::core::rotr( (std::uint16_t)0x1111, 1 ) == 0x8888 );
+
+STATIC_ASSERT( boost::core::rotl( (std::uint32_t)0x11111111, 1 ) == 0x22222222 );
+STATIC_ASSERT( boost::core::rotr( (std::uint32_t)0x11111111, 1 ) == 0x88888888 );
+
+STATIC_ASSERT( boost::core::rotl( (std::uint64_t)0x1111111111111111, 1 ) == 0x2222222222222222 );
+STATIC_ASSERT( boost::core::rotr( (std::uint64_t)0x1111111111111111, 1 ) == 0x8888888888888888 );
+
+#endif

test/bit_width_test.cpp

@@ -24,7 +24,7 @@ int main()
 
         x = 1;
 
-        for( int i = 0; i < 8; ++i, x <<= 1 )
+        for( int i = 0; i < 8; ++i, x = static_cast<boost::uint8_t>( x << 1 ) )
         {
             BOOST_TEST_EQ( boost::core::bit_width( x ), i+1 );
             BOOST_TEST_EQ( boost::core::bit_width( static_cast<boost::uint8_t>( x | ( x >> 1 ) ) ), i+1 );
@@ -39,7 +39,7 @@ int main()
 
         x = 1;
 
-        for( int i = 0; i < 16; ++i, x <<= 1 )
+        for( int i = 0; i < 16; ++i, x = static_cast<boost::uint16_t>( x << 1 ) )
         {
             BOOST_TEST_EQ( boost::core::bit_width( x ), i+1 );
             BOOST_TEST_EQ( boost::core::bit_width( static_cast<boost::uint16_t>( x | ( x >> 1 ) ) ), i+1 );

test/bit_width_test_cx.cpp

@@ -0,0 +1,30 @@
+// constexpr test for boost/core/bit.hpp (bit_width)
+//
+// 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_CXX14_CONSTEXPR)
+
+BOOST_PRAGMA_MESSAGE( "Test skipped because BOOST_NO_CXX14_CONSTEXPR is defined" )
+
+#elif defined(BOOST_MSVC) && BOOST_MSVC / 10 == 191
+
+BOOST_PRAGMA_MESSAGE( "Test skipped because BOOST_MSVC is " BOOST_STRINGIZE(BOOST_MSVC) )
+
+#else
+
+#include <boost/core/bit.hpp>
+
+#define STATIC_ASSERT(...) static_assert(__VA_ARGS__, #__VA_ARGS__)
+
+STATIC_ASSERT( boost::core::bit_width( (unsigned char)0x74 ) == 7 );
+STATIC_ASSERT( boost::core::bit_width( (unsigned short)0x7400 ) == 15 );
+STATIC_ASSERT( boost::core::bit_width( 0x740000u ) == 23 );
+STATIC_ASSERT( boost::core::bit_width( 0x74000000ul ) == 31 );
+STATIC_ASSERT( boost::core::bit_width( 0x7400000000ull ) == 39 );
+
+#endif

test/checked_array_deleter_compile_fail_adl.cpp

@@ -0,0 +1,30 @@
+/*
+ *             Copyright Andrey Semashev 2024.
+ * Distributed under the Boost Software License, Version 1.0.
+ *    (See accompanying file LICENSE_1_0.txt or copy at
+ *          http://www.boost.org/LICENSE_1_0.txt)
+ */
+/*!
+ * \file   checked_array_deleter_compile_fail_adl.cpp
+ * \author Andrey Semashev
+ * \date   07.02.2024
+ *
+ * This file tests that \c boost::checked_array_deleter doesn't bring namespace
+ * \c boost into ADL.
+ */
+
+#include <boost/core/checked_delete.hpp>
+
+namespace boost {
+
+void check_adl(checked_array_deleter< int > const&)
+{
+}
+
+} // namespace boost
+
+int main()
+{
+    // Must not find boost::check_adl
+    check_adl(boost::checked_array_deleter< int >());
+}

test/checked_deleter_compile_fail_adl.cpp

@@ -0,0 +1,30 @@
+/*
+ *             Copyright Andrey Semashev 2024.
+ * Distributed under the Boost Software License, Version 1.0.
+ *    (See accompanying file LICENSE_1_0.txt or copy at
+ *          http://www.boost.org/LICENSE_1_0.txt)
+ */
+/*!
+ * \file   checked_deleter_compile_fail_adl.cpp
+ * \author Andrey Semashev
+ * \date   07.02.2024
+ *
+ * This file tests that \c boost::checked_deleter doesn't bring namespace
+ * \c boost into ADL.
+ */
+
+#include <boost/core/checked_delete.hpp>
+
+namespace boost {
+
+void check_adl(checked_deleter< int > const&)
+{
+}
+
+} // namespace boost
+
+int main()
+{
+    // Must not find boost::check_adl
+    check_adl(boost::checked_deleter< int >());
+}

test/fclose_deleter_compile_fail_adl.cpp

@@ -0,0 +1,30 @@
+/*
+ *             Copyright Andrey Semashev 2024.
+ * Distributed under the Boost Software License, Version 1.0.
+ *    (See accompanying file LICENSE_1_0.txt or copy at
+ *          http://www.boost.org/LICENSE_1_0.txt)
+ */
+/*!
+ * \file   fclose_deleter_compile_fail_adl.cpp
+ * \author Andrey Semashev
+ * \date   02.02.2024
+ *
+ * This file tests that \c boost::fclose_deleter doesn't bring namespace
+ * \c boost into ADL.
+ */
+
+#include <boost/core/fclose_deleter.hpp>
+
+namespace boost {
+
+void check_adl(fclose_deleter const&)
+{
+}
+
+} // namespace boost
+
+int main()
+{
+    // Must not find boost::check_adl
+    check_adl(boost::fclose_deleter());
+}

test/functor_compile_fail_adl.cpp

@@ -0,0 +1,32 @@
+/*
+ *             Copyright Andrey Semashev 2024.
+ * Distributed under the Boost Software License, Version 1.0.
+ *    (See accompanying file LICENSE_1_0.txt or copy at
+ *          http://www.boost.org/LICENSE_1_0.txt)
+ */
+/*!
+ * \file   functor_compile_fail_adl.cpp
+ * \author Andrey Semashev
+ * \date   02.02.2024
+ *
+ * This file tests that \c boost::core::functor doesn't bring namespace
+ * \c boost::core into ADL.
+ */
+
+#include <boost/core/functor.hpp>
+
+void func() {}
+
+namespace boost::core {
+
+void check_adl(functor< ::func > const&)
+{
+}
+
+} // namespace boost::core
+
+int main()
+{
+    // Must not find boost::check_adl
+    check_adl(boost::core::functor< ::func >());
+}

test/functor_test.cpp

@@ -0,0 +1,202 @@
+/*
+ *             Copyright Andrey Semashev 2024.
+ * Distributed under the Boost Software License, Version 1.0.
+ *    (See accompanying file LICENSE_1_0.txt or copy at
+ *          http://www.boost.org/LICENSE_1_0.txt)
+ */
+/*!
+ * \file   functor_test.cpp
+ * \author Andrey Semashev
+ * \date   2024-01-23
+ *
+ * This file contains tests for \c boost::core::functor.
+ */
+
+#include <boost/config.hpp>
+
+#if !defined(BOOST_NO_CXX17_AUTO_NONTYPE_TEMPLATE_PARAMS)
+
+#include <boost/core/functor.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+
+#if (defined(__cpp_lib_is_invocable) && (__cpp_lib_is_invocable >= 201703l)) || \
+    (defined(BOOST_MSSTL_VERSION) && (BOOST_MSSTL_VERSION >= 140) && (BOOST_CXX_VERSION >= 201703l))
+
+namespace test {
+
+using std::is_invocable;
+
+} // namespace test
+
+#else
+
+namespace test {
+
+// A simplified implementation that does not support member function pointers
+template< typename Func, typename... Args >
+struct is_invocable_impl
+{
+    template< typename F = Func, typename = decltype(std::declval< F >()(std::declval< Args >()...)) >
+    static std::true_type _check_invocable(int);
+    static std::false_type _check_invocable(...);
+
+    typedef decltype(is_invocable_impl::_check_invocable(0)) type;
+};
+
+template< typename Func, typename... Args >
+struct is_invocable : public is_invocable_impl< Func, Args... >::type { };
+
+} // namespace test
+
+#endif
+
+int g_n = 0;
+
+void void_func()
+{
+    ++g_n;
+}
+
+int int_func()
+{
+    return ++g_n;
+}
+
+int& int_ref_func()
+{
+    ++g_n;
+    return g_n;
+}
+
+void void_add1(int x)
+{
+    g_n += x;
+}
+
+int add2(int x, int y)
+{
+    return x + y;
+}
+
+namespace test_ns {
+
+int add3(int x, int y, int z)
+{
+    return x + y + z;
+}
+
+} // namespace test_ns
+
+int int_func_noexcept() noexcept
+{
+    return ++g_n;
+}
+
+int main()
+{
+    {
+        boost::core::functor< void_func > fun;
+        BOOST_TEST_TRAIT_TRUE((test::is_invocable< boost::core::functor< void_func >& >));
+        BOOST_TEST_TRAIT_TRUE((test::is_invocable< boost::core::functor< void_func > const& >));
+        BOOST_TEST_TRAIT_FALSE((test::is_invocable< boost::core::functor< void_func > const&, int >));
+        BOOST_TEST_EQ(noexcept(fun()), false);
+        fun();
+        BOOST_TEST_EQ(g_n, 1);
+        fun();
+        BOOST_TEST_EQ(g_n, 2);
+    }
+
+    g_n = 0;
+    {
+        boost::core::functor< int_func > fun;
+        int res = fun();
+        BOOST_TEST_EQ(res, 1);
+        BOOST_TEST_EQ(g_n, 1);
+        res = fun();
+        BOOST_TEST_EQ(res, 2);
+        BOOST_TEST_EQ(g_n, 2);
+    }
+
+    g_n = 0;
+    {
+        boost::core::functor< int_ref_func > fun;
+        int& res1 = fun();
+        BOOST_TEST_EQ(&res1, &g_n);
+        BOOST_TEST_EQ(res1, 1);
+        int& res2 = fun();
+        BOOST_TEST_EQ(&res2, &g_n);
+        BOOST_TEST_EQ(res2, 2);
+    }
+
+    g_n = 0;
+    {
+        boost::core::functor< void_add1 > fun;
+        BOOST_TEST_TRAIT_FALSE((test::is_invocable< boost::core::functor< void_add1 >& >));
+        BOOST_TEST_TRAIT_FALSE((test::is_invocable< boost::core::functor< void_add1 > const& >));
+        BOOST_TEST_TRAIT_TRUE((test::is_invocable< boost::core::functor< void_add1 >&, int >));
+        BOOST_TEST_TRAIT_TRUE((test::is_invocable< boost::core::functor< void_add1 > const&, int >));
+        BOOST_TEST_TRAIT_TRUE((test::is_invocable< boost::core::functor< void_add1 >&, short int >));
+        BOOST_TEST_TRAIT_TRUE((test::is_invocable< boost::core::functor< void_add1 > const&, short int >));
+        BOOST_TEST_TRAIT_FALSE((test::is_invocable< boost::core::functor< void_add1 > const&, int, int >));
+        BOOST_TEST_TRAIT_FALSE((test::is_invocable< boost::core::functor< void_add1 > const&, const char* >));
+        fun(10);
+        BOOST_TEST_EQ(g_n, 10);
+        fun(20);
+        BOOST_TEST_EQ(g_n, 30);
+    }
+
+    {
+        boost::core::functor< add2 > fun;
+        BOOST_TEST_TRAIT_FALSE((test::is_invocable< boost::core::functor< add2 >& >));
+        BOOST_TEST_TRAIT_FALSE((test::is_invocable< boost::core::functor< add2 > const& >));
+        BOOST_TEST_TRAIT_FALSE((test::is_invocable< boost::core::functor< add2 >&, int >));
+        BOOST_TEST_TRAIT_FALSE((test::is_invocable< boost::core::functor< add2 > const&, int >));
+        BOOST_TEST_TRAIT_TRUE((test::is_invocable< boost::core::functor< add2 >&, int, int >));
+        BOOST_TEST_TRAIT_TRUE((test::is_invocable< boost::core::functor< add2 > const&, int, int >));
+        BOOST_TEST_TRAIT_TRUE((test::is_invocable< boost::core::functor< add2 >&, short int, signed char >));
+        BOOST_TEST_TRAIT_TRUE((test::is_invocable< boost::core::functor< add2 > const&, short int, signed char >));
+        BOOST_TEST_TRAIT_FALSE((test::is_invocable< boost::core::functor< add2 > const&, const char* >));
+        BOOST_TEST_TRAIT_FALSE((test::is_invocable< boost::core::functor< add2 > const&, const char*, float >));
+        int res = fun(10, 20);
+        BOOST_TEST_EQ(res, 30);
+        res = fun(30, 40);
+        BOOST_TEST_EQ(res, 70);
+    }
+
+    {
+        boost::core::functor< test_ns::add3 > fun;
+        int res = fun(10, 20, 30);
+        BOOST_TEST_EQ(res, 60);
+        res = fun(40, 50, 60);
+        BOOST_TEST_EQ(res, 150);
+    }
+
+    g_n = 0;
+    {
+        boost::core::functor< int_func_noexcept > fun;
+        BOOST_TEST_EQ(noexcept(fun()), true);
+        int res = fun();
+        BOOST_TEST_EQ(res, 1);
+        BOOST_TEST_EQ(g_n, 1);
+        res = fun();
+        BOOST_TEST_EQ(res, 2);
+        BOOST_TEST_EQ(g_n, 2);
+    }
+
+    return boost::report_errors();
+}
+
+#else // !defined(BOOST_NO_CXX17_AUTO_NONTYPE_TEMPLATE_PARAMS)
+
+#include <boost/config/pragma_message.hpp>
+
+BOOST_PRAGMA_MESSAGE("Test skipped because C++17 auto non-type template parameters are not supported")
+
+int main()
+{
+    return 0;
+}
+
+#endif // !defined(BOOST_NO_CXX17_AUTO_NONTYPE_TEMPLATE_PARAMS)

test/has_single_bit_test.cpp

@@ -28,7 +28,7 @@ int main()
 
         x = 2;
 
-        for( int i = 1; i < 8; ++i, x <<= 1 )
+        for( int i = 1; i < 8; ++i, x = static_cast<boost::uint8_t>( x << 1 ) )
         {
             BOOST_TEST_EQ( boost::core::has_single_bit( x ), true );
             BOOST_TEST_EQ( boost::core::has_single_bit( static_cast<boost::uint8_t>( x | ( x >> 1 ) ) ), false );
@@ -47,7 +47,7 @@ int main()
 
         x = 2;
 
-        for( int i = 1; i < 16; ++i, x <<= 1 )
+        for( int i = 1; i < 16; ++i, x = static_cast<boost::uint16_t>( x << 1 ) )
         {
             BOOST_TEST_EQ( boost::core::has_single_bit( x ), true );
             BOOST_TEST_EQ( boost::core::has_single_bit( static_cast<boost::uint16_t>( x | ( x >> 1 ) ) ), false );

test/has_single_bit_test_cx.cpp

@@ -0,0 +1,35 @@
+// constexpr test for boost/core/bit.hpp (has_single_bit)
+//
+// 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_CXX14_CONSTEXPR)
+
+BOOST_PRAGMA_MESSAGE( "Test skipped because BOOST_NO_CXX14_CONSTEXPR is defined" )
+
+#else
+
+#include <boost/core/bit.hpp>
+
+#define STATIC_ASSERT(...) static_assert(__VA_ARGS__, #__VA_ARGS__)
+
+STATIC_ASSERT( boost::core::has_single_bit( (unsigned char)0x80 ) == true );
+STATIC_ASSERT( boost::core::has_single_bit( (unsigned char)0x90 ) == false );
+
+STATIC_ASSERT( boost::core::has_single_bit( (unsigned short)0x8000 ) == true );
+STATIC_ASSERT( boost::core::has_single_bit( (unsigned short)0x9000 ) == false );
+
+STATIC_ASSERT( boost::core::has_single_bit( 0x800000u ) == true );
+STATIC_ASSERT( boost::core::has_single_bit( 0x900000u ) == false );
+
+STATIC_ASSERT( boost::core::has_single_bit( 0x80000000ul ) == true );
+STATIC_ASSERT( boost::core::has_single_bit( 0x90000000ul ) == false );
+
+STATIC_ASSERT( boost::core::has_single_bit( 0x8000000000ull ) == true );
+STATIC_ASSERT( boost::core::has_single_bit( 0x9000000000ull ) == false );
+
+#endif

test/minstd_rand_test.cpp

@@ -0,0 +1,38 @@
+// Test for boost/core/detail/minstd_rand.hpp
+//
+// Copyright 2022, 2024 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/core/detail/minstd_rand.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <boost/cstdint.hpp>
+
+int main()
+{
+    {
+        boost::detail::minstd_rand rng;
+
+        boost::uint_least32_t r1 = rng(), x1 = 48271;
+        BOOST_TEST_EQ( r1, x1 );
+
+        for( int i = 0; i < 1000; ++i ) rng();
+
+        boost::uint_least32_t r2 = rng(), x2 = 2076422031;
+        BOOST_TEST_EQ( r2, x2 );
+    }
+
+    {
+        boost::detail::minstd_rand rng( 12345 );
+
+        boost::uint_least32_t r1 = rng(), x1 = 595905495;
+        BOOST_TEST_EQ( r1, x1 );
+
+        for( int i = 0; i < 1000; ++i ) rng();
+
+        boost::uint_least32_t r2 = rng(), x2 = 1065162103;
+        BOOST_TEST_EQ( r2, x2 );
+    }
+
+    return boost::report_errors();
+}

test/null_deleter_compile_fail_adl.cpp

@@ -0,0 +1,30 @@
+/*
+ *             Copyright Andrey Semashev 2024.
+ * Distributed under the Boost Software License, Version 1.0.
+ *    (See accompanying file LICENSE_1_0.txt or copy at
+ *          http://www.boost.org/LICENSE_1_0.txt)
+ */
+/*!
+ * \file   fclose_deleter_compile_fail_adl.cpp
+ * \author Andrey Semashev
+ * \date   02.02.2024
+ *
+ * This file tests that \c boost::null_deleter doesn't bring namespace
+ * \c boost into ADL.
+ */
+
+#include <boost/core/null_deleter.hpp>
+
+namespace boost {
+
+void check_adl(null_deleter const&)
+{
+}
+
+} // namespace boost
+
+int main()
+{
+    // Must not find boost::check_adl
+    check_adl(boost::null_deleter());
+}

test/pointer_in_range_constexpr_test.cpp

@@ -0,0 +1,31 @@
+/*
+Copyright 2024 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+*/
+#include <boost/core/pointer_in_range.hpp>
+#include <boost/static_assert.hpp>
+
+#if !defined(BOOST_CORE_NO_CONSTEXPR_POINTER_IN_RANGE)
+int a[4] = { 0, 0, 0, 0 };
+int n = 0;
+const int b[4] = { 0, 0, 0, 0 };
+const int m = 0;
+
+BOOST_STATIC_ASSERT(!boost::pointer_in_range(&a[0], &a[1], a + 4));
+BOOST_STATIC_ASSERT(boost::pointer_in_range(&a[1], &a[1], a + 4));
+BOOST_STATIC_ASSERT(boost::pointer_in_range(&a[2], &a[1], a + 4));
+BOOST_STATIC_ASSERT(boost::pointer_in_range(&a[3], &a[1], a + 4));
+BOOST_STATIC_ASSERT(!boost::pointer_in_range(a + 4, &a[1], a + 4));
+BOOST_STATIC_ASSERT(!boost::pointer_in_range(&n, &a[0], &a[3]));
+BOOST_STATIC_ASSERT(!boost::pointer_in_range(&m, &a[0], &a[3]));
+BOOST_STATIC_ASSERT(!boost::pointer_in_range(&b[0], &b[1], b + 4));
+BOOST_STATIC_ASSERT(boost::pointer_in_range(&b[1], &b[1], b + 4));
+BOOST_STATIC_ASSERT(boost::pointer_in_range(&b[2], &b[1], b + 4));
+BOOST_STATIC_ASSERT(boost::pointer_in_range(&b[3], &b[1], b + 4));
+BOOST_STATIC_ASSERT(!boost::pointer_in_range(b + 4, &b[1], b + 4));
+BOOST_STATIC_ASSERT(!boost::pointer_in_range(&n, &b[0], &b[3]));
+BOOST_STATIC_ASSERT(!boost::pointer_in_range(&m, &b[0], &b[3]));
+#endif

test/pointer_in_range_test.cpp

@@ -0,0 +1,32 @@
+/*
+Copyright 2024 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+*/
+#include <boost/core/pointer_in_range.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+int main()
+{
+    int a[4] = { 0, 0, 0, 0 };
+    int n = 0;
+    const int b[4] = { 0, 0, 0, 0 };
+    const int m = 0;
+    BOOST_TEST(!boost::pointer_in_range(&a[0], &a[1], a + 4));
+    BOOST_TEST(boost::pointer_in_range(&a[1], &a[1], a + 4));
+    BOOST_TEST(boost::pointer_in_range(&a[2], &a[1], a + 4));
+    BOOST_TEST(boost::pointer_in_range(&a[3], &a[1], a + 4));
+    BOOST_TEST(!boost::pointer_in_range(a + 4, &a[1], a + 4));
+    BOOST_TEST(!boost::pointer_in_range(&n, &a[0], &a[3]));
+    BOOST_TEST(!boost::pointer_in_range(&m, &a[0], &a[3]));
+    BOOST_TEST(!boost::pointer_in_range(&b[0], &b[1], b + 4));
+    BOOST_TEST(boost::pointer_in_range(&b[1], &b[1], b + 4));
+    BOOST_TEST(boost::pointer_in_range(&b[2], &b[1], b + 4));
+    BOOST_TEST(boost::pointer_in_range(&b[3], &b[1], b + 4));
+    BOOST_TEST(!boost::pointer_in_range(b + 4, &b[1], b + 4));
+    BOOST_TEST(!boost::pointer_in_range(&n, &b[0], &b[3]));
+    BOOST_TEST(!boost::pointer_in_range(&m, &b[0], &b[3]));
+    return boost::report_errors();
+}

test/sp_thread_pause_test.cpp

@@ -0,0 +1,15 @@
+// Test for sp_thread_pause
+//
+// Copyright 2023 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/core/yield_primitives.hpp>
+
+int main()
+{
+    for( int i = 0; i < 1048576; ++i )
+    {
+        boost::core::sp_thread_pause();
+    }
+}

test/sp_thread_sleep_test.cpp

@@ -0,0 +1,15 @@
+// Test for sp_thread_sleep
+//
+// Copyright 2023 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/core/yield_primitives.hpp>
+
+int main()
+{
+    for( int i = 0; i < 100; ++i )
+    {
+        boost::core::sp_thread_sleep();
+    }
+}

test/sp_thread_yield_test.cpp

@@ -0,0 +1,15 @@
+// Test for sp_thread_yield
+//
+// Copyright 2023 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/core/yield_primitives.hpp>
+
+int main()
+{
+    for( int i = 0; i < 10000; ++i )
+    {
+        boost::core::sp_thread_yield();
+    }
+}

test/sv_construct_test.cpp

@@ -4,6 +4,18 @@
 
 #include <boost/core/detail/string_view.hpp>
 #include <boost/core/lightweight_test.hpp>
+#include <boost/config.hpp>
+
+#if !defined(BOOST_NO_CXX17_HDR_MEMORY_RESOURCE)
+# if defined(__apple_build_version__)
+// Under macOS, it's possible for the header
+// <memory_resource> to be present, but for
+// libc++.dylib to not have support for it.
+// https://github.com/boostorg/core/issues/162
+#  define BOOST_NO_CXX17_HDR_MEMORY_RESOURCE
+# endif
+#endif
+
 #include <iterator>
 #include <string>
 #if !defined(BOOST_NO_CXX17_HDR_STRING_VIEW)

test/sv_construct_test_cx.cpp

@@ -0,0 +1,147 @@
+// Copyright 2021, 2024 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/core/detail/string_view.hpp>
+#include <boost/config.hpp>
+#include <boost/config/pragma_message.hpp>
+
+#if defined(BOOST_NO_CXX14_CONSTEXPR)
+
+BOOST_PRAGMA_MESSAGE( "Test skipped because BOOST_NO_CXX14_CONSTEXPR is defined" )
+int main() {}
+
+#else
+
+#if !defined(BOOST_NO_CXX17_HDR_STRING_VIEW)
+# include <string_view>
+#endif
+
+#define STATIC_ASSERT(...) static_assert(__VA_ARGS__, #__VA_ARGS__)
+
+int main()
+{
+    {
+        constexpr boost::core::string_view sv;
+
+        STATIC_ASSERT( sv.data() == nullptr );
+        STATIC_ASSERT( sv.size() == 0 );
+
+        STATIC_ASSERT( sv.begin() == sv.data() );
+        STATIC_ASSERT( sv.end() == sv.data() + sv.size() );
+
+        STATIC_ASSERT( sv.cbegin() == sv.data() );
+        STATIC_ASSERT( sv.cend() == sv.data() + sv.size() );
+
+        STATIC_ASSERT( sv.length() == sv.size() );
+        STATIC_ASSERT( sv.empty() == ( sv.size() == 0 ) );
+
+        STATIC_ASSERT( sv.max_size() == boost::core::string_view::npos );
+    }
+
+    {
+        constexpr char const* s = "123";
+
+        constexpr boost::core::string_view sv( s, 0 );
+
+        STATIC_ASSERT( sv.data() == s );
+        STATIC_ASSERT( sv.size() == 0 );
+
+        STATIC_ASSERT( sv.begin() == sv.data() );
+        STATIC_ASSERT( sv.end() == sv.data() + sv.size() );
+
+        STATIC_ASSERT( sv.cbegin() == sv.data() );
+        STATIC_ASSERT( sv.cend() == sv.data() + sv.size() );
+
+        STATIC_ASSERT( sv.length() == sv.size() );
+        STATIC_ASSERT( sv.empty() == ( sv.size() == 0 ) );
+
+        STATIC_ASSERT( sv.max_size() == boost::core::string_view::npos );
+    }
+
+    {
+        constexpr char const* s = "123";
+
+        constexpr boost::core::string_view sv( s, 2 );
+
+        STATIC_ASSERT( sv.data() == s );
+        STATIC_ASSERT( sv.size() == 2 );
+
+        STATIC_ASSERT( sv.begin() == sv.data() );
+        STATIC_ASSERT( sv.end() == sv.data() + sv.size() );
+
+        STATIC_ASSERT( sv.cbegin() == sv.data() );
+        STATIC_ASSERT( sv.cend() == sv.data() + sv.size() );
+
+        STATIC_ASSERT( sv.length() == sv.size() );
+        STATIC_ASSERT( sv.empty() == ( sv.size() == 0 ) );
+
+        STATIC_ASSERT( sv.max_size() == boost::core::string_view::npos );
+    }
+
+    {
+        constexpr char const* s = "123";
+
+        constexpr boost::core::string_view sv( s, s );
+
+        STATIC_ASSERT( sv.data() == s );
+        STATIC_ASSERT( sv.size() == 0 );
+
+        STATIC_ASSERT( sv.begin() == sv.data() );
+        STATIC_ASSERT( sv.end() == sv.data() + sv.size() );
+
+        STATIC_ASSERT( sv.cbegin() == sv.data() );
+        STATIC_ASSERT( sv.cend() == sv.data() + sv.size() );
+
+        STATIC_ASSERT( sv.length() == sv.size() );
+        STATIC_ASSERT( sv.empty() == ( sv.size() == 0 ) );
+
+        STATIC_ASSERT( sv.max_size() == boost::core::string_view::npos );
+    }
+
+    {
+        constexpr char const* s = "123";
+
+        constexpr boost::core::string_view sv( s, s + 2 );
+
+        STATIC_ASSERT( sv.data() == s );
+        STATIC_ASSERT( sv.size() == 2 );
+
+        STATIC_ASSERT( sv.begin() == sv.data() );
+        STATIC_ASSERT( sv.end() == sv.data() + sv.size() );
+
+        STATIC_ASSERT( sv.cbegin() == sv.data() );
+        STATIC_ASSERT( sv.cend() == sv.data() + sv.size() );
+
+        STATIC_ASSERT( sv.length() == sv.size() );
+        STATIC_ASSERT( sv.empty() == ( sv.size() == 0 ) );
+
+        STATIC_ASSERT( sv.max_size() == boost::core::string_view::npos );
+    }
+
+#if !defined(BOOST_NO_CXX17_HDR_STRING_VIEW)
+
+    {
+        constexpr std::string_view str( "123", 3 );
+
+        constexpr boost::core::string_view sv( str );
+
+        STATIC_ASSERT( sv.data() == str.data() );
+        STATIC_ASSERT( sv.size() == str.size() );
+
+        STATIC_ASSERT( sv.begin() == sv.data() );
+        STATIC_ASSERT( sv.end() == sv.data() + sv.size() );
+
+        STATIC_ASSERT( sv.cbegin() == sv.data() );
+        STATIC_ASSERT( sv.cend() == sv.data() + sv.size() );
+
+        STATIC_ASSERT( sv.length() == sv.size() );
+        STATIC_ASSERT( sv.empty() == ( sv.size() == 0 ) );
+
+        STATIC_ASSERT( sv.max_size() == boost::core::string_view::npos );
+    }
+
+#endif
+}
+
+#endif

test/sv_construct_test_cx2.cpp

@@ -0,0 +1,75 @@
+// Copyright 2021, 2024 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/core/detail/string_view.hpp>
+#include <boost/config.hpp>
+#include <boost/config/pragma_message.hpp>
+
+#if defined(BOOST_NO_CXX14_CONSTEXPR)
+
+BOOST_PRAGMA_MESSAGE( "Test skipped because BOOST_NO_CXX14_CONSTEXPR is defined" )
+int main() {}
+
+#elif BOOST_CXX_VERSION < 201703L
+
+// std::char_traits is not constexpr in C++14
+
+BOOST_PRAGMA_MESSAGE( "Test skipped because BOOST_CXX_VERSION < 201703L" )
+int main() {}
+
+#elif defined(BOOST_LIBSTDCXX_VERSION) && BOOST_LIBSTDCXX_VERSION < 70300
+
+// std::char_traits is not constexpr in libstdc++ 7.2
+
+BOOST_PRAGMA_MESSAGE( "Test skipped because BOOST_LIBSTDCXX_VERSION < 70300" )
+int main() {}
+
+#else
+
+#define STATIC_ASSERT(...) static_assert(__VA_ARGS__, #__VA_ARGS__)
+
+int main()
+{
+    {
+        constexpr char const* s = "";
+
+        constexpr boost::core::string_view sv( s );
+
+        STATIC_ASSERT( sv.data() == s );
+        STATIC_ASSERT( sv.size() == 0 );
+
+        STATIC_ASSERT( sv.begin() == sv.data() );
+        STATIC_ASSERT( sv.end() == sv.data() + sv.size() );
+
+        STATIC_ASSERT( sv.cbegin() == sv.data() );
+        STATIC_ASSERT( sv.cend() == sv.data() + sv.size() );
+
+        STATIC_ASSERT( sv.length() == sv.size() );
+        STATIC_ASSERT( sv.empty() == ( sv.size() == 0 ) );
+
+        STATIC_ASSERT( sv.max_size() == boost::core::string_view::npos );
+    }
+
+    {
+        constexpr char const* s = "123";
+
+        constexpr boost::core::string_view sv( s );
+
+        STATIC_ASSERT( sv.data() == s );
+        STATIC_ASSERT( sv.size() == 3 );
+
+        STATIC_ASSERT( sv.begin() == sv.data() );
+        STATIC_ASSERT( sv.end() == sv.data() + sv.size() );
+
+        STATIC_ASSERT( sv.cbegin() == sv.data() );
+        STATIC_ASSERT( sv.cend() == sv.data() + sv.size() );
+
+        STATIC_ASSERT( sv.length() == sv.size() );
+        STATIC_ASSERT( sv.empty() == ( sv.size() == 0 ) );
+
+        STATIC_ASSERT( sv.max_size() == boost::core::string_view::npos );
+    }
+}
+
+#endif

test/sv_conversion_test.cpp

@@ -4,6 +4,18 @@
 
 #include <boost/core/detail/string_view.hpp>
 #include <boost/core/lightweight_test.hpp>
+#include <boost/config.hpp>
+
+#if !defined(BOOST_NO_CXX17_HDR_MEMORY_RESOURCE)
+# if defined(__apple_build_version__)
+// Under macOS, it's possible for the header
+// <memory_resource> to be present, but for
+// libc++.dylib to not have support for it.
+// https://github.com/boostorg/core/issues/162
+#  define BOOST_NO_CXX17_HDR_MEMORY_RESOURCE
+# endif
+#endif
+
 #include <string>
 #if !defined(BOOST_NO_CXX17_HDR_STRING_VIEW)
 # include <string_view>

test/sv_eq_test.cpp

@@ -4,6 +4,18 @@
 
 #include <boost/core/detail/string_view.hpp>
 #include <boost/core/lightweight_test.hpp>
+#include <boost/config.hpp>
+
+#if !defined(BOOST_NO_CXX17_HDR_MEMORY_RESOURCE)
+# if defined(__apple_build_version__)
+// Under macOS, it's possible for the header
+// <memory_resource> to be present, but for
+// libc++.dylib to not have support for it.
+// https://github.com/boostorg/core/issues/162
+#  define BOOST_NO_CXX17_HDR_MEMORY_RESOURCE
+# endif
+#endif
+
 #include <cstddef>
 #if !defined(BOOST_NO_CXX17_HDR_STRING_VIEW)
 # include <string_view>

test/sv_find_first_not_of_test.cpp

@@ -494,7 +494,7 @@ int main()
 
         for( int i = 0; i < 256; ++i )
         {
-            str[ i ] = static_cast< unsigned char >( i );
+            str[ i ] = static_cast<char>( static_cast< unsigned char >( i ) );
         }
 
         boost::core::string_view sv( str, 256 );
@@ -503,22 +503,22 @@ int main()
 
         std::string str2( sv.data(), sv.size() );
 
-        for( int i = 0; i < 256; ++i )
+        for( std::size_t i = 0; i < 256; ++i )
         {
             std::string str3( str2 );
 
-            str3[ i ] = ~str3[ i ];
+            str3[ i ] = static_cast<char>( ~str3[ i ] );
 
             BOOST_TEST_EQ( sv.find_first_not_of( str3 ), i );
         }
 
         std::reverse( str, str + 256 );
 
-        for( int i = 0; i < 256; ++i )
+        for( std::size_t i = 0; i < 256; ++i )
         {
             std::string str3( str2 );
 
-            str3[ i ] = ~str3[ i ];
+            str3[ i ] = static_cast<char>( ~str3[ i ] );
 
             BOOST_TEST_EQ( sv.find_first_not_of( str3 ), 255 - i );
         }
@@ -538,22 +538,22 @@ int main()
 
         std::wstring str2( sv.data(), sv.size() );
 
-        for( int i = 0; i < 256; ++i )
+        for( std::size_t i = 0; i < 256; ++i )
         {
             std::wstring str3( str2 );
 
-            str3[ i ] = ~str3[ i ];
+            str3[ i ] = static_cast<wchar_t>( ~str3[ i ] );
 
             BOOST_TEST_EQ( sv.find_first_not_of( str3 ), i );
         }
 
         std::reverse( str, str + 256 );
 
-        for( int i = 0; i < 256; ++i )
+        for( std::size_t i = 0; i < 256; ++i )
         {
             std::wstring str3( str2 );
 
-            str3[ i ] = ~str3[ i ];
+            str3[ i ] = static_cast<wchar_t>( ~str3[ i ] );
 
             BOOST_TEST_EQ( sv.find_first_not_of( str3 ), 255 - i );
         }

test/sv_find_first_of_test.cpp

@@ -426,14 +426,14 @@ int main()
 
         for( int i = 0; i < 256; ++i )
         {
-            str[ i ] = static_cast< unsigned char >( i );
+            str[ i ] = static_cast<char>( static_cast< unsigned char >( i ) );
         }
 
         boost::core::string_view sv( str, 256 );
 
         for( int i = 0; i < 256; ++i )
         {
-            std::string needle( 12, static_cast< unsigned char >( i ) );
+            std::string needle( 12, static_cast<char>( static_cast< unsigned char >( i ) ) );
             BOOST_TEST_EQ( sv.find_first_of( needle ), i );
         }
 
@@ -441,7 +441,7 @@ int main()
 
         for( int i = 0; i < 256; ++i )
         {
-            std::string needle( 12, static_cast< unsigned char >( i ) );
+            std::string needle( 12, static_cast<char>( static_cast< unsigned char >( i ) ) );
             BOOST_TEST_EQ( sv.find_first_of( needle ), 255 - i );
         }
     }

test/sv_find_last_not_of_test.cpp

@@ -494,7 +494,7 @@ int main()
 
         for( int i = 0; i < 256; ++i )
         {
-            str[ i ] = static_cast< unsigned char >( i );
+            str[ i ] = static_cast<char>( static_cast< unsigned char >( i ) );
         }
 
         boost::core::string_view sv( str, 256 );
@@ -503,22 +503,22 @@ int main()
 
         std::string str2( sv.data(), sv.size() );
 
-        for( int i = 0; i < 256; ++i )
+        for( std::size_t i = 0; i < 256; ++i )
         {
             std::string str3( str2 );
 
-            str3[ i ] = ~str3[ i ];
+            str3[ i ] = static_cast<char>( ~str3[ i ] );
 
             BOOST_TEST_EQ( sv.find_last_not_of( str3 ), i );
         }
 
         std::reverse( str, str + 256 );
 
-        for( int i = 0; i < 256; ++i )
+        for( std::size_t i = 0; i < 256; ++i )
         {
             std::string str3( str2 );
 
-            str3[ i ] = ~str3[ i ];
+            str3[ i ] = static_cast<char>( ~str3[ i ] );
 
             BOOST_TEST_EQ( sv.find_last_not_of( str3 ), 255 - i );
         }
@@ -538,22 +538,22 @@ int main()
 
         std::wstring str2( sv.data(), sv.size() );
 
-        for( int i = 0; i < 256; ++i )
+        for( std::size_t i = 0; i < 256; ++i )
         {
             std::wstring str3( str2 );
 
-            str3[ i ] = ~str3[ i ];
+            str3[ i ] = static_cast<wchar_t>( ~str3[ i ] );
 
             BOOST_TEST_EQ( sv.find_first_not_of( str3 ), i );
         }
 
         std::reverse( str, str + 256 );
 
-        for( int i = 0; i < 256; ++i )
+        for( std::size_t i = 0; i < 256; ++i )
         {
             std::wstring str3( str2 );
 
-            str3[ i ] = ~str3[ i ];
+            str3[ i ] = static_cast<wchar_t>( ~str3[ i ] );
 
             BOOST_TEST_EQ( sv.find_first_not_of( str3 ), 255 - i );
         }

test/sv_find_last_of_test.cpp

@@ -444,14 +444,14 @@ int main()
 
         for( int i = 0; i < 256; ++i )
         {
-            str[ i ] = static_cast< unsigned char >( i );
+            str[ i ] = static_cast<char>( static_cast< unsigned char >( i ) );
         }
 
         boost::core::string_view sv( str, 256 );
 
         for( int i = 0; i < 256; ++i )
         {
-            std::string needle( 12, static_cast< unsigned char >( i ) );
+            std::string needle( 12, static_cast<char>( static_cast< unsigned char >( i ) ) );
             BOOST_TEST_EQ( sv.find_last_of( needle ), i );
         }
 
@@ -459,7 +459,7 @@ int main()
 
         for( int i = 0; i < 256; ++i )
         {
-            std::string needle( 12, static_cast< unsigned char >( i ) );
+            std::string needle( 12, static_cast<char>( static_cast< unsigned char >( i ) ) );
             BOOST_TEST_EQ( sv.find_last_of( needle ), 255 - i );
         }
     }

test/sv_lt_test.cpp

@@ -4,6 +4,18 @@
 
 #include <boost/core/detail/string_view.hpp>
 #include <boost/core/lightweight_test.hpp>
+#include <boost/config.hpp>
+
+#if !defined(BOOST_NO_CXX17_HDR_MEMORY_RESOURCE)
+# if defined(__apple_build_version__)
+// Under macOS, it's possible for the header
+// <memory_resource> to be present, but for
+// libc++.dylib to not have support for it.
+// https://github.com/boostorg/core/issues/162
+#  define BOOST_NO_CXX17_HDR_MEMORY_RESOURCE
+# endif
+#endif
+
 #include <cstddef>
 #if !defined(BOOST_NO_CXX17_HDR_STRING_VIEW)
 # include <string_view>

test/sv_types_test.cpp

@@ -7,10 +7,19 @@
 #include <boost/core/lightweight_test_trait.hpp>
 #include <iterator>
 
+#if defined(_LIBCPP_VERSION) && _LIBCPP_VERSION >= 160000
+
+// std::char_traits<Ch> is deprecated for non-char types
+typedef wchar_t Ch;
+
+#else
+
 struct Ch
 {
 };
 
+#endif
+
 int main()
 {
     typedef boost::core::basic_string_view<Ch> ch_string_view;

test/swap/Jamfile.v2

@@ -7,12 +7,8 @@
 # bring in rules for testing
 import testing ;
 
-compile swap_root_header_1.cpp ;
-compile swap_root_header_2.cpp ;
 compile swap_lib_header_1.cpp ;
 compile swap_lib_header_2.cpp ;
-compile swap_mixed_headers_1.cpp ;
-compile swap_mixed_headers_2.cpp ;
 compile swap_noexcept.cpp ;
 
 compile-fail swap_const_wrapper_fail.cpp ;

test/swap/swap_array_of_array_of_class.cpp

@@ -4,9 +4,9 @@
 // (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 
-// Tests swapping an array of arrays of swap_test_class objects by means of boost::swap.
+// Tests swapping an array of arrays of swap_test_class objects by means of boost::core::invoke_swap.
 
-#include <boost/utility/swap.hpp>
+#include <boost/core/invoke_swap.hpp>
 #include <boost/core/lightweight_test.hpp>
 #define BOOST_CHECK BOOST_TEST
 #define BOOST_CHECK_EQUAL BOOST_TEST_EQ
@@ -59,7 +59,7 @@ int main()
     ptr2[i].set_data( static_cast<int>(i + number_of_elements) );
   }
 
-  boost::swap(array1, array2);
+  boost::core::invoke_swap(array1, array2);
 
   for (std::size_t i = 0; i < number_of_elements; ++i)
   {

test/swap/swap_array_of_array_of_int.cpp

@@ -4,9 +4,9 @@
 // (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 
-// Tests swapping an array of arrays of integers by means of boost::swap.
+// Tests swapping an array of arrays of integers by means of boost::core::invoke_swap.
 
-#include <boost/utility/swap.hpp>
+#include <boost/core/invoke_swap.hpp>
 #include <boost/core/lightweight_test.hpp>
 #define BOOST_CHECK BOOST_TEST
 #define BOOST_CHECK_EQUAL BOOST_TEST_EQ
@@ -32,7 +32,7 @@ int main()
     ptr2[i] = static_cast<int>(i + number_of_elements);
   }
 
-  boost::swap(array1, array2);
+  boost::core::invoke_swap(array1, array2);
 
   for (std::size_t i = 0; i < number_of_elements; ++i)
   {

test/swap/swap_array_of_class.cpp

@@ -4,9 +4,9 @@
 // (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 
-// Tests swapping an array of arrays of swap_test_class objects by means of boost::swap.
+// Tests swapping an array of arrays of swap_test_class objects by means of boost::core::invoke_swap.
 
-#include <boost/utility/swap.hpp>
+#include <boost/core/invoke_swap.hpp>
 #include <boost/core/lightweight_test.hpp>
 #define BOOST_CHECK BOOST_TEST
 #define BOOST_CHECK_EQUAL BOOST_TEST_EQ
@@ -54,7 +54,7 @@ int main()
   std::copy(initial_array2, initial_array2 + array_size, array2);
 
   swap_test_class::reset();
-  boost::swap(array1, array2);
+  boost::core::invoke_swap(array1, array2);
 
   BOOST_CHECK(std::equal(array1, array1 + array_size, initial_array2));
   BOOST_CHECK(std::equal(array2, array2 + array_size, initial_array1));

test/swap/swap_array_of_int.cpp

@@ -4,9 +4,9 @@
 // (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 
-// Tests swapping an array of integers by means of boost::swap.
+// Tests swapping an array of integers by means of boost::core::invoke_swap.
 
-#include <boost/utility/swap.hpp>
+#include <boost/core/invoke_swap.hpp>
 #include <boost/core/lightweight_test.hpp>
 #define BOOST_CHECK BOOST_TEST
 #define BOOST_CHECK_EQUAL BOOST_TEST_EQ
@@ -27,7 +27,7 @@ int main()
   std::copy(initial_array1, initial_array1 + array_size, array1);
   std::copy(initial_array2, initial_array2 + array_size, array2);
 
-  boost::swap(array1, array2);
+  boost::core::invoke_swap(array1, array2);
 
   BOOST_CHECK(std::equal(array1, array1 + array_size, initial_array2));
   BOOST_CHECK(std::equal(array2, array2 + array_size, initial_array1));

test/swap/swap_array_of_template.cpp

@@ -4,9 +4,9 @@
 // (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 
-// Tests swapping an array of swap_test_template<int> objects by means of boost::swap.
+// Tests swapping an array of swap_test_template<int> objects by means of boost::core::invoke_swap.
 
-#include <boost/utility/swap.hpp>
+#include <boost/core/invoke_swap.hpp>
 #include <boost/core/lightweight_test.hpp>
 #define BOOST_CHECK BOOST_TEST
 #define BOOST_CHECK_EQUAL BOOST_TEST_EQ
@@ -60,7 +60,7 @@ int main()
   std::copy(initial_array2, initial_array2 + array_size, array2);
 
   swap_test_class::reset();
-  boost::swap(array1, array2);
+  boost::core::invoke_swap(array1, array2);
 
   BOOST_CHECK(std::equal(array1, array1 + array_size, initial_array2));
   BOOST_CHECK(std::equal(array2, array2 + array_size, initial_array1));

test/swap/swap_const_wrapper_fail.cpp

@@ -1,8 +1,8 @@
-// Copyright 2018 Andrzej Krzemieński
+// Copyright 2018 Andrzej Krzemieński
 // Copyright 2018 Peter Dimov
 // Distributed under the Boost Software License, Version 1.0.
 
-#include <boost/core/swap.hpp>
+#include <boost/core/invoke_swap.hpp>
 
 namespace boost
 {
@@ -14,7 +14,7 @@ template<class T> struct Wrapper
 
 template<class T> inline void swap( Wrapper<T> & w, Wrapper<T> & v )
 {
-    boost::swap( w, v );
+    boost::core::invoke_swap( w, v );
 }
 
 } // namespace boost

test/swap/swap_lib_header_1.cpp

@@ -6,5 +6,5 @@
 
 // Tests that the swap header compiles as a standalone translation unit
 
-#include <boost/utility/swap.hpp>
+#include <boost/core/invoke_swap.hpp>
 

test/swap/swap_lib_header_2.cpp

@@ -6,6 +6,6 @@
 
 // Tests that the swap header include guards work correctly
 
-#include <boost/utility/swap.hpp>
-#include <boost/utility/swap.hpp>
+#include <boost/core/invoke_swap.hpp>
+#include <boost/core/invoke_swap.hpp>
 

test/swap/swap_mixed_headers_1.cpp

@@ -1,11 +0,0 @@
-// Copyright (c) 2007 Joseph Gauterin
-//
-// 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)
-
-// Tests that the swap headers work when both are included
-
-#include <boost/swap.hpp>
-#include <boost/utility/swap.hpp>
-

test/swap/swap_mixed_headers_2.cpp

@@ -1,12 +0,0 @@
-// Copyright (c) 2007 Joseph Gauterin
-//
-// 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)
-
-// Tests that the swap headers work when both are included
-
-#include <boost/utility/swap.hpp>
-#include <boost/swap.hpp>
-
-

test/swap/swap_no_ambiguity_in_boost.cpp

@@ -4,15 +4,15 @@
 // (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 
-// boost::swap internally does an unqualified function call to swap.
+// boost::core::invoke_swap internally does an unqualified function call to swap.
 // This could have led to ambiguity or infinite recursion, when the
 // objects to be swapped would themselves be from the boost namespace.
-// If so, boost::swap itself might be found by argument dependent lookup.
-// The implementation of boost::swap resolves this issue by giving
-// boost::swap two template argumetns, thereby making it less specialized
+// If so, boost::core::invoke_swap itself might be found by argument dependent lookup.
+// The implementation of boost::core::invoke_swap resolves this issue by giving
+// boost::core::invoke_swap two template argumetns, thereby making it less specialized
 // than std::swap.
 
-#include <boost/utility/swap.hpp>
+#include <boost/core/invoke_swap.hpp>
 #include <boost/core/lightweight_test.hpp>
 #define BOOST_CHECK BOOST_TEST
 #define BOOST_CHECK_EQUAL BOOST_TEST_EQ
@@ -33,7 +33,7 @@ int main()
   boost::swap_test_class object2 = initial_value2;
 
   boost::swap_test_class::reset();
-  boost::swap(object1,object2);
+  boost::core::invoke_swap(object1,object2);
 
   BOOST_CHECK(object1 == initial_value2);
   BOOST_CHECK(object2 == initial_value1);

test/swap/swap_noexcept.cpp

@@ -4,9 +4,9 @@
 // (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 
-// Tests that boost::swap propagates noexcept specification correctly
+// Tests that boost::core::invoke_swap propagates noexcept specification correctly
 
-#include <boost/core/swap.hpp>
+#include <boost/core/invoke_swap.hpp>
 #include <boost/config.hpp>
 
 #if !defined(BOOST_NO_CXX11_NOEXCEPT) && !defined(BOOST_NO_CXX11_STATIC_ASSERT) && \
@@ -34,9 +34,9 @@ struct class_with_except_swap
 
 } // namespace test_ns
 
-static_assert(noexcept(boost::swap(test_ns::class_with_noexcept_swap::instance(), test_ns::class_with_noexcept_swap::instance())),
-    "boost::swap for class_with_noexcept_swap should have noexcept specification");
-static_assert(!noexcept(boost::swap(test_ns::class_with_except_swap::instance(), test_ns::class_with_except_swap::instance())),
-    "boost::swap for class_with_except_swap should not have noexcept specification");
+static_assert(noexcept(boost::core::invoke_swap(test_ns::class_with_noexcept_swap::instance(), test_ns::class_with_noexcept_swap::instance())),
+    "boost::core::invoke_swap for class_with_noexcept_swap should have noexcept specification");
+static_assert(!noexcept(boost::core::invoke_swap(test_ns::class_with_except_swap::instance(), test_ns::class_with_except_swap::instance())),
+    "boost::core::invoke_swap for class_with_except_swap should not have noexcept specification");
 
 #endif // !defined(BOOST_NO_CXX11_NOEXCEPT) && !defined(BOOST_NO_CXX11_STATIC_ASSERT) ...

test/swap/swap_primitive.cpp

@@ -4,7 +4,7 @@
 // (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 
-#include <boost/utility/swap.hpp>
+#include <boost/core/invoke_swap.hpp>
 #include <boost/core/lightweight_test.hpp>
 #define BOOST_CHECK BOOST_TEST
 #define BOOST_CHECK_EQUAL BOOST_TEST_EQ
@@ -14,7 +14,7 @@ int main()
   int object1 = 1;
   int object2 = 2;
 
-  boost::swap(object1,object2);
+  boost::core::invoke_swap(object1,object2);
 
   BOOST_CHECK_EQUAL(object1,2);
   BOOST_CHECK_EQUAL(object2,1);

test/swap/swap_root_header_1.cpp

@@ -1,10 +0,0 @@
-// Copyright (c) 2007 Joseph Gauterin
-//
-// 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)
-
-// Tests that the swap header compiles as a standalone translation unit
-
-#include <boost/swap.hpp>
-

test/swap/swap_root_header_2.cpp

@@ -1,11 +0,0 @@
-// Copyright (c) 2007 Joseph Gauterin
-//
-// 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)
-
-// Tests that the swap header include guards work correctly
-
-#include <boost/swap.hpp>
-#include <boost/swap.hpp>
-

test/swap/swap_specialized_in_boost.cpp

@@ -4,7 +4,7 @@
 // (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 
-#include <boost/utility/swap.hpp>
+#include <boost/core/invoke_swap.hpp>
 #include <boost/core/lightweight_test.hpp>
 #define BOOST_CHECK BOOST_TEST
 #define BOOST_CHECK_EQUAL BOOST_TEST_EQ
@@ -33,7 +33,7 @@ int main()
   boost::swap_test_class object2 = initial_value2;
 
   boost::swap_test_class::reset();
-  boost::swap(object1,object2);
+  boost::core::invoke_swap(object1,object2);
 
   BOOST_CHECK(object1 == initial_value2);
   BOOST_CHECK(object2 == initial_value1);

test/swap/swap_specialized_in_boost_and_other.cpp

@@ -8,13 +8,13 @@
 // properly swapped, when both boost and the other namespace have a custom
 // swap function for that class. Note that it shouldn't be necessary for a class
 // in an other namespace to have a custom swap function in boost, because the
-// boost::swap utility should find the swap function in the other namespace, by
-// argument dependent lookup (ADL). Unfortunately ADL isn't fully implemented
-// by some specific compiler versions, including Intel C++ 8.1, MSVC 7.1, and
-// Borland 5.9.3. Users of those compilers might consider adding a swap overload
+// boost::core::invoke_swap utility should find the swap function in the other
+// namespace, by argument dependent lookup (ADL). Unfortunately ADL isn't fully
+// implemented by some specific compiler versions, including Intel C++ 8.1, MSVC 7.1,
+// and Borland 5.9.3. Users of those compilers might consider adding a swap overload
 // to the boost namespace.
 
-#include <boost/utility/swap.hpp>
+#include <boost/core/invoke_swap.hpp>
 #include <boost/core/lightweight_test.hpp>
 #define BOOST_CHECK BOOST_TEST
 #define BOOST_CHECK_EQUAL BOOST_TEST_EQ
@@ -52,7 +52,7 @@ int main()
   other::swap_test_class object2 = initial_value2;
 
   other::swap_test_class::reset();
-  boost::swap(object1,object2);
+  boost::core::invoke_swap(object1,object2);
 
   BOOST_CHECK(object1 == initial_value2);
   BOOST_CHECK(object2 == initial_value1);

test/swap/swap_specialized_in_global.cpp

@@ -4,7 +4,7 @@
 // (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 
-#include <boost/utility/swap.hpp>
+#include <boost/core/invoke_swap.hpp>
 #include <boost/core/lightweight_test.hpp>
 #define BOOST_CHECK BOOST_TEST
 #define BOOST_CHECK_EQUAL BOOST_TEST_EQ
@@ -27,7 +27,7 @@ int main()
   swap_test_class object2 = initial_value2;
 
   swap_test_class::reset();
-  boost::swap(object1,object2);
+  boost::core::invoke_swap(object1,object2);
 
   BOOST_CHECK(object1 == initial_value2);
   BOOST_CHECK(object2 == initial_value1);

test/swap/swap_specialized_in_other.cpp

@@ -4,7 +4,7 @@
 // (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 
-#include <boost/utility/swap.hpp>
+#include <boost/core/invoke_swap.hpp>
 #include <boost/core/lightweight_test.hpp>
 #define BOOST_CHECK BOOST_TEST
 #define BOOST_CHECK_EQUAL BOOST_TEST_EQ
@@ -33,7 +33,7 @@ int main()
   other::swap_test_class object2 = initial_value2;
 
   other::swap_test_class::reset();
-  boost::swap(object1,object2);
+  boost::core::invoke_swap(object1,object2);
 
   BOOST_CHECK(object1 == initial_value2);
   BOOST_CHECK(object2 == initial_value1);

test/swap/swap_specialized_in_std.cpp

@@ -4,7 +4,7 @@
 // (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 
-#include <boost/utility/swap.hpp>
+#include <boost/core/invoke_swap.hpp>
 #include <boost/core/lightweight_test.hpp>
 #define BOOST_CHECK BOOST_TEST
 #define BOOST_CHECK_EQUAL BOOST_TEST_EQ
@@ -32,7 +32,7 @@ int main()
   swap_test_class object2 = initial_value2;
 
   swap_test_class::reset();
-  boost::swap(object1,object2);
+  boost::core::invoke_swap(object1,object2);
 
   BOOST_CHECK(object1 == initial_value2);
   BOOST_CHECK(object2 == initial_value1);

test/swap/swap_std_bitset.cpp

@@ -4,11 +4,11 @@
 // (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 
-// Tests swapping std::bitset<T> objects by means of boost::swap.
+// Tests swapping std::bitset<T> objects by means of boost::core::invoke_swap.
 // Unlike most other Standard C++ Library template classes,
 // std::bitset<T> does not have its own std::swap overload.
 
-#include <boost/utility/swap.hpp>
+#include <boost/core/invoke_swap.hpp>
 #include <boost/core/lightweight_test.hpp>
 #define BOOST_CHECK BOOST_TEST
 #define BOOST_CHECK_EQUAL BOOST_TEST_EQ
@@ -24,7 +24,7 @@ int main()
   bitset_type object1 = initial_value1;
   bitset_type object2 = initial_value2;
 
-  boost::swap(object1,object2);
+  boost::core::invoke_swap(object1,object2);
 
   BOOST_CHECK_EQUAL(object1,initial_value2);
   BOOST_CHECK_EQUAL(object2,initial_value1);

test/swap/swap_std_dateorder.cpp

@@ -4,11 +4,11 @@
 // (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 
-// Tests swapping std::time_base::dateorder objects by means of boost::swap.
+// Tests swapping std::time_base::dateorder objects by means of boost::core::invoke_swap.
 // std::time_base::dateorder is an enumerated type. It does not have an
 // std::swap overload or template specialization.
 
-#include <boost/utility/swap.hpp>
+#include <boost/core/invoke_swap.hpp>
 #include <boost/core/lightweight_test.hpp>
 #define BOOST_CHECK BOOST_TEST
 #define BOOST_CHECK_EQUAL BOOST_TEST_EQ
@@ -23,7 +23,7 @@ int main()
   std::time_base::dateorder object1 = initial_value1;
   std::time_base::dateorder object2 = initial_value2;
 
-  boost::swap(object1,object2);
+  boost::core::invoke_swap(object1,object2);
 
   BOOST_CHECK_EQUAL(object1,initial_value2);
   BOOST_CHECK_EQUAL(object2,initial_value1);

test/swap/swap_std_string.cpp

@@ -4,10 +4,10 @@
 // (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 
-// Tests swapping std::string objects by means of boost::swap.
+// Tests swapping std::string objects by means of boost::core::invoke_swap.
 // std::string has its own std::swap overload.
 
-#include <boost/utility/swap.hpp>
+#include <boost/core/invoke_swap.hpp>
 #include <boost/core/lightweight_test.hpp>
 #define BOOST_CHECK BOOST_TEST
 #define BOOST_CHECK_EQUAL BOOST_TEST_EQ
@@ -22,7 +22,7 @@ int main()
   std::string object1 = initial_value1;
   std::string object2 = initial_value2;
 
-  boost::swap(object1,object2);
+  boost::core::invoke_swap(object1,object2);
 
   BOOST_CHECK_EQUAL(object1,initial_value2);
   BOOST_CHECK_EQUAL(object2,initial_value1);

test/swap/swap_std_typeinfo_ptr.cpp

@@ -4,11 +4,11 @@
 // (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 
-// Tests swapping std::type_info pointers by means of boost::swap.
+// Tests swapping std::type_info pointers by means of boost::core::invoke_swap.
 // There is no std::swap overload or template specialization
 // for std::type_info pointers.
 
-#include <boost/utility/swap.hpp>
+#include <boost/core/invoke_swap.hpp>
 #include <boost/core/lightweight_test.hpp>
 #define BOOST_CHECK BOOST_TEST
 #define BOOST_CHECK_EQUAL BOOST_TEST_EQ
@@ -23,7 +23,7 @@ int main()
   const std::type_info * ptr1 = initial_value1;
   const std::type_info * ptr2 = initial_value2;
 
-  boost::swap(ptr1,ptr2);
+  boost::core::invoke_swap(ptr1,ptr2);
 
   BOOST_CHECK_EQUAL(ptr1,initial_value2);
   BOOST_CHECK_EQUAL(ptr2,initial_value1);