passenger 6.0.16 → 6.0.18

data/src/cxx_supportlib/vendor-modified/boost/container_hash/hash.hpp

@@ -1,35 +1,50 @@
-
 // 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:
+// Copyright 2021, 2022 Peter Dimov.
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
 
-// MurmurHash3 was written by Austin Appleby, and is placed in the public
-// domain. The author hereby disclaims copyright to this source code.
+// 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)
+#ifndef 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/container_hash/is_range.hpp>
+#include <boost/container_hash/is_contiguous_range.hpp>
+#include <boost/container_hash/is_unordered_range.hpp>
+#include <boost/container_hash/is_described_class.hpp>
+#include <boost/container_hash/detail/hash_tuple.hpp>
+#include <boost/container_hash/detail/hash_mix.hpp>
+#include <boost/container_hash/detail/hash_range.hpp>
 #include <boost/type_traits/is_enum.hpp>
 #include <boost/type_traits/is_integral.hpp>
-#include <boost/core/enable_if.hpp>
+#include <boost/type_traits/is_floating_point.hpp>
+#include <boost/type_traits/is_signed.hpp>
+#include <boost/type_traits/is_unsigned.hpp>
+#include <boost/type_traits/make_unsigned.hpp>
+#include <boost/type_traits/enable_if.hpp>
+#include <boost/type_traits/conjunction.hpp>
+#include <boost/type_traits/is_union.hpp>
+#include <boost/describe/bases.hpp>
+#include <boost/describe/members.hpp>
 #include <boost/cstdint.hpp>
+
+#if defined(BOOST_DESCRIBE_CXX14)
+# include <boost/mp11/algorithm.hpp>
+#endif
+
+#include <string>
+#include <iterator>
+#include <complex>
+#include <utility>
+#include <limits>
 #include <climits>
+#include <cstring>
 
-#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
-#include <boost/type_traits/is_pointer.hpp>
+#if !defined(BOOST_NO_CXX11_SMART_PTR)
+# include <memory>
 #endif
 
 #if !defined(BOOST_NO_CXX11_HDR_TYPEINDEX)
@@ -40,728 +55,608 @@
 #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
+#if !defined(BOOST_NO_CXX17_HDR_OPTIONAL)
+#include <optional>
 #endif
 
-#if !defined(BOOST_HASH_HAS_OPTIONAL)
-#   define BOOST_HASH_HAS_OPTIONAL 0
+#if !defined(BOOST_NO_CXX17_HDR_VARIANT)
+#include <variant>
 #endif
 
-#if !defined(BOOST_HASH_HAS_VARIANT)
-#   define BOOST_HASH_HAS_VARIANT 0
+#if !defined(BOOST_NO_CXX17_HDR_STRING_VIEW)
+# include <string_view>
 #endif
 
