Mark quick_exit as inline

Avoid -Wlong-long in bit_ceil_test.cpp
Avoid -Wlong-long in bit_rotate_test.cpp
2022-02-15 02:08:30 +02:00 · 2022-02-08 22:58:45 +02:00 · 2022-02-08 22:55:08 +02:00 · 2022-02-08 22:49:44 +02:00 · 2022-02-08 22:48:01 +02:00 · 2022-02-08 22:00:42 +02:00
53 changed files with 1699 additions and 572 deletions
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -213,6 +213,30 @@ jobs:
              - clang-12
              - libc++-12-dev
              - libc++abi-12-dev
+          - toolset: clang
+            compiler: clang++-13
+            cxxstd: "03,11,14,17,20"
+            os: ubuntu-20.04
+            install:
+              - clang-13
+            sources:
+              - "deb http://apt.llvm.org/focal/ llvm-toolchain-focal-13 main"
+            source_keys:
+              - "https://apt.llvm.org/llvm-snapshot.gpg.key"
+          - toolset: clang
+            compiler: clang++-13
+            cxxstd: "03,11,14,17,20"
+            os: ubuntu-20.04
+            install:
+              - clang-13
+              - libc++-13-dev
+              - libc++abi-13-dev
+            sources:
+              - "deb http://apt.llvm.org/focal/ llvm-toolchain-focal-13 main"
+            source_keys:
+              - "https://apt.llvm.org/llvm-snapshot.gpg.key"
+            cxxflags: -stdlib=libc++
+            linkflags: -stdlib=libc++
          - name: UBSAN
            toolset: clang
            compiler: clang++-12
@@ -230,10 +254,6 @@ jobs:
            cxxstd: "03,11,14,17,2a"
            os: macos-10.15

-          - name: CMake tests
-            cmake_tests: 1
-            os: ubuntu-20.04
-
    timeout-minutes: 120
    runs-on: ${{matrix.os}}
    container: ${{matrix.container}}
@@ -386,20 +406,19 @@ jobs:
            git submodule init libs/static_assert
            git submodule init libs/throw_exception
            git submodule init libs/type_traits
+            git submodule init libs/utility
+            git submodule init libs/io
            git submodule update $GIT_ARGS
-            if [ -z "${{matrix.cmake_tests}}" ]
+            ./bootstrap.sh
+            ./b2 headers
+            if [ -n "${{matrix.compiler}}" -o -n "$GCC_TOOLCHAIN_ROOT" ]
            then
-                ./bootstrap.sh
-                ./b2 headers
-                if [ -n "${{matrix.compiler}}" -o -n "$GCC_TOOLCHAIN_ROOT" ]
+                echo -n "using ${{matrix.toolset}} : : ${{matrix.compiler}}" > ~/user-config.jam
+                if [ -n "$GCC_TOOLCHAIN_ROOT" ]
                then
-                    echo -n "using ${{matrix.toolset}} : : ${{matrix.compiler}}" > ~/user-config.jam
-                    if [ -n "$GCC_TOOLCHAIN_ROOT" ]
-                    then
-                        echo -n " : <compileflags>\"--gcc-toolchain=$GCC_TOOLCHAIN_ROOT\" <linkflags>\"--gcc-toolchain=$GCC_TOOLCHAIN_ROOT\"" >> ~/user-config.jam
-                    fi
-                    echo " ;" >> ~/user-config.jam
+                    echo -n " : <compileflags>\"--gcc-toolchain=$GCC_TOOLCHAIN_ROOT\" <linkflags>\"--gcc-toolchain=$GCC_TOOLCHAIN_ROOT\"" >> ~/user-config.jam
                fi
+                echo " ;" >> ~/user-config.jam
            fi

      - name: Run tests
@@ -433,52 +452,25 @@ jobs:
            B2_ARGS+=("libs/$LIBRARY/test")
            ./b2 "${B2_ARGS[@]}"

-      - name: Run CMake tests
-        if: matrix.cmake_tests != ''
-        run: |
-            cd ../boost-root
-            mkdir __build_cmake_test__ && cd __build_cmake_test__
-            cmake -DBUILD_TESTING=ON -DBOOST_INCLUDE_LIBRARIES=$LIBRARY ..
-            cmake --build . --target tests
-            ctest --output-on-failure
-
-      - name: Run CMake subdir tests
-        if: matrix.cmake_tests != ''
-        run: |
-            cd ../boost-root/libs/$LIBRARY/test/cmake_subdir_test
-            mkdir __build_cmake_subdir_test__ && cd __build_cmake_subdir_test__
-            cmake ..
-            cmake --build .
-            cmake --build . --target check
-
-      - name: Run CMake install tests
-        if: matrix.cmake_tests != ''
-        run: |
-            cd ../boost-root
-            mkdir __build_cmake_install_test__ && cd __build_cmake_install_test__
-            cmake -DBOOST_INCLUDE_LIBRARIES=$LIBRARY -DCMAKE_INSTALL_PREFIX=~/.local ..
-            cmake --build . --target install
-            cd ../libs/$LIBRARY/test/cmake_install_test
-            mkdir __build_cmake_install_test__ && cd __build_cmake_install_test__
-            cmake -DCMAKE_INSTALL_PREFIX=~/.local ..
-            cmake --build .
-            cmake --build . --target check
-
  windows:
    strategy:
      fail-fast: false
      matrix:
        include:
+          - toolset: msvc-14.0
+            cxxstd: "14"
+            addrmd: 32,64
+            os: windows-2019
          - toolset: msvc-14.1
            cxxstd: "14,17,latest"
            addrmd: 32,64
            os: windows-2016
          - toolset: msvc-14.2
-            cxxstd: "14,17,latest"
+            cxxstd: "14,17,20,latest"
            addrmd: 32,64
            os: windows-2019
          - toolset: msvc-14.3
-            cxxstd: "14,17,latest"
+            cxxstd: "14,17,20,latest"
            addrmd: 32,64
            os: windows-2022
          - toolset: gcc
@@ -517,6 +509,8 @@ jobs:
            git submodule init libs/static_assert
            git submodule init libs/throw_exception
            git submodule init libs/type_traits
+            git submodule init libs/utility
+            git submodule init libs/io
            git submodule update --jobs %GIT_FETCH_JOBS%
            cmd /c bootstrap
            b2 -d0 headers
@@ -526,3 +520,159 @@ jobs:
        run: |
            cd ../boost-root
            b2 -j %NUMBER_OF_PROCESSORS% libs/%LIBRARY%/test toolset=${{matrix.toolset}} cxxstd=${{matrix.cxxstd}} address-model=${{matrix.addrmd}} variant=debug,release
