Update dependencies

.travis.yml

@@ -1,16 +1,19 @@
-# Copyright 2016-2019 Peter Dimov
+# Copyright 2016 Peter Dimov
 # Distributed under the Boost Software License, Version 1.0.
 # (See accompanying file LICENSE_1_0.txt or copy at http://boost.org/LICENSE_1_0.txt)
 
 language: cpp
 
-dist: xenial
+sudo: false
+
+os:
+  - linux
+  - osx
 
 branches:
   only:
     - master
     - develop
-    - /feature\/.*/
 
 env:
   matrix:
@@ -23,32 +26,10 @@ matrix:
 
   include:
     - os: linux
-      compiler: g++
-      env: TOOLSET=gcc COMPILER=g++ CXXSTD=03,11
+      env: TOOLSET=gcc COMPILER=g++ CXXSTD=c++03
 
     - os: linux
-      compiler: g++-4.4
-      env: TOOLSET=gcc COMPILER=g++-4.4 CXXSTD=98,0x
-      addons:
-        apt:
-          packages:
-            - g++-4.4
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: g++-4.6
-      env: TOOLSET=gcc COMPILER=g++-4.6 CXXSTD=03,0x
-      addons:
-        apt:
-          packages:
-            - g++-4.6
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: g++-4.7
-      env: TOOLSET=gcc COMPILER=g++-4.7 CXXSTD=03,11
+      env: TOOLSET=gcc COMPILER=g++-4.7 CXXSTD=c++03
       addons:
         apt:
           packages:
@@ -57,8 +38,16 @@ matrix:
             - ubuntu-toolchain-r-test
 
     - os: linux
-      compiler: g++-4.8
-      env: TOOLSET=gcc COMPILER=g++-4.8 CXXSTD=03,11
+      env: TOOLSET=gcc COMPILER=g++-4.7 CXXSTD=c++11
+      addons:
+        apt:
+          packages:
+            - g++-4.7
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      env: TOOLSET=gcc COMPILER=g++-4.8 CXXSTD=c++03
       addons:
         apt:
           packages:
@@ -67,8 +56,16 @@ matrix:
             - ubuntu-toolchain-r-test
 
     - os: linux
-      compiler: g++-4.9
-      env: TOOLSET=gcc COMPILER=g++-4.9 CXXSTD=03,11
+      env: TOOLSET=gcc COMPILER=g++-4.8 CXXSTD=c++11
+      addons:
+        apt:
+          packages:
+            - g++-4.8
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      env: TOOLSET=gcc COMPILER=g++-4.9 CXXSTD=c++03
       addons:
         apt:
           packages:
@@ -77,8 +74,16 @@ matrix:
             - ubuntu-toolchain-r-test
 
     - os: linux
-      compiler: g++-5
-      env: TOOLSET=gcc COMPILER=g++-5 CXXSTD=03,11,14,1z
+      env: TOOLSET=gcc COMPILER=g++-4.9 CXXSTD=c++11
+      addons:
+        apt:
+          packages:
+            - g++-4.9
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      env: TOOLSET=gcc COMPILER=g++-5 CXXSTD=c++03
       addons:
         apt:
           packages:
@@ -87,8 +92,25 @@ matrix:
             - ubuntu-toolchain-r-test
 
     - os: linux
-      compiler: g++-6
-      env: TOOLSET=gcc COMPILER=g++-6 CXXSTD=03,11,14,1z
+      env: TOOLSET=gcc COMPILER=g++-5 CXXSTD=c++11
+      addons:
+        apt:
+          packages:
+            - g++-5
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      env: TOOLSET=gcc COMPILER=g++-5 CXXSTD=c++14
+      addons:
+        apt:
+          packages:
+            - g++-5
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      env: TOOLSET=gcc COMPILER=g++-6 CXXSTD=c++03
       addons:
         apt:
           packages:
@@ -97,315 +119,146 @@ matrix:
             - ubuntu-toolchain-r-test
 
     - os: linux
-      compiler: g++-7
-      env: TOOLSET=gcc COMPILER=g++-7 CXXSTD=03,11,14,17
+      env: TOOLSET=gcc COMPILER=g++-6 CXXSTD=c++11
       addons:
         apt:
           packages:
-            - g++-7
+            - g++-6
           sources:
             - ubuntu-toolchain-r-test
 
     - os: linux
-      compiler: g++-8
-      env: TOOLSET=gcc COMPILER=g++-8 CXXSTD=03,11,14,17
+      env: TOOLSET=gcc COMPILER=g++-6 CXXSTD=c++14
       addons:
         apt:
           packages:
-            - g++-8
+            - g++-6
           sources:
             - ubuntu-toolchain-r-test
 
     - os: linux
-      compiler: g++-9
-      env: TOOLSET=gcc COMPILER=g++-9 CXXSTD=03,11,14,17,2a
+      env: TOOLSET=gcc COMPILER=g++-6 CXXSTD=c++1z
       addons:
         apt:
           packages:
-            - g++-9
+            - g++-6
           sources:
             - ubuntu-toolchain-r-test
 
     - os: linux
-      dist: bionic
-      compiler: g++-10
-      env: TOOLSET=gcc COMPILER=g++-10 CXXSTD=03,11,14,17,20
-      addons:
-        apt:
-          packages:
-            - g++-10
-          sources:
-            - sourceline: "ppa:ubuntu-toolchain-r/test"
+      env: TOOLSET=clang COMPILER=clang++ CXXSTD=c++03
 
     - os: linux
-      dist: bionic
-      compiler: g++-10
-      env: UBSAN=1 TOOLSET=gcc COMPILER=g++-10 CXXSTD=03,11,14,17,20 UBSAN_OPTIONS=print_stacktrace=1 LINKFLAGS=-fuse-ld=gold
-      addons:
-        apt:
-          packages:
-            - g++-10
-          sources:
-            - sourceline: "ppa:ubuntu-toolchain-r/test"
+      env: TOOLSET=clang COMPILER=clang++ CXXSTD=c++11
 
     - os: linux
-      compiler: clang++
-      env: TOOLSET=clang COMPILER=clang++ CXXSTD=03,11
-
-    - os: linux
-      dist: trusty
-      compiler: /usr/bin/clang++
-      env: TOOLSET=clang COMPILER=/usr/bin/clang++ CXXSTD=03,11
-      addons:
-        apt:
-          packages:
-            - clang-3.3
-
-    - os: linux
-      dist: trusty
-      compiler: /usr/bin/clang++
-      env: TOOLSET=clang COMPILER=/usr/bin/clang++ CXXSTD=03,11
-      addons:
-        apt:
-          packages:
-            - clang-3.4
-
-    - os: linux
-      dist: trusty
-      compiler: clang++-3.5
-      env: TOOLSET=clang COMPILER=clang++-3.5 CXXSTD=03,11
-      addons:
-        apt:
-          packages:
-            - clang-3.5
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: clang++-3.6
-      env: TOOLSET=clang COMPILER=clang++-3.6 CXXSTD=03,11,14,1z
+      env: TOOLSET=clang COMPILER=clang++-3.6 CXXSTD=c++03
       addons:
         apt:
           packages:
             - clang-3.6
           sources:
             - ubuntu-toolchain-r-test
+            - llvm-toolchain-precise-3.6
 
     - os: linux
-      compiler: clang++-3.7
-      env: TOOLSET=clang COMPILER=clang++-3.7 CXXSTD=03,11,14,1z
+      env: TOOLSET=clang COMPILER=clang++-3.6 CXXSTD=c++11
+      addons:
+        apt:
+          packages:
+            - clang-3.6
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-precise-3.6
+
+    - os: linux
+      env: TOOLSET=clang COMPILER=clang++-3.7 CXXSTD=c++03
       addons:
         apt:
           packages:
             - clang-3.7
           sources:
             - ubuntu-toolchain-r-test
+            - llvm-toolchain-precise-3.7
 
     - os: linux
-      compiler: clang++-3.8
-      env: TOOLSET=clang COMPILER=clang++-3.8 CXXSTD=03,11,14,1z
+      env: TOOLSET=clang COMPILER=clang++-3.7 CXXSTD=c++11
+      addons:
+        apt:
+          packages:
+            - clang-3.7
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-precise-3.7
+
+    - os: linux
+      env: TOOLSET=clang COMPILER=clang++-3.8 CXXSTD=c++03
       addons:
         apt:
           packages:
             - clang-3.8
           sources:
             - ubuntu-toolchain-r-test
+            - llvm-toolchain-precise-3.8
 
     - os: linux
-      compiler: clang++-3.9
-      env: TOOLSET=clang COMPILER=clang++-3.9 CXXSTD=03,11,14,1z
+      env: TOOLSET=clang COMPILER=clang++-3.8 CXXSTD=c++11
       addons:
         apt:
           packages:
-            - clang-3.9
+            - clang-3.8
           sources:
             - ubuntu-toolchain-r-test
+            - llvm-toolchain-precise-3.8
 
     - os: linux
-      compiler: clang++-4.0
-      env: TOOLSET=clang COMPILER=clang++-4.0 CXXSTD=03,11,14,1z
+      env: TOOLSET=clang COMPILER=clang++-3.8 CXXSTD=c++14
       addons:
         apt:
           packages:
-            - clang-4.0
+            - clang-3.8
           sources:
             - ubuntu-toolchain-r-test
+            - llvm-toolchain-precise-3.8
 
     - os: linux
-      compiler: clang++-5.0
-      env: TOOLSET=clang COMPILER=clang++-5.0 CXXSTD=03,11,14,1z
+      env: TOOLSET=clang COMPILER=clang++-3.8 CXXSTD=c++1z
       addons:
         apt:
           packages:
-            - clang-5.0
+            - clang-3.8
           sources:
             - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: clang++-6.0
-      env: TOOLSET=clang COMPILER=clang++-6.0 CXXSTD=03,11,14,17
-      addons:
-        apt:
-          packages:
-            - clang-6.0
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: clang++-7
-      env: TOOLSET=clang COMPILER=clang++-7 CXXSTD=03,11,14,17
-      addons:
-        apt:
-          packages:
-            - clang-7
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-xenial-7
-
-    - os: linux
-      compiler: clang++-8
-      env: TOOLSET=clang COMPILER=clang++-8 CXXSTD=03,11,14,17,2a
-      addons:
-        apt:
-          packages:
-            - clang-8
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-xenial-8
-
-    - os: linux
-      compiler: clang++-9
-      env: TOOLSET=clang COMPILER=clang++-9 CXXSTD=03,11,14,17,2a
-      addons:
-        apt:
-          packages:
-            - clang-9
-          sources:
-            - ubuntu-toolchain-r-test
-            - sourceline: 'deb https://apt.llvm.org/xenial/ llvm-toolchain-xenial-9 main'
-              key_url: 'https://apt.llvm.org/llvm-snapshot.gpg.key'
-
-    - os: linux
-      compiler: clang++-10
-      env: TOOLSET=clang COMPILER=clang++-10 CXXSTD=03,11,14,17,20
-      addons:
-        apt:
-          packages:
-            - clang-10
-          sources:
-            - ubuntu-toolchain-r-test
-            - sourceline: 'deb https://apt.llvm.org/xenial/ llvm-toolchain-xenial-10 main'
-              key_url: 'https://apt.llvm.org/llvm-snapshot.gpg.key'
-
-    - os: linux
-      compiler: clang++-10
-      env: UBSAN=1 TOOLSET=clang COMPILER=clang++-10 CXXSTD=03,11,14,17,20 UBSAN_OPTIONS=print_stacktrace=1
-      addons:
-        apt:
-          packages:
-            - clang-10
-          sources:
-            - ubuntu-toolchain-r-test
-            - sourceline: 'deb https://apt.llvm.org/xenial/ llvm-toolchain-xenial-10 main'
-              key_url: 'https://apt.llvm.org/llvm-snapshot.gpg.key'
-
-    - os: linux
-      dist: trusty
-      compiler: clang++-libc++
-      env: TOOLSET=clang COMPILER=clang++-libc++ CXXSTD=03,11,14,1z
-      addons:
-        apt:
-          packages:
-            - libc++-dev
-            - libc++abi-dev
-
-    - os: linux
-      dist: trusty
-      compiler: clang++-libc++
-      env: UBSAN=1 TOOLSET=clang COMPILER=clang++-libc++ CXXSTD=03,11,14,1z UBSAN_OPTIONS=print_stacktrace=1
-      addons:
-        apt:
-          packages:
-            - libc++-dev
-            - libc++abi-dev
+            - llvm-toolchain-precise-3.8
 
     - os: osx
-      compiler: clang++
-      env: TOOLSET=clang COMPILER=clang++ CXXSTD=03,11,14,1z
-      osx_image: xcode7.3
+      env: TOOLSET=clang COMPILER=clang++ CXXSTD=c++03
 
     - os: osx
-      compiler: clang++
-      env: TOOLSET=clang COMPILER=clang++ CXXSTD=03,11,14,1z
-      osx_image: xcode8.3
+      env: TOOLSET=clang COMPILER=clang++ CXXSTD=c++11
 
     - os: osx
-      compiler: clang++
-      env: TOOLSET=clang COMPILER=clang++ CXXSTD=03,11,14,1z
-      osx_image: xcode9.4
-
-    - os: osx
-      compiler: clang++
-      env: TOOLSET=clang COMPILER=clang++ CXXSTD=03,11,14,1z
-      osx_image: xcode10.1
-
-    - os: linux
-      env: CMAKE_TEST=1
-      script:
-        - mkdir __build__ && cd __build__
-        - cmake -DBOOST_ENABLE_CMAKE=1 -DBoost_VERBOSE=1 -DBOOST_INCLUDE_LIBRARIES=core ..
-        - ctest --output-on-failure -R boost_core
-
-    - os: linux
-      env: CMAKE_SUBDIR_TEST=1
-      install:
-        - BOOST_BRANCH=develop
-        - if [ "$TRAVIS_BRANCH" = "master" ]; then BOOST_BRANCH=master; fi
-        - git clone -b $BOOST_BRANCH https://github.com/boostorg/config.git ../config
-        - git clone -b $BOOST_BRANCH https://github.com/boostorg/assert.git ../assert
-      script:
-      - cd test/cmake_subdir_test && mkdir __build__ && cd __build__
-      - cmake ..
-      - cmake --build .
-      - cmake --build . --target check
-
-    - os: linux
-      env: CMAKE_INSTALL_TEST=1
-      script:
-        - mkdir __build__ && cd __build__
-        - cmake -DBOOST_ENABLE_CMAKE=1 -DBoost_VERBOSE=1 -DBOOST_INCLUDE_LIBRARIES="assert;config;core" -DCMAKE_INSTALL_PREFIX=~/.local ..
-        - cmake --build . --target install
-        - cd ../libs/core/test/cmake_install_test && mkdir __build__ && cd __build__
-        - cmake -DCMAKE_INSTALL_PREFIX=~/.local ..
-        - cmake --build .
-        - cmake --build . --target check
+      env: TOOLSET=clang COMPILER=clang++ CXXSTD=c++14
 
 install:
-  - BOOST_BRANCH=develop
-  - if [ "$TRAVIS_BRANCH" = "master" ]; then BOOST_BRANCH=master; fi
   - cd ..
-  - git clone -b $BOOST_BRANCH https://github.com/boostorg/boost.git boost-root
+  - git clone -b $TRAVIS_BRANCH https://github.com/boostorg/boost.git boost-root
   - cd boost-root
-  - git submodule init libs/headers
   - git submodule init libs/assert
   - git submodule init libs/config
   - git submodule init libs/predef
   - git submodule init libs/static_assert
-  - git submodule init libs/throw_exception
   - git submodule init libs/type_traits
   - git submodule init tools/build
-  - git submodule init tools/boost_install
-  - git submodule init tools/cmake
-  - git submodule update --jobs 4
+  - git submodule update
   - cp -r $TRAVIS_BUILD_DIR/* libs/core
   - ./bootstrap.sh
   - ./b2 headers
 
 script:
   - |-
-    echo "using $TOOLSET : : $COMPILER ;" > ~/user-config.jam
-  - BUILD_JOBS=`(nproc || sysctl -n hw.ncpu) 2> /dev/null`
-  - ./b2 -j $BUILD_JOBS libs/core/test toolset=$TOOLSET cxxstd=$CXXSTD variant=debug,release ${UBSAN:+cxxflags=-fsanitize=undefined cxxflags=-fno-sanitize-recover=undefined linkflags=-fsanitize=undefined define=UBSAN=1 debug-symbols=on} ${LINKFLAGS:+linkflags=$LINKFLAGS}
+    echo "using $TOOLSET : : $COMPILER : <cxxflags>-std=$CXXSTD ;" > ~/user-config.jam
+  - ./b2 libs/core/test toolset=$TOOLSET
 
 notifications:
   email:

CMakeLists.txt

@@ -1,31 +1,8 @@
-# Copyright 2018, 2019 Peter Dimov
-# Distributed under the Boost Software License, Version 1.0.
-# See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt
+cmake_minimum_required(VERSION 3.5)
 
-cmake_minimum_required(VERSION 3.5...3.16)
+include(cmake/BoostVersion.cmake)
+set(BOOST_PROJECT_NAME core)
 
-project(boost_core VERSION "${BOOST_SUPERPROJECT_VERSION}" LANGUAGES CXX)
+project(boost_${BOOST_PROJECT_NAME} VERSION ${BOOST_VERSION} LANGUAGES CXX)
 
-add_library(boost_core INTERFACE)
-add_library(Boost::core ALIAS boost_core)
-
-target_include_directories(boost_core INTERFACE include)
-
-target_link_libraries(boost_core
-  INTERFACE
-    Boost::assert
-    Boost::config
-)
-
-if(BOOST_SUPERPROJECT_VERSION)
-
-  include(BoostInstall)
-  boost_install(TARGETS boost_core HEADER_DIRECTORY include/)
-
-endif()
-
-if(BUILD_TESTING)
-
-  add_subdirectory(test)
-
-endif()
+include(cmake/default.cmake)

README.md

@@ -1,7 +1,7 @@
 Boost.Core
 ==========
 
-Boost.Core, part of collection of the [Boost C++ Libraries](https://github.com/boostorg), is a collection of core utilities used by other Boost libraries.
+Boost.Core, part of collection of the [Boost C++ Libraries](http://github.com/boostorg), is a collection of core utilities used by other Boost libraries.
 The criteria for inclusion is that the utility component be:
 
 * simple,
@@ -23,10 +23,10 @@ Master   | [![Build Status](https://travis-ci.org/boostorg/core.svg?branch=maste
 
 ### More information
 
-* [Documentation](https://boost.org/libs/core)
+* [Documentation](http://boost.org/libs/core)
 * [Report bugs](https://svn.boost.org/trac/boost/newticket?component=core;version=Boost%20Release%20Branch). Be sure to mention Boost version, platform and compiler you're using. A small compilable code sample to reproduce the problem is always good as well.
-* Submit your patches as pull requests against **develop** branch. Note that by submitting patches you agree to license your modifications under the [Boost Software License, Version 1.0](https://www.boost.org/LICENSE_1_0.txt).
+* Submit your patches as pull requests against **develop** branch. Note that by submitting patches you agree to license your modifications under the [Boost Software License, Version 1.0](http://www.boost.org/LICENSE_1_0.txt).
 
 ### License
 
-Distributed under the [Boost Software License, Version 1.0](https://boost.org/LICENSE_1_0.txt).
+Distributed under the [Boost Software License, Version 1.0](http://boost.org/LICENSE_1_0.txt).

appveyor.yml

@@ -1,4 +1,4 @@
-# Copyright 2016-2019 Peter Dimov
+# Copyright 2016 Peter Dimov
 # Distributed under the Boost Software License, Version 1.0.
 # (See accompanying file LICENSE_1_0.txt or copy at http://boost.org/LICENSE_1_0.txt)
 
@@ -10,83 +10,23 @@ branches:
   only:
     - master
     - develop
-    - /feature\/.*/
-
-environment:
-  matrix:
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
-      TOOLSET: msvc-9.0,msvc-10.0,msvc-11.0
-
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
-      TOOLSET: msvc-12.0,msvc-14.0
-      ADDRMD: 32,64
-
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
-      TOOLSET: msvc-14.1
-      ADDRMD: 32,64
-      CXXSTD: 14,17
-
-    # clang-win 32 bit fails to link with "unable to load mspdbcore.dll (error code: 126)"
-
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
-      TOOLSET: clang-win
-      ADDRMD: 64
-      CXXSTD: 14,17
-
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
-      TOOLSET: msvc-14.2
-      ADDRMD: 32,64
-      CXXSTD: 14,17
-
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
-      ADDPATH: C:\cygwin\bin;
-      TOOLSET: gcc
-      CXXSTD: 03,11,14,1z
-
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
-      ADDPATH: C:\cygwin64\bin;
-      TOOLSET: gcc
-      CXXSTD: 03,11,14,1z
-
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
-      ADDPATH: C:\mingw\bin;
-      TOOLSET: gcc
-      CXXSTD: 03,11,14,1z
-
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
-      ADDPATH: C:\mingw-w64\x86_64-6.3.0-posix-seh-rt_v5-rev1\mingw64\bin;
-      TOOLSET: gcc
-      CXXSTD: 03,11,14,1z
-
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
-      ADDPATH: C:\mingw-w64\x86_64-7.2.0-posix-seh-rt_v5-rev1\mingw64\bin;
-      TOOLSET: gcc
-      CXXSTD: 03,11,14,1z
 
 install:
-  - set BOOST_BRANCH=develop
-  - if "%APPVEYOR_REPO_BRANCH%" == "master" set BOOST_BRANCH=master
   - cd ..
-  - git clone -b %BOOST_BRANCH% https://github.com/boostorg/boost.git boost-root
+  - git clone -b %APPVEYOR_REPO_BRANCH% https://github.com/boostorg/boost.git boost-root
   - cd boost-root
-  - git submodule init libs/headers
   - git submodule init libs/assert
   - git submodule init libs/config
   - git submodule init libs/predef
   - git submodule init libs/static_assert
-  - git submodule init libs/throw_exception
   - git submodule init libs/type_traits
   - git submodule init tools/build
-  - git submodule init tools/boost_install
-  - git submodule update --jobs 4
-  - xcopy /s /e /q %APPVEYOR_BUILD_FOLDER% libs\core\
-  - cmd /c bootstrap
+  - git submodule update
+  - xcopy /s /e /q %APPVEYOR_BUILD_FOLDER% libs\core
+  - bootstrap
   - b2 headers
 
 build: off
 
 test_script:
-  - PATH=%ADDPATH%%PATH%
-  - if not "%CXXSTD%" == "" set CXXSTD=cxxstd=%CXXSTD%
-  - if not "%ADDRMD%" == "" set ADDRMD=address-model=%ADDRMD%
-  - b2 -j %NUMBER_OF_PROCESSORS% libs/core/test toolset=%TOOLSET% %CXXSTD% %ADDRMD% variant=debug,release
+  - b2 libs/core/test toolset=msvc-9.0,msvc-10.0,msvc-11.0,msvc-14.0

cmake/BoostVersion.cmake

@@ -0,0 +1 @@
+set(BOOST_VERSION 1.65.0)

cmake/Jamfile

@@ -0,0 +1,20 @@
+# Update cmake files
+
+install BoostVersion_ : ../../../BoostVersion.cmake : <location>. ;
+install default_ : ../../../cmake/default.cmake : <location>. ;
+
+# Update dependencies
+
+import path ;
+
+path-constant LIBDIR : .. ;
+
+actions boostdep-cmake
+{
+    "$(LIBDIR)/../../dist/bin/boostdep" --cmake $(LIBDIR:B) > $(1)
+}
+
+make dependencies.cmake : : @boostdep-cmake ;
+always dependencies.cmake ;
+
+install dependencies_ : dependencies.cmake : <location>. ;

cmake/default.cmake