-#if BOOST_HASH_HAS_STRING_VIEW
-#   include <string_view>
-#endif
+namespace boost
+{
 
-#if BOOST_HASH_HAS_OPTIONAL
-#   include <optional>
-#endif
+    //
+    // boost::hash_value
+    //
 
-#if BOOST_HASH_HAS_VARIANT
-#   include <variant>
-#endif
+    // integral types
 
-namespace boost
-{
     namespace hash_detail
     {
-#if defined(BOOST_NO_CXX98_FUNCTION_BASE)
-        template <typename T>
-        struct hash_base
+        template<class T,
+            bool bigger_than_size_t = (sizeof(T) > sizeof(std::size_t)),
+            bool is_unsigned = boost::is_unsigned<T>::value,
+            std::size_t size_t_bits = sizeof(std::size_t) * CHAR_BIT,
+            std::size_t type_bits = sizeof(T) * CHAR_BIT>
+        struct hash_integral_impl;
+
+        template<class T, bool is_unsigned, std::size_t size_t_bits, std::size_t type_bits> struct hash_integral_impl<T, false, is_unsigned, size_t_bits, type_bits>
         {
-            typedef T argument_type;
-            typedef std::size_t result_type;
+            static std::size_t fn( T v )
+            {
+                return static_cast<std::size_t>( v );
+            }
         };
-#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
+        template<class T, std::size_t size_t_bits, std::size_t type_bits> struct hash_integral_impl<T, true, false, size_t_bits, type_bits>
+        {
+            static std::size_t fn( T v )
+            {
+                typedef typename boost::make_unsigned<T>::type U;
 
-#if !defined(BOOST_NO_CXX11_CHAR32_T)
-        template <> struct basic_numbers<char32_t> :
-            boost::hash_detail::enable_hash_value {};
-#endif
+                if( v >= 0 )
+                {
+                    return hash_integral_impl<U>::fn( static_cast<U>( v ) );
+                }
+                else
+                {
+                    return ~hash_integral_impl<U>::fn( static_cast<U>( ~static_cast<U>( v ) ) );
+                }
+            }
+        };
 
-        // 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
+        template<class T> struct hash_integral_impl<T, true, true, 32, 64>
+        {
+            static std::size_t fn( T v )
+            {
+                std::size_t seed = 0;
 
-#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
+                seed = static_cast<std::size_t>( v >> 32 ) + hash_detail::hash_mix( seed );
+                seed = static_cast<std::size_t>( v ) + hash_detail::hash_mix( seed );
 
-        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);
+                return seed;
+            }
+        };
 
-    template <typename T>
-    typename boost::enable_if<boost::is_enum<T>, std::size_t>::type
-        hash_value(T);
+        template<class T> struct hash_integral_impl<T, true, true, 32, 128>
+        {
+            static std::size_t fn( T v )
+            {
+                std::size_t seed = 0;
 
-#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
+                seed = static_cast<std::size_t>( v >> 96 ) + hash_detail::hash_mix( seed );
+                seed = static_cast<std::size_t>( v >> 64 ) + hash_detail::hash_mix( seed );
+                seed = static_cast<std::size_t>( v >> 32 ) + hash_detail::hash_mix( seed );
+                seed = static_cast<std::size_t>( v ) + hash_detail::hash_mix( seed );
 
-#if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
-    template< class T, unsigned N >
-    std::size_t hash_value(const T (&x)[N]);
+                return seed;
+            }
+        };
 
-    template< class T, unsigned N >
-    std::size_t hash_value(T (&x)[N]);
-#endif
+        template<class T> struct hash_integral_impl<T, true, true, 64, 128>
+        {
+            static std::size_t fn( T v )
+            {
+                std::size_t seed = 0;
 
-    template <class Ch, class A>
-    std::size_t hash_value(
-        std::basic_string<Ch, std::BOOST_HASH_CHAR_TRAITS<Ch>, A> const&);
+                seed = static_cast<std::size_t>( v >> 64 ) + hash_detail::hash_mix( seed );
+                seed = static_cast<std::size_t>( v ) + hash_detail::hash_mix( seed );
 
-#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
+                return seed;
+            }
+        };
 
-    template <typename T>
-    typename boost::hash_detail::float_numbers<T>::type hash_value(T);
+    } // namespace hash_detail
 
-#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
+    typename boost::enable_if_<boost::is_integral<T>::value, std::size_t>::type
+        hash_value( T v )
+    {
+        return hash_detail::hash_integral_impl<T>::fn( v );
+    }
 
-#if !defined(BOOST_NO_CXX11_HDR_TYPEINDEX)
-    std::size_t hash_value(std::type_index);
-#endif
+    // enumeration types
 
-#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
+    template <typename T>
+    typename boost::enable_if_<boost::is_enum<T>::value, std::size_t>::type
+        hash_value( T v )
+    {
+        // This should in principle return the equivalent of
+        //
+        // boost::hash_value( to_underlying(v) );
+        //
+        // However, the C++03 implementation of underlying_type,
+        //
+        // conditional<is_signed<T>, make_signed<T>, make_unsigned<T>>::type::type
+        //
+        // generates a legitimate -Wconversion warning in is_signed,
+        // because -1 is not a valid enum value when all the enumerators
+        // are nonnegative.
+        //
+        // So the legacy implementation will have to do for now.
+
+        return static_cast<std::size_t>( v );
+    }
 
-    // Implementation
+    // floating point types
 
     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,
+            std::size_t Bits = sizeof(T) * CHAR_BIT,
+            int Digits = std::numeric_limits<T>::digits>
+        struct hash_float_impl;
 
-        template <class T>
-        inline std::size_t hash_value_unsigned(T val)
+        // float
+        template<class T, int Digits> struct hash_float_impl<T, 32, Digits>
         {
-             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);
+            static std::size_t fn( T v )
+            {
+                boost::uint32_t w;
+                std::memcpy( &w, &v, sizeof( v ) );
 
-             std::size_t seed = 0;
+                return w;
+            }
+        };
 
