boostorg/container_hash
1
0
Fork 1
mirror of https://github.com/boostorg/container_hash.git synced 2025-08-03 14:34:39 +02:00
Code Issues Packages Projects Releases Wiki Activity

Remove C++03 workarounds

Browse Source
This commit is contained in:
Peter Dimov
2023-10-12 13:57:41 +03:00
parent b8496de2f2
commit 565bac8d31
11 changed files with 189 additions and 343 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
include/boost/container_hash/detail/hash_mix.hpp
View File

@@ -5,7 +5,7 @@
#ifndef BOOST_HASH_DETAIL_HASH_MIX_HPP #ifndef BOOST_HASH_DETAIL_HASH_MIX_HPP
#define BOOST_HASH_DETAIL_HASH_MIX_HPP #define BOOST_HASH_DETAIL_HASH_MIX_HPP
#include <boost/cstdint.hpp> #include <cstdint>
#include <cstddef> #include <cstddef>
#include <climits> #include <climits>
@@ -66,9 +66,9 @@ template<std::size_t Bits> struct hash_mix_impl;
template<> struct hash_mix_impl<64> 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 ^= x >> 32;
x *= m; x *= m;
@@ -87,10 +87,10 @@ template<> struct hash_mix_impl<64>
template<> struct hash_mix_impl<32> 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; std::uint32_t const m1 = 0x21f0aaad;
boost::uint32_t const m2 = 0x735a2d97; std::uint32_t const m2 = 0x735a2d97;
x ^= x >> 16; x ^= x >> 16;
x *= m1; x *= m1;

170
include/boost/container_hash/detail/hash_range.hpp
View File