+
+  posix-cmake-subdir:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: ubuntu-18.04
+          - os: ubuntu-20.04
+          - os: macos-10.15
+
+    runs-on: ${{matrix.os}}
+
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Install packages
+        if: matrix.install
+        run: sudo apt install ${{matrix.install}}
+
+      - name: Setup Boost
+        run: |
+          echo GITHUB_REPOSITORY: $GITHUB_REPOSITORY
+          LIBRARY=${GITHUB_REPOSITORY#*/}
+          echo LIBRARY: $LIBRARY
+          echo "LIBRARY=$LIBRARY" >> $GITHUB_ENV
+          echo GITHUB_BASE_REF: $GITHUB_BASE_REF
+          echo GITHUB_REF: $GITHUB_REF
+          REF=${GITHUB_BASE_REF:-$GITHUB_REF}
+          REF=${REF#refs/heads/}
+          echo REF: $REF
+          BOOST_BRANCH=develop && [ "$REF" == "master" ] && BOOST_BRANCH=master || true
+          echo BOOST_BRANCH: $BOOST_BRANCH
+          cd ..
+          git clone -b $BOOST_BRANCH --depth 1 https://github.com/boostorg/boost.git boost-root
+          cd boost-root
+          cp -r $GITHUB_WORKSPACE/* libs/$LIBRARY
+          git submodule update --init tools/boostdep
+          python tools/boostdep/depinst/depinst.py --git_args "--jobs 3" $LIBRARY
+
+      - name: Use library with add_subdirectory
+        run: |
+          cd ../boost-root/libs/$LIBRARY/test/cmake_subdir_test
+          mkdir __build__ && cd __build__
+          cmake ..
+          cmake --build .
+          ctest --output-on-failure --no-tests=error
+
+  posix-cmake-install:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: ubuntu-18.04
+          - os: ubuntu-20.04
+          - os: macos-10.15
+
+    runs-on: ${{matrix.os}}
+
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Install packages
+        if: matrix.install
+        run: sudo apt install ${{matrix.install}}
+
+      - name: Setup Boost
+        run: |
+          echo GITHUB_REPOSITORY: $GITHUB_REPOSITORY
+          LIBRARY=${GITHUB_REPOSITORY#*/}
+          echo LIBRARY: $LIBRARY
+          echo "LIBRARY=$LIBRARY" >> $GITHUB_ENV
+          echo GITHUB_BASE_REF: $GITHUB_BASE_REF
+          echo GITHUB_REF: $GITHUB_REF
+          REF=${GITHUB_BASE_REF:-$GITHUB_REF}
+          REF=${REF#refs/heads/}
+          echo REF: $REF
+          BOOST_BRANCH=develop && [ "$REF" == "master" ] && BOOST_BRANCH=master || true
+          echo BOOST_BRANCH: $BOOST_BRANCH
+          cd ..
+          git clone -b $BOOST_BRANCH --depth 1 https://github.com/boostorg/boost.git boost-root
+          cd boost-root
+          cp -r $GITHUB_WORKSPACE/* libs/$LIBRARY
+          git submodule update --init tools/boostdep
+          python tools/boostdep/depinst/depinst.py --git_args "--jobs 3" $LIBRARY
+
+      - name: Configure
+        run: |
+          cd ../boost-root
+          mkdir __build__ && cd __build__
+          cmake -DBOOST_INCLUDE_LIBRARIES=$LIBRARY -DCMAKE_INSTALL_PREFIX=~/.local ..
+
+      - name: Install
+        run: |
+          cd ../boost-root/__build__
+          cmake --build . --target install
+
+      - name: Use the installed library
+        run: |
+          cd ../boost-root/libs/$LIBRARY/test/cmake_install_test && mkdir __build__ && cd __build__
+          cmake -DCMAKE_INSTALL_PREFIX=~/.local ..
+          cmake --build .
+          ctest --output-on-failure --no-tests=error
+
+  posix-cmake-test:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: ubuntu-18.04
+          - os: ubuntu-20.04
+          - os: macos-10.15
+
+    runs-on: ${{matrix.os}}
+
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Install packages
+        if: matrix.install
+        run: sudo apt install ${{matrix.install}}
+
+      - name: Setup Boost
+        run: |
+          echo GITHUB_REPOSITORY: $GITHUB_REPOSITORY
+          LIBRARY=${GITHUB_REPOSITORY#*/}
+          echo LIBRARY: $LIBRARY
+          echo "LIBRARY=$LIBRARY" >> $GITHUB_ENV
+          echo GITHUB_BASE_REF: $GITHUB_BASE_REF
+          echo GITHUB_REF: $GITHUB_REF
+          REF=${GITHUB_BASE_REF:-$GITHUB_REF}
+          REF=${REF#refs/heads/}
+          echo REF: $REF
+          BOOST_BRANCH=develop && [ "$REF" == "master" ] && BOOST_BRANCH=master || true
+          echo BOOST_BRANCH: $BOOST_BRANCH
+          cd ..
+          git clone -b $BOOST_BRANCH --depth 1 https://github.com/boostorg/boost.git boost-root
+          cd boost-root
+          cp -r $GITHUB_WORKSPACE/* libs/$LIBRARY
+          git submodule update --init tools/boostdep
+          python tools/boostdep/depinst/depinst.py --git_args "--jobs 3" $LIBRARY
+
+      - name: Configure
+        run: |
+          cd ../boost-root
+          mkdir __build__ && cd __build__
+          cmake -DBOOST_INCLUDE_LIBRARIES=$LIBRARY -DBUILD_TESTING=ON ..
+
+      - name: Build tests
+        run: |
+          cd ../boost-root/__build__
+          cmake --build . --target tests
+
+      - name: Run tests
+        run: |
+          cd ../boost-root/__build__
+          ctest --output-on-failure --no-tests=error
--- a/appveyor.yml
+++ b/appveyor.yml
@@ -1,4 +1,4 @@
-# Copyright 2016-2019 Peter Dimov
+# Copyright 2016-2021 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)

@@ -29,14 +29,9 @@ environment:

    # clang-win 32 bit fails to link with "unable to load mspdbcore.dll (error code: 126)"

-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
      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,latest

    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
@@ -77,6 +72,8 @@ install:
  - git submodule init libs/static_assert
  - git submodule init libs/throw_exception
  - git submodule init libs/type_traits
+  - git submodule init libs/utility
+  - git submodule init libs/io
  - git submodule init tools/build
  - git submodule init tools/boost_install
  - git submodule update --jobs 4
@@ -90,4 +87,4 @@ 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 -j %NUMBER_OF_PROCESSORS% libs/core/test toolset=%TOOLSET% %CXXSTD% %ADDRMD% variant=debug,release embed-manifest-via=linker
--- a/doc/Jamfile.v2
+++ b/doc/Jamfile.v2
@@ -5,12 +5,15 @@
 # Version 1.0. (See accompanying file LICENSE_1_0.txt
 # or copy at http://boost.org/LICENSE_1_0.txt)

+import project ;
 import doxygen ;
 import quickbook ;

+path-constant INCLUDES : ../../.. ;
+
 doxygen ref_reference
  :
-    [ glob ../../../boost/core/ref.hpp ]
+    $(INCLUDES)/boost/core/ref.hpp
  :
    <doxygen:param>ENABLE_PREPROCESSING=YES
    <doxygen:param>EXPAND_ONLY_PREDEF=YES
--- a/doc/alloc_construct.qbk
+++ b/doc/alloc_construct.qbk
@@ -6,7 +6,7 @@ Distributed under the Boost Software License, Version 1.0.
 (http://www.boost.org/LICENSE_1_0.txt)
 ]

-[section:alloc_construct alloc_construct, alloc_destroy]
+[section:alloc_construct alloc_construct]

 [simplesect Authors]

--- a/doc/allocator_access.qbk
+++ b/doc/allocator_access.qbk
@@ -6,7 +6,7 @@ Distributed under the Boost Software License, Version 1.0.
 (http://www.boost.org/LICENSE_1_0.txt)
 ]

-[section Allocator Access]
+[section allocator_access]

 [simplesect Authors]

@@ -168,7 +168,8 @@ A allocator_select_on_container_copy_construction(const A& a);
 [[`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*`.]]
+[The member `type` is `A::pointer` if valid, otherwise
+`allocator_value_type_t<A>*`.]]
 [[`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
@@ -224,7 +225,7 @@ void allocator_construct(A& a, T*p, Args&&... args);`]
 [[`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)`.]]
+sizeof(allocator_value_type_t<A>)`.]]
 [[`template<class A> A allocator_select_on_container_copy_construction(const
 A& a);`]
 [Returns `a.select_on_container_copy_construction()` if valid, otherwise
--- a/doc/allocator_traits.qbk
+++ b/doc/allocator_traits.qbk
@@ -0,0 +1,116 @@
+[/
+Copyright 2021 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_traits allocator_traits]
+
+[simplesect Authors]
+
+* Glen Fernandes
+
+[endsimplesect]
+
+[section Overview]
+
+This header <boost/core/allocator_traits.hpp> provides an implementation of the
+C++ standard library class template `allocator_traits` based on the facilities
+in [link core.allocator_access Allocator Access]. Users should still prefer the
+individual traits, but this utility exists to simplify migration.
+
+[endsect]
+
+[section Reference]
+
+```
+namespace boost {
+
+template<class A>
+struct allocator_traits {
+    using allocator_type = A;
+
+    using value_type = allocator_value_type_t<A>;
+
+    using pointer = allocator_pointer_t<A>;
+
+    using const_pointer = allocator_const_pointer_t<A>;
+
+    using void_pointer = allocator_void_pointer_t<A>;
+
+    using const_pointer = allocator_const_void_pointer_t<A>;
+
+    using difference_type = allocator_difference_type_t<A>;
+
+    using size_type = allocator_size_type_t<A>;
+
+    using propagate_on_container_copy_assignment =
+        allocator_propagate_on_container_copy_assignment_t<A>;
+
+    using propagate_on_container_move_assignment =
+        allocator_propagate_on_container_move_assignment_t<A>;
+
+    using propagate_on_container_swap =
+        allocator_propagate_on_container_swap_t<A>;
+
+    using is_always_equal = allocator_is_always_equal_t<A>;
+
+    template<class T>
+    using rebind_traits = allocator_traits<allocator_rebind_t<A, T> >;
+
+    static pointer allocate(A& a, size_type n);
+
+    static pointer allocate(A& a, size_type n, const_void_pointer h);
+
+    static void deallocate(A& a, pointer p, size_type n);
+
+    template<class T, class... Args>
+    static void construct(A& a, T* p, Args&&... args);
+
+    static void destroy(A& a, T* p);
+
+    static size_type max_size(const A& a) noexcept;
+
+    static A select_on_container_copy_construction(const A& a);
+};
+
+} /* boost */
+```
+
+[section Static member functions]
+
+[variablelist
+[[`static pointer allocate(A& a, size_type n);`]
+[Equivalent to: `return boost::allocator_allocate(a, n);`]]
+[[`static pointer allocate(A& a, size_type n, const_void_pointer h);`]
+[Equivalent to: `return boost::allocator_allocate(a, n, h);`]]
+[[`static void deallocate(A& a, pointer p, size_type n);`]
+[Equivalent to: `boost::allocator_deallocate(a, n, h);`]]
+[[`template<class T, class... Args>
+static void construct(A& a, T* p, Args&&... args);`]
+[Equivalent to:
+`boost::allocator_construct(a, p, std::forward<Args>(args)...);`]]
+[[`static void destroy(A& a, T* p);`]
+[Equivalent to: `boost::allocator_destroy(a, p);`]]
+[[`static size_type max_size(const A& a) noexcept;`]
+[Equivalent to: `return boost::allocator_max_size(a);`]]
+[[`static A select_on_container_copy_construction(const A& a);`]
+[Equivalent to:
+`return boost::allocator_select_on_container_copy_construction(a);`]]]
+
+[endsect]
+
+[endsect]
+
+[section Notes]
+
+# The member `rebind_alloc` is not provided for parity with C++03 where it is
+unimplementable. Instead of `allocator_traits<A>::rebind_alloc<U>` you can
+express the same with `allocator_traits<A>::rebind_traits<U>::allocator_type`
+or more simply with `allocator_rebind_t<A, U>`.
+
+[endsect]
+
+[endsect]
--- a/doc/changes.qbk
+++ b/doc/changes.qbk
@@ -6,6 +6,14 @@

 [section Revision History]

+[section Changes in 1.79.0]
+
+* Added `boost::allocator_traits`, an implementation of `std::allocator_traits`.
+* Made `boost::pointer_traits` SFINAE friendly.
+* `boost/iterator.hpp` is deprecated and will be removed in a future release. The header defines `boost::iterator` template, which is equivalent to `std::iterator` in `<iterator>` header. However, since `std::iterator` is itself deprecated in C++17, users are advised to remove `boost::iterator` or `std::iterator` use from their code.
+
+[endsect]
+
 [section Changes in 1.78.0]

 * Added a generic implementation to `boost/core/cmath.hpp`, enabled when `BOOST_CORE_USE_GENERIC_CMATH`
--- a/doc/core.qbk
+++ b/doc/core.qbk
@@ -42,6 +42,7 @@ criteria for inclusion is that the utility component be:

 [include addressof.qbk]
 [include allocator_access.qbk]
+[include allocator_traits.qbk]
 [include alloc_construct.qbk]
 [include bit.qbk]
 [include checked_delete.qbk]
--- a/doc/pointer_traits.qbk
+++ b/doc/pointer_traits.qbk
@@ -1,5 +1,5 @@
 [/
-Copyright 2017-2018 Glen Joseph Fernandes
+Copyright 2017-2021 Glen Joseph Fernandes
 (glenjofe@gmail.com)

 Distributed under the Boost Software License, Version 1.0.
@@ -47,68 +47,88 @@ void function(Allocator& a)

 ```
 namespace boost {
-  template<class T> struct pointer_traits {
+
+template<class T>
+struct pointer_traits {
    typedef T pointer;
    typedef ``['see below]`` element_type;
    typedef ``['see below]`` difference_type;

-    template<class U> struct rebind_to { typedef ``['see below]`` type; };
-    template<class U> using rebind = typename rebind_to<U>::type;
+    template<class U>
+    struct rebind_to {
+        typedef ``['see below]`` type;
+    };

-    static pointer pointer_to(``['see below]`` v);
-  };
+    template<class U>
+    using rebind = typename rebind_to<U>::type;

-  template<class T> struct pointer_traits<T*> {
+    static pointer pointer_to(element_type& v);
+};
+
+template<class T>
+struct pointer_traits<T*> {
    typedef T* pointer;
    typedef T element_type;
    typedef std::ptrdiff_t difference_type;

-    template<class U> struct rebind_to { typedef U* type; };
-    template<class U> using rebind = typename rebind_to<U>::type;
+    template<class U>
+    struct rebind_to {
+        typedef U* type;
+    };
+
+    template<class U>
+    using rebind = typename rebind_to<U>::type;

    static pointer pointer_to(``['see below]`` v) noexcept;
-  };
+};

-  template<class T>
-  constexpr T* to_address(T* v) noexcept;
+template<class T>
+constexpr T* to_address(T* v) noexcept;

-  template<class T>
-  auto to_address(const T& v) noexcept;
-}
+template<class T>
+auto to_address(const T& v) noexcept;
+
+} // boost
 ```

+[section Overview]
+
+If the member type `element_type` is not defined, then all other members are
+also not defined (`pointer_traits` is SFINAE-friendly).
+
+[endsect]
+
 [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.]]
+  or more type arguments; otherwise the member is not defined.]]
 [[`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.]]]
+  where `Args` is zero or more type arguments; otherwise, the member is not
+  defined.]]]

 [endsect]

 [section Member functions]

 [variablelist
-[[`static pointer pointer_traits::pointer_to(`['see below] `v);`]
+[[`static pointer pointer_traits::pointer_to(element_type& v);`]
 [[variablelist
 [[Remark]
-[If `element_type` is a void type, the type of `v` is unspecified; otherwise,
-  it is `element_type&`.]]
+[If `element_type` is a void type, or if `T::pointer_to(v)` is not well formed,
+  this member is not defined.]]
 [[Returns]
 [A pointer to `v` obtained by calling `T::pointer_to(v)`.]]]]]
-[[`static pointer pointer_traits<T*>::pointer_to(`['see below] `v) noexcept;`]
+[[`static pointer pointer_traits<T*>::pointer_to(element_type& v) noexcept;`]
 [[variablelist
 [[Remark]
-[If `element_type` is a void type, the type of `v` is unspecified; otherwise,
-  it is `element_type&`.]]
+[If `element_type` is a void type, this member is not defined.]]
 [[Returns][`addressof(v)`.]]]]]]

 [endsect]
--- a/include/boost/core/allocator_access.hpp
+++ b/include/boost/core/allocator_access.hpp
@@ -9,16 +9,34 @@ Distributed under the Boost Software License, Version 1.0.
 #define BOOST_CORE_ALLOCATOR_ACCESS_HPP

 #include <boost/config.hpp>
-#if !defined(BOOST_NO_CXX11_ALLOCATOR)
 #include <boost/core/pointer_traits.hpp>
 #include <limits>
+#include <new>
+#if !defined(BOOST_NO_CXX11_ALLOCATOR)
 #include <type_traits>
 #endif
-#include <new>
 #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
 #include <utility>
 #endif

+#if defined(BOOST_GCC_VERSION) && (BOOST_GCC_VERSION >= 40300)
+#define BOOST_DETAIL_ALLOC_EMPTY(T) __is_empty(T)
+#elif defined(BOOST_INTEL) && defined(_MSC_VER) && (_MSC_VER >= 1500)
+#define BOOST_DETAIL_ALLOC_EMPTY(T) __is_empty(T)
+#elif defined(BOOST_MSVC) && (BOOST_MSVC >= 1400)
+#define BOOST_DETAIL_ALLOC_EMPTY(T) __is_empty(T)
+#elif defined(BOOST_CLANG) && !defined(__CUDACC__)
+#if __has_feature(is_empty)
+#define BOOST_DETAIL_ALLOC_EMPTY(T) __is_empty(T)
+#endif
+#elif defined(__SUNPRO_CC) && (__SUNPRO_CC >= 0x5130)
+#define BOOST_DETAIL_ALLOC_EMPTY(T) __oracle_is_empty(T)
+#elif defined(__ghs__) && (__GHS_VERSION_NUMBER >= 600)
+#define BOOST_DETAIL_ALLOC_EMPTY(T) __is_empty(T)
+#elif defined(BOOST_CODEGEARC)
+#define BOOST_DETAIL_ALLOC_EMPTY(T) __is_empty(T)
+#endif
+
 #if defined(_LIBCPP_SUPPRESS_DEPRECATED_PUSH)
 _LIBCPP_SUPPRESS_DEPRECATED_PUSH
 #endif
@@ -37,244 +55,311 @@ 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;
-};
-#else
-template<class A, class = void>
-struct allocator_pointer {
-    typedef typename A::value_type* type;
-};
-
 namespace detail {

+template<class A, class = void>
+struct alloc_ptr {
+    typedef typename boost::allocator_value_type<A>::type* type;
+};
+
 template<class>
 struct alloc_void {
    typedef void type;
 };

-} /* detail */
-
 template<class A>
-struct allocator_pointer<A,
-    typename detail::alloc_void<typename A::pointer>::type> {
+struct alloc_ptr<A,
+    typename 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;
-};
-#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;
-};
+} /* detail */

 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;
+struct allocator_pointer {
+    typedef typename detail::alloc_ptr<A>::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;
-};
-#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;
-};
-#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)
 namespace detail {

-struct alloc_false {
-    BOOST_STATIC_CONSTEXPR bool value = false;
+template<class A, class = void>
+struct alloc_const_ptr {
+    typedef typename boost::pointer_traits<typename
+        boost::allocator_pointer<A>::type>::template rebind_to<const typename
+            boost::allocator_value_type<A>::type>::type type;
+};
+
+template<class A>
+struct alloc_const_ptr<A,
+    typename alloc_void<typename A::const_pointer>::type> {
+    typedef typename A::const_pointer type;
 };

 } /* detail */

 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;
+struct allocator_const_pointer {
+    typedef typename detail::alloc_const_ptr<A>::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;
-};
-#else
 namespace detail {

 template<class, class>
 struct alloc_to { };

+#if defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+template<template<class> class A, class T, class U>
+struct alloc_to<A<U>, T> {
+    typedef A<T> type;
+};
+
+template<template<class, class> class A, class T, class U, class V>
+struct alloc_to<A<U, V>, T> {
+    typedef A<T, V> type;
+};
+
+template<template<class, class, class> class A, class T, class U, class V1,
+    class V2>
+struct alloc_to<A<U, V1, V2>, T> {
+    typedef A<T, V1, V2> type;
+};
+#else
 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 */
+#endif

 template<class A, class T, class = void>
-struct allocator_rebind {
-    typedef typename detail::alloc_to<A, T>::type type;
+struct alloc_rebind {
+    typedef typename 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> {
+struct alloc_rebind<A, T,
+    typename alloc_void<typename A::template rebind<T>::other>::type> {
    typedef typename A::template rebind<T>::other type;
 };
+
+} /* detail */
+
+template<class A, class T>
+struct allocator_rebind {
+    typedef typename detail::alloc_rebind<A, T>::type type;
+};
+
+namespace detail {
+
+template<class A, class = void>
+struct alloc_void_ptr {
+     typedef typename boost::pointer_traits<typename
+        boost::allocator_pointer<A>::type>::template
+            rebind_to<void>::type type;
+};
+
+template<class A>
+struct alloc_void_ptr<A,
+    typename alloc_void<typename A::void_pointer>::type> {
+    typedef typename A::void_pointer type;
+};
+
+} /* detail */
+
+template<class A>
+struct allocator_void_pointer {
+    typedef typename detail::alloc_void_ptr<A>::type type;
+};
+
+namespace detail {
+
+template<class A, class = void>
+struct alloc_const_void_ptr {
+     typedef typename boost::pointer_traits<typename
+        boost::allocator_pointer<A>::type>::template
+            rebind_to<const void>::type type;
+};
+
+template<class A>
+struct alloc_const_void_ptr<A,
+    typename alloc_void<typename A::const_void_pointer>::type> {
+    typedef typename A::const_void_pointer type;
+};
+
+} /* detail */
+
+template<class A>
+struct allocator_const_void_pointer {
+    typedef typename detail::alloc_const_void_ptr<A>::type type;
+};
+
+namespace detail {
+
+template<class A, class = void>
+struct alloc_diff_type {
+    typedef typename boost::pointer_traits<typename
+        boost::allocator_pointer<A>::type>::difference_type type;
+};
+
+template<class A>
+struct alloc_diff_type<A,
+    typename alloc_void<typename A::difference_type>::type> {
+    typedef typename A::difference_type type;
+};
+
+} /* detail */
+
+template<class A>
+struct allocator_difference_type {
+    typedef typename detail::alloc_diff_type<A>::type type;
+};
+
+namespace detail {
+
+#if defined(BOOST_NO_CXX11_ALLOCATOR)
+template<class A, class = void>
+struct alloc_size_type {
+    typedef std::size_t type;
+};
+#else
+template<class A, class = void>
+struct alloc_size_type {
+    typedef typename std::make_unsigned<typename
+        boost::allocator_difference_type<A>::type>::type type;
+};
 #endif

+template<class A>
+struct alloc_size_type<A,
+    typename alloc_void<typename A::size_type>::type> {
+    typedef typename A::size_type type;
+};
+
+} /* detail */
+
+template<class A>
+struct allocator_size_type {
+    typedef typename detail::alloc_size_type<A>::type type;
+};
+
+namespace detail {
+
+#if defined(BOOST_NO_CXX11_ALLOCATOR)
+template<bool V>
+struct alloc_bool {
+    typedef bool value_type;
+    typedef alloc_bool type;
+
+    static const bool value = V;
+
+    operator bool() const BOOST_NOEXCEPT {
+        return V;
+    }
+
+    bool operator()() const BOOST_NOEXCEPT {
+        return V;
+    }
+};
+
+template<bool V>
+const bool alloc_bool<V>::value;
+
+typedef alloc_bool<false> alloc_false;
+#else
+typedef std::false_type alloc_false;
+#endif
+
+template<class A, class = void>
+struct alloc_pocca {
+    typedef alloc_false type;
+};
+
+template<class A>
+struct alloc_pocca<A,
+    typename alloc_void<typename
+        A::propagate_on_container_copy_assignment>::type> {
+    typedef typename A::propagate_on_container_copy_assignment type;
+};
+
+} /* detail */
+
+template<class A, class = void>
+struct allocator_propagate_on_container_copy_assignment {
+    typedef typename detail::alloc_pocca<A>::type type;
+};
+
+namespace detail {
+
+template<class A, class = void>
+struct alloc_pocma {
+    typedef alloc_false type;
+};
+
+template<class A>
+struct alloc_pocma<A,
+    typename alloc_void<typename
+        A::propagate_on_container_move_assignment>::type> {
+    typedef typename A::propagate_on_container_move_assignment type;
+};
+
+} /* detail */
+
+template<class A>
+struct allocator_propagate_on_container_move_assignment {
+    typedef typename detail::alloc_pocma<A>::type type;
+};
+
+namespace detail {
+
+template<class A, class = void>
+struct alloc_pocs {
+    typedef alloc_false type;
+};
+
+template<class A>
+struct alloc_pocs<A,
+    typename alloc_void<typename A::propagate_on_container_swap>::type> {
+    typedef typename A::propagate_on_container_swap type;
+};
+
+} /* detail */
+
+template<class A>
+struct allocator_propagate_on_container_swap {
+    typedef typename detail::alloc_pocs<A>::type type;
+};
+
+namespace detail {
+
+#if !defined(BOOST_NO_CXX11_ALLOCATOR)
+template<class A, class = void>
+struct alloc_equal {
+    typedef typename std::is_empty<A>::type type;
+};
+#elif defined(BOOST_DETAIL_ALLOC_EMPTY)
+template<class A, class = void>
+struct alloc_equal {
+    typedef alloc_bool<BOOST_DETAIL_ALLOC_EMPTY(A)> type;
+};
+#else
+template<class A, class = void>
+struct alloc_equal {
+    typedef alloc_false type;
+};
+#endif
+
+template<class A>
+struct alloc_equal<A,
+    typename alloc_void<typename A::is_always_equal>::type> {
+    typedef typename A::is_always_equal type;
+};
+
+} /* detail */
+
+template<class A>
+struct allocator_is_always_equal {
+    typedef typename detail::alloc_equal<A>::type type;
+};
+
 template<class A>
 inline typename allocator_pointer<A>::type
 allocator_allocate(A& a, typename allocator_size_type<A>::type n)
@@ -301,21 +386,24 @@ allocator_allocate(A& a, typename allocator_size_type<A>::type n,
 #else
 namespace detail {

-struct alloc_none { };
+template<class>
+struct alloc_no {
+    char x, y;
+};

 template<class A>
 class alloc_has_allocate {
    template<class O>
-    static auto check(int) -> decltype(std::declval<O&>().allocate(
-        std::declval<typename allocator_size_type<A>::type>(),
-        std::declval<typename allocator_const_void_pointer<A>::type>()));
+    static auto check(int)
+    -> alloc_no<decltype(std::declval<O&>().allocate(std::declval<typename
+        boost::allocator_size_type<A>::type>(), std::declval<typename
+            boost::allocator_const_void_pointer<A>::type>()))>;

    template<class>
-    static alloc_none check(long);
+    static char check(long);

 public:
-    BOOST_STATIC_CONSTEXPR bool value =
-        !std::is_same<decltype(check<A>(0)), alloc_none>::value;
+    BOOST_STATIC_CONSTEXPR bool value = sizeof(check<A>(0)) > 1;
 };

 } /* detail */
@@ -385,15 +473,14 @@ template<class A, class T, class... Args>
 class alloc_has_construct {
    template<class O>
    static auto check(int)
-    -> decltype(std::declval<O&>().construct(std::declval<T*>(),
-        std::declval<Args&&>()...));
+    -> alloc_no<decltype(std::declval<O&>().construct(std::declval<T*>(),
+        std::declval<Args&&>()...))>;

    template<class>
-    static alloc_none check(long);
+    static char check(long);

 public:
-    BOOST_STATIC_CONSTEXPR bool value =
-        !std::is_same<decltype(check<A>(0)), alloc_none>::value;
+    BOOST_STATIC_CONSTEXPR bool value = sizeof(check<A>(0)) > 1;
 };

 } /* detail */
@@ -430,14 +517,13 @@ template<class A, class T>
 class alloc_has_destroy {
    template<class O>
    static auto check(int)
-    -> decltype(std::declval<O&>().destroy(std::declval<T*>()));
+    -> alloc_no<decltype(std::declval<O&>().destroy(std::declval<T*>()))>;

    template<class>
-    static alloc_none check(long);
+    static char check(long);

 public:
-    BOOST_STATIC_CONSTEXPR bool value =
-        !std::is_same<decltype(check<A>(0)), alloc_none>::value;
+    BOOST_STATIC_CONSTEXPR bool value = sizeof(check<A>(0)) > 1;
 };

 } /* detail */
@@ -458,89 +544,130 @@ allocator_destroy(A&, T* 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();
-}
-#else
 namespace detail {

+#if defined(BOOST_NO_CXX11_ALLOCATOR)
+template<class T, T>
+struct alloc_no {
+    char x, y;
+};
+
 template<class A>
 class alloc_has_max_size {
    template<class O>
-    static auto check(int) -> decltype(std::declval<O&>().max_size());
+    static alloc_no<typename boost::allocator_size_type<O>::type(O::*)(),
+        &O::max_size> check(int);
+
+    template<class O>
+    static alloc_no<typename boost::allocator_size_type<O>::type(O::*)() const,
+        &O::max_size> check(int);
+
+    template<class O>
+    static alloc_no<typename boost::allocator_size_type<O>::type(*)(),
+        &O::max_size> check(int);

    template<class>
-    static alloc_none check(long);
+    static char check(long);

 public:
-    BOOST_STATIC_CONSTEXPR bool value =
-        !std::is_same<decltype(check<A>(0)), alloc_none>::value;
+    BOOST_STATIC_CONSTEXPR bool value = sizeof(check<A>(0)) > 1;
+};
+#else
+template<class A>
+class alloc_has_max_size {
+    template<class O>
+    static auto check(int)
+    -> alloc_no<decltype(std::declval<const O&>().max_size())>;
+
+    template<class>
+    static char check(long);
+
+public:
+    BOOST_STATIC_CONSTEXPR bool value = sizeof(check<A>(0)) > 1;
+};
+#endif
+
+template<bool, class>
+struct alloc_if { };
+
+template<class T>
+struct alloc_if<true, T> {
+    typedef T type;
 };

 } /* detail */

 template<class A>
-inline typename std::enable_if<detail::alloc_has_max_size<A>::value,
+inline typename detail::alloc_if<detail::alloc_has_max_size<A>::value,
    typename allocator_size_type<A>::type>::type
-allocator_max_size(const A& a)
+allocator_max_size(const A& a) BOOST_NOEXCEPT
 {
    return a.max_size();
 }

 template<class A>
-inline typename std::enable_if<!detail::alloc_has_max_size<A>::value,
+inline typename detail::alloc_if<!detail::alloc_has_max_size<A>::value,
    typename allocator_size_type<A>::type>::type
-allocator_max_size(const A&)
+allocator_max_size(const A&) BOOST_NOEXCEPT
 {
    return (std::numeric_limits<typename
-        allocator_size_type<A>::type>::max)() / sizeof(typename A::value_type);
+        allocator_size_type<A>::type>::max)() /
+            sizeof(typename allocator_value_type<A>::type);
 }
-#endif
+
+namespace detail {

 #if defined(BOOST_NO_CXX11_ALLOCATOR)
 template<class A>
-inline A
-allocator_select_on_container_copy_construction(const A& a)
-{
-    return a;
-}
-#else
-namespace detail {
+class alloc_has_soccc {
+    template<class O>
+    static alloc_no<O(O::*)(), &O::select_on_container_copy_construction>
+    check(int);

+    template<class O>
+    static alloc_no<O(O::*)() const, &O::select_on_container_copy_construction>
+    check(int);
+
+    template<class O>
+    static alloc_no<O(*)(), &O::select_on_container_copy_construction>
+    check(int);
+
+    template<class>
+    static char check(long);
+
+public:
+    BOOST_STATIC_CONSTEXPR bool value = sizeof(check<A>(0)) > 1;
+};
+#else
 template<class A>
 class alloc_has_soccc {
    template<class O>
-    static auto check(int)
-    -> decltype(std::declval<O&>().select_on_container_copy_construction());
+    static auto check(int) -> alloc_no<decltype(std::declval<const
+        O&>().select_on_container_copy_construction())>;

    template<class>
-    static alloc_none check(long);
+    static char check(long);

 public:
-    BOOST_STATIC_CONSTEXPR bool value =
-        !std::is_same<decltype(check<A>(0)), alloc_none>::value;
+    BOOST_STATIC_CONSTEXPR bool value = sizeof(check<A>(0)) > 1;
 };
+#endif

 } /* detail */

 template<class A>
-inline typename std::enable_if<detail::alloc_has_soccc<A>::value, A>::type
+inline typename detail::alloc_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
+inline typename detail::alloc_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>
--- a/include/boost/core/allocator_traits.hpp
+++ b/include/boost/core/allocator_traits.hpp
@@ -0,0 +1,112 @@
+/*
+Copyright 2021 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_TRAITS_HPP
+#define BOOST_CORE_ALLOCATOR_TRAITS_HPP
+
+#include <boost/core/allocator_access.hpp>
+
+namespace boost {
+
+template<class A>
+struct allocator_traits {
+    typedef A allocator_type;
+
+    typedef typename allocator_value_type<A>::type value_type;
+
+    typedef typename allocator_pointer<A>::type pointer;
+
+    typedef typename allocator_const_pointer<A>::type const_pointer;
+
+    typedef typename allocator_void_pointer<A>::type void_pointer;
+
+    typedef typename allocator_const_void_pointer<A>::type const_void_pointer;
+
+    typedef typename allocator_difference_type<A>::type difference_type;
+
+    typedef typename allocator_size_type<A>::type size_type;
+
+    typedef typename allocator_propagate_on_container_copy_assignment<A>::type
+        propagate_on_container_copy_assignment;
+
+    typedef typename allocator_propagate_on_container_move_assignment<A>::type
+        propagate_on_container_move_assignment;
+
+    typedef typename allocator_propagate_on_container_swap<A>::type
+        propagate_on_container_swap;
+
+    typedef typename allocator_is_always_equal<A>::type is_always_equal;
+
+#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+    template<class T>
+    using rebind_traits = allocator_traits<typename
+        allocator_rebind<A, T>::type>;
+#else
+    template<class T>
+    struct rebind_traits
+        : allocator_traits<typename allocator_rebind<A, T>::type> { };
+#endif
+
+    static pointer allocate(A& a, size_type n) {
+        return boost::allocator_allocate(a, n);
+    }
+
+    static pointer allocate(A& a, size_type n, const_void_pointer h) {
+        return boost::allocator_allocate(a, n, h);
+    }
+
+    static void deallocate(A& a, pointer p, size_type n) {
+        return boost::allocator_deallocate(a, p, n);
+    }
+
+    template<class T>
+    static void 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 T, class V, class... Args>
+    static void construct(A& a, T* p, V&& v, Args&&... args) {
+        boost::allocator_construct(a, p, std::forward<V>(v),
+            std::forward<Args>(args)...);
+    }
+#else
+    template<class T, class V>
+    static void construct(A& a, T* p, V&& v) {
+        boost::allocator_construct(a, p, std::forward<V>(v));
+    }
+#endif
+#else
+    template<class T, class V>
+    static void construct(A& a, T* p, const V& v) {
+        boost::allocator_construct(a, p, v);
+    }
+
+    template<class T, class V>
+    static void construct(A& a, T* p, V& v) {
+        boost::allocator_construct(a, p, v);
+    }
+#endif
+
+    template<class T>
+    static void destroy(A& a, T* p) {
+        boost::allocator_destroy(a, p);
+    }
+
+    static size_type max_size(const A& a) BOOST_NOEXCEPT {
+        return boost::allocator_max_size(a);
+    }
+
+    static A select_on_container_copy_construction(const A& a) {
+        return boost::allocator_select_on_container_copy_construction(a);
+    }
+};
+
+} /* boost */
+
+#endif
--- a/include/boost/core/bit.hpp
+++ b/include/boost/core/bit.hpp
@@ -82,9 +82,9 @@ BOOST_CONSTEXPR inline int countl_impl( unsigned long x ) BOOST_NOEXCEPT
    return x? __builtin_clzl( x ): std::numeric_limits<unsigned long>::digits;
 }

-BOOST_CONSTEXPR inline int countl_impl( unsigned long long x ) BOOST_NOEXCEPT
+BOOST_CONSTEXPR inline int countl_impl( boost::ulong_long_type x ) BOOST_NOEXCEPT
 {
-    return x? __builtin_clzll( x ): std::numeric_limits<unsigned long long>::digits;
+    return x? __builtin_clzll( x ): std::numeric_limits<boost::ulong_long_type>::digits;
 }

 } // namespace detail
@@ -224,9 +224,9 @@ BOOST_CONSTEXPR inline int countr_impl( unsigned long x ) BOOST_NOEXCEPT
    return x? __builtin_ctzl( x ): std::numeric_limits<unsigned long>::digits;
 }

-BOOST_CONSTEXPR inline int countr_impl( unsigned long long x ) BOOST_NOEXCEPT
+BOOST_CONSTEXPR inline int countr_impl( boost::ulong_long_type x ) BOOST_NOEXCEPT
 {
-    return x? __builtin_ctzll( x ): std::numeric_limits<unsigned long long>::digits;
+    return x? __builtin_ctzll( x ): std::numeric_limits<boost::ulong_long_type>::digits;
 }

 } // namespace detail
@@ -365,7 +365,7 @@ BOOST_CORE_POPCOUNT_CONSTEXPR inline int popcount_impl( unsigned long x ) BOOST_
    return __builtin_popcountl( x );
 }

-BOOST_CORE_POPCOUNT_CONSTEXPR inline int popcount_impl( unsigned long long x ) BOOST_NOEXCEPT
+BOOST_CORE_POPCOUNT_CONSTEXPR inline int popcount_impl( boost::ulong_long_type x ) BOOST_NOEXCEPT
 {
    return __builtin_popcountll( x );
 }
@@ -446,10 +446,13 @@ BOOST_CONSTEXPR bool has_single_bit( T x ) BOOST_NOEXCEPT
    return x != 0 && ( x & ( x - 1 ) ) == 0;
 }

+// bit_width should return int, https://cplusplus.github.io/LWG/issue3656
+
 template<class T>
 BOOST_CONSTEXPR T bit_width( T x ) BOOST_NOEXCEPT
 {
-    return std::numeric_limits<T>::digits - boost::core::countl_zero( x );
+    return static_cast<T>(
+        std::numeric_limits<T>::digits - boost::core::countl_zero( x ) );
 }

 template<class T>
--- a/include/boost/core/default_allocator.hpp
+++ b/include/boost/core/default_allocator.hpp
@@ -19,21 +19,25 @@ BOOST_NORETURN void throw_exception(const std::exception&);

 namespace default_ {

-struct true_type {
+template<bool V>
+struct bool_constant {
    typedef bool value_type;
-    typedef true_type type;
+    typedef bool_constant type;

-    BOOST_STATIC_CONSTANT(bool, value = true);
+    static const bool value = V;

-    BOOST_CONSTEXPR operator bool() const BOOST_NOEXCEPT {
-        return true;
+    operator bool() const BOOST_NOEXCEPT {
+        return V;
    }

-    BOOST_CONSTEXPR bool operator()() const BOOST_NOEXCEPT {
-        return true;
+    bool operator()() const BOOST_NOEXCEPT {
+        return V;
    }
 };

+template<bool V>
+const bool bool_constant<V>::value;
+
 template<class T>
 struct add_reference {
    typedef T& type;
@@ -58,8 +62,8 @@ struct default_allocator {
    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;
+    typedef bool_constant<true> propagate_on_container_move_assignment;
+    typedef bool_constant<true> is_always_equal;

    template<class U>
    struct rebind {
@@ -108,6 +112,12 @@ struct default_allocator {
    }
 #endif

+#if defined(BOOST_NO_CXX11_ALLOCATOR)
+    T* allocate(std::size_t n, const void*) {
+        return allocate(n);
+    }
+#endif
+
 #if (defined(BOOST_LIBSTDCXX_VERSION) && BOOST_LIBSTDCXX_VERSION < 60000) || \
    defined(BOOST_NO_CXX11_ALLOCATOR)
    template<class U, class V>
--- a/include/boost/core/detail/splitmix64.hpp
+++ b/include/boost/core/detail/splitmix64.hpp
@@ -34,14 +34,14 @@ public:

    boost::uint64_t operator()()
    {
-        x_ += 0x9e3779b97f4a7c15;
+        x_ += ( boost::uint64_t(0x9e3779b9u) << 32 ) + 0x7f4a7c15u;

        boost::uint64_t z = x_;

        z ^= z >> 30;
-        z *= 0xbf58476d1ce4e5b9;
+        z *= ( boost::uint64_t(0xbf58476du) << 32 ) + 0x1ce4e5b9u;
        z ^= z >> 27;
-        z *= 0x94d049bb133111eb;
+        z *= ( boost::uint64_t(0x94d049bbu) << 32 ) + 0x133111ebu;
        z ^= z >> 31;

        return z;
--- a/include/boost/core/detail/string_view.hpp
+++ b/include/boost/core/detail/string_view.hpp
@@ -31,9 +31,15 @@
 #if !defined(BOOST_NO_CXX17_HDR_STRING_VIEW)
 # include <string_view>
 #endif
+#if !defined(BOOST_NO_CXX20_HDR_CONCEPTS) // std::common_reference_with
+# include <type_traits>
+#endif

 namespace boost
 {
+
+template<class Ch, class Tr> class basic_string_view;
+
 namespace core
 {
 namespace detail
@@ -388,6 +394,11 @@ public:

 #endif

+    template<class Ch2> basic_string_view( boost::basic_string_view<Ch2, std::char_traits<Ch2> > const& str,
+        typename boost::enable_if<is_same<Ch, Ch2> >::type* = 0 ) BOOST_NOEXCEPT: p_( str.data() ), n_( str.size() )
+    {
+    }
+
    // BOOST_CONSTEXPR basic_string_view& operator=( basic_string_view const& ) BOOST_NOEXCEPT & = default;

    // conversions
@@ -407,6 +418,12 @@ public:

 #endif

+    template<class Ch2> operator boost::basic_string_view<Ch2,
+        typename boost::enable_if<boost::core::is_same<Ch2, Ch>, std::char_traits<Ch> >::type> () const BOOST_NOEXCEPT
+    {
+        return boost::basic_string_view< Ch, std::char_traits<Ch> >( data(), size() );
+    }
+
    // iterator support

    BOOST_CONSTEXPR const_iterator begin() const BOOST_NOEXCEPT
@@ -538,7 +555,7 @@ public:
            boost::throw_exception( std::out_of_range( "basic_string_view::copy" ), BOOST_CURRENT_LOCATION );
        }

-        std::size_t rlen = std::min( n, size() - pos );
+        std::size_t rlen = (std::min)( n, size() - pos );

        traits_type::copy( s, data() + pos, rlen );

@@ -552,7 +569,7 @@ public:
            boost::throw_exception( std::out_of_range( "basic_string_view::substr" ), BOOST_CURRENT_LOCATION );
        }

-        std::size_t rlen = std::min( n, size() - pos );
+        std::size_t rlen = (std::min)( n, size() - pos );

        return basic_string_view( data() + pos, rlen );
    }
@@ -561,7 +578,7 @@ public:

    BOOST_CXX14_CONSTEXPR int compare( basic_string_view str ) const BOOST_NOEXCEPT
    {
-        std::size_t rlen = std::min( size(), str.size() );
+        std::size_t rlen = (std::min)( size(), str.size() );

        int cmp = traits_type::compare( data(), str.data(), rlen );

@@ -1202,4 +1219,29 @@ typedef basic_string_view<char8_t> u8string_view;
 } // namespace core
 } // namespace boost

+// std::common_reference support
+// needed for iterators that have reference=string_view and value_type=std::string
+
+#if !defined(BOOST_NO_CXX20_HDR_CONCEPTS)
+
+template<class Ch, class A, template<class> class Q1, template<class> class Q2>
+struct std::basic_common_reference<
+    boost::core::basic_string_view<Ch>,
+    std::basic_string<Ch, std::char_traits<Ch>, A>,
+    Q1, Q2>
+{
+    using type = boost::core::basic_string_view<Ch>;
+};
+
+template<class Ch, class A, template<class> class Q1, template<class> class Q2>
+struct std::basic_common_reference<
+    std::basic_string<Ch, std::char_traits<Ch>, A>,
+    boost::core::basic_string_view<Ch>,
+    Q1, Q2>
+{
+    using type = boost::core::basic_string_view<Ch>;
+};
+
+#endif
+
 #endif  // #ifndef BOOST_CORE_STRING_VIEW_HPP_INCLUDED
--- a/include/boost/core/pointer_traits.hpp
+++ b/include/boost/core/pointer_traits.hpp
@@ -1,5 +1,5 @@
 /*
-Copyright 2017-2018 Glen Joseph Fernandes
+Copyright 2017-2021 Glen Joseph Fernandes
 (glenjofe@gmail.com)

 Distributed under the Boost Software License, Version 1.0.
@@ -9,43 +9,23 @@ Distributed under the Boost Software License, Version 1.0.
 #define BOOST_CORE_POINTER_TRAITS_HPP

 #include <boost/config.hpp>
-#if !defined(BOOST_NO_CXX11_POINTER_TRAITS)
-#include <memory>
-#else
 #include <boost/core/addressof.hpp>
 #include <cstddef>
-#endif

 namespace boost {
-
-#if !defined(BOOST_NO_CXX11_POINTER_TRAITS)
-template<class T>
-struct pointer_traits
-    : std::pointer_traits<T> {
-    template<class U>
-    struct rebind_to {
-        typedef typename std::pointer_traits<T>::template rebind<U> type;
-    };
-};
-
-template<class T>
-struct pointer_traits<T*>
-    : std::pointer_traits<T*> {
-    template<class U>
-    struct rebind_to {
-        typedef U* type;
-    };
-};
-#else
 namespace detail {

+struct ptr_none { };
+
 template<class>
-struct ptr_void {
+struct ptr_valid {
    typedef void type;
 };

-template<class T>
-struct ptr_first;
+template<class>
+struct ptr_first {
+    typedef ptr_none type;
+};

 #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
 template<template<class, class...> class T, class U, class... Args>
@@ -75,7 +55,7 @@ struct ptr_element {
 };

 template<class T>
-struct ptr_element<T, typename ptr_void<typename T::element_type>::type> {
+struct ptr_element<T, typename ptr_valid<typename T::element_type>::type> {
    typedef typename T::element_type type;
 };

@@ -86,12 +66,12 @@ struct ptr_difference {

 template<class T>
 struct ptr_difference<T,
-    typename ptr_void<typename T::difference_type>::type> {
+    typename ptr_valid<typename T::difference_type>::type> {
    typedef typename T::difference_type type;
 };

-template<class T, class V>
-struct ptr_transform;
+template<class, class>
+struct ptr_transform { };

 #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
 template<template<class, class...> class T, class U, class... Args, class V>
@@ -117,68 +97,131 @@ struct ptr_transform<T<U1, U2, U3>, V> {
 #endif

 template<class T, class U, class = void>
-struct ptr_rebind {
-    typedef typename ptr_transform<T, U>::type type;
-};
+struct ptr_rebind
+    : ptr_transform<T, U> { };

-#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> {
+    typename ptr_valid<typename T::template rebind<U> >::type> {
    typedef typename T::template rebind<U> type;
 };
+
+#if !defined(BOOST_NO_CXX11_DECLTYPE_N3276)
+template<class T, class E>
+class ptr_to_expr {
+    template<class>
+    struct result {
+        char x, y;
+    };
+
+    static E& source();
+
+    template<class O>
+    static auto check(int) -> result<decltype(O::pointer_to(source()))>;
+
+    template<class>
+    static char check(long);
+
+public:
+    BOOST_STATIC_CONSTEXPR bool value = sizeof(check<T>(0)) > 1;
+};
+
+template<class T, class E>
+struct ptr_to_expr<T*, E> {
+    BOOST_STATIC_CONSTEXPR bool value = true;
+};
+
+template<class T, class E>
+struct ptr_has_to {
+    BOOST_STATIC_CONSTEXPR bool value = ptr_to_expr<T, E>::value;
+};
+#else
+template<class, class>
+struct ptr_has_to {
+    BOOST_STATIC_CONSTEXPR bool value = true;
+};
 #endif

 template<class T>
-struct ptr_value {
-    typedef T type;
+struct ptr_has_to<T, void> {
+    BOOST_STATIC_CONSTEXPR bool value = false;
 };

-template<>
-struct ptr_value<void> {
-    typedef struct { } type;
+template<class T>
+struct ptr_has_to<T, const void> {
+    BOOST_STATIC_CONSTEXPR bool value = false;
 };

+template<class T>
+struct ptr_has_to<T, volatile void> {
+    BOOST_STATIC_CONSTEXPR bool value = false;
+};
+
+template<class T>
+struct ptr_has_to<T, const volatile void> {
+    BOOST_STATIC_CONSTEXPR bool value = false;
+};
+
+template<class T, class E, bool = ptr_has_to<T, E>::value>
+struct ptr_to { };
+
+template<class T, class E>
+struct ptr_to<T, E, true> {
+    static T pointer_to(E& v) {
+        return T::pointer_to(v);
+    }
+};
+
+template<class T>
+struct ptr_to<T*, T, true> {
+    static T* pointer_to(T& v) BOOST_NOEXCEPT {
+        return boost::addressof(v);
+    }
+};
+
+template<class T, class E>
+struct ptr_traits
+    : ptr_to<T, E> {
+    typedef T pointer;
+    typedef E element_type;
+    typedef typename ptr_difference<T>::type difference_type;
+
+    template<class U>
+    struct rebind_to
+        : ptr_rebind<T, U> { };
+
+#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+    template<class U>
+    using rebind = typename rebind_to<U>::type;
+#endif
+};
+
+template<class T>
+struct ptr_traits<T, ptr_none> { };
+
 } /* detail */

 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;
-    template<class U>
-    struct rebind_to {
-        typedef typename detail::ptr_rebind<T, U>::type type;
-    };
-#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
-    template<class U>
-    using rebind = typename detail::ptr_rebind<T, U>::type;
-#endif
-    static pointer
-    pointer_to(typename detail::ptr_value<element_type>::type& v) {
-        return pointer::pointer_to(v);
-    }
-};
+struct pointer_traits
+    : detail::ptr_traits<T, typename detail::ptr_element<T>::type> { };

 template<class T>
-struct pointer_traits<T*> {
+struct pointer_traits<T*>
+    : detail::ptr_to<T*, T> {
    typedef T* pointer;
    typedef T element_type;
    typedef std::ptrdiff_t difference_type;
+
    template<class U>
    struct rebind_to {
        typedef U* type;
    };
+
 #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
    template<class U>
-    using rebind = U*;
+    using rebind = typename rebind_to<U>::type*;
 #endif
-    static T*
-    pointer_to(typename detail::ptr_value<T>::type& v) BOOST_NOEXCEPT {
-        return boost::addressof(v);
-    }
 };
-#endif

 template<class T>
 BOOST_CONSTEXPR inline T*
--- a/include/boost/core/quick_exit.hpp
+++ b/include/boost/core/quick_exit.hpp
@@ -33,7 +33,7 @@ extern "C" _Noreturn void quick_exit(int);
 namespace boost
 {

-BOOST_NORETURN void quick_exit( int code ) BOOST_NOEXCEPT
+BOOST_NORETURN inline void quick_exit( int code ) BOOST_NOEXCEPT
 {
 #if defined(_MSC_VER) && _MSC_VER < 1900

--- a/include/boost/iterator.hpp
+++ b/include/boost/iterator.hpp
@@ -5,7 +5,9 @@
 #ifndef BOOST_ITERATOR_HPP
 #define BOOST_ITERATOR_HPP

-// This header is obsolete and will be deprecated.
+#include <boost/config/header_deprecated.hpp>
+
+BOOST_HEADER_DEPRECATED("<iterator>")

 #include <iterator>
 #include <cstddef>           // std::ptrdiff_t
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright 2018, 2019, 2021 Peter Dimov
+# Copyright 2018-2021 Peter Dimov
 # Distributed under the Boost Software License, Version 1.0.
 # See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt

@@ -23,6 +23,10 @@ set(BOOST_TEST_LINK_LIBRARIES Boost::core Boost::throw_exception)

 boost_test(TYPE run SOURCES no_exceptions_support_test.cpp)

+set(BOOST_TEST_LINK_LIBRARIES Boost::core Boost::utility)
+
+boost_test(TYPE run SOURCES sv_conversion_test2.cpp)
+
 endif()

 add_subdirectory(swap)
--- a/test/Jamfile.v2
+++ b/test/Jamfile.v2
@@ -189,6 +189,9 @@ 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 pointer_traits_sfinae_test.cpp ;
+run pointer_traits_rebind_sfinae_test.cpp ;
+run pointer_traits_pointer_to_sfinae_test.cpp ;
 run to_address_test.cpp ;

 run exchange_test.cpp ;
@@ -211,6 +214,7 @@ run default_allocator_test.cpp
        <toolset>msvc:<warnings-as-errors>on
        <toolset>gcc:<warnings-as-errors>on
        <toolset>clang:<warnings-as-errors>on ;
+run default_allocator_allocate_hint_test.cpp ;

 run noinit_adaptor_test.cpp ;
 run alloc_construct_test.cpp ;
@@ -236,6 +240,7 @@ run allocator_allocate_hint_test.cpp ;
 run allocator_deallocate_test.cpp ;
 run allocator_max_size_test.cpp ;
 run allocator_soccc_test.cpp ;
+run allocator_traits_test.cpp ;

 lib lib_typeid : lib_typeid.cpp : <link>shared:<define>LIB_TYPEID_DYN_LINK=1 ;

@@ -259,19 +264,30 @@ run uncaught_exceptions_np.cpp
 run no_exceptions_support_test.cpp : ;
 run no_exceptions_support_test.cpp : : : <exception-handling>off : no_exceptions_support_test_nx ;

-run cmath_test.cpp ;
+run cmath_test.cpp
+  : : : $(pedantic-errors) ;
 run cmath_test.cpp : : : <define>BOOST_CORE_USE_GENERIC_CMATH <toolset>msvc-8.0:<build>no : cmath_test_generic ;

-run bit_cast_test.cpp ;
-run bit_rotate_test.cpp ;
-run bit_countr_test.cpp ;
-run bit_countl_test.cpp ;
-run bit_width_test.cpp ;
-run has_single_bit_test.cpp ;
-run bit_floor_test.cpp ;
-run bit_ceil_test.cpp ;
-run bit_popcount_test.cpp ;
-run bit_endian_test.cpp ;
+run bit_cast_test.cpp
+  : : : $(pedantic-errors) ;
+run bit_rotate_test.cpp
+  : : : $(pedantic-errors) ;
+run bit_countr_test.cpp
+  : : : $(pedantic-errors) ;
+run bit_countl_test.cpp
+  : : : $(pedantic-errors) ;
+run bit_width_test.cpp
+  : : : $(pedantic-errors) ;
+run has_single_bit_test.cpp
+  : : : $(pedantic-errors) ;
+run bit_floor_test.cpp
+  : : : $(pedantic-errors) ;
+run bit_ceil_test.cpp
+  : : : $(pedantic-errors) ;
+run bit_popcount_test.cpp
+  : : : $(pedantic-errors) ;
+run bit_endian_test.cpp
+  : : : $(pedantic-errors) ;

 run type_name_test.cpp ;

@@ -300,6 +316,10 @@ run sv_eq_test.cpp ;
 run sv_lt_test.cpp ;
 run sv_stream_insert_test.cpp ;
 run sv_conversion_test.cpp ;
+run sv_conversion_test2.cpp : ;
+run sv_common_reference_test.cpp ;
+compile sv_common_reference_test2.cpp ;
+compile sv_windows_h_test.cpp ;

 run span_test.cpp ;
 run span_types_test.cpp ;
@@ -308,5 +328,8 @@ run span_deduction_guide_test.cpp ;
 run as_bytes_test.cpp ;
 run as_writable_bytes_test.cpp ;

+run splitmix64_test.cpp
+  : : : $(pedantic-errors) ;
+
 use-project /boost/core/swap : ./swap ;
 build-project ./swap ;
--- a/test/allocator_const_pointer_test.cpp
+++ b/test/allocator_const_pointer_test.cpp
@@ -15,20 +15,16 @@ struct A1 {
    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();
 }
--- a/test/allocator_const_void_pointer_test.cpp
+++ b/test/allocator_const_void_pointer_test.cpp
@@ -20,20 +20,16 @@ struct A1 {
    };
 };

-#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();
 }
--- a/test/allocator_difference_type_test.cpp
+++ b/test/allocator_difference_type_test.cpp
@@ -15,20 +15,16 @@ struct A1 {
    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();
 }
--- a/test/allocator_is_always_equal_test.cpp
+++ b/test/allocator_is_always_equal_test.cpp
@@ -15,7 +15,6 @@ struct A1 {
    int value;
 };

-#if !defined(BOOST_NO_CXX11_ALLOCATOR)
 template<class T>
 struct A2 {
    typedef T value_type;
@@ -24,24 +23,25 @@ struct A2 {
 template<class T>
 struct A3 {
    typedef T value_type;
-    typedef std::false_type is_always_equal;
+    struct is_always_equal {
+        static const bool value = false;
+    };
 };

 template<class T>
 struct A4 {
    typedef T value_type;
-    typedef std::true_type is_always_equal;
+    struct is_always_equal {
+        static const bool value = true;
+    };
    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();
 }
--- a/test/allocator_max_size_test.cpp
+++ b/test/allocator_max_size_test.cpp
@@ -19,21 +19,17 @@ struct A1 {
    }
 };

-#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();
 }
--- a/test/allocator_pocca_test.cpp
+++ b/test/allocator_pocca_test.cpp
@@ -14,21 +14,19 @@ 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;
+    struct propagate_on_container_copy_assignment {
+        static const bool value = true;
+    };
 };
-#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();
 }
--- a/test/allocator_pocma_test.cpp
+++ b/test/allocator_pocma_test.cpp
@@ -14,21 +14,19 @@ 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;
+    struct propagate_on_container_move_assignment {
+        static const bool value = true;
+    };
 };
-#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();
 }
--- a/test/allocator_pocs_test.cpp
+++ b/test/allocator_pocs_test.cpp
@@ -14,21 +14,19 @@ 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;
+    struct propagate_on_container_swap {
+        static const bool value = true;
+    };
 };
-#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();
 }
--- a/test/allocator_pointer_test.cpp
+++ b/test/allocator_pointer_test.cpp
@@ -15,20 +15,16 @@ struct A1 {
    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();
 }
--- a/test/allocator_rebind_test.cpp
+++ b/test/allocator_rebind_test.cpp
@@ -18,20 +18,16 @@ struct A1 {
    };
 };

