From 565bac8d31926d82b482ae1a777592920f0932b4 Mon Sep 17 00:00:00 2001
From: Peter Dimov <pdimov@gmail.com>
Date: Thu, 12 Oct 2023 13:57:41 +0300
Subject: [PATCH] Remove C++03 workarounds

---
 .../boost/container_hash/detail/hash_mix.hpp  |  12 +-
 .../container_hash/detail/hash_range.hpp      | 170 +++++++++---------
 .../container_hash/detail/hash_tuple_like.hpp | 104 +----------
 include/boost/container_hash/detail/mulx.hpp  |  40 ++---
 include/boost/container_hash/hash.hpp         |  71 +++-----
 .../container_hash/is_contiguous_range.hpp    |  50 +++---
 .../container_hash/is_described_class.hpp     |   9 +-
 include/boost/container_hash/is_range.hpp     |  45 +----
 .../boost/container_hash/is_tuple_like.hpp    |  12 +-
 .../container_hash/is_unordered_range.hpp     |  13 +-
 test/is_contiguous_range_test.cpp             |   6 +-
 11 files changed, 189 insertions(+), 343 deletions(-)

diff --git a/include/boost/container_hash/detail/hash_mix.hpp b/include/boost/container_hash/detail/hash_mix.hpp
index 327da9e..088dd75 100644
--- a/include/boost/container_hash/detail/hash_mix.hpp
+++ b/include/boost/container_hash/detail/hash_mix.hpp
@@ -5,7 +5,7 @@
 #ifndef BOOST_HASH_DETAIL_HASH_MIX_HPP
 #define BOOST_HASH_DETAIL_HASH_MIX_HPP
 
-#include <boost/cstdint.hpp>
+#include <cstdint>
 #include <cstddef>
 #include <climits>
 
