Remove BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION

Process #ifndef...#else...#endif blocks.

[SVN r86245]

.appveyor.yml

@@ -1,72 +0,0 @@
-# Copyright 2017 Daniel James
-# 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)
-
-version: 1.0.{build}-{branch}
-
-shallow_clone: true
-
-branches:
-  only:
-    - master
-    - develop
-    - /feature\/.*/
-
-environment:
-  matrix:
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
-      TOOLSET: msvc-9.0,msvc-10.0,msvc-11.0
-      ADDRMD: 32
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
-      TOOLSET: msvc-12.0,msvc-14.0
-      ADDRMD: 32,64
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
-      TOOLSET: msvc-14.1
-      CXXSTD: 14,17
-      ADDRMD: 32,64
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
-      TOOLSET: msvc-14.2
-      CXXSTD: 14,17,latest
-      ADDRMD: 32,64
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
-      TOOLSET: clang-win
-      CXXSTD: 14,17,latest
-      ADDRMD: 64
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
-      ADDPATH: C:\cygwin\bin;
-      TOOLSET: gcc
-      CXXSTD: 03,11,14,1z
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
-      ADDPATH: C:\cygwin64\bin;
-      TOOLSET: gcc
-      CXXSTD: 03,11,14,1z
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
-      ADDPATH: C:\mingw\bin;
-      TOOLSET: gcc
-      CXXSTD: 03,11,14,1z
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
-      ADDPATH: C:\mingw-w64\x86_64-6.3.0-posix-seh-rt_v5-rev1\mingw64\bin;
-      TOOLSET: gcc
-      CXXSTD: 03,11,14,1z
-
-install:
-  - set BOOST_BRANCH=develop
-  - if "%APPVEYOR_REPO_BRANCH%" == "master" set BOOST_BRANCH=master
-  - cd ..
-  - git clone -b %BOOST_BRANCH% --depth 1 https://github.com/boostorg/boost.git boost-root
-  - cd boost-root
-  - git submodule update --init tools/boostdep
-  - xcopy /s /e /q %APPVEYOR_BUILD_FOLDER% libs\container_hash\
-  - python tools/boostdep/depinst/depinst.py -I examples container_hash
-  - cmd /c bootstrap
-  - b2 -d0 headers
-
-build: off
-
-test_script:
-  - PATH=%ADDPATH%%PATH%
-  - if not "%CXXSTD%" == "" set CXXSTD=cxxstd=%CXXSTD%
-  - if not "%ADDRMD%" == "" set ADDRMD=address-model=%ADDRMD%
-  - b2 -j3 --verbose-test libs/container_hash/test//hash_info toolset=%TOOLSET% %CXXSTD% %ADDRMD% variant=debug,release embed-manifest-via=linker
-  - b2 -j3 libs/container_hash/test toolset=%TOOLSET% %CXXSTD% %ADDRMD% variant=debug,release embed-manifest-via=linker

.github/workflows/ci.yml