@@ -7,10 +7,8 @@
#include <boost/container_hash/hash_fwd.hpp> #include <boost/container_hash/hash_fwd.hpp>
#include <boost/container_hash/detail/mulx.hpp> #include <boost/container_hash/detail/mulx.hpp>
#include <boost/type_traits/integral_constant.hpp> #include <type_traits>
#include <boost/type_traits/enable_if.hpp> #include <cstdint>
#include <boost/type_traits/is_same.hpp>
#include <boost/cstdint.hpp>
#include <iterator> #include <iterator>
#include <limits> #include <limits>
#include <cstddef> #include <cstddef>
@@ -22,20 +20,20 @@ namespace boost
namespace hash_detail 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 #if CHAR_BIT == 8
template<> struct is_char_type<char>: public boost::true_type {}; template<> struct is_char_type<char>: public std::true_type {};
template<> struct is_char_type<signed char>: public boost::true_type {}; template<> struct is_char_type<signed char>: public std::true_type {};
template<> struct is_char_type<unsigned char>: public boost::true_type {}; template<> struct is_char_type<unsigned char>: public std::true_type {};
#if defined(__cpp_char8_t) && __cpp_char8_t >= 201811L #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 #endif
#if defined(__cpp_lib_byte) && __cpp_lib_byte >= 201603L #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
#endif #endif
@@ -43,7 +41,7 @@ template<> struct is_char_type<std::byte>: public boost::true_type {};
// generic version // generic version
template<class It> 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_char_type<typename std::iterator_traits<It>::value_type>::value,
std::size_t >::type std::size_t >::type
hash_range( std::size_t seed, It first, It last ) hash_range( std::size_t seed, It first, It last )
@@ -58,25 +56,25 @@ std::size_t >::type
// specialized char[] version, 32 bit // 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 // 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 // gcc on s390x and power BE even knows how to use load-reverse
boost::uint32_t w = std::uint32_t w =
static_cast<boost::uint32_t>( static_cast<unsigned char>( p[0] ) ) | static_cast<std::uint32_t>( static_cast<unsigned char>( p[0] ) ) |
static_cast<boost::uint32_t>( static_cast<unsigned char>( p[1] ) ) << 8 | static_cast<std::uint32_t>( static_cast<unsigned char>( p[1] ) ) << 8 |
static_cast<boost::uint32_t>( static_cast<unsigned char>( p[2] ) ) << 16 | static_cast<std::uint32_t>( static_cast<unsigned char>( p[2] ) ) << 16 |
static_cast<boost::uint32_t>( static_cast<unsigned char>( p[3] ) ) << 24; static_cast<std::uint32_t>( static_cast<unsigned char>( p[3] ) ) << 24;
return w; return w;
} }
#if defined(_MSC_VER) && !defined(__clang__) #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 ); std::memcpy( &w, p, 4 );
return w; return w;
@@ -84,15 +82,15 @@ template<class T> inline boost::uint32_t read32le( T* p )
#endif #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> 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_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::numeric_limits<std::size_t>::digits <= 32,
std::size_t>::type std::size_t>::type
hash_range( std::size_t seed, It first, It last ) hash_range( std::size_t seed, It first, It last )
@@ -100,17 +98,17 @@ std::size_t>::type
It p = first; It p = first;
std::size_t n = static_cast<std::size_t>( last - first ); std::size_t n = static_cast<std::size_t>( last - first );
boost::uint32_t const q = 0x9e3779b9U; std::uint32_t const q = 0x9e3779b9U;
boost::uint32_t const k = 0xe35e67b1U; // q * q std::uint32_t const k = 0xe35e67b1U; // q * q
boost::uint64_t h = mul32( static_cast<boost::uint32_t>( seed ) + q, k ); std::uint64_t h = mul32( static_cast<std::uint32_t>( seed ) + q, k );
boost::uint32_t w = static_cast<boost::uint32_t>( h & 0xFFFFFFFF ); std::uint32_t w = static_cast<std::uint32_t>( h & 0xFFFFFFFF );
h ^= n; h ^= n;
while( n >= 4 ) while( n >= 4 )
{ {
boost::uint32_t v1 = read32le( p ); std::uint32_t v1 = read32le( p );
w += q; w += q;
h ^= mul32( v1 + w, k ); 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 ) if( n >= 1 )
{ {
@@ -128,9 +126,9 @@ std::size_t>::type
std::size_t const x2 = n >> 1; // 1: 0, 2: 1, 3: 1 std::size_t const x2 = n >> 1; // 1: 0, 2: 1, 3: 1
v1 = v1 =
static_cast<boost::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>( x1 ) ] ) ) << x1 * 8 |
static_cast<boost::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[ 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[ 0 ] ) );
} }
w += q; w += q;
@@ -138,28 +136,28 @@ std::size_t>::type
} }
w += q; 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> 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_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::numeric_limits<std::size_t>::digits <= 32,
std::size_t>::type std::size_t>::type
hash_range( std::size_t seed, It first, It last ) hash_range( std::size_t seed, It first, It last )
{ {
std::size_t n = 0; std::size_t n = 0;
boost::uint32_t const q = 0x9e3779b9U; std::uint32_t const q = 0x9e3779b9U;
boost::uint32_t const k = 0xe35e67b1U; // q * q std::uint32_t const k = 0xe35e67b1U; // q * q
boost::uint64_t h = mul32( static_cast<boost::uint32_t>( seed ) + q, k ); std::uint64_t h = mul32( static_cast<std::uint32_t>( seed ) + q, k );
boost::uint32_t w = static_cast<boost::uint32_t>( h & 0xFFFFFFFF ); std::uint32_t w = static_cast<std::uint32_t>( h & 0xFFFFFFFF );
boost::uint32_t v1 = 0; std::uint32_t v1 = 0;
for( ;; ) for( ;; )
{ {
@@ -170,7 +168,7 @@ std::size_t>::type
break; break;
} }
v1 |= static_cast<boost::uint32_t>( static_cast<unsigned char>( *first ) ); v1 |= static_cast<std::uint32_t>( static_cast<unsigned char>( *first ) );
++first; ++first;
++n; ++n;
@@ -179,7 +177,7 @@ std::size_t>::type
break; 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; ++first;
++n; ++n;
@@ -188,7 +186,7 @@ std::size_t>::type
break; 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; ++first;
++n; ++n;
@@ -197,7 +195,7 @@ std::size_t>::type
break; 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; ++first;
++n; ++n;
@@ -211,33 +209,33 @@ std::size_t>::type
h ^= mul32( v1 + w, k ); h ^= mul32( v1 + w, k );
w += q; 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 // 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 = std::uint64_t w =
static_cast<boost::uint64_t>( static_cast<unsigned char>( p[0] ) ) | static_cast<std::uint64_t>( static_cast<unsigned char>( p[0] ) ) |
static_cast<boost::uint64_t>( static_cast<unsigned char>( p[1] ) ) << 8 | static_cast<std::uint64_t>( static_cast<unsigned char>( p[1] ) ) << 8 |
static_cast<boost::uint64_t>( static_cast<unsigned char>( p[2] ) ) << 16 | static_cast<std::uint64_t>( static_cast<unsigned char>( p[2] ) ) << 16 |
static_cast<boost::uint64_t>( static_cast<unsigned char>( p[3] ) ) << 24 | static_cast<std::uint64_t>( static_cast<unsigned char>( p[3] ) ) << 24 |
static_cast<boost::uint64_t>( static_cast<unsigned char>( p[4] ) ) << 32 | static_cast<std::uint64_t>( static_cast<unsigned char>( p[4] ) ) << 32 |
static_cast<boost::uint64_t>( static_cast<unsigned char>( p[5] ) ) << 40 | static_cast<std::uint64_t>( static_cast<unsigned char>( p[5] ) ) << 40 |
static_cast<boost::uint64_t>( static_cast<unsigned char>( p[6] ) ) << 48 | static_cast<std::uint64_t>( static_cast<unsigned char>( p[6] ) ) << 48 |
static_cast<boost::uint64_t>( static_cast<unsigned char>( p[7] ) ) << 56; static_cast<std::uint64_t>( static_cast<unsigned char>( p[7] ) ) << 56;
return w; return w;
} }
#if defined(_MSC_VER) && !defined(__clang__) #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 ); std::memcpy( &w, p, 8 );
return w; return w;
@@ -246,9 +244,9 @@ template<class T> inline boost::uint64_t read64le( T* p )
#endif #endif
template<class It> 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_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::numeric_limits<std::size_t>::digits > 32),
std::size_t>::type std::size_t>::type
hash_range( std::size_t seed, It first, It last ) hash_range( std::size_t seed, It first, It last )
@@ -256,15 +254,15 @@ std::size_t>::type
It p = first; It p = first;
std::size_t n = static_cast<std::size_t>( last - 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; std::uint64_t const q = 0x9e3779b97f4a7c15;
boost::uint64_t const k = static_cast<boost::uint64_t>( 0xdf442d22 ) << 32 | 0xce4859b9; // q * q std::uint64_t const k = 0xdf442d22ce4859b9; // q * q
boost::uint64_t w = mulx( seed + q, k ); std::uint64_t w = mulx( seed + q, k );
boost::uint64_t h = w ^ n; std::uint64_t h = w ^ n;
while( n >= 8 ) while( n >= 8 )
{ {
boost::uint64_t v1 = read64le( p ); std::uint64_t v1 = read64le( p );
w += q; w += q;
h ^= mulx( v1 + w, k ); 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 ) 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 ) 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 std::size_t const x2 = n >> 1; // 1: 0, 2: 1, 3: 1
v1 = v1 =
static_cast<boost::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>( x1 ) ] ) ) << x1 * 8 |
static_cast<boost::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[ 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[ 0 ] ) );
} }
w += q; w += q;
@@ -299,22 +297,22 @@ std::size_t>::type
} }
template<class It> 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_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::numeric_limits<std::size_t>::digits > 32),
std::size_t>::type std::size_t>::type
hash_range( std::size_t seed, It first, It last ) hash_range( std::size_t seed, It first, It last )
{ {
std::size_t n = 0; std::size_t n = 0;
boost::uint64_t const q = static_cast<boost::uint64_t>( 0x9e3779b9 ) << 32 | 0x7f4a7c15; std::uint64_t const q = 0x9e3779b97f4a7c15;
boost::uint64_t const k = static_cast<boost::uint64_t>( 0xdf442d22 ) << 32 | 0xce4859b9; // q * q std::uint64_t const k = 0xdf442d22ce4859b9; // q * q
boost::uint64_t w = mulx( seed + q, k ); std::uint64_t w = mulx( seed + q, k );
boost::uint64_t h = w; std::uint64_t h = w;
boost::uint64_t v1 = 0; std::uint64_t v1 = 0;
for( ;; ) for( ;; )
{ {
@@ -325,7 +323,7 @@ std::size_t>::type
break; break;
} }
v1 |= static_cast<boost::uint64_t>( static_cast<unsigned char>( *first ) ); v1 |= static_cast<std::uint64_t>( static_cast<unsigned char>( *first ) );
++first; ++first;
++n; ++n;
@@ -334,7 +332,7 @@ std::size_t>::type
break; 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; ++first;
++n; ++n;
@@ -343,7 +341,7 @@ std::size_t>::type
break; 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; ++first;
++n; ++n;
@@ -352,7 +350,7 @@ std::size_t>::type
break; 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; ++first;
++n; ++n;
@@ -361,7 +359,7 @@ std::size_t>::type
break; 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; ++first;
++n; ++n;
@@ -370,7 +368,7 @@ std::size_t>::type
break; 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; ++first;
++n; ++n;
@@ -379,7 +377,7 @@ std::size_t>::type
break; 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; ++first;
++n; ++n;
@@ -388,7 +386,7 @@ std::size_t>::type
break; 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; ++first;
++n; ++n;

104
include/boost/container_hash/detail/hash_tuple_like.hpp
View File

@@ -9,17 +9,8 @@
#include <boost/container_hash/hash_fwd.hpp> #include <boost/container_hash/hash_fwd.hpp>
#include <boost/container_hash/is_tuple_like.hpp> #include <boost/container_hash/is_tuple_like.hpp>
#include <boost/container_hash/is_range.hpp> #include <boost/container_hash/is_range.hpp>
#include <boost/type_traits/enable_if.hpp> #include <type_traits>
#include <boost/config.hpp> #include <utility>
#include <boost/config/workaround.hpp>
#if defined(BOOST_NO_CXX11_HDR_TUPLE)
// no support for tuple-likes
#else
#include <tuple>
namespace boost namespace boost
{ {
@@ -28,14 +19,14 @@ namespace hash_detail
template <std::size_t I, typename T> template <std::size_t I, typename T>
inline 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& ) hash_combine_tuple_like( std::size_t&, T const& )
{ {
} }
template <std::size_t I, typename T> template <std::size_t I, typename T>
inline 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 ) hash_combine_tuple_like( std::size_t& seed, T const& v )
{ {
using std::get; using std::get;
@@ -56,13 +47,9 @@ inline std::size_t hash_tuple_like( T const& v )
} // namespace hash_detail } // namespace hash_detail
#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
#if !BOOST_WORKAROUND(BOOST_MSVC, <= 1800)
template <class T> template <class T>
inline inline
typename boost::enable_if_< typename std::enable_if<
container_hash::is_tuple_like<T>::value && !container_hash::is_range<T>::value, container_hash::is_tuple_like<T>::value && !container_hash::is_range<T>::value,
std::size_t>::type std::size_t>::type
hash_value( T const& v ) hash_value( T const& v )
@@ -70,87 +57,6 @@ std::size_t>::type
return boost::hash_detail::hash_tuple_like( v ); 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 } // namespace boost
#endif // #if defined(BOOST_NO_CXX11_HDR_TUPLE)
#endif // #ifndef BOOST_HASH_DETAIL_HASH_TUPLE_LIKE_HPP #endif // #ifndef BOOST_HASH_DETAIL_HASH_TUPLE_LIKE_HPP

40
include/boost/container_hash/detail/mulx.hpp
View File

@@ -5,7 +5,7 @@
#ifndef BOOST_HASH_DETAIL_MULX_HPP #ifndef BOOST_HASH_DETAIL_MULX_HPP
#define BOOST_HASH_DETAIL_MULX_HPP #define BOOST_HASH_DETAIL_MULX_HPP
#include <boost/cstdint.hpp> #include <cstdint>
#if defined(_MSC_VER) #if defined(_MSC_VER)
# include <intrin.h> # include <intrin.h>
#endif #endif
@@ -17,55 +17,55 @@ namespace hash_detail
#if defined(_MSC_VER) && defined(_M_X64) && !defined(__clang__) #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; std::uint64_t r2;
boost::uint64_t r = _umul128( x, y, &r2 ); std::uint64_t r = _umul128( x, y, &r2 );
return r ^ r2; return r ^ r2;
} }
#elif defined(_MSC_VER) && defined(_M_ARM64) && !defined(__clang__) #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; std::uint64_t r = x * y;
boost::uint64_t r2 = __umulh( x, y ); std::uint64_t r2 = __umulh( x, y );
return r ^ r2; return r ^ r2;
} }
#elif defined(__SIZEOF_INT128__) #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; __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 #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 ); std::uint64_t x1 = static_cast<std::uint32_t>( x );
boost::uint64_t x2 = x >> 32; std::uint64_t x2 = x >> 32;
boost::uint64_t y1 = static_cast<boost::uint32_t>( y ); std::uint64_t y1 = static_cast<std::uint32_t>( y );
boost::uint64_t y2 = y >> 32; 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; r3 += r2a >> 32;
boost::uint64_t r2b = x2 * y1; std::uint64_t r2b = x2 * y1;
r3 += r2b >> 32; 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; r3 += r2 >> 32;
return r1 ^ r3; return r1 ^ r3;