-             // 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);
+        // double
+        template<class T, int Digits> struct hash_float_impl<T, 64, Digits>
+        {
+            static std::size_t fn( T v )
+            {
+                boost::uint64_t w;
+                std::memcpy( &w, &v, sizeof( v ) );
 
-             return seed;
-        }
+                return hash_value( w );
+            }
+        };
 
-        template<std::size_t Bits> struct hash_combine_impl
+        // 80 bit long double in 12 bytes
+        template<class T> struct hash_float_impl<T, 96, 64>
         {
-            template <typename SizeT>
-            inline static SizeT fn(SizeT seed, SizeT value)
+            static std::size_t fn( T v )
             {
-                seed ^= value + 0x9e3779b9 + (seed<<6) + (seed>>2);
+                boost::uint64_t w[ 2 ] = {};
+                std::memcpy( &w, &v, 80 / CHAR_BIT );
+
+                std::size_t seed = 0;
+
+                seed = hash_value( w[0] ) + hash_detail::hash_mix( seed );
+                seed = hash_value( w[1] ) + hash_detail::hash_mix( seed );
+
                 return seed;
             }
         };
 
-        template<> struct hash_combine_impl<32>
+        // 80 bit long double in 16 bytes
+        template<class T> struct hash_float_impl<T, 128, 64>
         {
-            inline static boost::uint32_t fn(boost::uint32_t h1, boost::uint32_t k1)
+            static std::size_t fn( T v )
             {
-                const boost::uint32_t c1 = 0xcc9e2d51;
-                const boost::uint32_t c2 = 0x1b873593;
+                boost::uint64_t w[ 2 ] = {};
+                std::memcpy( &w, &v, 80 / CHAR_BIT );
 
-                k1 *= c1;
-                k1 = BOOST_FUNCTIONAL_HASH_ROTL32(k1,15);
-                k1 *= c2;
+                std::size_t seed = 0;
 
-                h1 ^= k1;
-                h1 = BOOST_FUNCTIONAL_HASH_ROTL32(h1,13);
-                h1 = h1*5+0xe6546b64;
+                seed = hash_value( w[0] ) + hash_detail::hash_mix( seed );
+                seed = hash_value( w[1] ) + hash_detail::hash_mix( seed );
 
-                return h1;
+                return seed;
             }
         };
 
-        template<> struct hash_combine_impl<64>
+        // 128 bit long double
+        template<class T, int Digits> struct hash_float_impl<T, 128, Digits>
         {
-            inline static boost::uint64_t fn(boost::uint64_t h, boost::uint64_t k)
+            static std::size_t fn( T v )
             {
-                const boost::uint64_t m = (boost::uint64_t(0xc6a4a793) << 32) + 0x5bd1e995;
-                const int r = 47;
+                boost::uint64_t w[ 2 ];
+                std::memcpy( &w, &v, sizeof( v ) );
 
-                k *= m;
-                k ^= k >> r;
-                k *= m;
+                std::size_t seed = 0;
 
-                h ^= k;
-                h *= m;
+#if defined(__FLOAT_WORD_ORDER__) && defined(__ORDER_BIG_ENDIAN__) && __FLOAT_WORD_ORDER__ == __ORDER_BIG_ENDIAN__
 
-                // Completely arbitrary number, to prevent 0's
-                // from hashing to 0.
-                h += 0xe6546b64;
+                seed = hash_value( w[1] ) + hash_detail::hash_mix( seed );
+                seed = hash_value( w[0] ) + hash_detail::hash_mix( seed );
 
-                return h;
+#else
+
+                seed = hash_value( w[0] ) + hash_detail::hash_mix( seed );
+                seed = hash_value( w[1] ) + hash_detail::hash_mix( seed );
+
+#endif
+                return seed;
             }
         };