@@ -66,9 +66,9 @@ template<std::size_t Bits> struct hash_mix_impl;
 
 template<> struct hash_mix_impl<64>
 {
-    inline static boost::uint64_t fn( boost::uint64_t x )
+    inline static std::uint64_t fn( std::uint64_t x )
     {
-        boost::uint64_t const m = (boost::uint64_t(0xe9846af) << 32) + 0x9b1a615d;
+        std::uint64_t const m = 0xe9846af9b1a615d;
 
         x ^= x >> 32;
         x *= m;
@@ -87,10 +87,10 @@ template<> struct hash_mix_impl<64>
 
 template<> struct hash_mix_impl<32>
 {
-    inline static boost::uint32_t fn( boost::uint32_t x )
+    inline static std::uint32_t fn( std::uint32_t x )
     {
-        boost::uint32_t const m1 = 0x21f0aaad;
-        boost::uint32_t const m2 = 0x735a2d97;
+        std::uint32_t const m1 = 0x21f0aaad;
+        std::uint32_t const m2 = 0x735a2d97;
 
         x ^= x >> 16;
         x *= m1;
diff --git a/include/boost/container_hash/detail/hash_range.hpp b/include/boost/container_hash/detail/hash_range.hpp
index 84ec97d..74bfe38 100644
--- a/include/boost/container_hash/detail/hash_range.hpp
+++ b/include/boost/container_hash/detail/hash_range.hpp
@@ -7,10 +7,8 @@
 
 #include <boost/container_hash/hash_fwd.hpp>
 #include <boost/container_hash/detail/mulx.hpp>
-#include <boost/type_traits/integral_constant.hpp>
-#include <boost/type_traits/enable_if.hpp>
-#include <boost/type_traits/is_same.hpp>
-#include <boost/cstdint.hpp>
+#include <type_traits>
+#include <cstdint>
 #include <iterator>
 #include <limits>
 #include <cstddef>
@@ -22,20 +20,20 @@ namespace boost
 namespace hash_detail
 {
 
-template<class T> struct is_char_type: public boost::false_type {};
+template<class T> struct is_char_type: public std::false_type {};
 
 #if CHAR_BIT == 8
 
-template<> struct is_char_type<char>: public boost::true_type {};
-template<> struct is_char_type<signed char>: public boost::true_type {};
-template<> struct is_char_type<unsigned char>: public boost::true_type {};
+template<> struct is_char_type<char>: public std::true_type {};
+template<> struct is_char_type<signed char>: public std::true_type {};
+template<> struct is_char_type<unsigned char>: public std::true_type {};
 
 #if defined(__cpp_char8_t) && __cpp_char8_t >= 201811L
-template<> struct is_char_type<char8_t>: public boost::true_type {};
+template<> struct is_char_type<char8_t>: public std::true_type {};
 #endif
 
 #if defined(__cpp_lib_byte) && __cpp_lib_byte >= 201603L
-template<> struct is_char_type<std::byte>: public boost::true_type {};
+template<> struct is_char_type<std::byte>: public std::true_type {};
 #endif
 
 #endif
@@ -43,7 +41,7 @@ template<> struct is_char_type<std::byte>: public boost::true_type {};
 // generic version
 
 template<class It>
-inline typename boost::enable_if_<
+inline typename std::enable_if<
     !is_char_type<typename std::iterator_traits<It>::value_type>::value,
 std::size_t >::type
     hash_range( std::size_t seed, It first, It last )
@@ -58,25 +56,25 @@ std::size_t >::type
 
 // specialized char[] version, 32 bit
 
-template<class It> inline boost::uint32_t read32le( It p )
+template<class It> inline std::uint32_t read32le( It p )
 {
     // clang 5+, gcc 5+ figure out this pattern and use a single mov on x86
     // gcc on s390x and power BE even knows how to use load-reverse
 
-    boost::uint32_t w =
-        static_cast<boost::uint32_t>( static_cast<unsigned char>( p[0] ) ) |
-        static_cast<boost::uint32_t>( static_cast<unsigned char>( p[1] ) ) <<  8 |
-        static_cast<boost::uint32_t>( static_cast<unsigned char>( p[2] ) ) << 16 |
-        static_cast<boost::uint32_t>( static_cast<unsigned char>( p[3] ) ) << 24;
+    std::uint32_t w =
+        static_cast<std::uint32_t>( static_cast<unsigned char>( p[0] ) ) |
+        static_cast<std::uint32_t>( static_cast<unsigned char>( p[1] ) ) <<  8 |
+        static_cast<std::uint32_t>( static_cast<unsigned char>( p[2] ) ) << 16 |
+        static_cast<std::uint32_t>( static_cast<unsigned char>( p[3] ) ) << 24;
 
     return w;
 }
 
 #if defined(_MSC_VER) && !defined(__clang__)
 
-template<class T> inline boost::uint32_t read32le( T* p )
+template<class T> inline std::uint32_t read32le( T* p )
 {
-    boost::uint32_t w;
+    std::uint32_t w;
 
     std::memcpy( &w, p, 4 );
     return w;
@@ -84,15 +82,15 @@ template<class T> inline boost::uint32_t read32le( T* p )
 
 #endif
 
-inline boost::uint64_t mul32( boost::uint32_t x, boost::uint32_t y )
+inline std::uint64_t mul32( std::uint32_t x, std::uint32_t y )
 {
-    return static_cast<boost::uint64_t>( x ) * y;
+    return static_cast<std::uint64_t>( x ) * y;
 }
 
 template<class It>
-inline typename boost::enable_if_<
+inline typename std::enable_if<
     is_char_type<typename std::iterator_traits<It>::value_type>::value &&
-    is_same<typename std::iterator_traits<It>::iterator_category, std::random_access_iterator_tag>::value &&
+    std::is_same<typename std::iterator_traits<It>::iterator_category, std::random_access_iterator_tag>::value &&
     std::numeric_limits<std::size_t>::digits <= 32,
 std::size_t>::type
     hash_range( std::size_t seed, It first, It last )
@@ -100,17 +98,17 @@ std::size_t>::type
     It p = first;
     std::size_t n = static_cast<std::size_t>( last - first );
 
-    boost::uint32_t const q = 0x9e3779b9U;
-    boost::uint32_t const k = 0xe35e67b1U; // q * q
+    std::uint32_t const q = 0x9e3779b9U;
+    std::uint32_t const k = 0xe35e67b1U; // q * q
 
-    boost::uint64_t h = mul32( static_cast<boost::uint32_t>( seed ) + q, k );
-    boost::uint32_t w = static_cast<boost::uint32_t>( h & 0xFFFFFFFF );
+    std::uint64_t h = mul32( static_cast<std::uint32_t>( seed ) + q, k );
+    std::uint32_t w = static_cast<std::uint32_t>( h & 0xFFFFFFFF );
 
     h ^= n;
 
     while( n >= 4 )
     {
-        boost::uint32_t v1 = read32le( p );
+        std::uint32_t v1 = read32le( p );
 
         w += q;
         h ^= mul32( v1 + w, k );
@@ -120,7 +118,7 @@ std::size_t>::type
     }
 
     {
-        boost::uint32_t v1 = 0;
+        std::uint32_t v1 = 0;
 
         if( n >= 1 )
         {
@@ -128,9 +126,9 @@ std::size_t>::type
             std::size_t const x2 = n >> 1;        // 1: 0, 2: 1, 3: 1
 
             v1 =
-                static_cast<boost::uint32_t>( static_cast<unsigned char>( p[ static_cast<std::ptrdiff_t>( x1 ) ] ) ) << x1 * 8 |
-                static_cast<boost::uint32_t>( static_cast<unsigned char>( p[ static_cast<std::ptrdiff_t>( x2 ) ] ) ) << x2 * 8 |
-                static_cast<boost::uint32_t>( static_cast<unsigned char>( p[ 0 ] ) );
+                static_cast<std::uint32_t>( static_cast<unsigned char>( p[ static_cast<std::ptrdiff_t>( x1 ) ] ) ) << x1 * 8 |
+                static_cast<std::uint32_t>( static_cast<unsigned char>( p[ static_cast<std::ptrdiff_t>( x2 ) ] ) ) << x2 * 8 |
+                static_cast<std::uint32_t>( static_cast<unsigned char>( p[ 0 ] ) );
         }
 
         w += q;
@@ -138,28 +136,28 @@ std::size_t>::type
     }
 
     w += q;
-    h ^= mul32( static_cast<boost::uint32_t>( h & 0xFFFFFFFF ) + w, static_cast<boost::uint32_t>( h >> 32 ) + w + k );
+    h ^= mul32( static_cast<std::uint32_t>( h & 0xFFFFFFFF ) + w, static_cast<std::uint32_t>( h >> 32 ) + w + k );
 
-    return static_cast<boost::uint32_t>( h & 0xFFFFFFFF ) ^ static_cast<boost::uint32_t>( h >> 32 );
+    return static_cast<std::uint32_t>( h & 0xFFFFFFFF ) ^ static_cast<std::uint32_t>( h >> 32 );
 }
 
 template<class It>
-inline typename boost::enable_if_<
+inline typename std::enable_if<
     is_char_type<typename std::iterator_traits<It>::value_type>::value &&
-    !is_same<typename std::iterator_traits<It>::iterator_category, std::random_access_iterator_tag>::value &&
+    !std::is_same<typename std::iterator_traits<It>::iterator_category, std::random_access_iterator_tag>::value &&
     std::numeric_limits<std::size_t>::digits <= 32,
 std::size_t>::type
     hash_range( std::size_t seed, It first, It last )
 {
     std::size_t n = 0;
 
-    boost::uint32_t const q = 0x9e3779b9U;
-    boost::uint32_t const k = 0xe35e67b1U; // q * q
+    std::uint32_t const q = 0x9e3779b9U;
+    std::uint32_t const k = 0xe35e67b1U; // q * q
 
-    boost::uint64_t h = mul32( static_cast<boost::uint32_t>( seed ) + q, k );
-    boost::uint32_t w = static_cast<boost::uint32_t>( h & 0xFFFFFFFF );
+    std::uint64_t h = mul32( static_cast<std::uint32_t>( seed ) + q, k );
+    std::uint32_t w = static_cast<std::uint32_t>( h & 0xFFFFFFFF );
 
-    boost::uint32_t v1 = 0;
+    std::uint32_t v1 = 0;
 
     for( ;; )
     {
@@ -170,7 +168,7 @@ std::size_t>::type
             break;
         }
 
-        v1 |= static_cast<boost::uint32_t>( static_cast<unsigned char>( *first ) );
+        v1 |= static_cast<std::uint32_t>( static_cast<unsigned char>( *first ) );
         ++first;
         ++n;
 
@@ -179,7 +177,7 @@ std::size_t>::type
             break;
         }
 
-        v1 |= static_cast<boost::uint32_t>( static_cast<unsigned char>( *first ) ) << 8;
+        v1 |= static_cast<std::uint32_t>( static_cast<unsigned char>( *first ) ) << 8;
         ++first;
         ++n;
 
@@ -188,7 +186,7 @@ std::size_t>::type
             break;
         }
 
-        v1 |= static_cast<boost::uint32_t>( static_cast<unsigned char>( *first ) ) << 16;
+        v1 |= static_cast<std::uint32_t>( static_cast<unsigned char>( *first ) ) << 16;
         ++first;
         ++n;
 
@@ -197,7 +195,7 @@ std::size_t>::type
             break;
         }
 
-        v1 |= static_cast<boost::uint32_t>( static_cast<unsigned char>( *first ) ) << 24;
+        v1 |= static_cast<std::uint32_t>( static_cast<unsigned char>( *first ) ) << 24;
         ++first;
         ++n;
 
@@ -211,33 +209,33 @@ std::size_t>::type
     h ^= mul32( v1 + w, k );
 
     w += q;
-    h ^= mul32( static_cast<boost::uint32_t>( h & 0xFFFFFFFF ) + w, static_cast<boost::uint32_t>( h >> 32 ) + w + k );
+    h ^= mul32( static_cast<std::uint32_t>( h & 0xFFFFFFFF ) + w, static_cast<std::uint32_t>( h >> 32 ) + w + k );
 
-    return static_cast<boost::uint32_t>( h & 0xFFFFFFFF ) ^ static_cast<boost::uint32_t>( h >> 32 );
+    return static_cast<std::uint32_t>( h & 0xFFFFFFFF ) ^ static_cast<std::uint32_t>( h >> 32 );
 }
 
 // specialized char[] version, 64 bit
 
-template<class It> inline boost::uint64_t read64le( It p )
+template<class It> inline std::uint64_t read64le( It p )
 {
-    boost::uint64_t w =
-        static_cast<boost::uint64_t>( static_cast<unsigned char>( p[0] ) ) |
-        static_cast<boost::uint64_t>( static_cast<unsigned char>( p[1] ) ) <<  8 |
-        static_cast<boost::uint64_t>( static_cast<unsigned char>( p[2] ) ) << 16 |
-        static_cast<boost::uint64_t>( static_cast<unsigned char>( p[3] ) ) << 24 |
-        static_cast<boost::uint64_t>( static_cast<unsigned char>( p[4] ) ) << 32 |
-        static_cast<boost::uint64_t>( static_cast<unsigned char>( p[5] ) ) << 40 |
-        static_cast<boost::uint64_t>( static_cast<unsigned char>( p[6] ) ) << 48 |
-        static_cast<boost::uint64_t>( static_cast<unsigned char>( p[7] ) ) << 56;
+    std::uint64_t w =
+        static_cast<std::uint64_t>( static_cast<unsigned char>( p[0] ) ) |
+        static_cast<std::uint64_t>( static_cast<unsigned char>( p[1] ) ) <<  8 |
+        static_cast<std::uint64_t>( static_cast<unsigned char>( p[2] ) ) << 16 |
+        static_cast<std::uint64_t>( static_cast<unsigned char>( p[3] ) ) << 24 |
+        static_cast<std::uint64_t>( static_cast<unsigned char>( p[4] ) ) << 32 |
+        static_cast<std::uint64_t>( static_cast<unsigned char>( p[5] ) ) << 40 |
+        static_cast<std::uint64_t>( static_cast<unsigned char>( p[6] ) ) << 48 |
+        static_cast<std::uint64_t>( static_cast<unsigned char>( p[7] ) ) << 56;
 
     return w;
 }
 
 #if defined(_MSC_VER) && !defined(__clang__)
 
-template<class T> inline boost::uint64_t read64le( T* p )
+template<class T> inline std::uint64_t read64le( T* p )
 {
-    boost::uint64_t w;
+    std::uint64_t w;
 
     std::memcpy( &w, p, 8 );
     return w;
@@ -246,9 +244,9 @@ template<class T> inline boost::uint64_t read64le( T* p )
 #endif
 
 template<class It>
-inline typename boost::enable_if_<
+inline typename std::enable_if<
     is_char_type<typename std::iterator_traits<It>::value_type>::value &&
-    is_same<typename std::iterator_traits<It>::iterator_category, std::random_access_iterator_tag>::value &&
+    std::is_same<typename std::iterator_traits<It>::iterator_category, std::random_access_iterator_tag>::value &&
     (std::numeric_limits<std::size_t>::digits > 32),
 std::size_t>::type
     hash_range( std::size_t seed, It first, It last )
@@ -256,15 +254,15 @@ std::size_t>::type
     It p = first;
     std::size_t n = static_cast<std::size_t>( last - first );
 
-    boost::uint64_t const q = static_cast<boost::uint64_t>( 0x9e3779b9 ) << 32 | 0x7f4a7c15;
-    boost::uint64_t const k = static_cast<boost::uint64_t>( 0xdf442d22 ) << 32 | 0xce4859b9; // q * q
+    std::uint64_t const q = 0x9e3779b97f4a7c15;
+    std::uint64_t const k = 0xdf442d22ce4859b9; // q * q
 
-    boost::uint64_t w = mulx( seed + q, k );
-    boost::uint64_t h = w ^ n;
+    std::uint64_t w = mulx( seed + q, k );
+    std::uint64_t h = w ^ n;
 
     while( n >= 8 )
     {
-        boost::uint64_t v1 = read64le( p );
+        std::uint64_t v1 = read64le( p );
 
         w += q;
         h ^= mulx( v1 + w, k );
@@ -274,11 +272,11 @@ std::size_t>::type
     }
 
     {
-        boost::uint64_t v1 = 0;
+        std::uint64_t v1 = 0;
 
         if( n >= 4 )
         {
-            v1 = static_cast<boost::uint64_t>( read32le( p + static_cast<std::ptrdiff_t>( n - 4 ) ) ) << ( n - 4 ) * 8 | read32le( p );
+            v1 = static_cast<std::uint64_t>( read32le( p + static_cast<std::ptrdiff_t>( n - 4 ) ) ) << ( n - 4 ) * 8 | read32le( p );
         }
         else if( n >= 1 )
         {
@@ -286,9 +284,9 @@ std::size_t>::type
             std::size_t const x2 = n >> 1;        // 1: 0, 2: 1, 3: 1
 
             v1 =
-                static_cast<boost::uint64_t>( static_cast<unsigned char>( p[ static_cast<std::ptrdiff_t>( x1 ) ] ) ) << x1 * 8 |
-                static_cast<boost::uint64_t>( static_cast<unsigned char>( p[ static_cast<std::ptrdiff_t>( x2 ) ] ) ) << x2 * 8 |
-                static_cast<boost::uint64_t>( static_cast<unsigned char>( p[ 0 ] ) );
+                static_cast<std::uint64_t>( static_cast<unsigned char>( p[ static_cast<std::ptrdiff_t>( x1 ) ] ) ) << x1 * 8 |
+                static_cast<std::uint64_t>( static_cast<unsigned char>( p[ static_cast<std::ptrdiff_t>( x2 ) ] ) ) << x2 * 8 |
+                static_cast<std::uint64_t>( static_cast<unsigned char>( p[ 0 ] ) );
         }
 
         w += q;
@@ -299,22 +297,22 @@ std::size_t>::type
 }
 
 template<class It>
-inline typename boost::enable_if_<
+inline typename std::enable_if<
     is_char_type<typename std::iterator_traits<It>::value_type>::value &&
-    !is_same<typename std::iterator_traits<It>::iterator_category, std::random_access_iterator_tag>::value &&
+    !std::is_same<typename std::iterator_traits<It>::iterator_category, std::random_access_iterator_tag>::value &&
     (std::numeric_limits<std::size_t>::digits > 32),
 std::size_t>::type
     hash_range( std::size_t seed, It first, It last )
 {
     std::size_t n = 0;
 
-    boost::uint64_t const q = static_cast<boost::uint64_t>( 0x9e3779b9 ) << 32 | 0x7f4a7c15;
-    boost::uint64_t const k = static_cast<boost::uint64_t>( 0xdf442d22 ) << 32 | 0xce4859b9; // q * q
+    std::uint64_t const q = 0x9e3779b97f4a7c15;
+    std::uint64_t const k = 0xdf442d22ce4859b9; // q * q
 
-    boost::uint64_t w = mulx( seed + q, k );
-    boost::uint64_t h = w;
+    std::uint64_t w = mulx( seed + q, k );
+    std::uint64_t h = w;
 
-    boost::uint64_t v1 = 0;
+    std::uint64_t v1 = 0;
 
     for( ;; )
     {
@@ -325,7 +323,7 @@ std::size_t>::type
             break;
         }
 
-        v1 |= static_cast<boost::uint64_t>( static_cast<unsigned char>( *first ) );
+        v1 |= static_cast<std::uint64_t>( static_cast<unsigned char>( *first ) );
         ++first;
         ++n;
 
@@ -334,7 +332,7 @@ std::size_t>::type
             break;
         }
 
-        v1 |= static_cast<boost::uint64_t>( static_cast<unsigned char>( *first ) ) << 8;
+        v1 |= static_cast<std::uint64_t>( static_cast<unsigned char>( *first ) ) << 8;
         ++first;
         ++n;
 
@@ -343,7 +341,7 @@ std::size_t>::type
             break;
         }
 
-        v1 |= static_cast<boost::uint64_t>( static_cast<unsigned char>( *first ) ) << 16;
+        v1 |= static_cast<std::uint64_t>( static_cast<unsigned char>( *first ) ) << 16;
         ++first;
         ++n;
 
@@ -352,7 +350,7 @@ std::size_t>::type
             break;
         }
 
-        v1 |= static_cast<boost::uint64_t>( static_cast<unsigned char>( *first ) ) << 24;
+        v1 |= static_cast<std::uint64_t>( static_cast<unsigned char>( *first ) ) << 24;
         ++first;
         ++n;
 
@@ -361,7 +359,7 @@ std::size_t>::type
             break;
         }
 