-#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();
 }
--- a/test/allocator_soccc_test.cpp
+++ b/test/allocator_soccc_test.cpp
@@ -16,7 +16,6 @@ struct A1 {
    int value;
 };

-#if !defined(BOOST_NO_CXX11_ALLOCATOR)
 template<class T>
 struct A2 {
    typedef T value_type;
@@ -27,15 +26,12 @@ struct A2 {
    }
    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();
 }
--- a/test/allocator_traits_test.cpp
+++ b/test/allocator_traits_test.cpp
@@ -0,0 +1,114 @@
+/*
+Copyright 2021 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_traits.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+
+template<class T>
+class creator {
+public:
+    typedef T value_type;
+    typedef T* pointer;
+    typedef const T* const_pointer;
+    typedef void* void_pointer;
+    typedef const void* const_void_pointer;
+    typedef std::size_t size_type;
+    typedef std::ptrdiff_t difference_type;
+
+    template<class U>
+    struct rebind {
+        typedef creator<U> other;
+    };
+
+    explicit creator(int value) BOOST_NOEXCEPT
+        : state_(value) { }
+
+    template<class U>
+    creator(const creator<U>& other) BOOST_NOEXCEPT
+        : state_(other.state) { }
+
+    std::size_t max_size() const BOOST_NOEXCEPT {
+        return static_cast<std::size_t>(-1) / sizeof(T);
+    }
+
+    T* allocate(std::size_t n, const void* = 0) {
+        return static_cast<T*>(::operator new(sizeof(T) * n));
+    }
+
+    void deallocate(T* p, std::size_t) {
+        ::operator delete(p);
+    }
+
+    int state() const {
+        return state_;
+    }
+
+private:
+    int state_;
+};
+
+template<class T, class U>
+inline bool operator==(const creator<T>& lhs,
+    const creator<U>& rhs) BOOST_NOEXCEPT
+{
+    return lhs.state() == rhs.state();
+}
+
+template<class T, class U>
+inline bool operator!=(const creator<T>& lhs,
+    const creator<U>& rhs) BOOST_NOEXCEPT
+{
+    return !(lhs == rhs);
+}
+
+int main()
+{
+    BOOST_TEST_TRAIT_SAME(creator<int>,
+        boost::allocator_traits<creator<int> >::allocator_type);
+    BOOST_TEST_TRAIT_SAME(int,
+        boost::allocator_traits<creator<int> >::value_type);
+    BOOST_TEST_TRAIT_SAME(int*,
+        boost::allocator_traits<creator<int> >::pointer);
+    BOOST_TEST_TRAIT_SAME(const int*,
+        boost::allocator_traits<creator<int> >::const_pointer);
+    BOOST_TEST_TRAIT_SAME(void*,
+        boost::allocator_traits<creator<int> >::void_pointer);
+    BOOST_TEST_TRAIT_SAME(const void*,
+        boost::allocator_traits<creator<int> >::const_void_pointer);
+    BOOST_TEST_TRAIT_SAME(std::ptrdiff_t,
+        boost::allocator_traits<creator<int> >::difference_type);
+    BOOST_TEST_TRAIT_SAME(std::size_t,
+        boost::allocator_traits<creator<int> >::size_type);
+    BOOST_TEST_TRAIT_FALSE((boost::allocator_traits<creator<int> >::
+        propagate_on_container_copy_assignment));
+    BOOST_TEST_TRAIT_FALSE((boost::allocator_traits<creator<int> >::
+        propagate_on_container_move_assignment));
+    BOOST_TEST_TRAIT_FALSE((boost::allocator_traits<creator<int> >::
+        propagate_on_container_swap));
+    BOOST_TEST_TRAIT_FALSE((boost::allocator_traits<creator<int> >::
+        is_always_equal));
+    BOOST_TEST_TRAIT_SAME(creator<char>,
+        boost::allocator_traits<creator<int> >::
+            rebind_traits<char>::allocator_type);
+    creator<int> a(1);
+    int* p1 = boost::allocator_traits<creator<int> >::allocate(a, 1);
+    if (BOOST_TEST(p1)) {
+        boost::allocator_traits<creator<int> >::construct(a, p1, 5);
+        BOOST_TEST_EQ(*p1, 5);
+        boost::allocator_traits<creator<int> >::destroy(a, p1);
+        boost::allocator_traits<creator<int> >::deallocate(a, p1, 1);
+    }
+    int* p2 = boost::allocator_traits<creator<int> >::allocate(a, 1, 0);
+    if (BOOST_TEST(p2)) {
+        boost::allocator_traits<creator<int> >::deallocate(a, p2, 1);
+    }
+    BOOST_TEST_EQ(boost::allocator_traits<creator<int> >::max_size(a),
+        static_cast<std::size_t>(-1) / sizeof(int));
+    BOOST_TEST(boost::allocator_traits<creator<int> >::
+        select_on_container_copy_construction(a) == a);
+    return boost::report_errors();
+}
--- a/test/allocator_void_pointer_test.cpp
+++ b/test/allocator_void_pointer_test.cpp
@@ -20,20 +20,16 @@ struct A1 {
    };
 };

-#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();
 }
--- a/test/bit_ceil_test.cpp
+++ b/test/bit_ceil_test.cpp
@@ -38,14 +38,14 @@ int main()
        test_bit_ceil( static_cast<unsigned short>( 0 ) );
        test_bit_ceil( static_cast<unsigned int>( 0 ) );
        test_bit_ceil( static_cast<unsigned long>( 0 ) );
-        test_bit_ceil( static_cast<unsigned long long>( 0 ) );
+        test_bit_ceil( static_cast<boost::ulong_long_type>( 0 ) );
    }

    {
        test_bit_ceil( static_cast<boost::uint8_t>( 0x80 ) );
        test_bit_ceil( static_cast<boost::uint16_t>( 0x8000 ) );
        test_bit_ceil( static_cast<boost::uint32_t>( 0x80000000 ) );
-        test_bit_ceil( static_cast<boost::uint64_t>( 0x8000000000000000 ) );
+        test_bit_ceil( boost::uint64_t( 1 ) << 63 );
    }

    boost::detail::splitmix64 rng;
@@ -58,7 +58,7 @@ int main()
        test_bit_ceil( static_cast<unsigned short>( x ) );
        test_bit_ceil( static_cast<unsigned int>( x ) );
        test_bit_ceil( static_cast<unsigned long>( x ) );
-        test_bit_ceil( static_cast<unsigned long long>( x ) );
+        test_bit_ceil( static_cast<boost::ulong_long_type>( x ) );
    }

    return boost::report_errors();
--- a/test/bit_countl_test.cpp
+++ b/test/bit_countl_test.cpp
@@ -27,7 +27,7 @@ int main()
    test_countl( static_cast<unsigned short>( 0 ) );
    test_countl( static_cast<unsigned int>( 0 ) );
    test_countl( static_cast<unsigned long>( 0 ) );
-    test_countl( static_cast<unsigned long long>( 0 ) );
+    test_countl( static_cast<boost::ulong_long_type>( 0 ) );

    boost::detail::splitmix64 rng;

@@ -39,7 +39,7 @@ int main()
        test_countl( static_cast<unsigned short>( x ) );
        test_countl( static_cast<unsigned int>( x ) );
        test_countl( static_cast<unsigned long>( x ) );
-        test_countl( static_cast<unsigned long long>( x ) );
+        test_countl( static_cast<boost::ulong_long_type>( x ) );
    }

    return boost::report_errors();
--- a/test/bit_countr_test.cpp
+++ b/test/bit_countr_test.cpp
@@ -27,7 +27,7 @@ int main()
    test_countr( static_cast<unsigned short>( 0 ) );
    test_countr( static_cast<unsigned int>( 0 ) );
    test_countr( static_cast<unsigned long>( 0 ) );
-    test_countr( static_cast<unsigned long long>( 0 ) );
+    test_countr( static_cast<boost::ulong_long_type>( 0 ) );

    boost::detail::splitmix64 rng;

@@ -39,7 +39,7 @@ int main()
        test_countr( static_cast<unsigned short>( x ) );
        test_countr( static_cast<unsigned int>( x ) );
        test_countr( static_cast<unsigned long>( x ) );
-        test_countr( static_cast<unsigned long long>( x ) );
+        test_countr( static_cast<boost::ulong_long_type>( x ) );
    }

    return boost::report_errors();
--- a/test/bit_endian_test.cpp
+++ b/test/bit_endian_test.cpp
@@ -15,7 +15,7 @@

 int main()
 {
-    boost::uint64_t v = static_cast<boost::uint64_t>( 0x0102030405060708ull );
+    boost::uint64_t v = ( static_cast<boost::uint64_t>( 0x01020304u ) << 32 ) + 0x05060708u;

    if( boost::core::endian::native == boost::core::endian::little )
    {
--- a/test/bit_floor_test.cpp
+++ b/test/bit_floor_test.cpp
@@ -33,7 +33,7 @@ int main()
        test_bit_floor( static_cast<unsigned short>( 0 ) );
        test_bit_floor( static_cast<unsigned int>( 0 ) );
        test_bit_floor( static_cast<unsigned long>( 0 ) );
-        test_bit_floor( static_cast<unsigned long long>( 0 ) );
+        test_bit_floor( static_cast<boost::ulong_long_type>( 0 ) );
    }

    boost::detail::splitmix64 rng;
@@ -46,7 +46,7 @@ int main()
        test_bit_floor( static_cast<unsigned short>( x ) );
        test_bit_floor( static_cast<unsigned int>( x ) );
        test_bit_floor( static_cast<unsigned long>( x ) );
-        test_bit_floor( static_cast<unsigned long long>( x ) );
+        test_bit_floor( static_cast<boost::ulong_long_type>( x ) );
    }

    return boost::report_errors();
--- a/test/bit_popcount_test.cpp
+++ b/test/bit_popcount_test.cpp
@@ -26,7 +26,7 @@ int main()
        test_popcount( static_cast<unsigned short>( 0 ) );
        test_popcount( static_cast<unsigned int>( 0 ) );
        test_popcount( static_cast<unsigned long>( 0 ) );
-        test_popcount( static_cast<unsigned long long>( 0 ) );
+        test_popcount( static_cast<boost::ulong_long_type>( 0 ) );
    }

    boost::detail::splitmix64 rng;
@@ -39,7 +39,7 @@ int main()
        test_popcount( static_cast<unsigned short>( x ) );
        test_popcount( static_cast<unsigned int>( x ) );
        test_popcount( static_cast<unsigned long>( x ) );
-        test_popcount( static_cast<unsigned long long>( x ) );
+        test_popcount( static_cast<boost::ulong_long_type>( x ) );
    }

    return boost::report_errors();
--- a/test/bit_rotate_test.cpp
+++ b/test/bit_rotate_test.cpp
@@ -103,26 +103,28 @@ int main()
        BOOST_TEST_EQ( +boost::core::rotr( x, 1 ), 0x44444444 );
    }

+#define CONST64(x) ((boost::uint64_t(x) << 32) + (x))
+
    {
-        boost::uint64_t x = 0x1111111111111111;
+        boost::uint64_t x = CONST64(0x11111111);

-        BOOST_TEST_EQ( +boost::core::rotl( x, 1 ), 0x2222222222222222 );
-        BOOST_TEST_EQ( +boost::core::rotr( x, 1 ), 0x8888888888888888 );
+        BOOST_TEST_EQ( +boost::core::rotl( x, 1 ), CONST64(0x22222222) );
+        BOOST_TEST_EQ( +boost::core::rotr( x, 1 ), CONST64(0x88888888) );

-        x = 0x2222222222222222;
+        x = CONST64(0x22222222);

-        BOOST_TEST_EQ( +boost::core::rotl( x, 1 ), 0x4444444444444444 );
-        BOOST_TEST_EQ( +boost::core::rotr( x, 1 ), 0x1111111111111111 );
+        BOOST_TEST_EQ( +boost::core::rotl( x, 1 ), CONST64(0x44444444) );
+        BOOST_TEST_EQ( +boost::core::rotr( x, 1 ), CONST64(0x11111111) );

-        x = 0x4444444444444444;
+        x = CONST64(0x44444444);

-        BOOST_TEST_EQ( +boost::core::rotl( x, 1 ), 0x8888888888888888 );
-        BOOST_TEST_EQ( +boost::core::rotr( x, 1 ), 0x2222222222222222 );
+        BOOST_TEST_EQ( +boost::core::rotl( x, 1 ), CONST64(0x88888888) );
+        BOOST_TEST_EQ( +boost::core::rotr( x, 1 ), CONST64(0x22222222) );

-        x = 0x8888888888888888;
+        x = CONST64(0x88888888);

-        BOOST_TEST_EQ( +boost::core::rotl( x, 1 ), 0x1111111111111111 );
-        BOOST_TEST_EQ( +boost::core::rotr( x, 1 ), 0x4444444444444444 );
+        BOOST_TEST_EQ( +boost::core::rotl( x, 1 ), CONST64(0x11111111) );
+        BOOST_TEST_EQ( +boost::core::rotr( x, 1 ), CONST64(0x44444444) );
    }

    for( int i = -M; i <= M; ++i )
@@ -152,7 +154,7 @@ int main()
        }

        {
-            unsigned long long x = 0;
+            boost::ulong_long_type x = 0;
            BOOST_TEST_EQ( boost::core::rotl( x, i ), x );
            BOOST_TEST_EQ( boost::core::rotr( x, i ), x );
        }
@@ -168,7 +170,7 @@ int main()
        test_rotate( static_cast<unsigned short>( x ) );
        test_rotate( static_cast<unsigned int>( x ) );
        test_rotate( static_cast<unsigned long>( x ) );
-        test_rotate( static_cast<unsigned long long>( x ) );
+        test_rotate( static_cast<boost::ulong_long_type>( x ) );
    }

    return boost::report_errors();
--- a/test/bit_width_test.cpp
+++ b/test/bit_width_test.cpp
@@ -87,7 +87,7 @@ int main()
        test_width( static_cast<unsigned short>( x ) );
        test_width( static_cast<unsigned int>( x ) );
        test_width( static_cast<unsigned long>( x ) );
-        test_width( static_cast<unsigned long long>( x ) );
+        test_width( static_cast<boost::ulong_long_type>( x ) );
    }

    return boost::report_errors();
--- a/test/default_allocator_allocate_hint_test.cpp
+++ b/test/default_allocator_allocate_hint_test.cpp
@@ -0,0 +1,19 @@
+/*
+Copyright 2021 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/allocator_access.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+int main()
+{
+    boost::default_allocator<int> a;
+    int* p = boost::allocator_allocate(a, 1, 0);
+    BOOST_TEST(p != 0);
+    a.deallocate(p, 1);
+    return boost::report_errors();
+}
--- a/test/has_single_bit_test.cpp
+++ b/test/has_single_bit_test.cpp
@@ -103,7 +103,7 @@ int main()
        test_single_bit( static_cast<unsigned short>( x ) );
        test_single_bit( static_cast<unsigned int>( x ) );
        test_single_bit( static_cast<unsigned long>( x ) );
-        test_single_bit( static_cast<unsigned long long>( x ) );
+        test_single_bit( static_cast<boost::ulong_long_type>( x ) );
    }

    return boost::report_errors();
--- a/test/iterator_test.cpp
+++ b/test/iterator_test.cpp
@@ -8,8 +8,15 @@
 // http://www.boost.org/LICENSE_1_0.txt
 //

+#define BOOST_ALLOW_DEPRECATED_HEADERS
 #define _SILENCE_CXX17_ITERATOR_BASE_CLASS_DEPRECATION_WARNING

+#include <boost/config.hpp>
+
+// std::iterator template is deprecated in C++17. Some standard libraries emit warnings
+// that cannot be easily suppressed, so disable the tests in C++17 onwards.
+#if BOOST_CXX_VERSION < 201703
+
 #include <boost/iterator.hpp>
 #include <boost/core/is_same.hpp>
 #include <boost/core/lightweight_test_trait.hpp>
@@ -69,3 +76,11 @@ int main()

    return boost::report_errors();
 }
+
+#else // BOOST_CXX_VERSION < 201703
+
+int main()
+{
+}
+
+#endif // BOOST_CXX_VERSION < 201703
--- a/test/pointer_traits_pointer_to_sfinae_test.cpp
+++ b/test/pointer_traits_pointer_to_sfinae_test.cpp
@@ -0,0 +1,72 @@
+/*
+Copyright 2021 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_DECLTYPE_N3276)
+#include <boost/core/pointer_traits.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+template<class T>
+class has_pointer_to {
+    template<class>
+    struct result {
+        char x, y;
+    };
+
+    template<class O>
+    static auto check(int) -> result<decltype(O::pointer_to)>;
+
+    template<class O>
+    static char check(long);
+
+public:
+    static const bool value = sizeof(check<T>(0)) > 1;
+};
+
+struct P1 { };
+
+struct P2 {
+    typedef int element_type;
+
+    static int* pointer_to(int& value) {
+        return &value;
+    }
+};
+
+struct P3 {
+    typedef void element_type;
+};
+
+struct P4 {
+    typedef int element_type;
+};
+
+struct P5 {
+    typedef int element_type;
+
+    static int* pointer_to() {
+        return 0;
+    }
+};
+
+int main()
+{
+    BOOST_TEST((!has_pointer_to<boost::pointer_traits<P1> >::value));
+    BOOST_TEST(has_pointer_to<boost::pointer_traits<P2> >::value);
+    BOOST_TEST(!has_pointer_to<boost::pointer_traits<P3> >::value);
+    BOOST_TEST(!has_pointer_to<boost::pointer_traits<P4> >::value);
+    BOOST_TEST(!has_pointer_to<boost::pointer_traits<P5> >::value);
+    BOOST_TEST(has_pointer_to<boost::pointer_traits<int*> >::value);
+    BOOST_TEST(!has_pointer_to<boost::pointer_traits<void*> >::value);
+    return boost::report_errors();
+}
+#else
+int main()
+{
+    return 0;
+}
+#endif
--- a/test/pointer_traits_rebind_sfinae_test.cpp
+++ b/test/pointer_traits_rebind_sfinae_test.cpp
@@ -0,0 +1,83 @@
+/*
+Copyright 2021 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_TEMPLATE_ALIASES) && \
+    (!defined(BOOST_GCC) || (BOOST_GCC >= 40800)) && \
+    (!defined(BOOST_MSVC) || (BOOST_MSVC >= 1900))
+#include <boost/core/pointer_traits.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+template<class>
+struct valid {
+    typedef void type;
+};
+
+#if !defined(BOOST_GCC) || (BOOST_GCC >= 50000)
+template<class, class, class = void>
+struct has_rebind {
+    static const bool value = false;
+};
+
+template<class T, class U>
+struct has_rebind<T, U,
+    typename valid<typename T::template rebind<U> >::type> {
+    static const bool value = true;
+};
+#else
+template<template<class> class T, class U>
+using defer = T<U>;
+
+template<class T, class U>
+using rebind = defer<T::template rebind, U>;
+
+template<class, class, template<class, class> class = rebind, class = void>
+struct has_rebind {
+    static const bool value = false;
+};
+
+template<class T, class U, template<class, class> class R>
+struct has_rebind<T, U, R, typename valid<R<T, U> >::type> {
+    static const bool value = true;
+};
+#endif
+
+struct P1 { };
+
+struct P2 {
+    typedef int element_type;
+};
+
+struct P3 {
+    typedef int element_type;
+
+    template<class>
+    struct rebind { };
+};
+
+template<class T>
+struct S {
+    typedef T element_type;
+};
+
+typedef S<int> P4;
+
+int main()
+{
+    BOOST_TEST((!has_rebind<boost::pointer_traits<P1>, char>::value));
+    BOOST_TEST((!has_rebind<boost::pointer_traits<P2>, char>::value));
+    BOOST_TEST((has_rebind<boost::pointer_traits<P3>, char>::value));
+    BOOST_TEST((has_rebind<boost::pointer_traits<P4>, char>::value));
+    BOOST_TEST((has_rebind<boost::pointer_traits<int*>, char>::value));
+    return boost::report_errors();
+}
+#else
+int main()
+{
+    return 0;
+}
+#endif
--- a/test/pointer_traits_sfinae_test.cpp
+++ b/test/pointer_traits_sfinae_test.cpp
@@ -0,0 +1,101 @@
+/*
+Copyright 2021 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+*/
+#include <boost/core/pointer_traits.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+template<class>
+struct valid {
+    typedef void type;
+};
+
+template<class, class = void>
+struct has_pointer {
+    static const bool value = false;
+};
+
+template<class T>
+struct has_pointer<T, typename valid<typename T::pointer>::type> {
+    static const bool value = true;
+};
+
+template<class, class = void>
+struct has_element_type {
+    static const bool value = false;
+};
+
+template<class T>
+struct has_element_type<T, typename valid<typename T::element_type>::type> {
+    static const bool value = true;
+};
+
+template<class, class = void>
+struct has_difference_type {
+    static const bool value = false;
+};
+
+template<class T>
+struct has_difference_type<T,
+    typename valid<typename T::difference_type>::type> {
+    static const bool value = true;
+};
+
+template<class, class, class = void>
+struct has_rebind_to_type {
+    static const bool value = false;
+};
+
+template<class T, class U>
+struct has_rebind_to_type<T, U,
+    typename valid<typename T::template rebind_to<U>::type>::type> {
+    static const bool value = true;
+};
+
+struct P1 { };
+
+struct P2 {
+    typedef int element_type;
+};
+
+struct P3 {
+    typedef int element_type;
+
+    template<class>
+    struct rebind { };
+};
+
+template<class T>
+struct S {
+    typedef T element_type;
+};
+
+typedef S<int> P4;
+
+int main()
+{
+    BOOST_TEST(!has_pointer<boost::pointer_traits<P1> >::value);
+    BOOST_TEST(!has_element_type<boost::pointer_traits<P1> >::value);
+    BOOST_TEST(!has_difference_type<boost::pointer_traits<P1> >::value);
+    BOOST_TEST((!has_rebind_to_type<boost::pointer_traits<P1>, char>::value));
+    BOOST_TEST(has_pointer<boost::pointer_traits<P2> >::value);
+    BOOST_TEST(has_element_type<boost::pointer_traits<P2> >::value);
+    BOOST_TEST(has_difference_type<boost::pointer_traits<P2> >::value);
+    BOOST_TEST((!has_rebind_to_type<boost::pointer_traits<P2>, char>::value));
+    BOOST_TEST(has_pointer<boost::pointer_traits<P3> >::value);
+    BOOST_TEST(has_element_type<boost::pointer_traits<P3> >::value);
+    BOOST_TEST(has_difference_type<boost::pointer_traits<P3> >::value);
+    BOOST_TEST((has_rebind_to_type<boost::pointer_traits<P3>, char>::value));
+    BOOST_TEST(has_pointer<boost::pointer_traits<P4> >::value);
+    BOOST_TEST(has_element_type<boost::pointer_traits<P4> >::value);
+    BOOST_TEST(has_difference_type<boost::pointer_traits<P4> >::value);
+    BOOST_TEST((has_rebind_to_type<boost::pointer_traits<P4>, char>::value));
+    BOOST_TEST(has_pointer<boost::pointer_traits<int*> >::value);
+    BOOST_TEST(has_element_type<boost::pointer_traits<int*> >::value);
+    BOOST_TEST(has_difference_type<boost::pointer_traits<int*> >::value);
+    BOOST_TEST((has_rebind_to_type<boost::pointer_traits<int*>, char>::value));
+    return boost::report_errors();
+}
--- a/test/splitmix64_test.cpp
+++ b/test/splitmix64_test.cpp
@@ -0,0 +1,38 @@
+// Test for boost/core/detail/splitmix64.hpp
+//
+// Copyright 2022 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/core/detail/splitmix64.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <boost/cstdint.hpp>
+
+int main()
+{
+    {
+        boost::detail::splitmix64 rng;
+
+        boost::uint64_t r1 = rng(), x1 = ( boost::uint64_t(0xe220a839u) << 32 ) + 0x7b1dcdafu;
+        BOOST_TEST_EQ( r1, x1 );
+
+        for( int i = 0; i < 1000; ++i ) rng();
+
+        boost::uint64_t r2 = rng(), x2 = ( boost::uint64_t(0xdcad513cu) << 32 ) + 0x211f942du;
+        BOOST_TEST_EQ( r2, x2 );
+    }
+
+    {
+        boost::detail::splitmix64 rng( 12345 );
+
+        boost::uint64_t r1 = rng(), x1 = ( boost::uint64_t(0x22118258u) << 32 ) + 0xa9d111a0u;
+        BOOST_TEST_EQ( r1, x1 );
+
+        for( int i = 0; i < 1000; ++i ) rng();
+
+        boost::uint64_t r2 = rng(), x2 = ( boost::uint64_t(0xaaefb4b6u) << 32 ) + 0x5c15e958u;
+        BOOST_TEST_EQ( r2, x2 );
+    }
+
+    return boost::report_errors();
+}
--- a/test/sv_common_reference_test.cpp
+++ b/test/sv_common_reference_test.cpp
@@ -0,0 +1,34 @@
+// Copyright 2021 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/core/detail/string_view.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <boost/config/pragma_message.hpp>
+#include <boost/config.hpp>
+#include <string>
+
+#if defined(BOOST_NO_CXX20_HDR_CONCEPTS)
+
+BOOST_PRAGMA_MESSAGE( "Skipping test because BOOST_NO_CXX20_HDR_CONCEPTS is defined" )
+int main() {}
+
+#else
+
+#include <concepts>
+#include <type_traits>
+
+using T = std::common_reference_t< boost::core::string_view&&, std::string& >;
+
+static_assert( std::common_reference_with< boost::core::string_view&&, std::string& > );
+static_assert( std::common_reference_with< boost::core::wstring_view&&, std::wstring const& > );
+
+int main()
+{
+    BOOST_TEST_TRAIT_SAME( std::common_reference_t< boost::core::string_view&&, std::string& >, boost::core::string_view );
+    BOOST_TEST_TRAIT_SAME( std::common_reference_t< boost::core::wstring_view&&, std::wstring const& >, boost::core::wstring_view );
+
+    return boost::report_errors();
+}
+
+#endif
--- a/test/sv_common_reference_test2.cpp
+++ b/test/sv_common_reference_test2.cpp
@@ -0,0 +1,24 @@
+// Copyright 2021 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/core/detail/string_view.hpp>
+#include <boost/config/pragma_message.hpp>
+#include <string>
+#include <iterator>
+
+#if !defined(__cpp_lib_ranges)
+
+BOOST_PRAGMA_MESSAGE( "Skipping test because __cpp_lib_ranges is not defined" )
+
+#else
+
+struct Iterator
+{
+    using value_type = std::string;
+    boost::core::string_view operator*() const noexcept;
+};
+
+static_assert( std::indirectly_readable<Iterator> );
+
+#endif
--- a/test/sv_conversion_test2.cpp
+++ b/test/sv_conversion_test2.cpp
@@ -0,0 +1,32 @@
+// Copyright 2021 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/core/detail/string_view.hpp>
+#include <boost/utility/string_view.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <string>
+
+boost::core::string_view f( boost::core::string_view const& str )
+{
+    return str;
+}
+
+int main()
+{
+    {
+        std::string s1( "123" );
+        std::string s2 = f( s1 );
+
+        BOOST_TEST_EQ( s1, s2 );
+    }
+
+    {
+        boost::string_view s1( "123" );
+        boost::string_view s2 = f( s1 );
+
+        BOOST_TEST_EQ( s1, s2 );
+    }
+
+    return boost::report_errors();
+}
--- a/test/sv_windows_h_test.cpp
+++ b/test/sv_windows_h_test.cpp
@@ -0,0 +1,15 @@
+// Copyright 2021 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#if !defined(_WIN32) && !defined(__CYGWIN__)
+
+#include <boost/config/pragma_message.hpp>
+BOOST_PRAGMA_MESSAGE( "Skipping test because _WIN32 and __CYGWIN__ are not defined" )
+
+#else
+
+#include <windows.h>
+#include <boost/core/detail/string_view.hpp>
+
+#endif
--- a/test/to_address_test.cpp
+++ b/test/to_address_test.cpp
@@ -13,9 +13,11 @@ class P1 {
 public:
    explicit P1(T* p)
        : p_(p) { }
+
    T* operator->() const BOOST_NOEXCEPT {
        return p_;
    }
+
 private:
    T* p_;
 };