-    }
 
-    template <typename T>
-    typename boost::hash_detail::basic_numbers<T>::type hash_value(T v)
-    {
-        return static_cast<std::size_t>(v);
-    }
+    } // namespace hash_detail
 
     template <typename T>
-    typename boost::hash_detail::long_numbers<T>::type hash_value(T v)
+    typename boost::enable_if_<boost::is_floating_point<T>::value, std::size_t>::type
+        hash_value( T v )
     {
-        return hash_detail::hash_value_signed(v);
+        return boost::hash_detail::hash_float_impl<T>::fn( v + 0 );
     }
 
-    template <typename T>
-    typename boost::hash_detail::ulong_numbers<T>::type hash_value(T v)
+    // pointer types
+
+    // `x + (x >> 3)` adjustment by Alberto Barbati and Dave Harris.
+    template <class T> std::size_t hash_value( T* const& v )
     {
-        return hash_detail::hash_value_unsigned(v);
+        boost::uintptr_t x = reinterpret_cast<boost::uintptr_t>( v );
+        return boost::hash_value( x + (x >> 3) );
     }
 
-    template <typename T>
-    typename boost::enable_if<boost::is_enum<T>, std::size_t>::type
-        hash_value(T v)
+    // array types
+
+    template<class T, std::size_t N>
+    inline std::size_t hash_value( T const (&x)[ N ] )
     {
-        return static_cast<std::size_t>(v);
+        return boost::hash_range( x, x + N );
     }
 
-    // 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
+    template<class T, std::size_t N>
+    inline std::size_t hash_value( T (&x)[ N ] )
     {
-#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);
+        return boost::hash_range( x, x + N );
     }
 
-#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
+    // complex
 
     template <class T>
-    inline void hash_combine(std::size_t& seed, T const& v)
+    std::size_t hash_value( std::complex<T> const& v )
     {
-        boost::hash<T> hasher;
-        seed = boost::hash_detail::hash_combine_impl<sizeof(std::size_t) * CHAR_BIT>::fn(seed, hasher(v));
+        std::size_t re = boost::hash<T>()( v.real() );
+        std::size_t im = boost::hash<T>()( v.imag() );
+
+        return re + hash_detail::hash_mix( im );
     }
 
-#if defined(BOOST_MSVC)
-#pragma warning(pop)
-#endif
+    // pair
 
-    template <class It>
-    inline std::size_t hash_range(It first, It last)
+    template <class A, class B>
+    std::size_t hash_value( std::pair<A, B> const& v )
     {
         std::size_t seed = 0;
 
-        for(; first != last; ++first)
-        {
-            hash_combine<typename std::iterator_traits<It>::value_type>(seed, *first);
-        }
+        boost::hash_combine( seed, v.first );
+        boost::hash_combine( seed, v.second );
 
         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);
-        }
-    }
+    // ranges (list, set, deque...)
 
-#if BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x551))
-    template <class T>
-    inline std::size_t hash_range(T* first, T* last)
+    template <typename T>
+    typename boost::enable_if_<container_hash::is_range<T>::value && !container_hash::is_contiguous_range<T>::value && !container_hash::is_unordered_range<T>::value, std::size_t>::type
+        hash_value( T const& v )
     {
-        std::size_t seed = 0;
+        return boost::hash_range( v.begin(), v.end() );
+    }
 
-        for(; first != last; ++first)
-        {
-            boost::hash<T> hasher;
-            seed ^= hasher(*first) + 0x9e3779b9 + (seed<<6) + (seed>>2);
-        }
+    // contiguous ranges (string, vector, array)
 
-        return seed;
+    template <typename T>
+    typename boost::enable_if_<container_hash::is_contiguous_range<T>::value, std::size_t>::type
+        hash_value( T const& v )
+    {
+        return boost::hash_range( v.data(), v.data() + v.size() );
     }
 