-        v1 |= static_cast<boost::uint64_t>( static_cast<unsigned char>( *first ) ) << 32;
+        v1 |= static_cast<std::uint64_t>( static_cast<unsigned char>( *first ) ) << 32;
         ++first;
         ++n;
 
@@ -370,7 +368,7 @@ std::size_t>::type
             break;
         }
 
-        v1 |= static_cast<boost::uint64_t>( static_cast<unsigned char>( *first ) ) << 40;
+        v1 |= static_cast<std::uint64_t>( static_cast<unsigned char>( *first ) ) << 40;
         ++first;
         ++n;
 
@@ -379,7 +377,7 @@ std::size_t>::type
             break;
         }
 
-        v1 |= static_cast<boost::uint64_t>( static_cast<unsigned char>( *first ) ) << 48;
+        v1 |= static_cast<std::uint64_t>( static_cast<unsigned char>( *first ) ) << 48;
         ++first;
         ++n;
 
@@ -388,7 +386,7 @@ std::size_t>::type
             break;
         }
 
-        v1 |= static_cast<boost::uint64_t>( static_cast<unsigned char>( *first ) ) << 56;
+        v1 |= static_cast<std::uint64_t>( static_cast<unsigned char>( *first ) ) << 56;
         ++first;
         ++n;
 