@@ -25,9 +27,11 @@ class P2 {
 public:
    explicit P2(T* p)
        : p_(p) { }
+
    P1<T> operator->() const BOOST_NOEXCEPT {
        return p_;
    }
+
 private:
    P1<T> p_;
 };
@@ -38,20 +42,24 @@ class P3 {
 public:
    explicit P3(T* p)
        : p_(p) { }
+
    T* get() const BOOST_NOEXCEPT {
        return p_;
    }
+
 private:
    T* p_;
 };

 namespace boost {
+
 template<class T>
 struct pointer_traits<P3<T> > {
    static T* to_address(const P3<T>& p) BOOST_NOEXCEPT {
        return p.get();
    }
 };
+
 } /* boost */

 template<class T>
@@ -59,77 +67,29 @@ class P4 {
 public:
    explicit P4(T* p)
        : p_(p) { }
+
    T* operator->() const BOOST_NOEXCEPT {
        return 0;
    }
+
    T* get() const BOOST_NOEXCEPT {
        return p_;
    }
+
 private:
    int* p_;
 };

 namespace boost {
+
 template<class T>
 struct pointer_traits<P4<T> > {
    static T* to_address(const P4<T>& p) BOOST_NOEXCEPT {
        return p.get();
    }
 };
+
 } /* boost */