-    template <class T>
-    inline void hash_range(std::size_t& seed, T* first, T* last)
+    // unordered ranges (unordered_set, unordered_map)
+
+    template <typename T>
+    typename boost::enable_if_<container_hash::is_unordered_range<T>::value, std::size_t>::type
+        hash_value( T const& v )
     {
-        for(; first != last; ++first)
-        {
-            boost::hash<T> hasher;
-            seed ^= hasher(*first) + 0x9e3779b9 + (seed<<6) + (seed>>2);
-        }
+        return boost::hash_unordered_range( v.begin(), v.end() );
     }
-#endif
 
-#if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
-    template< class T, unsigned N >
-    inline std::size_t hash_value(const T (&x)[N])
+#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && ( \
+    ( defined(_MSVC_STL_VERSION) && _MSVC_STL_VERSION < 142 ) || \
+    ( !defined(_MSVC_STL_VERSION) && defined(_CPPLIB_VER) && _CPPLIB_VER >= 520 ) )
+
+    // resolve ambiguity with unconstrained stdext::hash_value in <xhash> :-/
+
+    template<template<class...> class L, class... T>
+    typename boost::enable_if_<container_hash::is_range<L<T...>>::value && !container_hash::is_contiguous_range<L<T...>>::value && !container_hash::is_unordered_range<L<T...>>::value, std::size_t>::type
+        hash_value( L<T...> const& v )
     {
-        return hash_range(x, x + N);
+        return boost::hash_range( v.begin(), v.end() );
     }
 
-    template< class T, unsigned N >
-    inline std::size_t hash_value(T (&x)[N])
+    // contiguous ranges (string, vector, array)
+
+    template<template<class...> class L, class... T>
+    typename boost::enable_if_<container_hash::is_contiguous_range<L<T...>>::value, std::size_t>::type
+        hash_value( L<T...> const& v )
     {
-        return hash_range(x, x + N);
+        return boost::hash_range( v.data(), v.data() + v.size() );
     }
-#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)
+    template<template<class, std::size_t> class L, class T, std::size_t N>
+    typename boost::enable_if_<container_hash::is_contiguous_range<L<T, N>>::value, std::size_t>::type
+        hash_value( L<T, N> const& v )
     {
-        return hash_range(v.begin(), v.end());
+        return boost::hash_range( v.data(), v.data() + v.size() );
     }
 
-#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)
+    // unordered ranges (unordered_set, unordered_map)
+
+    template<template<class...> class L, class... T>
+    typename boost::enable_if_<container_hash::is_unordered_range<L<T...>>::value, std::size_t>::type
+        hash_value( L<T...> const& v )
     {
-        return hash_range(v.begin(), v.end());
+        return boost::hash_unordered_range( v.begin(), v.end() );
     }
+
+#endif
+
+    // described classes
+
+#if defined(BOOST_DESCRIBE_CXX14)
+
+#if defined(_MSC_VER) && _MSC_VER == 1900
+# pragma warning(push)
+# pragma warning(disable: 4100) // unreferenced formal parameter
 #endif
 
     template <typename T>
-    typename boost::hash_detail::float_numbers<T>::type hash_value(T v)
+    typename boost::enable_if_<container_hash::is_described_class<T>::value, std::size_t>::type
+        hash_value( T const& v )
     {
-        return boost::hash_detail::float_hash_value(v);
-    }
+        static_assert( !boost::is_union<T>::value, "described unions are not supported" );
 
-#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);
-        }
+        std::size_t r = 0;
+
+        using Bd = describe::describe_bases<T, describe::mod_any_access>;
+
+        mp11::mp_for_each<Bd>([&](auto D){
+
+            using B = typename decltype(D)::type;
+            boost::hash_combine( r, (B const&)v );
+
+        });
+
+        using Md = describe::describe_members<T, describe::mod_any_access>;
+
+        mp11::mp_for_each<Md>([&](auto D){
+
+            boost::hash_combine( r, v.*D.pointer );
+
+        });
+
+        return r;
     }
+
+#if defined(_MSC_VER) && _MSC_VER == 1900
+# pragma warning(pop)
 #endif
 