diff --git a/include/boost/container_hash/detail/hash_tuple_like.hpp b/include/boost/container_hash/detail/hash_tuple_like.hpp
index f9f5a5b..c7f881c 100644
--- a/include/boost/container_hash/detail/hash_tuple_like.hpp
+++ b/include/boost/container_hash/detail/hash_tuple_like.hpp
@@ -9,17 +9,8 @@
 #include <boost/container_hash/hash_fwd.hpp>
 #include <boost/container_hash/is_tuple_like.hpp>
 #include <boost/container_hash/is_range.hpp>
-#include <boost/type_traits/enable_if.hpp>
-#include <boost/config.hpp>
-#include <boost/config/workaround.hpp>
-
-#if defined(BOOST_NO_CXX11_HDR_TUPLE)
-
-// no support for tuple-likes
-
-#else
-
-#include <tuple>
+#include <type_traits>
+#include <utility>
 
 namespace boost
 {
@@ -28,14 +19,14 @@ namespace hash_detail
 
 template <std::size_t I, typename T>
 inline
-typename boost::enable_if_<(I == std::tuple_size<T>::value), void>::type
+typename std::enable_if<(I == std::tuple_size<T>::value), void>::type
     hash_combine_tuple_like( std::size_t&, T const& )
 {
 }
 
 template <std::size_t I, typename T>
 inline
-typename boost::enable_if_<(I < std::tuple_size<T>::value), void>::type
+typename std::enable_if<(I < std::tuple_size<T>::value), void>::type
     hash_combine_tuple_like( std::size_t& seed, T const& v )
 {
     using std::get;
@@ -56,13 +47,9 @@ inline std::size_t hash_tuple_like( T const& v )
 
 } // namespace hash_detail
 
-#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-
-#if !BOOST_WORKAROUND(BOOST_MSVC, <= 1800)
-
 template <class T>
 inline
-typename boost::enable_if_<
+typename std::enable_if<
     container_hash::is_tuple_like<T>::value && !container_hash::is_range<T>::value,
 std::size_t>::type
     hash_value( T const& v )
@@ -70,87 +57,6 @@ std::size_t>::type
     return boost::hash_detail::hash_tuple_like( v );
 }
 