@@ -1,204 +0,0 @@
-name: CI
-
-on:
-  pull_request:
-  push:
-    branches:
-      - master
-      - develop
-      - feature/**
-
-env:
-  UBSAN_OPTIONS: print_stacktrace=1
-
-jobs:
-  posix:
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-          - toolset: gcc-4.8
-            cxxstd: "03,11"
-            os: ubuntu-18.04
-            install: g++-4.8-multilib
-            address-model: 32,64
-          - toolset: gcc-5
-            cxxstd: "03,11,14,1z"
-            os: ubuntu-18.04
-            install: g++-5-multilib
-            address-model: 32,64
-          - toolset: gcc-6
-            cxxstd: "03,11,14,1z"
-            os: ubuntu-18.04
-            install: g++-6-multilib
-            address-model: 32,64
-          - toolset: gcc-7
-            cxxstd: "03,11,14,17"
-            os: ubuntu-18.04
-            install: g++-7-multilib
-            address-model: 32,64
-          - toolset: gcc-8
-            cxxstd: "03,11,14,17,2a"
-            os: ubuntu-18.04
-            install: g++-8-multilib
-            address-model: 32,64
-          - toolset: gcc-9
-            cxxstd: "03,11,14,17,2a"
-            os: ubuntu-20.04
-            install: g++-9-multilib
-            address-model: 32,64
-          - toolset: gcc-10
-            cxxstd: "03,11,14,17,2a"
-            os: ubuntu-20.04
-            install: g++-10-multilib
-            address-model: 32,64
-          - toolset: gcc-11
-            cxxstd: "03,11,14,17,20"
-            os: ubuntu-20.04
-            install: g++-11-multilib
-            address-model: 32,64
-          - toolset: clang
-            compiler: clang++-3.9
-            cxxstd: "03,11,14"
-            os: ubuntu-18.04
-            install: clang-3.9
-          - toolset: clang
-            compiler: clang++-4.0
-            cxxstd: "03,11,14"
-            os: ubuntu-18.04
-            install: clang-4.0
-          - toolset: clang
-            compiler: clang++-5.0
-            cxxstd: "03,11,14,1z"
-            os: ubuntu-18.04
-            install: clang-5.0
-          - toolset: clang
-            compiler: clang++-6.0
-            cxxstd: "03,11,14,17"
-            os: ubuntu-18.04
-            install: clang-6.0
-          - toolset: clang
-            compiler: clang++-7
-            cxxstd: "03,11,14,17"
-            os: ubuntu-18.04
-            install: clang-7
-          - toolset: clang
-            compiler: clang++-8
-            cxxstd: "03,11,14,17"
-            os: ubuntu-20.04
-            install: clang-8
-          - toolset: clang
-            compiler: clang++-9
-            cxxstd: "03,11,14,17,2a"
-            os: ubuntu-20.04
-            install: clang-9
-          - toolset: clang
-            compiler: clang++-10
-            cxxstd: "03,11,14,17,2a"
-            os: ubuntu-20.04
-          - toolset: clang
-            compiler: clang++-11
-            cxxstd: "03,11,14,17,2a"
-            os: ubuntu-20.04
-          - toolset: clang
-            compiler: clang++-12
-            cxxstd: "03,11,14,17,20"
-            os: ubuntu-20.04
-          - toolset: clang
-            cxxstd: "03,11,14,17,2a"
-            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 -I examples --git_args "--jobs 3" $LIBRARY
-          ./bootstrap.sh
-          ./b2 -d0 headers
-
-      - name: Create user-config.jam
-        if: matrix.compiler
-        run: |
-          echo "using ${{matrix.toolset}} : : ${{matrix.compiler}} ;" > ~/user-config.jam
-
-      - name: Run tests
-        run: |
-          cd ../boost-root
-          export ADDRMD=${{matrix.address-model}}
-          ./b2 -j3 --verbose-test libs/$LIBRARY/test//hash_info toolset=${{matrix.toolset}} cxxstd=${{matrix.cxxstd}} ${ADDRMD:+address-model=$ADDRMD} variant=debug,release
-          ./b2 -j3 libs/$LIBRARY/test toolset=${{matrix.toolset}} cxxstd=${{matrix.cxxstd}} ${ADDRMD:+address-model=$ADDRMD} variant=debug,release
-
-  windows:
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-          - toolset: msvc-14.1
-            cxxstd: "14,17,latest"
-            addrmd: 32,64
-            os: windows-2016
-          - toolset: msvc-14.2
-            cxxstd: "14,17,latest"
-            addrmd: 32,64
-            os: windows-2019
-          - toolset: gcc
-            cxxstd: "03,11,14,17,2a"
-            addrmd: 64
-            os: windows-2019
-
-    runs-on: ${{matrix.os}}
-
-    steps:
-      - uses: actions/checkout@v2
-
-      - name: Setup Boost
-        shell: cmd
-        run: |
-          echo GITHUB_REPOSITORY: %GITHUB_REPOSITORY%
-          for /f %%i in ("%GITHUB_REPOSITORY%") do set LIBRARY=%%~nxi
-          echo LIBRARY: %LIBRARY%
-          echo LIBRARY=%LIBRARY%>>%GITHUB_ENV%
-          echo GITHUB_BASE_REF: %GITHUB_BASE_REF%
-          echo GITHUB_REF: %GITHUB_REF%
-          if "%GITHUB_BASE_REF%" == "" set GITHUB_BASE_REF=%GITHUB_REF%
-          set BOOST_BRANCH=develop
-          for /f %%i in ("%GITHUB_BASE_REF%") do if "%%~nxi" == "master" set BOOST_BRANCH=master
-          echo BOOST_BRANCH: %BOOST_BRANCH%
-          cd ..
-          git clone -b %BOOST_BRANCH% --depth 1 https://github.com/boostorg/boost.git boost-root
-          cd boost-root
-          xcopy /s /e /q %GITHUB_WORKSPACE% libs\%LIBRARY%\
-          git submodule update --init tools/boostdep
-          python tools/boostdep/depinst/depinst.py -I examples --git_args "--jobs 3" %LIBRARY%
-          cmd /c bootstrap
-          b2 -d0 headers
-
-      - name: Run tests
-        shell: cmd
-        run: |
-          cd ../boost-root
-          b2 -j3 --verbose-test libs/%LIBRARY%/test//hash_info toolset=${{matrix.toolset}} cxxstd=${{matrix.cxxstd}} address-model=${{matrix.addrmd}} variant=debug,release
-          b2 -j3 libs/%LIBRARY%/test toolset=${{matrix.toolset}} cxxstd=${{matrix.cxxstd}} address-model=${{matrix.addrmd}} variant=debug,release

.travis.yml

@@ -1,78 +0,0 @@
-# Copyright (C) 2016 Daniel James.
-# 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)
-
-# Use Trusty to get a reasonably recent version of Boost.
-sudo: required
-dist: trusty
-
-language: c++
-
-matrix:
-    include:
-      - compiler: gcc
-        env: |
-            USER_CONFIG="using gcc : : g++-4.8 ;"
-            CXXSTD=03,11
-      - compiler: g++-7
-        env: |
-            USER_CONFIG="using gcc : : g++-7 ;"
-            CXXSTD=11,14,17
-        addons:
-          apt:
-            packages:
-              - g++-7
-            sources:
-              - ubuntu-toolchain-r-test
-      - compiler: clang
-        env: |
-            USER_CONFIG="using clang : : clang++ ;"
-            CXXSTD=03,11
-      - compiler: clang
-        env: |
-            USER_CONFIG="using clang : : clang++ -D_HAS_AUTO_PTR_ETC=0 ;"
-            CXXSTD=11
-
-before_script:
-    - export BOOST_VERSION=1.67.0
-    - export BOOST_FILENAME=boost_1_67_0
-    - export BOOST_ROOT=${HOME}/boost
-    - cd ${TRAVIS_BUILD_DIR}
-    - touch Jamroot.jam
-    - cd $HOME
-    - echo $USER_CONFIG > ~/user-config.jam
-    - cat ~/user-config.jam
-    - |
-        mkdir $HOME/download
-        mkdir $HOME/extract
-        cd $HOME/download
-        if [ "$TRAVIS_EVENT_TYPE" == "cron" ]
-        then
-            if [ "$TRAVIS_BRANCH" == "master" ]
-            then
-                snapshot_branch=master
-            else
-                snapshot_branch=develop
-            fi
-            download_url=$(curl https://api.bintray.com/packages/boostorg/$snapshot_branch/snapshot/files |
-                    python -c "import os.path, sys, json; x = json.load(sys.stdin); print '\n'.join(a['path'] for a in x if os.path.splitext(a['path'])[1] == '.bz2')" |
-                    head -n 1 |
-                    sed "s/^/http:\/\/dl.bintray.com\/boostorg\/$snapshot_branch\//")
-        else
-            download_url=https://sourceforge.net/projects/boost/files/boost/${BOOST_VERSION}/${BOOST_FILENAME}.tar.bz2/download
-        fi
-        echo "Downloading ${download_url}"
-        wget -O boost.tar.bz2 $download_url
-        cd $HOME/extract
-        tar -xjf $HOME/download/boost.tar.bz2
-        mv * ${BOOST_ROOT}
-    - rm -r ${BOOST_ROOT}/boost/functional
-    - cd ${BOOST_ROOT}/tools/build
-    - mkdir ${HOME}/opt
-    - ./bootstrap.sh
-    - ./b2 install --prefix=$HOME/opt
-
-script:
-    - cd ${TRAVIS_BUILD_DIR}/test
-    - ${HOME}/opt/bin/b2 --verbose-test -j 3 cxxstd=$CXXSTD -q ${BJAM_TOOLSET} include=${BOOST_ROOT} include=${TRAVIS_BUILD_DIR}/include hash_info
-    - ${HOME}/opt/bin/b2 -j 3 cxxstd=$CXXSTD -q ${BJAM_TOOLSET} include=${BOOST_ROOT} include=${TRAVIS_BUILD_DIR}/include

CMakeLists.txt

@@ -1,22 +0,0 @@
-# Copyright 2018 Mike Dev
-# Distributed under the Boost Software License, Version 1.0.
-# See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt
-
-cmake_minimum_required(VERSION 3.5...3.20)
-project(boost_container_hash VERSION "${BOOST_SUPERPROJECT_VERSION}" LANGUAGES CXX)
-
-add_library(boost_container_hash INTERFACE)
-add_library(Boost::container_hash ALIAS boost_container_hash)
-
-target_include_directories(boost_container_hash INTERFACE include)
-
-target_link_libraries(boost_container_hash
-    INTERFACE
-        Boost::assert
-        Boost::config
-        Boost::core
-        Boost::detail
-        Boost::integer
-        Boost::static_assert
-        Boost::type_traits
-)

doc/Jamfile.v2

@@ -15,11 +15,5 @@ boostbook standalone : hash :
     <xsl:param>generate.section.toc.level=2
     <xsl:param>toc.section.depth=1
     <xsl:param>toc.max.depth=1
-    <format>pdf:<xsl:param>boost.url.prefix=http://www.boost.org/doc/libs/release/libs/container_hash/doc/html
+    <format>pdf:<xsl:param>boost.url.prefix=http://www.boost.org/doc/libs/release/libs/functional/hash/doc/html
     ;
-
-###############################################################################
-    alias boostdoc : hash ;
-    explicit boostdoc ;
-    alias boostrelease ;
-    explicit boostrelease ;

doc/changes.qbk

@@ -43,7 +43,7 @@
     the number of times combine is called and hopefully give a better
     quality hash function.
   * Improved the algorithm for hashing floating point numbers.
-  * On Cygwin use a binary hash function for floating point numbers, as
+  * On Cygwin use a binary hash function for floating point numbers, as 
     Cygwin doesn't have decent floating point functions for `long double`.
   * Never uses `fpclass` which doesn't support `long double`.
   * [@http://svn.boost.org/trac/boost/ticket/1064 Ticket 1064]:
@@ -71,11 +71,11 @@
 
 * Changed the warnings in the deprecated headers from 1.34.0 to errors. These
   will be removed in a future version of Boost.
-* Moved detail headers out of `boost/container_hash/detail`, since they are part of
-  functional/hash, not container_hash. `boost/container_hash/detail/container_fwd.hpp`
+* Moved detail headers out of `boost/functional/detail`, since they are part of
+  functional/hash, not functional. `boost/functional/detail/container_fwd.hpp`
   has been moved to `boost/detail/container_fwd.hpp` as it's used outside of
   this library, the others have been moved to `boost/functional/hash/detail`.
-
+  
 [h2 Boost 1.39.0]
 
 * Move the hash_fwd.hpp implementation into the hash subdirectory, leaving a
@@ -132,7 +132,7 @@
 * [@http://svn.boost.org/trac/boost/ticket/6806 Ticket 6806]:
   Support `std::array` and `std::tuple` when available.
 * Add deprecation warning to the long deprecated
-  `boost/container_hash/detail/container_fwd.hpp`.
+  `boost/functional/detail/container_fwd.hpp`.
 
 [h2 Boost 1.51.0]
 
@@ -168,55 +168,5 @@
   ([ticket 8822]).
 * Suppress Visual C++ infinite loop warning ([ticket 8568]).
 
-[h2 Boost 1.56.0]
-
-* Removed some Visual C++ 6 workarounds.
-* Ongoing work on improving `hash_combine`. This changes the combine function
-  which was previously defined in the reference documentation.
-
-[h2 Boost 1.58.0]
-
-* Fixed strict aliasing violation
-  ([@https://github.com/boostorg/container_hash/pull/3 GitHub #3]).
-
-[h2 Boost 1.63.0]
-
-* Fixed some warnings.
-* Only define hash for `std::wstring` when we know we have a `wchar_t`.
-  Otherwise there's a compile error as there's no overload for hashing
-  the characters in wide strings ([ticket 8552]).
-
-[h2 Boost 1.64.0]
-
-* Fix for recent versions of Visual C++ which have removed `std::unary_function`
-  and `std::binary_function` ([ticket 12353]).
-
-[h2 Boost 1.65.0]
-
-* Support for `char16_t`, `char32_t`, `u16string`, `u32string`
-
-[h2 Boost 1.66.0]
-
-* Avoid float comparison warning when using Clang - this workaround was
-  already in place for GCC, and was used when Clang pretends to be GCC,
-  but the warning was appearing when running Clang in other contexts.
-
-[h2 Boost 1.67.0]
-
-* Moved library into its own module, `container_hash`.
-* Moved headers for new module name, now at:
-  `<boost/container_hash/hash.hpp>`,
-  `<boost/container_hash/hash_fwd.hpp>`,
-  `<boost/container_hash/extensions.hpp>`.
-* Added forwarding headers to support the old headers locations.
-* Support `std::string_view`, `std::error_code`, `std::error_condition`
-  `std::optional`, `std::variant`, `std::monostate` where available.
-* Update include paths from other Boost libraries.
-* Manually write out tuple overloads, rather than using the
-  preprocessor to generate them. Should improve usability, due
-  to better error messages, and easier debugging.
-* Fix tutorial example ([ticket 11017]).
-* Quick fix for hashing `vector<bool>` when using libc++. Will try to introduce
-  a more general fix in the next release.
 
 [endsect]

doc/disable.qbk

@@ -10,7 +10,7 @@ to turn them of in order to check that your code will work with other
 implementations of TR1. To do this define the macro `BOOST_HASH_NO_EXTENSIONS`.
 When this macro is defined, only the specialisations detailed
 in TR1 will be declared. But, if you later undefine the macro and include
-<[headerref boost/container_hash/hash.hpp]> then the non-specialised form will be defined
+<[headerref boost/functional/hash.hpp]> then the non-specialised form will be defined
 - activating the extensions.
 
 It is strongly recommended that you never undefine the macro - and only define

doc/hash.qbk

@@ -1,4 +1,4 @@
-[library Boost.ContainerHash
+[library Boost.Functional/Hash
     [quickbook 1.5]
     [authors [James, Daniel]]
     [copyright 2005 2006 2007 2008 Daniel James]
@@ -6,7 +6,7 @@
         defined types]
     [category higher-order]
     [id hash]
-    [dirname container_hash]
+    [dirname functional/hash]
     [license
         Distributed under the Boost Software License, Version 1.0.
         (See accompanying file LICENSE_1_0.txt or copy at

doc/portability.qbk

@@ -88,6 +88,6 @@ boost namespace:
     }
 
 Full code for this example is at
-[@boost:/libs/container_hash/examples/portable.cpp /libs/container_hash/examples/portable.cpp].
+[@boost:/libs/functional/hash/examples/portable.cpp /libs/functional/hash/examples/portable.cpp].
 
 [endsect]

doc/ref.xml

@@ -13,7 +13,7 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
         <ulink url="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1837.pdf">Library Extension Technical Report Issues List</ulink> (page 63).
     </para>
   </section>
-  <header name="boost/container_hash/hash.hpp">
+  <header name="boost/functional/hash.hpp">
     <para>
       Defines <code><classname>boost::hash</classname></code>,
       and helper functions.
@@ -57,12 +57,7 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
             </para>
             <para>
               Forward declared in
-              <code>&lt;boost/container_hash/hash_fwd.hpp&gt;</code>
-            </para>
-            <para>
-              This hash function is not intended for general use, and isn't
-              guaranteed to be equal during separate runs of a program - so
-              please don't use it for any persistent storage or communication.
+              <code>&lt;boost/functional/hash_fwd.hpp&gt;</code>
             </para>
           </notes>
           <throws><para>
@@ -162,42 +157,6 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
         </method>
       </struct-specialization>
 
-      <struct-specialization name="hash">
-        <template></template>
-        <specialization>
-          <template-arg>char16_t</template-arg>
-        </specialization>
-        <method name="operator()" cv="const">
-          <type>std::size_t</type>
-          <parameter name="val">
-            <paramtype>char16_t</paramtype>
-          </parameter>
-          <returns>
-            <para>Unspecified in TR1, except that equal arguments yield the same result.</para>
-            <para><functionname>hash_value</functionname>(val) in Boost.</para>
-          </returns>
-          <throws><para>Doesn't throw</para></throws>
-        </method>
-      </struct-specialization>
-
-      <struct-specialization name="hash">
-        <template></template>
-        <specialization>
-          <template-arg>char32_t</template-arg>
-        </specialization>
-        <method name="operator()" cv="const">
-          <type>std::size_t</type>
-          <parameter name="val">
-            <paramtype>char32_t</paramtype>
-          </parameter>
-          <returns>
-            <para>Unspecified in TR1, except that equal arguments yield the same result.</para>
-            <para><functionname>hash_value</functionname>(val) in Boost.</para>
-          </returns>
-          <throws><para>Doesn't throw</para></throws>
-        </method>
-      </struct-specialization>
-
       <struct-specialization name="hash">
         <template></template>
         <specialization>
@@ -432,42 +391,6 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
         </method>
       </struct-specialization>
 
-      <struct-specialization name="hash">
-        <template></template>
-        <specialization>
-          <template-arg>std::u16string</template-arg>
-        </specialization>
-        <method name="operator()" cv="const">
-          <type>std::size_t</type>
-          <parameter name="val">
-            <paramtype>std::u16string const&amp;</paramtype>
-          </parameter>
-          <returns>
-            <para>Unspecified in TR1, except that equal arguments yield the same result.</para>
-            <para><functionname>hash_value</functionname>(val) in Boost.</para>
-          </returns>
-          <throws><para>Doesn't throw</para></throws>
-        </method>
-      </struct-specialization>
-
-      <struct-specialization name="hash">
-        <template></template>
-        <specialization>
-          <template-arg>std::u32string</template-arg>
-        </specialization>
-        <method name="operator()" cv="const">
-          <type>std::size_t</type>
-          <parameter name="val">
-            <paramtype>std::u32string const&amp;</paramtype>
-          </parameter>
-          <returns>
-            <para>Unspecified in TR1, except that equal arguments yield the same result.</para>
-            <para><functionname>hash_value</functionname>(val) in Boost.</para>
-          </returns>
-          <throws><para>Doesn't throw</para></throws>
-        </method>
-      </struct-specialization>
-
       <struct-specialization name="hash">
         <template>
           <template-type-parameter name="T"/>
@@ -527,27 +450,14 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
             Called repeatedly to incrementally create a hash value from
             several variables.
         </simpara></purpose>
-        <effects>
-            Updates <code>seed</code> with a new hash value generated by
-            combining it with the result of
-            <code><functionname>hash_value</functionname>(v)</code>. Will
-            always produce the same result for the same combination of
-            <code>seed</code> and
-            <code><functionname>hash_value</functionname>(v)</code> during
-            the single run of a program.
-        </effects>
+        <effects><programlisting>seed ^= <functionname>hash_value</functionname>(v) + 0x9e3779b9 + (seed &lt;&lt; 6) + (seed &gt;&gt; 2);</programlisting></effects>
         <notes>
           <para><functionname>hash_value</functionname> is called without
           qualification, so that overloads can be found via ADL.</para>
           <para>This is an extension to TR1</para>
           <para>
             Forward declared in
-            <code>&lt;boost/container_hash/hash_fwd.hpp&gt;</code>
-          </para>
-          <para>
-            This hash function is not intended for general use, and isn't
-            guaranteed to be equal during separate runs of a program - so
-            please don't use it for any persistent storage or communication.
+            <code>&lt;boost/functional/hash_fwd.hpp&gt;</code>
           </para>
         </notes>
         <throws>
@@ -615,12 +525,7 @@ for(; first != last; ++first)
           <para>This is an extension to TR1</para>
           <para>
             Forward declared in
-            <code>&lt;boost/container_hash/hash_fwd.hpp&gt;</code>
-          </para>
-          <para>
-            This hash function is not intended for general use, and isn't
-            guaranteed to be equal during separate runs of a program - so
-            please don't use it for any persistent storage or communication.
+            <code>&lt;boost/functional/hash_fwd.hpp&gt;</code>
           </para>
         </notes>
         <throws><para>
@@ -669,16 +574,6 @@ for(; first != last; ++first)
           <parameter name="val"><paramtype>wchar_t</paramtype></parameter>
         </signature>
 
-        <signature>
-          <type>std::size_t</type>
-          <parameter name="val"><paramtype>char16_t</paramtype></parameter>
-        </signature>
-
-        <signature>
-          <type>std::size_t</type>
-          <parameter name="val"><paramtype>char32_t</paramtype></parameter>
-        </signature>
-
         <signature>
           <type>std::size_t</type>
           <parameter name="val"><paramtype>short</paramtype></parameter>
@@ -889,11 +784,6 @@ for(; first != last; ++first)
 
         <notes>
           <para>This is an extension to TR1</para>
-          <para>
-            This hash function is not intended for general use, and isn't
-            guaranteed to be equal during separate runs of a program - so
-            please don't use it for any persistent storage or communication.
-          </para>
         </notes>
 
         <throws>
@@ -915,8 +805,7 @@ for(; first != last; ++first)
               <tbody>
                 <row>
                   <entry><code>bool</code>,
-                    <code>char</code>, <code>signed char</code>, <code>unsigned char</code>,
-                    <code>wchar_t</code>, <code>char16_t</code>, <code>char32_t</code>,
+                    <code>char</code>, <code>signed char</code>, <code>unsigned char</code>, <code>wchar_t</code>,
                     <code>short</code>, <code>unsigned short</code>,
                     <code>int</code>, <code>unsigned int</code>, <code>long</code>, <code>unsigned long</code>
                   </entry>

doc/samples/tutorial.cpp

@@ -1,27 +0,0 @@
-#include <boost/container_hash/hash.hpp>
-#include <vector>
-#include <algorithm>
-#include <iterator>
-#include <cassert>
-
-//[ get_hashes
-template <class Container>
-std::vector<std::size_t> get_hashes(Container const& x)
-{
-    std::vector<std::size_t> hashes;
-    std::transform(x.begin(), x.end(), std::back_inserter(hashes),
-        boost::hash<typename Container::value_type>());
-
-    return hashes;
-}
-//]
-
-int main() {
-    std::vector<int> values;
-    values.push_back(10);
-    values.push_back(20);
-
-    std::vector<std::size_t> hashes = get_hashes(values);
-    assert(hashes[0] = boost::hash<int>()(values[0]));
-    assert(hashes[1] = boost::hash<int>()(values[1]));
-}

doc/tutorial.qbk

@@ -3,9 +3,6 @@
  / 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) ]
 
-[quickbook 1.7]
-[import samples/tutorial.cpp]
-
 [def __multi-index-short__ [@boost:/libs/multi_index/doc/index.html
     Boost.MultiIndex]]
 
@@ -30,7 +27,7 @@ associative containers and you wish to use
 
 To use [classref boost::hash] directly, create an instance and call it as a function:
 
-    #include <``[headerref boost/container_hash/hash.hpp]``>
+    #include <``[headerref boost/functional/hash.hpp]``>
 
     int main()
     {
@@ -42,7 +39,15 @@ To use [classref boost::hash] directly, create an instance and call it as a func
 For an example of generic use, here is a function to generate a vector
 containing the hashes of the elements of a container:
 
-[get_hashes]
+    template <class Container>
+    std::vector<std::size_t> get_hashes(Container const& x)
+    {
+        std::vector<std::size_t> hashes;
+        std::transform(x.begin(), x.end(), std::insert_iterator(hashes),
+            ``[classref boost::hash]``<typename Container::value_type>());
+
+        return hashes;
+    }
 
 [endsect]
 
@@ -105,9 +110,9 @@ And you can now use [classref boost::hash] with book:
     assert(books.find(dandelion) == books.end());
 
 The full example can be found in:
-[@boost:/libs/container_hash/examples/books.hpp /libs/container_hash/examples/books.hpp]
+[@boost:/libs/functional/hash/examples/books.hpp /libs/functional/hash/examples/books.hpp]
 and
-[@boost:/libs/container_hash/examples/books.cpp /libs/container_hash/examples/books.cpp].
+[@boost:/libs/functional/hash/examples/books.cpp /libs/functional/hash/examples/books.cpp].
 
 [tip
 When writing a hash function, first look at how the equality function works.
@@ -165,7 +170,7 @@ of point, it can be repeatedly called for any number of elements. It calls
 [funcref boost::hash_value hash_value] on the supplied element, and combines it with the seed.
 
 Full code for this example is at
-[@boost:/libs/container_hash/examples/point.cpp /libs/container_hash/examples/point.cpp].
+[@boost:/libs/functional/hash/examples/point.cpp /libs/functional/hash/examples/point.cpp].
 
 [note
 When using [funcref boost::hash_combine] the order of the
@@ -195,13 +200,13 @@ To calculate the hash of an iterator range you can use [funcref boost::hash_rang
 
 Note that when writing template classes, you might not want to include the main
 hash header as it's quite an expensive include that brings in a lot of other
-headers, so instead you can include the `<boost/container_hash/hash_fwd.hpp>`
+headers, so instead you can include the `<boost/functional/hash_fwd.hpp>`
 header which forward declares [classref boost::hash],
 [funcref boost::hash_range] and [funcref boost::hash_combine]. You'll need to
 include the main header before instantiating [classref boost::hash]. When using
 a container that uses [classref boost::hash] it should do that for you, so your
 type will work fine with the boost hash containers. There's an example of this
-in [@boost:/libs/container_hash/examples/template.hpp template.hpp] and
-[@boost:/libs/container_hash/examples/template.cpp template.cpp].
+in [@boost:/libs/functional/hash/examples/template.hpp template.hpp] and
+[@boost:/libs/functional/hash/examples/template.cpp template.cpp].
 
 [endsect]

examples/books.cpp

@@ -4,7 +4,7 @@
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
 #include "./books.hpp"
-#include <boost/container_hash/hash.hpp>
+#include <boost/functional/hash.hpp>
 #include <cassert>
 
 // If std::unordered_set was available:

examples/point.cpp

@@ -3,12 +3,7 @@
 // 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)
 
-// Force use of assert.
-#if defined(NDEBUG)
-#undef NDEBUG
-#endif
-
-#include <boost/container_hash/hash.hpp>
+#include <boost/functional/hash.hpp>
 #include <cassert>
 
 // This example illustrates how to use boost::hash_combine to generate a hash

examples/portable.cpp

@@ -3,12 +3,7 @@
 // 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)
 
-// Force use of assert.
-#if defined(NDEBUG)
-#undef NDEBUG
-#endif
-
-#include <boost/container_hash/hash.hpp>
+#include <boost/functional/hash.hpp>
 #include <cassert>
 
 // This example illustrates how to customise boost::hash portably, so that

examples/template.hpp

@@ -6,7 +6,7 @@
 // This is an example of how to write a hash function for a template
 // class.
 
-#include <boost/container_hash/hash_fwd.hpp>
+#include <boost/functional/hash_fwd.hpp>
 
 template <typename A, typename B>
 class my_pair

include/boost/container_hash/extensions.hpp

@@ -1,361 +0,0 @@
-
-// Copyright 2005-2009 Daniel James.
-// 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)
-
-//  Based on Peter Dimov's proposal
-//  http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2005/n1756.pdf
-//  issue 6.18.
-
-// This implements the extensions to the standard.
-// It's undocumented, so you shouldn't use it....
-
-#if !defined(BOOST_FUNCTIONAL_HASH_EXTENSIONS_HPP)
-#define BOOST_FUNCTIONAL_HASH_EXTENSIONS_HPP
-
-#include <boost/config.hpp>
-#if defined(BOOST_HAS_PRAGMA_ONCE)
-#pragma once
-#endif
-
-#include <boost/container_hash/hash.hpp>
-#include <boost/detail/container_fwd.hpp>
-#include <boost/core/enable_if.hpp>
-#include <boost/static_assert.hpp>
-
-#if !defined(BOOST_NO_CXX11_HDR_ARRAY)
-#   include <array>
-#endif
-
-#if !defined(BOOST_NO_CXX11_HDR_TUPLE)
-#   include <tuple>
-#endif
-
-#include <memory>
-
-#if defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
-#include <boost/type_traits/is_array.hpp>
-#endif
-
-namespace boost
-{
-    template <class A, class B>
-    std::size_t hash_value(std::pair<A, B> const&);
-    template <class T, class A>
-    std::size_t hash_value(std::vector<T, A> const&);
-    template <class T, class A>
-    std::size_t hash_value(std::list<T, A> const& v);
-    template <class T, class A>
-    std::size_t hash_value(std::deque<T, A> const& v);
-    template <class K, class C, class A>
-    std::size_t hash_value(std::set<K, C, A> const& v);
-    template <class K, class C, class A>
-    std::size_t hash_value(std::multiset<K, C, A> const& v);
-    template <class K, class T, class C, class A>
-    std::size_t hash_value(std::map<K, T, C, A> const& v);
-    template <class K, class T, class C, class A>
-    std::size_t hash_value(std::multimap<K, T, C, A> const& v);
-
-    template <class T>
-    std::size_t hash_value(std::complex<T> const&);
-
-    template <class A, class B>
-    std::size_t hash_value(std::pair<A, B> const& v)
-    {
-        std::size_t seed = 0;
-        boost::hash_combine(seed, v.first);
-        boost::hash_combine(seed, v.second);
-        return seed;
-    }
-
-    template <class T, class A>
-    std::size_t hash_value(std::vector<T, A> const& v)
-    {
-        return boost::hash_range(v.begin(), v.end());
-    }
-
-    template <class T, class A>
-    std::size_t hash_value(std::list<T, A> const& v)
-    {
-        return boost::hash_range(v.begin(), v.end());
-    }
-
-    template <class T, class A>
-    std::size_t hash_value(std::deque<T, A> const& v)
-    {
-        return boost::hash_range(v.begin(), v.end());
-    }
-
-    template <class K, class C, class A>
-    std::size_t hash_value(std::set<K, C, A> const& v)
-    {
-        return boost::hash_range(v.begin(), v.end());
-    }
-
-    template <class K, class C, class A>
-    std::size_t hash_value(std::multiset<K, C, A> const& v)
-    {
-        return boost::hash_range(v.begin(), v.end());
-    }
-
-    template <class K, class T, class C, class A>
-    std::size_t hash_value(std::map<K, T, C, A> const& v)
-    {
-        return boost::hash_range(v.begin(), v.end());
-    }
-
-    template <class K, class T, class C, class A>
-    std::size_t hash_value(std::multimap<K, T, C, A> const& v)
-    {
-        return boost::hash_range(v.begin(), v.end());
-    }
-
-    template <class T>
-    std::size_t hash_value(std::complex<T> const& v)
-    {
-        boost::hash<T> hasher;
-        std::size_t seed = hasher(v.imag());
-        seed ^= hasher(v.real()) + (seed<<6) + (seed>>2);
-        return seed;
-    }
-
-#if !defined(BOOST_NO_CXX11_HDR_ARRAY)
-    template <class T, std::size_t N>
-    std::size_t hash_value(std::array<T, N> const& v)
-    {
-        return boost::hash_range(v.begin(), v.end());
-    }
-#endif
-
-#if !defined(BOOST_NO_CXX11_HDR_TUPLE)
-    namespace hash_detail {
-        template <std::size_t I, typename T>
-        inline typename boost::enable_if_c<(I == std::tuple_size<T>::value),
-                void>::type
-            hash_combine_tuple(std::size_t&, T const&)
-        {
-        }
-
-        template <std::size_t I, typename T>
-        inline typename boost::enable_if_c<(I < std::tuple_size<T>::value),
-                void>::type
-            hash_combine_tuple(std::size_t& seed, T const& v)
-        {
-            boost::hash_combine(seed, std::get<I>(v));
-            boost::hash_detail::hash_combine_tuple<I + 1>(seed, v);
-        }
-
-        template <typename T>
-        inline std::size_t hash_tuple(T const& v)
-        {
-            std::size_t seed = 0;
-            boost::hash_detail::hash_combine_tuple<0>(seed, v);
-            return seed;
-        }
-    }
-
-#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-    template <typename... T>
-    inline std::size_t hash_value(std::tuple<T...> const& v)
-    {
-        return boost::hash_detail::hash_tuple(v);
-    }
-#else
-
-    inline std::size_t hash_value(std::tuple<> const& v)
-    {
-        return boost::hash_detail::hash_tuple(v);
-    }
-
-    template<typename A0>
-    inline std::size_t hash_value(std::tuple<A0> const& v)
-    {
-        return boost::hash_detail::hash_tuple(v);
-    }
-
-    template<typename A0, typename A1>
-    inline std::size_t hash_value(std::tuple<A0, A1> const& v)
-    {
-        return boost::hash_detail::hash_tuple(v);
-    }
-
-    template<typename A0, typename A1, typename A2>
-    inline std::size_t hash_value(std::tuple<A0, A1, A2> const& v)
-    {
-        return boost::hash_detail::hash_tuple(v);
-    }
-
-    template<typename A0, typename A1, typename A2, typename A3>
-    inline std::size_t hash_value(std::tuple<A0, A1, A2, A3> const& v)
-    {
-        return boost::hash_detail::hash_tuple(v);
-    }
-
-    template<typename A0, typename A1, typename A2, typename A3, typename A4>
-    inline std::size_t hash_value(std::tuple<A0, A1, A2, A3, A4> const& v)
-    {
-        return boost::hash_detail::hash_tuple(v);
-    }
-
-    template<typename A0, typename A1, typename A2, typename A3, typename A4, typename A5>
-    inline std::size_t hash_value(std::tuple<A0, A1, A2, A3, A4, A5> const& v)
-    {
-        return boost::hash_detail::hash_tuple(v);
-    }
-
-    template<typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6>
-    inline std::size_t hash_value(std::tuple<A0, A1, A2, A3, A4, A5, A6> const& v)
-    {
-        return boost::hash_detail::hash_tuple(v);
-    }
-
-    template<typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7>
-    inline std::size_t hash_value(std::tuple<A0, A1, A2, A3, A4, A5, A6, A7> const& v)
-    {
-        return boost::hash_detail::hash_tuple(v);
-    }
-
-    template<typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8>
-    inline std::size_t hash_value(std::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8> const& v)
-    {
-        return boost::hash_detail::hash_tuple(v);
-    }
-
-    template<typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9>
-    inline std::size_t hash_value(std::tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9> const& v)
-    {
-        return boost::hash_detail::hash_tuple(v);
-    }
-
-#endif
-
-#endif
-
-#if !defined(BOOST_NO_CXX11_SMART_PTR)
-    template <typename T>
-    inline std::size_t hash_value(std::shared_ptr<T> const& x) {
-        return boost::hash_value(x.get());
-    }
-
-    template <typename T, typename Deleter>
-    inline std::size_t hash_value(std::unique_ptr<T, Deleter> const& x) {
-        return boost::hash_value(x.get());
-    }
-#endif
-
-    //
-    // call_hash_impl
-    //
-
-    // On compilers without function template ordering, this deals with arrays.
-
-#if defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
-    namespace hash_detail
-    {
-        template <bool IsArray>
-        struct call_hash_impl
-        {
-            template <class T>
-            struct inner
-            {
-                static std::size_t call(T const& v)
-                {
-                    using namespace boost;
-                    return hash_value(v);
-                }
-            };
-        };
-
-        template <>
-        struct call_hash_impl<true>
-        {
-            template <class Array>
-            struct inner
-            {
-                static std::size_t call(Array const& v)
-                {
-                    const int size = sizeof(v) / sizeof(*v);
-                    return boost::hash_range(v, v + size);
-                }
-            };
-        };
-
-        template <class T>
-        struct call_hash
-            : public call_hash_impl<boost::is_array<T>::value>
-                ::BOOST_NESTED_TEMPLATE inner<T>
-        {
-        };
-    }
-#endif // BOOST_NO_FUNCTION_TEMPLATE_ORDERING
-
-    //
-    // boost::hash
-    //
-
-
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
-
-    template <class T> struct hash
-        : boost::hash_detail::hash_base<T>
-    {
-#if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
-        std::size_t operator()(T const& val) const
-        {
-            return hash_value(val);
-        }
-#else
-        std::size_t operator()(T const& val) const
-        {
-            return hash_detail::call_hash<T>::call(val);
-        }
-#endif
-    };
-
-#if BOOST_WORKAROUND(__DMC__, <= 0x848)
-    template <class T, unsigned int n> struct hash<T[n]>
-        : boost::hash_detail::hash_base<T[n]>
-    {
-        std::size_t operator()(const T* val) const
-        {
-            return boost::hash_range(val, val+n);
-        }
-    };
-#endif
-
-#else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-
-    // On compilers without partial specialization, boost::hash<T>
-    // has already been declared to deal with pointers, so just
-    // need to supply the non-pointer version of hash_impl.
-
-    namespace hash_detail
-    {
-        template <bool IsPointer>
-        struct hash_impl;
-
-        template <>
-        struct hash_impl<false>
-        {
-            template <class T>
-            struct inner
-                : boost::hash_detail::hash_base<T>
-            {
-#if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
-                std::size_t operator()(T const& val) const
-                {
-                    return hash_value(val);
-                }
-#else
-                std::size_t operator()(T const& val) const
-                {
-                    return hash_detail::call_hash<T>::call(val);
-                }
-#endif
-            };
-        };
-    }
-#endif  // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-}
-
-#endif

include/boost/container_hash/hash.hpp

@@ -1,767 +0,0 @@
-
-// Copyright 2005-2014 Daniel James.
-// 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)
-
-//  Based on Peter Dimov's proposal
-//  http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2005/n1756.pdf
-//  issue 6.18.
-//
-//  This also contains public domain code from MurmurHash. From the
-//  MurmurHash header:
-
-// MurmurHash3 was written by Austin Appleby, and is placed in the public
-// domain. The author hereby disclaims copyright to this source code.
-
-#if !defined(BOOST_FUNCTIONAL_HASH_HASH_HPP)
-#define BOOST_FUNCTIONAL_HASH_HASH_HPP
-
-#include <boost/container_hash/hash_fwd.hpp>
-#include <functional>
-#include <iterator>
-#include <boost/container_hash/detail/hash_float.hpp>
-#include <string>
-#include <boost/limits.hpp>
-#include <boost/type_traits/is_enum.hpp>
-#include <boost/type_traits/is_integral.hpp>
-#include <boost/core/enable_if.hpp>
-#include <boost/cstdint.hpp>
-#include <climits>
-
-#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
-#include <boost/type_traits/is_pointer.hpp>
-#endif
-
-#if !defined(BOOST_NO_CXX11_HDR_TYPEINDEX)
-#include <typeindex>
-#endif
-
-#if !defined(BOOST_NO_CXX11_HDR_SYSTEM_ERROR)
-#include <system_error>
-#endif
-
-#if defined(BOOST_MSVC)
-#pragma warning(push)
-
-#if BOOST_MSVC >= 1400
-#pragma warning(disable:6295) // Ill-defined for-loop : 'unsigned int' values
-                              // are always of range '0' to '4294967295'.
-                              // Loop executes infinitely.
-#endif
-
-#endif
-
-#if BOOST_WORKAROUND(__GNUC__, < 3) \
-    && !defined(__SGI_STL_PORT) && !defined(_STLPORT_VERSION)
-#define BOOST_HASH_CHAR_TRAITS string_char_traits
-#else
-#define BOOST_HASH_CHAR_TRAITS char_traits
-#endif
-
-#if defined(_MSC_VER)
-#   define BOOST_FUNCTIONAL_HASH_ROTL32(x, r) _rotl(x,r)
-#else
-#   define BOOST_FUNCTIONAL_HASH_ROTL32(x, r) (x << r) | (x >> (32 - r))
-#endif
-
-// Detect whether standard library has C++17 headers
-
-#if !defined(BOOST_HASH_CXX17)
-#   if defined(BOOST_MSVC)
-#       if defined(_HAS_CXX17) && _HAS_CXX17
-#           define BOOST_HASH_CXX17 1
-#       endif
-#   elif defined(__cplusplus) && __cplusplus >= 201703
-#       define BOOST_HASH_CXX17 1
-#   endif
-#endif
-
-#if !defined(BOOST_HASH_CXX17)
-#   define BOOST_HASH_CXX17 0
-#endif
-
-#if BOOST_HASH_CXX17 && defined(__has_include)
-#   if !defined(BOOST_HASH_HAS_STRING_VIEW) && __has_include(<string_view>)
-#       define BOOST_HASH_HAS_STRING_VIEW 1
-#   endif
-#   if !defined(BOOST_HASH_HAS_OPTIONAL) && __has_include(<optional>)
-#       define BOOST_HASH_HAS_OPTIONAL 1
-#   endif
-#   if !defined(BOOST_HASH_HAS_VARIANT) && __has_include(<variant>)
-#       define BOOST_HASH_HAS_VARIANT 1
-#   endif
-#endif
-
-#if !defined(BOOST_HASH_HAS_STRING_VIEW)
-#   define BOOST_HASH_HAS_STRING_VIEW 0
-#endif
-
-#if !defined(BOOST_HASH_HAS_OPTIONAL)
-#   define BOOST_HASH_HAS_OPTIONAL 0
-#endif
-
-#if !defined(BOOST_HASH_HAS_VARIANT)
-#   define BOOST_HASH_HAS_VARIANT 0
-#endif
-
-#if BOOST_HASH_HAS_STRING_VIEW
-#   include <string_view>
-#endif
-
-#if BOOST_HASH_HAS_OPTIONAL
-#   include <optional>
-#endif
-
-#if BOOST_HASH_HAS_VARIANT
-#   include <variant>
-#endif
-
-namespace boost
-{
-    namespace hash_detail
-    {
-#if defined(BOOST_NO_CXX98_FUNCTION_BASE)
-        template <typename T>
-        struct hash_base
-        {
-            typedef T argument_type;
-            typedef std::size_t result_type;
-        };
-#else
-        template <typename T>
-        struct hash_base : std::unary_function<T, std::size_t> {};
-#endif
-
-        struct enable_hash_value { typedef std::size_t type; };
-
-        template <typename T> struct basic_numbers {};
-        template <typename T> struct long_numbers;
-        template <typename T> struct ulong_numbers;
-        template <typename T> struct float_numbers {};
-
-        template <> struct basic_numbers<bool> :
-            boost::hash_detail::enable_hash_value {};
-        template <> struct basic_numbers<char> :
-            boost::hash_detail::enable_hash_value {};
-        template <> struct basic_numbers<unsigned char> :
-            boost::hash_detail::enable_hash_value {};
-        template <> struct basic_numbers<signed char> :
-            boost::hash_detail::enable_hash_value {};
-        template <> struct basic_numbers<short> :
-            boost::hash_detail::enable_hash_value {};
-        template <> struct basic_numbers<unsigned short> :
-            boost::hash_detail::enable_hash_value {};
-        template <> struct basic_numbers<int> :
-            boost::hash_detail::enable_hash_value {};
-        template <> struct basic_numbers<unsigned int> :
-            boost::hash_detail::enable_hash_value {};
-        template <> struct basic_numbers<long> :
-            boost::hash_detail::enable_hash_value {};
-        template <> struct basic_numbers<unsigned long> :
-            boost::hash_detail::enable_hash_value {};
-
-#if !defined(BOOST_NO_INTRINSIC_WCHAR_T)
-        template <> struct basic_numbers<wchar_t> :
-            boost::hash_detail::enable_hash_value {};
-#endif
-
-#if !defined(BOOST_NO_CXX11_CHAR16_T)
-        template <> struct basic_numbers<char16_t> :
-            boost::hash_detail::enable_hash_value {};
-#endif
-
-#if !defined(BOOST_NO_CXX11_CHAR32_T)
-        template <> struct basic_numbers<char32_t> :
-            boost::hash_detail::enable_hash_value {};
-#endif
-
-        // long_numbers is defined like this to allow for separate
-        // specialization for long_long and int128_type, in case
-        // they conflict.
-        template <typename T> struct long_numbers2 {};
-        template <typename T> struct ulong_numbers2 {};
-        template <typename T> struct long_numbers : long_numbers2<T> {};
-        template <typename T> struct ulong_numbers : ulong_numbers2<T> {};
-
-#if !defined(BOOST_NO_LONG_LONG)
-        template <> struct long_numbers<boost::long_long_type> :
-            boost::hash_detail::enable_hash_value {};
-        template <> struct ulong_numbers<boost::ulong_long_type> :
-            boost::hash_detail::enable_hash_value {};
-#endif
-
-#if defined(BOOST_HAS_INT128)
-        template <> struct long_numbers2<boost::int128_type> :
-            boost::hash_detail::enable_hash_value {};
-        template <> struct ulong_numbers2<boost::uint128_type> :
-            boost::hash_detail::enable_hash_value {};
-#endif
-
-        template <> struct float_numbers<float> :
-            boost::hash_detail::enable_hash_value {};
-        template <> struct float_numbers<double> :
-            boost::hash_detail::enable_hash_value {};
-        template <> struct float_numbers<long double> :
-            boost::hash_detail::enable_hash_value {};
-    }
-
-    template <typename T>
-    typename boost::hash_detail::basic_numbers<T>::type hash_value(T);
-    template <typename T>
-    typename boost::hash_detail::long_numbers<T>::type hash_value(T);
-    template <typename T>
-    typename boost::hash_detail::ulong_numbers<T>::type hash_value(T);
-
-    template <typename T>
-    typename boost::enable_if<boost::is_enum<T>, std::size_t>::type
-        hash_value(T);
-
-#if !BOOST_WORKAROUND(__DMC__, <= 0x848)
-    template <class T> std::size_t hash_value(T* const&);
-#else
-    template <class T> std::size_t hash_value(T*);
-#endif
-
-#if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
-    template< class T, unsigned N >
-    std::size_t hash_value(const T (&x)[N]);
-
-    template< class T, unsigned N >
-    std::size_t hash_value(T (&x)[N]);
-#endif
-
-    template <class Ch, class A>
-    std::size_t hash_value(
-        std::basic_string<Ch, std::BOOST_HASH_CHAR_TRAITS<Ch>, A> const&);
-
-#if BOOST_HASH_HAS_STRING_VIEW
-    template <class Ch>
-    std::size_t hash_value(
-        std::basic_string_view<Ch, std::BOOST_HASH_CHAR_TRAITS<Ch> > const&);
-#endif
-
-    template <typename T>
-    typename boost::hash_detail::float_numbers<T>::type hash_value(T);
-
-#if BOOST_HASH_HAS_OPTIONAL
-    template <typename T>
-    std::size_t hash_value(std::optional<T> const&);
-#endif
-
-#if BOOST_HASH_HAS_VARIANT
-    std::size_t hash_value(std::monostate);
-    template <typename... Types>
-    std::size_t hash_value(std::variant<Types...> const&);
-#endif
-
-#if !defined(BOOST_NO_CXX11_HDR_TYPEINDEX)
-    std::size_t hash_value(std::type_index);
-#endif
-
-#if !defined(BOOST_NO_CXX11_HDR_SYSTEM_ERROR)
-    std::size_t hash_value(std::error_code const&);
-    std::size_t hash_value(std::error_condition const&);
-#endif
-
-    // Implementation
-
-    namespace hash_detail
-    {
-        template <class T>
-        inline std::size_t hash_value_signed(T val)
-        {
-             const unsigned int size_t_bits = std::numeric_limits<std::size_t>::digits;
-             // ceiling(std::numeric_limits<T>::digits / size_t_bits) - 1
-             const int length = (std::numeric_limits<T>::digits - 1)
-                 / static_cast<int>(size_t_bits);
-
-             std::size_t seed = 0;
-             T positive = val < 0 ? -1 - val : val;
-
-             // Hopefully, this loop can be unrolled.
-             for(unsigned int i = length * size_t_bits; i > 0; i -= size_t_bits)
-             {
-                 seed ^= (std::size_t) (positive >> i) + (seed<<6) + (seed>>2);
-             }
-             seed ^= (std::size_t) val + (seed<<6) + (seed>>2);
-
-             return seed;
-        }
-
-        template <class T>
-        inline std::size_t hash_value_unsigned(T val)
-        {
-             const unsigned int size_t_bits = std::numeric_limits<std::size_t>::digits;
-             // ceiling(std::numeric_limits<T>::digits / size_t_bits) - 1
-             const int length = (std::numeric_limits<T>::digits - 1)
-                 / static_cast<int>(size_t_bits);
-
-             std::size_t seed = 0;
-
-             // Hopefully, this loop can be unrolled.
-             for(unsigned int i = length * size_t_bits; i > 0; i -= size_t_bits)
-             {
-                 seed ^= (std::size_t) (val >> i) + (seed<<6) + (seed>>2);
-             }
-             seed ^= (std::size_t) val + (seed<<6) + (seed>>2);
-
-             return seed;
-        }
-
-        template<std::size_t Bits> struct hash_combine_impl
-        {
-            template <typename SizeT>
-            inline static SizeT fn(SizeT seed, SizeT value)
-            {
-                seed ^= value + 0x9e3779b9 + (seed<<6) + (seed>>2);
-                return seed;
-            }
-        };
-
-        template<> struct hash_combine_impl<32>
-        {
-            inline static boost::uint32_t fn(boost::uint32_t h1, boost::uint32_t k1)
-            {
-                const boost::uint32_t c1 = 0xcc9e2d51;
-                const boost::uint32_t c2 = 0x1b873593;
-
-                k1 *= c1;
-                k1 = BOOST_FUNCTIONAL_HASH_ROTL32(k1,15);
-                k1 *= c2;
-
-                h1 ^= k1;
-                h1 = BOOST_FUNCTIONAL_HASH_ROTL32(h1,13);
-                h1 = h1*5+0xe6546b64;
-
-                return h1;
-            }
-        };
-
-        template<> struct hash_combine_impl<64>
-        {
-            inline static boost::uint64_t fn(boost::uint64_t h, boost::uint64_t k)
-            {
-                const boost::uint64_t m = (boost::uint64_t(0xc6a4a793) << 32) + 0x5bd1e995;
-                const int r = 47;
-
-                k *= m;
-                k ^= k >> r;
-                k *= m;
-
-                h ^= k;
-                h *= m;
-
-                // Completely arbitrary number, to prevent 0's
-                // from hashing to 0.
-                h += 0xe6546b64;
-
-                return h;
-            }
-        };
-    }
-
-    template <typename T>
-    typename boost::hash_detail::basic_numbers<T>::type hash_value(T v)
-    {
-        return static_cast<std::size_t>(v);
-    }
-
-    template <typename T>
-    typename boost::hash_detail::long_numbers<T>::type hash_value(T v)
-    {
-        return hash_detail::hash_value_signed(v);
-    }
-
-    template <typename T>
-    typename boost::hash_detail::ulong_numbers<T>::type hash_value(T v)
-    {
-        return hash_detail::hash_value_unsigned(v);
-    }
-
-    template <typename T>
-    typename boost::enable_if<boost::is_enum<T>, std::size_t>::type
-        hash_value(T v)
-    {
-        return static_cast<std::size_t>(v);
-    }
-
-    // Implementation by Alberto Barbati and Dave Harris.
-#if !BOOST_WORKAROUND(__DMC__, <= 0x848)
-    template <class T> std::size_t hash_value(T* const& v)
-#else
-    template <class T> std::size_t hash_value(T* v)
-#endif
-    {
-#if defined(__VMS) && __INITIAL_POINTER_SIZE == 64
-    // for some reason ptrdiff_t on OpenVMS compiler with
-    // 64 bit is not 64 bit !!!
-        std::size_t x = static_cast<std::size_t>(
-           reinterpret_cast<long long int>(v));
-#else
-        std::size_t x = static_cast<std::size_t>(
-           reinterpret_cast<std::ptrdiff_t>(v));
-#endif
-        return x + (x >> 3);
-    }
-
-#if defined(BOOST_MSVC)
-#pragma warning(push)
-#if BOOST_MSVC <= 1400
-#pragma warning(disable:4267) // 'argument' : conversion from 'size_t' to
-                              // 'unsigned int', possible loss of data
-                              // A misguided attempt to detect 64-bit
-                              // incompatability.
-#endif
-#endif
-
-    template <class T>
-    inline void hash_combine(std::size_t& seed, T const& v)
-    {
-        boost::hash<T> hasher;
-        seed = boost::hash_detail::hash_combine_impl<sizeof(std::size_t) * CHAR_BIT>::fn(seed, hasher(v));
-    }
-
-#if defined(BOOST_MSVC)
-#pragma warning(pop)
-#endif
-
-    template <class It>
-    inline std::size_t hash_range(It first, It last)
-    {
-        std::size_t seed = 0;
-
-        for(; first != last; ++first)
-        {
-            hash_combine<typename std::iterator_traits<It>::value_type>(seed, *first);
-        }
-
-        return seed;
-    }
-
-    template <class It>
-    inline void hash_range(std::size_t& seed, It first, It last)
-    {
-        for(; first != last; ++first)
-        {
-            hash_combine<typename std::iterator_traits<It>::value_type>(seed, *first);
-        }
-    }
-
-#if BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x551))
-    template <class T>
-    inline std::size_t hash_range(T* first, T* last)
-    {
-        std::size_t seed = 0;
-
-        for(; first != last; ++first)
-        {
-            boost::hash<T> hasher;
-            seed ^= hasher(*first) + 0x9e3779b9 + (seed<<6) + (seed>>2);
-        }
-
-        return seed;
-    }
-
-    template <class T>
-    inline void hash_range(std::size_t& seed, T* first, T* last)
-    {
-        for(; first != last; ++first)
-        {
-            boost::hash<T> hasher;
-            seed ^= hasher(*first) + 0x9e3779b9 + (seed<<6) + (seed>>2);
-        }
-    }
-#endif
-
-#if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
-    template< class T, unsigned N >
-    inline std::size_t hash_value(const T (&x)[N])
-    {
-        return hash_range(x, x + N);
-    }
-
-    template< class T, unsigned N >
-    inline std::size_t hash_value(T (&x)[N])
-    {
-        return hash_range(x, x + N);
-    }
-#endif
-
-    template <class Ch, class A>
-    inline std::size_t hash_value(
-        std::basic_string<Ch, std::BOOST_HASH_CHAR_TRAITS<Ch>, A> const& v)
-    {
-        return hash_range(v.begin(), v.end());
-    }
-
-#if BOOST_HASH_HAS_STRING_VIEW
-    template <class Ch>
-    inline std::size_t hash_value(
-        std::basic_string_view<Ch, std::BOOST_HASH_CHAR_TRAITS<Ch> > const& v)
-    {
-        return hash_range(v.begin(), v.end());
-    }
-#endif
-
-    template <typename T>
-    typename boost::hash_detail::float_numbers<T>::type hash_value(T v)
-    {
-        return boost::hash_detail::float_hash_value(v);
-    }
-
-#if BOOST_HASH_HAS_OPTIONAL
-    template <typename T>
-    inline std::size_t hash_value(std::optional<T> const& v) {
-        if (!v) {
-            // Arbitray value for empty optional.
-            return 0x12345678;
-        } else {
-            boost::hash<T> hf;
-            return hf(*v);
-        }
-    }
-#endif
-
-#if BOOST_HASH_HAS_VARIANT
-    inline std::size_t hash_value(std::monostate) {
-        return 0x87654321;
-    }
-
-    template <typename... Types>
-    inline std::size_t hash_value(std::variant<Types...> const& v) {
-        std::size_t seed = 0;
-        hash_combine(seed, v.index());
-        std::visit([&seed](auto&& x) { hash_combine(seed, x); }, v);
-        return seed;
-    }
-#endif
-
-
-#if !defined(BOOST_NO_CXX11_HDR_TYPEINDEX)
-    inline std::size_t hash_value(std::type_index v)
-    {
-        return v.hash_code();
-    }
-#endif
-
-#if !defined(BOOST_NO_CXX11_HDR_SYSTEM_ERROR)
-    inline std::size_t hash_value(std::error_code const& v) {
-        std::size_t seed = 0;
-        hash_combine(seed, v.value());
-        hash_combine(seed, &v.category());
-        return seed;
-    }
-
-    inline std::size_t hash_value(std::error_condition const& v) {
-        std::size_t seed = 0;
-        hash_combine(seed, v.value());
-        hash_combine(seed, &v.category());
-        return seed;
-    }
-#endif
-
-    //
-    // boost::hash
-    //
-
-    // Define the specializations required by the standard. The general purpose
-    // boost::hash is defined later in extensions.hpp if
-    // BOOST_HASH_NO_EXTENSIONS is not defined.
-
-    // BOOST_HASH_SPECIALIZE - define a specialization for a type which is
-    // passed by copy.
-    //
-    // BOOST_HASH_SPECIALIZE_REF - define a specialization for a type which is
-    // passed by const reference.
-    //
-    // These are undefined later.
-
-#define BOOST_HASH_SPECIALIZE(type) \
-    template <> struct hash<type> \
-         : public boost::hash_detail::hash_base<type> \
-    { \
-        std::size_t operator()(type v) const \
-        { \
-            return boost::hash_value(v); \
-        } \
-    };
-
-#define BOOST_HASH_SPECIALIZE_REF(type) \
-    template <> struct hash<type> \
-         : public boost::hash_detail::hash_base<type> \
-    { \
-        std::size_t operator()(type const& v) const \
-        { \
-            return boost::hash_value(v); \
-        } \
-    };
-
-#define BOOST_HASH_SPECIALIZE_TEMPLATE_REF(type) \
-    struct hash<type> \
-         : public boost::hash_detail::hash_base<type> \
-    { \
-        std::size_t operator()(type const& v) const \
-        { \
-            return boost::hash_value(v); \
-        } \
-    };
-
-    BOOST_HASH_SPECIALIZE(bool)
-    BOOST_HASH_SPECIALIZE(char)
-    BOOST_HASH_SPECIALIZE(signed char)
-    BOOST_HASH_SPECIALIZE(unsigned char)
-#if !defined(BOOST_NO_INTRINSIC_WCHAR_T)
-    BOOST_HASH_SPECIALIZE(wchar_t)
-#endif
-#if !defined(BOOST_NO_CXX11_CHAR16_T)
-    BOOST_HASH_SPECIALIZE(char16_t)
-#endif
-#if !defined(BOOST_NO_CXX11_CHAR32_T)
-    BOOST_HASH_SPECIALIZE(char32_t)
-#endif
-    BOOST_HASH_SPECIALIZE(short)
-    BOOST_HASH_SPECIALIZE(unsigned short)
-    BOOST_HASH_SPECIALIZE(int)
-    BOOST_HASH_SPECIALIZE(unsigned int)
-    BOOST_HASH_SPECIALIZE(long)
-    BOOST_HASH_SPECIALIZE(unsigned long)
-
-    BOOST_HASH_SPECIALIZE(float)
-    BOOST_HASH_SPECIALIZE(double)
-    BOOST_HASH_SPECIALIZE(long double)
-
-    BOOST_HASH_SPECIALIZE_REF(std::string)
-#if !defined(BOOST_NO_STD_WSTRING) && !defined(BOOST_NO_INTRINSIC_WCHAR_T)
-    BOOST_HASH_SPECIALIZE_REF(std::wstring)
-#endif
-#if !defined(BOOST_NO_CXX11_CHAR16_T)
-    BOOST_HASH_SPECIALIZE_REF(std::basic_string<char16_t>)
-#endif
-#if !defined(BOOST_NO_CXX11_CHAR32_T)
-    BOOST_HASH_SPECIALIZE_REF(std::basic_string<char32_t>)
-#endif
-
-#if BOOST_HASH_HAS_STRING_VIEW
-    BOOST_HASH_SPECIALIZE_REF(std::string_view)
-#   if !defined(BOOST_NO_STD_WSTRING) && !defined(BOOST_NO_INTRINSIC_WCHAR_T)
-    BOOST_HASH_SPECIALIZE_REF(std::wstring_view)
-#   endif
-#   if !defined(BOOST_NO_CXX11_CHAR16_T)
-    BOOST_HASH_SPECIALIZE_REF(std::basic_string_view<char16_t>)
-#   endif
-#   if !defined(BOOST_NO_CXX11_CHAR32_T)
-    BOOST_HASH_SPECIALIZE_REF(std::basic_string_view<char32_t>)
-#   endif
-#endif
-
-#if !defined(BOOST_NO_LONG_LONG)
-    BOOST_HASH_SPECIALIZE(boost::long_long_type)
-    BOOST_HASH_SPECIALIZE(boost::ulong_long_type)
-#endif
-
-#if defined(BOOST_HAS_INT128)
-    BOOST_HASH_SPECIALIZE(boost::int128_type)
-    BOOST_HASH_SPECIALIZE(boost::uint128_type)
-#endif
-
-#if BOOST_HASH_HAS_OPTIONAL
-    template <typename T>
-    BOOST_HASH_SPECIALIZE_TEMPLATE_REF(std::optional<T>)
-#endif
-
-#if !defined(BOOST_HASH_HAS_VARIANT)
-    template <typename... T>
-    BOOST_HASH_SPECIALIZE_TEMPLATE_REF(std::variant<T...>)
-    BOOST_HASH_SPECIALIZE(std::monostate)
-#endif
-
-#if !defined(BOOST_NO_CXX11_HDR_TYPEINDEX)
-    BOOST_HASH_SPECIALIZE(std::type_index)
-#endif
-
-#undef BOOST_HASH_SPECIALIZE
-#undef BOOST_HASH_SPECIALIZE_REF
-#undef BOOST_HASH_SPECIALIZE_TEMPLATE_REF
-
-// Specializing boost::hash for pointers.
-
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
-
-    template <class T>
-    struct hash<T*>
-        : public boost::hash_detail::hash_base<T*>
-    {
-        std::size_t operator()(T* v) const
-        {
-#if !BOOST_WORKAROUND(__SUNPRO_CC, <= 0x590)
-            return boost::hash_value(v);
-#else
-            std::size_t x = static_cast<std::size_t>(
-                reinterpret_cast<std::ptrdiff_t>(v));
-
-            return x + (x >> 3);
-#endif
-        }
-    };
-
-#else
-
-    // For compilers without partial specialization, we define a
-    // boost::hash for all remaining types. But hash_impl is only defined
-    // for pointers in 'extensions.hpp' - so when BOOST_HASH_NO_EXTENSIONS
-    // is defined there will still be a compile error for types not supported
-    // in the standard.
-
-    namespace hash_detail
-    {
-        template <bool IsPointer>
-        struct hash_impl;
-
-        template <>
-        struct hash_impl<true>
-        {
-            template <class T>
-            struct inner
-                : public boost::hash_detail::hash_base<T>
-            {
-                std::size_t operator()(T val) const
-                {
-#if !BOOST_WORKAROUND(__SUNPRO_CC, <= 590)
-                    return boost::hash_value(val);
-#else
-                    std::size_t x = static_cast<std::size_t>(
-                        reinterpret_cast<std::ptrdiff_t>(val));
-
-                    return x + (x >> 3);
-#endif
-                }
-            };
-        };
-    }
-
-    template <class T> struct hash
-        : public boost::hash_detail::hash_impl<boost::is_pointer<T>::value>
-            ::BOOST_NESTED_TEMPLATE inner<T>
-    {
-    };
-
-#endif
-}
-
-#undef BOOST_HASH_CHAR_TRAITS
-#undef BOOST_FUNCTIONAL_HASH_ROTL32
-
-#if defined(BOOST_MSVC)
-#pragma warning(pop)
-#endif
-
-#endif // BOOST_FUNCTIONAL_HASH_HASH_HPP
-
-// Include this outside of the include guards in case the file is included
-// twice - once with BOOST_HASH_NO_EXTENSIONS defined, and then with it
-// undefined.
-
-#if !defined(BOOST_HASH_NO_EXTENSIONS) \
-    && !defined(BOOST_FUNCTIONAL_HASH_EXTENSIONS_HPP)
-#include <boost/container_hash/extensions.hpp>
-#endif

include/boost/container_hash/hash_fwd.hpp

@@ -1,36 +0,0 @@
-
-// Copyright 2005-2009 Daniel James.
-// 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)
-
-//  Based on Peter Dimov's proposal
-//  http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2005/n1756.pdf
-//  issue 6.18. 
-
-#if !defined(BOOST_FUNCTIONAL_HASH_FWD_HPP)
-#define BOOST_FUNCTIONAL_HASH_FWD_HPP
-
-#include <boost/config/workaround.hpp>
-#include <cstddef>
-
-#if defined(BOOST_HAS_PRAGMA_ONCE)
-#pragma once
-#endif
-
-
-namespace boost
-{
-    template <class T> struct hash;
-
-    template <class T> void hash_combine(std::size_t& seed, T const& v);
-
-    template <class It> std::size_t hash_range(It, It);
-    template <class It> void hash_range(std::size_t&, It, It);
-
-#if BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x551))
-    template <class T> inline std::size_t hash_range(T*, T*);
-    template <class T> inline void hash_range(std::size_t&, T*, T*);
-#endif
-}
-
-#endif

include/boost/functional/hash.hpp

@@ -3,4 +3,5 @@
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
-#include <boost/container_hash/hash.hpp>
+#include <boost/functional/hash/hash.hpp>
+

include/boost/functional/hash/detail/hash_float.hpp

@@ -11,9 +11,9 @@
 #pragma once
 #endif
 
-#include <boost/container_hash/detail/float_functions.hpp>
-#include <boost/container_hash/detail/limits.hpp>
-#include <boost/core/enable_if.hpp>
+#include <boost/functional/hash/detail/float_functions.hpp>
+#include <boost/functional/hash/detail/limits.hpp>
+#include <boost/utility/enable_if.hpp>
 #include <boost/integer/static_log2.hpp>
 #include <boost/cstdint.hpp>
 #include <boost/assert.hpp>
@@ -68,7 +68,7 @@ namespace boost
             std::size_t seed = 0;
 
             if (length >= sizeof(std::size_t)) {
-                std::memcpy(&seed, ptr, sizeof(std::size_t));
+                seed = *(std::size_t*) ptr;
                 length -= sizeof(std::size_t);
                 ptr += sizeof(std::size_t);
 
@@ -179,7 +179,7 @@ namespace boost
                 hash_float_combine(seed, part);
             }
 
-            hash_float_combine(seed, static_cast<std::size_t>(exp));
+            hash_float_combine(seed, exp);
 
             return seed;
         }
@@ -241,7 +241,7 @@ namespace boost
         template <class T>
         inline bool is_zero(T v)
         {
-#if !defined(__GNUC__) && !defined(__clang__)
+#if !defined(__GNUC__)
             return v == 0;
 #else
             // GCC's '-Wfloat-equal' will complain about comparing

include/boost/functional/hash/extensions.hpp

@@ -1,6 +1,284 @@
 
-// Copyright 2017 Daniel James.
+// Copyright 2005-2009 Daniel James.
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
-#include <boost/container_hash/extensions.hpp>
+//  Based on Peter Dimov's proposal
+//  http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2005/n1756.pdf
+//  issue 6.18. 
+
+// This implements the extensions to the standard.
+// It's undocumented, so you shouldn't use it....
+
+#if !defined(BOOST_FUNCTIONAL_HASH_EXTENSIONS_HPP)
+#define BOOST_FUNCTIONAL_HASH_EXTENSIONS_HPP
+
+#include <boost/config.hpp>
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+#pragma once
+#endif
+
+#include <boost/functional/hash/hash.hpp>
+#include <boost/detail/container_fwd.hpp>
+#include <boost/utility/enable_if.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/preprocessor/repetition/repeat_from_to.hpp>
+#include <boost/preprocessor/repetition/enum_params.hpp>
+
+#if !defined(BOOST_NO_CXX11_HDR_ARRAY)
+#   include <array>
+#endif
+
+#if !defined(BOOST_NO_CXX11_HDR_TUPLE)
+#   include <tuple>
+#endif
+
+#if !defined(BOOST_NO_CXX11_HDR_MEMORY)
+#   include <memory>
+#endif
+
+#if defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
+#include <boost/type_traits/is_array.hpp>
+#endif
+
+namespace boost
+{
+    template <class A, class B>
+    std::size_t hash_value(std::pair<A, B> const&);
+    template <class T, class A>
+    std::size_t hash_value(std::vector<T, A> const&);
+    template <class T, class A>
+    std::size_t hash_value(std::list<T, A> const& v);
+    template <class T, class A>
+    std::size_t hash_value(std::deque<T, A> const& v);
+    template <class K, class C, class A>
+    std::size_t hash_value(std::set<K, C, A> const& v);
+    template <class K, class C, class A>
+    std::size_t hash_value(std::multiset<K, C, A> const& v);
+    template <class K, class T, class C, class A>
+    std::size_t hash_value(std::map<K, T, C, A> const& v);
+    template <class K, class T, class C, class A>
+    std::size_t hash_value(std::multimap<K, T, C, A> const& v);
+
+    template <class T>
+    std::size_t hash_value(std::complex<T> const&);
+
+    template <class A, class B>
+    std::size_t hash_value(std::pair<A, B> const& v)
+    {
+        std::size_t seed = 0;
+        boost::hash_combine(seed, v.first);
+        boost::hash_combine(seed, v.second);
+        return seed;
+    }
+
+    template <class T, class A>
+    std::size_t hash_value(std::vector<T, A> const& v)
+    {
+        return boost::hash_range(v.begin(), v.end());
+    }
+
+    template <class T, class A>
+    std::size_t hash_value(std::list<T, A> const& v)
+    {
+        return boost::hash_range(v.begin(), v.end());
+    }
+
+    template <class T, class A>
+    std::size_t hash_value(std::deque<T, A> const& v)
+    {
+        return boost::hash_range(v.begin(), v.end());
+    }
+
+    template <class K, class C, class A>
+    std::size_t hash_value(std::set<K, C, A> const& v)
+    {
+        return boost::hash_range(v.begin(), v.end());
+    }
+
+    template <class K, class C, class A>
+    std::size_t hash_value(std::multiset<K, C, A> const& v)
+    {
+        return boost::hash_range(v.begin(), v.end());
+    }
+
+    template <class K, class T, class C, class A>
+    std::size_t hash_value(std::map<K, T, C, A> const& v)
+    {
+        return boost::hash_range(v.begin(), v.end());
+    }
+
+    template <class K, class T, class C, class A>
+    std::size_t hash_value(std::multimap<K, T, C, A> const& v)
+    {
+        return boost::hash_range(v.begin(), v.end());
+    }
+
+    template <class T>
+    std::size_t hash_value(std::complex<T> const& v)
+    {
+        boost::hash<T> hasher;
+        std::size_t seed = hasher(v.imag());
+        seed ^= hasher(v.real()) + (seed<<6) + (seed>>2);
+        return seed;
+    }
+
+#if !defined(BOOST_NO_CXX11_HDR_ARRAY)
+    template <class T, std::size_t N>
+    std::size_t hash_value(std::array<T, N> const& v)
+    {
+        return boost::hash_range(v.begin(), v.end());
+    }
+#endif
+
+#if !defined(BOOST_NO_CXX11_HDR_TUPLE)
+    namespace hash_detail {
+        template <std::size_t I, typename T>
+        inline typename boost::enable_if_c<(I == std::tuple_size<T>::value),
+                void>::type
+            hash_combine_tuple(std::size_t&, T const&)
+        {
+        }
+
+        template <std::size_t I, typename T>
+        inline typename boost::enable_if_c<(I < std::tuple_size<T>::value),
+                void>::type
+            hash_combine_tuple(std::size_t& seed, T const& v)
+        {
+            boost::hash_combine(seed, std::get<I>(v));
+            boost::hash_detail::hash_combine_tuple<I + 1>(seed, v);
+        }
+
+        template <typename T>
+        inline std::size_t hash_tuple(T const& v)
+        {
+            std::size_t seed = 0;
+            boost::hash_detail::hash_combine_tuple<0>(seed, v);
+            return seed;
+        }
+    }
+
+#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+    template <typename... T>
+    inline std::size_t hash_value(std::tuple<T...> const& v)
+    {
+        return boost::hash_detail::hash_tuple(v);
+    }
+#else
+
+    inline std::size_t hash_value(std::tuple<> const& v)
+    {
+        return boost::hash_detail::hash_tuple(v);
+    }
+
+#   define BOOST_HASH_TUPLE_F(z, n, _)                                      \
+    template<                                                               \
+        BOOST_PP_ENUM_PARAMS_Z(z, n, typename A)                            \
+    >                                                                       \
+    inline std::size_t hash_value(std::tuple<                               \
+        BOOST_PP_ENUM_PARAMS_Z(z, n, A)                                     \
+    > const& v)                                                             \
+    {                                                                       \
+        return boost::hash_detail::hash_tuple(v);                           \
+    }
+
+    BOOST_PP_REPEAT_FROM_TO(1, 11, BOOST_HASH_TUPLE_F, _)
+#   undef BOOST_HASH_TUPLE_F
+#endif
+
+#endif
+
+#if !defined(BOOST_NO_CXX11_SMART_PTR)
+    template <typename T>
+    inline std::size_t hash_value(std::shared_ptr<T> const& x) {
+        return boost::hash_value(x.get());
+    }
+
+    template <typename T, typename Deleter>
+    inline std::size_t hash_value(std::unique_ptr<T, Deleter> const& x) {
+        return boost::hash_value(x.get());
+    }
+#endif
+
+    //
+    // call_hash_impl
+    //
+
+    // On compilers without function template ordering, this deals with arrays.
+
+#if defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
+    namespace hash_detail
+    {
+        template <bool IsArray>
+        struct call_hash_impl
+        {
+            template <class T>
+            struct inner
+            {
+                static std::size_t call(T const& v)
+                {
+                    using namespace boost;
+                    return hash_value(v);
+                }
+            };
+        };
+
+        template <>
+        struct call_hash_impl<true>
+        {
+            template <class Array>
+            struct inner
+            {
+                static std::size_t call(Array const& v)
+                {
+                    const int size = sizeof(v) / sizeof(*v);
+                    return boost::hash_range(v, v + size);
+                }
+            };
+        };
+
+        template <class T>
+        struct call_hash
+            : public call_hash_impl<boost::is_array<T>::value>
+                ::BOOST_NESTED_TEMPLATE inner<T>
+        {
+        };
+    }
+#endif // BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+
+    //
+    // boost::hash
+    //
+
+
+
+    template <class T> struct hash
+        : std::unary_function<T, std::size_t>
+    {
+#if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
+        std::size_t operator()(T const& val) const
+        {
+            return hash_value(val);
+        }
+#else
+        std::size_t operator()(T const& val) const
+        {
+            return hash_detail::call_hash<T>::call(val);
+        }
+#endif
+    };
+
+#if BOOST_WORKAROUND(__DMC__, <= 0x848)
+    template <class T, unsigned int n> struct hash<T[n]>
+        : std::unary_function<T[n], std::size_t>
+    {
+        std::size_t operator()(const T* val) const
+        {
+            return boost::hash_range(val, val+n);
+        }
+    };
+#endif
+
+}
+
+#endif

include/boost/functional/hash/hash.hpp

@@ -3,4 +3,443 @@
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
-#include <boost/container_hash/hash.hpp>
+//  Based on Peter Dimov's proposal
+//  http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2005/n1756.pdf
+//  issue 6.18. 
+
+#if !defined(BOOST_FUNCTIONAL_HASH_HASH_HPP)
+#define BOOST_FUNCTIONAL_HASH_HASH_HPP
+
+#include <boost/functional/hash/hash_fwd.hpp>
+#include <functional>
+#include <boost/functional/hash/detail/hash_float.hpp>
+#include <string>
+#include <boost/limits.hpp>
+#include <boost/type_traits/is_enum.hpp>
+#include <boost/type_traits/is_integral.hpp>
+#include <boost/utility/enable_if.hpp>
+
+
+#if !defined(BOOST_NO_CXX11_HDR_TYPEINDEX)
+#include <typeindex>
+#endif
+
+#if defined(BOOST_MSVC)
+#pragma warning(push)
+
+#if BOOST_MSVC >= 1400
+#pragma warning(disable:6295) // Ill-defined for-loop : 'unsigned int' values
+                              // are always of range '0' to '4294967295'.
+                              // Loop executes infinitely.
+#endif
+
+#endif
+
+namespace boost
+{
+    namespace hash_detail
+    {
+        struct enable_hash_value { typedef std::size_t type; };
+
+        template <typename T> struct basic_numbers {};
+        template <typename T> struct long_numbers;
+        template <typename T> struct ulong_numbers;
+        template <typename T> struct float_numbers {};
+
+        template <> struct basic_numbers<bool> :
+            boost::hash_detail::enable_hash_value {};
+        template <> struct basic_numbers<char> :
+            boost::hash_detail::enable_hash_value {};
+        template <> struct basic_numbers<unsigned char> :
+            boost::hash_detail::enable_hash_value {};
+        template <> struct basic_numbers<signed char> :
+            boost::hash_detail::enable_hash_value {};
+        template <> struct basic_numbers<short> :
+            boost::hash_detail::enable_hash_value {};
+        template <> struct basic_numbers<unsigned short> :
+            boost::hash_detail::enable_hash_value {};
+        template <> struct basic_numbers<int> :
+            boost::hash_detail::enable_hash_value {};
+        template <> struct basic_numbers<unsigned int> :
+            boost::hash_detail::enable_hash_value {};
+        template <> struct basic_numbers<long> :
+            boost::hash_detail::enable_hash_value {};
+        template <> struct basic_numbers<unsigned long> :
+            boost::hash_detail::enable_hash_value {};
+
+#if !defined(BOOST_NO_INTRINSIC_WCHAR_T)
+        template <> struct basic_numbers<wchar_t> :
+            boost::hash_detail::enable_hash_value {};
+#endif
+
+        // long_numbers is defined like this to allow for separate
+        // specialization for long_long and int128_type, in case
+        // they conflict.
+        template <typename T> struct long_numbers2 {};
+        template <typename T> struct ulong_numbers2 {};
+        template <typename T> struct long_numbers : long_numbers2<T> {};
+        template <typename T> struct ulong_numbers : ulong_numbers2<T> {};
+
+#if !defined(BOOST_NO_LONG_LONG)
+        template <> struct long_numbers<boost::long_long_type> :
+            boost::hash_detail::enable_hash_value {};
+        template <> struct ulong_numbers<boost::ulong_long_type> :
+            boost::hash_detail::enable_hash_value {};
+#endif
+
+#if defined(BOOST_HAS_INT128)
+        template <> struct long_numbers2<boost::int128_type> :
+            boost::hash_detail::enable_hash_value {};
+        template <> struct ulong_numbers2<boost::uint128_type> :
+            boost::hash_detail::enable_hash_value {};
+#endif
+
+        template <> struct float_numbers<float> :
+            boost::hash_detail::enable_hash_value {};
+        template <> struct float_numbers<double> :
+            boost::hash_detail::enable_hash_value {};
+        template <> struct float_numbers<long double> :
+            boost::hash_detail::enable_hash_value {};
+    }
+
+    template <typename T>
+    typename boost::hash_detail::basic_numbers<T>::type hash_value(T);
+    template <typename T>
+    typename boost::hash_detail::long_numbers<T>::type hash_value(T);
+    template <typename T>
+    typename boost::hash_detail::ulong_numbers<T>::type hash_value(T);
+
+    template <typename T>
+    typename boost::enable_if<boost::is_enum<T>, std::size_t>::type
+        hash_value(T);
+
+#if !BOOST_WORKAROUND(__DMC__, <= 0x848)
+    template <class T> std::size_t hash_value(T* const&);
+#else
+    template <class T> std::size_t hash_value(T*);
+#endif
+
+#if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
+    template< class T, unsigned N >
+    std::size_t hash_value(const T (&x)[N]);
+
+    template< class T, unsigned N >
+    std::size_t hash_value(T (&x)[N]);
+#endif
+
+    template <class Ch, class A>
+    std::size_t hash_value(
+        std::basic_string<Ch, std::char_traits<Ch>, A> const&);
+
+    template <typename T>
+    typename boost::hash_detail::float_numbers<T>::type hash_value(T);
+
+#if !defined(BOOST_NO_CXX11_HDR_TYPEINDEX)
+    std::size_t hash_value(std::type_index);
+#endif
+
+    // Implementation
+
+    namespace hash_detail
+    {
+        template <class T>
+        inline std::size_t hash_value_signed(T val)
+        {
+             const int size_t_bits = std::numeric_limits<std::size_t>::digits;
+             // ceiling(std::numeric_limits<T>::digits / size_t_bits) - 1
+             const int length = (std::numeric_limits<T>::digits - 1)
+                 / size_t_bits;
+
+             std::size_t seed = 0;
+             T positive = val < 0 ? -1 - val : val;
+
+             // Hopefully, this loop can be unrolled.
+             for(unsigned int i = length * size_t_bits; i > 0; i -= size_t_bits)
+             {
+                 seed ^= (std::size_t) (positive >> i) + (seed<<6) + (seed>>2);
+             }
+             seed ^= (std::size_t) val + (seed<<6) + (seed>>2);
+
+             return seed;
+        }
+
+        template <class T>
+        inline std::size_t hash_value_unsigned(T val)
+        {
+             const int size_t_bits = std::numeric_limits<std::size_t>::digits;
+             // ceiling(std::numeric_limits<T>::digits / size_t_bits) - 1
+             const int length = (std::numeric_limits<T>::digits - 1)
+                 / size_t_bits;
+
+             std::size_t seed = 0;
+
+             // Hopefully, this loop can be unrolled.
+             for(unsigned int i = length * size_t_bits; i > 0; i -= size_t_bits)
+             {
+                 seed ^= (std::size_t) (val >> i) + (seed<<6) + (seed>>2);
+             }
+             seed ^= (std::size_t) val + (seed<<6) + (seed>>2);
+
+             return seed;
+        }
+    }
+
+    template <typename T>
+    typename boost::hash_detail::basic_numbers<T>::type hash_value(T v)
+    {
+        return static_cast<std::size_t>(v);
+    }
+
+    template <typename T>
+    typename boost::hash_detail::long_numbers<T>::type hash_value(T v)
+    {
+        return hash_detail::hash_value_signed(v);
+    }
+
+    template <typename T>
+    typename boost::hash_detail::ulong_numbers<T>::type hash_value(T v)
+    {
+        return hash_detail::hash_value_unsigned(v);
+    }
+
+    template <typename T>
+    typename boost::enable_if<boost::is_enum<T>, std::size_t>::type
+        hash_value(T v)
+    {
+        return static_cast<std::size_t>(v);
+    }
+
+    // Implementation by Alberto Barbati and Dave Harris.
+#if !BOOST_WORKAROUND(__DMC__, <= 0x848)
+    template <class T> std::size_t hash_value(T* const& v)
+#else
+    template <class T> std::size_t hash_value(T* v)
+#endif
+    {
+#if defined(__VMS) && __INITIAL_POINTER_SIZE == 64
+    // for some reason ptrdiff_t on OpenVMS compiler with
+    // 64 bit is not 64 bit !!!
+        std::size_t x = static_cast<std::size_t>(
+           reinterpret_cast<long long int>(v));
+#else
+        std::size_t x = static_cast<std::size_t>(
+           reinterpret_cast<std::ptrdiff_t>(v));
+#endif
+        return x + (x >> 3);
+    }
+
+#if defined(BOOST_MSVC)
+#pragma warning(push)
+#if BOOST_MSVC <= 1400
+#pragma warning(disable:4267) // 'argument' : conversion from 'size_t' to
+                              // 'unsigned int', possible loss of data
+                              // A misguided attempt to detect 64-bit
+                              // incompatability.
+#endif
+#endif
+
+    template <class T>
+    inline void hash_combine(std::size_t& seed, T const& v)
+    {
+        boost::hash<T> hasher;
+        seed ^= hasher(v) + 0x9e3779b9 + (seed<<6) + (seed>>2);
+    }
+
+#if defined(BOOST_MSVC)
+#pragma warning(pop)
+#endif
+
+    template <class It>
+    inline std::size_t hash_range(It first, It last)
+    {
+        std::size_t seed = 0;
+
+        for(; first != last; ++first)
+        {
+            hash_combine(seed, *first);
+        }
+
+        return seed;
+    }
+
+    template <class It>
+    inline void hash_range(std::size_t& seed, It first, It last)
+    {
+        for(; first != last; ++first)
+        {
+            hash_combine(seed, *first);
+        }
+    }
+
+#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))
+    template <class T>
+    inline std::size_t hash_range(T* first, T* last)
+    {
+        std::size_t seed = 0;
+
+        for(; first != last; ++first)
+        {
+            boost::hash<T> hasher;
+            seed ^= hasher(*first) + 0x9e3779b9 + (seed<<6) + (seed>>2);
+        }
+
+        return seed;
+    }
+
+    template <class T>
+    inline void hash_range(std::size_t& seed, T* first, T* last)
+    {
+        for(; first != last; ++first)
+        {
+            boost::hash<T> hasher;
+            seed ^= hasher(*first) + 0x9e3779b9 + (seed<<6) + (seed>>2);
+        }
+    }
+#endif
+
+#if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
+    template< class T, unsigned N >
+    inline std::size_t hash_value(const T (&x)[N])
+    {
+        return hash_range(x, x + N);
+    }
+
+    template< class T, unsigned N >
+    inline std::size_t hash_value(T (&x)[N])
+    {
+        return hash_range(x, x + N);
+    }
+#endif
+
+    template <class Ch, class A>
+    inline std::size_t hash_value(
+        std::basic_string<Ch, std::char_traits<Ch>, A> const& v)
+    {
+        return hash_range(v.begin(), v.end());
+    }
+
+    template <typename T>
+    typename boost::hash_detail::float_numbers<T>::type hash_value(T v)
+    {
+        return boost::hash_detail::float_hash_value(v);
+    }
+
+#if !defined(BOOST_NO_CXX11_HDR_TYPEINDEX)
+    inline std::size_t hash_value(std::type_index v)
+    {
+        return v.hash_code();
+    }
+#endif
+
+    //
+    // boost::hash
+    //
+    
+    // Define the specializations required by the standard. The general purpose
+    // boost::hash is defined later in extensions.hpp if
+    // BOOST_HASH_NO_EXTENSIONS is not defined.
+    
+    // BOOST_HASH_SPECIALIZE - define a specialization for a type which is
+    // passed by copy.
+    //
+    // BOOST_HASH_SPECIALIZE_REF - define a specialization for a type which is
+    // passed by copy.
+    //
+    // These are undefined later.
+
+#define BOOST_HASH_SPECIALIZE(type) \
+    template <> struct hash<type> \
+         : public std::unary_function<type, std::size_t> \
+    { \
+        std::size_t operator()(type v) const \
+        { \
+            return boost::hash_value(v); \
+        } \
+    };
+
+#define BOOST_HASH_SPECIALIZE_REF(type) \
+    template <> struct hash<type> \
+         : public std::unary_function<type, std::size_t> \
+    { \
+        std::size_t operator()(type const& v) const \
+        { \
+            return boost::hash_value(v); \
+        } \
+    };
+
+    BOOST_HASH_SPECIALIZE(bool)
+    BOOST_HASH_SPECIALIZE(char)
+    BOOST_HASH_SPECIALIZE(signed char)
+    BOOST_HASH_SPECIALIZE(unsigned char)
+#if !defined(BOOST_NO_INTRINSIC_WCHAR_T)
+    BOOST_HASH_SPECIALIZE(wchar_t)
+#endif
+    BOOST_HASH_SPECIALIZE(short)
+    BOOST_HASH_SPECIALIZE(unsigned short)
+    BOOST_HASH_SPECIALIZE(int)
+    BOOST_HASH_SPECIALIZE(unsigned int)
+    BOOST_HASH_SPECIALIZE(long)
+    BOOST_HASH_SPECIALIZE(unsigned long)
+
+    BOOST_HASH_SPECIALIZE(float)
+    BOOST_HASH_SPECIALIZE(double)
+    BOOST_HASH_SPECIALIZE(long double)
+
+    BOOST_HASH_SPECIALIZE_REF(std::string)
+#if !defined(BOOST_NO_STD_WSTRING)
+    BOOST_HASH_SPECIALIZE_REF(std::wstring)
+#endif
+
+#if !defined(BOOST_NO_LONG_LONG)
+    BOOST_HASH_SPECIALIZE(boost::long_long_type)
+    BOOST_HASH_SPECIALIZE(boost::ulong_long_type)
+#endif
+
+#if defined(BOOST_HAS_INT128)
+    BOOST_HASH_SPECIALIZE(boost::int128_type)
+    BOOST_HASH_SPECIALIZE(boost::uint128_type)
+#endif
+
+#if !defined(BOOST_NO_CXX11_HDR_TYPEINDEX)
+    BOOST_HASH_SPECIALIZE(std::type_index)
+#endif
+
+#undef BOOST_HASH_SPECIALIZE
+#undef BOOST_HASH_SPECIALIZE_REF
+
+// Specializing boost::hash for pointers.
+
+
+    template <class T>
+    struct hash<T*>
+        : public std::unary_function<T*, std::size_t>
+    {
+        std::size_t operator()(T* v) const
+        {
+#if !BOOST_WORKAROUND(__SUNPRO_CC, <= 0x590)
+            return boost::hash_value(v);
+#else
+            std::size_t x = static_cast<std::size_t>(
+                reinterpret_cast<std::ptrdiff_t>(v));
+
+            return x + (x >> 3);
+#endif
+        }
+    };
+
+}
+
+#if defined(BOOST_MSVC)
+#pragma warning(pop)
+#endif
+
+#endif // BOOST_FUNCTIONAL_HASH_HASH_HPP
+
+// Include this outside of the include guards in case the file is included
+// twice - once with BOOST_HASH_NO_EXTENSIONS defined, and then with it
+// undefined.
+
+#if !defined(BOOST_HASH_NO_EXTENSIONS) \
+    && !defined(BOOST_FUNCTIONAL_HASH_EXTENSIONS_HPP)
+#include <boost/functional/hash/extensions.hpp>
+#endif

include/boost/functional/hash/hash_fwd.hpp

@@ -3,4 +3,34 @@
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
-#include <boost/container_hash/hash_fwd.hpp>
+//  Based on Peter Dimov's proposal
+//  http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2005/n1756.pdf
+//  issue 6.18. 
+
+#if !defined(BOOST_FUNCTIONAL_HASH_FWD_HPP)
+#define BOOST_FUNCTIONAL_HASH_FWD_HPP
+
+#include <boost/config.hpp>
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+#pragma once
+#endif
+
+#include <cstddef>
+#include <boost/detail/workaround.hpp>
+
+namespace boost
+{
+    template <class T> struct hash;
+
+    template <class T> void hash_combine(std::size_t& seed, T const& v);
+
+    template <class It> std::size_t hash_range(It, It);
+    template <class It> void hash_range(std::size_t&, It, It);
+
+#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))
+    template <class T> inline std::size_t hash_range(T*, T*);
+    template <class T> inline void hash_range(std::size_t&, T*, T*);
+#endif
+}
+
+#endif

include/boost/functional/hash_fwd.hpp

@@ -3,4 +3,9 @@
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
-#include <boost/container_hash/hash_fwd.hpp>
+#include <boost/config.hpp>
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+#pragma once
+#endif
+
+#include <boost/functional/hash/hash_fwd.hpp>

meta/explicit-failures-markup.xml

@@ -1,96 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!--
- Copyright 2018 Daniel James
- 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)
--->
-<explicit-failures-markup>
-    <!-- container_hash -->
-    <library name="container_hash">
-        <mark-expected-failures>
-            <test name="hash_value_array_test"/>
-            <toolset name="msvc-6.5*"/>
-            <toolset name="msvc-7.0*"/>
-            <note author="Daniel James">
-              hash_value is not overloaded for arrays for older versions
-              of Visual C++. There is a work around so that
-              boost::hash&lt;T[N]&gt;, boost::hash_combine and boost::hash_range
-              work.
-            </note>
-        </mark-expected-failures>
-
-        <mark-expected-failures>
-            <test name="hash_function_pointer_test"/>
-            <toolset name="msvc-6.5*"/>
-            <toolset name="msvc-7.0*"/>
-            <note refid="2" author="Daniel James"/>
-        </mark-expected-failures>
-
-        <mark-expected-failures>
-            <test name="hash_function_pointer_test"/>
-            <toolset name="sun-5.7"/>
-            <toolset name="sun-5.8"/>
-            <toolset name="sun-5.9"/>
-            <note author="Daniel James">
-                On these compilers the wrong overload of hash_value is called
-                when the argument is a hash function pointer. So calling
-                hash_value doesn't work but boost::hash does work (and it's
-                recommended that user never call hash_value directly so this
-                shouldn't be a problem).
-            </note>
-        </mark-expected-failures>
-
-        <mark-expected-failures>
-            <test name="hash_long_double_test"/>
-            <toolset name="gcc-3.4.3_sunos"/>
-            <toolset name="*pa_risc"/>
-            <note author="Daniel James">
-                This platform has poor support for <code>long double</code> so
-                the hash function perform poorly for values out of the range
-                of <code>double</code> or if they differ at a greater precision
-                that <code>double</code> is capable of representing.
-            </note>
-        </mark-expected-failures>
-
-        <mark-expected-failures>
-            <test name="point" />
-            <test name="books" />
-            <toolset name="msvc-6.5*"/>
-            <toolset name="msvc-7.0*"/>
-            <note author="Daniel James">
-                These examples only work on compilers with support for ADL.
-                It is possible to work around this, but I wanted to keep the
-                example code as clean as possible.
-            </note>
-        </mark-expected-failures>
-
-        <mark-expected-failures>
-            <test name="point" />
-            <toolset name="borland-*"/>
-            <note author="Daniel James">
-                It appears that Borland doesn't find friend functions defined
-                in a class by ADL. This is easily fixed but this example is
-                meant to show the typical way of customising boost::hash, not
-                the portable way.
-            </note>
-        </mark-expected-failures>
-
-        <mark-expected-failures>
-            <test name="hash_global_namespace_test" />
-            <toolset name="borland-*"/>
-            <note author="Daniel James">
-                The test demonstrates a Borland bug - functions that aren't
-                in a namespace don't appear to be found by ADL.
-            </note>
-        </mark-expected-failures>
-
-        <mark-expected-failures>
-            <test name="container_fwd_gcc_debug"/>
-            <toolset name="darwin-4.2"/>
-            <note author="Daniel James">
-              Debug containers aren't supported on Apple's version of gcc 4.2.
-            </note>
-        </mark-expected-failures>
-    </library>
-</explicit-failures-markup>

meta/libraries.json

@@ -1,21 +0,0 @@
-[
-    {
-        "key": "container_hash",
-        "boost-version": "1.33.0",
-        "name": "Container Hash",
-        "authors": [
-            "Daniel James"
-        ],
-        "maintainers": [
-            "Daniel James <dnljms -at- gmail.com>"
-        ],
-        "description": "An STL-compatible hash function object that can be extended to hash user defined types.",
-        "std": [
-            "tr1"
-        ],
-        "category": [
-            "Function-objects"
-        ],
-        "cxxstd": "03"
-    }
-]

test/Jamfile.v2

@@ -7,20 +7,18 @@ import testing ;
 
 project hash-tests
     : requirements
-        <warnings>pedantic
+        <warnings>all
         <toolset>intel:<warnings>on
-        <toolset>gcc:<cxxflags>"-Wstrict-aliasing -Wsign-promo -Wunused-parameter -Wconversion -Wfloat-equal -Wshadow"
-        <toolset>darwin:<cxxflags>"-Wstrict-aliasing -Wsign-promo -Wunused-parameter -Wconversion -Wfloat-equal -Wshadow"
-        <toolset>clang:<cxxflags>"-Wstrict-aliasing -Wsign-promo -Wunused-parameter -Wsign-conversion -Wconversion -Wfloat-equal -Wshadow"
-        <toolset>msvc:<warnings-as-errors>on
-        <toolset>gcc:<warnings-as-errors>on
-        <toolset>clang:<warnings-as-errors>on
+        #<toolset>intel:<cxxflags>-strict-ansi
+        <toolset>gcc:<cxxflags>"-pedantic -Wstrict-aliasing -fstrict-aliasing -Wextra -Wsign-promo -Wunused-parameter -Wconversion -Wfloat-equal -Wshadow"
+        <toolset>darwin:<cxxflags>"-pedantic -Wstrict-aliasing -fstrict-aliasing -Wextra -Wsign-promo -Wunused-parameter -Wconversion -Wfloat-equal -Wshadow"
+        #<toolset>msvc:<warnings-as-errors>on
+        #<toolset>gcc:<warnings-as-errors>on
+        #<toolset>darwin:<warnings-as-errors>on
     ;
 
-test-suite container_hash/hash
+test-suite functional/hash
     :
-        [ run hash_info.cpp : : : <test-info>always_show_run_output ]
-        [ compile check_float_funcs.cpp ]
         [ run hash_fwd_test_1.cpp ]
         [ run hash_fwd_test_2.cpp ]
         [ run hash_number_test.cpp ]
@@ -42,10 +40,7 @@ test-suite container_hash/hash
         [ run hash_set_test.cpp ]
         [ run hash_map_test.cpp ]
         [ run hash_complex_test.cpp ]
-        [ run hash_optional_test.cpp ]
-        [ run hash_variant_test.cpp ]
         [ run hash_type_index_test.cpp ]
-        [ run hash_system_error_test.cpp ]
         [ run hash_std_array_test.cpp ]
         [ run hash_std_tuple_test.cpp ]
         [ run hash_std_smart_ptr_test.cpp ]
@@ -59,7 +54,7 @@ test-suite container_hash/hash
         [ run hash_no_ext_macro_2.cpp ]
     ;
 
-test-suite container_hash/hash_no_ext
+test-suite functional/hash_no_ext
     :
         [ run hash_number_test.cpp : : : <define>BOOST_HASH_NO_EXTENSIONS : no_ext_number_test ]
         [ run hash_pointer_test.cpp : : : <define>BOOST_HASH_NO_EXTENSIONS : no_ext_pointer_test ]
@@ -72,7 +67,7 @@ test-suite container_hash/hash_no_ext
 
 # Tests to see if the floating point hash is using the binary hash.
 # Not run normally because on some platforms these should fail.
-test-suite container_hash/hash_no_generic_float
+test-suite functional/hash_no_generic_float
     :
         [ run hash_float_test.cpp
             : : : <define>BOOST_HASH_DETAIL_TEST_WITHOUT_GENERIC
@@ -81,8 +76,6 @@ test-suite container_hash/hash_no_generic_float
             : : : <define>BOOST_HASH_DETAIL_TEST_WITHOUT_GENERIC
             : hash_long_double_test_no_generic ]
     ;
-explicit container_hash/hash_no_generic_float ;
+explicit functional/hash_no_generic_float ;
 
 build-project ../examples ;
-
-run hash_reference_values.cpp ;

test/compile_time.hpp

@@ -5,16 +5,12 @@
 
 #include <boost/config.hpp>
 #include <boost/static_assert.hpp>
-#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/is_base_and_derived.hpp>
 
 template <class T>
 void compile_time_tests(T*)
 {
-    BOOST_STATIC_ASSERT((boost::is_same<T,
-        typename BOOST_HASH_TEST_NAMESPACE::hash<T>::argument_type
-    >::value));
-    BOOST_STATIC_ASSERT((boost::is_same<std::size_t,
-        typename BOOST_HASH_TEST_NAMESPACE::hash<T>::result_type
-    >::value));
+    BOOST_STATIC_ASSERT((boost::is_base_and_derived<
+        std::unary_function<T, std::size_t>, BOOST_HASH_TEST_NAMESPACE::hash<T> >::value));
 }
 

test/config.hpp

@@ -18,8 +18,4 @@
 // before doing anything else.
 #pragma warning(disable:4201)   // nonstandard extension used :
                                 // nameless struct/union
-
 #endif
-
-#define HASH_TEST_CAT(x, y) HASH_TEST_CAT2(x, y)
-#define HASH_TEST_CAT2(x, y) x##y

test/extensions_hpp_test.cpp

@@ -3,14 +3,14 @@
 // 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)
 
-// Check that boost/container_hash/extensions.hpp works okay.
+// Check that boost/functional/hash/extensions.hpp works okay.
 //
-// It probably should be in boost/container_hash/detail, but since it isn't it
+// It probably should be in boost/functional/hash/detail, but since it isn't it
 // should work.
 
 #include "./config.hpp"
 
-#include <boost/container_hash/extensions.hpp>
+#include <boost/functional/hash/extensions.hpp>
 
 int main() {
     int x[2] = { 2, 3 };

test/extra/Jamfile.v2

@@ -0,0 +1,13 @@
+
+# Copyright 2012 Daniel James.
+# Distributed under the Boost Software License, Version 1.0. (See accompanying
+# file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+import testing ;
+
+build-project .. ;
+
+test-suite functional/hash/config
+    :
+        [ compile check_float_funcs.cpp ]
+    ;

test/extra/check_float_funcs.cpp

@@ -3,11 +3,6 @@
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
-#if defined(__GNUC__)
-// in type_traits/is_complete.hpp:47
-#pragma GCC diagnostic ignored "-Wconversion"
-#endif
-
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/type_traits/is_convertible.hpp>

test/hash_built_in_array_test.cpp

@@ -9,11 +9,11 @@
 #  ifdef BOOST_HASH_TEST_STD_INCLUDES
 #    include <functional>
 #  else
-#    include <boost/container_hash/hash.hpp>
+#    include <boost/functional/hash.hpp>
 #  endif
 #endif
 
-#include <boost/core/lightweight_test.hpp>
+#include <boost/detail/lightweight_test.hpp>
 
 #ifdef BOOST_HASH_TEST_EXTENSIONS
 

test/hash_complex_test.cpp

@@ -14,10 +14,10 @@ int main() {}
 #ifdef BOOST_HASH_TEST_STD_INCLUDES
 #  include <functional>
 #else
-#  include <boost/container_hash/hash.hpp>
+#  include <boost/functional/hash.hpp>
 #endif
 
-#include <boost/core/lightweight_test.hpp>
+#include <boost/detail/lightweight_test.hpp>
 
 #if defined(BOOST_MSVC)
 #pragma warning(disable:4244)   // conversion from 'unsigned long' to
@@ -35,7 +35,7 @@ int main() {}
 #endif
 #endif
 
-#if ( defined(__GNUC__) || defined(__clang__) ) && !defined(BOOST_INTEL_CXX_VERSION)
+#if defined(__GNUC__) && !defined(BOOST_INTEL_CXX_VERSION)
 #pragma GCC diagnostic ignored "-Wfloat-equal"
 #endif
 
@@ -84,8 +84,8 @@ void complex_integral_tests(Integer*)
     generic_complex_tests(complex(15342,124));
     generic_complex_tests(complex(25,54356));
     generic_complex_tests(complex(5325,2346));
-    generic_complex_tests(complex(Integer(-243897),Integer(-49923874)));
-    generic_complex_tests(complex(Integer(-543),Integer(763)));
+    generic_complex_tests(complex(-243897,-49923874));
+    generic_complex_tests(complex(-543,763));
 }
 
 int main()

test/hash_custom_test.cpp

@@ -15,7 +15,7 @@ namespace test
 
         std::size_t hash() const
         {
-            return static_cast<std::size_t>(value_ * 10);
+            return value_ * 10;
         }
 
 #if !defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)
@@ -45,11 +45,11 @@ namespace boost
 #  ifdef BOOST_HASH_TEST_STD_INCLUDES
 #    include <functional>
 #  else
-#    include <boost/container_hash/hash.hpp>
+#    include <boost/functional/hash.hpp>
 #  endif
 #endif
 
-#include <boost/core/lightweight_test.hpp>
+#include <boost/detail/lightweight_test.hpp>
 
 #ifdef BOOST_HASH_TEST_EXTENSIONS
 

test/hash_deque_test.cpp

@@ -9,11 +9,11 @@
 #  ifdef BOOST_HASH_TEST_STD_INCLUDES
 #    include <functional>
 #  else
-#    include <boost/container_hash/hash.hpp>
+#    include <boost/functional/hash.hpp>
 #  endif
 #endif
 
-#include <boost/core/lightweight_test.hpp>
+#include <boost/detail/lightweight_test.hpp>
 
 #ifdef BOOST_HASH_TEST_EXTENSIONS
 

test/hash_enum_test.cpp

@@ -8,10 +8,10 @@
 #ifdef BOOST_HASH_TEST_STD_INCLUDES
 #  include <functional>
 #else
-#  include <boost/container_hash/hash.hpp>
+#  include <boost/functional/hash.hpp>
 #endif
 
-#include <boost/core/lightweight_test.hpp>
+#include <boost/detail/lightweight_test.hpp>
 #include "./compile_time.hpp"
 
 namespace test {

test/hash_float_test.hpp

@@ -8,15 +8,15 @@
 #ifdef BOOST_HASH_TEST_STD_INCLUDES
 #  include <functional>
 #else
-#  include <boost/container_hash/hash.hpp>
+#  include <boost/functional/hash.hpp>
 #endif
 
-#include <boost/core/lightweight_test.hpp>
+#include <boost/detail/lightweight_test.hpp>
 
 #include <cmath>
-#include <boost/container_hash/detail/limits.hpp>
-#include <boost/container_hash/detail/float_functions.hpp>
-#include <boost/config/workaround.hpp>
+#include <boost/functional/hash/detail/limits.hpp>
+#include <boost/functional/hash/detail/float_functions.hpp>
+#include <boost/detail/workaround.hpp>
 
 #include <iostream>
 
@@ -30,7 +30,7 @@
 #endif
 #endif
 
-#if ( defined(__GNUC__) || defined(__clang__) ) && !defined(BOOST_INTEL_CXX_VERSION)
+#if defined(__GNUC__) && !defined(BOOST_INTEL_CXX_VERSION)
 #pragma GCC diagnostic ignored "-Wfloat-equal"
 #endif
 
@@ -91,7 +91,7 @@ void float_tests(char const* name, T* = 0)
     using namespace std;
 
 // Doing anything with infinity causes borland to crash.
-#if defined(BOOST_BORLANDC)
+#if defined(__BORLANDC__)
     std::cerr
         <<  "Not running infinity checks on Borland, as it causes it to crash."
             "\n";
@@ -292,7 +292,7 @@ void float_tests(char const* name, T* = 0)
     }
 
 // NaN also causes borland to crash.
-#if !defined(BOOST_BORLANDC) && defined(BOOST_HASH_TEST_EXTENSIONS)
+#if !defined(__BORLANDC__) && defined(BOOST_HASH_TEST_EXTENSIONS)
     if(boost::hash_detail::limits<T>::has_quiet_NaN) {
         if(x1(boost::hash_detail::limits<T>::quiet_NaN()) == x1(1.0)) {
             std::cerr<<"x1(quiet_NaN) == x1(1.0) == "<<x1(1.0)<<"\n";

test/hash_friend_test.cpp

@@ -17,7 +17,7 @@ namespace test
 
         std::size_t hash() const
         {
-            return static_cast<std::size_t>(value_ * 10);
+            return value_ * 10;
         }
 
 #if !defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)
@@ -48,11 +48,11 @@ namespace boost
 #  ifdef BOOST_HASH_TEST_STD_INCLUDES
 #    include <functional>
 #  else
-#    include <boost/container_hash/hash.hpp>
+#    include <boost/functional/hash.hpp>
 #  endif
 #endif
 
-#include <boost/core/lightweight_test.hpp>
+#include <boost/detail/lightweight_test.hpp>
 
 #ifdef BOOST_HASH_TEST_EXTENSIONS
 

test/hash_function_pointer_test.cpp

@@ -8,10 +8,10 @@
 #ifdef BOOST_HASH_TEST_STD_INCLUDES
 #  include <functional>
 #else
-#  include <boost/container_hash/hash.hpp>
+#  include <boost/functional/hash.hpp>
 #endif
 
-#include <boost/core/lightweight_test.hpp>
+#include <boost/detail/lightweight_test.hpp>
 #include "./compile_time.hpp"
 
 void void_func1() { static int x = 1; ++x; }

test/hash_fwd_test.hpp

@@ -6,7 +6,7 @@
 #include "./config.hpp"
 
 #if defined(BOOST_HASH_TEST_EXTENSIONS) && !defined(BOOST_HASH_TEST_STD_INCLUDES)
-#include <boost/container_hash/hash_fwd.hpp>
+#include <boost/functional/hash_fwd.hpp>
 
 #include <boost/config.hpp>
 #include <cstddef>

test/hash_fwd_test_1.cpp

@@ -9,11 +9,11 @@
 
 #include "./hash_fwd_test.hpp"
 
-#include <boost/core/lightweight_test.hpp>
+#include <boost/detail/lightweight_test.hpp>
 
 #if defined(BOOST_HASH_TEST_EXTENSIONS) && !defined(BOOST_HASH_TEST_STD_INCLUDES)
 
-#include <boost/container_hash/hash.hpp>
+#include <boost/functional/hash.hpp>
 #include <string>
 
 void fwd_test1()

test/hash_fwd_test_2.cpp

@@ -15,7 +15,7 @@ int main() {}
 #else
 
 #include "./hash_fwd_test.hpp"
-#include <boost/core/lightweight_test.hpp>
+#include <boost/detail/lightweight_test.hpp>
 
 template <class T> void unused(T const&) {}
 

test/hash_global_namespace_test.cpp

@@ -17,7 +17,7 @@ struct custom
 
     std::size_t hash() const
     {
-        return static_cast<std::size_t>(value_ * 10);
+        return value_ * 10;
     }
 
 #if !defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)
@@ -46,11 +46,11 @@ namespace boost
 #  ifdef BOOST_HASH_TEST_STD_INCLUDES
 #    include <functional>
 #  else
-#    include <boost/container_hash/hash.hpp>
+#    include <boost/functional/hash.hpp>
 #  endif
 #endif
 
-#include <boost/core/lightweight_test.hpp>
+#include <boost/detail/lightweight_test.hpp>
 
 #ifdef BOOST_HASH_TEST_EXTENSIONS
 

test/hash_info.cpp

@@ -1,102 +0,0 @@
-
-// Copyright 2017 Daniel James.
-// 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)
-
-// Not a test, just a small program to write out configuration info
-
-#include <boost/container_hash/hash.hpp>
-#include <iostream>
-#include <algorithm>
-
-#if defined(BOOST_MSVC)
-
-struct msvc_version {
-    unsigned version;
-    char const* description;
-
-    friend bool operator<(msvc_version const& v1, msvc_version const& v2) {
-        return v1.version < v2.version;
-    }
-};
-
-void write_compiler_info() {
-    // From:
-    // https://en.wikipedia.org/wiki/Microsoft_Visual_C%2B%2B
-    // https://blogs.msdn.microsoft.com/vcblog/2017/11/15/side-by-side-minor-version-msvc-toolsets-in-visual-studio-2017/
-    msvc_version versions[] = {
-        {0, "Old Visual C++"},
-        {1000, "Visual C++ 4.x, VS4.0?"},
-        {1100, "Visual C++ 5.0, VS97"},
-        {1200, "Visual C++ 6.0, VS6.0"},
-        {1300, "Visual C++ 7.0, VS.NET 2002"},
-        {1310, "Visual C++ 7.1, VS.NET 2003"},
-        {1400, "Visual C++ 8.0, VS2005"},
-        {1500, "Visual C++ 9.0, VS2008"},
-        {1600, "Visual C++ 10.0, VS2010"},
-        {1700, "Visual C++ 11.0, VS2012"},
-        {1800, "Visual C++ 12.0, VS2013"},
-        {1900, "Visual C++ 14.00, VS2015"},
-        {1910, "Visual C++ 14.10, VS2017 15.1/2"},
-        {1911, "Visual C++ 14.11, VS2017 15.3/4"},
-        {1912, "Visual C++ 14.12, VS2017 15.5"},
-        {1913, "Visual C++ 14.13, VS2017 15.6"}
-    };
-
-    msvc_version msvc = { BOOST_MSVC, "" };
-    msvc_version* v = std::upper_bound(versions,
-        versions + sizeof(versions) / sizeof(*versions),
-        msvc) - 1;
-    unsigned difference = msvc.version - v->version;
-
-    std::cout << v->description << std::endl;
-    if (difference) {
-        std::cout << "+" << difference << std::endl;
-    }
-}
-
-#else
-
-void write_compiler_info() {
-}
-
-#endif
-
-int main() {
-    write_compiler_info();
-
-#if defined(__cplusplus)
-    std::cout << "__cplusplus: "
-        << __cplusplus
-        << std::endl;
-#endif
-
-    std::cout << "BOOST_HASH_CXX17: "
-        << BOOST_HASH_CXX17
-        << std::endl;
-
-    std::cout << "BOOST_HASH_HAS_STRING_VIEW: "
-        << BOOST_HASH_HAS_STRING_VIEW
-        << std::endl;
-
-    std::cout << "BOOST_HASH_HAS_OPTIONAL: "
-        << BOOST_HASH_HAS_OPTIONAL
-        << std::endl;
-
-    std::cout << "BOOST_HASH_HAS_VARIANT: "
-        << BOOST_HASH_HAS_VARIANT
-        << std::endl;
-
-#if defined(BOOST_NO_CXX11_HDR_TYPEINDEX)
-    std::cout << "No <typeindex>" << std::endl;
-#else
-    std::cout << "<typeindex>" << std::endl;
-#endif
-
-#if defined(BOOST_NO_CXX11_HDR_SYSTEM_ERROR)
-    std::cout << "No <system_error>" << std::endl;
-#else
-    std::cout << "<system_error>" << std::endl;
-#endif
-
-}

test/hash_list_test.cpp

@@ -9,11 +9,11 @@
 #  ifdef BOOST_HASH_TEST_STD_INCLUDES
 #    include <functional>
 #  else
-#    include <boost/container_hash/hash.hpp>
+#    include <boost/functional/hash.hpp>
 #  endif
 #endif
 
-#include <boost/core/lightweight_test.hpp>
+#include <boost/detail/lightweight_test.hpp>
 
 #ifdef BOOST_HASH_TEST_EXTENSIONS
 

test/hash_map_test.cpp

@@ -9,11 +9,11 @@
 #  ifdef BOOST_HASH_TEST_STD_INCLUDES
 #    include <functional>
 #  else
-#    include <boost/container_hash/hash.hpp>
+#    include <boost/functional/hash.hpp>
 #  endif
 #endif
 
-#include <boost/core/lightweight_test.hpp>
+#include <boost/detail/lightweight_test.hpp>
 
 #include <map>
 

test/hash_map_test.hpp

@@ -7,13 +7,15 @@
 #error "CONTAINER_TYPE not defined"
 #else
 
+#include <boost/preprocessor/cat.hpp>
+
 #if defined(BOOST_MSVC)
 #pragma warning(push)
 #pragma warning(disable:4244) // conversion from 'int' to 'float'
 #pragma warning(disable:4245) // signed/unsigned mismatch
 #endif
 
-namespace HASH_TEST_CAT(CONTAINER_TYPE, _tests)
+namespace BOOST_PP_CAT(CONTAINER_TYPE, _tests)
 {
     template <class T>
     void integer_tests(T* = 0)
@@ -57,7 +59,7 @@ namespace HASH_TEST_CAT(CONTAINER_TYPE, _tests)
         }
     }
 
-    void HASH_TEST_CAT(CONTAINER_TYPE, _hash_integer_tests())
+    void BOOST_PP_CAT(CONTAINER_TYPE, _hash_integer_tests())
     {
         integer_tests((CONTAINER_TYPE<char, unsigned char>*) 0);
         integer_tests((CONTAINER_TYPE<int, float>*) 0);

test/hash_no_ext_fail_test.cpp

@@ -14,7 +14,7 @@
 #ifdef BOOST_HASH_TEST_STD_INCLUDES
 #  include <functional>
 #else
-#  include <boost/container_hash/hash.hpp>
+#  include <boost/functional/hash.hpp>
 #endif
 
 template <class T> void ignore(T const&) {}

test/hash_no_ext_macro_1.cpp

@@ -11,14 +11,14 @@
 #  if defined(BOOST_HASH_NO_EXTENSIONS)
 #    undef BOOST_HASH_NO_EXTENSIONS
 #  endif
-#  include <boost/container_hash/hash.hpp>
+#  include <boost/functional/hash.hpp>
 
 // Include header with BOOST_HASH_NO_EXTENSIONS defined
 #  define BOOST_HASH_NO_EXTENSIONS
-#  include <boost/container_hash/hash.hpp>
+#  include <boost/functional/hash.hpp>
 #endif
 
-#include <boost/core/lightweight_test.hpp>
+#include <boost/detail/lightweight_test.hpp>
 #include <deque>
 
 int main()

test/hash_no_ext_macro_2.cpp

@@ -11,14 +11,14 @@
 #  if !defined(BOOST_HASH_NO_EXTENSIONS)
 #    define BOOST_HASH_NO_EXTENSIONS
 #  endif
-#  include <boost/container_hash/hash.hpp>
+#  include <boost/functional/hash.hpp>
 
 // Include header without BOOST_HASH_NO_EXTENSIONS defined
 #  undef BOOST_HASH_NO_EXTENSIONS
-#  include <boost/container_hash/hash.hpp>
+#  include <boost/functional/hash.hpp>
 #endif
 
-#include <boost/core/lightweight_test.hpp>
+#include <boost/detail/lightweight_test.hpp>
 #include <map>
 
 int main()

test/hash_number_test.cpp

@@ -8,14 +8,15 @@
 #ifdef BOOST_HASH_TEST_STD_INCLUDES
 #  include <functional>
 #else
-#  include <boost/container_hash/hash.hpp>
+#  include <boost/functional/hash.hpp>
 #endif
 
 #include <iostream>
-#include <boost/core/lightweight_test.hpp>
+#include <boost/detail/lightweight_test.hpp>
 
-#include <boost/container_hash/detail/limits.hpp>
-#include <boost/core/enable_if.hpp>
+#include <boost/preprocessor/cat.hpp>
+#include <boost/functional/hash/detail/limits.hpp>
+#include <boost/utility/enable_if.hpp>
 
 #include "./compile_time.hpp"
 
@@ -26,7 +27,7 @@
 #pragma warning(disable:4310) // cast truncates constant value
 #endif
 
-#if ( defined(__GNUC__) || defined(__clang__) ) && !defined(BOOST_INTEL_CXX_VERSION)
+#if defined(__GNUC__) && !defined(BOOST_INTEL_CXX_VERSION)
 #pragma GCC diagnostic ignored "-Wfloat-equal"
 #endif
 
@@ -57,6 +58,8 @@ void numeric_extra_tests(typename
 template <class T>
 void numeric_test(T*)
 {
+    typedef boost::hash_detail::limits<T> limits;
+
     compile_time_tests((T*) 0);
 
     BOOST_HASH_TEST_NAMESPACE::hash<T> x1;
@@ -126,20 +129,16 @@ void poor_quality_tests(T*)
         BOOST_TEST(x1(T(1)) !=  x2(T(-1)));
     if(T(1) != T(2))
         BOOST_TEST(x1(T(1)) !=  x2(T(2)));
-
-    // TODO: This test is useless for floating point numbers.
-    T max_number = static_cast<T>((limits::max)());
-    T max_minus_one = static_cast<T>(max_number - 1);
-    if (max_number != max_minus_one) {
-        BOOST_TEST(x1(max_number) != x1(max_minus_one));
-    }
+    if((limits::max)() != (limits::max)() - 1)
+        BOOST_TEST(x1(static_cast<T>((limits::max)()))
+            != x2(static_cast<T>((limits::max)() - 1)));
 }
 
 void bool_test()
 {
     BOOST_HASH_TEST_NAMESPACE::hash<bool> x1;
     BOOST_HASH_TEST_NAMESPACE::hash<bool> x2;
-
+    
     BOOST_TEST(x1(true) == x2(true));
     BOOST_TEST(x1(false) == x2(false));
     BOOST_TEST(x1(true) != x2(false));
@@ -163,12 +162,6 @@ int main()
     NUMERIC_TEST(unsigned char, uchar)
 #ifndef BOOST_NO_INTRINSIC_WCHAR_T
     NUMERIC_TEST(wchar_t, wchar)
-#endif
-#ifndef BOOST_NO_CXX11_CHAR16_T
-    NUMERIC_TEST(char16_t, char16)
-#endif
-#ifndef BOOST_NO_CXX11_CHAR32_T
-    NUMERIC_TEST(char32_t, char32)
 #endif
     NUMERIC_TEST(short, short)
     NUMERIC_TEST(unsigned short, ushort)

test/hash_optional_test.cpp

@@ -1,70 +0,0 @@
-
-// Copyright 2018 Daniel James
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#include "./config.hpp"
-
-#ifndef BOOST_HASH_TEST_STD_INCLUDES
-#  include <boost/container_hash/hash.hpp>
-#endif
-#include <boost/config.hpp>
-#include <boost/core/lightweight_test.hpp>
-
-#if BOOST_HASH_HAS_OPTIONAL
-
-#include <optional>
-#include <string>
-
-void test_optional_int()
-{
-    std::optional<int> x1a;
-    std::optional<int> x1b;
-    std::optional<int> x2a(10);
-    std::optional<int> x2b(x2a);
-    std::optional<int> x3(20);
-
-    boost::hash<std::optional<int> > hasher;
-
-    BOOST_TEST(hasher(x1a) == hasher(x1a));
-    BOOST_TEST(hasher(x1a) == hasher(x1b));
-    BOOST_TEST(hasher(x1a) != hasher(x2a));
-    BOOST_TEST(hasher(x1a) != hasher(x3));
-    BOOST_TEST(hasher(x2a) == hasher(x2a));
-    BOOST_TEST(hasher(x2b) == hasher(x2b));
-    BOOST_TEST(hasher(x2a) != hasher(x3));
-    BOOST_TEST(hasher(x3) == hasher(x3));
-}
-
-void test_optional_string()
-{
-    std::optional<std::string> x1a;
-    std::optional<std::string> x1b;
-    std::optional<std::string> x2a("10");
-    std::optional<std::string> x2b(x2a);
-    std::optional<std::string> x3("20");
-
-    boost::hash<std::optional<std::string> > hasher;
-
-    BOOST_TEST(hasher(x1a) == hasher(x1a));
-    BOOST_TEST(hasher(x1a) == hasher(x1b));
-    BOOST_TEST(hasher(x1a) != hasher(x2a));
-    BOOST_TEST(hasher(x1a) != hasher(x3));
-    BOOST_TEST(hasher(x2a) == hasher(x2a));
-    BOOST_TEST(hasher(x2b) == hasher(x2b));
-    BOOST_TEST(hasher(x2a) != hasher(x3));
-    BOOST_TEST(hasher(x3) == hasher(x3));
-}
-
-#endif
-
-int main()
-{
-#if BOOST_HASH_HAS_OPTIONAL
-    test_optional_int();
-    test_optional_string();
-#else
-    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "<optional> not available." << std::endl;
-#endif
-    return boost::report_errors();
-}

test/hash_pointer_test.cpp

@@ -8,10 +8,10 @@
 #ifdef BOOST_HASH_TEST_STD_INCLUDES
 #  include <functional>
 #else
-#  include <boost/container_hash/hash.hpp>
+#  include <boost/functional/hash.hpp>
 #endif
 
-#include <boost/core/lightweight_test.hpp>
+#include <boost/detail/lightweight_test.hpp>
 #include <boost/limits.hpp>
 #include "./compile_time.hpp"
 

test/hash_range_test.cpp

@@ -14,10 +14,10 @@ int main() {}
 #ifdef BOOST_HASH_TEST_STD_INCLUDES
 #  include <functional>
 #else
-#  include <boost/container_hash/hash.hpp>
+#  include <boost/functional/hash.hpp>
 #endif
 
-#include <boost/core/lightweight_test.hpp>
+#include <boost/detail/lightweight_test.hpp>
 #include <boost/limits.hpp>
 #include <vector>
 

test/hash_reference_values.cpp

@@ -1,495 +0,0 @@
-// Copyright 2021 Peter Dimov.
-// Distributed under the Boost Software License, Version 1.0.
-// https://www.boost.org/LICENSE_1_0.txt
-
-#include <boost/config/pragma_message.hpp>
-
-#if defined(__GNUC__) && !defined(__clang__) && __cplusplus < 201100L
-
-BOOST_PRAGMA_MESSAGE("Skipping test under GCC in C++98 mode")
-int main() {}
-
-#else
-
-#if defined(__clang__)
-# pragma clang diagnostic ignored "-Wlong-long"
-#endif
-
-#include <boost/container_hash/hash.hpp>
-#include <boost/core/lightweight_test.hpp>
-#include <string>
-#include <vector>
-#include <list>
-#include <utility>
-#include <complex>
-#include <limits>
-#include <climits>
-#include <cfloat>
-#include <cstddef>
-
-// This test checks whether hash values have changed
-
-template<class T> std::size_t hv( T const& t )
-{
-    return boost::hash<T>()( t );
-}
-
-int main()
-{
-    // char
-    BOOST_TEST_EQ( hv('\x00'), 0 );
-    BOOST_TEST_EQ( hv('A'), 'A' );
-    BOOST_TEST_EQ( hv('\x7F'), 0x7F );
-
-    // signed char
-    BOOST_TEST_EQ( hv((signed char)0), 0 );
-    BOOST_TEST_EQ( hv((signed char)+1), +1 );
-    BOOST_TEST_EQ( hv((signed char)-1), (std::size_t)-1 );
-    BOOST_TEST_EQ( hv((signed char)+127), 127 );
-    BOOST_TEST_EQ( hv((signed char)-128), (std::size_t)-128 );
-
-    // unsigned char
-    BOOST_TEST_EQ( hv((unsigned char)0), 0 );
-    BOOST_TEST_EQ( hv((unsigned char)1), 1 );
-    BOOST_TEST_EQ( hv((unsigned char)255), 255 );
-
-    // short
-    BOOST_TEST_EQ( hv((short)0), 0 );
-    BOOST_TEST_EQ( hv((short)+1), 1 );
-    BOOST_TEST_EQ( hv((short)-1), (std::size_t)-1 );
-    BOOST_TEST_EQ( hv((short)+32767), 32767 );
-    BOOST_TEST_EQ( hv((short)-32768), (std::size_t)-32768 );
-
-    // unsigned short
-    BOOST_TEST_EQ( hv((unsigned short)0), 0 );
-    BOOST_TEST_EQ( hv((unsigned short)1), 1 );
-    BOOST_TEST_EQ( hv((unsigned short)65535), 65535 );
-
-    // int
-    BOOST_TEST_EQ( hv(0), 0 );
-    BOOST_TEST_EQ( hv(+1), 1 );
-    BOOST_TEST_EQ( hv(-1), (std::size_t)-1 );
-    BOOST_TEST_EQ( hv(+32767), 32767 );
-    BOOST_TEST_EQ( hv(-32768), (std::size_t)-32768 );
-
-    // unsigned int
-    BOOST_TEST_EQ( hv((unsigned)0), 0 );
-    BOOST_TEST_EQ( hv((unsigned)1), 1 );
-    BOOST_TEST_EQ( hv((unsigned)65535), 65535 );
-    BOOST_TEST_EQ( hv((unsigned)-1), (std::size_t)(unsigned)-1 );
-
-    // long
-    BOOST_TEST_EQ( hv(0L), 0 );
-    BOOST_TEST_EQ( hv(+1L), 1 );
-    BOOST_TEST_EQ( hv(-1L), (std::size_t)-1 );
-    BOOST_TEST_EQ( hv(+32767L), 32767 );
-    BOOST_TEST_EQ( hv(-32768L), (std::size_t)-32768 );
-
-    // unsigned long
-    BOOST_TEST_EQ( hv(0UL), 0 );
-    BOOST_TEST_EQ( hv(1UL), 1 );
-    BOOST_TEST_EQ( hv(65535UL), 65535 );
-    BOOST_TEST_EQ( hv((unsigned long)-1), (std::size_t)(unsigned long)-1 );
-
-    // long long
-    BOOST_TEST_EQ( hv(0LL), 0 );
-    BOOST_TEST_EQ( hv(+1LL), 1 );
-    BOOST_TEST_EQ( hv(-1LL), (std::size_t)-1 );
-    BOOST_TEST_EQ( hv(+32767LL), 32767 );
-    BOOST_TEST_EQ( hv(-32768LL), (std::size_t)-32768 );
-
-    // unsigned long long
-    BOOST_TEST_EQ( hv(0ULL), 0 );
-    BOOST_TEST_EQ( hv(1ULL), 1 );
-    BOOST_TEST_EQ( hv(65535ULL), 65535 );
-#if SIZE_MAX == 4294967295U
-    BOOST_TEST_EQ( hv((unsigned long long)-1), 3221225537U );
-#else
-    BOOST_TEST_EQ( hv((unsigned long long)-1), (std::size_t)-1 );
-#endif
-
-#if defined(BOOST_HAS_INT128)
-
-    typedef boost::int128_type int128;
-
-    BOOST_TEST_EQ( hv((int128)0), 0 );
-    BOOST_TEST_EQ( hv((int128)1), 1 );
-    BOOST_TEST_EQ( hv((int128)-1), (std::size_t)-1 );
-    BOOST_TEST_EQ( hv((int128)+32767), 32767 );
-    BOOST_TEST_EQ( hv((int128)-32768), (std::size_t)-32768 );
-
-    typedef boost::uint128_type uint128;
-
-    BOOST_TEST_EQ( hv((uint128)0), 0 );
-    BOOST_TEST_EQ( hv((uint128)1), 1 );
-    BOOST_TEST_EQ( hv((uint128)65535), 65535 );
-
-#if defined(BOOST_GCC) && BOOST_GCC < 100000
-
-    // This looks like some sort of miscompilation.
-    // Under CI, both GHA and Appveyor GCCs produce this value.
-    // But the exact same test on godbolt.org produces the correct
-    // value, below.
-
-    // BOOST_TEST_EQ( hv((uint128)-1), 18446744073709551615ULL );
-
-#else
-
-    BOOST_TEST_EQ( hv((uint128)-1), 13835058055282163777ULL );
-
-#endif
-
-#endif
-
-    // float
-    BOOST_TEST_EQ( hv(0.0f), 0 );
-    BOOST_TEST_EQ( hv(-0.0f), 0 );
-    BOOST_TEST_EQ( hv(1.0f), 1065353216U );
-    BOOST_TEST_EQ( hv(-1.0f), 3212836864U );
-    BOOST_TEST_EQ( hv(3.14f), 1078523331U );
-    BOOST_TEST_EQ( hv(-3.14f), 3226006979U );
-    BOOST_TEST_EQ( hv(1e-38f), 7136238U );
-    BOOST_TEST_EQ( hv(-1e-38f), 2154619886U );
-    BOOST_TEST_EQ( hv(1e+38f), 2123789977U );
-    BOOST_TEST_EQ( hv(-1e+38f), 4271273625U );
-
-#if !defined(__GLIBCXX__)
-
-    BOOST_TEST_EQ( hv(std::numeric_limits<float>::infinity()), 2139095040U );
-    BOOST_TEST_EQ( hv(-std::numeric_limits<float>::infinity()), 4286578688U );
-
-#elif SIZE_MAX == 4294967295U
-
-    BOOST_TEST_EQ( hv(std::numeric_limits<float>::infinity()), 4294967295U );
-    BOOST_TEST_EQ( hv(-std::numeric_limits<float>::infinity()), 4294967294U );
-
-#else
-
-    BOOST_TEST_EQ( hv(std::numeric_limits<float>::infinity()), 18446744073709551615ULL );
-    BOOST_TEST_EQ( hv(-std::numeric_limits<float>::infinity()), 18446744073709551614ULL );
-
-#endif
-
-    // double
-    BOOST_TEST_EQ( hv(0.0), 0 );
-    BOOST_TEST_EQ( hv(-0.0), 0 );
-
-#if SIZE_MAX == 4294967295U
-
-    BOOST_TEST_EQ( hv(1.0), 1072693248U );
-    BOOST_TEST_EQ( hv(-1.0), 3220176896U );
-    BOOST_TEST_EQ( hv(3.14), 2660156064U );
-    BOOST_TEST_EQ( hv(-3.14), 512672416U );
-    BOOST_TEST_EQ( hv(1e-308), 1553872728U );
-    BOOST_TEST_EQ( hv(-1e-308), 3701356376U );
-    BOOST_TEST_EQ( hv(1e+308), 2577739707U );
-    BOOST_TEST_EQ( hv(-1e+308), 430256059U );
-
-#if !defined(__GLIBCXX__)
-
-    BOOST_TEST_EQ( hv(std::numeric_limits<double>::infinity()), 2146435072U );
-    BOOST_TEST_EQ( hv(-std::numeric_limits<double>::infinity()), 4293918720U );
-
-#else
-
-    BOOST_TEST_EQ( hv(std::numeric_limits<double>::infinity()), 4294967295U );
-    BOOST_TEST_EQ( hv(-std::numeric_limits<double>::infinity()), 4294967294U );
-
-#endif
-
-#else
-
-    BOOST_TEST_EQ( hv(1.0), 4607182418800017408ULL );
-    BOOST_TEST_EQ( hv(-1.0), 13830554455654793216ULL );
-    BOOST_TEST_EQ( hv(3.14), 4614253070214989087ULL );
-    BOOST_TEST_EQ( hv(-3.14), 13837625107069764895ULL );
-    BOOST_TEST_EQ( hv(1e-308), 2024022533073106ULL );
-    BOOST_TEST_EQ( hv(-1e-308), 9225396059387848914ULL );
-    BOOST_TEST_EQ( hv(1e+308), 9214871658872686752ULL );
-    BOOST_TEST_EQ( hv(-1e+308), 18438243695727462560ULL );
-
-#if !defined(__GLIBCXX__)
-
-    BOOST_TEST_EQ( hv(std::numeric_limits<double>::infinity()), 9218868437227405312ULL );
-    BOOST_TEST_EQ( hv(-std::numeric_limits<double>::infinity()), 18442240474082181120ULL );
-
-#else
-
-    BOOST_TEST_EQ( hv(std::numeric_limits<double>::infinity()), 18446744073709551615ULL );
-    BOOST_TEST_EQ( hv(-std::numeric_limits<double>::infinity()), 18446744073709551614ULL );
-
-#endif
-
-#endif
-
-    // long double
-    BOOST_TEST_EQ( hv(0.0L), 0 );
-    BOOST_TEST_EQ( hv(-0.0L), 0 );
-
-#if defined(_WIN32) && !defined(__GNUC__) // Under MS ABI, long double == double
-
-#if SIZE_MAX == 4294967295U
-
-    BOOST_TEST_EQ( hv(1.0L), 1072693248U );
-    BOOST_TEST_EQ( hv(-1.0L), 3220176896U );
-    BOOST_TEST_EQ( hv(3.14L), 2660156064U );
-    BOOST_TEST_EQ( hv(-3.14L), 512672416U );
-    BOOST_TEST_EQ( hv(std::numeric_limits<long double>::infinity()), 2146435072U );
-    BOOST_TEST_EQ( hv(-std::numeric_limits<long double>::infinity()), 4293918720U );
-
-#else
-
-    BOOST_TEST_EQ( hv(1.0L), 4607182418800017408ULL );
-    BOOST_TEST_EQ( hv(-1.0L), 13830554455654793216ULL );
-    BOOST_TEST_EQ( hv(3.14L), 4614253070214989087ULL );
-    BOOST_TEST_EQ( hv(-3.14L), 13837625107069764895ULL );
-    BOOST_TEST_EQ( hv(std::numeric_limits<long double>::infinity()), 9218868437227405312ULL );
-    BOOST_TEST_EQ( hv(-std::numeric_limits<long double>::infinity()), 18442240474082181120ULL );
-
-#endif
-
-#else
-
-#if SIZE_MAX == 4294967295U
-
-    BOOST_TEST_EQ( hv(1.0L), 2684370943U );
-    BOOST_TEST_EQ( hv(-1.0L), 2684403711U );
-    BOOST_TEST_EQ( hv(3.14L), 83002659U );
-    BOOST_TEST_EQ( hv(-3.14L), 82969891U );
-
-#if !defined(__GLIBCXX__)
-
-    BOOST_TEST_EQ( hv(std::numeric_limits<long double>::infinity()), 0xA0007FFFu );
-    BOOST_TEST_EQ( hv(-std::numeric_limits<long double>::infinity()), 0xA000FFFFu );
-
-#else
-
-    BOOST_TEST_EQ( hv(std::numeric_limits<long double>::infinity()), 4294967295U );
-    BOOST_TEST_EQ( hv(-std::numeric_limits<long double>::infinity()), 4294967294U );
-
-#endif
-
-#else
-
-    BOOST_TEST_EQ( hv(1.0L), 11529215046068486143ULL );
-    BOOST_TEST_EQ( hv(-1.0L), 11529215046068518911ULL );
-    BOOST_TEST_EQ( hv(3.14L), 12059468778148142067ULL );
-    BOOST_TEST_EQ( hv(-3.14L), 12059468778147191795ULL );
-
-#if !defined(__GLIBCXX__)
-
-    BOOST_TEST_EQ( hv(std::numeric_limits<long double>::infinity()), 11529215046068502527ULL );
-    BOOST_TEST_EQ( hv(-std::numeric_limits<long double>::infinity()), 11529215046068535295ULL );
-
-#else
-
-    BOOST_TEST_EQ( hv(std::numeric_limits<long double>::infinity()), 18446744073709551615ULL );
-    BOOST_TEST_EQ( hv(-std::numeric_limits<long double>::infinity()), 18446744073709551614ULL );
-
-#endif
-
-#endif
-
-#endif
-
-    // C array
-    {
-        int a1[] = { 0 };
-        int a2[] = { 0, 0 };
-        int a3[] = { 0, 0, 0 };
-
-#if SIZE_MAX == 4294967295U
-
-        BOOST_TEST_EQ( hv(a1), 3864292196U );
-        BOOST_TEST_EQ( hv(a2), 2842917718U );
-        BOOST_TEST_EQ( hv(a3), 325752138U );
-
-#else
-
-        BOOST_TEST_EQ( hv(a1), 3864292196ULL );
-        BOOST_TEST_EQ( hv(a2), 14642545639667855512ULL );
-        BOOST_TEST_EQ( hv(a3), 17867750819888810972ULL );
-
-#endif
-    }
-
-    // string
-#if SIZE_MAX == 4294967295U
-
-    BOOST_TEST_EQ( hv(std::string()), 0 );
-    BOOST_TEST_EQ( hv(std::string("abc")), 1849538372U );
-    BOOST_TEST_EQ( hv(std::string("\0", 1)), 3864292196U );
-    BOOST_TEST_EQ( hv(std::string("\0\0", 2)), 2842917718U );
-    BOOST_TEST_EQ( hv(std::string("\0\0\0", 3)), 325752138U );
-
-#else
-
-    BOOST_TEST_EQ( hv(std::string()), 0 );
-    BOOST_TEST_EQ( hv(std::string("abc")), 6420922261882292859ULL );
-    BOOST_TEST_EQ( hv(std::string("\0", 1)), 3864292196ULL );
-    BOOST_TEST_EQ( hv(std::string("\0\0", 2)), 14642545639667855512ULL );
-    BOOST_TEST_EQ( hv(std::string("\0\0\0", 3)), 17867750819888810972ULL );
-
-#endif
-
-    // pointer
-    BOOST_TEST_EQ( hv((void*)0), 0 );
-    BOOST_TEST_EQ( hv((void*)0x200014A0), 603985716U );
-
-    // complex<int>
-    BOOST_TEST_EQ( hv(std::complex<int>(0, 0)), 0U );
-    BOOST_TEST_EQ( hv(std::complex<int>(+1, 0)), 1U );
-    BOOST_TEST_EQ( hv(std::complex<int>(0, +1)), 65U );
-
-#if SIZE_MAX == 4294967295U
-
-    BOOST_TEST_EQ( hv(std::complex<int>(-1, 0)), 4294967295U );
-    BOOST_TEST_EQ( hv(std::complex<int>(0, -1)), 3221225536U );
-
-#else
-
-    BOOST_TEST_EQ( hv(std::complex<int>(-1, 0)), 18446744073709551615ULL );
-    BOOST_TEST_EQ( hv(std::complex<int>(0, -1)), 13835058055282163776ULL );
-
-#endif
-
-    // complex<float>
-    BOOST_TEST_EQ( hv(std::complex<float>(0.0f, 0.0f)), 0U );
-    BOOST_TEST_EQ( hv(std::complex<float>(+1.0f, 0.0f)), 1065353216U );
-    BOOST_TEST_EQ( hv(std::complex<float>(-1.0f, 0.0f)), 3212836864U );
-
-#if SIZE_MAX == 4294967295U
-
-    BOOST_TEST_EQ( hv(std::complex<float>(0.0f, +1.0f)), 3495952384U );
-    BOOST_TEST_EQ( hv(std::complex<float>(0.0f, -1.0f)), 2959081472U );
-
-#else
-
-    BOOST_TEST_EQ( hv(std::complex<float>(0.0f, +1.0f)), 67920461824ULL );
-    BOOST_TEST_EQ( hv(std::complex<float>(0.0f, -1.0f)), 209117511680ULL );
-
-#endif
-
-    // complex<double>
-    BOOST_TEST_EQ( hv(std::complex<double>(0.0, 0.0)), 0U );
-
-#if SIZE_MAX == 4294967295U
-
-    BOOST_TEST_EQ( hv(std::complex<double>(+1.0, 0.0)), 1072693248U );
-    BOOST_TEST_EQ( hv(std::complex<double>(-1.0, 0.0)), 3220176896U );
-    BOOST_TEST_EQ( hv(std::complex<double>(0.0, +1.0)), 873201664U );
-    BOOST_TEST_EQ( hv(std::complex<double>(0.0, -1.0)), 2483814400U );
-
-#else
-
-    BOOST_TEST_EQ( hv(std::complex<double>(+1.0, 0.0)), 4607182418800017408ULL );
-    BOOST_TEST_EQ( hv(std::complex<double>(-1.0, 0.0)), 13830554455654793216ULL );
-    BOOST_TEST_EQ( hv(std::complex<double>(0.0, +1.0)), 3750372589692780544ULL );
-    BOOST_TEST_EQ( hv(std::complex<double>(0.0, -1.0)), 10667901617333862400ULL );
-
-#endif
-
-    // pair
-#if SIZE_MAX == 4294967295U
-
-    BOOST_TEST_EQ( hv(std::make_pair(0, 0)), 2842917718U );
-    BOOST_TEST_EQ( hv(std::make_pair(1, 2)), 2507434894U );
-    BOOST_TEST_EQ( hv(std::make_pair(-1, -2)), 1874100199 );
-
-#else
-
-    BOOST_TEST_EQ( hv(std::make_pair(0, 0)), 14642545639667855512ULL );
-    BOOST_TEST_EQ( hv(std::make_pair(1, 2)), 3370697991563800380ULL );
-    BOOST_TEST_EQ( hv(std::make_pair(-1, -2)), 4139767141999124554ULL );
-
-#endif
-
-    // vector<char>
-#if SIZE_MAX == 4294967295U
-
-    BOOST_TEST_EQ( hv(std::vector<char>(0)), 0 );
-    BOOST_TEST_EQ( hv(std::vector<char>(1)), 3864292196U );
-    BOOST_TEST_EQ( hv(std::vector<char>(2)), 2842917718U );
-    BOOST_TEST_EQ( hv(std::vector<char>(3)), 325752138U );
-
-#else
-
-    BOOST_TEST_EQ( hv(std::vector<char>(0)), 0 );
-    BOOST_TEST_EQ( hv(std::vector<char>(1)), 3864292196ULL );
-    BOOST_TEST_EQ( hv(std::vector<char>(2)), 14642545639667855512ULL );
-    BOOST_TEST_EQ( hv(std::vector<char>(3)), 17867750819888810972ULL );
-
-#endif
-
-    // vector<int>
-#if SIZE_MAX == 4294967295U
-
-    BOOST_TEST_EQ( hv(std::vector<int>(0)), 0 );
-    BOOST_TEST_EQ( hv(std::vector<int>(1)), 3864292196U );
-    BOOST_TEST_EQ( hv(std::vector<int>(2)), 2842917718U );
-    BOOST_TEST_EQ( hv(std::vector<int>(3)), 325752138U );
-
-#else
-
-    BOOST_TEST_EQ( hv(std::vector<int>(0)), 0 );
-    BOOST_TEST_EQ( hv(std::vector<int>(1)), 3864292196ULL );
-    BOOST_TEST_EQ( hv(std::vector<int>(2)), 14642545639667855512ULL );
-    BOOST_TEST_EQ( hv(std::vector<int>(3)), 17867750819888810972ULL );
-
-#endif
-
-    // vector<vector<int>>
-#if SIZE_MAX == 4294967295U
-
-    BOOST_TEST_EQ( hv(std::vector<std::vector<int> >(0)), 0 );
-    BOOST_TEST_EQ( hv(std::vector<std::vector<int> >(1)), 3864292196U );
-    BOOST_TEST_EQ( hv(std::vector<std::vector<int> >(2)), 2842917718U );
-    BOOST_TEST_EQ( hv(std::vector<std::vector<int> >(3)), 325752138U );
-
-#else
-
-    BOOST_TEST_EQ( hv(std::vector<std::vector<int> >(0)), 0 );
-    BOOST_TEST_EQ( hv(std::vector<std::vector<int> >(1)), 3864292196ULL );
-    BOOST_TEST_EQ( hv(std::vector<std::vector<int> >(2)), 14642545639667855512ULL );
-    BOOST_TEST_EQ( hv(std::vector<std::vector<int> >(3)), 17867750819888810972ULL );
-
-#endif
-
-    // list<char>
-#if SIZE_MAX == 4294967295U
-
-    BOOST_TEST_EQ( hv(std::list<char>(0)), 0 );
-    BOOST_TEST_EQ( hv(std::list<char>(1)), 3864292196U );
-    BOOST_TEST_EQ( hv(std::list<char>(2)), 2842917718U );
-    BOOST_TEST_EQ( hv(std::list<char>(3)), 325752138U );
-
-#else
-
-    BOOST_TEST_EQ( hv(std::list<char>(0)), 0 );
-    BOOST_TEST_EQ( hv(std::list<char>(1)), 3864292196ULL );
-    BOOST_TEST_EQ( hv(std::list<char>(2)), 14642545639667855512ULL );
-    BOOST_TEST_EQ( hv(std::list<char>(3)), 17867750819888810972ULL );
-
-#endif
-
-    // list<int>
-#if SIZE_MAX == 4294967295U
-
-    BOOST_TEST_EQ( hv(std::list<int>(0)), 0 );
-    BOOST_TEST_EQ( hv(std::list<int>(1)), 3864292196U );
-    BOOST_TEST_EQ( hv(std::list<int>(2)), 2842917718U );
-    BOOST_TEST_EQ( hv(std::list<int>(3)), 325752138U );
-
-#else
-
-    BOOST_TEST_EQ( hv(std::list<int>(0)), 0 );
-    BOOST_TEST_EQ( hv(std::list<int>(1)), 3864292196ULL );
-    BOOST_TEST_EQ( hv(std::list<int>(2)), 14642545639667855512ULL );
-    BOOST_TEST_EQ( hv(std::list<int>(3)), 17867750819888810972ULL );
-
-#endif
-
-    return boost::report_errors();
-}
-
-#endif

test/hash_sequence_test.hpp

@@ -7,18 +7,18 @@
 #error "CONTAINER_TYPE not defined"
 #else
 
+#include <boost/preprocessor/cat.hpp>
+
 #if defined(BOOST_MSVC)
 #pragma warning(push)
 #pragma warning(disable:4245) // signed/unsigned mismatch
 #endif
 
-namespace HASH_TEST_CAT(CONTAINER_TYPE, _tests)
+namespace BOOST_PP_CAT(CONTAINER_TYPE, _tests)
 {
     template <class T>
     void integer_tests(T* = 0)
     {
-        typedef typename T::value_type value_type;
-
         const int number_of_containers = 11;
         T containers[number_of_containers];
 
@@ -27,16 +27,16 @@ namespace HASH_TEST_CAT(CONTAINER_TYPE, _tests)
                 containers[i].push_back(0);
         }
 
-        containers[5].push_back(value_type(1));
-        containers[6].push_back(value_type(1));
-        containers[6].push_back(value_type(1));
-        containers[7].push_back(value_type(-1));
-        containers[8].push_back(value_type(-1));
-        containers[8].push_back(value_type(-1));
-        containers[9].push_back(value_type(1));
-        containers[9].push_back(value_type(-1));
-        containers[10].push_back(value_type(-1));
-        containers[10].push_back(value_type(1));
+        containers[5].push_back(1);
+        containers[6].push_back(1);
+        containers[6].push_back(1);
+        containers[7].push_back(-1);
+        containers[8].push_back(-1);
+        containers[8].push_back(-1);
+        containers[9].push_back(1);
+        containers[9].push_back(-1);
+        containers[10].push_back(-1);
+        containers[10].push_back(1);
 
         BOOST_HASH_TEST_NAMESPACE::hash<T> hasher;
 
@@ -59,7 +59,7 @@ namespace HASH_TEST_CAT(CONTAINER_TYPE, _tests)
         }
     }
 
-    void HASH_TEST_CAT(CONTAINER_TYPE, _hash_integer_tests())
+    void BOOST_PP_CAT(CONTAINER_TYPE, _hash_integer_tests())
     {
         integer_tests((CONTAINER_TYPE<char>*) 0);
         integer_tests((CONTAINER_TYPE<int>*) 0);

test/hash_set_test.cpp

@@ -9,11 +9,11 @@
 #  ifdef BOOST_HASH_TEST_STD_INCLUDES
 #    include <functional>
 #  else
-#    include <boost/container_hash/hash.hpp>
+#    include <boost/functional/hash.hpp>
 #  endif
 #endif
 
-#include <boost/core/lightweight_test.hpp>
+#include <boost/detail/lightweight_test.hpp>
 
 #ifdef BOOST_HASH_TEST_EXTENSIONS
 

test/hash_set_test.hpp

@@ -7,18 +7,18 @@
 #error "CONTAINER_TYPE not defined"
 #else
 
+#include <boost/preprocessor/cat.hpp>
+
 #if defined(BOOST_MSVC)
 #pragma warning(push)
 #pragma warning(disable:4245) // signed/unsigned mismatch
 #endif
 
-namespace HASH_TEST_CAT(CONTAINER_TYPE, _tests)
+namespace BOOST_PP_CAT(CONTAINER_TYPE, _tests)
 {
     template <class T>
     void integer_tests(T* = 0)
     {
-        typedef typename T::value_type value_type;
-
         const int number_of_containers = 12;
         T containers[number_of_containers];
 
@@ -27,19 +27,19 @@ namespace HASH_TEST_CAT(CONTAINER_TYPE, _tests)
                 containers[i].insert(0);
         }
 
-        containers[6].insert(value_type(1));
-        containers[7].insert(value_type(1));
-        containers[7].insert(value_type(1));
-        containers[8].insert(value_type(-1));
-        containers[9].insert(value_type(-1));
-        containers[9].insert(value_type(-1));
-        containers[10].insert(value_type(-1));
-        containers[10].insert(value_type(1));
-        containers[11].insert(value_type(1));
-        containers[11].insert(value_type(2));
-        containers[11].insert(value_type(3));
-        containers[11].insert(value_type(4));
-        containers[11].insert(value_type(5));
+        containers[6].insert(1);
+        containers[7].insert(1);
+        containers[7].insert(1);
+        containers[8].insert(-1);
+        containers[9].insert(-1);
+        containers[9].insert(-1);
+        containers[10].insert(-1);
+        containers[10].insert(1);
+        containers[11].insert(1);
+        containers[11].insert(2);
+        containers[11].insert(3);
+        containers[11].insert(4);
+        containers[11].insert(5);
 
         BOOST_HASH_TEST_NAMESPACE::hash<T> hasher;
 
@@ -62,7 +62,7 @@ namespace HASH_TEST_CAT(CONTAINER_TYPE, _tests)
         }
     }
 
-    void HASH_TEST_CAT(CONTAINER_TYPE, _hash_integer_tests())
+    void BOOST_PP_CAT(CONTAINER_TYPE, _hash_integer_tests())
     {
         integer_tests((CONTAINER_TYPE<char>*) 0);
         integer_tests((CONTAINER_TYPE<int>*) 0);

test/hash_std_array_test.cpp

@@ -9,12 +9,12 @@
 #  ifdef BOOST_HASH_TEST_STD_INCLUDES
 #    include <functional>
 #  else
-#    include <boost/container_hash/hash.hpp>
+#    include <boost/functional/hash.hpp>
 #  endif
 #endif
 
 #include <boost/config.hpp>
-#include <boost/core/lightweight_test.hpp>
+#include <boost/detail/lightweight_test.hpp>
 
 #if defined(BOOST_HASH_TEST_EXTENSIONS) && !defined(BOOST_NO_CXX11_HDR_ARRAY)
 #define TEST_ARRAY

test/hash_std_smart_ptr_test.cpp

@@ -8,10 +8,10 @@
 #ifdef BOOST_HASH_TEST_STD_INCLUDES
 #  include <functional>
 #else
-#  include <boost/container_hash/hash.hpp>
+#  include <boost/functional/hash.hpp>
 #endif
 
-#include <boost/core/lightweight_test.hpp>
+#include <boost/detail/lightweight_test.hpp>
 #include "./compile_time.hpp"
 
 #if defined(BOOST_HASH_TEST_EXTENSIONS) && !defined(BOOST_NO_CXX11_SMART_PTR)

test/hash_std_tuple_test.cpp

@@ -9,12 +9,12 @@
 #  ifdef BOOST_HASH_TEST_STD_INCLUDES
 #    include <functional>
 #  else
-#    include <boost/container_hash/hash.hpp>
+#    include <boost/functional/hash.hpp>
 #  endif
 #endif
 
 #include <boost/config.hpp>
-#include <boost/core/lightweight_test.hpp>
+#include <boost/detail/lightweight_test.hpp>
 
 #if defined(BOOST_HASH_TEST_EXTENSIONS) && !defined(BOOST_NO_CXX11_HDR_TUPLE)
 #define TEST_TUPLE

test/hash_string_test.cpp

@@ -8,10 +8,10 @@
 #ifdef BOOST_HASH_TEST_STD_INCLUDES
 #  include <functional>
 #else
-#  include <boost/container_hash/hash.hpp>
+#  include <boost/functional/hash.hpp>
 #endif
 
-#include <boost/core/lightweight_test.hpp>
+#include <boost/detail/lightweight_test.hpp>
 #include <string>
 #include "./compile_time.hpp"
 
@@ -38,24 +38,7 @@ void string_tests()
 #endif
 }
 
-void string0_tests()
-{
-    std::string x1(1, '\0');
-    std::string x2(2, '\0');
-    std::string x3(3, '\0');
-    std::string x4(10, '\0');
-
-    BOOST_HASH_TEST_NAMESPACE::hash<std::string> hasher;
-
-    BOOST_TEST(hasher(x1) != hasher(x2));
-    BOOST_TEST(hasher(x1) != hasher(x3));
-    BOOST_TEST(hasher(x1) != hasher(x4));
-    BOOST_TEST(hasher(x2) != hasher(x3));
-    BOOST_TEST(hasher(x2) != hasher(x4));
-    BOOST_TEST(hasher(x3) != hasher(x4));
-}
-
-#if !defined(BOOST_NO_STD_WSTRING) && !defined(BOOST_NO_INTRINSIC_WCHAR_T)
+#if !defined(BOOST_NO_STD_WSTRING)
 void wstring_tests()
 {
     compile_time_tests((std::wstring*) 0);
@@ -80,105 +63,11 @@ void wstring_tests()
 }
 #endif
 
-#if !defined(BOOST_NO_CXX11_CHAR16_T)
-void u16string_tests()
-{
-    compile_time_tests((std::u16string*) 0);
-
-    BOOST_HASH_TEST_NAMESPACE::hash<std::u16string> x1;
-    BOOST_HASH_TEST_NAMESPACE::hash<std::u16string> x2;
-
-    BOOST_TEST(x1(u"Hello") == x2(std::u16string(u"Hel") + u"lo"));
-    BOOST_TEST(x1(u"") == x2(std::u16string()));
-
-#if defined(BOOST_HASH_TEST_EXTENSIONS)
-    std::u16string value1;
-    std::u16string value2(u"Hello");
-
-    BOOST_TEST(x1(value1) == BOOST_HASH_TEST_NAMESPACE::hash_value(value1));
-    BOOST_TEST(x1(value2) == BOOST_HASH_TEST_NAMESPACE::hash_value(value2));
-    BOOST_TEST(BOOST_HASH_TEST_NAMESPACE::hash_value(value1) ==
-            BOOST_HASH_TEST_NAMESPACE::hash_range(value1.begin(), value1.end()));
-    BOOST_TEST(BOOST_HASH_TEST_NAMESPACE::hash_value(value2) ==
-            BOOST_HASH_TEST_NAMESPACE::hash_range(value2.begin(), value2.end()));
-#endif
-}
-#endif
-
-#if !defined(BOOST_NO_CXX11_CHAR32_T)
-void u32string_tests()
-{
-    compile_time_tests((std::u32string*) 0);
-
-    BOOST_HASH_TEST_NAMESPACE::hash<std::u32string> x1;
-    BOOST_HASH_TEST_NAMESPACE::hash<std::u32string> x2;
-
-    BOOST_TEST(x1(U"Hello") == x2(std::u32string(U"Hel") + U"lo"));
-    BOOST_TEST(x1(U"") == x2(std::u32string()));
-
-#if defined(BOOST_HASH_TEST_EXTENSIONS)
-    std::u32string value1;
-    std::u32string value2(U"Hello");
-
-    BOOST_TEST(x1(value1) == BOOST_HASH_TEST_NAMESPACE::hash_value(value1));
-    BOOST_TEST(x1(value2) == BOOST_HASH_TEST_NAMESPACE::hash_value(value2));
-    BOOST_TEST(BOOST_HASH_TEST_NAMESPACE::hash_value(value1) ==
-            BOOST_HASH_TEST_NAMESPACE::hash_range(value1.begin(), value1.end()));
-    BOOST_TEST(BOOST_HASH_TEST_NAMESPACE::hash_value(value2) ==
-            BOOST_HASH_TEST_NAMESPACE::hash_range(value2.begin(), value2.end()));
-#endif
-}
-#endif
-
-template <typename StringType>
-void generic_string_tests(StringType*)
-{
-    std::string x1(1, '\0');
-    std::string x2(2, '\0');
-    std::string x3(3, '\0');
-    std::string x4(10, '\0');
-    std::string x5 = x2 + "hello" + x2;
-
-    StringType strings[] = {
-        "",
-        "hello",
-        x1,
-        x2,
-        x3,
-        x4,
-        x5
-    };
-
-    std::size_t const strings_length = sizeof(strings) / sizeof(StringType);
-    boost::hash<StringType> hash;
-
-    for (std::size_t i = 0; i < strings_length; ++i) {
-        std::size_t hash_i = hash(strings[i]);
-        for (std::size_t j = 0; j < strings_length; ++j) {
-            std::size_t hash_j = hash(strings[j]);
-            BOOST_TEST((hash_i == hash_j) == (i == j));
-        }
-    }
-}
-
 int main()
 {
     string_tests();
-    string0_tests();
-#if !defined(BOOST_NO_STD_WSTRING) && !defined(BOOST_NO_INTRINSIC_WCHAR_T)
+#if !defined(BOOST_NO_STD_WSTRING)
     wstring_tests();
 #endif
-#if !defined(BOOST_NO_CXX11_CHAR16_T)
-    u16string_tests();
-#endif
-#if !defined(BOOST_NO_CXX11_CHAR32_T)
-    u32string_tests();
-#endif
-
-    generic_string_tests((std::string*) 0);
-#if BOOST_HASH_HAS_STRING_VIEW
-    generic_string_tests((std::string_view*) 0);
-#endif
-
     return boost::report_errors();
 }

test/hash_system_error_test.cpp

@@ -1,55 +0,0 @@
-
-// Copyright 2018 Daniel James
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#include "./config.hpp"
-
-#ifndef BOOST_HASH_TEST_STD_INCLUDES
-#  include <boost/container_hash/hash.hpp>
-#endif
-#include <boost/config.hpp>
-#include <boost/core/lightweight_test.hpp>
-
-#if !defined(BOOST_NO_CXX11_HDR_SYSTEM_ERROR)
-
-#include <system_error>
-
-void test_error_code()
-{
-    std::error_code err1a = std::make_error_code(std::errc::argument_list_too_long);
-    std::error_code err1b = std::make_error_code(std::errc::argument_list_too_long);
-    std::error_code err2 = std::make_error_code(std::errc::bad_file_descriptor);
-
-    boost::hash<std::error_code> hasher;
-
-    BOOST_TEST(hasher(err1a) == hasher(err1a));
-    BOOST_TEST(hasher(err1a) == hasher(err1b));
-    BOOST_TEST(hasher(err1a) != hasher(err2));
-}
-
-void test_error_condition()
-{
-    std::error_condition err1a = std::make_error_condition(std::errc::directory_not_empty);
-    std::error_condition err1b = std::make_error_condition(std::errc::directory_not_empty);
-    std::error_condition err2 = std::make_error_condition(std::errc::filename_too_long);
-
-    boost::hash<std::error_condition> hasher;
-
-    BOOST_TEST(hasher(err1a) == hasher(err1a));
-    BOOST_TEST(hasher(err1a) == hasher(err1b));
-    BOOST_TEST(hasher(err1a) != hasher(err2));
-}
-
-#endif
-
-int main()
-{
-#if !defined(BOOST_NO_CXX11_HDR_SYSTEM_ERROR)
-    test_error_code();
-    test_error_condition();
-#else
-    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "<system_error> not available." << std::endl;
-#endif
-    return boost::report_errors();
-}

test/hash_type_index_test.cpp

@@ -8,10 +8,10 @@
 #ifdef BOOST_HASH_TEST_STD_INCLUDES
 #  include <functional>
 #else
-#  include <boost/container_hash/hash.hpp>
+#  include <boost/functional/hash.hpp>
 #endif
 #include <boost/config.hpp>
-#include <boost/core/lightweight_test.hpp>
+#include <boost/detail/lightweight_test.hpp>
 
 #if !defined(BOOST_NO_CXX11_HDR_TYPEINDEX)
 

test/hash_value_array_test.cpp

@@ -12,11 +12,11 @@
 #  ifdef BOOST_HASH_TEST_STD_INCLUDES
 #    include <functional>
 #  else
-#    include <boost/container_hash/hash.hpp>
+#    include <boost/functional/hash.hpp>
 #  endif
 #endif
 
-#include <boost/core/lightweight_test.hpp>
+#include <boost/detail/lightweight_test.hpp>
 
 #ifdef BOOST_HASH_TEST_EXTENSIONS
 

test/hash_variant_test.cpp

@@ -1,100 +0,0 @@
-
-// Copyright 2018 Daniel James
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#include "./config.hpp"
-
-#ifndef BOOST_HASH_TEST_STD_INCLUDES
-#  include <boost/container_hash/hash.hpp>
-#endif
-#include <boost/config.hpp>
-#include <boost/core/lightweight_test.hpp>
-
-#if BOOST_HASH_HAS_VARIANT
-
-#include <variant>
-#include <string>
-
-void test_monostate()
-{
-    std::monostate x1;
-    std::monostate x2;
-
-    boost::hash<std::monostate> hasher;
-
-    BOOST_TEST(hasher(x1) == hasher(x2));
-}
-
-void test_variant_int()
-{
-    std::variant<std::monostate, int> x1a;
-    std::variant<std::monostate, int> x1b;
-    std::variant<std::monostate, int> x2a(10);
-    std::variant<std::monostate, int> x2b(x2a);
-    std::variant<std::monostate, int> x3(20);
-
-    boost::hash<std::variant<std::monostate, int> > hasher;
-
-    BOOST_TEST(hasher(x1a) == hasher(x1a));
-    BOOST_TEST(hasher(x1a) == hasher(x1b));
-    BOOST_TEST(hasher(x1a) != hasher(x2a));
-    BOOST_TEST(hasher(x1a) != hasher(x3));
-    BOOST_TEST(hasher(x2a) == hasher(x2a));
-    BOOST_TEST(hasher(x2b) == hasher(x2b));
-    BOOST_TEST(hasher(x2a) != hasher(x3));
-    BOOST_TEST(hasher(x3) == hasher(x3));
-}
-
-struct custom1 {
-    int value;
-    friend std::size_t hash_value(custom1 v) { return boost::hash_value(v.value); }
-};
-
-struct custom2 {
-    int value;
-    friend std::size_t hash_value(custom2 v) { return boost::hash_value(v.value); }
-};
-
-void test_variant_unique_types()
-{
-    custom1 x11 = { 0 };
-    custom1 x12 = { 1 };
-    custom2 x21 = { 0 };
-    custom2 x22 = { 1 };
-
-    boost::hash<custom1> hasher1;
-    boost::hash<custom2> hasher2;
-
-    BOOST_TEST(hasher1(x11) == hasher2(x21));
-    BOOST_TEST(hasher1(x11) != hasher2(x22));
-    BOOST_TEST(hasher1(x12) != hasher2(x21));
-    BOOST_TEST(hasher1(x12) == hasher2(x22));
-
-    typedef std::variant<custom1, custom2> variant_type;
-
-    variant_type y11(x11);
-    variant_type y12(x12);
-    variant_type y21(x21);
-    variant_type y22(x22);
-
-    boost::hash<variant_type> hasher;
-
-    BOOST_TEST(hasher(y11) != hasher(y21));
-    BOOST_TEST(hasher(y11) != hasher(y22));
-    BOOST_TEST(hasher(y12) != hasher(y21));
-    BOOST_TEST(hasher(y12) != hasher(y22));
-}
-
-#endif
-
-int main()
-{
-#if BOOST_HASH_HAS_VARIANT
-    test_variant_int();
-    test_variant_unique_types();
-#else
-    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "<variant> not available." << std::endl;
-#endif
-    return boost::report_errors();
-}

test/hash_vector_test.cpp

@@ -9,11 +9,11 @@
 #  ifdef BOOST_HASH_TEST_STD_INCLUDES
 #    include <functional>
 #  else
-#    include <boost/container_hash/hash.hpp>
+#    include <boost/functional/hash.hpp>
 #  endif
 #endif
 
-#include <boost/core/lightweight_test.hpp>
+#include <boost/detail/lightweight_test.hpp>
 
 #ifdef BOOST_HASH_TEST_EXTENSIONS
 
@@ -25,44 +25,11 @@ using std::vector;
 
 #endif // BOOST_HASH_TEST_EXTENSIONS
 
-namespace vector_bool_tests
-{
-    void vector_bool_test() {
-        std::vector<bool> x_empty1,x_empty2,x1,x1a,x2,x3;
-
-        x1.push_back(0);
-        x1a.push_back(0);
-        x2.push_back(1);
-        x3.push_back(0);
-        x3.push_back(0);
-
-        BOOST_HASH_TEST_NAMESPACE::hash<std::vector<bool> > hasher;
-
-        BOOST_TEST_EQ(hasher(x_empty1), hasher(x_empty1));
-        BOOST_TEST_EQ(hasher(x_empty1), hasher(x_empty2));
-        BOOST_TEST_NE(hasher(x_empty1), hasher(x1));
-        BOOST_TEST_NE(hasher(x_empty1), hasher(x2));
-        BOOST_TEST_NE(hasher(x_empty1), hasher(x3));
-
-        BOOST_TEST_EQ(hasher(x1), hasher(x1));
-        BOOST_TEST_EQ(hasher(x1), hasher(x1a));
-        BOOST_TEST_NE(hasher(x1), hasher(x2));
-        BOOST_TEST_NE(hasher(x1), hasher(x3));
-
-        BOOST_TEST_EQ(hasher(x2), hasher(x2));
-        BOOST_TEST_NE(hasher(x2), hasher(x3));
-
-        BOOST_TEST_EQ(hasher(x3), hasher(x3));
-    }
-}
-
 int main()
 {
 #ifdef BOOST_HASH_TEST_EXTENSIONS
     vector_tests::vector_hash_integer_tests();
 #endif
 
-    vector_bool_tests::vector_bool_test();
-
     return boost::report_errors();
 }

test/implicit_test.cpp

@@ -3,7 +3,7 @@
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
-#include <boost/container_hash/hash.hpp>
+#include <boost/functional/hash.hpp>
 
 namespace test
 {

test/link_ext_test.cpp

@@ -6,8 +6,8 @@
 #include "./config.hpp"
 
 #define BOOST_HASH_TEST_NAMESPACE boost
-#include <boost/container_hash/hash.hpp>
-#include <boost/core/lightweight_test.hpp>
+#include <boost/functional/hash.hpp>
+#include <boost/detail/lightweight_test.hpp>
 #include <vector>
 
 int f(std::size_t hash1, int* x1) {
@@ -20,7 +20,7 @@ int f(std::size_t hash1, int* x1) {
 
     // Check that std::vector<std::size_t> is avaiable in this file.
     std::vector<std::size_t> x;
-    x.push_back(static_cast<std::size_t>(*x1));
+    x.push_back(*x1);
     BOOST_HASH_TEST_NAMESPACE::hash<std::vector<std::size_t> > vector_hasher;
     return vector_hasher(x) != BOOST_HASH_TEST_NAMESPACE::hash_value(x);
     

test/link_no_ext_test.cpp

@@ -7,8 +7,8 @@
 
 #define BOOST_HASH_TEST_NAMESPACE boost
 #define BOOST_HASH_NO_EXTENSIONS
-#include <boost/container_hash/hash.hpp>
-#include <boost/core/lightweight_test.hpp>
+#include <boost/functional/hash.hpp>
+#include <boost/detail/lightweight_test.hpp>
 
 extern int f(std::size_t, int*);
 

test/link_test.cpp

@@ -5,7 +5,7 @@
 
 #include "./config.hpp"
 
-#include <boost/container_hash/hash.hpp>
+#include <boost/functional/hash.hpp>
 
 extern int f();
 int main() { return f(); }

test/link_test_2.cpp

@@ -5,6 +5,6 @@
 
 #include "./config.hpp"
 
-#include <boost/container_hash/hash.hpp>
+#include <boost/functional/hash.hpp>
 
 int f() { return 0; }

test/namespace_fail_test.cpp

@@ -9,7 +9,7 @@
 #include "./config.hpp"
 
 #include <list>
-#include <boost/container_hash/hash.hpp>
+#include <boost/functional/hash.hpp>
 
 typedef list<int> foo;