-#if BOOST_HASH_HAS_VARIANT
-    inline std::size_t hash_value(std::monostate) {
-        return 0x87654321;
+#endif
+
+    // std::unique_ptr, std::shared_ptr
+
+#if !defined(BOOST_NO_CXX11_SMART_PTR)
+
+    template <typename T>
+    std::size_t hash_value( std::shared_ptr<T> const& x )
+    {
+        return boost::hash_value( x.get() );
     }
 
-    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;
+    template <typename T, typename Deleter>
+    std::size_t hash_value( std::unique_ptr<T, Deleter> const& x )
+    {
+        return boost::hash_value( x.get() );
     }
+
 #endif
 
+    // std::type_index
 
 #if !defined(BOOST_NO_CXX11_HDR_TYPEINDEX)
-    inline std::size_t hash_value(std::type_index v)
+
+    inline std::size_t hash_value( std::type_index const& v )
     {
         return v.hash_code();
     }
+
 #endif
 
+    // std::error_code, std::error_condition
+
 #if !defined(BOOST_NO_CXX11_HDR_SYSTEM_ERROR)
-    inline std::size_t hash_value(std::error_code const& v) {
+
+    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());
+
+        boost::hash_combine( seed, v.value() );
+        boost::hash_combine( seed, &v.category() );
+
         return seed;
     }
 
-    inline std::size_t hash_value(std::error_condition const& v) {
+    inline std::size_t hash_value( std::error_condition const& v )
+    {
+        std::size_t seed = 0;
+
+        boost::hash_combine( seed, v.value() );
+        boost::hash_combine( seed, &v.category() );
+
+        return seed;
+    }
+
+#endif
+
+    // std::optional
+
+#if !defined(BOOST_NO_CXX17_HDR_OPTIONAL)
+
+    template <typename T>
+    std::size_t hash_value( std::optional<T> const& v )
+    {
+        if( !v )
+        {
+            // Arbitray value for empty optional.
+            return 0x12345678;
+        }
+        else
+        {
+            return boost::hash<T>()(*v);
+        }
+    }
+
+#endif
+
+    // std::variant
+
+#if !defined(BOOST_NO_CXX17_HDR_VARIANT)
+
+    inline std::size_t hash_value( std::monostate )
+    {
+        return 0x87654321;
+    }
+
+    template <typename... Types>
+    std::size_t hash_value( std::variant<Types...> const& v )
+    {
         std::size_t seed = 0;
-        hash_combine(seed, v.value());
-        hash_combine(seed, &v.category());
+
+        hash_combine( seed, v.index() );
+        std::visit( [&seed](auto&& x) { hash_combine(seed, x); }, v );
+
         return seed;
     }
+
 #endif
 
     //
-    // boost::hash
+    // boost::hash_combine
     //
 
-    // 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.
+    template <class T>
+    inline void hash_combine( std::size_t& seed, T const& v )
+    {
+        seed = boost::hash_detail::hash_mix( seed + 0x9e3779b9 + boost::hash<T>()( v ) );
+    }
 
-    // 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.
+    // boost::hash_range
     //
-    // 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); \
-        } \
-    };
+    template <class It>
+    inline void hash_range( std::size_t& seed, It first, It last )
+    {
+        seed = hash_detail::hash_range( seed, first, last );
+    }
 
-#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); \
-        } \
-    };
+    template <class It>
+    inline std::size_t hash_range( It first, It last )
+    {
+        std::size_t seed = 0;
 
-    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
+        hash_range( seed, first, last );
 
-#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
+        return seed;
+    }
 
-#if !defined(BOOST_NO_LONG_LONG)
-    BOOST_HASH_SPECIALIZE(boost::long_long_type)
-    BOOST_HASH_SPECIALIZE(boost::ulong_long_type)
-#endif
+    //
+    // boost::hash_unordered_range
+    //
 