-
-#if !defined(BOOST_NO_CXX11_POINTER_TRAITS)
-template<class T>
-class P5 {
-public:
-    explicit P5(T* p)
-        : p_(p) { }
-    T* get() const BOOST_NOEXCEPT {
-        return p_;
-    }
-private:
-    T* p_;
-};
-
-namespace std {
-template<class T>
-struct pointer_traits<P5<T> > {
-    static T* to_address(const P5<T>& p) BOOST_NOEXCEPT {
-        return p.get();
-    }
-};
-} /* std */
-
-template<class T>
-class P6 {
-public:
-    explicit P6(T* p)
-        : p_(p) { }
-    T* get() const BOOST_NOEXCEPT {
-        return p_;
-    }
-private:
-    T* p_;
-};
-
-namespace boost {
-template<class T>
-struct pointer_traits<P6<T> > {
-    static T* to_address(const P6<T>& p) BOOST_NOEXCEPT {
-        return p.get();
-    }
-};
-} /* boost */
-
-namespace std {
-template<class T>
-struct pointer_traits<P6<T> > {
-    static T* to_address(const P6<T>& /*p*/) BOOST_NOEXCEPT {
-        return 0;
-    }
-};
-} /* std */
-#endif
 #endif

 int main()
@@ -147,12 +107,6 @@ int main()
    BOOST_TEST(boost::to_address(p3) == &i);
    P4<int> p4(&i);
    BOOST_TEST(boost::to_address(p4) == &i);