@@ -0,0 +1,103 @@
+#
+# Default CMakeLists.txt contents for a Boost library
+#
+
+# sources.cmake defines ${PROJECT_NAME}_SOURCES
+include(cmake/sources.cmake)
+
+if("${${PROJECT_NAME}_SOURCES}" STREQUAL "")
+
+  # if no sources, this is a header-only library
+  add_library(boost_${BOOST_PROJECT_NAME} INTERFACE)
+
+  # include directory
+  target_include_directories(${PROJECT_NAME} INTERFACE
+    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+    $<INSTALL_INTERFACE:include>
+  )
+
+else()
+
+  # a library that requires building
+  add_library(${PROJECT_NAME} ${${PROJECT_NAME}_SOURCES})
+
+  # include directory
+  target_include_directories(${PROJECT_NAME} PUBLIC
+    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+    $<INSTALL_INTERFACE:include>
+  )
+
+endif()
+
+# add namespaced alias
+add_library(boost::${BOOST_PROJECT_NAME} ALIAS ${PROJECT_NAME})
+
+# set imported target name to the unqualified name, it will be namespaced
+set_property(TARGET ${PROJECT_NAME} PROPERTY EXPORT_NAME ${BOOST_PROJECT_NAME})
+
+# link to dependencies
+include(CMakeFindDependencyMacro)
+
+function(boost_declare_dependency package type target)
+
+  target_link_libraries(${PROJECT_NAME} ${type} ${target})
+
+  if(${CMAKE_CURRENT_SOURCE_DIR} STREQUAL ${CMAKE_SOURCE_DIR})
+
+    find_dependency(${package} ${PROJECT_VERSION} EXACT)
+
+  endif()
+
+endfunction()
+
+include(cmake/dependencies.cmake)
+
+# target installation
+install(TARGETS ${PROJECT_NAME} EXPORT ${PROJECT_NAME}-targets
+    RUNTIME DESTINATION bin
+    LIBRARY DESTINATION lib
+    ARCHIVE DESTINATION lib
+    INCLUDES DESTINATION include
+)
+
+# header installation
+install(DIRECTORY include/ DESTINATION include)
+
+# export target info to ${PROJECT_NAME}-targets.cmake, used by -config.cmake
+install(EXPORT ${PROJECT_NAME}-targets
+  FILE ${PROJECT_NAME}-targets.cmake
+  NAMESPACE boost::
+  DESTINATION lib/cmake/${PROJECT_NAME}-${PROJECT_VERSION}
+)
+
+# install -dependencies.cmake, used by -config.cmake
+
+install(FILES cmake/dependencies.cmake
+  DESTINATION lib/cmake/${PROJECT_NAME}-${PROJECT_VERSION}
+  RENAME ${PROJECT_NAME}-dependencies.cmake
+)
+
+# write ${PROJECT_NAME}-config.cmake
+file(WRITE "${PROJECT_BINARY_DIR}/${PROJECT_NAME}-config.cmake" "
+include(\${CMAKE_CURRENT_LIST_DIR}/${PROJECT_NAME}-targets.cmake)
+include(CMakeFindDependencyMacro)
+function(boost_declare_dependency package type target)
+  find_dependency(\${package} ${PROJECT_VERSION} EXACT)
+endfunction()
+include(\${CMAKE_CURRENT_LIST_DIR}/${PROJECT_NAME}-dependencies.cmake)
+")
+
+include(CMakePackageConfigHelpers)
+
+# write ${PROJECT_NAME}-config-version.cmake
+write_basic_package_version_file("${PROJECT_BINARY_DIR}/${PROJECT_NAME}-config-version.cmake"
+  VERSION ${PROJECT_VERSION}
+  COMPATIBILITY AnyNewerVersion
+)
+
+# install -config, -config-version
+install(FILES
+    "${PROJECT_BINARY_DIR}/${PROJECT_NAME}-config.cmake"
+    "${PROJECT_BINARY_DIR}/${PROJECT_NAME}-config-version.cmake"
+  DESTINATION lib/cmake/${PROJECT_NAME}-${PROJECT_VERSION}
+)

cmake/dependencies.cmake

@@ -0,0 +1,4 @@
+# Generated file. Do not edit.
+
+boost_declare_dependency(boost_assert INTERFACE boost::assert)
+boost_declare_dependency(boost_config INTERFACE boost::config)

doc/.gitignore

@@ -1,3 +0,0 @@
-/html/
-/pdf/
-ref_reference.xml

doc/Jamfile.v2

@@ -1,5 +1,5 @@
-# Copyright 2014 Glen Joseph Fernandes
-# (glenjofe@gmail.com)
+# Copyright (c) 2014 Glen Joseph Fernandes
+# glenfe at live dot com
 #
 # Distributed under the Boost Software License,
 # Version 1.0. (See accompanying file LICENSE_1_0.txt
@@ -49,7 +49,7 @@ boostbook standalone
     <xsl:param>boost.root=../../../..
     <xsl:param>generate.section.toc.level=1
     <xsl:param>toc.max.depth=1
-    <format>pdf:<xsl:param>boost.url.prefix="http://www.boost.org/doc/libs/release/libs/core/doc/html"
+    <format>pdf:<xsl:param>boost.url.prefix=http://www.boost.org/doc/libs/release/libs/core/doc/html
   ;
 
 ###############################################################################

doc/alloc_construct.qbk

@@ -1,149 +0,0 @@
-[/
-Copyright 2019 Glen Joseph Fernandes
-(glenjofe@gmail.com)
-
-Distributed under the Boost Software License, Version 1.0.
-(http://www.boost.org/LICENSE_1_0.txt)
-]
-
-[section:alloc_construct alloc_construct, alloc_destroy]
-
-[simplesect Authors]
-
-* Glen Fernandes
-
-[endsimplesect]
-
-[section Overview]
-
-The header <boost/core/alloc_construct.hpp> provides function templates
-`alloc_construct`, `alloc_construct_n`, `alloc_destroy`, and `alloc_destroy_n`
-for allocator aware and exception safe construction and destruction of objects
-and arrays.
-
-[endsect]
-
-[section Example]
-
-The following example allocates storage for an array of `n` elements of `T`
-using an allocator `a` and constructs `T` elements in that storage. If any
-exception was thrown during construction of an element, the constructed
-elements are destroyed in reverse order.
-
-```
-template<class A>
-auto create(A& a, std::size_t n)
-{
-    auto p = a.allocate(n);
-    try {
-        boost::alloc_construct_n(a, boost::to_address(p), n);
-    } catch (...) {
-        a.deallocate(p, n);
-        throw;
-    }
-    return p;
-}
-```
-
-[endsect]
-
-[section Reference]
-
-```
-namespace boost {
-
-template<class A, class T>
-void alloc_destroy(A& a, T* p);
-
-template<class A, class T>
-void alloc_destroy_n(A& a, T* p, std::size_t n);
-
-template<class A, class T, class Args>
-void alloc_construct(A& a, T* p, Args&&... args);
-
-template<class A, class T>
-void alloc_construct_n(A& a, T* p, std::size_t n);
-
-template<class A, class T>
-void alloc_construct_n(A& a, T* p, std::size_t n, const T* l, std::size_t m);
-
-template<class A, class T, class I>
-void alloc_construct_n(A& a, T* p, std::size_t n, I begin);
-
-} /* boost */
-```
-
-[section Functions]
-
-[variablelist
-[[`template<class A, class T> void alloc_destroy(A& a, T* p);`]
-[[variablelist
-[[Requires][`A` is an /Allocator/]]
-[[Effects][`std::allocator_traits<A>::destroy(a, p)`.]]]]]
-[[`template<class A, class T> void alloc_destroy_n(A& a, T* p,
-std::size_t n);`]
-[[variablelist
-[[Requires][`A` is an /Allocator/]]
-[[Effects]
-[Destroys each `i`-th element in reverse order by calling
-`std::allocator_traits<A>::destroy(a, &p[i])`.]]]]]
-[[`template<class A, class T, class Args> void alloc_construct(A& a, T* p,
-Args&&... args);`]
-[[variablelist
-[[Requires][`A` is an /Allocator/]]
-[[Effects]
-[`std::allocator_traits<A>::construct(a, p, std::forward<Args>(args)...)`.]]]]]
-[[`template<class A, class T> void alloc_construct_n(A& a, T* p,
-std::size_t n);`]
-[[variablelist
-[[Requires][`A` is an /Allocator/]]
-[[Effects]
-[Constructs each `i`-th element in order by calling
-`std::allocator_traits<A>::construct(a, &p[i])`.]]
-[[Remarks]
-[If an exception is thrown destroys each already constructed `j`-th element in
-reverse order by calling `std::allocator_traits<A>::destroy(a, &p[j])`.]]]]]
-[[`template<class A, class T> void alloc_construct_n(A& a, T* p, std::size_t n,
-const T* l, std::size_t m);`]
-[[variablelist
-[[Requires][`A` is an /Allocator/]]
-[[Effects]
-[Constructs each `i`-th element in order by calling
-`std::allocator_traits<A>::construct(a, &p[i], l[i % m])`.]]
-[[Remarks]
-[If an exception is thrown destroys each already constructed `j`-th element in
-reverse order by calling `std::allocator_traits<A>::destroy(a, &p[j])`.]]]]]
-[[`template<class A, class T, class I> void alloc_construct_n(A& a, T* p,
-std::size_t n, I begin);`]
-[[variablelist
-[[Requires]
-[[itemized_list
-[`A` is an /Allocator/][`I` is an /InputIterator/]]]]
-[[Effects]
-[Constructs each `i`-th element in order by calling
-`std::allocator_traits<A>::construct(a, &p[i], *begin++])`.]]
-[[Remarks]
-[If an exception is thrown destroys each already constructed `j`-th element in
-reverse order by calling `std::allocator_traits<A>::destroy(a, &p[j])`.]]]]]]
-
-[endsect]
-
-[endsect]
-
-[section Compatibility]
-
-When `BOOST_NO_CXX11_ALLOCATOR` is defined, and the C++11 allocator model is
-not supported, these functions invoke constructors and destructors directly
-without going through the supplied allocator.
-
-[endsect]
-
-[section Acknowledgments]
-
-Glen Fernandes originally implemented this functionality in Boost.Smart_Ptr and
-later moved these functions to Boost.Core for use in other Boost libraries,
-such as Boost.Multi_Array and Boost.Histogram.
-
-[endsect]
-
-[endsect]

doc/allocator_access.qbk

@@ -1,243 +0,0 @@
-[/
-Copyright 2020 Glen Joseph Fernandes
-(glenjofe@gmail.com)
-
-Distributed under the Boost Software License, Version 1.0.
-(http://www.boost.org/LICENSE_1_0.txt)
-]
-
-[section Allocator Access]
-
-[simplesect Authors]
-
-* Glen Fernandes
-
-[endsimplesect]
-
-[section Overview]
-
-The header `<boost/core/allocator_access.hpp>` provides the class and function
-templates to simplify allocator use. It provides the same functionality as the
-C++ standard library `std::allocator_traits` but with individual templates for
-each allocator feature.
-
-These facilities also simplify existing libraries by avoiding having to check
-for `BOOST_NO_CXX11_ALLOCATOR` and conditionally use `std::allocator_traits`.
-
-[endsect]
-
-[section Examples]
-
-The following example shows these utilities used in the definition of
-an allocator-aware container class:
-
-```
-template<class T, class A = boost::default_allocator<T> >
-class container
-    : boost::empty_value<typename boost::allocator_rebind<A, T>::type> {
-public:
-    typedef T value_type;
-    typedef A allocator_type;
-    typedef typename boost::allocator_size_type<A>::type size_type;
-    typedef typename boost::allocator_difference_type<A>::type difference_type;
-    typedef value_type& reference;
-    typedef const value_type& const_reference;
-    typedef typename boost::allocator_pointer<A>::type pointer;
-    typedef typename boost::allocator_const_pointer<A>::type const_pointer;
-    // ...
-};
-```
-
-In C++11 or above, aliases such as `boost::allocator_pointer_t<A>` can be used
-instead of `typename boost::allocator_pointer<A>::type`.
-
-[endsect]
-
-[section Reference]
-
-```
-namespace boost {
-
-template<class A>
-struct allocator_value_type;
-
-template<class A>
-using allocator_value_type_t = typename allocator_value_type<A>::type;
-
-template<class A>
-struct allocator_pointer;
-
-template<class A>
-using allocator_pointer_t = typename allocator_pointer<A>::type;
-
-template<class A>
-struct allocator_const_pointer;
-
-template<class A>
-using allocator_const_pointer_t = typename allocator_const_pointer<A>::type;
-
-template<class A>
-struct allocator_void_pointer;
-
-template<class A>
-using allocator_void_pointer_t = typename allocator_void_pointer<A>::type;
-
-template<class A>
-struct allocator_const_void_pointer;
-
-template<class A>
-using allocator_const_void_pointer_t =
-    typename allocator_const_void_pointer<A>::type;
-
-template<class A>
-struct allocator_difference_type;
-
-template<class A>
-using allocator_difference_type_t =
-    typename allocator_difference_type<A>::type;
-
-template<class A>
-struct allocator_size_type;
-
-template<class A>
-using allocator_size_type_t = typename allocator_size_type<A>::type;
-
-template<class A>
-struct allocator_propagate_on_container_copy_assignment;
-
-template<class A>
-using allocator_propagate_on_container_copy_assignment_t =
-    typename allocator_propagate_on_container_copy_assignment<A>::type;
-
-template<class A>
-struct allocator_propagate_on_container_move_assignment;
-
-template<class A>
-using allocator_propagate_on_container_move_assignment_t =
-    typename allocator_propagate_on_container_move_assignment<A>::type;
-
-template<class A>
-struct allocator_propagate_on_container_swap;
-
-template<class A>
-using allocator_propagate_on_container_swap_t =
-    typename allocator_propagate_on_container_swap<A>::type;
-
-template<class A>
-struct allocator_is_always_equal;
-
-template<class A>
-using allocator_is_always_equal_t =
-    typename allocator_is_always_equal<A>::type;
-
-template<class A, class T>
-struct allocator_rebind;
-
-template<class A, class T>
-using allocator_rebind_t = typename allocator_rebind<A, T>::type;
-
-template<class A>
-allocator_pointer_t<A> allocator_allocate(A& a, allocator_size_type_t<A> n);
-
-template<class A>
-allocator_pointer_t<A> allocator_allocate(A& a, allocator_size_type_t<A> n,
-    allocator_const_void_pointer_t<A> h);
-
-template<class A>
-void allocator_deallocate(A& a, allocator_pointer_t<A> p,
-    allocator_size_type_t<A> n);
-
-template<class A, class T, class... Args>
-void allocator_construct(A& a, T* p, Args&&... args);
-
-template<class A, class T>
-void allocator_destroy(A& a, T* p);
-
-template<class A>
-allocator_size_type_t<A> allocator_max_size(const A& a);
-
-template<class A>
-A allocator_select_on_container_copy_construction(const A& a);
-
-} // boost
-```
-
-[section Types]
-
-[variablelist
-[[`template<class A> struct allocator_value_type;`]
-[The member `type` is `A::value_type`.]]
-[[`template<class A> struct allocator_pointer;`]
-[The member `type` is `A::pointer` if valid, otherwise `A::value_type*`.]]
-[[`template<class A> struct allocator_const_pointer;`]
-[The member `type` is `A::const_pointer` if valid, otherwise
-`pointer_traits<allocator_pointer_t<A> >::rebind<const
-allocator_value_type_t<A> >`.]]
-[[`template<class A> struct allocator_void_pointer;`]
-[The member `type` is `A::void_pointer` if valid, otherwise
-`pointer_traits<allocator_pointer_t<A> >::rebind<void>`.]]
-[[`template<class A> struct allocator_const_void_pointer;`]
-[The member `type` is `A::const_void_pointer` if valid, otherwise
-`pointer_traits<allocator_pointer_t<A> >::rebind<const void>`.]]
-[[`template<class A> struct allocator_difference_type;`]
-[The member `type` is `A::difference_type` if valid, otherwise
-`pointer_traits<allocator_pointer_t<A> >::difference_type`.]]
-[[`template<class A> struct allocator_size_type;`]
-[The member `type` is `A::size_type` if valid, otherwise
-`std::make_unsigned_t<allocator_difference_type_t<A> >`.]]
-[[`template<class A> struct allocator_propagate_on_container_copy_assignment;`]
-[The member `type` is `A::propagate_on_container_copy_assignment` if valid,
-otherwise `std::false_type`.]]
-[[`template<class A> struct allocator_propagate_on_container_move_assignment;`]
-[The member `type` is `A::propagate_on_container_move_assignment` if valid,
-otherwise `std::false_type`.]]
-[[`template<class A> struct allocator_propagate_on_container_swap;`]
-[The member `type` is `A::propagate_on_container_swap` if valid, otherwise
-`std::false_type`.]]
-[[`template<class A> struct allocator_is_always_equal;`]
-[The member `type` is `A::is_always_equal` if valid, otherwise
-`std::is_empty<A>::type`.]]
-[[`template<class A, class T> struct allocator_rebind;`]
-[The member `type` is `A::rebind<T>::other` if valid, otherwise `A<T, Args>`
-if this `A` is `A<U, Args>`.]]]
-
-[endsect]
-
-[section Functions]
-
-[variablelist
-[[`template<class A>
-allocator_pointer_t<A> allocator_allocate(A& a, allocator_size_type_t<A> n);`]
-[Calls `a.allocate(n)`.]]
-[[`template<class A> allocator_pointer_t<A> allocator_allocate(A& a,
-allocator_size_type_t<A> n, allocator_const_void_pointer_t<A> hint);`]
-[Calls `a.allocate(n, hint)` if valid, otherwise calls `a.allocate(n)`.]]
-[[`template<class A> void allocator_deallocate(A& a, allocator_pointer_t<A> p,
-allocator_size_type_t<A> n);`]
-[Calls `a.deallocate(p, n)`.]]
-[[`template<class A, class T, class... Args>
-void allocator_construct(A& a, T*p, Args&&... args);`]
-[Calls `a.construct(p, std::forward<Args>(args)...)` if valid, otherwise calls
-`::new(static_cast<void*>(p)) T(std::forward<Args>(args)...)`.]]
-[[`template<class A, class T> void allocator_destroy(A& a, T* p);`]
-[Calls `a.destroy(p)` if valid, otherwise calls `p->~T()`.]]
-[[`template<class A> allocator_size_type_t<A> allocator_max_size(const A& a);`]
-[Returns `a.max_size()` if valid, otherwise returns
-`std::numeric_limits<allocator_size_type_t<A> >::max() /
-sizeof(A::value_type)`.]]
-[[`template<class A> A allocator_select_on_container_copy_construction(const
-A& a);`]
-[Returns `a.select_on_container_copy_construction()` if valid, otherwise
-returns `a`.]]]
-
-[endsect]
-
-[endsect]
-
-[section Acknowledgments]
-
-Glen Fernandes implemented the allocator access utilities.
-
-[endsect]
-
-[endsect]

doc/core.qbk

@@ -1,10 +1,10 @@
 [/
-Copyright 2014 Glen Joseph Fernandes
-(glenjofe@gmail.com)
+  Copyright (c) 2014 Glen Joseph Fernandes
+  glenfe at live dot com
 
-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)
+  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)
 ]
 
 [library Boost.Core
@@ -39,29 +39,18 @@ criteria for inclusion is that the utility component be:
 [endsect]
 
 [include addressof.qbk]
-[include allocator_access.qbk]
-[include alloc_construct.qbk]
 [include checked_delete.qbk]
-[include default_allocator.qbk]
 [include demangle.qbk]
-[include empty_value.qbk]
 [include enable_if.qbk]
-[include exchange.qbk]
 [include explicit_operator_bool.qbk]
-[include first_scalar.qbk]
 [include ignore_unused.qbk]
 [include is_same.qbk]
 [include lightweight_test.qbk]
 [include no_exceptions_support.qbk]
-[include noinit_adaptor.qbk]
 [include noncopyable.qbk]
 [include null_deleter.qbk]
-[include nvp.qbk]
 [include pointer_traits.qbk]
-[include quick_exit.qbk]
 [include ref.qbk]
 [include scoped_enum.qbk]
 [include swap.qbk]
 [include typeinfo.qbk]
-[include uncaught_exceptions.qbk]
-[include use_default.qbk]

doc/default_allocator.qbk

@@ -1,140 +0,0 @@
-[/
-Copyright 2019 Glen Joseph Fernandes
-(glenjofe@gmail.com)
-
-Distributed under the Boost Software License, Version 1.0.
-(http://www.boost.org/LICENSE_1_0.txt)
-]
-
-[section:default_allocator default_allocator]
-
-[simplesect Authors]
-
-* Glen Fernandes
-
-[endsimplesect]
-
-[section Overview]
-
-The header <boost/core/default_allocator.hpp> provides the class template
-`boost::default_allocator` to serve as a minimal default allocator that:
-
-* Like C++2a's `std::allocator`, does not provide members such as `construct()`
-and `destroy()` to be eligible for optimizations by allocator-aware code that
-detects the absence of these members to provide more optimal construction.
-* Supports `BOOST_NO_EXCEPTIONS` in allocation.
-* Does not have `std` as an associated namespace.
-
-[endsect]
-
-[section Examples]
-
-The following snippet shows the use of this allocator as the default allocator
-for a container.
-
-```
-template<class Key, class Compare = std::less<Key>,
-    class Allocator = boost::default_allocator<Key> >
-class FlatSet;
-```
-
-Facilities like `make_shared` can be implemented using `allocate_shared` with
-`default_allocator`.
-
-```
-template<class T, class... Args>
-enable_if_t<!is_array_v<T>, shared_ptr<T> >
-make_shared(Args&&... args)
-{
-    return allocate_shared<T>(boost::default_allocator<remove_cv_t<T> >(),
-        std::forward<Args>(args)...);
-}
-```
-
-[endsect]
-
-[section Reference]
-
-```
-namespace boost {
-
-template<class T>
-struct default_allocator {
-    typedef T value_type;
-    typedef T* pointer;
-    typedef const T* const_pointer;
-    typedef std::add_lvalue_reference_t<T> reference;
-    typedef std::add_lvalue_reference_t<const T> const_reference;
-    typedef std::size_t size_type;
-    typedef std::ptrdiff_t difference_type;
-    typedef ``['true_type]`` propagate_on_container_move_assignment;
-    typedef ``['true_type]`` is_always_equal;
-
-    template<class U>
-    struct rebind {
-        typedef default_allocator<U> other;
-    };
-
-    constexpr default_allocator() = default;
-
-    template<class U>
-    constexpr default_allocator(const default_allocator<U>&) noexcept { }
-
-    constexpr std::size_t max_size() const noexcept;
-    T* allocate(std::size_t n);
-    void deallocate(T* p, std::size_t);
-};
-
-template<class T, class U>
-constexpr bool operator==(const default_allocator<T>&,
-    const default_allocator<U>&) noexcept;
-
-template<class T, class U>
-constexpr bool operator!=(const default_allocator<T>&,
-    const default_allocator<U>&) noexcept;
-
-} /* boost */
-```
-
-[section Members]
-
-[variablelist
-[[`constexpr std::size_t max_size() const noexcept;`]
-[[variablelist
-[[Returns][The largest value `N` for which the call `allocate(N)` might
-succeed.]]]]]
-[[`T* allocate(std::size_t n);`]
-[[variablelist
-[[Returns]
-[A pointer to the initial element of an array of storage of size
-`n * sizeof(T)`, aligned appropriately for objects of type `T`.]]
-[[Remarks][The storage is obtained by calling `::operator new`.]]
-[[Throws][`std::bad_alloc` if the storage cannot be obtained.]]]]]
-[[`void deallocate(T* p, std::size_t n);`]
-[[variablelist
-[[Requires]
-[`p` shall be a pointer value obtained from `allocate()`. `n` shall equal the
-value passed as the first argument to the invocation of `allocate` which
-returned `p`.]]
-[[Effects][Deallocates the storage referenced by `p`.]]
-[[Remarks][Uses `::operator delete`.]]]]]]
-
-[endsect]
-
-[section Operators]
-
-[variablelist
-[[`template<class T, class U> constexpr bool operator==(const
-default_allocator<T>&, const default_allocator<U>&) noexcept;`]
-[[variablelist
-[[Returns][`true`.]]]]]
-[[`template<class T, class U> constexpr bool operator!=(const
-default_allocator<T>&, const default_allocator<U>&) noexcept;`]
-[[variablelist
-[[Returns][`false`.]]]]]]
-
-[endsect]
-
-[endsect]
-
-[endsect]

doc/empty_value.qbk

@@ -1,140 +0,0 @@
-[/
-Copyright 2018 Glen Joseph Fernandes
-(glenjofe@gmail.com)
-
-Distributed under the Boost Software License, Version 1.0.
-(http://www.boost.org/LICENSE_1_0.txt)
-]
-
-[section:empty_value empty_value]
-
-[simplesect Authors]
-
-* Glen Fernandes
-
-[endsimplesect]
-
-[section Overview]
-
-The header <boost/core/empty_value.hpp> provides the class template
-`boost::empty_value` for library authors to conveniently leverage the Empty
-Base Optimization to store objects of potentially empty types.
-
-[endsect]
-
-[section Examples]
-
-The following example shows `boost::empty_value` used to create a type that
-stores a pointer, comparer, and allocator, where the comparer and allocator
-could be empty types.
-
-```
-template<class Ptr, class Compare, class Allocator>
-class storage
-    : empty_value<Compare, 0>
-    , empty_value<Allocator, 1> {
-public:
-    storage()
-        : empty_value<Compare, 0>(empty_init_t())
-        , empty_value<Allocator, 1>(empty_init_t())
-        , ptr_() { }
-
-    storage(const Compare& c, const Allocator& a)
-        : empty_value<Compare, 0>(empty_init_t(), c)
-        , empty_value<Allocator, 1>(empty_init_t(), a)
-        , ptr_() { }
-
-    const Ptr& pointer() const {
-        return ptr_;
-    }
-
-    Ptr& pointer() {
-        return ptr_;
-    }
-
-    const Compare& compare() const {
-        return empty_value<Compare, 0>::get();
-    }
-
-    Compare& compare() {
-        return empty_value<Compare, 0>::get();
-    }
-
-    const Allocator& allocator() const {
-        return empty_value<Allocator, 1>::get();
-    }
-
-    Allocator& allocator() {
-        return empty_value<Allocator, 1>::get();
-    }
-
-private:
-    Ptr ptr_;
-};
-```
-
-[endsect]
-
-[section Reference]
-
-```
-namespace boost {
-
-struct empty_init_t { };
-
-template<class T, unsigned Index = 0, bool Empty = ``/see below/``>
-class empty_value {
-public:
-    typedef T type;
-
-    empty_value() = default;
-
-    template<class... Args>
-    empty_value(empty_init_t, Args&&... args);
-
-    const T& get() const noexcept;
-
-    T& get() noexcept;
-};
-
-inline constexpr empty_init_t empty_init{ };
-
-} /* boost */
-```
-
-[section Template parameters]
-
-[variablelist
-[[`T`][The type of value to store]]
-[[`Index`][Optional: Specify to create a distinct base type]]
-[[`Empty`][Optional: Specify to force inheritance from type]]]
-
-[endsect]
-
-[section Member types]
-
-[variablelist
-[[`type`][The template parameter `T`]]]
-
-[endsect]
-
-[section Constructors]
-
-[variablelist
-[[`empty_value() = default;`][Default initialize the value]]
-[[`template<class... Args> empty_value(empty_init_t, Args&&... args);`]
-[Initialize the value with `std::forward<Args>(args)...`]]]
-
-[endsect]
-
-[section Member functions]
-
-[variablelist
-[[`const T& get() const noexcept;`][Returns the value]]
-[[`T& get() noexcept;`][Returns the value]]]
-
-[endsect]
-
-[endsect]
-
-[endsect]

doc/exchange.qbk

@@ -1,63 +0,0 @@
-[/
-Copyright 2018 Glen Joseph Fernandes
-(glenjofe@gmail.com)
-
-Distributed under the Boost Software License, Version 1.0.
-(http://www.boost.org/LICENSE_1_0.txt)
-]
-
-[section:exchange exchange]
-
-[simplesect Authors]
-
-* Glen Fernandes
-
-[endsimplesect]
-
-[section Overview]
-
-The header <boost/core/exchange.hpp> provides the function template
-`boost::exchange` which is an implementation of the `std::exchange`
-function introduced in C++14. `boost::exchange(o, v)` replaces the
-value of `o` with `v` and returns the old value of `o`.
-
-[endsect]
-
-[section Examples]
-
-The following example shows `boost::exchange` used to simplify the
-implementation of a move constructor.
-
-```
-Node(Node&& other)
-  : head_(boost::exchange(other.head_, nullptr))
-  , tail_(boost::exchange(other.tail_, nullptr)) { }
-```
-
-[endsect]
-
-[section Reference]
-
-```
-namespace boost {
-  template<class T, class U = T>
-  constexpr T exchange(T& t, U&& u);
-}
-```
-[section Functions]
-
-[*`template<class T, class U = T> constexpr T exchange(T& t, U&& u);`]
-
-Equivalent to:
-
-```
-T v = std::move(t);
-t = std::forward<U>(u);
-return v;
-```
-
-[endsect]
-
-[endsect]
-
-[endsect]

doc/first_scalar.qbk

@@ -1,91 +0,0 @@
-[/
-Copyright 2019 Glen Joseph Fernandes
-(glenjofe@gmail.com)
-
-Distributed under the Boost Software License, Version 1.0.
-(http://www.boost.org/LICENSE_1_0.txt)
-]
-
-[section:first_scalar first_scalar]
-
-[simplesect Authors]
-
-* Glen Fernandes
-
-[endsimplesect]
-
-[section Overview]
-
-The header <boost/core/first_scalar.hpp> provides the function templates
-`boost::first_scalar` that can be used to obtain a pointer to the first scalar
-element of an array. Given a pointer of type `T*` they return a pointer of
-type `remove_all_extents_t<T>*`. The functions are `constexpr` and can be used
-in constant expressions.
-
-[endsect]
-
-[section Examples]
-
-The following function uses an allocator to allocate an array of arrays and
-constructs each scalar element in it.
-
-```
-#include <boost/alloc_construct.hpp>
-#include <boost/first_scalar.hpp>
-
-template<class A>
-auto create(const A& allocator)
-{
-    typename std::allocator_traits<A>::template
-        rebind_alloc<int[2][3]> other(allocator);
-    auto ptr = other.allocate(4);
-    try {
-        boost::alloc_construct_n(other,
-            boost::first_scalar(boost::to_address(ptr)), 24);
-    } catch (...) {
-        other.deallocate(ptr, 4);
-        throw;
-    }
-    return ptr;
-}
-```
-
-[endsect]
-
-[section Reference]
-
-```
-namespace boost {
-
-template<class T>
-constexpr T* first_scalar(T* p) noexcept;
-
-template<class T, std::size_t N>
-constexpr auto first_scalar(T (*p)[N]) noexcept;
-
-} /* boost */
-```
-
-[section Functions]
-
-[variablelist
-[[`template<class T> constexpr T* first_scalar(T* p) noexcept;`]
-[[variablelist
-[[Returns][`p`.]]]]]
-[[`template<class T, std::size_t N> constexpr auto first_scalar(T (*p)[N])
-noexcept;`]
-[[variablelist
-[[Returns][`first_scalar(&(*p)[0])`.]]]]]]
-
-[endsect]
-
-[endsect]
-
-[section History]
-
-Glen Fernandes implemented `first_scalar`. Peter Dimov suggested a change for
-GCC to support an additional `constexpr` use.
-
-[endsect]
-
-[endsect]

doc/lightweight_test.qbk

@@ -1,7 +1,7 @@
 [/
   Copyright 2010, 2011 Beman Dawes
   Copyright 2013 Ion Gaztanaga
-  Copyright 2014-2019 Peter Dimov
+  Copyright 2014, 2017 Peter Dimov
   Copyright 2017 Kohei Takahashi
 
   Distributed under the Boost Software License, Version 1.0.
@@ -43,11 +43,9 @@ When using `lightweight_test.hpp`, *do not forget* to
 #define BOOST_TEST_GE(expr1, expr2) /*unspecified*/
 #define BOOST_TEST_CSTR_EQ(expr1, expr2) /*unspecified*/
 #define BOOST_TEST_CSTR_NE(expr1, expr2) /*unspecified*/
-#define BOOST_TEST_WITH(expr1, expr2, pred) /*unspecified*/
 #define BOOST_TEST_ALL_EQ(begin1, end1, begin2, end2) /* unspecified */
 #define BOOST_TEST_ALL_WITH(begin1, end1, begin2, end2, predicate) /* unspecified */
 #define BOOST_TEST_THROWS(expr, excep) /*unspecified*/
-#define BOOST_TEST_NO_THROW(expr) /*unspecified*/
 
 namespace boost
 {
@@ -176,17 +174,6 @@ Specialization of `BOOST_TEST_NE` which interprets `expr1` and `expr2` as pointe
 
 [endsect]
 
-[section BOOST_TEST_WITH]
-
-``
-BOOST_TEST_WITH(expr1, expr2, pred)
-``
-
-If `pred(expr1, expr2)` is not true increases the error count and outputs a
-message containing both expressions.
-
-[endsect]
-
 [section BOOST_TEST_ALL_EQ]
 
 ``
@@ -222,20 +209,6 @@ nothing and `expr` is not evaluated.
 
 [endsect]
 
-[section BOOST_TEST_NO_THROW]
-
-``
-BOOST_TEST_NO_THROW(expr)
-``
-
-If `BOOST_NO_EXCEPTIONS` is *not* defined and if `expr` throws an exception,
-increases the error count and outputs a message containing the expression
-and (if possible) the exception message.
-
-If `BOOST_NO_EXCEPTIONS` is defined, `expr` is evaluated.
-
-[endsect]
-
 [section report_errors]
 
 ``
@@ -280,7 +253,6 @@ return a boolean value.
 ``
 #define BOOST_TEST_TRAIT_TRUE((Trait)) /*unspecified*/
 #define BOOST_TEST_TRAIT_FALSE((Trait)) /*unspecified*/
-#define BOOST_TEST_TRAIT_SAME(Type1, Type2) /*unspecified*/
 ``
 
 [endsect]
@@ -308,20 +280,6 @@ message containing `Trait`. Note the double set of parentheses.
 
 [endsect]
 
-[section BOOST_TEST_TRAIT_SAME]
-
-``
-BOOST_TEST_TRAIT_SAME(Type1, Type2)
-``
-
-If the two types are not the same, increases the error count and outputs a
-message containing them. This macro requires that the compiler supports
-variadic macros and `__VA_ARGS__`. (Note that unlike `BOOST_TEST_TRAIT_TRUE`
-and `BOOST_TEST_TRAIT_FALSE`, this macro only requires a single set of
-parentheses.)
-
-[endsect]
-
 [section Example]
 
 ``
@@ -339,8 +297,6 @@ int main()
 {
     BOOST_TEST_TRAIT_TRUE(( is_same<X<int, long>::type, int> ));
 
-    BOOST_TEST_TRAIT_SAME( X<int, long>::type, int );
-
     return boost::report_errors();
 }
 ``

doc/noinit_adaptor.qbk

@@ -1,163 +0,0 @@
-[/
-Copyright 2019 Glen Joseph Fernandes
-(glenjofe@gmail.com)
-
-Distributed under the Boost Software License, Version 1.0.
-(http://www.boost.org/LICENSE_1_0.txt)
-]
-
-[section:noinit_adaptor noinit_adaptor]
-
-[simplesect Authors]
-
-* Glen Fernandes
-
-[endsimplesect]
-
-[section Overview]
-
-The header <boost/core/noinit_adaptor.hpp> provides the class
-template `boost::noinit_adaptor` that converts any allocator into
-one whose `construct(ptr)` performs default initialization via placement new,
-and whose `destroy(ptr)` invokes `value_type` destructor directly.
-
-[endsect]
-
-[section Examples]
-
-The following example shows use of this allocator adaptor to achieve default
-initialization of elements of a trivial type, which are later assigned values.
-
-```
-#include <boost/core/noinit_adaptor.hpp>
-#include <numeric>
-#include <vector>
-
-int main()
-{
-    std::vector<int, boost::noinit_adaptor<std::allocator<int> > > v(5);
-    std::iota(v.begin(), v.end(), 1);
-}
-```
-
-The `allocate_shared_noinit` function templates are now implemented simply
-using `allocate_shared` with `noinit_adaptor`.
-
-```
-template<class T, class A>
-enable_if_t<is_unbounded_array_v<T>, shared_ptr<T> >
-allocate_shared_noinit(const A& a, size_t n)
-{
-    return allocate_shared<T>(boost::noinit_adapt(a), n);
-}
-
-template<class T, class A>
-enable_if_t<!is_unbounded_array_v<T>, shared_ptr<T> >
-allocate_shared_noinit(const A& a)
-{
-    return allocate_shared<T>(boost::noinit_adapt(a));
-}
-```
-
-[endsect]
-
-[section Reference]
-
-```
-namespace boost {
-
-template<class A>
-struct noinit_adaptor
-    : A {
-    template<class U>
-    struct rebind {
-        typedef noinit_adaptor<allocator_rebind_t<A, U> > other;
-    };
-
-    noinit_adaptor() noexcept;
-
-    template<class U>
-    noinit_adaptor(U&& u) noexcept;
-
-    template<class U>
-    noinit_adaptor(const noinit_adaptor<U>& u) noexcept;
-
-    template<class U>
-    void construct(U* p);
-
-    template<class U>
-    void destroy(U* p);
-};
-
-template<class T, class U>
-bool operator==(const noinit_adaptor<T>& lhs,
-    const noinit_adaptor<U>& rhs) noexcept;
-
-template<class T, class U>
-bool operator!=(const noinit_adaptor<T>& lhs,
-    const noinit_adaptor<U>& rhs) noexcept;
-
-template<class A>
-noinit_adaptor<A> noinit_adapt(const A& a) noexcept;
-
-} /* boost */
-```
-
-[section Constructors]
-
-[variablelist
-[[`noinit_adaptor() noexcept;`]
-[[variablelist
-[[Effects][Value initializes the A base class.]]]]]
-[[`template<class U> noinit_adaptor(U&& u) noexcept;`]
-[[variablelist
-[[Requires][`A` shall be constructible from `U`.]]
-[[Effects][Initializes the `A` base class with `std::forward<U>(u)`.]]]]]
-[[`template<class U> noinit_adaptor(const noinit_adaptor<U>& u) noexcept;`]
-[[variablelist
-[[Requires][`A` shall be constructible from `U`.]]
-[[Effects][Initializes the `A` base class with
-`static_cast<const A&>(u)`.]]]]]]
-
-[endsect]
-
-[section Member functions]
-
-[variablelist
-[[`template<class U> void construct(U* p);`]
-[[variablelist
-[[Effects][`::new((void*)p) U`.]]]]]
-[[`template<class U> void destroy(U* p);`]
-[[variablelist
-[[Effects][`p->~U()`.]]]]]]
-
-[endsect]
-
-[section Operators]
-
-[variablelist
-[[`template<class T, class U> constexpr bool
-operator==(const noinit_adaptor<T>& lhs,
-const noinit_adaptor<U>& rhs) noexcept;`]
-[[variablelist
-[[Returns][`static_cast<const T&>(lhs) == static_cast<const U&>(rhs)`.]]]]]
-[[`template<class T, class U> constexpr bool
-operator!=(const noinit_adaptor<T>& lhs,
-const noinit_adaptor<U>& rhs) noexcept;`]
-[[variablelist
-[[Returns][`!(lhs == rhs)`.]]]]]]
-
-[endsect]
-
-[section Free functions]
-
-[variablelist
-[[`template<class A> noinit_adaptor<A> noinit_adapt(const A& a) noexcept;`]
-[[variablelist
-[[Returns][`noinit_adaptor<A>(a)`.]]]]]]
-
-[endsect]
-
-[endsect]
-
-[endsect]

doc/noncopyable.qbk

@@ -18,9 +18,9 @@
 
 [section Header <boost/core/noncopyable.hpp>]
 
-The header `<boost/core/noncopyable.hpp>` defines the class
+The header `<boost/noncopyable.hpp>` defines the class
 `boost::noncopyable`. It is intended to be used as a private
-base class. `boost::noncopyable` has private (under C++03) or
+base. `boost::noncopyable` has private (under C++03) or
 deleted (under C++11) copy constructor and a copy assignment
 operator and can't be copied or assigned; a class that derives
 from it inherits these properties.

doc/nvp.qbk

@@ -1,108 +0,0 @@
-[/
-Copyright 2019 Glen Joseph Fernandes
-(glenjofe@gmail.com)
-
-Distributed under the Boost Software License, Version 1.0.
-(http://www.boost.org/LICENSE_1_0.txt)
-]
-
-[section:nvp nvp]
-
-[section Overview]
-
-The header <boost/core/nvp.hpp> provides the class template `boost::nvp` that
-pairs a name (`const char*`) with the address of a value (`T*`). It is the new
-implementation of the NVP type previously provided by the Boost Serialization
-library. This type now lives in the Core library so that other Boost libraries
-can support named value serialization without taking a dependency on the
-Serialization library.
-
-[endsect]
-
-[section Examples]
-
-The following snippet shows use in a member serialize function:
-
-```
-template<class A>
-void serialize(A& archive, unsigned)
-{
-    archive & boost::make_nvp("x", x_) & boost::make_nvp("y", y_);
-}
-```
-
-[endsect]
-
-[section Reference]
-
-```
-namespace boost {
-
-template<class T>
-class nvp {
-public:
-    nvp(const char* name, T& value) noexcept;
-
-    const char* name() const noexcept;
-
-    T& value() const noexcept;
-
-    const T& const_value() const noexcept;
-};
-
-template<class T>
-const nvp<T> make_nvp(const char* name, T& value) noexcept;
-
-} /* boost */
-
-#define BOOST_NVP(object) ``['see below]``
-```
-
-[section Constructors]
-
-[variablelist
-[[`nvp(const char* name, T& value) noexcept;`]
-[Initializes the stored name pointer with `name` and the value pointer with
-`addressof(value)`.]]]
-
-[endsect]
-
-[section Members]
-
-[variablelist
-[[`const char* name() const noexcept;`]
-[Returns a pointer to the name.]]
-[[`T& value() const noexcept;`]
-[Returns a reference to the value.]]
-[[`const T& const_value() const noexcept;`]
-[Returns a reference to the value.]]]
-
-[endsect]
-
-[section Functions]
-
-[variablelist
-[[`template<class T> const nvp<T> make_nvp(const char* name, T& value)
-noexcept;`]
-[Returns `nvp<T>(name, value)`.]]]
-
-[endsect]
-
-[section Macros]
-
-[variablelist
-[[`#define BOOST_NVP(object) see below`]
-[Expands to `boost::make_nvp(BOOST_STRINGIZE(object), object)`.]]]
-
-[endsect]
-
-[endsect]
-
-[section History]
-
-Robert Ramey originally implemented NVP in the Serialization library. Glen
-Fernandes implemented this new (but compatible) version in the Core library.
-
-[endsect]
-
-[endsect]

doc/pointer_traits.qbk

@@ -1,5 +1,5 @@
 [/
-Copyright 2017-2018 Glen Joseph Fernandes
+Copyright 2017 Glen Joseph Fernandes
 (glenjofe@gmail.com)
 
 Distributed under the Boost Software License, Version 1.0.
@@ -20,24 +20,23 @@ The header <boost/core/pointer_traits.hpp> provides the class template
 `boost::pointer_traits` to facilitate use of pointer-like types. The C++11
 standard library introduced `std::pointer_traits` along with an allocator
 model which supported pointer-like types in addition to plain raw pointers.
-This implementation also supports C++98.
-
-It also provides the function template `boost::to_address` to obtain a raw
-pointer from an object of any pointer-like type.
+This implementation also supports C++98, and adds additional functionality
+for obtaining raw pointers from pointers.
 
 [endsect]
 
 [section Examples]
 
-The following example allocates storage and constructs an object in that
-storage using an allocator.
+The following function template obtains a raw pointer from a pointer and is
+well defined when the pointer aliases storage that has no object constructed
+in it.
 
 ```
-template<class Allocator>
-void function(Allocator& a)
+template<class T>
+inline typename boost::pointer_traits<T>::element_type*
+to_raw_pointer(T v) noexcept
 {
-    auto p = a.allocate(1);
-    std::allocator_traits<Allocator>::construct(a, boost::to_address(p));
+    return boost::pointer_traits<T>::to_address(v);
 }
 ```
 
@@ -56,6 +55,7 @@ namespace boost {
     template<class U> using rebind = typename rebind_to<U>::type;
 
     static pointer pointer_to(``['see below]`` v);
+    static element_type* to_address(pointer v) noexcept;
   };
 
   template<class T> struct pointer_traits<T*> {
@@ -67,76 +67,65 @@ namespace boost {
     template<class U> using rebind = typename rebind_to<U>::type;
 
     static pointer pointer_to(``['see below]`` v) noexcept;
+    static element_type* to_address(pointer v) noexcept;
   };
-
-  template<class T>
-  constexpr T* to_address(T* v) noexcept;
-
-  template<class T>
-  auto to_address(const T& v) noexcept;
 }
 ```
 
 [section Member types]
 
 [variablelist
-[[`typedef` ['see below] `element_type;`]
-[`T::element_type` if such a type exists; otherwise `U` if `T` is a class
-  template instantiation of the form `Pointer<U, Args>`, where `Args` is zero
-  or more type arguments; otherwise the specialization is ill-formed.]]
-[[`typedef` ['see below] `difference_type;`]
-[`T::difference_type` if such a type exists; otherwise `std::ptrdiff_t`.]]
-[[`template<class U> struct rebind_to { typedef` ['see below] `type; };`]
-[`type` is `T::rebind<U>` if such a type exists; otherwise, `Pointer<V, Args>`
-  if `T` is a class template instantiation of the form `Pointer<T, Args>`,
-  where `Args` is zero or more type arguments; otherwise, the instantiation of
-  `rebind_to` is ill-formed.]]]
+  [[`typedef` ['see below] `element_type;`]
+    [[variablelist
+      [[Type]
+        [`T::element_type` if such a type exists; otherwise `U` if `T` is a
+          class template instantiation of the form `Pointer<U, Args>`, where
+          `Args` is zero or more type arguments; otherwise the specialization
+          is ill-formed.]]]]]
+  [[`typedef` ['see below] `difference_type;`]
+    [[variablelist
+      [[Type]
+        [`T::difference_type` if such a type exists; otherwise
+          `std::ptrdiff_t`.]]]]]
+  [[`template<class U> struct rebind_to { typedef` ['see below] `type; };`]
+    [[variablelist
+      [[Type]
+        [`type` is `T::rebind<U>` if such a type exists; otherwise,
+          `Pointer<V, Args>` if `T` is a class template instantiation of the
+          form `Pointer<T, Args>`, where `Args` is zero or more type
+          arguments; otherwise, the instantiation of `rebind_to` is
+          ill-formed.]]]]]]
 
 [endsect]
 
 [section Member functions]
 
-[variablelist
-[[`static pointer pointer_traits::pointer_to(`['see below] `v);`]
-[[variablelist
-[[Remark]
-[If `element_type` is a void type, the type of `v` is unspecified; otherwise,
-  it is `element_type&`.]]
-[[Returns]
-[A pointer to `v` obtained by calling `T::pointer_to(v)`.]]]]]
-[[`static pointer pointer_traits<T*>::pointer_to(`['see below] `v) noexcept;`]
-[[variablelist
-[[Remark]
-[If `element_type` is a void type, the type of `v` is unspecified; otherwise,
-  it is `element_type&`.]]
-[[Returns][`addressof(v)`.]]]]]]
+[variablelist pointer_traits
+  [[`static pointer pointer_to(`['see below] `v);`]
+    [[variablelist
+      [[Remark]
+        [If `element_type` is a void type, the type of `v` is unspecified;
+          otherwise, it is `element_type&`.]]
+      [[Returns]
+        [A pointer to `v` obtained by calling `T::pointer_to(v)`.]]]]]
+  [[`static element_type* to_address(pointer v) noexcept;`]
+    [[variablelist
+      [[Requires]
+        [`v` is not a null pointer.]]
+      [[Returns]
+        [A pointer of type `element_type*` that references the same location
+          as the argument.]]]]]]
 
-[endsect]
-
-[section Optional members]
-
-[variablelist
-[[`static element_type* to_address(pointer v) noexcept;`]
-[[variablelist
-[[Returns]
-[A pointer of type `element_type*` that references the same location as the
-  argument `p`.]]
-[[Note]
-[This function should be the inverse of `pointer_to`. If defined, it
-  customizes the behavior of the non-member function `to_address`.]]]]]]
-
-[endsect]
-
-[section Free functions]
-
-[variablelist
-[[`template<class T> constexpr T* to_address(T* v) noexcept;`]
-[[variablelist
-[[Returns][`v`.]]]]]
-[[`template<class T> auto to_address(const T& v) noexcept;`]
-[[variablelist
-[[Returns][`pointer_traits<T>::to_address(v)` if that
-  expression is well-formed, otherwise `to_address(v.operator->())`.]]]]]]
+[variablelist pointer_traits<T*>
+  [[`static pointer pointer_to(`['see below] `v) noexcept;`]
+    [[variablelist
+      [[Remark]
+        [If `element_type` is a void type, the type of `v` is unspecified;
+          otherwise, it is `element_type&`.]]
+      [[Returns]
+        [The result of `std::addressof(v)`.]]]]]
+  [[`static element_type* to_address(pointer v) noexcept;`]
+    [[variablelist [[Returns] [The value of `v`.]]]]]]
 
 [endsect]
 
@@ -144,8 +133,8 @@ namespace boost {
 
 [section Acknowledgments]
 
-Glen Fernandes implemented `pointer_traits` and `to_address` with reviews and
-guidance from Peter Dimov.
+Glen Fernandes implemented `pointer_traits` with reviews and guidance from
+Peter Dimov.
 
 [endsect]
 

doc/quick_exit.qbk

@@ -1,40 +0,0 @@
-[/
-  Copyright 2018 Peter Dimov
-
-  Distributed under the Boost Software License, Version 1.0.
-
-  See accompanying file LICENSE_1_0.txt
-  or copy at http://boost.org/LICENSE_1_0.txt
-]
-
-[section:quick_exit quick_exit]
-
-[simplesect Authors]
-
-* Peter Dimov
-
-[endsimplesect]
-
-[section Header <boost/core/quick_exit.hpp>]
-
-The header `<boost/core/quick_exit.hpp>` defines the function
-`void boost::quick_exit(int code)`. It calls the standard C++11 function
-[@https://en.cppreference.com/w/cpp/utility/program/quick_exit
- `std::quick_exit(code)`], if that is available, and otherwise exits the
- process via [@https://en.cppreference.com/w/cpp/utility/program/_Exit
- `std::_Exit(code)`] or equivalent.
-
-[section Synopsis]
-
-``
-namespace boost
-{
-    [[noreturn]] void quick_exit(int code) noexcept;
-}
-``
-
-[endsect]
-
-[endsect]
-
-[endsect]

doc/scoped_enum.qbk

@@ -67,9 +67,9 @@ The enumeration can be forward declared:
 
     BOOST_SCOPED_ENUM_FORWARD_DECLARE(future_errc);
 
-There are however some limitations. The emulated scoped enum is not a C++ enum, so `is_enum< future_errc >` will be `false_type`.
+There are however some limitations. First, the emulated scoped enum is not a C++ enum, so `is_enum< future_errc >` will be `false_type`.
 
-The emulated scoped enum can not be used in switch nor in template arguments. For these cases the user needs to use some helpers. Instead of
+Second, the emulated scoped enum can not be used in switch nor in template arguments. For these cases the user needs to use some helpers. Instead of
 
     switch (ev)
     {
@@ -99,29 +99,10 @@ use
     {
     };
 
-Explicit conversion to the underlying type should be performed with `boost::underlying_cast` instead of `static_cast`:
+Lastly, explicit conversion to the underlying type should be performed with `boost::underlying_cast` instead of `static_cast`:
 
     unsigned int val = boost::underlying_cast< unsigned int >(ev);
 
-In C++03, scoped enums behave differently in case of calling an overloaded function when one overload takes a scoped enum as a parameter, and the other takes a parameter of an integral type. Consider the following code:
-
-    enum enum_regular { REGULAR_A, REGULAR_B };
-
-    BOOST_SCOPED_ENUM_DECLARE_BEGIN(enum_scoped)
-    {
-        a, b
-    }
-    BOOST_SCOPED_ENUM_DECLARE_END(enum_scoped)
-
-    void regular_or_int(enum_regular); // (1)
-    void regular_or_int(int);          // (2)
-    void scoped_or_int(enum_scoped);   // (3)
-    void scoped_or_int(int);           // (4)
-
-    regular_or_int(REGULAR_A);                  // calls (1) in C++03 and C++11
-    scoped_or_int(enum_scoped::a);              // calls (3) in C++11 but (4) in C++03!
-    scoped_or_int(enum_scoped(enum_scoped::a)); // calls (3) in C++03 and C++11
-
 Here is usage example:
 
     BOOST_SCOPED_ENUM_UT_DECLARE_BEGIN(algae, char)

doc/uncaught_exceptions.qbk

@@ -1,52 +0,0 @@
-[/
- / Copyright (c) 2018 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:uncaught_exceptions uncaught_exceptions]
-
-[simplesect Authors]
-
-* Andrey Semashev
-
-[endsimplesect]
-
-[section Header <boost/core/uncaught_exceptions.hpp>]
-
-The header `<boost/core/uncaught_exceptions.hpp>` defines the `boost::core::uncaught_exceptions` function,
-which is a more portable implementation of the same named function introduced in C++17. The function
-returns the number of the currently pending exceptions. When that function returns a value greater than 0,
-throwing an exception from a destructor can terminate the program.
-
-Unfortunately, the function cannot be implemented on every pre-C++17 compiler, although the most commonly
-used compilers are supported. When the compiler does not provide the necessary functionality,
-`boost::core::uncaught_exceptions` returns a non-zero value if at least one exception is pending (i.e. not
-necessarily the number of pending exceptions), and `BOOST_CORE_UNCAUGHT_EXCEPTIONS_EMULATED` macro
-is defined.
-
-[section Example]
-``
-class my_class
-{
-private:
-    const unsigned int m_exception_count;
-
-public:
-    my_class() : m_exception_count(boost::core::uncaught_exceptions())
-    {
-    }
-
-    ~my_class() noexcept(false)
-    {
-        if (m_exception_count == boost::core::uncaught_exceptions())
-            do_something_potentially_throwing();
-    }
-};
-``
-[endsect]
-
-[endsect]
-
-[endsect]

doc/use_default.qbk

@@ -1,47 +0,0 @@
-[/
-Copyright 2019 Glen Joseph Fernandes
-(glenjofe@gmail.com)
-
-Distributed under the Boost Software License, Version 1.0.
-(http://www.boost.org/LICENSE_1_0.txt)
-]
-
-[section:use_default use_default]
-
-[section Overview]
-
-The header <boost/core/use_default.hpp> provides the type `boost::use_default`
-which is used by other Boost libraries as a sentinel type in a templates to
-indicate defaults.
-
-[endsect]
-
-[section Example]
-
-```
-template<class Derived, class Base,
-   class Value = boost::use_default,
-   class CategoryOrTraversal = boost::use_default,
-   class Reference = boost::use_default,
-   class Difference = boost::use_default>
-class iterator_adaptor;
-
-template<class Value>
-class node_iterator
-    : public iterator_adaptor<node_iterator<Value>, Value*,
-        boost::use_default, boost::forward_traversal_tag>;
-```
-
-[endsect]
-
-[section Reference]
-
-```
-namespace boost {
-  struct use_default { };
-}
-```
-
-[endsect]
-
-[endsect]

include/boost/core/addressof.hpp

@@ -49,20 +49,20 @@ namespace boost {
 namespace detail {
 
 template<class T>
-class addrof_ref {
+class addressof_ref {
 public:
-    BOOST_FORCEINLINE addrof_ref(T& o) BOOST_NOEXCEPT
+    BOOST_FORCEINLINE addressof_ref(T& o) BOOST_NOEXCEPT
         : o_(o) { }
     BOOST_FORCEINLINE operator T&() const BOOST_NOEXCEPT {
         return o_;
     }
 private:
-    addrof_ref& operator=(const addrof_ref&);
+    addressof_ref& operator=(const addressof_ref&);
     T& o_;
 };
 
 template<class T>
-struct addrof {
+struct address_of {
     static BOOST_FORCEINLINE T* get(T& o, long) BOOST_NOEXCEPT {
         return reinterpret_cast<T*>(&
             const_cast<char&>(reinterpret_cast<const volatile char&>(o)));
@@ -76,38 +76,38 @@ struct addrof {
 #if !defined(BOOST_NO_CXX11_DECLTYPE) && \
     (defined(__INTEL_COMPILER) || \
         (defined(__clang__) && !defined(_LIBCPP_VERSION)))
-typedef decltype(nullptr) addrof_null_t;
+typedef decltype(nullptr) addressof_null_t;
 #else
-typedef std::nullptr_t addrof_null_t;
+typedef std::nullptr_t addressof_null_t;
 #endif
 
 template<>
-struct addrof<addrof_null_t> {
-    typedef addrof_null_t type;
+struct address_of<addressof_null_t> {
+    typedef addressof_null_t type;
     static BOOST_FORCEINLINE type* get(type& o, int) BOOST_NOEXCEPT {
         return &o;
     }
 };
 
 template<>
-struct addrof<const addrof_null_t> {
-    typedef const addrof_null_t type;
+struct address_of<const addressof_null_t> {
+    typedef const addressof_null_t type;
     static BOOST_FORCEINLINE type* get(type& o, int) BOOST_NOEXCEPT {
         return &o;
     }
 };
 
 template<>
-struct addrof<volatile addrof_null_t> {
-    typedef volatile addrof_null_t type;
+struct address_of<volatile addressof_null_t> {
+    typedef volatile addressof_null_t type;
     static BOOST_FORCEINLINE type* get(type& o, int) BOOST_NOEXCEPT {
         return &o;
     }
 };
 
 template<>
-struct addrof<const volatile addrof_null_t> {
-    typedef const volatile addrof_null_t type;
+struct address_of<const volatile addressof_null_t> {
+    typedef const volatile addressof_null_t type;
     static BOOST_FORCEINLINE type* get(type& o, int) BOOST_NOEXCEPT {
         return &o;
     }
@@ -125,11 +125,11 @@ template<class T>
 BOOST_FORCEINLINE T*
 addressof(T& o) BOOST_NOEXCEPT
 {
-#if BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x610)) || \
+#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x610)) || \
     BOOST_WORKAROUND(__SUNPRO_CC, <= 0x5120)
-    return boost::detail::addrof<T>::get(o, 0);
+    return detail::address_of<T>::get(o, 0);
 #else
-    return boost::detail::addrof<T>::get(boost::detail::addrof_ref<T>(o), 0);
+    return detail::address_of<T>::get(detail::addressof_ref<T>(o), 0);
 #endif
 }
 
@@ -137,21 +137,21 @@ addressof(T& o) BOOST_NOEXCEPT
 namespace detail {
 
 template<class T>
-struct addrof_result {
+struct addressof_result {
     typedef T* type;
 };
 
 } /* detail */
 
 template<class T, std::size_t N>
-BOOST_FORCEINLINE typename boost::detail::addrof_result<T[N]>::type
+BOOST_FORCEINLINE typename detail::addressof_result<T[N]>::type
 addressof(T (&o)[N]) BOOST_NOEXCEPT
 {
     return &o;
 }
 #endif
 
-#if BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x564))
+#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
 template<class T, std::size_t N>
 BOOST_FORCEINLINE
 T (*addressof(T (&o)[N]) BOOST_NOEXCEPT)[N]
@@ -170,79 +170,79 @@ const T (*addressof(const T (&o)[N]) BOOST_NOEXCEPT)[N]
 namespace detail {
 
 template<class T>
-T addrof_declval() BOOST_NOEXCEPT;
+T addressof_declval() BOOST_NOEXCEPT;
 
 template<class>
-struct addrof_void {
+struct addressof_void {
     typedef void type;
 };
 
 template<class T, class E = void>
-struct addrof_member_operator {
+struct addressof_member_operator {
     static constexpr bool value = false;
 };
 
 template<class T>
-struct addrof_member_operator<T, typename
-    addrof_void<decltype(addrof_declval<T&>().operator&())>::type> {
+struct addressof_member_operator<T, typename
+    addressof_void<decltype(addressof_declval<T&>().operator&())>::type> {
     static constexpr bool value = true;
 };
 
 #if BOOST_WORKAROUND(BOOST_INTEL, < 1600)
-struct addrof_addressable { };
+struct addressof_addressable { };
 
-addrof_addressable*
-operator&(addrof_addressable&) BOOST_NOEXCEPT;
+addressof_addressable*
+operator&(addressof_addressable&) BOOST_NOEXCEPT;
 #endif
 
 template<class T, class E = void>
-struct addrof_non_member_operator {
+struct addressof_non_member_operator {
     static constexpr bool value = false;
 };
 
 template<class T>
-struct addrof_non_member_operator<T, typename
-    addrof_void<decltype(operator&(addrof_declval<T&>()))>::type> {
+struct addressof_non_member_operator<T, typename
+    addressof_void<decltype(operator&(addressof_declval<T&>()))>::type> {
     static constexpr bool value = true;
 };
 
 template<class T, class E = void>
-struct addrof_expression {
+struct addressof_expression {
     static constexpr bool value = false;
 };
 
 template<class T>
-struct addrof_expression<T,
-    typename addrof_void<decltype(&addrof_declval<T&>())>::type> {
+struct addressof_expression<T,
+    typename addressof_void<decltype(&addressof_declval<T&>())>::type> {
     static constexpr bool value = true;
 };
 
 template<class T>
-struct addrof_is_constexpr {
-    static constexpr bool value = addrof_expression<T>::value &&
-        !addrof_member_operator<T>::value &&
-        !addrof_non_member_operator<T>::value;
+struct addressof_is_constexpr {
+    static constexpr bool value = addressof_expression<T>::value &&
+        !addressof_member_operator<T>::value &&
+        !addressof_non_member_operator<T>::value;
 };
 
 template<bool E, class T>
-struct addrof_if { };
+struct addressof_if { };
 
 template<class T>
-struct addrof_if<true, T> {
+struct addressof_if<true, T> {
     typedef T* type;
 };
 
 template<class T>
 BOOST_FORCEINLINE
-typename addrof_if<!addrof_is_constexpr<T>::value, T>::type
+typename addressof_if<!addressof_is_constexpr<T>::value, T>::type
 addressof(T& o) BOOST_NOEXCEPT
 {
-    return addrof<T>::get(addrof_ref<T>(o), 0);
+    return address_of<T>::get(addressof_ref<T>(o), 0);
 }
 
 template<class T>
 constexpr BOOST_FORCEINLINE
-typename addrof_if<addrof_is_constexpr<T>::value, T>::type
+typename addressof_if<addressof_is_constexpr<T>::value, T>::type
 addressof(T& o) BOOST_NOEXCEPT
 {
     return &o;
@@ -254,7 +254,7 @@ template<class T>
 constexpr BOOST_FORCEINLINE T*
 addressof(T& o) BOOST_NOEXCEPT
 {
-    return boost::detail::addressof(o);
+    return detail::addressof(o);
 }
 #endif
 

include/boost/core/alloc_construct.hpp

@@ -1,169 +0,0 @@
-/*
-Copyright 2019 Glen Joseph Fernandes
-(glenjofe@gmail.com)
-
-Distributed under the Boost Software License, Version 1.0.
-(http://www.boost.org/LICENSE_1_0.txt)
-*/
-#ifndef BOOST_CORE_ALLOC_CONSTRUCT_HPP
-#define BOOST_CORE_ALLOC_CONSTRUCT_HPP
-
-#include <boost/core/noinit_adaptor.hpp>
-
-namespace boost {
-
-template<class A, class T>
-inline void
-alloc_destroy(A& a, T* p)
-{
-    boost::allocator_destroy(a, p);
-}
-
-template<class A, class T>
-inline void
-alloc_destroy_n(A& a, T* p, std::size_t n)
-{
-    while (n > 0) {
-        boost::allocator_destroy(a, p + --n);
-    }
-}
-
-template<class A, class T>
-inline void
-alloc_destroy(noinit_adaptor<A>&, T* p)
-{
-    p->~T();
-}
-
-template<class A, class T>
-inline void
-alloc_destroy_n(noinit_adaptor<A>&, T* p, std::size_t n)
-{
-    while (n > 0) {
-        p[--n].~T();
-    }
-}
-
-namespace detail {
-
-template<class A, class T>
-class alloc_destroyer {
-public:
-    alloc_destroyer(A& a, T* p) BOOST_NOEXCEPT
-        : a_(a),
-          p_(p),
-          n_(0) { }
-
-    ~alloc_destroyer() {
-        boost::alloc_destroy_n(a_, p_, n_);
-    }
-
-    std::size_t& size() BOOST_NOEXCEPT {
-        return n_;
-    }
-
-private:
-    alloc_destroyer(const alloc_destroyer&);
-    alloc_destroyer& operator=(const alloc_destroyer&);
-
-    A& a_;
-    T* p_;
-    std::size_t n_;
-};
-
-} /* detail */
-
-template<class A, class T>
-inline void
-alloc_construct(A& a, T* p)
-{
-    boost::allocator_construct(a, p);
-}
-
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-template<class A, class T, class U, class... V>
-inline void
-alloc_construct(A& a, T* p, U&& u, V&&... v)
-{
-    boost::allocator_construct(a, p, std::forward<U>(u),
-        std::forward<V>(v)...);
-}
-#else
-template<class A, class T, class U>
-inline void
-alloc_construct(A& a, T* p, U&& u)
-{
-    boost::allocator_construct(a, p, std::forward<U>(u));
-}
-#endif
-#else
-template<class A, class T, class U>
-inline void
-alloc_construct(A& a, T* p, const U& u)
-{
-    boost::allocator_construct(a, p, u);
-}
-
-template<class A, class T, class U>
-inline void
-alloc_construct(A& a, T* p, U& u)
-{
-    boost::allocator_construct(a, p, u);
-}
-#endif
-
-template<class A, class T>
-inline void
-alloc_construct_n(A& a, T* p, std::size_t n)
-{
-    detail::alloc_destroyer<A, T> hold(a, p);
-    for (std::size_t& i = hold.size(); i < n; ++i) {
-        boost::allocator_construct(a, p + i);
-    }
-    hold.size() = 0;
-}
-
-template<class A, class T>
-inline void
-alloc_construct_n(A& a, T* p, std::size_t n, const T* l, std::size_t m)
-{
-    detail::alloc_destroyer<A, T> hold(a, p);
-    for (std::size_t& i = hold.size(); i < n; ++i) {
-        boost::allocator_construct(a, p + i, l[i % m]);
-    }
-    hold.size() = 0;
-}
-
-template<class A, class T, class I>
-inline void
-alloc_construct_n(A& a, T* p, std::size_t n, I b)
-{
-    detail::alloc_destroyer<A, T> hold(a, p);
-    for (std::size_t& i = hold.size(); i < n; void(++i), void(++b)) {
-        boost::allocator_construct(a, p + i, *b);
-    }
-    hold.size() = 0;
-}
-
-template<class A, class T>
-inline void
-alloc_construct(noinit_adaptor<A>&, T* p)
-{
-    ::new(static_cast<void*>(p)) T;
-}
-
-template<class A, class T>
-inline void
-alloc_construct_n(noinit_adaptor<A>& a, T* p, std::size_t n)
-{
-    detail::alloc_destroyer<noinit_adaptor<A>, T> hold(a, p);
-    for (std::size_t& i = hold.size(); i < n; ++i) {
-        ::new(static_cast<void*>(p + i)) T;
-    }
-    hold.size() = 0;
-}
-
-} /* boost */
-
-#endif

include/boost/core/allocator_access.hpp

@@ -1,633 +0,0 @@
-/*
-Copyright 2020 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_ALLOCATOR_ACCESS_HPP
-#define BOOST_CORE_ALLOCATOR_ACCESS_HPP
-
-#include <boost/config.hpp>
-#if !defined(BOOST_NO_CXX11_ALLOCATOR)
-#include <boost/core/pointer_traits.hpp>
-#if !defined(BOOST_MSVC)
-#include <limits>
-#else
-#include <memory>
-#endif
-#include <type_traits>
-#endif
-#include <new>
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-#include <utility>
-#endif
-
-namespace boost {
-namespace detail {
-
-#if defined(BOOST_NO_CXX11_ALLOCATOR)
-struct alloc_false {
-    BOOST_STATIC_CONSTEXPR bool value = false;
-};
-#else
-template<class>
-struct alloc_void {
-    typedef void type;
-};
-#endif
-
-} /* detail */
-
-template<class A>
-struct allocator_value_type {
-    typedef typename A::value_type type;
-};
-
-#if defined(BOOST_NO_CXX11_ALLOCATOR)
-template<class A>
-struct allocator_pointer {
-    typedef typename A::pointer type;
-};
-#elif defined(BOOST_MSVC)
-template<class A>
-struct allocator_pointer {
-    typedef typename std::allocator_traits<A>::pointer type;
-};
-#else
-template<class A, class = void>
-struct allocator_pointer {
-    typedef typename A::value_type* type;
-};
-
-template<class A>
-struct allocator_pointer<A,
-    typename detail::alloc_void<typename A::pointer>::type> {
-    typedef typename A::pointer type;
-};
-#endif
-
-#if defined(BOOST_NO_CXX11_ALLOCATOR)
-template<class A>
-struct allocator_const_pointer {
-    typedef typename A::const_pointer type;
-};
-#elif defined(BOOST_MSVC)
-template<class A>
-struct allocator_const_pointer {
-    typedef typename std::allocator_traits<A>::const_pointer type;
-};
-#else
-template<class A, class = void>
-struct allocator_const_pointer {
-    typedef typename pointer_traits<typename
-        allocator_pointer<A>::type>::template
-            rebind_to<const typename A::value_type>::type type;
-};
-
-template<class A>
-struct allocator_const_pointer<A,
-    typename detail::alloc_void<typename A::const_pointer>::type> {
-    typedef typename A::const_pointer type;
-};
-#endif
-
-#if defined(BOOST_NO_CXX11_ALLOCATOR)
-template<class A>
-struct allocator_void_pointer {
-    typedef typename A::template rebind<void>::other::pointer type;
-};
-#else
-template<class A, class = void>
-struct allocator_void_pointer {
-     typedef typename pointer_traits<typename
-        allocator_pointer<A>::type>::template
-            rebind_to<void>::type type;
-};
-
-template<class A>
-struct allocator_void_pointer<A,
-    typename detail::alloc_void<typename A::void_pointer>::type> {
-    typedef typename A::void_pointer type;
-};
-#endif
-
-#if defined(BOOST_NO_CXX11_ALLOCATOR)
-template<class A>
-struct allocator_const_void_pointer {
-    typedef typename A::template rebind<void>::other::const_pointer type;
-};
-#else
-template<class A, class = void>
-struct allocator_const_void_pointer {
-     typedef typename pointer_traits<typename
-        allocator_pointer<A>::type>::template
-            rebind_to<const void>::type type;
-};
-
-template<class A>
-struct allocator_const_void_pointer<A,
-    typename detail::alloc_void<typename A::const_void_pointer>::type> {
-    typedef typename A::const_void_pointer type;
-};
-#endif
-
-#if defined(BOOST_NO_CXX11_ALLOCATOR)
-template<class A>
-struct allocator_difference_type {
-    typedef typename A::difference_type type;
-};
-#elif defined(BOOST_MSVC)
-template<class A>
-struct allocator_difference_type {
-    typedef typename std::allocator_traits<A>::difference_type type;
-};
-#else
-template<class A, class = void>
-struct allocator_difference_type {
-    typedef typename pointer_traits<typename
-        allocator_pointer<A>::type>::difference_type type;
-};
-
-template<class A>
-struct allocator_difference_type<A,
-    typename detail::alloc_void<typename A::difference_type>::type> {
-    typedef typename A::difference_type type;
-};
-#endif
-
-#if defined(BOOST_NO_CXX11_ALLOCATOR)
-template<class A>
-struct allocator_size_type {
-    typedef typename A::size_type type;
-};
-#elif defined(BOOST_MSVC)
-template<class A>
-struct allocator_size_type {
-    typedef typename std::allocator_traits<A>::size_type type;
-};
-#else
-template<class A, class = void>
-struct allocator_size_type {
-    typedef typename std::make_unsigned<typename
-        allocator_difference_type<A>::type>::type type;
-};
-
-template<class A>
-struct allocator_size_type<A,
-    typename detail::alloc_void<typename A::size_type>::type> {
-    typedef typename A::size_type type;
-};
-#endif
-
-#if defined(BOOST_NO_CXX11_ALLOCATOR)
-template<class A>
-struct allocator_propagate_on_container_copy_assignment {
-    typedef detail::alloc_false type;
-};
-#else
-template<class A, class = void>
-struct allocator_propagate_on_container_copy_assignment {
-    typedef std::false_type type;
-};
-
-template<class A>
-struct allocator_propagate_on_container_copy_assignment<A,
-    typename detail::alloc_void<typename
-        A::propagate_on_container_copy_assignment>::type> {
-    typedef typename A::propagate_on_container_copy_assignment type;
-};
-#endif
-
-#if defined(BOOST_NO_CXX11_ALLOCATOR)
-template<class A>
-struct allocator_propagate_on_container_move_assignment {
-    typedef detail::alloc_false type;
-};
-#else
-template<class A, class = void>
-struct allocator_propagate_on_container_move_assignment {
-    typedef std::false_type type;
-};
-
-template<class A>
-struct allocator_propagate_on_container_move_assignment<A,
-    typename detail::alloc_void<typename
-        A::propagate_on_container_move_assignment>::type> {
-    typedef typename A::propagate_on_container_move_assignment type;
-};
-#endif
-
-#if defined(BOOST_NO_CXX11_ALLOCATOR)
-template<class A>
-struct allocator_propagate_on_container_swap {
-    typedef detail::alloc_false type;
-};
-#else
-template<class A, class = void>
-struct allocator_propagate_on_container_swap {
-    typedef std::false_type type;
-};
-
-template<class A>
-struct allocator_propagate_on_container_swap<A,
-    typename detail::alloc_void<typename
-        A::propagate_on_container_swap>::type> {
-    typedef typename A::propagate_on_container_swap type;
-};
-#endif
-
-#if defined(BOOST_NO_CXX11_ALLOCATOR)
-template<class A>
-struct allocator_is_always_equal {
-    typedef detail::alloc_false type;
-};
-#else
-template<class A, class = void>
-struct allocator_is_always_equal {
-    typedef typename std::is_empty<A>::type type;
-};
-
-template<class A>
-struct allocator_is_always_equal<A,
-    typename detail::alloc_void<typename A::is_always_equal>::type> {
-    typedef typename A::is_always_equal type;
-};
-#endif
-
-#if defined(BOOST_NO_CXX11_ALLOCATOR)
-template<class A, class T>
-struct allocator_rebind {
-    typedef typename A::template rebind<T>::other type;
-};
-#elif defined(BOOST_MSVC)
-template<class A, class T>
-struct allocator_rebind {
-    typedef typename std::allocator_traits<A>::template rebind_alloc<T> type;
-};
-#else
-namespace detail {
-
-template<class, class>
-struct alloc_to { };
-
-template<template<class, class...> class A, class T, class U, class... V>
-struct alloc_to<A<U, V...>, T> {
-    typedef A<T, V...> type;
-};
-
-} /* detail */
-
-template<class A, class T, class = void>
-struct allocator_rebind {
-    typedef typename detail::alloc_to<A, T>::type type;
-};
-
-template<class A, class T>
-struct allocator_rebind<A, T,
-    typename detail::alloc_void<typename A::template rebind<T>::other>::type> {
-    typedef typename A::template rebind<T>::other type;
-};
-#endif
-
-template<class A>
-inline typename allocator_pointer<A>::type
-allocator_allocate(A& a, typename allocator_size_type<A>::type n)
-{
-    return a.allocate(n);
-}
-
-template<class A>
-inline void
-allocator_deallocate(A& a, typename allocator_pointer<A>::type p,
-    typename allocator_size_type<A>::type n)
-{
-    a.deallocate(p, n);
-}
-
-#if defined(BOOST_NO_CXX11_ALLOCATOR)
-template<class A>
-inline typename allocator_pointer<A>::type
-allocator_allocate(A& a, typename allocator_size_type<A>::type n,
-    typename allocator_const_void_pointer<A>::type h)
-{
-    return a.allocate(n, h);
-}
-#elif defined(BOOST_MSVC)
-template<class A>
-inline typename allocator_pointer<A>::type
-allocator_allocate(A& a, typename allocator_size_type<A>::type n,
-    typename allocator_const_void_pointer<A>::type h)
-{
-    return std::allocator_traits<A>::allocate(a, n, h);
-}
-#else
-namespace detail {
-
-template<class, class, class, class = void>
-struct alloc_has_allocate {
-    BOOST_STATIC_CONSTEXPR bool value = false;
-};
-
-template<class A, class N, class H>
-struct alloc_has_allocate<A, N, H,
-    typename alloc_void<decltype(std::declval<A&>().allocate(std::declval<N>(),
-        std::declval<H>()))>::type> {
-    BOOST_STATIC_CONSTEXPR bool value = true;
-};
-
-} /* detail */
-
-template<class A>
-inline typename std::enable_if<detail::alloc_has_allocate<A,
-    typename allocator_size_type<A>::type,
-        typename allocator_const_void_pointer<A>::type>::value,
-            typename allocator_pointer<A>::type>::type
-allocator_allocate(A& a, typename allocator_size_type<A>::type n,
-    typename allocator_const_void_pointer<A>::type h)
-{
-    return a.allocate(n, h);
-}
-
-template<class A>
-inline typename std::enable_if<!detail::alloc_has_allocate<A,
-    typename allocator_size_type<A>::type,
-        typename allocator_const_void_pointer<A>::type>::value,
-            typename allocator_pointer<A>::type>::type
-allocator_allocate(A& a, typename allocator_size_type<A>::type n,
-    typename allocator_const_void_pointer<A>::type)
-{
-    return a.allocate(n);
-}
-#endif
-
-#if defined(BOOST_NO_CXX11_ALLOCATOR)
-template<class A, class T>
-inline void
-allocator_construct(A&, T* p)
-{
-    ::new((void*)p) T();
-}
-
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-template<class A, class T, class V, class... Args>
-inline void
-allocator_construct(A&, T* p, V&& v, Args&&... args)
-{
-    ::new((void*)p) T(std::forward<V>(v), std::forward<Args>(args)...);
-}
-#else
-template<class A, class T, class V>
-inline void
-allocator_construct(A&, T* p, V&& v)
-{
-    ::new((void*)p) T(std::forward<V>(v));
-}
-#endif
-#else
-template<class A, class T, class V>
-inline void
-allocator_construct(A&, T* p, const V& v)
-{
-    ::new((void*)p) T(v);
-}
-
-template<class A, class T, class V>
-inline void
-allocator_construct(A&, T* p, V& v)
-{
-    ::new((void*)p) T(v);
-}
-#endif
-#elif defined(BOOST_MSVC)
-template<class A, class T, class... Args>
-inline void
-allocator_construct(A& a, T* p, Args&&... args)
-{
-    std::allocator_traits<A>::construct(a, p, std::forward<Args>(args)...);
-}
-#else
-namespace detail {
-
-template<class, class, class, class...>
-struct alloc_has_construct {
-    BOOST_STATIC_CONSTEXPR bool value = false;
-};
-
-template<class A, class T, class... Args>
-struct alloc_has_construct<typename alloc_void<decltype(std::declval<A
-    &>().construct(std::declval<T*>(), std::declval<Args&&>()...))>::type,
-        A, T, Args...> {
-    BOOST_STATIC_CONSTEXPR bool value = true;
-};
-
-} /* detail */
-
-template<class A, class T, class... Args>
-inline typename std::enable_if<detail::alloc_has_construct<void, A, T,
-    Args...>::value>::type
-allocator_construct(A& a, T* p, Args&&... args)
-{
-    a.construct(p, std::forward<Args>(args)...);
-}
-
-template<class A, class T, class... Args>
-inline typename std::enable_if<!detail::alloc_has_construct<void, A, T,
-    Args...>::value>::type
-allocator_construct(A&, T* p, Args&&... args)
-{
-    ::new((void*)p) T(std::forward<Args>(args)...);
-}
-#endif
-
-#if defined(BOOST_NO_CXX11_ALLOCATOR)
-template<class A, class T>
-inline void
-allocator_destroy(A&, T* p)
-{
-    p->~T();
-    (void)p;
-}
-#elif defined(BOOST_MSVC)
-template<class A, class T>
-inline void
-allocator_destroy(A& a, T* p)
-{
-    std::allocator_traits<A>::destroy(a, p);
-}
-#else
-namespace detail {
-
-template<class, class, class = void>
-struct alloc_has_destroy {
-    BOOST_STATIC_CONSTEXPR bool value = false;
-};
-
-template<class A, class T>
-struct alloc_has_destroy<A, T,
-    typename alloc_void<decltype(std::declval<A
-        &>().destroy(std::declval<T*>()))>::type> {
-    BOOST_STATIC_CONSTEXPR bool value = true;
-};
-
-} /* detail */
-
-template<class A, class T>
-inline typename std::enable_if<detail::alloc_has_destroy<A, T>::value>::type
-allocator_destroy(A& a, T* p)
-{
-    a.destroy(p);
-}
-
-template<class A, class T>
-inline typename std::enable_if<!detail::alloc_has_destroy<A, T>::value>::type
-allocator_destroy(A&, T* p)
-{
-    p->~T();
-    (void)p;
-}
-#endif
-
-#if defined(BOOST_NO_CXX11_ALLOCATOR)
-template<class A>
-inline typename allocator_size_type<A>::type
-allocator_max_size(const A& a)
-{
-    return a.max_size();
-}
-#elif defined(BOOST_MSVC)
-template<class A>
-inline typename allocator_size_type<A>::type
-allocator_max_size(const A& a)
-{
-    return std::allocator_traits<A>::max_size(a);
-}
-#else
-namespace detail {
-
-template<class, class = void>
-struct alloc_has_max_size {
-    BOOST_STATIC_CONSTEXPR bool value = false;
-};
-
-template<class A>
-struct alloc_has_max_size<A,
-    typename alloc_void<decltype(std::declval<const
-        A&>().max_size())>::type> {
-    BOOST_STATIC_CONSTEXPR bool value = true;
-};
-
-} /* detail */
-
-template<class A>
-inline typename std::enable_if<detail::alloc_has_max_size<A>::value,
-    typename allocator_size_type<A>::type>::type
-allocator_max_size(const A& a)
-{
-    return a.max_size();
-}
-
-template<class A>
-inline typename std::enable_if<!detail::alloc_has_max_size<A>::value,
-    typename allocator_size_type<A>::type>::type
-allocator_max_size(const A&)
-{
-    return (std::numeric_limits<typename
-        allocator_size_type<A>::type>::max)() / sizeof(typename A::value_type);
-}
-#endif
-
-#if defined(BOOST_NO_CXX11_ALLOCATOR)
-template<class A>
-inline A
-allocator_select_on_container_copy_construction(const A& a)
-{
-    return a;
-}
-#elif defined(BOOST_MSVC)
-template<class A>
-inline A
-allocator_select_on_container_copy_construction(const A& a)
-{
-    return std::allocator_traits<A>::select_on_container_copy_construction(a);
-}
-#else
-namespace detail {
-
-template<class, class = void>
-struct alloc_has_soccc {
-    BOOST_STATIC_CONSTEXPR bool value = false;
-};
-
-template<class A>
-struct alloc_has_soccc<A,
-    typename alloc_void<decltype(std::declval<const
-        A&>().select_on_container_copy_construction())>::type> {
-    BOOST_STATIC_CONSTEXPR bool value = true;
-};
-
-} /* detail */
-
-template<class A>
-inline typename std::enable_if<detail::alloc_has_soccc<A>::value, A>::type
-allocator_select_on_container_copy_construction(const A& a)
-{
-    return a.select_on_container_copy_construction();
-}
-
-template<class A>
-inline typename std::enable_if<!detail::alloc_has_soccc<A>::value, A>::type
-allocator_select_on_container_copy_construction(const A& a)
-{
-    return a;
-}
-#endif
-
-#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
-template<class A>
-using allocator_value_type_t = typename allocator_value_type<A>::type;
-
-template<class A>
-using allocator_pointer_t = typename allocator_pointer<A>::type;
-
-template<class A>
-using allocator_const_pointer_t = typename allocator_const_pointer<A>::type;
-
-template<class A>
-using allocator_void_pointer_t = typename allocator_void_pointer<A>::type;
-
-template<class A>
-using allocator_const_void_pointer_t =
-    typename allocator_const_void_pointer<A>::type;
-
-template<class A>
-using allocator_difference_type_t =
-    typename allocator_difference_type<A>::type;
-
-template<class A>
-using allocator_size_type_t = typename allocator_size_type<A>::type;
-
-template<class A>
-using allocator_propagate_on_container_copy_assignment_t =
-    typename allocator_propagate_on_container_copy_assignment<A>::type;
-
-template<class A>
-using allocator_propagate_on_container_move_assignment_t =
-    typename allocator_propagate_on_container_move_assignment<A>::type;
-
-template<class A>
-using allocator_propagate_on_container_swap_t =
-    typename allocator_propagate_on_container_swap<A>::type;
-
-template<class A>
-using allocator_is_always_equal_t =
-    typename allocator_is_always_equal<A>::type;
-
-template<class A, class T>
-using allocator_rebind_t = typename allocator_rebind<A, T>::type;
-#endif
-
-} /* boost */
-
-#endif

include/boost/core/checked_delete.hpp

@@ -7,8 +7,6 @@
 # pragma once
 #endif
 
-#include <boost/config.hpp>
-
 //
 //  boost/checked_delete.hpp
 //
@@ -28,7 +26,7 @@ namespace boost
 
 // verify that types are complete for increased safety
 
-template<class T> inline void checked_delete(T * x) BOOST_NOEXCEPT
+template<class T> inline void checked_delete(T * x)
 {
     // intentionally complex - simplification causes regressions
     typedef char type_must_be_complete[ sizeof(T)? 1: -1 ];
@@ -36,7 +34,7 @@ template<class T> inline void checked_delete(T * x) BOOST_NOEXCEPT
     delete x;
 }
 
-template<class T> inline void checked_array_delete(T * x) BOOST_NOEXCEPT
+template<class T> inline void checked_array_delete(T * x)
 {
     typedef char type_must_be_complete[ sizeof(T)? 1: -1 ];
     (void) sizeof(type_must_be_complete);
@@ -48,7 +46,7 @@ template<class T> struct checked_deleter
     typedef void result_type;
     typedef T * argument_type;
 
-    void operator()(T * x) const BOOST_NOEXCEPT
+    void operator()(T * x) const
     {
         // boost:: disables ADL
         boost::checked_delete(x);
@@ -60,7 +58,7 @@ template<class T> struct checked_array_deleter
     typedef void result_type;
     typedef T * argument_type;
 
-    void operator()(T * x) const BOOST_NOEXCEPT
+    void operator()(T * x) const
     {
         boost::checked_array_delete(x);
     }

include/boost/core/default_allocator.hpp

@@ -1,148 +0,0 @@
-/*
-Copyright 2019 Glen Joseph Fernandes
-(glenjofe@gmail.com)
-
-Distributed under the Boost Software License, Version 1.0.
-(http://www.boost.org/LICENSE_1_0.txt)
-*/
-#ifndef BOOST_CORE_DEFAULT_ALLOCATOR_HPP
-#define BOOST_CORE_DEFAULT_ALLOCATOR_HPP
-
-#include <boost/config.hpp>
-#include <new>
-
-namespace boost {
-
-#if defined(BOOST_NO_EXCEPTIONS)
-BOOST_NORETURN void throw_exception(const std::exception&);
-#endif
-
-namespace default_ {
-
-struct true_type {
-    typedef bool value_type;
-    typedef true_type type;
-
-    BOOST_STATIC_CONSTANT(bool, value = true);
-
-    BOOST_CONSTEXPR operator bool() const BOOST_NOEXCEPT {
-        return true;
-    }
-
-    BOOST_CONSTEXPR bool operator()() const BOOST_NOEXCEPT {
-        return true;
-    }
-};
-
-template<class T>
-struct add_reference {
-    typedef T& type;
-};
-
-template<>
-struct add_reference<void> {
-    typedef void type;
-};
-
-template<>
-struct add_reference<const void> {
-    typedef const void type;
-};
-
-template<class T>
-struct default_allocator {
-    typedef T value_type;
-    typedef T* pointer;
-    typedef const T* const_pointer;
-    typedef typename add_reference<T>::type reference;
-    typedef typename add_reference<const T>::type const_reference;
-    typedef std::size_t size_type;
-    typedef std::ptrdiff_t difference_type;
-    typedef true_type propagate_on_container_move_assignment;
-    typedef true_type is_always_equal;
-
-    template<class U>
-    struct rebind {
-        typedef default_allocator<U> other;
-    };
-
-#if !defined(BOOST_NO_CXX11_DEFAULTED_FUNCTIONS)
-    default_allocator() = default;
-#else
-    BOOST_CONSTEXPR default_allocator() BOOST_NOEXCEPT { }
-#endif
-
-    template<class U>
-    BOOST_CONSTEXPR default_allocator(const default_allocator<U>&)
-        BOOST_NOEXCEPT { }
-
-    BOOST_CONSTEXPR std::size_t max_size() const BOOST_NOEXCEPT {
-        return static_cast<std::size_t>(-1) / (2 < sizeof(T) ? sizeof(T) : 2);
-    }
-
-#if !defined(BOOST_NO_EXCEPTIONS)
-    T* allocate(std::size_t n) {
-        if (n > max_size()) {
-            throw std::bad_alloc();
-        }
-        return static_cast<T*>(::operator new(sizeof(T) * n));
-    }
-
-    void deallocate(T* p, std::size_t) {
-        ::operator delete(p);
-    }
-#else
-    T* allocate(std::size_t n) {
-        if (n > max_size()) {
-            boost::throw_exception(std::bad_alloc());
-        }
-        void* p = ::operator new(sizeof(T) * n, std::nothrow);
-        if (!p) {
-            boost::throw_exception(std::bad_alloc());
-        }
-        return static_cast<T*>(p);
-    }
-
-    void deallocate(T* p, std::size_t) {
-        ::operator delete(p, std::nothrow);
-    }
-#endif
-
-#if (defined(BOOST_LIBSTDCXX_VERSION) && BOOST_LIBSTDCXX_VERSION < 60000) || \
-    defined(BOOST_NO_CXX11_ALLOCATOR)
-    template<class U, class V>
-    void construct(U* p, const V& v) {
-        ::new(p) U(v);
-    }
-
-    template<class U>
-    void destroy(U* p) {
-        p->~U();
-        (void)p;
-    }
-#endif
-};
-
-template<class T, class U>
-BOOST_CONSTEXPR inline bool
-operator==(const default_allocator<T>&,
-    const default_allocator<U>&) BOOST_NOEXCEPT
-{
-    return true;
-}
-
-template<class T, class U>
-BOOST_CONSTEXPR inline bool
-operator!=(const default_allocator<T>&,
-    const default_allocator<U>&) BOOST_NOEXCEPT
-{
-    return false;
-}
-
-} /* default_ */
-
-using default_::default_allocator;
-
-} /* boost */
-
-#endif

include/boost/core/empty_value.hpp

@@ -1,146 +0,0 @@
-/*
-Copyright 2018 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_EMPTY_VALUE_HPP
-#define BOOST_CORE_EMPTY_VALUE_HPP
-
-#include <boost/config.hpp>
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-#include <utility>
-#endif
-
-#if defined(BOOST_GCC_VERSION) && (BOOST_GCC_VERSION >= 40700)
-#define BOOST_DETAIL_EMPTY_VALUE_BASE
-#elif defined(BOOST_INTEL) && defined(_MSC_VER) && (_MSC_VER >= 1800)
-#define BOOST_DETAIL_EMPTY_VALUE_BASE
-#elif defined(BOOST_MSVC) && (BOOST_MSVC >= 1800)
-#define BOOST_DETAIL_EMPTY_VALUE_BASE
-#elif defined(BOOST_CLANG) && !defined(__CUDACC__)
-#if __has_feature(is_empty) && __has_feature(is_final)
-#define BOOST_DETAIL_EMPTY_VALUE_BASE
-#endif
-#endif
-
-namespace boost {
-
-template<class T>
-struct use_empty_value_base {
-    enum {
-#if defined(BOOST_DETAIL_EMPTY_VALUE_BASE)
-        value = __is_empty(T) && !__is_final(T)
-#else
-        value = false
-#endif
-    };
-};
-
-struct empty_init_t { };
-
-namespace empty_ {
-
-template<class T, unsigned N = 0,
-    bool E = boost::use_empty_value_base<T>::value>
-class empty_value {
-public:
-    typedef T type;
-
-#if !defined(BOOST_NO_CXX11_DEFAULTED_FUNCTIONS)
-    empty_value() = default;
-#else
-    empty_value() { }
-#endif
-
-    empty_value(boost::empty_init_t)
-        : value_() { }
-
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-    template<class U, class... Args>
-    empty_value(boost::empty_init_t, U&& value, Args&&... args)
-        : value_(std::forward<U>(value), std::forward<Args>(args)...) { }
-#else
-    template<class U>
-    empty_value(boost::empty_init_t, U&& value)
-        : value_(std::forward<U>(value)) { }
-#endif
-#else
-    template<class U>
-    empty_value(boost::empty_init_t, const U& value)
-        : value_(value) { }
-
-    template<class U>
-    empty_value(boost::empty_init_t, U& value)
-        : value_(value) { }
-#endif
-
-    const T& get() const BOOST_NOEXCEPT {
-        return value_;
-    }
-
-    T& get() BOOST_NOEXCEPT {
-        return value_;
-    }
-
-private:
-    T value_;
-};
-
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
-template<class T, unsigned N>
-class empty_value<T, N, true>
-    : T {
-public:
-    typedef T type;
-
-#if !defined(BOOST_NO_CXX11_DEFAULTED_FUNCTIONS)
-    empty_value() = default;
-#else
-    empty_value() { }
-#endif
-
-    empty_value(boost::empty_init_t)
-        : T() { }
-
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-    template<class U, class... Args>
-    empty_value(boost::empty_init_t, U&& value, Args&&... args)
-        : T(std::forward<U>(value), std::forward<Args>(args)...) { }
-#else
-    template<class U>
-    empty_value(boost::empty_init_t, U&& value)
-        : T(std::forward<U>(value)) { }
-#endif
-#else
-    template<class U>
-    empty_value(boost::empty_init_t, const U& value)
-        : T(value) { }
-
-    template<class U>
-    empty_value(boost::empty_init_t, U& value)
-        : T(value) { }
-#endif
-
-    const T& get() const BOOST_NOEXCEPT {
-        return *this;
-    }
-
-    T& get() BOOST_NOEXCEPT {
-        return *this;
-    }
-};
-#endif
-
-} /* empty_ */
-
-using empty_::empty_value;
-
-BOOST_INLINE_CONSTEXPR empty_init_t empty_init = empty_init_t();
-
-} /* boost */
-
-#endif

include/boost/core/exchange.hpp

@@ -1,49 +0,0 @@
-/*
-Copyright 2018 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_EXCHANGE_HPP
-#define BOOST_CORE_EXCHANGE_HPP
-
-#include <boost/config.hpp>
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-#include <boost/config/workaround.hpp>
-#include <utility>
-#endif
-
-namespace boost {
-
-#if defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-template<class T, class U>
-inline T exchange(T& t, const U& u)
-{
-    T v = t;
-    t = u;
-    return v;
-}
-#else
-#if BOOST_WORKAROUND(BOOST_MSVC, < 1800)
-template<class T, class U>
-inline T exchange(T& t, U&& u)
-{
-    T v = std::move(t);
-    t = std::forward<U>(u);
-    return v;
-}
-#else
-template<class T, class U = T>
-BOOST_CXX14_CONSTEXPR inline T exchange(T& t, U&& u)
-{
-    T v = std::move(t);
-    t = std::forward<U>(u);
-    return v;
-}
-#endif
-#endif
-
-} /* boost */
-
-#endif

include/boost/core/explicit_operator_bool.hpp

@@ -19,7 +19,6 @@
 #define BOOST_CORE_EXPLICIT_OPERATOR_BOOL_HPP
 
 #include <boost/config.hpp>
-#include <boost/config/workaround.hpp>
 
 #ifdef BOOST_HAS_PRAGMA_ONCE
 #pragma once
@@ -53,8 +52,6 @@
         return !this->operator! ();\
     }
 
-#if !BOOST_WORKAROUND(BOOST_GCC, < 40700)
-
 /*!
  * \brief The macro defines a constexpr explicit operator of conversion to \c bool
  *
@@ -68,12 +65,6 @@
         return !this->operator! ();\
     }
 
-#else
-
-#define BOOST_CONSTEXPR_EXPLICIT_OPERATOR_BOOL() BOOST_EXPLICIT_OPERATOR_BOOL_NOEXCEPT()
-
-#endif
-
 #else // !defined(BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS)
 
 #if (defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x530)) && !defined(BOOST_NO_COMPILER_CONFIG)

include/boost/core/first_scalar.hpp

@@ -1,45 +0,0 @@
-/*
-Copyright 2019 Glen Joseph Fernandes
-(glenjofe@gmail.com)
-
-Distributed under the Boost Software License, Version 1.0.
-(http://www.boost.org/LICENSE_1_0.txt)
-*/
-#ifndef BOOST_CORE_FIRST_SCALAR_HPP
-#define BOOST_CORE_FIRST_SCALAR_HPP
-
-#include <boost/config.hpp>
-#include <cstddef>
-
-namespace boost {
-namespace detail {
-
-template<class T>
-struct make_scalar {
-    typedef T type;
-};
-
-template<class T, std::size_t N>
-struct make_scalar<T[N]> {
-    typedef typename make_scalar<T>::type type;
-};
-
-} /* detail */
-
-template<class T>
-BOOST_CONSTEXPR inline T*
-first_scalar(T* p) BOOST_NOEXCEPT
-{
-    return p;
-}
-
-template<class T, std::size_t N>
-BOOST_CONSTEXPR inline typename detail::make_scalar<T>::type*
-first_scalar(T (*p)[N]) BOOST_NOEXCEPT
-{
-    return boost::first_scalar(&(*p)[0]);
-}
-
-} /* boost */
-
-#endif

include/boost/core/lightweight_test.hpp

@@ -14,27 +14,19 @@
 //  Copyright (2) Beman Dawes 2010, 2011
 //  Copyright (3) Ion Gaztanaga 2013
 //
-//  Copyright 2018 Glen Joseph Fernandes
-//  (glenjofe@gmail.com)
-//
 //  Distributed under the Boost Software License, Version 1.0.
 //  See accompanying file LICENSE_1_0.txt or copy at
 //  http://www.boost.org/LICENSE_1_0.txt
 //
 
-#include <boost/current_function.hpp>
-#include <boost/config.hpp>
-#include <exception>
-#include <iostream>
 #include <iterator>
-#include <cstdlib>
+#include <boost/assert.hpp>
+#include <boost/current_function.hpp>
+#include <boost/core/no_exceptions_support.hpp>
+#include <iostream>
 #include <cstring>
 #include <cstddef>
 
-#if defined(_MSC_VER) && defined(_CPPLIB_VER) && defined(_DEBUG)
-# include <crtdbg.h>
-#endif
-
 //  IDE's like Visual Studio perform better if output goes to std::cout or
 //  some other stream, so allow user to configure output stream:
 #ifndef BOOST_LIGHTWEIGHT_TEST_OSTREAM
@@ -47,68 +39,37 @@ namespace boost
 namespace detail
 {
 
-class test_result {
-public:
-    test_result()
-        : report_(false)
-        , errors_(0) {
-#if defined(_MSC_VER) && (_MSC_VER > 1310)
-        // disable message boxes on assert(), abort()
-        ::_set_abort_behavior(0, _WRITE_ABORT_MSG | _CALL_REPORTFAULT);
-#endif
-#if defined(_MSC_VER) && defined(_CPPLIB_VER) && defined(_DEBUG)
-        // disable message boxes on iterator debugging violations
-        _CrtSetReportMode( _CRT_ASSERT, _CRTDBG_MODE_FILE );
-        _CrtSetReportFile( _CRT_ASSERT, _CRTDBG_FILE_STDERR );
-#endif
-    }
+struct report_errors_reminder
+{
+    bool called_report_errors_function;
 
-    ~test_result() {
-        if (!report_) {
-            BOOST_LIGHTWEIGHT_TEST_OSTREAM << "main() should return report_errors()" << std::endl;
-            std::abort();
-        }
-    }
+    report_errors_reminder() : called_report_errors_function(false) {}
 
-    int& errors() {
-        return errors_;
+    ~report_errors_reminder()
+    {
+        BOOST_ASSERT(called_report_errors_function);  // verify report_errors() was called  
     }
-
-    void done() {
-        report_ = true;
-    }
-
-private:
-    bool report_;
-    int errors_;
 };
 
-inline test_result& test_results()
+inline report_errors_reminder& report_errors_remind()
 {
-    static test_result instance;
-    return instance;
+    static report_errors_reminder r;
+    return r;
 }
 
-inline int& test_errors()
+inline int & test_errors()
 {
-    return test_results().errors();
+    static int x = 0;
+    report_errors_remind();
+    return x;
 }
 
-inline bool test_impl(char const * expr, char const * file, int line, char const * function, bool v)
+inline void test_failed_impl(char const * expr, char const * file, int line, char const * function)
 {
-    if( v )
-    {
-        test_results();
-        return true;
-    }
-    else
-    {
-        BOOST_LIGHTWEIGHT_TEST_OSTREAM
-          << file << "(" << line << "): test '" << expr << "' failed in function '"
-          << function << "'" << std::endl;
-        ++test_results().errors();
-        return false;
-    }
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM
+      << file << "(" << line << "): test '" << expr << "' failed in function '"
+      << function << "'" << std::endl;
+    ++test_errors();
 }
 
 inline void error_impl(char const * msg, char const * file, int line, char const * function)
@@ -116,44 +77,28 @@ inline void error_impl(char const * msg, char const * file, int line, char const
     BOOST_LIGHTWEIGHT_TEST_OSTREAM
       << file << "(" << line << "): " << msg << " in function '"
       << function << "'" << std::endl;
-    ++test_results().errors();
+    ++test_errors();
 }
 
-inline void throw_failed_impl(const char* expr, char const * excep, char const * file, int line, char const * function)
+inline void throw_failed_impl(char const * excep, char const * file, int line, char const * function)
 {
    BOOST_LIGHTWEIGHT_TEST_OSTREAM
-    << file << "(" << line << "): expression '" << expr << "' did not throw exception '" << excep << "' in function '"
+    << file << "(" << line << "): Exception '" << excep << "' not thrown in function '"
     << function << "'" << std::endl;
-   ++test_results().errors();
-}
-
-inline void no_throw_failed_impl(const char* expr, const char* file, int line, const char* function)
-{
-    BOOST_LIGHTWEIGHT_TEST_OSTREAM
-        << file << "(" << line << "): expression '" << expr << "' threw an exception in function '"
-        << function << "'" << std::endl;
-   ++test_results().errors();
-}
-
-inline void no_throw_failed_impl(const char* expr, const char* what, const char* file, int line, const char* function)
-{
-    BOOST_LIGHTWEIGHT_TEST_OSTREAM
-        << file << "(" << line << "): expression '" << expr << "' threw an exception in function '"
-        << function << "': " << what << std::endl;
-   ++test_results().errors();
+   ++test_errors();
 }
 
 // In the comparisons below, it is possible that T and U are signed and unsigned integer types, which generates warnings in some compilers.
 // A cleaner fix would require common_type trait or some meta-programming, which would introduce a dependency on Boost.TypeTraits. To avoid
 // the dependency we just disable the warnings.
-#if defined(__clang__) && defined(__has_warning)
+#if defined(_MSC_VER)
+# pragma warning(push)
+# pragma warning(disable: 4389)
+#elif defined(__clang__) && defined(__has_warning)
 # if __has_warning("-Wsign-compare")
 #  pragma clang diagnostic push
 #  pragma clang diagnostic ignored "-Wsign-compare"
 # endif
-#elif defined(_MSC_VER)
-# pragma warning(push)
-# pragma warning(disable: 4389)
 #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"
@@ -170,145 +115,147 @@ inline const void* test_output_impl(signed char* v) { return v; }
 template<class T> inline const void* test_output_impl(T volatile* v) { return const_cast<T*>(v); }
 
 #if !defined( BOOST_NO_CXX11_NULLPTR )
-inline const void* test_output_impl(std::nullptr_t) { return nullptr; }
+inline const void* test_output_impl(std::nullptr_t v) { return v; }
 #endif
 
-// predicates
-
-struct lw_test_eq
+template<class T, class U> inline void test_eq_impl( char const * expr1, char const * expr2,
+  char const * file, int line, char const * function, T const & t, U const & u )
 {
-    template <typename T, typename U>
-    bool operator()(const T& t, const U& u) const { return t == u; }
-};
-
-struct lw_test_ne
-{
-    template <typename T, typename U>
-    bool operator()(const T& t, const U& u) const { return t != u; }
-};
-
-struct lw_test_lt
-{
-    template <typename T, typename U>
-    bool operator()(const T& t, const U& u) const { return t < u; }
-};
-
-struct lw_test_le
-{
-    template <typename T, typename U>
-    bool operator()(const T& t, const U& u) const { return t <= u; }
-};
-
-struct lw_test_gt
-{
-    template <typename T, typename U>
-    bool operator()(const T& t, const U& u) const { return t > u; }
-};
-
-struct lw_test_ge
-{
-    template <typename T, typename U>
-    bool operator()(const T& t, const U& u) const { return t >= u; }
-};
-
-// lwt_predicate_name
-
-template<class T> char const * lwt_predicate_name( T const& )
-{
-    return "~=";
-}
-
-inline char const * lwt_predicate_name( lw_test_eq const& )
-{
-    return "==";
-}
-
-inline char const * lwt_predicate_name( lw_test_ne const& )
-{
-    return "!=";
-}
-
-inline char const * lwt_predicate_name( lw_test_lt const& )
-{
-    return "<";
-}
-
-inline char const * lwt_predicate_name( lw_test_le const& )
-{
-    return "<=";
-}
-
-inline char const * lwt_predicate_name( lw_test_gt const& )
-{
-    return ">";
-}
-
-inline char const * lwt_predicate_name( lw_test_ge const& )
-{
-    return ">=";
-}
-
-//
-
-template<class BinaryPredicate, class T, class U>
-inline bool test_with_impl(BinaryPredicate pred, char const * expr1, char const * expr2,
-                           char const * file, int line, char const * function,
-                           T const & t, U const & u)
-{
-    if( pred(t, u) )
+    if( t == u )
     {
-        test_results();
-        return true;
+        report_errors_remind();
     }
     else
     {
         BOOST_LIGHTWEIGHT_TEST_OSTREAM
-            << file << "(" << line << "): test '" << expr1 << " " << lwt_predicate_name(pred) << " " << expr2
-            << "' ('" << test_output_impl(t) << "' " << lwt_predicate_name(pred) << " '" << test_output_impl(u)
-            << "') failed in function '" << function << "'" << std::endl;
-        ++test_results().errors();
-        return false;
+            << file << "(" << line << "): test '" << expr1 << " == " << expr2
+            << "' failed in function '" << function << "': "
+            << "'" << test_output_impl(t) << "' != '" << test_output_impl(u) << "'" << std::endl;
+        ++test_errors();
     }
 }
 
-inline bool test_cstr_eq_impl( char const * expr1, char const * expr2,
+template<class T, class U> inline void test_ne_impl( char const * expr1, char const * expr2,
+  char const * file, int line, char const * function, T const & t, U const & u )
+{
+    if( t != u )
+    {
+        report_errors_remind();
+    }
+    else
+    {
+        BOOST_LIGHTWEIGHT_TEST_OSTREAM
+            << file << "(" << line << "): test '" << expr1 << " != " << expr2
+            << "' failed in function '" << function << "': "
+            << "'" << test_output_impl(t) << "' == '" << test_output_impl(u) << "'" << std::endl;
+        ++test_errors();
+    }
+}
+
+template<class T, class U> inline void test_lt_impl( char const * expr1, char const * expr2,
+  char const * file, int line, char const * function, T const & t, U const & u )
+{
+    if( t < u )
+    {
+        report_errors_remind();
+    }
+    else
+    {
+        BOOST_LIGHTWEIGHT_TEST_OSTREAM
+            << file << "(" << line << "): test '" << expr1 << " < " << expr2
+            << "' failed in function '" << function << "': "
+            << "'" << test_output_impl(t) << "' >= '" << test_output_impl(u) << "'" << std::endl;
+        ++test_errors();
+    }
+}
+
+template<class T, class U> inline void test_le_impl( char const * expr1, char const * expr2,
+  char const * file, int line, char const * function, T const & t, U const & u )
+{
+    if( t <= u )
+    {
+        report_errors_remind();
+    }
+    else
+    {
+        BOOST_LIGHTWEIGHT_TEST_OSTREAM
+            << file << "(" << line << "): test '" << expr1 << " <= " << expr2
+            << "' failed in function '" << function << "': "
+            << "'" << test_output_impl(t) << "' > '" << test_output_impl(u) << "'" << std::endl;
+        ++test_errors();
+    }
+}
+
+template<class T, class U> inline void test_gt_impl( char const * expr1, char const * expr2,
+  char const * file, int line, char const * function, T const & t, U const & u )
+{
+    if( t > u )
+    {
+        report_errors_remind();
+    }
+    else
+    {
+        BOOST_LIGHTWEIGHT_TEST_OSTREAM
+            << file << "(" << line << "): test '" << expr1 << " > " << expr2
+            << "' failed in function '" << function << "': "
+            << "'" << test_output_impl(t) << "' <= '" << test_output_impl(u) << "'" << std::endl;
+        ++test_errors();
+    }
+}
+
+template<class T, class U> inline void test_ge_impl( char const * expr1, char const * expr2,
+  char const * file, int line, char const * function, T const & t, U const & u )
+{
+    if( t >= u )
+    {
+        report_errors_remind();
+    }
+    else
+    {
+        BOOST_LIGHTWEIGHT_TEST_OSTREAM
+            << file << "(" << line << "): test '" << expr1 << " >= " << expr2
+            << "' failed in function '" << function << "': "
+            << "'" << test_output_impl(t) << "' < '" << test_output_impl(u) << "'" << std::endl;
+        ++test_errors();
+    }
+}
+
+inline void test_cstr_eq_impl( char const * expr1, char const * expr2,
   char const * file, int line, char const * function, char const * const t, char const * const u )
 {
     if( std::strcmp(t, u) == 0 )
     {
-        test_results();
-        return true;
+        report_errors_remind();
     }
     else
     {
         BOOST_LIGHTWEIGHT_TEST_OSTREAM
-            << file << "(" << line << "): test '" << expr1 << " == " << expr2 << "' ('" << t
-            << "' == '" << u << "') failed in function '" << function << "'" << std::endl;
-        ++test_results().errors();
-        return false;
+            << file << "(" << line << "): test '" << expr1 << " == " << expr2
+            << "' failed in function '" << function << "': "
+            << "'" << t << "' != '" << u << "'" << std::endl;
+        ++test_errors();
     }
 }
 
-inline bool test_cstr_ne_impl( char const * expr1, char const * expr2,
+inline void test_cstr_ne_impl( char const * expr1, char const * expr2,
   char const * file, int line, char const * function, char const * const t, char const * const u )
 {
     if( std::strcmp(t, u) != 0 )
     {
-        test_results();
-        return true;
+        report_errors_remind();
     }
     else
     {
         BOOST_LIGHTWEIGHT_TEST_OSTREAM
-            << file << "(" << line << "): test '" << expr1 << " != " << expr2 << "' ('" << t
-            << "' != '" << u << "') failed in function '" << function << "'" << std::endl;
-        ++test_results().errors();
-        return false;
+            << file << "(" << line << "): test '" << expr1 << " == " << expr2
+            << "' failed in function '" << function << "': "
+            << "'" << t << "' == '" << u << "'" << std::endl;
+        ++test_errors();
     }
 }
 
 template<class FormattedOutputFunction, class InputIterator1, class InputIterator2>
-bool test_all_eq_impl(FormattedOutputFunction& output,
+void test_all_eq_impl(FormattedOutputFunction& output,
                       char const * file, int line, char const * function,
                       InputIterator1 first_begin, InputIterator1 first_end,
                       InputIterator2 second_begin, InputIterator2 second_end)
@@ -366,19 +313,17 @@ bool test_all_eq_impl(FormattedOutputFunction& output,
 
     if (error_count == 0)
     {
-        test_results();
-        return true;
+        boost::detail::report_errors_remind();
     }
     else
     {
         output << std::endl;
-        ++test_results().errors();
-        return false;
+        ++boost::detail::test_errors();
     }
 }
 
 template<class FormattedOutputFunction, class InputIterator1, class InputIterator2, typename BinaryPredicate>
-bool test_all_with_impl(FormattedOutputFunction& output,
+void test_all_with_impl(FormattedOutputFunction& output,
                         char const * file, int line, char const * function,
                         InputIterator1 first_begin, InputIterator1 first_end,
                         InputIterator2 second_begin, InputIterator2 second_end,
@@ -437,23 +382,21 @@ bool test_all_with_impl(FormattedOutputFunction& output,
 
     if (error_count == 0)
     {
-        test_results();
-        return true;
+        report_errors_remind();
     }
     else
     {
         output << std::endl;
-        ++test_results().errors();
-        return false;
+        ++test_errors();
     }
 }
 
-#if defined(__clang__) && defined(__has_warning)
+#if defined(_MSC_VER)
+# pragma warning(pop)
+#elif defined(__clang__) && defined(__has_warning)
 # if __has_warning("-Wsign-compare")
 #  pragma clang diagnostic pop
 # endif
-#elif defined(_MSC_VER)
-# pragma warning(pop)
 #elif defined(__GNUC__) && !(defined(__INTEL_COMPILER) || defined(__ICL) || defined(__ICC) || defined(__ECC)) && (__GNUC__ * 100 + __GNUC_MINOR__) >= 406
 # pragma GCC diagnostic pop
 #endif
@@ -462,42 +405,38 @@ bool test_all_with_impl(FormattedOutputFunction& output,
 
 inline int report_errors()
 {
-    boost::detail::test_result& result = boost::detail::test_results();
-    result.done();
+    boost::detail::report_errors_remind().called_report_errors_function = true;
 
-    int errors = result.errors();
+    int errors = boost::detail::test_errors();
 
     if( errors == 0 )
     {
         BOOST_LIGHTWEIGHT_TEST_OSTREAM
           << "No errors detected." << std::endl;
+        return 0;
     }
     else
     {
         BOOST_LIGHTWEIGHT_TEST_OSTREAM
           << errors << " error" << (errors == 1? "": "s") << " detected." << std::endl;
+        return 1;
     }
-
-    // `return report_errors();` from main only supports 8 bit exit codes
-    return errors < 256? errors: 255;
 }
 
 } // namespace boost
 
-#define BOOST_TEST(expr) ( ::boost::detail::test_impl(#expr, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION, (expr)? true: false) )
+#define BOOST_TEST(expr) ((expr)? (void)0: ::boost::detail::test_failed_impl(#expr, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION))
 #define BOOST_TEST_NOT(expr) BOOST_TEST(!(expr))
 
 #define BOOST_ERROR(msg) ( ::boost::detail::error_impl(msg, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION) )
 
-#define BOOST_TEST_WITH(expr1,expr2,predicate) ( ::boost::detail::test_with_impl(predicate, #expr1, #expr2, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION, expr1, expr2) )
+#define BOOST_TEST_EQ(expr1,expr2) ( ::boost::detail::test_eq_impl(#expr1, #expr2, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION, expr1, expr2) )
+#define BOOST_TEST_NE(expr1,expr2) ( ::boost::detail::test_ne_impl(#expr1, #expr2, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION, expr1, expr2) )
 
-#define BOOST_TEST_EQ(expr1,expr2) ( ::boost::detail::test_with_impl(::boost::detail::lw_test_eq(), #expr1, #expr2, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION, expr1, expr2) )
-#define BOOST_TEST_NE(expr1,expr2) ( ::boost::detail::test_with_impl(::boost::detail::lw_test_ne(), #expr1, #expr2, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION, expr1, expr2) )
-
-#define BOOST_TEST_LT(expr1,expr2) ( ::boost::detail::test_with_impl(::boost::detail::lw_test_lt(), #expr1, #expr2, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION, expr1, expr2) )
-#define BOOST_TEST_LE(expr1,expr2) ( ::boost::detail::test_with_impl(::boost::detail::lw_test_le(), #expr1, #expr2, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION, expr1, expr2) )
-#define BOOST_TEST_GT(expr1,expr2) ( ::boost::detail::test_with_impl(::boost::detail::lw_test_gt(), #expr1, #expr2, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION, expr1, expr2) )
-#define BOOST_TEST_GE(expr1,expr2) ( ::boost::detail::test_with_impl(::boost::detail::lw_test_ge(), #expr1, #expr2, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION, expr1, expr2) )
+#define BOOST_TEST_LT(expr1,expr2) ( ::boost::detail::test_lt_impl(#expr1, #expr2, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION, expr1, expr2) )
+#define BOOST_TEST_LE(expr1,expr2) ( ::boost::detail::test_le_impl(#expr1, #expr2, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION, expr1, expr2) )
+#define BOOST_TEST_GT(expr1,expr2) ( ::boost::detail::test_gt_impl(#expr1, #expr2, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION, expr1, expr2) )
+#define BOOST_TEST_GE(expr1,expr2) ( ::boost::detail::test_ge_impl(#expr1, #expr2, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION, expr1, expr2) )
 
 #define BOOST_TEST_CSTR_EQ(expr1,expr2) ( ::boost::detail::test_cstr_eq_impl(#expr1, #expr2, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION, expr1, expr2) )
 #define BOOST_TEST_CSTR_NE(expr1,expr2) ( ::boost::detail::test_cstr_ne_impl(#expr1, #expr2, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION, expr1, expr2) )
@@ -506,38 +445,21 @@ inline int report_errors()
 #define BOOST_TEST_ALL_WITH(begin1, end1, begin2, end2, predicate) ( ::boost::detail::test_all_with_impl(BOOST_LIGHTWEIGHT_TEST_OSTREAM, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION, begin1, end1, begin2, end2, predicate) )
 
 #ifndef BOOST_NO_EXCEPTIONS
-   #define BOOST_TEST_THROWS( EXPR, EXCEP )                           \
-      try {                                                           \
-         EXPR;                                                        \
-         ::boost::detail::throw_failed_impl                           \
-         (#EXPR, #EXCEP, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION); \
-      }                                                               \
-      catch(EXCEP const&) {                                           \
-         ::boost::detail::test_results();                             \
-      }                                                               \
-      catch(...) {                                                    \
-         ::boost::detail::throw_failed_impl                           \
-         (#EXPR, #EXCEP, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION); \
-      }                                                               \
+   #define BOOST_TEST_THROWS( EXPR, EXCEP )                    \
+      try {                                                    \
+         EXPR;                                                 \
+         ::boost::detail::throw_failed_impl                    \
+         (#EXCEP, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION); \
+      }                                                        \
+      catch(EXCEP const&) {                                    \
+      }                                                        \
+      catch(...) {                                             \
+         ::boost::detail::throw_failed_impl                    \
+         (#EXCEP, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION); \
+      }                                                        \
    //
 #else
    #define BOOST_TEST_THROWS( EXPR, EXCEP )
 #endif
 
-#ifndef BOOST_NO_EXCEPTIONS
-#  define BOOST_TEST_NO_THROW(EXPR)                                    \
-    try {                                                              \
-        EXPR;                                                          \
-    } catch (const std::exception& e) {                                \
-        ::boost::detail::no_throw_failed_impl                          \
-        (#EXPR, e.what(), __FILE__, __LINE__, BOOST_CURRENT_FUNCTION); \
-    } catch (...) {                                                    \
-        ::boost::detail::no_throw_failed_impl                          \
-        (#EXPR, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION);           \
-    }
-    //
-#else
-#  define BOOST_TEST_NO_THROW(EXPR) { EXPR; }
-#endif
-
 #endif // #ifndef BOOST_CORE_LIGHTWEIGHT_TEST_HPP

include/boost/core/lightweight_test_trait.hpp

@@ -9,21 +9,16 @@
 
 // boost/core/lightweight_test_trait.hpp
 //
-// BOOST_TEST_TRAIT_TRUE, BOOST_TEST_TRAIT_FALSE, BOOST_TEST_TRAIT_SAME
+// BOOST_TEST_TRAIT_TRUE, BOOST_TEST_TRAIT_FALSE
 //
 // Copyright 2014 Peter Dimov
 //
-// Copyright 2019 Glen Joseph Fernandes
-// (glenjofe@gmail.com)
-//
 // Distributed under the Boost Software License, Version 1.0.
 // See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt
 
 #include <boost/core/lightweight_test.hpp>
 #include <boost/core/typeinfo.hpp>
-#include <boost/core/is_same.hpp>
-#include <boost/config.hpp>
 
 namespace boost
 {
@@ -31,56 +26,12 @@ namespace boost
 namespace detail
 {
 
-template<class, int = 0> struct test_print { };
-
-template<class T> inline std::ostream& operator<<(std::ostream& o, test_print<T, 2>)
-{
-    return o << boost::core::demangled_name(BOOST_CORE_TYPEID(T));
-}
-
-template<class T> inline std::ostream& operator<<(std::ostream& o, test_print<T, 1>)
-{
-    return o << test_print<T, 2>();
-}
-
-template<class T> inline std::ostream& operator<<(std::ostream& o, test_print<const T, 1>)
-{
-    return o << test_print<T, 2>() << " const";
-}
-
-template<class T> inline std::ostream& operator<<(std::ostream& o, test_print<volatile T, 1>)
-{
-    return o << test_print<T, 2>() << " volatile";
-}
-
-template<class T> inline std::ostream& operator<<(std::ostream& o, test_print<const volatile T, 1>)
-{
-    return o << test_print<T, 2>() << " const volatile";
-}
-
-template<class T> inline std::ostream& operator<<(std::ostream& o, test_print<T>)
-{
-    return o << test_print<T, 1>();
-}
-
-template<class T> inline std::ostream& operator<<(std::ostream& o, test_print<T&>)
-{
-    return o << test_print<T, 1>() << " &";
-}
-
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-template<class T> inline std::ostream& operator<<(std::ostream& o, test_print<T&&>)
-{
-    return o << test_print<T, 1>() << " &&";
-}
-#endif
-
 template< class T > inline void test_trait_impl( char const * trait, void (*)( T ),
   bool expected, char const * file, int line, char const * function )
 {
     if( T::value == expected )
     {
-        test_results();
+        report_errors_remind();
     }
     else
     {
@@ -91,32 +42,7 @@ template< class T > inline void test_trait_impl( char const * trait, void (*)( T
             << "' (should have been " << ( expected? "true": "false" ) << ")"
             << std::endl;
 
-        ++test_results().errors();
-    }
-}
-
-template<class T> inline bool test_trait_same_impl_( T )
-{
-    return T::value;
-}
-
-template<class T1, class T2> inline void test_trait_same_impl( char const * types,
-  boost::core::is_same<T1, T2> same, char const * file, int line, char const * function )
-{
-    if( test_trait_same_impl_( same ) )
-    {
-        test_results();
-    }
-    else
-    {
-        BOOST_LIGHTWEIGHT_TEST_OSTREAM
-            << file << "(" << line << "): test 'is_same<" << types << ">'"
-            << " failed in function '" << function
-            << "' ('" << test_print<T1>()
-            << "' != '" << test_print<T2>() << "')"
-            << std::endl;
-
-        ++test_results().errors();
+        ++test_errors();
     }
 }
 
@@ -127,11 +53,4 @@ template<class T1, class T2> inline void test_trait_same_impl( char const * type
 #define BOOST_TEST_TRAIT_TRUE(type) ( ::boost::detail::test_trait_impl(#type, (void(*)type)0, true, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION) )
 #define BOOST_TEST_TRAIT_FALSE(type) ( ::boost::detail::test_trait_impl(#type, (void(*)type)0, false, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION) )
 
-#if defined(__GNUC__)
-// ignoring -Wvariadic-macros with #pragma doesn't work under GCC
-# pragma GCC system_header
-#endif
-
-#define BOOST_TEST_TRAIT_SAME(...) ( ::boost::detail::test_trait_same_impl(#__VA_ARGS__, ::boost::core::is_same<__VA_ARGS__>(), __FILE__, __LINE__, BOOST_CURRENT_FUNCTION) )
-
 #endif // #ifndef BOOST_CORE_LIGHTWEIGHT_TEST_TRAIT_HPP

include/boost/core/no_exceptions_support.hpp

@@ -29,24 +29,12 @@
 #    define BOOST_RETHROW throw;
 #    define BOOST_CATCH_END }
 #else
-#    if BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x564))
+#    if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
 #        define BOOST_TRY { if ("")
 #        define BOOST_CATCH(x) else if (!"")
-#    elif !defined(BOOST_MSVC) || BOOST_MSVC >= 1900
+#    else
 #        define BOOST_TRY { if (true)
 #        define BOOST_CATCH(x) else if (false)
-#    else
-         // warning C4127: conditional expression is constant
-#        define BOOST_TRY { \
-             __pragma(warning(push)) \
-             __pragma(warning(disable: 4127)) \
-             if (true) \
-             __pragma(warning(pop))
-#        define BOOST_CATCH(x) else \
-             __pragma(warning(push)) \
-             __pragma(warning(disable: 4127)) \
-             if (false) \
-             __pragma(warning(pop))
 #    endif
 #    define BOOST_RETHROW
 #    define BOOST_CATCH_END }

include/boost/core/noinit_adaptor.hpp

@@ -1,87 +0,0 @@
-/*
-Copyright 2019 Glen Joseph Fernandes
-(glenjofe@gmail.com)
-
-Distributed under the Boost Software License, Version 1.0.
-(http://www.boost.org/LICENSE_1_0.txt)
-*/
-#ifndef BOOST_CORE_NOINIT_ADAPTOR_HPP
-#define BOOST_CORE_NOINIT_ADAPTOR_HPP
-
-#include <boost/core/allocator_access.hpp>
-
-namespace boost {
-
-template<class A>
-struct noinit_adaptor
-    : A {
-    template<class U>
-    struct rebind {
-        typedef noinit_adaptor<typename allocator_rebind<A, U>::type> other;
-    };
-
-    noinit_adaptor()
-        : A() { }
-
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-    template<class U>
-    noinit_adaptor(U&& u) BOOST_NOEXCEPT
-        : A(std::forward<U>(u)) { }
-#else
-    template<class U>
-    noinit_adaptor(const U& u) BOOST_NOEXCEPT
-        : A(u) { }
-
-    template<class U>
-    noinit_adaptor(U& u) BOOST_NOEXCEPT
-        : A(u) { }
-#endif
-
-    template<class U>
-    noinit_adaptor(const noinit_adaptor<U>& u) BOOST_NOEXCEPT
-        : A(static_cast<const A&>(u)) { }
-
-    template<class U>
-    void construct(U* p) {
-        ::new((void*)p) U;
-    }
-
-#if defined(BOOST_NO_CXX11_ALLOCATOR)
-    template<class U, class V>
-    void construct(U* p, const V& v) {
-        ::new((void*)p) U(v);
-    }
-#endif
-
-    template<class U>
-    void destroy(U* p) {
-        p->~U();
-    }
-};
-
-template<class T, class U>
-inline bool
-operator==(const noinit_adaptor<T>& lhs,
-    const noinit_adaptor<U>& rhs) BOOST_NOEXCEPT
-{
-    return static_cast<const T&>(lhs) == static_cast<const U&>(rhs);
-}
-
-template<class T, class U>
-inline bool
-operator!=(const noinit_adaptor<T>& lhs,
-    const noinit_adaptor<U>& rhs) BOOST_NOEXCEPT
-{
-    return !(lhs == rhs);
-}
-
-template<class A>
-inline noinit_adaptor<A>
-noinit_adapt(const A& a) BOOST_NOEXCEPT
-{
-    return noinit_adaptor<A>(a);
-}
-
-} /* boost */
-
-#endif

include/boost/core/noncopyable.hpp

@@ -20,22 +20,7 @@ namespace boost {
 
 namespace noncopyable_  // protection from unintended ADL
 {
-#ifndef BOOST_NONCOPYABLE_BASE_TOKEN_DEFINED
-#define BOOST_NONCOPYABLE_BASE_TOKEN_DEFINED
-
-// noncopyable derives from base_token to enable Type Traits to detect
-// whether a type derives from noncopyable without needing the definition
-// of noncopyable itself.
-//
-// The definition of base_token is macro-guarded so that Type Trais can
-// define it locally without including this header, to avoid a dependency
-// on Core.
-
-  struct base_token {};
-
-#endif // #ifndef BOOST_NONCOPYABLE_BASE_TOKEN_DEFINED
-
-  class noncopyable: base_token
+  class noncopyable
   {
   protected:
 #if !defined(BOOST_NO_CXX11_DEFAULTED_FUNCTIONS) && !defined(BOOST_NO_CXX11_NON_PUBLIC_DEFAULTED_FUNCTIONS)

include/boost/core/nvp.hpp

@@ -1,57 +0,0 @@
-/*
-Copyright 2019 Glen Joseph Fernandes
-(glenjofe@gmail.com)
-
-Distributed under the Boost Software License, Version 1.0.
-(http://www.boost.org/LICENSE_1_0.txt)
-*/
-#ifndef BOOST_CORE_NVP_HPP
-#define BOOST_CORE_NVP_HPP
-
-#include <boost/core/addressof.hpp>
-#include <boost/config.hpp>
-
-namespace boost {
-namespace serialization {
-
-template<class T>
-class nvp {
-public:
-    nvp(const char* n, T& v) BOOST_NOEXCEPT
-        : n_(n)
-        , v_(boost::addressof(v)) { }
-
-    const char* name() const BOOST_NOEXCEPT {
-        return n_;
-    }
-
-    T& value() const BOOST_NOEXCEPT {
-        return *v_;
-    }
-
-    const T& const_value() const BOOST_NOEXCEPT {
-        return *v_;
-    }
-
-private:
-    const char* n_;
-    T* v_;
-};
-
-template<class T>
-inline const nvp<T>
-make_nvp(const char* n, T& v) BOOST_NOEXCEPT
-{
-    return nvp<T>(n, v);
-}
-
-} /* serialization */
-
-using serialization::nvp;
-using serialization::make_nvp;
-
-} /* boost */
-
-#define BOOST_NVP(v) boost::make_nvp(BOOST_STRINGIZE(v), v)
-
-#endif

include/boost/core/pointer_traits.hpp

@@ -1,5 +1,5 @@
 /*
-Copyright 2017-2018 Glen Joseph Fernandes
+Copyright 2017 Glen Joseph Fernandes
 (glenjofe@gmail.com)
 
 Distributed under the Boost Software License, Version 1.0.
@@ -13,11 +13,24 @@ Distributed under the Boost Software License, Version 1.0.
 #include <memory>
 #else
 #include <boost/core/addressof.hpp>
-#include <cstddef>
 #endif
 
 namespace boost {
 
+template<class T>
+struct pointer_traits;
+
+namespace detail {
+
+template<class U>
+static typename boost::pointer_traits<U>::element_type*
+ptr_traits_address(U v) BOOST_NOEXCEPT
+{
+    return boost::pointer_traits<U>::to_address(v);
+}
+
+} /* detail */
+
 #if !defined(BOOST_NO_CXX11_POINTER_TRAITS)
 template<class T>
 struct pointer_traits
@@ -26,6 +39,10 @@ struct pointer_traits
     struct rebind_to {
         typedef typename std::pointer_traits<T>::template rebind<U> type;
     };
+    static typename std::pointer_traits<T>::element_type*
+    to_address(T v) BOOST_NOEXCEPT {
+        return detail::ptr_traits_address(v.operator->());
+    }
 };
 
 template<class T>
@@ -35,107 +52,143 @@ struct pointer_traits<T*>
     struct rebind_to {
         typedef U* type;
     };
+    static T* to_address(T* v) BOOST_NOEXCEPT {
+        return v;
+    }
 };
 #else
 namespace detail {
 
-template<class>
-struct ptr_void {
-    typedef void type;
+struct ptr_traits_none { char first, second; };
+
+template<class T>
+struct ptr_traits_has_element {
+private:
+    template<class U>
+    static ptr_traits_none call(...);
+    template<class U>
+    static char call(typename U::element_type* = 0);
+public:
+    static const bool value = sizeof(call<T>(0)) == 1;
 };
 
 template<class T>
-struct ptr_first;
+struct ptr_traits_first;
 
 #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
 template<template<class, class...> class T, class U, class... Args>
-struct ptr_first<T<U, Args...> > {
+struct ptr_traits_first<T<U, Args...> > {
     typedef U type;
 };
 #else
 template<template<class> class T, class U>
-struct ptr_first<T<U> > {
+struct ptr_traits_first<T<U> > {
     typedef U type;
 };
 
 template<template<class, class> class T, class U1, class U2>
-struct ptr_first<T<U1, U2> > {
+struct ptr_traits_first<T<U1, U2> > {
     typedef U1 type;
 };
 
 template<template<class, class, class> class T, class U1, class U2, class U3>
-struct ptr_first<T<U1, U2, U3> > {
+struct ptr_traits_first<T<U1, U2, U3> > {
     typedef U1 type;
 };
 #endif
 
-template<class T, class = void>
-struct ptr_element {
-    typedef typename ptr_first<T>::type type;
-};
-
-template<class T>
-struct ptr_element<T, typename ptr_void<typename T::element_type>::type> {
+template<class T, bool = ptr_traits_has_element<T>::value>
+struct ptr_traits_element {
     typedef typename T::element_type type;
 };
 
-template<class, class = void>
-struct ptr_difference {
-    typedef std::ptrdiff_t type;
+template<class T>
+struct ptr_traits_element<T, false> {
+    typedef typename ptr_traits_first<T>::type type;
 };
 
 template<class T>
-struct ptr_difference<T,
-    typename ptr_void<typename T::difference_type>::type> {
+struct ptr_traits_has_difference {
+private:
+    template<class U>
+    static ptr_traits_none call(...);
+    template<class U>
+    static char call(typename U::difference_type* = 0);
+public:
+    static const bool value = sizeof(call<T>(0)) == 1;
+};
+
+template<class T, bool = ptr_traits_has_difference<T>::value>
+struct ptr_traits_difference {
     typedef typename T::difference_type type;
 };
 
+template<class T>
+struct ptr_traits_difference<T, false> {
+    typedef std::ptrdiff_t type;
+};
+
 template<class T, class V>
-struct ptr_transform;
+struct ptr_traits_has_rebind {
+private:
+    template<class U>
+    static ptr_traits_none call(...);
+    template<class U>
+    static char call(typename U::template rebind<V>* = 0);
+public:
+    static const bool value = sizeof(call<T>(0)) == 1;
+};
+
+template<class T, class V>
+struct ptr_traits_rebind_to;
 
 #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
 template<template<class, class...> class T, class U, class... Args, class V>
-struct ptr_transform<T<U, Args...>, V> {
+struct ptr_traits_rebind_to<T<U, Args...>, V> {
     typedef T<V, Args...> type;
 };
 #else
 template<template<class> class T, class U, class V>
-struct ptr_transform<T<U>, V> {
+struct ptr_traits_rebind_to<T<U>, V> {
     typedef T<V> type;
 };
 
 template<template<class, class> class T, class U1, class U2, class V>
-struct ptr_transform<T<U1, U2>, V> {
+struct ptr_traits_rebind_to<T<U1, U2>, V> {
     typedef T<V, U2> type;
 };
 
 template<template<class, class, class> class T,
     class U1, class U2, class U3, class V>
-struct ptr_transform<T<U1, U2, U3>, V> {
+struct ptr_traits_rebind_to<T<U1, U2, U3>, V> {
     typedef T<V, U2, U3> type;
 };
 #endif
 
-template<class T, class U, class = void>
-struct ptr_rebind {
-    typedef typename ptr_transform<T, U>::type type;
+#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+template<class T, class U, bool = ptr_traits_has_rebind<T, U>::value>
+struct ptr_traits_rebind {
+    typedef typename T::template rebind<U> type;
 };
 
-#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
 template<class T, class U>
-struct ptr_rebind<T, U,
-    typename ptr_void<typename T::template rebind<U> >::type> {
-    typedef typename T::template rebind<U> type;
+struct ptr_traits_rebind<T, U, false> {
+    typedef typename ptr_traits_rebind_to<T, U>::type type;
+};
+#else
+template<class T, class U>
+struct ptr_traits_rebind {
+    typedef typename ptr_traits_rebind_to<T, U>::type type;
 };
 #endif
 
 template<class T>
-struct ptr_value {
+struct ptr_traits_value {
     typedef T type;
 };
 
 template<>
-struct ptr_value<void> {
+struct ptr_traits_value<void> {
     typedef struct { } type;
 };
 
@@ -144,20 +197,23 @@ struct ptr_value<void> {
 template<class T>
 struct pointer_traits {
     typedef T pointer;
-    typedef typename detail::ptr_element<T>::type element_type;
-    typedef typename detail::ptr_difference<T>::type difference_type;
+    typedef typename detail::ptr_traits_element<T>::type element_type;
+    typedef typename detail::ptr_traits_difference<T>::type difference_type;
     template<class U>
     struct rebind_to {
-        typedef typename detail::ptr_rebind<T, U>::type type;
+        typedef typename detail::ptr_traits_rebind<T, U>::type type;
     };
 #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
     template<class U>
-    using rebind = typename detail::ptr_rebind<T, U>::type;
+    using rebind = typename detail::ptr_traits_rebind<T, U>::type;
 #endif
     static pointer
-    pointer_to(typename detail::ptr_value<element_type>::type& v) {
+    pointer_to(typename detail::ptr_traits_value<element_type>::type& v) {
         return pointer::pointer_to(v);
     }
+    static element_type* to_address(pointer v) BOOST_NOEXCEPT {
+        return detail::ptr_traits_address(v.operator->());
+    }
 };
 
 template<class T>
@@ -174,61 +230,15 @@ struct pointer_traits<T*> {
     using rebind = U*;
 #endif
     static T*
-    pointer_to(typename detail::ptr_value<T>::type& v) BOOST_NOEXCEPT {
-        return boost::addressof(v);
+    pointer_to(typename detail::ptr_traits_value<T>::type& v) BOOST_NOEXCEPT {
+        return addressof(v);
+    }
+    static T* to_address(T* v) BOOST_NOEXCEPT {
+        return v;
     }
 };
 #endif
 
-template<class T>
-BOOST_CONSTEXPR inline T*
-to_address(T* v) BOOST_NOEXCEPT
-{
-    return v;
-}
-
-#if !defined(BOOST_NO_CXX14_RETURN_TYPE_DEDUCTION)
-namespace detail {
-
-template<class T>
-inline T*
-ptr_address(T* v, int) BOOST_NOEXCEPT
-{
-    return v;
-}
-
-template<class T>
-inline auto
-ptr_address(const T& v, int) BOOST_NOEXCEPT
--> decltype(boost::pointer_traits<T>::to_address(v))
-{
-    return boost::pointer_traits<T>::to_address(v);
-}
-
-template<class T>
-inline auto
-ptr_address(const T& v, long) BOOST_NOEXCEPT
-{
-    return boost::detail::ptr_address(v.operator->(), 0);
-}
-
-} /* detail */
-
-template<class T>
-inline auto
-to_address(const T& v) BOOST_NOEXCEPT
-{
-    return boost::detail::ptr_address(v, 0);
-}
-#else
-template<class T>
-inline typename pointer_traits<T>::element_type*
-to_address(const T& v) BOOST_NOEXCEPT
-{
-    return boost::to_address(v.operator->());
-}
-#endif
-
 } /* boost */
 
 #endif

include/boost/core/quick_exit.hpp

@@ -1,59 +0,0 @@
-#ifndef BOOST_CORE_QUICK_EXIT_HPP_INCLUDED
-#define BOOST_CORE_QUICK_EXIT_HPP_INCLUDED
-
-// MS compatible compilers support #pragma once
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-//  boost/core/quick_exit.hpp
-//
-//  Copyright 2018 Peter Dimov
-//
-//  Distributed under the Boost Software License, Version 1.0.
-//  See accompanying file LICENSE_1_0.txt or copy at
-//  http://www.boost.org/LICENSE_1_0.txt)
-
-#include <boost/config.hpp>
-#include <stdlib.h>
-
-#if defined(__MINGW32__) && !defined(__MINGW64_VERSION_MAJOR)
-
-extern "C" _CRTIMP __cdecl __MINGW_NOTHROW  void _exit (int) __MINGW_ATTRIB_NORETURN;
-
-#endif
-
-#if defined(__CYGWIN__) && __cplusplus < 201103L
-
-extern "C" _Noreturn void quick_exit(int);
-
-#endif
-
-namespace boost
-{
-
-BOOST_NORETURN void quick_exit( int code ) BOOST_NOEXCEPT
-{
-#if defined(_MSC_VER) && _MSC_VER < 1900
-
-    ::_exit( code );
-
-#elif defined(__MINGW32__)
-
-    ::_exit( code );
-
-#elif defined(__APPLE__)
-
-    ::_Exit( code );
-
-#else
-
-    ::quick_exit( code );
-
-#endif
-}
-
-} // namespace boost
-
-#endif  // #ifndef BOOST_CORE_QUICK_EXIT_HPP_INCLUDED

include/boost/core/ref.hpp

@@ -19,8 +19,7 @@
 //  Copyright (C) 2002 David Abrahams
 //
 //  Copyright (C) 2014 Glen Joseph Fernandes
-//  (glenjofe@gmail.com)
-//
+//  glenfe at live dot com
 //  Copyright (C) 2014 Agustin Berge
 //
 // Distributed under the Boost Software License, Version 1.0. (See
@@ -116,7 +115,7 @@ private:
 /**
  @cond
 */
-#if defined( BOOST_BORLANDC ) && BOOST_WORKAROUND( BOOST_BORLANDC, BOOST_TESTED_AT(0x581) )
+#if defined( __BORLANDC__ ) && BOOST_WORKAROUND( __BORLANDC__, BOOST_TESTED_AT(0x581) )
 #  define BOOST_REF_CONST
 #else
 #  define BOOST_REF_CONST const

include/boost/core/swap.hpp

@@ -21,22 +21,13 @@
 // 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 <utility> //for std::swap (C++11)
+#include <algorithm> //for std::swap (C++98)
+#include <cstddef> //for std::size_t
 #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
 
 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 }; };
-
   template<class T>
   BOOST_GPU_ENABLED
   void swap_impl(T& left, T& right)
@@ -60,8 +51,7 @@ 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
-  swap(T1& left, T2& right)
+  void swap(T1& left, T2& right)
   {
     ::boost_swap_impl::swap_impl(left, right);
   }

include/boost/core/typeinfo.hpp

@@ -21,7 +21,6 @@
 
 #include <boost/current_function.hpp>
 #include <functional>
-#include <cstring>
 
 namespace boost
 {
@@ -37,43 +36,26 @@ private:
     typeinfo& operator=( typeinfo const& );
 
     char const * name_;
-    void (*lib_id_)();
 
 public:
 
-    typeinfo( char const * name, void (*lib_id)() ): name_( name ), lib_id_( lib_id )
+    explicit typeinfo( char const * name ): name_( name )
     {
     }
 
     bool operator==( typeinfo const& rhs ) const
     {
-#if ( defined(_WIN32) || defined(__CYGWIN__) ) && ( defined(__GNUC__) || defined(__clang__) ) && !defined(BOOST_DISABLE_CURRENT_FUNCTION)
-
-        return lib_id_ == rhs.lib_id_? this == &rhs: std::strcmp( name_, rhs.name_ ) == 0;
-
-#else
-
         return this == &rhs;
-
-#endif
     }
 
     bool operator!=( typeinfo const& rhs ) const
     {
-        return !( *this == rhs );
+        return this != &rhs;
     }
 
     bool before( typeinfo const& rhs ) const
     {
-#if ( defined(_WIN32) || defined(__CYGWIN__) ) && ( defined(__GNUC__) || defined(__clang__) ) && !defined(BOOST_DISABLE_CURRENT_FUNCTION)
-
-        return lib_id_ == rhs.lib_id_? std::less< typeinfo const* >()( this, &rhs ): std::strcmp( name_, rhs.name_ ) < 0;
-
-#else
-
         return std::less< typeinfo const* >()( this, &rhs );
-
-#endif
     }
 
     char const* name() const
@@ -92,7 +74,7 @@ inline char const * demangled_name( core::typeinfo const & ti )
 namespace detail
 {
 
-template<class T> struct BOOST_SYMBOL_VISIBLE core_typeid_
+template<class T> struct core_typeid_
 {
     static boost::core::typeinfo ti_;
 
@@ -102,11 +84,13 @@ template<class T> struct BOOST_SYMBOL_VISIBLE core_typeid_
     }
 };
 
-BOOST_SYMBOL_VISIBLE inline void core_typeid_lib_id()
-{
-}
-
-template<class T> boost::core::typeinfo core_typeid_< T >::ti_( core_typeid_< T >::name(), &core_typeid_lib_id );
+#if defined(__SUNPRO_CC)
+// see #4199, the Sun Studio compiler gets confused about static initialization 
+// constructor arguments. But an assignment works just fine. 
+template<class T> boost::core::typeinfo core_typeid_< T >::ti_ = core_typeid_< T >::name();
+#else
+template<class T> boost::core::typeinfo core_typeid_< T >::ti_(core_typeid_< T >::name());
+#endif
 
 template<class T> struct core_typeid_< T & >: core_typeid_< T >
 {

include/boost/core/uncaught_exceptions.hpp

@@ -1,155 +0,0 @@
-/*
- *          Copyright Andrey Semashev 2018 - 2020.
- * Distributed under the Boost Software License, Version 1.0.
- *    (See accompanying file LICENSE_1_0.txt or copy at
- *          https://www.boost.org/LICENSE_1_0.txt)
- */
-/*!
- * \file   uncaught_exceptions.hpp
- * \author Andrey Semashev
- * \date   2018-11-10
- *
- * \brief  This header provides an `uncaught_exceptions` function implementation, which was introduced in C++17.
- *
- * The code in this file is based on the implementation by Evgeny Panasyuk:
- *
- * https://github.com/panaseleus/stack_unwinding/blob/master/boost/exception/uncaught_exception_count.hpp
- */
-
-#ifndef BOOST_CORE_UNCAUGHT_EXCEPTIONS_HPP_INCLUDED_
-#define BOOST_CORE_UNCAUGHT_EXCEPTIONS_HPP_INCLUDED_
-
-#include <exception>
-#include <boost/config.hpp>
-
-#if defined(BOOST_HAS_PRAGMA_ONCE)
-#pragma once
-#endif
-
-#if defined(__APPLE__)
-#include <Availability.h>
-// Apple systems only support std::uncaught_exceptions starting with specific versions:
-// - Mac OS >= 10.12
-// - iOS >= 10.0
-// - tvOS >= 10.0
-// - watchOS >= 3.0
-// https://github.com/boostorg/core/issues/80
-#if (defined(__cpp_lib_uncaught_exceptions) && __cpp_lib_uncaught_exceptions >= 201411) && \
-    ( \
-        (defined(__MAC_OS_X_VERSION_MIN_REQUIRED) && __MAC_OS_X_VERSION_MIN_REQUIRED >= 101200) || \
-        (defined(__IPHONE_OS_VERSION_MIN_REQUIRED) && __IPHONE_OS_VERSION_MIN_REQUIRED >= 100000) \
-    )
-#define BOOST_CORE_HAS_UNCAUGHT_EXCEPTIONS
-#endif
-// Visual Studio 14.0 supports N4152 std::uncaught_exceptions() but doesn't define __cpp_lib_uncaught_exceptions
-#elif (defined(__cpp_lib_uncaught_exceptions) && __cpp_lib_uncaught_exceptions >= 201411) || \
-    (defined(_MSC_VER) && _MSC_VER >= 1900)
-#define BOOST_CORE_HAS_UNCAUGHT_EXCEPTIONS
-#endif
-
-#if !defined(BOOST_CORE_HAS_UNCAUGHT_EXCEPTIONS)
-
-// cxxabi.h availability macro
-#if defined(__has_include) && (!defined(BOOST_GCC) || (__GNUC__ >= 5))
-#   if __has_include(<cxxabi.h>)
-#       define BOOST_CORE_HAS_CXXABI_H
-#   endif
-#elif defined(__GLIBCXX__) || defined(__GLIBCPP__)
-#   define BOOST_CORE_HAS_CXXABI_H
-#endif
-
-#if defined(BOOST_CORE_HAS_CXXABI_H)
-// MinGW GCC 4.4 seem to not work the same way the newer GCC versions do. As a result, __cxa_get_globals based implementation will always return 0.
-// Just disable it for now and fall back to std::uncaught_exception().
-// On AIX, xlclang++ does have cxxabi.h but doesn't have __cxa_get_globals (https://github.com/boostorg/core/issues/78).
-#if !( \
-        (defined(__MINGW32__) && (defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__) < 405)) || \
-        defined(__ibmxl__) \
-    )
-#include <cxxabi.h>
-#include <cstring>
-#define BOOST_CORE_HAS_CXA_GET_GLOBALS
-// At least on MinGW and Linux, only GCC since 4.7 declares __cxa_get_globals() in cxxabi.h. Older versions of GCC do not expose this function but it's there.
-// On OpenBSD, it seems, the declaration is also missing.
-// Note that at least on FreeBSD 11, cxxabi.h declares __cxa_get_globals with a different exception specification, so we can't declare the function unconditionally.
-// On Linux with clang and libc++ and on OS X, there is a version of cxxabi.h from libc++abi that doesn't declare __cxa_get_globals, but provides __cxa_uncaught_exceptions.
-// The function only appeared in version _LIBCPPABI_VERSION >= 1002 of the library. Unfortunately, there are linking errors about undefined reference to __cxa_uncaught_exceptions
-// on Ubuntu Trusty and OS X, so we avoid using it and forward-declare __cxa_get_globals instead.
-// On QNX SDP 7.0 (QCC 5.4.0), there are multiple cxxabi.h, one from glibcxx from gcc and another from libc++abi from LLVM. Which one is included will be determined by the qcc
-// command line arguments (-V and/or -Y; http://www.qnx.com/developers/docs/7.0.0/#com.qnx.doc.neutrino.utilities/topic/q/qcc.html). The LLVM libc++abi is missing the declaration
-// of __cxa_get_globals but it is also patched by QNX developers to not define _LIBCPPABI_VERSION. Older QNX SDP versions, up to and including 6.6, don't provide LLVM and libc++abi.
-// See https://github.com/boostorg/core/issues/59.
-#if !defined(__FreeBSD__) && \
-    ( \
-        (defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__) < 407) || \
-        defined(__OpenBSD__) || \
-        (defined(__QNXNTO__) && !defined(__GLIBCXX__) && !defined(__GLIBCPP__)) || \
-        defined(_LIBCPPABI_VERSION) \
-    )
-namespace __cxxabiv1 {
-struct __cxa_eh_globals;
-#if defined(__OpenBSD__)
-extern "C" __cxa_eh_globals* __cxa_get_globals();
-#else
-extern "C" __cxa_eh_globals* __cxa_get_globals() BOOST_NOEXCEPT_OR_NOTHROW __attribute__((__const__));
-#endif
-} // namespace __cxxabiv1
-#endif
-#endif
-#endif // defined(BOOST_CORE_HAS_CXXABI_H)
-
-#if defined(_MSC_VER) && _MSC_VER >= 1400
-#include <cstring>
-#define BOOST_CORE_HAS_GETPTD
-namespace boost {
-namespace core {
-namespace detail {
-extern "C" void* _getptd();
-} // namespace detail
-} // namespace core
-} // namespace boost
-#endif // defined(_MSC_VER) && _MSC_VER >= 1400
-
-#endif // !defined(BOOST_CORE_HAS_UNCAUGHT_EXCEPTIONS)
-
-#if !defined(BOOST_CORE_HAS_UNCAUGHT_EXCEPTIONS) && !defined(BOOST_CORE_HAS_CXA_GET_GLOBALS) && !defined(BOOST_CORE_HAS_GETPTD)
-//! This macro is defined when `uncaught_exceptions` is not guaranteed to return values greater than 1 if multiple exceptions are pending
-#define BOOST_CORE_UNCAUGHT_EXCEPTIONS_EMULATED
-#endif
-
-namespace boost {
-
-namespace core {
-
-//! Returns the number of currently pending exceptions
-inline unsigned int uncaught_exceptions() BOOST_NOEXCEPT
-{
-#if defined(BOOST_CORE_HAS_UNCAUGHT_EXCEPTIONS)
-    // C++17 implementation
-    return static_cast< unsigned int >(std::uncaught_exceptions());
-#elif defined(BOOST_CORE_HAS_CXA_GET_GLOBALS)
-    // Tested on {clang 3.2,GCC 3.5.6,GCC 4.1.2,GCC 4.4.6,GCC 4.4.7}x{x32,x64}
-    unsigned int count;
-    std::memcpy(&count, reinterpret_cast< const unsigned char* >(::abi::__cxa_get_globals()) + sizeof(void*), sizeof(count)); // __cxa_eh_globals::uncaughtExceptions, x32 offset - 0x4, x64 - 0x8
-    return count;
-#elif defined(BOOST_CORE_HAS_GETPTD)
-    // MSVC specific. Tested on {MSVC2005SP1,MSVC2008SP1,MSVC2010SP1,MSVC2012}x{x32,x64}.
-    unsigned int count;
-    std::memcpy(&count, static_cast< const unsigned char* >(boost::core::detail::_getptd()) + (sizeof(void*) == 8u ? 0x100 : 0x90), sizeof(count)); // _tiddata::_ProcessingThrow, x32 offset - 0x90, x64 - 0x100
-    return count;
-#else
-    // Portable C++03 implementation. Does not allow to detect multiple nested exceptions.
-    return static_cast< unsigned int >(std::uncaught_exception());
-#endif
-}
-
-} // namespace core
-
-} // namespace boost
-
-#undef BOOST_CORE_HAS_CXXABI_H
-#undef BOOST_CORE_HAS_CXA_GET_GLOBALS
-#undef BOOST_CORE_HAS_UNCAUGHT_EXCEPTIONS
-#undef BOOST_CORE_HAS_GETPTD
-
-#endif // BOOST_CORE_UNCAUGHT_EXCEPTIONS_HPP_INCLUDED_

include/boost/core/use_default.hpp

@@ -1,17 +0,0 @@
-/*
-Copyright 2019 Glen Joseph Fernandes
-(glenjofe@gmail.com)
-
-Distributed under the Boost Software License, Version 1.0.
-(http://www.boost.org/LICENSE_1_0.txt)
-*/
-#ifndef BOOST_CORE_USE_DEFAULT_HPP
-#define BOOST_CORE_USE_DEFAULT_HPP
-
-namespace boost {
-
-struct use_default { };
-
-} /* boost */
-
-#endif

include/boost/detail/iterator.hpp

@@ -6,11 +6,7 @@
 #ifndef ITERATOR_DWA122600_HPP_
 #define ITERATOR_DWA122600_HPP_
 
-// This header is obsolete and deprecated.
-
-#include <boost/config/header_deprecated.hpp>
-
-BOOST_HEADER_DEPRECATED("<iterator>")
+// This header is obsolete and will be deprecated.
 
 #include <iterator>
 #if defined(__SUNPRO_CC) && (defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION))

include/boost/detail/no_exceptions_support.hpp

@@ -12,10 +12,6 @@
 // The header file at this path is deprecated;
 // use boost/core/no_exceptions_support.hpp instead.
 
-#include <boost/config/header_deprecated.hpp>
-
-BOOST_HEADER_DEPRECATED("<boost/core/no_exceptions_support.hpp>")
-
 #include <boost/core/no_exceptions_support.hpp>
 
 #endif

include/boost/detail/scoped_enum_emulation.hpp

@@ -12,10 +12,6 @@
 // The header file at this path is deprecated;
 // use boost/core/scoped_enum.hpp instead.
 
-#include <boost/config/header_deprecated.hpp>
-
-BOOST_HEADER_DEPRECATED("<boost/core/scoped_enum.hpp>")
-
 #include <boost/core/scoped_enum.hpp>
 
 #endif

include/boost/detail/sp_typeinfo.hpp

@@ -18,9 +18,6 @@
 //  http://www.boost.org/LICENSE_1_0.txt)
 
 #include <boost/core/typeinfo.hpp>
-#include <boost/config/header_deprecated.hpp>
-
-BOOST_HEADER_DEPRECATED( "<boost/core/typeinfo.hpp>" )
 
 namespace boost
 {

include/boost/utility/empty_deleter.hpp

@@ -0,0 +1,43 @@
+/*
+ *          Copyright Andrey Semashev 2007 - 2013.
+ * Distributed under the Boost Software License, Version 1.0.
+ *    (See accompanying file LICENSE_1_0.txt or copy at
+ *          http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+/*!
+ * \file   empty_deleter.hpp
+ * \author Andrey Semashev
+ * \date   22.04.2007
+ *
+ * This header contains an \c empty_deleter implementation. This is an empty
+ * function object that receives a pointer and does nothing with it.
+ * Such empty deletion strategy may be convenient, for example, when
+ * constructing <tt>shared_ptr</tt>s that point to some object that should not be
+ * deleted (i.e. a variable on the stack or some global singleton, like <tt>std::cout</tt>).
+ */
+
+#ifndef BOOST_UTILITY_EMPTY_DELETER_HPP
+#define BOOST_UTILITY_EMPTY_DELETER_HPP
+
+#include <boost/config.hpp>
+#include <boost/core/null_deleter.hpp>
+
+#ifdef BOOST_HAS_PRAGMA_ONCE
+#pragma once
+#endif
+
+#if defined(__GNUC__)
+#pragma message "This header is deprecated, use boost/core/null_deleter.hpp instead."
+#elif defined(_MSC_VER)
+#pragma message("This header is deprecated, use boost/core/null_deleter.hpp instead.")
+#endif
+
+namespace boost {
+
+//! A deprecated name for \c null_deleter
+typedef null_deleter empty_deleter;
+
+} // namespace boost
+
+#endif // BOOST_UTILITY_EMPTY_DELETER_HPP

meta/libraries.json

@@ -9,7 +9,7 @@
     ],
     "maintainers": [
         "Peter Dimov <pdimov -at- pdimov.com>",
-        "Glen Fernandes <glenjofe -at- gmail.com>",
+        "Glen Fernandes <glenfe -at- live.com>",
         "Andrey Semashev <andrey.semashev -at- gmail.com>"
     ],
     "description": "A collection of simple core utilities with minimal dependencies.",

test/CMakeLists.txt

@@ -1,13 +0,0 @@
-# Copyright 2018, 2019 Peter Dimov
-# Distributed under the Boost Software License, Version 1.0.
-# See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt
-
-include(BoostTestJamfile OPTIONAL RESULT_VARIABLE HAVE_BOOST_TEST)
-
-if(HAVE_BOOST_TEST)
-
-boost_test_jamfile(FILE Jamfile.v2 LINK_LIBRARIES Boost::core Boost::static_assert Boost::type_traits Boost::throw_exception)
-
-endif()
-
-add_subdirectory(swap)

test/Jamfile.v2

@@ -1,6 +1,6 @@
 #  Boost.Core Library test Jamfile
 #
-#  Copyright (c) 2014, 2017 Peter Dimov
+#  Copyright (c) 2014 Peter Dimov
 #
 #  Distributed under the Boost Software License, Version 1.0.
 #  See accompanying file LICENSE_1_0.txt or copy at
@@ -9,10 +9,6 @@
 import modules ;
 import testing ;
 
-# quick test (for CI)
-run quick.cpp ;
-
-# full test suite
 run addressof_test.cpp ;
 run addressof_test2.cpp ;
 run addressof_np_test.cpp ;
@@ -55,12 +51,10 @@ compile-fail explicit_operator_bool_compile_fail_conv_pvoid.cpp ;
 compile-fail explicit_operator_bool_compile_fail_delete.cpp ;
 compile-fail explicit_operator_bool_compile_fail_shift.cpp ;
 
-compile ignore_unused_test.cpp
-  : <warnings>extra
-    <toolset>gcc:<warnings-as-errors>on
-    <toolset>clang:<warnings-as-errors>on
-    <toolset>msvc:<warnings-as-errors>on ;
-
+compile ignore_unused_test.cpp : <toolset>gcc-4.8:<cxxflags>"-Wunused-variable -Wunused-local-typedefs -Werror"
+                                   <toolset>gcc:<cxxflags>"-Wunused-variable -Werror"
+                                   <toolset>clang:<cxxflags>"-Wunused-variable -Werror"
+                                   <toolset>msvc:<cxxflags>"/we4100 /we4101" ;
 run sp_typeinfo_test.cpp ;
 run sp_typeinfo_test.cpp : : : <rtti>off : sp_typeinfo_test_no_rtti ;
 
@@ -68,35 +62,17 @@ 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 ;
+run lightweight_test_test.cpp : : : <exception-handling>off : lightweight_test_test_no_except ;
 
-run lightweight_test_test.cpp
-  : : : $(pedantic-errors) ;
-run lightweight_test_test.cpp : : :
-  <exception-handling>off $(pedantic-errors) : lightweight_test_test_no_except ;
-run lightweight_test_test2.cpp
-  : : : $(pedantic-errors) ;
-run lightweight_test_all_with_test.cpp
-  : : : $(pedantic-errors) ;
-run lightweight_test_lt_le_test.cpp
-  : : : $(pedantic-errors) ;
-run lightweight_test_gt_ge_test.cpp
-  : : : $(pedantic-errors) ;
-run lightweight_test_eq_nullptr.cpp
-  : : : $(pedantic-errors) ;
-run lightweight_test_test3.cpp
-  : : : $(pedantic-errors) ;
-run lightweight_test_test4.cpp
-  : : : $(pedantic-errors) ;
-run lightweight_test_test5.cpp
-  : : : $(pedantic-errors)
-    <toolset>gcc-4.4.7:<cxxflags>-Wno-sign-compare ;
+run lightweight_test_test2.cpp ;
+run lightweight_test_all_eq_test.cpp ;
+run lightweight_test_all_with_test.cpp ;
+run lightweight_test_all_with_fail.cpp ;
+run lightweight_test_lt_le_test.cpp ;
+run lightweight_test_gt_ge_test.cpp ;
 
-run-fail lightweight_test_all_eq_test.cpp ;
-run-fail lightweight_test_all_with_fail.cpp ;
+run lightweight_test_eq_nullptr.cpp ;
 
 run-fail lightweight_test_fail.cpp ;
 run-fail lightweight_test_fail2.cpp ;
@@ -110,22 +86,11 @@ run-fail lightweight_test_fail8.cpp ;
 run-fail lightweight_test_fail8.cpp : : : <rtti>off : lightweight_test_fail8_no_rtti ;
 run-fail lightweight_test_fail9.cpp ;
 run-fail lightweight_test_fail10.cpp ;
-run-fail lightweight_test_fail11.cpp : ;
-run-fail lightweight_test_fail12.cpp ;
-run-fail lightweight_test_fail13.cpp ;
-run-fail lightweight_test_fail14.cpp ;
 run-fail lightweight_test_lt_fail.cpp ;
 run-fail lightweight_test_le_fail.cpp ;
 run-fail lightweight_test_gt_fail.cpp ;
 run-fail lightweight_test_ge_fail.cpp ;
 
-run lightweight_test_bool.cpp
-  : : : $(pedantic-errors) ;
-
-run lightweight_test_with_test.cpp
-  : : : $(pedantic-errors) ;
-run-fail lightweight_test_with_fail.cpp ;
-
 run is_same_test.cpp ;
 
 run typeinfo_test.cpp ;
@@ -134,12 +99,9 @@ run typeinfo_test.cpp : : : <rtti>off : typeinfo_test_no_rtti ;
 run iterator_test.cpp ;
 run detail_iterator_test.cpp ;
 
-run demangle_test.cpp
-  : : : <test-info>always_show_run_output ;
-
-run demangled_name_test.cpp
-  : : : <test-info>always_show_run_output ;
+run demangle_test.cpp  : : : <test-info>always_show_run_output ;
 
+run demangled_name_test.cpp  : : : <test-info>always_show_run_output ;
 run demangled_name_test.cpp  : : : <rtti>off <test-info>always_show_run_output : demangled_name_test_no_rtti ;
 
 run scoped_enum.cpp ;
@@ -148,74 +110,12 @@ compile-fail scoped_enum_compile_fail_conv_to_int.cpp ;
 
 run underlying_type.cpp ;
 
+run pointer_traits_to_address_test.cpp ;
 run pointer_traits_pointer_test.cpp ;
 run pointer_traits_element_type_test.cpp ;
 run pointer_traits_difference_type_test.cpp ;
 run pointer_traits_rebind_test.cpp ;
 run pointer_traits_pointer_to_test.cpp ;
-run to_address_test.cpp ;
-
-run exchange_test.cpp ;
-run exchange_move_test.cpp ;
-
-run first_scalar_test.cpp ;
-compile first_scalar_constexpr_test.cpp ;
-
-run empty_value_test.cpp ;
-run empty_value_size_test.cpp ;
-run empty_value_final_test.cpp ;
-
-run quick_exit_test.cpp ;
-run-fail quick_exit_fail.cpp ;
-
-compile use_default_test.cpp ;
-
-run default_allocator_test.cpp
-  : : : <warnings>pedantic
-        <toolset>msvc:<warnings-as-errors>on
-        <toolset>gcc:<warnings-as-errors>on
-        <toolset>clang:<warnings-as-errors>on ;
-
-run noinit_adaptor_test.cpp ;
-run alloc_construct_test.cpp ;
-run alloc_construct_throws_test.cpp ;
-run alloc_construct_cxx11_test.cpp ;
-
-run nvp_test.cpp ;
-
-run allocator_value_type_test.cpp ;
-run allocator_pointer_test.cpp ;
-run allocator_const_pointer_test.cpp ;
-run allocator_void_pointer_test.cpp ;
-run allocator_const_void_pointer_test.cpp ;
-run allocator_difference_type_test.cpp ;
-run allocator_size_type_test.cpp ;
-run allocator_pocca_test.cpp ;
-run allocator_pocma_test.cpp ;
-run allocator_pocs_test.cpp ;
-run allocator_is_always_equal_test.cpp ;
-run allocator_rebind_test.cpp ;
-run allocator_allocate_test.cpp ;
-run allocator_allocate_hint_test.cpp ;
-run allocator_deallocate_test.cpp ;
-run allocator_max_size_test.cpp ;
-run allocator_soccc_test.cpp ;
-
-lib lib_typeid : lib_typeid.cpp : <link>shared:<define>LIB_TYPEID_DYN_LINK=1 ;
-
-run test_lib_typeid.cpp lib_typeid : : : <link>shared : test_lib_typeid_shared ;
-run test_lib_typeid.cpp lib_typeid : : : <link>static : test_lib_typeid_static ;
-
-run test_lib_typeid.cpp lib_typeid : : : <link>shared <rtti>off : test_lib_typeid_shared_no_rtti ;
-run test_lib_typeid.cpp lib_typeid : : : <link>static <rtti>off : test_lib_typeid_static_no_rtti ;
-
-run uncaught_exceptions.cpp
-  : : : <exception-handling>on ;
-run uncaught_exceptions_np.cpp
-  : : : <exception-handling>on ;
-
-run no_exceptions_support_test.cpp ;
-run no_exceptions_support_test.cpp : : : <exception-handling>off : no_exceptions_support_test_nx ;
 
 use-project /boost/core/swap : ./swap ;
 build-project ./swap ;

test/addressof_fn_test.cpp

@@ -16,7 +16,7 @@
 //  http://www.boost.org/LICENSE_1_0.txt
 
 #include <boost/utility/addressof.hpp>
-#include <boost/core/lightweight_test.hpp>
+#include <boost/detail/lightweight_test.hpp>
 
 
 void f0()

test/addressof_np_test.cpp

@@ -7,7 +7,7 @@
 //
 
 #include <boost/utility/addressof.hpp>
-#include <boost/core/lightweight_test.hpp>
+#include <boost/detail/lightweight_test.hpp>
 #include <cstddef>
 
 #if defined( BOOST_NO_CXX11_NULLPTR )

test/addressof_test.cpp

@@ -20,7 +20,7 @@
 #pragma warning(pop)
 #endif
 
-#include <boost/core/lightweight_test.hpp>
+#include <boost/detail/lightweight_test.hpp>
 
 template<class T> void scalar_test( T * = 0 )
 {

test/addressof_test2.cpp

@@ -22,7 +22,7 @@
 #pragma warning(pop)
 #endif
 
-#include <boost/core/lightweight_test.hpp>
+#include <boost/detail/lightweight_test.hpp>
 
 template<class T> void scalar_test( T * = 0 )
 {

test/alloc_construct_cxx11_test.cpp

@@ -1,78 +0,0 @@
-/*
-Copyright 2019 Glen Joseph Fernandes
-(glenjofe@gmail.com)
-
-Distributed under the Boost Software License, Version 1.0.
-(http://www.boost.org/LICENSE_1_0.txt)
-*/
-#include <boost/config.hpp>
-#if !defined(BOOST_NO_CXX11_ALLOCATOR)
-#include <boost/core/alloc_construct.hpp>
-#include <boost/core/lightweight_test.hpp>
-
-class type {
-public:
-    explicit type(int x)
-        : value_(x) { }
-
-    int value() const {
-        return value_;
-    }
-
-    static int count;
-
-private:
-    type(const type&);
-    type& operator=(const type&);
-
-    int value_;
-};
-
-int type::count = 0;
-
-template<class T>
-struct creator {
-    typedef T value_type;
-
-    creator() { }
-
-    template<class U>
-    creator(const creator<U>&) { }
-
-    T* allocate(std::size_t size) {
-        return static_cast<T*>(::operator new(sizeof(T) * size));
-    }
-
-    void deallocate(T* ptr, std::size_t) {
-        ::operator delete(ptr);
-    }
-
-    template<class V>
-    void construct(type* ptr, const V& value) {
-        ::new(static_cast<void*>(ptr)) type(value + 1);
-        ++type::count;
-    }
-
-    void destroy(type* ptr) {
-        ptr->~type();
-        --type::count;
-    }
-};
-
-int main()
-{
-    creator<type> a;
-    type* p = a.allocate(1);
-    boost::alloc_construct(a, p, 1);
-    BOOST_TEST_EQ(type::count, 1);
-    BOOST_TEST_EQ(p->value(), 2);
-    boost::alloc_destroy(a, p);
-    BOOST_TEST_EQ(type::count, 0);
-    return boost::report_errors();
-}
-#else
-int main()
-{
-    return 0;
-}
-#endif

test/alloc_construct_test.cpp

@@ -1,135 +0,0 @@
-/*
-Copyright 2019 Glen Joseph Fernandes
-(glenjofe@gmail.com)
-
-Distributed under the Boost Software License, Version 1.0.
-(http://www.boost.org/LICENSE_1_0.txt)
-*/
-#include <boost/core/alloc_construct.hpp>
-#include <boost/core/default_allocator.hpp>
-#include <boost/core/lightweight_test.hpp>
-
-class type {
-public:
-    explicit type(int x = 0, int y = 0)
-        : value_(x + y) {
-        ++count;
-    }
-
-    type(const type& other)
-        : value_(other.value_) {
-        ++count;
-    }
-
-    ~type() {
-        --count;
-    }
-
-    int value() const {
-        return value_;
-    }
-
-    static int count;
-
-private:
-    int value_;
-};
-
-int type::count = 0;
-
-void test_construct()
-{
-    boost::default_allocator<type> a;
-    type* p = a.allocate(1);
-    boost::alloc_construct(a, p);
-    BOOST_TEST_EQ(type::count, 1);
-    BOOST_TEST_EQ(p->value(), 0);
-    boost::alloc_destroy(a, p);
-    BOOST_TEST_EQ(type::count, 0);
-    a.deallocate(p, 1);
-}
-
-void test_construct_value()
-{
-    boost::default_allocator<type> a;
-    type* p = a.allocate(1);
-    boost::alloc_construct(a, p, 1);
-    BOOST_TEST_EQ(type::count, 1);
-    BOOST_TEST_EQ(p->value(), 1);
-    boost::alloc_destroy(a, p);
-    BOOST_TEST_EQ(type::count, 0);
-    a.deallocate(p, 1);
-}
-
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && \
-    !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-void test_construct_args()
-{
-    boost::default_allocator<type> a;
-    type* p = a.allocate(1);
-    boost::alloc_construct(a, p, 1, 2);
-    BOOST_TEST_EQ(type::count, 1);
-    BOOST_TEST_EQ(p->value(), 3);
-    boost::alloc_destroy(a, p);
-    BOOST_TEST_EQ(type::count, 0);
-    a.deallocate(p, 1);
-}
-#endif
-
-void test_construct_n()
-{
-    boost::default_allocator<type> a;
-    type* p = a.allocate(3);
-    boost::alloc_construct_n(a, p, 3);
-    BOOST_TEST_EQ(type::count, 3);
-    BOOST_TEST_EQ(p[0].value(), 0);
-    BOOST_TEST_EQ(p[1].value(), 0);
-    BOOST_TEST_EQ(p[2].value(), 0);
-    boost::alloc_destroy_n(a, p, 3);
-    BOOST_TEST_EQ(type::count, 0);
-    a.deallocate(p, 3);
-}
-
-void test_construct_n_list()
-{
-    boost::default_allocator<type> a;
-    type* p = a.allocate(3);
-    type q(1);
-    boost::alloc_construct_n(a, p, 3, &q, 1);
-    BOOST_TEST_EQ(type::count, 4);
-    BOOST_TEST_EQ(p[0].value(), 1);
-    BOOST_TEST_EQ(p[1].value(), 1);
-    BOOST_TEST_EQ(p[2].value(), 1);
-    boost::alloc_destroy_n(a, p, 3);
-    BOOST_TEST_EQ(type::count, 1);
-    a.deallocate(p, 3);
-}
-
-void test_construct_n_iterator()
-{
-    boost::default_allocator<type> a;
-    type* p = a.allocate(3);
-    type l[] = { type(1), type(2), type(3) };
-    boost::alloc_construct_n(a, p, 3, &l[0]);
-    BOOST_TEST_EQ(type::count, 6);
-    BOOST_TEST_EQ(p[0].value(), 1);
-    BOOST_TEST_EQ(p[1].value(), 2);
-    BOOST_TEST_EQ(p[2].value(), 3);
-    boost::alloc_destroy_n(a, p, 3);
-    BOOST_TEST_EQ(type::count, 3);
-    a.deallocate(p, 3);
-}
-
-int main()
-{
-    test_construct();
-    test_construct_value();
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && \
-    !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-    test_construct_args();
-#endif
-    test_construct_n();
-    test_construct_n_list();
-    test_construct_n_iterator();
-    return boost::report_errors();
-}

test/alloc_construct_throws_test.cpp

@@ -1,46 +0,0 @@
-/*
-Copyright 2019 Glen Joseph Fernandes
-(glenjofe@gmail.com)
-
-Distributed under the Boost Software License, Version 1.0.
-(http://www.boost.org/LICENSE_1_0.txt)
-*/
-#include <boost/core/alloc_construct.hpp>
-#include <boost/core/default_allocator.hpp>
-#include <boost/core/lightweight_test.hpp>
-
-class type {
-public:
-    type() {
-        if (count == 4) {
-            throw true;
-        }
-        ++count;
-    }
-
-    ~type() {
-        --count;
-    }
-
-    static int count;
-
-private:
-    type(const type&);
-    type& operator=(const type&);
-};
-
-int type::count = 0;
-
-int main()
-{
-    boost::default_allocator<type> a;
-    type* p = a.allocate(5);
-    try {
-        boost::alloc_construct_n(a, p, 5);
-        BOOST_ERROR("construct_n did not throw");
-    } catch (...) {
-        BOOST_TEST_EQ(type::count, 0);
-    }
-    a.deallocate(p, 5);
-    return boost::report_errors();
-}

test/allocator_allocate_hint_test.cpp

@@ -1,59 +0,0 @@
-/*
-Copyright 2020 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/allocator_access.hpp>
-#include <boost/core/lightweight_test.hpp>
-
-template<class T>
-struct A1 {
-    typedef T value_type;
-    typedef std::size_t size_type;
-    typedef T* pointer;
-    typedef const T* const_pointer;
-    template<class U>
-    struct rebind {
-        typedef A1<U> other;
-    };
-    A1()
-        : value() { }
-    T* allocate(std::size_t n, const void*) {
-        value = n;
-        return 0;
-    }
-    std::size_t value;
-};
-
-#if !defined(BOOST_NO_CXX11_ALLOCATOR)
-template<class T>
-struct A2 {
-    typedef T value_type;
-    A2()
-        : value() { }
-    T* allocate(std::size_t n) {
-        value = n;
-        return 0;
-    }
-    std::size_t value;
-};
-#endif
-
-int main()
-{
-    {
-        A1<int> a;
-        BOOST_TEST_NOT(boost::allocator_allocate(a, 5, 0));
-        BOOST_TEST_EQ(a.value, 5);
-    }
-#if !defined(BOOST_NO_CXX11_ALLOCATOR)
-    {
-        A2<int> a;
-        BOOST_TEST_NOT(boost::allocator_allocate(a, 5, 0));
-        BOOST_TEST_EQ(a.value, 5);
-    }
-#endif
-    return boost::report_errors();
-}

test/allocator_allocate_test.cpp

@@ -1,31 +0,0 @@
-/*
-Copyright 2020 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/allocator_access.hpp>
-#include <boost/core/lightweight_test.hpp>
-
-template<class T>
-struct A {
-    typedef T value_type;
-    typedef T* pointer;
-    typedef std::size_t size_type;
-    A()
-        : value() { }
-    T* allocate(std::size_t n) {
-        value = n;
-        return 0;
-    }
-    std::size_t value;
-};
-
-int main()
-{
-    A<int> a;
-    BOOST_TEST_NOT(boost::allocator_allocate(a, 5));
-    BOOST_TEST_EQ(a.value, 5);
-    return boost::report_errors();
-}

test/allocator_const_pointer_test.cpp

@@ -1,34 +0,0 @@
-/*
-Copyright 2020 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/allocator_access.hpp>
-#include <boost/core/is_same.hpp>
-#include <boost/core/lightweight_test_trait.hpp>
-
-template<class T>
-struct A1 {
-    typedef T value_type;
-    typedef int* const_pointer;
-};
-
-#if !defined(BOOST_NO_CXX11_ALLOCATOR)
-template<class T>
-struct A2 {
-    typedef T value_type;
-};
-#endif
-
-int main()
-{
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<int*,
-        boost::allocator_const_pointer<A1<char> >::type>));
-#if !defined(BOOST_NO_CXX11_ALLOCATOR)
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<const int*,
-        boost::allocator_const_pointer<A2<int> >::type>));
-#endif
-    return boost::report_errors();
-}

test/allocator_const_void_pointer_test.cpp

@@ -1,39 +0,0 @@
-/*
-Copyright 2020 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/allocator_access.hpp>
-#include <boost/core/is_same.hpp>
-#include <boost/core/lightweight_test_trait.hpp>
-
-template<class T>
-struct A1 {
-    typedef T value_type;
-    typedef int* const_pointer;
-    typedef int* const_void_pointer;
-    template<class U>
-    struct rebind {
-        typedef A1<U> other;
-    };
-};
-
-#if !defined(BOOST_NO_CXX11_ALLOCATOR)
-template<class T>
-struct A2 {
-    typedef T value_type;
-};
-#endif
-
-int main()
-{
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<int*,
-        boost::allocator_const_void_pointer<A1<char> >::type>));
-#if !defined(BOOST_NO_CXX11_ALLOCATOR)
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<const void*,
-        boost::allocator_const_void_pointer<A2<int> >::type>));
-#endif
-    return boost::report_errors();
-}

test/allocator_construct_test.cpp

@@ -1,46 +0,0 @@
-/*
-Copyright 2020 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/allocator_access.hpp>
-#include <boost/core/lightweight_test.hpp>
-
-template<class T>
-struct A1 {
-    typedef T value_type;
-    A1() { }
-};
-
-#if !defined(BOOST_NO_CXX11_ALLOCATOR)
-template<class T>
-struct A2 {
-    typedef T value_type;
-    A2() { }
-    template<class U, class V>
-    void construct(U* p, const V& v) {
-        ::new((void*)p) U(v + 1);
-    }
-};
-#endif
-
-int main()
-{
-    {
-        A1<int> a;
-        int i = 0;
-        boost::allocator_construct(a, &i, 5);
-        BOOST_TEST_EQ(i, 5);
-    }
-#if !defined(BOOST_NO_CXX11_ALLOCATOR)
-    {
-        A1<int> a;
-        int i = 0;
-        boost::allocator_construct(a, &i, 5);
-        BOOST_TEST_EQ(i, 6);
-    }
-#endif
-    return boost::report_errors();
-}

test/allocator_deallocate_test.cpp

@@ -1,30 +0,0 @@
-/*
-Copyright 2020 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/allocator_access.hpp>
-#include <boost/core/lightweight_test.hpp>
-
-template<class T>
-struct A {
-    typedef T value_type;
-    typedef T* pointer;
-    typedef std::size_t size_type;
-    A()
-        : value() { }
-    void deallocate(T*, std::size_t n) {
-        value = n;
-    }
-    std::size_t value;
-};
-
-int main()
-{
-    A<int> a;
-    boost::allocator_deallocate(a, 0, 5);
-    BOOST_TEST_EQ(a.value, 5);
-    return boost::report_errors();
-}

test/allocator_destroy_test.cpp

@@ -1,62 +0,0 @@
-/*
-Copyright 2020 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/allocator_access.hpp>
-#include <boost/core/lightweight_test.hpp>
-
-struct S {
-    static int count;
-    S() {
-        ++count;
-    }
-    S(const S&) {
-        ++count;
-    }
-    ~S() {
-        --count;
-    }
-};
-
-int S::count = 0;
-
-template<class T>
-struct A1 {
-    typedef T value_type;
-    A1() { }
-};
-
-#if !defined(BOOST_NO_CXX11_ALLOCATOR)
-template<class T>
-struct A2 {
-    typedef T value_type;
-    A2() { }
-    template<class U>
-    void destroy(U* p) {
-        *p = U();
-    }
-};
-#endif
-
-int main()
-{
-    {
-        A1<int> a;
-        S s;
-        boost::allocator_destroy(a, &s);
-        BOOST_TEST_EQ(S::count, 0);
-        ::new((void*)&s) S();
-    }
-#if !defined(BOOST_NO_CXX11_ALLOCATOR)
-    {
-        A1<int> a;
-        int i = 5;
-        boost::allocator_destroy(a, &i);
-        BOOST_TEST_EQ(i, 0);
-    }
-#endif
-    return boost::report_errors();
-}

test/allocator_difference_type_test.cpp

@@ -1,34 +0,0 @@
-/*
-Copyright 2020 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/allocator_access.hpp>
-#include <boost/core/is_same.hpp>
-#include <boost/core/lightweight_test_trait.hpp>
-
-template<class T>
-struct A1 {
-    typedef T value_type;
-    typedef short difference_type;
-};
-
-#if !defined(BOOST_NO_CXX11_ALLOCATOR)
-template<class T>
-struct A2 {
-    typedef T value_type;
-};
-#endif
-
-int main()
-{
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<short,
-        boost::allocator_difference_type<A1<char> >::type>));
-#if !defined(BOOST_NO_CXX11_ALLOCATOR)
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<std::ptrdiff_t,
-        boost::allocator_difference_type<A2<int> >::type>));
-#endif
-    return boost::report_errors();
-}

test/allocator_is_always_equal_test.cpp

@@ -1,47 +0,0 @@
-/*
-Copyright 2020 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/allocator_access.hpp>
-#include <boost/core/is_same.hpp>
-#include <boost/core/lightweight_test_trait.hpp>
-
-template<class T>
-struct A1 {
-    typedef T value_type;
-    int value;
-};
-
-#if !defined(BOOST_NO_CXX11_ALLOCATOR)
-template<class T>
-struct A2 {
-    typedef T value_type;
-};
-
-template<class T>
-struct A3 {
-    typedef T value_type;
-    typedef std::false_type is_always_equal;
-};
-
-template<class T>
-struct A4 {
-    typedef T value_type;
-    typedef std::true_type is_always_equal;
-    int value;
-};
-#endif
-
-int main()
-{
-    BOOST_TEST_TRAIT_FALSE((boost::allocator_is_always_equal<A1<int> >::type));
- #if !defined(BOOST_NO_CXX11_ALLOCATOR)
-    BOOST_TEST_TRAIT_TRUE((boost::allocator_is_always_equal<A2<int> >::type));
-    BOOST_TEST_TRAIT_FALSE((boost::allocator_is_always_equal<A3<int> >::type));
-    BOOST_TEST_TRAIT_TRUE((boost::allocator_is_always_equal<A4<int> >::type));
- #endif
-    return boost::report_errors();
-}

test/allocator_max_size_test.cpp

@@ -1,39 +0,0 @@
-/*
-Copyright 2020 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/allocator_access.hpp>
-#include <boost/core/lightweight_test.hpp>
-#include <limits>
-
-template<class T>
-struct A1 {
-    typedef T value_type;
-    typedef short size_type;
-    A1() { }
-    short max_size() const {
-        return 1;
-    }
-};
-
-#if !defined(BOOST_NO_CXX11_ALLOCATOR)
-template<class T>
-struct A2 {
-    typedef T value_type;
-    typedef short size_type;
-    A2() { }
-};
-#endif
-
-int main()
-{
-    BOOST_TEST_EQ(boost::allocator_max_size(A1<int>()), 1);
-#if !defined(BOOST_NO_CXX11_ALLOCATOR)
-    BOOST_TEST_LE(boost::allocator_max_size(A2<int>()),
-        (std::numeric_limits<short>::max)());
-#endif
-    return boost::report_errors();
-}

test/allocator_pocca_test.cpp

@@ -1,34 +0,0 @@
-/*
-Copyright 2020 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/allocator_access.hpp>
-#include <boost/core/is_same.hpp>
-#include <boost/core/lightweight_test_trait.hpp>
-
-template<class T>
-struct A1 {
-    typedef T value_type;
-};
-
-#if !defined(BOOST_NO_CXX11_ALLOCATOR)
-template<class T>
-struct A2 {
-    typedef T value_type;
-    typedef std::true_type propagate_on_container_copy_assignment;
-};
-#endif
-
-int main()
-{
-    BOOST_TEST_TRAIT_FALSE((boost::
-        allocator_propagate_on_container_copy_assignment<A1<int> >::type));
-#if !defined(BOOST_NO_CXX11_ALLOCATOR)
-    BOOST_TEST_TRAIT_TRUE((boost::
-        allocator_propagate_on_container_copy_assignment<A2<int> >::type));
-#endif
-    return boost::report_errors();
-}

test/allocator_pocma_test.cpp

@@ -1,34 +0,0 @@
-/*
-Copyright 2020 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/allocator_access.hpp>
-#include <boost/core/is_same.hpp>
-#include <boost/core/lightweight_test_trait.hpp>
-
-template<class T>
-struct A1 {
-    typedef T value_type;
-};
-
-#if !defined(BOOST_NO_CXX11_ALLOCATOR)
-template<class T>
-struct A2 {
-    typedef T value_type;
-    typedef std::true_type propagate_on_container_move_assignment;
-};
-#endif
-
-int main()
-{
-    BOOST_TEST_TRAIT_FALSE((boost::
-        allocator_propagate_on_container_move_assignment<A1<int> >::type));
-#if !defined(BOOST_NO_CXX11_ALLOCATOR)
-    BOOST_TEST_TRAIT_TRUE((boost::
-        allocator_propagate_on_container_move_assignment<A2<int> >::type));
-#endif
-    return boost::report_errors();
-}

test/allocator_pocs_test.cpp

@@ -1,34 +0,0 @@
-/*
-Copyright 2020 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/allocator_access.hpp>
-#include <boost/core/is_same.hpp>
-#include <boost/core/lightweight_test_trait.hpp>
-
-template<class T>
-struct A1 {
-    typedef T value_type;
-};
-
-#if !defined(BOOST_NO_CXX11_ALLOCATOR)
-template<class T>
-struct A2 {
-    typedef T value_type;
-    typedef std::true_type propagate_on_container_swap;
-};
-#endif
-
-int main()
-{
-    BOOST_TEST_TRAIT_FALSE((boost::
-        allocator_propagate_on_container_swap<A1<int> >::type));
-#if !defined(BOOST_NO_CXX11_ALLOCATOR)
-    BOOST_TEST_TRAIT_TRUE((boost::
-        allocator_propagate_on_container_swap<A2<int> >::type));
-#endif
-    return boost::report_errors();
-}

test/allocator_pointer_test.cpp

@@ -1,34 +0,0 @@
-/*
-Copyright 2020 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/allocator_access.hpp>
-#include <boost/core/is_same.hpp>
-#include <boost/core/lightweight_test_trait.hpp>
-
-template<class T>
-struct A1 {
-    typedef T value_type;
-    typedef int* pointer;
-};
-
-#if !defined(BOOST_NO_CXX11_ALLOCATOR)
-template<class T>
-struct A2 {
-    typedef T value_type;
-};
-#endif
-
-int main()
-{
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<int*,
-        boost::allocator_pointer<A1<char> >::type>));
-#if !defined(BOOST_NO_CXX11_ALLOCATOR)
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<int*,
-        boost::allocator_pointer<A2<int> >::type>));
-#endif
-    return boost::report_errors();
-}

test/allocator_rebind_test.cpp

@@ -1,37 +0,0 @@
-/*
-Copyright 2020 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/allocator_access.hpp>
-#include <boost/core/is_same.hpp>
-#include <boost/core/lightweight_test_trait.hpp>
-
-template<class T>
-struct A1 {
-    typedef T value_type;
-    template<class>
-    struct rebind {
-        typedef A1<int> other;
-    };
-};
-
-#if !defined(BOOST_NO_CXX11_ALLOCATOR)
-template<class T>
-struct A2 {
-    typedef T value_type;
-};
-#endif
-
-int main()
-{
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<A1<int>,
-        boost::allocator_rebind<A1<char>, bool>::type>));
-#if !defined(BOOST_NO_CXX11_ALLOCATOR)
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<A2<int>,
-        boost::allocator_rebind<A2<char>, int>::type>));
-#endif
-    return boost::report_errors();
-}

test/allocator_size_type_test.cpp

@@ -1,34 +0,0 @@
-/*
-Copyright 2020 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/allocator_access.hpp>
-#include <boost/core/is_same.hpp>
-#include <boost/core/lightweight_test_trait.hpp>
-
-template<class T>
-struct A1 {
-    typedef T value_type;
-    typedef int size_type;
-};
-
-#if !defined(BOOST_NO_CXX11_ALLOCATOR)
-template<class T>
-struct A2 {
-    typedef T value_type;
-};
-#endif
-
-int main()
-{
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<int,
-        boost::allocator_size_type<A1<char> >::type>));
-#if !defined(BOOST_NO_CXX11_ALLOCATOR)
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<std::size_t,
-        boost::allocator_size_type<A2<int> >::type>));
-#endif
-    return boost::report_errors();
-}

test/allocator_soccc_test.cpp

@@ -1,41 +0,0 @@
-/*
-Copyright 2020 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/allocator_access.hpp>
-#include <boost/core/lightweight_test.hpp>
-
-template<class T>
-struct A1 {
-    typedef T value_type;
-    A1(int n)
-        : value(n) { }
-    int value;
-};
-
-#if !defined(BOOST_NO_CXX11_ALLOCATOR)
-template<class T>
-struct A2 {
-    typedef T value_type;
-    A2(int n)
-        : value(n) { }
-    A2 select_on_container_copy_construction() const {
-        return A2(value + 1);
-    }
-    int value;
-};
-#endif
-
-int main()
-{
-    BOOST_TEST_EQ(1, boost::
-        allocator_select_on_container_copy_construction(A1<int>(1)).value);
-#if !defined(BOOST_NO_CXX11_ALLOCATOR)
-    BOOST_TEST_EQ(2, boost::
-        allocator_select_on_container_copy_construction(A2<int>(1)).value);
-#endif
-    return boost::report_errors();
-}

test/allocator_value_type_test.cpp

@@ -1,22 +0,0 @@
-/*
-Copyright 2020 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/allocator_access.hpp>
-#include <boost/core/is_same.hpp>
-#include <boost/core/lightweight_test_trait.hpp>
-
-template<class T>
-struct A {
-    typedef T value_type;
-};
-
-int main()
-{
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<int,
-        boost::allocator_value_type<A<int> >::type>));
-    return boost::report_errors();
-}

test/allocator_void_pointer_test.cpp

@@ -1,39 +0,0 @@
-/*
-Copyright 2020 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/allocator_access.hpp>
-#include <boost/core/is_same.hpp>
-#include <boost/core/lightweight_test_trait.hpp>
-
-template<class T>
-struct A1 {
-    typedef T value_type;
-    typedef int* pointer;
-    typedef int* void_pointer;
-    template<class U>
-    struct rebind {
-        typedef A1<U> other;
-    };
-};
-
-#if !defined(BOOST_NO_CXX11_ALLOCATOR)
-template<class T>
-struct A2 {
-    typedef T value_type;
-};
-#endif
-
-int main()
-{
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<int*,
-        boost::allocator_void_pointer<A1<char> >::type>));
-#if !defined(BOOST_NO_CXX11_ALLOCATOR)
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<void*,
-        boost::allocator_void_pointer<A2<int> >::type>));
-#endif
-    return boost::report_errors();
-}

test/cmake_install_test/CMakeLists.txt

@@ -1,17 +0,0 @@
-# Copyright 2018, 2019 Peter Dimov
-# Distributed under the Boost Software License, Version 1.0.
-# See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt
-
-cmake_minimum_required(VERSION 3.5...3.16)
-
-project(cmake_install_test LANGUAGES CXX)
-
-find_package(boost_core REQUIRED)
-
-add_executable(quick ../quick.cpp)
-target_link_libraries(quick Boost::core)
-
-enable_testing()
-add_test(quick quick)
-
-add_custom_target(check COMMAND ${CMAKE_CTEST_COMMAND} --output-on-failure -C $<CONFIG>)

test/cmake_subdir_test/CMakeLists.txt

@@ -1,19 +0,0 @@
-# Copyright 2018, 2019 Peter Dimov
-# Distributed under the Boost Software License, Version 1.0.
-# See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt
-
-cmake_minimum_required(VERSION 3.5...3.16)
-
-project(cmake_subdir_test LANGUAGES CXX)
-
-add_subdirectory(../.. boostorg/core)
-add_subdirectory(../../../assert boostorg/assert)
-add_subdirectory(../../../config boostorg/config)
-
-add_executable(quick ../quick.cpp)
-target_link_libraries(quick Boost::core)
-
-enable_testing()
-add_test(quick quick)
-
-add_custom_target(check COMMAND ${CMAKE_CTEST_COMMAND} --output-on-failure -C $<CONFIG>)

test/default_allocator_test.cpp

@@ -1,268 +0,0 @@
-/*
-Copyright 2019 Glen Joseph Fernandes
-(glenjofe@gmail.com)
-
-Distributed under the Boost Software License, Version 1.0.
-(http://www.boost.org/LICENSE_1_0.txt)
-*/
-#include <boost/core/default_allocator.hpp>
-#include <boost/core/lightweight_test_trait.hpp>
-#include <vector>
-#include <list>
-
-class type {
-public:
-    explicit type(double value)
-        : value_(value) { }
-
-private:
-    type(const type&);
-    type& operator=(const type&);
-
-    double value_;
-};
-
-void test_value_type()
-{
-    BOOST_TEST_TRAIT_SAME(int,
-        boost::default_allocator<int>::value_type);
-    BOOST_TEST_TRAIT_SAME(type,
-        boost::default_allocator<type>::value_type);
-    BOOST_TEST_TRAIT_SAME(int[5],
-        boost::default_allocator<int[5]>::value_type);
-    BOOST_TEST_TRAIT_SAME(void,
-        boost::default_allocator<void>::value_type);
-}
-
-void test_pointer()
-{
-    BOOST_TEST_TRAIT_SAME(int*,
-        boost::default_allocator<int>::pointer);
-    BOOST_TEST_TRAIT_SAME(type*,
-        boost::default_allocator<type>::pointer);
-    BOOST_TEST_TRAIT_SAME(int(*)[5],
-        boost::default_allocator<int[5]>::pointer);
-    BOOST_TEST_TRAIT_SAME(void*,
-        boost::default_allocator<void>::pointer);
-}
-
-void test_const_pointer()
-{
-    BOOST_TEST_TRAIT_SAME(const int*,
-        boost::default_allocator<int>::const_pointer);
-    BOOST_TEST_TRAIT_SAME(const type*,
-        boost::default_allocator<type>::const_pointer);
-    BOOST_TEST_TRAIT_SAME(const int(*)[5],
-        boost::default_allocator<int[5]>::const_pointer);
-    BOOST_TEST_TRAIT_SAME(const void*,
-        boost::default_allocator<void>::const_pointer);
-}
-
-void test_reference()
-{
-    BOOST_TEST_TRAIT_SAME(int&,
-        boost::default_allocator<int>::reference);
-    BOOST_TEST_TRAIT_SAME(type&,
-        boost::default_allocator<type>::reference);
-    BOOST_TEST_TRAIT_SAME(int(&)[5],
-        boost::default_allocator<int[5]>::reference);
-    BOOST_TEST_TRAIT_SAME(void,
-        boost::default_allocator<void>::reference);
-}
-
-void test_const_reference()
-{
-    BOOST_TEST_TRAIT_SAME(const int&,
-        boost::default_allocator<int>::const_reference);
-    BOOST_TEST_TRAIT_SAME(const type&,
-        boost::default_allocator<type>::const_reference);
-    BOOST_TEST_TRAIT_SAME(const int(&)[5],
-        boost::default_allocator<int[5]>::const_reference);
-    BOOST_TEST_TRAIT_SAME(const void,
-        boost::default_allocator<void>::const_reference);
-}
-
-void test_size_type()
-{
-    BOOST_TEST_TRAIT_SAME(std::size_t,
-        boost::default_allocator<int>::size_type);
-    BOOST_TEST_TRAIT_SAME(std::size_t,
-        boost::default_allocator<type>::size_type);
-    BOOST_TEST_TRAIT_SAME(std::size_t,
-        boost::default_allocator<int[5]>::size_type);
-    BOOST_TEST_TRAIT_SAME(std::size_t,
-        boost::default_allocator<void>::size_type);
-}
-
-void test_difference_type()
-{
-    BOOST_TEST_TRAIT_SAME(std::ptrdiff_t,
-        boost::default_allocator<int>::difference_type);
-    BOOST_TEST_TRAIT_SAME(std::ptrdiff_t,
-        boost::default_allocator<type>::difference_type);
-    BOOST_TEST_TRAIT_SAME(std::ptrdiff_t,
-        boost::default_allocator<int[5]>::difference_type);
-    BOOST_TEST_TRAIT_SAME(std::ptrdiff_t,
-        boost::default_allocator<void>::difference_type);
-}
-
-void test_propagate_on_container_move_assignment()
-{
-    BOOST_TEST_TRAIT_TRUE((boost::default_allocator<int>::
-        propagate_on_container_move_assignment));
-    BOOST_TEST_TRAIT_TRUE((boost::default_allocator<type>::
-        propagate_on_container_move_assignment));
-    BOOST_TEST_TRAIT_TRUE((boost::default_allocator<int[5]>::
-        propagate_on_container_move_assignment));
-    BOOST_TEST_TRAIT_TRUE((boost::default_allocator<void>::
-        propagate_on_container_move_assignment));
-}
-
-void test_is_always_equal()
-{
-    BOOST_TEST_TRAIT_TRUE((boost::default_allocator<int>::is_always_equal));
-    BOOST_TEST_TRAIT_TRUE((boost::default_allocator<type>::is_always_equal));
-    BOOST_TEST_TRAIT_TRUE((boost::default_allocator<int[5]>::is_always_equal));
-    BOOST_TEST_TRAIT_TRUE((boost::default_allocator<void>::is_always_equal));
-}
-
-void test_rebind()
-{
-    BOOST_TEST_TRAIT_SAME(boost::default_allocator<type>,
-        boost::default_allocator<int>::rebind<type>::other);
-    BOOST_TEST_TRAIT_SAME(boost::default_allocator<int[5]>,
-        boost::default_allocator<type>::rebind<int[5]>::other);
-    BOOST_TEST_TRAIT_SAME(boost::default_allocator<void>,
-        boost::default_allocator<int[5]>::rebind<void>::other);
-    BOOST_TEST_TRAIT_SAME(boost::default_allocator<int>,
-        boost::default_allocator<void>::rebind<int>::other);
-}
-
-void test_default_construct()
-{
-    boost::default_allocator<int> a1;
-    (void)a1;
-    boost::default_allocator<type> a2;
-    (void)a2;
-    boost::default_allocator<int[5]> a3;
-    (void)a3;
-    boost::default_allocator<void> a4;
-    (void)a4;
-}
-
-void test_copy()
-{
-    boost::default_allocator<int> a1;
-    boost::default_allocator<int> a2(a1);
-    (void)a2;
-    boost::default_allocator<int[5]> a3;
-    boost::default_allocator<int[5]> a4(a3);
-    (void)a4;
-    boost::default_allocator<void> a5;
-    boost::default_allocator<void> a6(a5);
-    (void)a6;
-}
-
-void test_construct_other()
-{
-    boost::default_allocator<int> a1;
-    boost::default_allocator<type> a2(a1);
-    boost::default_allocator<int[5]> a3(a2);
-    boost::default_allocator<void> a4(a3);
-    boost::default_allocator<int> a5(a4);
-    (void)a5;
-}
-
-template<class T>
-std::size_t max_size()
-{
-    return static_cast<std::size_t>(-1) / (2 < sizeof(T) ? sizeof(T) : 2);
-}
-
-void test_max_size()
-{
-    BOOST_TEST_EQ(max_size<int>(),
-        boost::default_allocator<int>().max_size());
-    BOOST_TEST_EQ(max_size<type>(),
-        boost::default_allocator<type>().max_size());
-    BOOST_TEST_EQ(max_size<int[5]>(),
-        boost::default_allocator<int[5]>().max_size());
-}
-
-template<class T>
-void test_allocate()
-{
-    boost::default_allocator<T> a;
-    T* p = a.allocate(1);
-    BOOST_TEST(p != 0);
-    a.deallocate(p, 1);
-    p = a.allocate(0);
-    a.deallocate(p, 0);
-    BOOST_TEST_THROWS(a.allocate(a.max_size() + 1), std::bad_alloc);
-}
-
-void test_allocate_deallocate()
-{
-    test_allocate<int>();
-    test_allocate<type>();
-    test_allocate<int[5]>();
-}
-
-void test_equals()
-{
-    BOOST_TEST(boost::default_allocator<int>() ==
-        boost::default_allocator<type>());
-    BOOST_TEST(boost::default_allocator<type>() ==
-        boost::default_allocator<int[5]>());
-    BOOST_TEST(boost::default_allocator<int[5]>() ==
-        boost::default_allocator<void>());
-    BOOST_TEST(boost::default_allocator<void>() ==
-        boost::default_allocator<int>());
-}
-
-void test_not_equals()
-{
-    BOOST_TEST(!(boost::default_allocator<int>() !=
-        boost::default_allocator<type>()));
-    BOOST_TEST(!(boost::default_allocator<type>() !=
-        boost::default_allocator<int[5]>()));
-    BOOST_TEST(!(boost::default_allocator<int[5]>() !=
-        boost::default_allocator<void>()));
-    BOOST_TEST(!(boost::default_allocator<void>() !=
-        boost::default_allocator<int>()));
-}
-
-void test_container()
-{
-    std::vector<int, boost::default_allocator<int> > v;
-    v.push_back(1);
-    BOOST_TEST(v.size() == 1);
-    BOOST_TEST(v.front() == 1);
-    std::list<int, boost::default_allocator<int> > l;
-    l.push_back(1);
-    BOOST_TEST(l.size() == 1);
-    BOOST_TEST(l.front() == 1);
-}
-
-int main()
-{
-    test_value_type();
-    test_pointer();
-    test_const_pointer();
-    test_reference();
-    test_const_reference();
-    test_size_type();
-    test_difference_type();
-    test_propagate_on_container_move_assignment();
-    test_is_always_equal();
-    test_rebind();
-    test_default_construct();
-    test_copy();
-    test_construct_other();
-    test_max_size();
-    test_allocate_deallocate();
-    test_equals();
-    test_not_equals();
-    test_container();
-    return boost::report_errors();
-}

test/detail_iterator_test.cpp

@@ -8,7 +8,6 @@
 // http://www.boost.org/LICENSE_1_0.txt
 //
 
-#define BOOST_ALLOW_DEPRECATED_HEADERS
 #include <boost/detail/iterator.hpp>
 #include <boost/core/is_same.hpp>
 #include <boost/core/lightweight_test_trait.hpp>

test/eif_constructors.cpp

@@ -12,7 +12,7 @@
 
 #include <boost/utility/enable_if.hpp>
 #include <boost/type_traits.hpp>
-#include <boost/core/lightweight_test.hpp>
+#include <boost/detail/lightweight_test.hpp>
 
 using boost::enable_if;
 using boost::disable_if;

test/eif_dummy_arg_disambiguation.cpp

@@ -12,7 +12,7 @@
 
 #include <boost/utility/enable_if.hpp>
 #include <boost/type_traits/is_arithmetic.hpp>
-#include <boost/core/lightweight_test.hpp>
+#include <boost/detail/lightweight_test.hpp>
 
 using boost::enable_if;
 using boost::disable_if;

test/eif_lazy.cpp

@@ -12,7 +12,7 @@
 
 #include <boost/utility/enable_if.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <boost/core/lightweight_test.hpp>
+#include <boost/detail/lightweight_test.hpp>
 
 using boost::enable_if_c;
 using boost::lazy_enable_if_c;

test/eif_lazy_test.cpp

@@ -14,7 +14,7 @@
 
 #include <boost/utility/enable_if.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <boost/core/lightweight_test.hpp>
+#include <boost/detail/lightweight_test.hpp>
 
 using boost::lazy_enable_if;
 using boost::lazy_disable_if;

test/eif_member_templates.cpp

@@ -12,7 +12,7 @@
 
 #include <boost/utility/enable_if.hpp>
 #include <boost/type_traits/is_arithmetic.hpp>
-#include <boost/core/lightweight_test.hpp>
+#include <boost/detail/lightweight_test.hpp>
 
 using boost::enable_if;
 using boost::disable_if;

test/eif_namespace_disambiguation.cpp

@@ -13,7 +13,7 @@
 #include <boost/config.hpp>
 #include <boost/utility/enable_if.hpp>
 #include <boost/type_traits/is_arithmetic.hpp>
-#include <boost/core/lightweight_test.hpp>
+#include <boost/detail/lightweight_test.hpp>
 
 using boost::enable_if;
 using boost::is_arithmetic;

test/eif_no_disambiguation.cpp

@@ -13,7 +13,7 @@
 #include <boost/config.hpp>
 #include <boost/utility/enable_if.hpp>
 #include <boost/type_traits/is_arithmetic.hpp>
-#include <boost/core/lightweight_test.hpp>
+#include <boost/detail/lightweight_test.hpp>
 
 using boost::enable_if;
 using boost::is_arithmetic;

test/eif_partial_specializations.cpp

@@ -12,7 +12,7 @@
 
 #include <boost/utility/enable_if.hpp>
 #include <boost/type_traits/is_arithmetic.hpp>
-#include <boost/core/lightweight_test.hpp>
+#include <boost/detail/lightweight_test.hpp>
 
 using boost::enable_if_has_type;
 using boost::enable_if_c;

test/empty_value_final_test.cpp

@@ -1,62 +0,0 @@
-/*
-Copyright 2018 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/empty_value.hpp>
-#include <boost/core/lightweight_test.hpp>
-
-#if !defined(BOOST_NO_CXX11_FINAL)
-class type final {
-public:
-    explicit type(int count)
-        : value_(count) { }
-    int value() const {
-        return value_ + 1;
-    }
-    int value() {
-        return value_ + 2;
-    }
-private:
-    int value_;
-};
-
-struct empty final {
-    int value() const {
-        return 1;
-    }
-    int value() {
-        return 2;
-    }
-};
-
-void test_type()
-{
-    const boost::empty_value<type> v1(boost::empty_init_t(), 3);
-    BOOST_TEST(v1.get().value() == 4);
-    boost::empty_value<type> v2(boost::empty_init_t(), 3);
-    BOOST_TEST(v2.get().value() == 5);
-}
-
-void test_empty()
-{
-    const boost::empty_value<empty> v1 = boost::empty_init_t();
-    BOOST_TEST(v1.get().value() == 1);
-    boost::empty_value<empty> v2;
-    BOOST_TEST(v2.get().value() == 2);
-}
-
-int main()
-{
-    test_type();
-    test_empty();
-    return boost::report_errors();
-}
-#else
-int main()
-{
-    return 0;
-}
-#endif

test/empty_value_size_test.cpp

@@ -1,60 +0,0 @@
-/*
-Copyright 2018 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/config.hpp>
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
-#include <boost/core/empty_value.hpp>
-#include <boost/core/lightweight_test.hpp>
-
-struct T1 { };
-
-struct S1
-    : boost::empty_value<T1, 0, true> { };
-
-struct T2 {
-    int value;
-};
-
-struct S2
-    : boost::empty_value<T1, 0, true>
-    , boost::empty_value<T2, 1, true> { };
-
-struct S3
-    : boost::empty_value<T1, 0, false>
-    , boost::empty_value<T2, 1, true> { };
-
-struct T3 { };
-
-struct S4
-    : boost::empty_value<T1, 0, true>
-    , boost::empty_value<T3, 1, true> { };
-
-struct S5
-    : boost::empty_value<T1, 0, false>
-    , boost::empty_value<T3, 1, false> { };
-
-struct S6
-    : boost::empty_value<T1, 0, true>
-    , boost::empty_value<T2, 1, true>
-    , boost::empty_value<T3, 2, true> { };
-
-int main()
-{
-    BOOST_TEST(sizeof(S1) == sizeof(T1));
-    BOOST_TEST(sizeof(S2) == sizeof(T2));
-    BOOST_TEST(sizeof(S3) > sizeof(T2));
-    BOOST_TEST(sizeof(S4) == sizeof(T1));
-    BOOST_TEST(sizeof(S5) > sizeof(T1));
-    BOOST_TEST(sizeof(S6) == sizeof(T2));
-    return boost::report_errors();
-}
-#else
-int main()
-{
-    return 0;
-}
-#endif

test/empty_value_test.cpp

@@ -1,72 +0,0 @@
-/*
-Copyright 2018 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/empty_value.hpp>
-#include <boost/core/lightweight_test.hpp>
-
-struct empty {
-    int value() const {
-        return 1;
-    }
-    int value() {
-        return 2;
-    }
-};
-
-class type {
-public:
-    explicit type(int count)
-        : value_(count) { }
-    int value() const {
-        return value_ + 1;
-    }
-    int value() {
-        return value_ + 2;
-    }
-private:
-    int value_;
-};
-
-void test_int()
-{
-    const boost::empty_value<int> v1(boost::empty_init_t(), 7);
-    BOOST_TEST(v1.get() == 7);
-    boost::empty_value<int> v2 = boost::empty_init_t();
-    BOOST_TEST(v2.get() == 0);
-    v2 = v1;
-    BOOST_TEST(v2.get() == 7);
-    v2.get() = 8;
-    BOOST_TEST(v2.get() == 8);
-}
-
-void test_empty()
-{
-    const boost::empty_value<empty> v1 = boost::empty_init_t();
-    BOOST_TEST(v1.get().value() == 1);
-    boost::empty_value<empty> v2;
-    BOOST_TEST(v2.get().value() == 2);
-}
-
-void test_type()
-{
-    const boost::empty_value<type> v1(boost::empty_init_t(), 2);
-    BOOST_TEST(v1.get().value() == 3);
-    boost::empty_value<type> v2(boost::empty_init_t(), 3);
-    BOOST_TEST(v2.get().value() == 5);
-    v2 = v1;
-    BOOST_TEST(v2.get().value() == 4);
-    v2.get() = type(4);
-    BOOST_TEST(v2.get().value() == 6);
-}
-
-int main()
-{
-    test_int();
-    test_empty();
-    test_type();
-    return boost::report_errors();
-}

test/exchange_move_test.cpp

@@ -1,100 +0,0 @@
-/*
-Copyright 2018 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/config.hpp>
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-#include <boost/core/exchange.hpp>
-#include <boost/core/lightweight_test.hpp>
-
-class C1 {
-public:
-    explicit C1(int i)
-        : i_(i) { }
-    C1(C1&& c)
-        : i_(c.i_) { }
-    C1& operator=(C1&& c) {
-        i_ = c.i_;
-        return *this;
-    }
-    int i() const {
-        return i_;
-    }
-private:
-    C1(const C1&);
-    C1& operator=(const C1&);
-    int i_;
-};
-
-void test1()
-{
-    C1 x(1);
-    BOOST_TEST(boost::exchange(x, C1(2)).i() == 1);
-    BOOST_TEST(x.i() == 2);
-}
-
-class C2 {
-public:
-    explicit C2(int i)
-        : i_(i) { }
-    operator C1() const {
-        return C1(i_);
-    }
-    int i() const {
-        return i_;
-    }
-private:
-    C2(const C2&);
-    C2& operator=(const C2&);
-    int i_;
-};
-
-void test2()
-{
-    C1 x(1);
-    BOOST_TEST(boost::exchange(x, C2(2)).i() == 1);
-    BOOST_TEST(x.i() == 2);
-}
-
-class C3 {
-public:
-    explicit C3(int i)
-        : i_(i) { }
-    C3(C3&& c)
-        : i_(c.i_) { }
-    C3& operator=(C1&& c) {
-        i_ = c.i();
-        return *this;
-    }
-    int i() const {
-        return i_;
-    }
-private:
-    C3(const C3&);
-    C3& operator=(const C3&);
-    int i_;
-};
-
-void test3()
-{
-    C3 x(1);
-    BOOST_TEST(boost::exchange(x, C1(2)).i() == 1);
-    BOOST_TEST(x.i() == 2);
-}
-
-int main()
-{
-    test1();
-    test2();
-    test3();
-    return boost::report_errors();
-}
-#else
-int main()
-{
-    return 0;
-}
-#endif

test/exchange_test.cpp

@@ -1,89 +0,0 @@
-/*
-Copyright 2018 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/exchange.hpp>
-#include <boost/core/lightweight_test.hpp>
-
-void test1()
-{
-    int i = 1;
-    BOOST_TEST(boost::exchange(i, 2) == 1);
-    BOOST_TEST(i == 2);
-}
-
-class C1 {
-public:
-    explicit C1(int i)
-        : i_(i) { }
-    int i() const {
-        return i_;
-    }
-private:
-    int i_;
-};
-
-void test2()
-{
-    C1 x(1);
-    BOOST_TEST(boost::exchange(x, C1(2)).i() == 1);
-    BOOST_TEST(x.i() == 2);
-}
-
-class C2 {
-public:
-    explicit C2(int i)
-        : i_(i) { }
-    operator C1() const {
-        return C1(i_);
-    }
-    int i() const {
-        return i_;
-    }
-private:
-    int i_;
-};
-
-void test3()
-{
-    C1 x(1);
-    BOOST_TEST(boost::exchange(x, C2(2)).i() == 1);
-    BOOST_TEST(x.i() == 2);
-}
-
-class C3 {
-public:
-    explicit C3(int i)
-        : i_(i) { }
-    C3(const C3& c)
-        : i_(c.i_) { }
-    C3& operator=(const C1& c) {
-        i_ = c.i();
-        return *this;
-    }
-    int i() const {
-        return i_;
-    }
-private:
-    C3& operator=(const C3&);
-    int i_;
-};
-
-void test4()
-{
-    C3 x(1);
-    BOOST_TEST(boost::exchange(x, C1(2)).i() == 1);
-    BOOST_TEST(x.i() == 2);
-}
-
-int main()
-{
-    test1();
-    test2();
-    test3();
-    test4();
-    return boost::report_errors();
-}