-#if defined(BOOST_HAS_INT128)
-    BOOST_HASH_SPECIALIZE(boost::int128_type)
-    BOOST_HASH_SPECIALIZE(boost::uint128_type)
-#endif
+    template <class It>
+    inline void hash_unordered_range( std::size_t& seed, It first, It last )
+    {
+        std::size_t r = 0;
+        std::size_t const s2( seed );
 
-#if BOOST_HASH_HAS_OPTIONAL
-    template <typename T>
-    BOOST_HASH_SPECIALIZE_TEMPLATE_REF(std::optional<T>)
-#endif
+        for( ; first != last; ++first )
+        {
+            std::size_t s3( s2 );
 
-#if !defined(BOOST_HASH_HAS_VARIANT)
-    template <typename... T>
-    BOOST_HASH_SPECIALIZE_TEMPLATE_REF(std::variant<T...>)
-    BOOST_HASH_SPECIALIZE(std::monostate)
-#endif
+            hash_combine<typename std::iterator_traits<It>::value_type>( s3, *first );
 
-#if !defined(BOOST_NO_CXX11_HDR_TYPEINDEX)
-    BOOST_HASH_SPECIALIZE(std::type_index)
-#endif
+            r += s3;
+        }
 
-#undef BOOST_HASH_SPECIALIZE
-#undef BOOST_HASH_SPECIALIZE_REF
-#undef BOOST_HASH_SPECIALIZE_TEMPLATE_REF
+        seed += r;
+    }
 
-// Specializing boost::hash for pointers.
+    template <class It>
+    inline std::size_t hash_unordered_range( It first, It last )
+    {
+        std::size_t seed = 0;
 
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+        hash_unordered_range( seed, first, last );
 
-    template <class T>
-    struct hash<T*>
-        : public boost::hash_detail::hash_base<T*>
+        return seed;
+    }
+
+    //
+    // boost::hash
+    //
+
+    template <class T> struct hash
     {
-        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));
+        typedef T argument_type;
+        typedef std::size_t result_type;
 
-            return x + (x >> 3);
-#endif
+        std::size_t operator()( T const& val ) const
+        {
+            return hash_value( val );
         }
     };
 
-#else
+#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && ( \
+    ( defined(_MSVC_STL_VERSION) && _MSVC_STL_VERSION < 142 ) || \
+    ( !defined(_MSVC_STL_VERSION) && defined(_CPPLIB_VER) && _CPPLIB_VER >= 520 ) )
 
-    // 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.
+    // Dinkumware has stdext::hash_value for basic_string in <xhash> :-/
 
-    namespace hash_detail
+    template<class E, class T, class A> struct hash< std::basic_string<E, T, A> >
     {
-        template <bool IsPointer>
-        struct hash_impl;
+        typedef std::basic_string<E, T, A> argument_type;
+        typedef std::size_t result_type;
 
-        template <>
-        struct hash_impl<true>
+        std::size_t operator()( std::basic_string<E, T, A> const& val ) const
         {
-            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 boost::hash_value( 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>
+    // boost::unordered::hash_is_avalanching
+
+    namespace unordered
     {
-    };
+        template<class T> struct hash_is_avalanching;
+        template<class Ch> struct hash_is_avalanching< boost::hash< std::basic_string<Ch> > >: boost::is_integral<Ch> {};
 
+        // boost::is_integral<char8_t> is false, but should be true (https://github.com/boostorg/type_traits/issues/175)
+#if defined(__cpp_char8_t) && __cpp_char8_t >= 201811L
+        template<> struct hash_is_avalanching< boost::hash< std::basic_string<char8_t> > >: boost::true_type {};
 #endif
-}
 
-#undef BOOST_HASH_CHAR_TRAITS
-#undef BOOST_FUNCTIONAL_HASH_ROTL32
+#if !defined(BOOST_NO_CXX17_HDR_STRING_VIEW)
+
+        template<class Ch> struct hash_is_avalanching< boost::hash< std::basic_string_view<Ch> > >: boost::is_integral<Ch> {};
 
-#if defined(BOOST_MSVC)
-#pragma warning(pop)
+#if defined(__cpp_char8_t) && __cpp_char8_t >= 201811L
+        template<> struct hash_is_avalanching< boost::hash< std::basic_string_view<char8_t> > >: boost::true_type {};
 #endif
 
-#endif // BOOST_FUNCTIONAL_HASH_HASH_HPP
+#endif
+    } // namespace unordered
 
-// 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.
+} // namespace boost
 
-#if !defined(BOOST_HASH_NO_EXTENSIONS) \
-    && !defined(BOOST_FUNCTIONAL_HASH_EXTENSIONS_HPP)
-#include <boost/container_hash/extensions.hpp>
-#endif
+#endif // #ifndef BOOST_FUNCTIONAL_HASH_HASH_HPP