-#else
-
-template <typename... T>
-inline std::size_t hash_value( std::tuple<T...> const& v )
-{
-    return boost::hash_detail::hash_tuple_like( v );
-}
-
-#endif
-
-#else
-
-inline std::size_t hash_value( std::tuple<> const& v )
-{
-    return boost::hash_detail::hash_tuple_like( v );
-}
-
-template<typename A0>
-inline std::size_t hash_value( std::tuple<A0> const& v )
-{
-    return boost::hash_detail::hash_tuple_like( v );
-}
-
-template<typename A0, typename A1>
-inline std::size_t hash_value( std::tuple<A0, A1> const& v )
-{
-    return boost::hash_detail::hash_tuple_like( 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_like( 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_like( 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_like( 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_like( 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_like( 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_like( 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_like( 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_like( v );
-}
-
-#endif // #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-
 } // namespace boost
 
-#endif // #if defined(BOOST_NO_CXX11_HDR_TUPLE)
-
 #endif // #ifndef BOOST_HASH_DETAIL_HASH_TUPLE_LIKE_HPP
diff --git a/include/boost/container_hash/detail/mulx.hpp b/include/boost/container_hash/detail/mulx.hpp
index da6f21a..a99a7dd 100644
--- a/include/boost/container_hash/detail/mulx.hpp
+++ b/include/boost/container_hash/detail/mulx.hpp
@@ -5,7 +5,7 @@
 #ifndef BOOST_HASH_DETAIL_MULX_HPP
 #define BOOST_HASH_DETAIL_MULX_HPP
 
-#include <boost/cstdint.hpp>
+#include <cstdint>
 #if defined(_MSC_VER)
 # include <intrin.h>
 #endif
@@ -17,55 +17,55 @@ namespace hash_detail
 
 #if defined(_MSC_VER) && defined(_M_X64) && !defined(__clang__)
 
-__forceinline boost::uint64_t mulx( boost::uint64_t x, boost::uint64_t y )
+__forceinline std::uint64_t mulx( std::uint64_t x, std::uint64_t y )
 {
-    boost::uint64_t r2;
-    boost::uint64_t r = _umul128( x, y, &r2 );
+    std::uint64_t r2;
+    std::uint64_t r = _umul128( x, y, &r2 );
     return r ^ r2;
 }
 
 #elif defined(_MSC_VER) && defined(_M_ARM64) && !defined(__clang__)
 
-__forceinline boost::uint64_t mulx( boost::uint64_t x, boost::uint64_t y )
+__forceinline std::uint64_t mulx( std::uint64_t x, std::uint64_t y )
 {
-    boost::uint64_t r = x * y;
-    boost::uint64_t r2 = __umulh( x, y );
+    std::uint64_t r = x * y;
+    std::uint64_t r2 = __umulh( x, y );
     return r ^ r2;
 }
 
 #elif defined(__SIZEOF_INT128__)
 
-inline boost::uint64_t mulx( boost::uint64_t x, boost::uint64_t y )
+inline std::uint64_t mulx( std::uint64_t x, std::uint64_t y )
 {
     __uint128_t r = static_cast<__uint128_t>( x ) * y;
-    return static_cast<boost::uint64_t>( r ) ^ static_cast<boost::uint64_t>( r >> 64 );
+    return static_cast<std::uint64_t>( r ) ^ static_cast<std::uint64_t>( r >> 64 );
 }
 
 #else
 
-inline boost::uint64_t mulx( boost::uint64_t x, boost::uint64_t y )
+inline std::uint64_t mulx( std::uint64_t x, std::uint64_t y )
 {
-    boost::uint64_t x1 = static_cast<boost::uint32_t>( x );
-    boost::uint64_t x2 = x >> 32;
+    std::uint64_t x1 = static_cast<std::uint32_t>( x );
+    std::uint64_t x2 = x >> 32;
 
-    boost::uint64_t y1 = static_cast<boost::uint32_t>( y );
-    boost::uint64_t y2 = y >> 32;
+    std::uint64_t y1 = static_cast<std::uint32_t>( y );
+    std::uint64_t y2 = y >> 32;
 
-    boost::uint64_t r3 = x2 * y2;
+    std::uint64_t r3 = x2 * y2;
 
-    boost::uint64_t r2a = x1 * y2;
+    std::uint64_t r2a = x1 * y2;
 
     r3 += r2a >> 32;
 
-    boost::uint64_t r2b = x2 * y1;
+    std::uint64_t r2b = x2 * y1;
 
     r3 += r2b >> 32;
 
-    boost::uint64_t r1 = x1 * y1;
+    std::uint64_t r1 = x1 * y1;
 
-    boost::uint64_t r2 = (r1 >> 32) + static_cast<boost::uint32_t>( r2a ) + static_cast<boost::uint32_t>( r2b );
+    std::uint64_t r2 = (r1 >> 32) + static_cast<std::uint32_t>( r2a ) + static_cast<std::uint32_t>( r2b );
 
-    r1 = (r2 << 32) + static_cast<boost::uint32_t>( r1 );
+    r1 = (r2 << 32) + static_cast<std::uint32_t>( r1 );
     r3 += r2 >> 32;
 
     return r1 ^ r3;
diff --git a/include/boost/container_hash/hash.hpp b/include/boost/container_hash/hash.hpp
index 605644b..f523c96 100644
--- a/include/boost/container_hash/hash.hpp
+++ b/include/boost/container_hash/hash.hpp
@@ -11,7 +11,6 @@
 #define BOOST_FUNCTIONAL_HASH_HASH_HPP
 
 #include <boost/container_hash/hash_fwd.hpp>
-#include <boost/container_hash/detail/requires_cxx11.hpp>
 #include <boost/container_hash/is_range.hpp>
 #include <boost/container_hash/is_contiguous_range.hpp>
 #include <boost/container_hash/is_unordered_range.hpp>
@@ -19,19 +18,10 @@
 #include <boost/container_hash/detail/hash_tuple_like.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/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/type_traits/is_same.hpp>
 #include <boost/describe/bases.hpp>
 #include <boost/describe/members.hpp>
-#include <boost/cstdint.hpp>
+#include <type_traits>
+#include <cstdint>
 
 #if defined(BOOST_DESCRIBE_CXX14)
 # include <boost/mp11/algorithm.hpp>
@@ -82,7 +72,7 @@ namespace boost
     {
         template<class T,
             bool bigger_than_size_t = (sizeof(T) > sizeof(std::size_t)),
-            bool is_unsigned = boost::is_unsigned<T>::value,
+            bool is_unsigned = std::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;
@@ -99,7 +89,7 @@ namespace boost
         {
             static std::size_t fn( T v )
             {
-                typedef typename boost::make_unsigned<T>::type U;
+                typedef typename std::make_unsigned<T>::type U;
 
                 if( v >= 0 )
                 {
@@ -156,7 +146,7 @@ namespace boost
     } // namespace hash_detail
 
     template <typename T>
-    typename boost::enable_if_<boost::is_integral<T>::value, std::size_t>::type
+    typename std::enable_if<std::is_integral<T>::value, std::size_t>::type
         hash_value( T v )
     {
         return hash_detail::hash_integral_impl<T>::fn( v );
@@ -165,7 +155,7 @@ namespace boost
     // enumeration types
 
     template <typename T>
-    typename boost::enable_if_<boost::is_enum<T>::value, std::size_t>::type
+    typename std::enable_if<std::is_enum<T>::value, std::size_t>::type
         hash_value( T v )
     {
         // This should in principle return the equivalent of
@@ -199,7 +189,7 @@ namespace boost
         {
             static std::size_t fn( T v )
             {
-                boost::uint32_t w;
+                std::uint32_t w;
                 std::memcpy( &w, &v, sizeof( v ) );
 
                 return w;
@@ -211,7 +201,7 @@ namespace boost
         {
             static std::size_t fn( T v )
             {
-                boost::uint64_t w;
+                std::uint64_t w;
                 std::memcpy( &w, &v, sizeof( v ) );
 
                 return hash_value( w );
@@ -223,7 +213,7 @@ namespace boost
         {
             static std::size_t fn( T v )
             {
-                boost::uint64_t w[ 2 ] = {};
+                std::uint64_t w[ 2 ] = {};
                 std::memcpy( &w, &v, 80 / CHAR_BIT );
 
                 std::size_t seed = 0;
@@ -240,7 +230,7 @@ namespace boost
         {
             static std::size_t fn( T v )
             {
-                boost::uint64_t w[ 2 ] = {};
+                std::uint64_t w[ 2 ] = {};
                 std::memcpy( &w, &v, 80 / CHAR_BIT );
 
                 std::size_t seed = 0;
@@ -257,7 +247,7 @@ namespace boost
         {
             static std::size_t fn( T v )
             {
-                boost::uint64_t w[ 2 ];
+                std::uint64_t w[ 2 ];
                 std::memcpy( &w, &v, sizeof( v ) );
 
                 std::size_t seed = 0;
@@ -280,7 +270,7 @@ namespace boost
     } // namespace hash_detail
 
     template <typename T>
-    typename boost::enable_if_<boost::is_floating_point<T>::value, std::size_t>::type
+    typename std::enable_if<std::is_floating_point<T>::value, std::size_t>::type
         hash_value( T v )
     {
         return boost::hash_detail::hash_float_impl<T>::fn( v + 0 );
@@ -291,7 +281,7 @@ namespace boost
     // `x + (x >> 3)` adjustment by Alberto Barbati and Dave Harris.
     template <class T> std::size_t hash_value( T* const& v )
     {
-        boost::uintptr_t x = reinterpret_cast<boost::uintptr_t>( v );
+        std::uintptr_t x = reinterpret_cast<std::uintptr_t>( v );
         return boost::hash_value( x + (x >> 3) );
     }
 
@@ -336,7 +326,7 @@ namespace boost
     // ranges (list, set, deque...)
 
     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
+    typename std::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 )
     {
         return boost::hash_range( v.begin(), v.end() );
@@ -345,7 +335,7 @@ namespace boost
     // contiguous ranges (string, vector, array)
 
     template <typename T>
-    typename boost::enable_if_<container_hash::is_contiguous_range<T>::value, std::size_t>::type
+    typename std::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() );
@@ -354,7 +344,7 @@ namespace boost
     // unordered ranges (unordered_set, unordered_map)
 
     template <typename T>
-    typename boost::enable_if_<container_hash::is_unordered_range<T>::value, std::size_t>::type
+    typename std::enable_if<container_hash::is_unordered_range<T>::value, std::size_t>::type
         hash_value( T const& v )
     {
         return boost::hash_unordered_range( v.begin(), v.end() );
@@ -367,7 +357,7 @@ namespace boost
     // 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
+    typename std::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 boost::hash_range( v.begin(), v.end() );
@@ -376,14 +366,14 @@ namespace boost
     // 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
+    typename std::enable_if<container_hash::is_contiguous_range<L<T...>>::value, std::size_t>::type
         hash_value( L<T...> const& v )
     {
         return boost::hash_range( v.data(), v.data() + v.size() );
     }
 
     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
+    typename std::enable_if<container_hash::is_contiguous_range<L<T, N>>::value, std::size_t>::type
         hash_value( L<T, N> const& v )
     {
         return boost::hash_range( v.data(), v.data() + v.size() );
@@ -392,7 +382,7 @@ namespace boost
     // 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
+    typename std::enable_if<container_hash::is_unordered_range<L<T...>>::value, std::size_t>::type
         hash_value( L<T...> const& v )
     {
         return boost::hash_unordered_range( v.begin(), v.end() );
@@ -410,10 +400,10 @@ namespace boost
 #endif
 
     template <typename T>
-    typename boost::enable_if_<container_hash::is_described_class<T>::value, std::size_t>::type
+    typename std::enable_if<container_hash::is_described_class<T>::value, std::size_t>::type
         hash_value( T const& v )
     {
-        static_assert( !boost::is_union<T>::value, "described unions are not supported" );
+        static_assert( !std::is_union<T>::value, "described unions are not supported" );
 
         std::size_t r = 0;
 
@@ -503,7 +493,7 @@ namespace boost
 #if !defined(BOOST_NO_CXX11_NULLPTR)
 
     template <typename T>
-    typename boost::enable_if_<boost::is_same<T, std::nullptr_t>::value, std::size_t>::type
+    typename std::enable_if<std::is_same<T, std::nullptr_t>::value, std::size_t>::type
         hash_value( T const& /*v*/ )
     {
         return boost::hash_value( static_cast<void*>( nullptr ) );
@@ -520,7 +510,7 @@ namespace boost
     {
         if( !v )
         {
-            // Arbitray value for empty optional.
+            // Arbitrary value for empty optional.
             return 0x12345678;
         }
         else
@@ -654,20 +644,11 @@ namespace boost
     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
+        template<class Ch> struct hash_is_avalanching< boost::hash< std::basic_string<Ch> > >: std::is_integral<Ch> {};
 
 #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(__cpp_char8_t) && __cpp_char8_t >= 201811L
-        template<> struct hash_is_avalanching< boost::hash< std::basic_string_view<char8_t> > >: boost::true_type {};
-#endif
+        template<class Ch> struct hash_is_avalanching< boost::hash< std::basic_string_view<Ch> > >: std::is_integral<Ch> {};
 
 #endif
     } // namespace unordered
diff --git a/include/boost/container_hash/is_contiguous_range.hpp b/include/boost/container_hash/is_contiguous_range.hpp
index 96043cc..c18db6b 100644
--- a/include/boost/container_hash/is_contiguous_range.hpp
+++ b/include/boost/container_hash/is_contiguous_range.hpp
@@ -5,17 +5,13 @@
 #ifndef BOOST_HASH_IS_CONTIGUOUS_RANGE_HPP_INCLUDED
 #define BOOST_HASH_IS_CONTIGUOUS_RANGE_HPP_INCLUDED
 
-#include <boost/container_hash/detail/requires_cxx11.hpp>
 #include <boost/container_hash/is_range.hpp>
-#include <boost/type_traits/integral_constant.hpp>
 #include <boost/config.hpp>
 #include <boost/config/workaround.hpp>
+#include <type_traits>
 
-#if !defined(BOOST_NO_CXX11_DECLTYPE) && !defined(BOOST_NO_SFINAE_EXPR) && !BOOST_WORKAROUND(BOOST_GCC, < 40700) && !BOOST_WORKAROUND(BOOST_MSVC, < 1910)
+#if !BOOST_WORKAROUND(BOOST_MSVC, < 1910)
 
-#include <boost/type_traits/is_integral.hpp>
-#include <boost/type_traits/declval.hpp>
-#include <boost/type_traits/is_same.hpp>
 #include <iterator>
 
 namespace boost
@@ -24,11 +20,11 @@ namespace hash_detail
 {
 
 template<class It, class T, class S>
-    integral_constant< bool, is_same<typename std::iterator_traits<It>::value_type, T>::value && is_integral<S>::value >
+    std::integral_constant< bool, std::is_same<typename std::iterator_traits<It>::value_type, T>::value && std::is_integral<S>::value >
         is_contiguous_range_check( It first, It last, T const*, T const*, S );
 
-template<class T> decltype( is_contiguous_range_check( declval<T const&>().begin(), declval<T const&>().end(), declval<T const&>().data(), declval<T const&>().data() + declval<T const&>().size(), declval<T const&>().size() ) ) is_contiguous_range_( int );
-template<class T> false_type is_contiguous_range_( ... );
+template<class T> decltype( is_contiguous_range_check( std::declval<T const&>().begin(), std::declval<T const&>().end(), std::declval<T const&>().data(), std::declval<T const&>().data() + std::declval<T const&>().size(), std::declval<T const&>().size() ) ) is_contiguous_range_( int );
+template<class T> std::false_type is_contiguous_range_( ... );
 
 template<class T> struct is_contiguous_range: decltype( hash_detail::is_contiguous_range_<T>( 0 ) )
 {
@@ -39,54 +35,64 @@ template<class T> struct is_contiguous_range: decltype( hash_detail::is_contiguo
 namespace container_hash
 {
 
-template<class T> struct is_contiguous_range: integral_constant< bool, is_range<T>::value && hash_detail::is_contiguous_range<T>::value >
+template<class T> struct is_contiguous_range: std::integral_constant< bool, is_range<T>::value && hash_detail::is_contiguous_range<T>::value >
 {
 };
 
 } // namespace container_hash
 } // namespace boost
 
-#else // !defined(BOOST_NO_CXX11_DECLTYPE) && !defined(BOOST_NO_SFINAE_EXPR)
+#else // !BOOST_WORKAROUND(BOOST_MSVC, < 1910)
 
 #include <cstddef>
 #include <vector>
 #include <string>
-#if !defined(BOOST_NO_CXX11_HDR_ARRAY)
 #include <array>
-#endif
 
 namespace boost
 {
 namespace container_hash
 {
 
-template<class T> struct is_contiguous_range: false_type
+template<class T> struct is_contiguous_range: std::false_type
 {
 };
 
-template<class E, class T, class A> struct is_contiguous_range< std::basic_string<E, T, A> >: true_type
+template<class E, class T, class A> struct is_contiguous_range< std::basic_string<E, T, A> >: std::true_type
 {
 };
 
-template<class E, class T, class A> struct is_contiguous_range< std::basic_string<E, T, A> const >: true_type
+template<class E, class T, class A> struct is_contiguous_range< std::basic_string<E, T, A> const >: std::true_type
 {
 };
 
-#if !defined(BOOST_NO_CXX11_HDR_ARRAY)
-
-template<class T, std::size_t N> struct is_contiguous_range< std::array<T, N> >: true_type
+template<class T, class A> struct is_contiguous_range< std::vector<T, A> >: std::true_type
 {
 };
 
-template<class T, std::size_t N> struct is_contiguous_range< std::array<T, N> const >: true_type
+template<class T, class A> struct is_contiguous_range< std::vector<T, A> const >: std::true_type
 {
 };
 
-#endif
+template<class A> struct is_contiguous_range< std::vector<bool, A> >: std::false_type
+{
+};
+
+template<class A> struct is_contiguous_range< std::vector<bool, A> const >: std::false_type
+{
+};
+
+template<class T, std::size_t N> struct is_contiguous_range< std::array<T, N> >: std::true_type
+{
+};
+
+template<class T, std::size_t N> struct is_contiguous_range< std::array<T, N> const >: std::true_type
+{
+};
 
 } // namespace container_hash
 } // namespace boost
 
-#endif // !defined(BOOST_NO_CXX11_DECLTYPE) && !defined(BOOST_NO_SFINAE_EXPR)
+#endif // !BOOST_WORKAROUND(BOOST_MSVC, < 1910)
 
 #endif // #ifndef BOOST_HASH_IS_CONTIGUOUS_RANGE_HPP_INCLUDED
diff --git a/include/boost/container_hash/is_described_class.hpp b/include/boost/container_hash/is_described_class.hpp
index cd2e1db..88f8ed3 100644
--- a/include/boost/container_hash/is_described_class.hpp
+++ b/include/boost/container_hash/is_described_class.hpp
@@ -5,10 +5,9 @@
 #ifndef BOOST_HASH_IS_DESCRIBED_CLASS_HPP_INCLUDED
 #define BOOST_HASH_IS_DESCRIBED_CLASS_HPP_INCLUDED
 
-#include <boost/type_traits/integral_constant.hpp>
-#include <boost/type_traits/is_union.hpp>
 #include <boost/describe/bases.hpp>
 #include <boost/describe/members.hpp>
+#include <type_traits>
 
 namespace boost
 {
@@ -17,16 +16,16 @@ namespace container_hash
 
 #if defined(BOOST_DESCRIBE_CXX11)
 
-template<class T> struct is_described_class: boost::integral_constant<bool,
+template<class T> struct is_described_class: std::integral_constant<bool,
     describe::has_describe_bases<T>::value &&
     describe::has_describe_members<T>::value &&
-    !boost::is_union<T>::value>
+    !std::is_union<T>::value>
 {
 };
 
 #else
 
-template<class T> struct is_described_class: boost::false_type
+template<class T> struct is_described_class: std::false_type
 {
 };
 
diff --git a/include/boost/container_hash/is_range.hpp b/include/boost/container_hash/is_range.hpp
index 2d3746c..f0b067f 100644
--- a/include/boost/container_hash/is_range.hpp
+++ b/include/boost/container_hash/is_range.hpp
@@ -5,29 +5,21 @@
 #ifndef BOOST_HASH_IS_RANGE_HPP_INCLUDED
 #define BOOST_HASH_IS_RANGE_HPP_INCLUDED
 
-#include <boost/container_hash/detail/requires_cxx11.hpp>
-#include <boost/type_traits/integral_constant.hpp>
-#include <boost/type_traits/is_integral.hpp>
-#include <boost/type_traits/declval.hpp>
-#include <boost/type_traits/is_same.hpp>
-#include <boost/type_traits/remove_cv.hpp>
-#include <boost/config.hpp>
-#include <boost/config/workaround.hpp>
 #include <iterator>
+#include <type_traits>
 
 namespace boost
 {
-#if !defined(BOOST_NO_CXX11_DECLTYPE) && !defined(BOOST_NO_SFINAE_EXPR) && !BOOST_WORKAROUND(BOOST_GCC, < 40700)
 
 namespace hash_detail
 {
 
 template<class T, class It>
-    integral_constant< bool, !is_same<typename remove_cv<T>::type, typename std::iterator_traits<It>::value_type>::value >
+    std::integral_constant< bool, !std::is_same<typename std::remove_cv<T>::type, typename std::iterator_traits<It>::value_type>::value >
         is_range_check( It first, It last );
 
-template<class T> decltype( is_range_check<T>( declval<T const&>().begin(), declval<T const&>().end() ) ) is_range_( int );
-template<class T> false_type is_range_( ... );
+template<class T> decltype( is_range_check<T>( std::declval<T const&>().begin(), std::declval<T const&>().end() ) ) is_range_( int );
+template<class T> std::false_type is_range_( ... );
 
 } // namespace hash_detail
 
@@ -40,35 +32,6 @@ template<class T> struct is_range: decltype( hash_detail::is_range_<T>( 0 ) )
 
 } // namespace container_hash
 
-#else
-
-namespace hash_detail
-{
-
-template<class T, class E = true_type> struct is_range_: false_type
-{
-};
-
-template<class T> struct is_range_< T, integral_constant< bool,
-        is_same<typename T::value_type, typename std::iterator_traits<typename T::const_iterator>::value_type>::value &&
-        is_integral<typename T::size_type>::value
-    > >: true_type
-{
-};
-
-} // namespace hash_detail
-
-namespace container_hash
-{
-
-template<class T> struct is_range: hash_detail::is_range_<T>
-{
-};
-
-} // namespace container_hash
-
-#endif // !defined(BOOST_NO_CXX11_DECLTYPE) && !defined(BOOST_NO_SFINAE_EXPR)
-
 } // namespace boost
 
 #endif // #ifndef BOOST_HASH_IS_RANGE_HPP_INCLUDED
diff --git a/include/boost/container_hash/is_tuple_like.hpp b/include/boost/container_hash/is_tuple_like.hpp
index 8f57364..48728cd 100644
--- a/include/boost/container_hash/is_tuple_like.hpp
+++ b/include/boost/container_hash/is_tuple_like.hpp
@@ -5,9 +5,7 @@
 // Distributed under the Boost Software License, Version 1.0.
 // https://www.boost.org/LICENSE_1_0.txt
 
-#include <boost/type_traits/integral_constant.hpp>
-#include <boost/config.hpp>
-#include <boost/config/workaround.hpp>
+#include <type_traits>
 #include <utility>
 
 namespace boost
@@ -15,18 +13,14 @@ namespace boost
 namespace hash_detail
 {
 
-template<class T, class E = true_type> struct is_tuple_like_: false_type
+template<class T, class E = std::true_type> struct is_tuple_like_: std::false_type
 {
 };
 
-#if !defined(BOOST_NO_CXX11_HDR_TUPLE) && !BOOST_WORKAROUND(BOOST_MSVC, <= 1800)
-
-template<class T> struct is_tuple_like_<T, integral_constant<bool, std::tuple_size<T>::value == std::tuple_size<T>::value> >: true_type
+template<class T> struct is_tuple_like_<T, std::integral_constant<bool, std::tuple_size<T>::value == std::tuple_size<T>::value> >: std::true_type
 {
 };
 
-#endif
-
 } // namespace hash_detail
 
 namespace container_hash
diff --git a/include/boost/container_hash/is_unordered_range.hpp b/include/boost/container_hash/is_unordered_range.hpp
index 11ee386..5a81b7d 100644
--- a/include/boost/container_hash/is_unordered_range.hpp
+++ b/include/boost/container_hash/is_unordered_range.hpp
@@ -6,21 +6,20 @@
 #define BOOST_HASH_IS_UNORDERED_RANGE_HPP_INCLUDED
 
 #include <boost/container_hash/is_range.hpp>
-#include <boost/type_traits/integral_constant.hpp>
-#include <boost/type_traits/is_same.hpp>
+#include <type_traits>
 
 namespace boost
 {
 namespace hash_detail
 {
 
-template<class T, class E = true_type> struct has_hasher_: false_type
+template<class T, class E = std::true_type> struct has_hasher_: std::false_type
 {
 };
 
-template<class T> struct has_hasher_< T, integral_constant< bool,
-        is_same<typename T::hasher, typename T::hasher>::value
-    > >: true_type
+template<class T> struct has_hasher_< T, std::integral_constant< bool,
+        std::is_same<typename T::hasher, typename T::hasher>::value
+    > >: std::true_type
 {
 };
 
@@ -29,7 +28,7 @@ template<class T> struct has_hasher_< T, integral_constant< bool,
 namespace container_hash
 {
 
-template<class T> struct is_unordered_range: integral_constant< bool, is_range<T>::value && hash_detail::has_hasher_<T>::value >
+template<class T> struct is_unordered_range: std::integral_constant< bool, is_range<T>::value && hash_detail::has_hasher_<T>::value >
 {
 };
 
diff --git a/test/is_contiguous_range_test.cpp b/test/is_contiguous_range_test.cpp
index 9ce6664..9b77a9c 100644
--- a/test/is_contiguous_range_test.cpp
+++ b/test/is_contiguous_range_test.cpp
@@ -50,11 +50,11 @@ int main()
     BOOST_TEST_TRAIT_TRUE((is_contiguous_range<std::wstring>));
     BOOST_TEST_TRAIT_TRUE((is_contiguous_range<std::wstring const>));
 
-// std::vector doesn't have data() in C++03
-#if !defined(BOOST_NO_CXX11_DECLTYPE) && !defined(BOOST_NO_SFINAE_EXPR) && !BOOST_WORKAROUND(BOOST_GCC, < 40700) && !BOOST_WORKAROUND(BOOST_MSVC, < 1910)
     BOOST_TEST_TRAIT_TRUE((is_contiguous_range< std::vector<X> >));
     BOOST_TEST_TRAIT_TRUE((is_contiguous_range< std::vector<X> const >));
-#endif
+
+    BOOST_TEST_TRAIT_FALSE((is_contiguous_range< std::vector<bool> >));
+    BOOST_TEST_TRAIT_FALSE((is_contiguous_range< std::vector<bool> const >));
 
     BOOST_TEST_TRAIT_FALSE((is_contiguous_range< std::deque<X> >));
     BOOST_TEST_TRAIT_FALSE((is_contiguous_range< std::deque<X> const >));