71
include/boost/container_hash/hash.hpp
View File

@@ -11,7 +11,6 @@
#define BOOST_FUNCTIONAL_HASH_HASH_HPP #define BOOST_FUNCTIONAL_HASH_HASH_HPP
#include <boost/container_hash/hash_fwd.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_range.hpp>
#include <boost/container_hash/is_contiguous_range.hpp> #include <boost/container_hash/is_contiguous_range.hpp>
#include <boost/container_hash/is_unordered_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_tuple_like.hpp>
#include <boost/container_hash/detail/hash_mix.hpp> #include <boost/container_hash/detail/hash_mix.hpp>
#include <boost/container_hash/detail/hash_range.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/bases.hpp>
#include <boost/describe/members.hpp> #include <boost/describe/members.hpp>
#include <boost/cstdint.hpp> #include <type_traits>
#include <cstdint>
#if defined(BOOST_DESCRIBE_CXX14) #if defined(BOOST_DESCRIBE_CXX14)
# include <boost/mp11/algorithm.hpp> # include <boost/mp11/algorithm.hpp>
@@ -82,7 +72,7 @@ namespace boost
{ {
template<class T, template<class T,
bool bigger_than_size_t = (sizeof(T) > sizeof(std::size_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 size_t_bits = sizeof(std::size_t) * CHAR_BIT,
std::size_t type_bits = sizeof(T) * CHAR_BIT> std::size_t type_bits = sizeof(T) * CHAR_BIT>
struct hash_integral_impl; struct hash_integral_impl;
@@ -99,7 +89,7 @@ namespace boost
{ {
static std::size_t fn( T v ) 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 ) if( v >= 0 )
{ {
@@ -156,7 +146,7 @@ namespace boost
} // namespace hash_detail } // namespace hash_detail
template <typename T> 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 ) hash_value( T v )
{ {
return hash_detail::hash_integral_impl<T>::fn( v ); return hash_detail::hash_integral_impl<T>::fn( v );
@@ -165,7 +155,7 @@ namespace boost
// enumeration types // enumeration types
template <typename T> 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 ) hash_value( T v )
{ {
// This should in principle return the equivalent of // This should in principle return the equivalent of
@@ -199,7 +189,7 @@ namespace boost
{ {
static std::size_t fn( T v ) static std::size_t fn( T v )
{ {
boost::uint32_t w; std::uint32_t w;
std::memcpy( &w, &v, sizeof( v ) ); std::memcpy( &w, &v, sizeof( v ) );
return w; return w;
@@ -211,7 +201,7 @@ namespace boost
{ {
static std::size_t fn( T v ) static std::size_t fn( T v )
{ {
boost::uint64_t w; std::uint64_t w;
std::memcpy( &w, &v, sizeof( v ) ); std::memcpy( &w, &v, sizeof( v ) );
return hash_value( w ); return hash_value( w );
@@ -223,7 +213,7 @@ namespace boost
{ {
static std::size_t fn( T v ) 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::memcpy( &w, &v, 80 / CHAR_BIT );
std::size_t seed = 0; std::size_t seed = 0;
@@ -240,7 +230,7 @@ namespace boost
{ {
static std::size_t fn( T v ) 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::memcpy( &w, &v, 80 / CHAR_BIT );
std::size_t seed = 0; std::size_t seed = 0;
@@ -257,7 +247,7 @@ namespace boost
{ {
static std::size_t fn( T v ) static std::size_t fn( T v )
{ {
boost::uint64_t w[ 2 ]; std::uint64_t w[ 2 ];
std::memcpy( &w, &v, sizeof( v ) ); std::memcpy( &w, &v, sizeof( v ) );
std::size_t seed = 0; std::size_t seed = 0;
@@ -280,7 +270,7 @@ namespace boost
} // namespace hash_detail } // namespace hash_detail
template <typename T> 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 ) hash_value( T v )
{ {
return boost::hash_detail::hash_float_impl<T>::fn( v + 0 ); 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. // `x + (x >> 3)` adjustment by Alberto Barbati and Dave Harris.
template <class T> std::size_t hash_value( T* const& v ) 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) ); return boost::hash_value( x + (x >> 3) );
} }
@@ -336,7 +326,7 @@ namespace boost
// ranges (list, set, deque...) // ranges (list, set, deque...)
template <typename T> 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 ) hash_value( T const& v )
{ {
return boost::hash_range( v.begin(), v.end() ); return boost::hash_range( v.begin(), v.end() );
@@ -345,7 +335,7 @@ namespace boost
// contiguous ranges (string, vector, array) // contiguous ranges (string, vector, array)
template <typename T> 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 ) hash_value( T const& v )
{ {
return boost::hash_range( v.data(), v.data() + v.size() ); return boost::hash_range( v.data(), v.data() + v.size() );
@@ -354,7 +344,7 @@ namespace boost
// unordered ranges (unordered_set, unordered_map) // unordered ranges (unordered_set, unordered_map)
template <typename T> 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 ) hash_value( T const& v )
{ {
return boost::hash_unordered_range( v.begin(), v.end() ); return boost::hash_unordered_range( v.begin(), v.end() );
@@ -367,7 +357,7 @@ namespace boost
// resolve ambiguity with unconstrained stdext::hash_value in <xhash> :-/ // resolve ambiguity with unconstrained stdext::hash_value in <xhash> :-/
template<template<class...> class L, class... T> 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 ) hash_value( L<T...> const& v )
{ {
return boost::hash_range( v.begin(), v.end() ); return boost::hash_range( v.begin(), v.end() );
@@ -376,14 +366,14 @@ namespace boost
// contiguous ranges (string, vector, array) // contiguous ranges (string, vector, array)
template<template<class...> class L, class... T> 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 ) hash_value( L<T...> const& v )
{ {
return boost::hash_range( v.data(), v.data() + v.size() ); return boost::hash_range( v.data(), v.data() + v.size() );
} }
template<template<class, std::size_t> class L, class T, std::size_t N> 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 ) hash_value( L<T, N> const& v )
{ {
return boost::hash_range( v.data(), v.data() + v.size() ); return boost::hash_range( v.data(), v.data() + v.size() );
@@ -392,7 +382,7 @@ namespace boost
// unordered ranges (unordered_set, unordered_map) // unordered ranges (unordered_set, unordered_map)
template<template<class...> class L, class... T> 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 ) hash_value( L<T...> const& v )
{ {
return boost::hash_unordered_range( v.begin(), v.end() ); return boost::hash_unordered_range( v.begin(), v.end() );
@@ -410,10 +400,10 @@ namespace boost
#endif #endif
template <typename T> 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 ) 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; std::size_t r = 0;
@@ -503,7 +493,7 @@ namespace boost
#if !defined(BOOST_NO_CXX11_NULLPTR) #if !defined(BOOST_NO_CXX11_NULLPTR)
template <typename T> 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*/ ) hash_value( T const& /*v*/ )
{ {
return boost::hash_value( static_cast<void*>( nullptr ) ); return boost::hash_value( static_cast<void*>( nullptr ) );
@@ -520,7 +510,7 @@ namespace boost
{ {
if( !v ) if( !v )
{ {
// Arbitray value for empty optional. // Arbitrary value for empty optional.
return 0x12345678; return 0x12345678;
} }
else else
@@ -654,20 +644,11 @@ namespace boost
namespace unordered namespace unordered
{ {
template<class T> struct hash_is_avalanching; template<class T> struct hash_is_avalanching;
template<class Ch> struct hash_is_avalanching< boost::hash< std::basic_string<Ch> > >: boost::is_integral<Ch> {}; template<class Ch> struct hash_is_avalanching< boost::hash< std::basic_string<Ch> > >: std::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
#if !defined(BOOST_NO_CXX17_HDR_STRING_VIEW) #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> {}; template<class Ch> struct hash_is_avalanching< boost::hash< std::basic_string_view<Ch> > >: std::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
#endif #endif
} // namespace unordered } // namespace unordered

50
include/boost/container_hash/is_contiguous_range.hpp
View File

@@ -5,17 +5,13 @@
#ifndef BOOST_HASH_IS_CONTIGUOUS_RANGE_HPP_INCLUDED #ifndef BOOST_HASH_IS_CONTIGUOUS_RANGE_HPP_INCLUDED
#define 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/container_hash/is_range.hpp>
#include <boost/type_traits/integral_constant.hpp>
#include <boost/config.hpp> #include <boost/config.hpp>
#include <boost/config/workaround.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> #include <iterator>
namespace boost namespace boost
@@ -24,11 +20,11 @@ namespace hash_detail
{ {
template<class It, class T, class S> 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 ); 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> 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> false_type is_contiguous_range_( ... ); template<class T> std::false_type is_contiguous_range_( ... );
template<class T> struct is_contiguous_range: decltype( hash_detail::is_contiguous_range_<T>( 0 ) ) 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 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 container_hash
} // namespace boost } // namespace boost
#else // !defined(BOOST_NO_CXX11_DECLTYPE) && !defined(BOOST_NO_SFINAE_EXPR) #else // !BOOST_WORKAROUND(BOOST_MSVC, < 1910)
#include <cstddef> #include <cstddef>
#include <vector> #include <vector>
#include <string> #include <string>
#if !defined(BOOST_NO_CXX11_HDR_ARRAY)
#include <array> #include <array>
#endif
namespace boost namespace boost
{ {
namespace container_hash 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, 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> >: 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 container_hash
} // namespace boost } // 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 #endif // #ifndef BOOST_HASH_IS_CONTIGUOUS_RANGE_HPP_INCLUDED

9
include/boost/container_hash/is_described_class.hpp
View File

@@ -5,10 +5,9 @@
#ifndef BOOST_HASH_IS_DESCRIBED_CLASS_HPP_INCLUDED #ifndef BOOST_HASH_IS_DESCRIBED_CLASS_HPP_INCLUDED
#define 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/bases.hpp>
#include <boost/describe/members.hpp> #include <boost/describe/members.hpp>
#include <type_traits>
namespace boost namespace boost
{ {
@@ -17,16 +16,16 @@ namespace container_hash
#if defined(BOOST_DESCRIBE_CXX11) #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_bases<T>::value &&
describe::has_describe_members<T>::value && describe::has_describe_members<T>::value &&
!boost::is_union<T>::value> !std::is_union<T>::value>
{ {
}; };
#else #else
template<class T> struct is_described_class: boost::false_type template<class T> struct is_described_class: std::false_type
{ {
}; };

45
include/boost/container_hash/is_range.hpp
View File

@@ -5,29 +5,21 @@
#ifndef BOOST_HASH_IS_RANGE_HPP_INCLUDED #ifndef BOOST_HASH_IS_RANGE_HPP_INCLUDED
#define 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 <iterator>
#include <type_traits>
namespace boost namespace boost
{ {
#if !defined(BOOST_NO_CXX11_DECLTYPE) && !defined(BOOST_NO_SFINAE_EXPR) && !BOOST_WORKAROUND(BOOST_GCC, < 40700)
namespace hash_detail namespace hash_detail
{ {
template<class T, class It> 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 ); 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> decltype( is_range_check<T>( std::declval<T const&>().begin(), std::declval<T const&>().end() ) ) is_range_( int );
template<class T> false_type is_range_( ... ); template<class T> std::false_type is_range_( ... );
} // namespace hash_detail } // namespace hash_detail
@@ -40,35 +32,6 @@ template<class T> struct is_range: decltype( hash_detail::is_range_<T>( 0 ) )
} // namespace container_hash } // 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 } // namespace boost
#endif // #ifndef BOOST_HASH_IS_RANGE_HPP_INCLUDED #endif // #ifndef BOOST_HASH_IS_RANGE_HPP_INCLUDED

12
include/boost/container_hash/is_tuple_like.hpp
View File

@@ -5,9 +5,7 @@
// Distributed under the Boost Software License, Version 1.0. // Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt // https://www.boost.org/LICENSE_1_0.txt
#include <boost/type_traits/integral_constant.hpp> #include <type_traits>
#include <boost/config.hpp>
#include <boost/config/workaround.hpp>
#include <utility> #include <utility>
namespace boost namespace boost
@@ -15,18 +13,14 @@ namespace boost
namespace hash_detail 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, std::integral_constant<bool, std::tuple_size<T>::value == std::tuple_size<T>::value> >: std::true_type
template<class T> struct is_tuple_like_<T, integral_constant<bool, std::tuple_size<T>::value == std::tuple_size<T>::value> >: true_type
{ {
}; };
#endif
} // namespace hash_detail } // namespace hash_detail
namespace container_hash namespace container_hash

13
include/boost/container_hash/is_unordered_range.hpp
View File

@@ -6,21 +6,20 @@
#define BOOST_HASH_IS_UNORDERED_RANGE_HPP_INCLUDED #define BOOST_HASH_IS_UNORDERED_RANGE_HPP_INCLUDED
#include <boost/container_hash/is_range.hpp> #include <boost/container_hash/is_range.hpp>
#include <boost/type_traits/integral_constant.hpp> #include <type_traits>
#include <boost/type_traits/is_same.hpp>
namespace boost namespace boost
{ {
namespace hash_detail 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, template<class T> struct has_hasher_< T, std::integral_constant< bool,
is_same<typename T::hasher, typename T::hasher>::value std::is_same<typename T::hasher, typename T::hasher>::value
> >: true_type > >: std::true_type
{ {
}; };
@@ -29,7 +28,7 @@ template<class T> struct has_hasher_< T, integral_constant< bool,
namespace container_hash 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 >
{ {
}; };

6
test/is_contiguous_range_test.cpp
View File

@@ -50,11 +50,11 @@ int main()
BOOST_TEST_TRAIT_TRUE((is_contiguous_range<std::wstring>)); BOOST_TEST_TRAIT_TRUE((is_contiguous_range<std::wstring>));
BOOST_TEST_TRAIT_TRUE((is_contiguous_range<std::wstring const>)); 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> >));
BOOST_TEST_TRAIT_TRUE((is_contiguous_range< std::vector<X> const >)); 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> >));
BOOST_TEST_TRAIT_FALSE((is_contiguous_range< std::deque<X> const >)); BOOST_TEST_TRAIT_FALSE((is_contiguous_range< std::deque<X> const >));