-#if !defined(BOOST_NO_CXX11_POINTER_TRAITS)
-    P5<int> p5(&i);
-    BOOST_TEST(boost::to_address(p5) == &i);
-    P6<int> p6(&i);
-    BOOST_TEST(boost::to_address(p6) == &i);
-#endif
 #endif
    return boost::report_errors();
 }
Author	SHA1	Message	Date
Peter Dimov	b7c987f83c	Mark quick_exit as inline	2022-02-15 02:08:30 +02:00
Peter Dimov	89d8efb7ff	Avoid -Wlong-long in bit_ceil_test.cpp	2022-02-08 22:58:45 +02:00
Peter Dimov	f12eeb6b9f	Avoid -Wlong-long in bit_rotate_test.cpp	2022-02-08 22:55:08 +02:00
Peter Dimov	ad63dcda9f	Fix -Wlong-long warnings in splitmix64.hpp	2022-02-08 22:49:44 +02:00
Peter Dimov	6a5f726602	Add splitmix64_test.cpp	2022-02-08 22:48:01 +02:00
Peter Dimov	cf619432a7	Fix GCC -Wlong-long warnings	2022-02-08 22:00:42 +02:00
Peter Dimov	b38c148969	Enable -pedantic for the cmath.hpp and bit.hpp tests	2022-02-08 21:37:34 +02:00
Peter Dimov	bae7c049b0	Avoid conversion warning in bit_width	2022-01-19 17:20:39 +02:00
Glen Fernandes	ea7b623b7d	Use consistent section titles in documentation	2022-01-07 11:16:44 -05:00
Andrey Semashev	6ae6ff79f1	Deprecated boost/iterator.hpp, emit warnings on inclusion. The header defines boost::iterator template, which is an alias for std::iterator, which is itself deprecated since C++17. Updated test to avoid testing the definition in C++17 onwards to avoid failures due to deprecation warnings from libc++-13.	2021-12-23 16:46:29 +03:00
Andrey Semashev	06976ccad7	Use path-constant to specify path to headers in docs Jamfile.	2021-12-23 15:10:58 +03:00
Andrey Semashev	65723e0e1f	Added clang-13 CI jobs.	2021-12-23 14:50:35 +03:00
Peter Dimov	df3b9827cf	Enclose std::min in parentheses to guard against <windows.h>	2021-12-20 01:35:55 +02:00
Peter Dimov	392cc988dd	Add sv_windows_h_test	2021-12-20 01:30:32 +02:00
Peter Dimov	0ef1c06fd8	Add cxxstd=20 to msvc-14.2, msvc-14.3	2021-12-18 21:59:21 +02:00
Peter Dimov	0b9624d047	Add sv_common_reference_test2	2021-12-18 18:53:42 +02:00
Peter Dimov	574c7cf86e	Update string_view.hpp to use BOOST_NO_CXX20_HDR_CONCEPTS	2021-12-18 18:39:03 +02:00
Peter Dimov	6e6af5fc90	Update sv_common_reference_test to check BOOST_NO_CXX20_HDR_CONCEPTS	2021-12-18 18:18:19 +02:00
Peter Dimov	95f2a76c90	Specialize std::basic_common_reference to enable std::common_reference and std::common_reference_with	2021-12-18 07:43:33 +02:00
Peter Dimov	28d26d13f1	Add sv_common_reference_test	2021-12-18 07:34:16 +02:00
Peter Dimov	ac71c55b4e	Remove msvc-14.2 from appveyor.yml (in GHA); use clang-win from VS2019	2021-12-18 05:07:12 +02:00
Peter Dimov	c83e682b7e	Update ci.yml	2021-12-18 05:05:36 +02:00
Peter Dimov	7a79d17da2	Add conversions from and to boost::string_view	2021-12-18 04:15:06 +02:00
Glen Fernandes	02b3f91fc3	Use same style of detection in pointer_traits and allocator_traits	2021-12-15 15:30:57 -05:00
Glen Fernandes	a2b37091eb	Update documentation	2021-12-15 11:36:02 -05:00
Glen Fernandes	78dd0cce2f	Make pointer_to SFINAE friendlier	2021-12-15 09:31:34 -05:00
Glen Fernandes	a121ab0278	Update release notes for 1.79	2021-12-14 07:52:42 -05:00
Glen Fernandes	0e62373aa2	Make pointer_traits SFINAE friendly	2021-12-13 13:13:12 -05:00
Glen Fernandes	6da7958281	Update unit tests	2021-12-08 10:26:49 -05:00
Glen Fernandes	c8479b4eca	Simplify C++03 detection traits slightly	2021-12-07 21:17:28 -05:00
Glen Fernandes	f5ab83efe8	Merge pull request #104 from boostorg/feature/allocator_access Support additional is_empty intrinsics	2021-12-07 11:02:04 -05:00
Glen Fernandes	eb7bc1ff53	Support additional is_empty intrinsics	2021-12-07 10:10:07 -05:00
Glen Fernandes	d038633f98	Correct spelling of detail macro	2021-12-07 02:57:14 -05:00
Glen Fernandes	ac4bdcc4c5	Update documentation	2021-12-06 23:43:03 -05:00
Glen Fernandes	85a3183c01	Update bool constant	2021-12-06 23:36:48 -05:00
Glen Fernandes	0c9675cf56	Add partial C++03 support for C++11 allocator model	2021-12-06 19:56:57 -05:00
Glen Fernandes	5abadf4472	Change A::value_type to allocator_value_type	2021-12-06 16:41:16 -05:00
Glen Fernandes	6b3fb219cc	Minor refactoring in allocator access	2021-12-06 15:58:48 -05:00
Glen Fernandes	febc195093	Add default_allocator allocate hint overload in C++03 mode	2021-12-04 14:41:23 -05:00
Glen Fernandes	8985ce604e	Simplify test	2021-12-04 14:39:36 -05:00
Glen Fernandes	15c884438c	Correct note in documentation	2021-12-04 14:38:18 -05:00
Glen Fernandes	15f7fb7eaa	Move Notes to a top level section	2021-12-04 00:32:27 -05:00
Glen Fernandes	46f37b2f16	Make max_size noexcept	2021-12-04 00:24:45 -05:00
Glen Fernandes	c1be2097d7	Minor documentation changes	2021-12-04 00:22:51 -05:00
Glen Fernandes	c8b989d80b	Add allocator_traits that uses allocator_access	2021-12-03 23:55:40 -05:00
Glen Fernandes	74c770206a	Allow all individual traits to be specialized	2021-12-02 23:09:09 -05:00