taynpg/cxxLibrary
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

整理

Browse Source
This commit is contained in:
taynpg
2026-03-23 20:54:41 +08:00
commit e13b3650e9
4596 changed files with 1015768 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

146
include/boost/container_hash/detail/hash_integral.hpp Normal file
View File

@@ -0,0 +1,146 @@
// Copyright 2021-2023 Peter Dimov
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt
#ifndef BOOST_HASH_DETAIL_HASH_INTEGRAL_HPP
#define BOOST_HASH_DETAIL_HASH_INTEGRAL_HPP
#include <boost/container_hash/detail/hash_mix.hpp>
#include <type_traits>
#include <cstddef>
#include <climits>
namespace boost
{
namespace hash_detail
{
// libstdc++ doesn't provide support for __int128 in the standard traits
template<class T> struct is_integral: public std::is_integral<T>
{
};
template<class T> struct is_unsigned: public std::is_unsigned<T>
{
};
template<class T> struct make_unsigned: public std::make_unsigned<T>
{
};
#if defined(__SIZEOF_INT128__)
template<> struct is_integral<__int128_t>: public std::true_type
{
};
template<> struct is_integral<__uint128_t>: public std::true_type
{
};
template<> struct is_unsigned<__int128_t>: public std::false_type
{
};
template<> struct is_unsigned<__uint128_t>: public std::true_type
{
};
template<> struct make_unsigned<__int128_t>
{
typedef __uint128_t type;
};
template<> struct make_unsigned<__uint128_t>
{
typedef __uint128_t type;
};
#endif
template<class T,
bool bigger_than_size_t = (sizeof(T) > sizeof(std::size_t)),
bool is_unsigned = is_unsigned<T>::value,
std::size_t size_t_bits = sizeof(std::size_t) * CHAR_BIT,
std::size_t type_bits = sizeof(T) * CHAR_BIT>
struct hash_integral_impl;
template<class T, bool is_unsigned, std::size_t size_t_bits, std::size_t type_bits> struct hash_integral_impl<T, false, is_unsigned, size_t_bits, type_bits>
{
static std::size_t fn( T v )
{
return static_cast<std::size_t>( v );
}
};
template<class T, std::size_t size_t_bits, std::size_t type_bits> struct hash_integral_impl<T, true, false, size_t_bits, type_bits>
{
static std::size_t fn( T v )
{
typedef typename make_unsigned<T>::type U;
if( v >= 0 )
{
return hash_integral_impl<U>::fn( static_cast<U>( v ) );
}
else
{
return ~hash_integral_impl<U>::fn( static_cast<U>( ~static_cast<U>( v ) ) );
}
}
};
template<class T> struct hash_integral_impl<T, true, true, 32, 64>
{
static std::size_t fn( T v )
{
std::size_t seed = 0;
seed = static_cast<std::size_t>( v >> 32 ) + hash_detail::hash_mix( seed );
seed = static_cast<std::size_t>( v & 0xFFFFFFFF ) + hash_detail::hash_mix( seed );
return seed;
}
};
template<class T> struct hash_integral_impl<T, true, true, 32, 128>
{
static std::size_t fn( T v )
{
std::size_t seed = 0;
seed = static_cast<std::size_t>( v >> 96 ) + hash_detail::hash_mix( seed );
seed = static_cast<std::size_t>( v >> 64 ) + hash_detail::hash_mix( seed );
seed = static_cast<std::size_t>( v >> 32 ) + hash_detail::hash_mix( seed );
seed = static_cast<std::size_t>( v ) + hash_detail::hash_mix( seed );
return seed;
}
};
template<class T> struct hash_integral_impl<T, true, true, 64, 128>
{
static std::size_t fn( T v )
{
std::size_t seed = 0;
seed = static_cast<std::size_t>( v >> 64 ) + hash_detail::hash_mix( seed );
seed = static_cast<std::size_t>( v ) + hash_detail::hash_mix( seed );
return seed;
}
};
} // namespace hash_detail
template <typename T>
typename std::enable_if<hash_detail::is_integral<T>::value, std::size_t>::type
hash_value( T v )
{
return hash_detail::hash_integral_impl<T>::fn( v );
}
} // namespace boost
#endif // #ifndef BOOST_HASH_DETAIL_HASH_INTEGRAL_HPP

113
include/boost/container_hash/detail/hash_mix.hpp Normal file
View File

@@ -0,0 +1,113 @@
// Copyright 2022 Peter Dimov
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt
#ifndef BOOST_HASH_DETAIL_HASH_MIX_HPP
#define BOOST_HASH_DETAIL_HASH_MIX_HPP
#include <cstdint>
#include <cstddef>
#include <climits>
namespace boost
{
namespace hash_detail
{
template<std::size_t Bits> struct hash_mix_impl;
// hash_mix for 64 bit size_t
//
// The general "xmxmx" form of state of the art 64 bit mixers originates
// from Murmur3 by Austin Appleby, which uses the following function as
// its "final mix":
//
// k ^= k >> 33;
// k *= 0xff51afd7ed558ccd;
// k ^= k >> 33;
// k *= 0xc4ceb9fe1a85ec53;
// k ^= k >> 33;
//
// (https://github.com/aappleby/smhasher/blob/master/src/MurmurHash3.cpp)
//
// It has subsequently been improved multiple times by different authors
// by changing the constants. The most well known improvement is the
// so-called "variant 13" function by David Stafford:
//
// k ^= k >> 30;
// k *= 0xbf58476d1ce4e5b9;
// k ^= k >> 27;
// k *= 0x94d049bb133111eb;
// k ^= k >> 31;
//
// (https://zimbry.blogspot.com/2011/09/better-bit-mixing-improving-on.html)
//
// This mixing function is used in the splitmix64 RNG:
// http://xorshift.di.unimi.it/splitmix64.c
//
// We use Jon Maiga's implementation from
// http://jonkagstrom.com/mx3/mx3_rev2.html
//
// x ^= x >> 32;
// x *= 0xe9846af9b1a615d;
// x ^= x >> 32;
// x *= 0xe9846af9b1a615d;
// x ^= x >> 28;
//
// An equally good alternative is Pelle Evensen's Moremur:
//
// x ^= x >> 27;
// x *= 0x3C79AC492BA7B653;
// x ^= x >> 33;
// x *= 0x1C69B3F74AC4AE35;
// x ^= x >> 27;
//
// (https://mostlymangling.blogspot.com/2019/12/stronger-better-morer-moremur-better.html)
template<> struct hash_mix_impl<64>
{
inline static std::uint64_t fn( std::uint64_t x )
{
std::uint64_t const m = 0xe9846af9b1a615d;
x ^= x >> 32;
x *= m;
x ^= x >> 32;
x *= m;
x ^= x >> 28;
return x;
}
};
// hash_mix for 32 bit size_t
//
// We use the "best xmxmx" implementation from
// https://github.com/skeeto/hash-prospector/issues/19
template<> struct hash_mix_impl<32>
{
inline static std::uint32_t fn( std::uint32_t x )
{
std::uint32_t const m1 = 0x21f0aaad;
std::uint32_t const m2 = 0x735a2d97;
x ^= x >> 16;
x *= m1;
x ^= x >> 15;
x *= m2;
x ^= x >> 15;
return x;
}
};
inline std::size_t hash_mix( std::size_t v )
{
return hash_mix_impl<sizeof(std::size_t) * CHAR_BIT>::fn( v );
}
} // namespace hash_detail
} // namespace boost
#endif // #ifndef BOOST_HASH_DETAIL_HASH_MIX_HPP

408
include/boost/container_hash/detail/hash_range.hpp Normal file
View File

@@ -0,0 +1,408 @@
// Copyright 2022 Peter Dimov
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt
#ifndef BOOST_HASH_DETAIL_HASH_RANGE_HPP
#define BOOST_HASH_DETAIL_HASH_RANGE_HPP
#include <boost/container_hash/hash_fwd.hpp>
#include <boost/container_hash/detail/mulx.hpp>
#include <type_traits>
#include <cstdint>
#include <iterator>
#include <limits>
#include <cstddef>
#include <climits>
#include <cstring>
namespace boost
{
namespace hash_detail
{
template<class T> struct is_char_type: public std::false_type {};
#if CHAR_BIT == 8
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 std::true_type {};
#endif
#if defined(__cpp_lib_byte) && __cpp_lib_byte >= 201603L
template<> struct is_char_type<std::byte>: public std::true_type {};
#endif
#endif
// generic version
template<class It>
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 )
{
for( ; first != last; ++first )
{
hash_combine<typename std::iterator_traits<It>::value_type>( seed, *first );
}
return seed;
}
// specialized char[] version, 32 bit
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
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 std::uint32_t read32le( T* p )
{
std::uint32_t w;
std::memcpy( &w, p, 4 );
return w;
}
#endif
inline std::uint64_t mul32( std::uint32_t x, std::uint32_t y )
{
return static_cast<std::uint64_t>( x ) * y;
}
template<class It>
inline typename std::enable_if<
is_char_type<typename std::iterator_traits<It>::value_type>::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 )
{
It p = first;
std::size_t n = static_cast<std::size_t>( last - first );
std::uint32_t const q = 0x9e3779b9U;
std::uint32_t const k = 0xe35e67b1U; // q * q
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 )
{
std::uint32_t v1 = read32le( p );
w += q;
h ^= mul32( v1 + w, k );
p += 4;
n -= 4;
}
{
std::uint32_t v1 = 0;
if( n >= 1 )
{
std::size_t const x1 = ( n - 1 ) & 2; // 1: 0, 2: 0, 3: 2
std::size_t const x2 = n >> 1; // 1: 0, 2: 1, 3: 1
v1 =
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;
h ^= mul32( v1 + w, k );
}
w += q;
h ^= mul32( static_cast<std::uint32_t>( h & 0xFFFFFFFF ) + w, static_cast<std::uint32_t>( h >> 32 ) + w + k );
return static_cast<std::uint32_t>( h & 0xFFFFFFFF ) ^ static_cast<std::uint32_t>( h >> 32 );
}
template<class It>
inline typename std::enable_if<
is_char_type<typename std::iterator_traits<It>::value_type>::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;
std::uint32_t const q = 0x9e3779b9U;
std::uint32_t const k = 0xe35e67b1U; // q * q
std::uint64_t h = mul32( static_cast<std::uint32_t>( seed ) + q, k );
std::uint32_t w = static_cast<std::uint32_t>( h & 0xFFFFFFFF );
std::uint32_t v1 = 0;
for( ;; )
{
v1 = 0;
if( first == last )
{
break;
}
v1 |= static_cast<std::uint32_t>( static_cast<unsigned char>( *first ) );
++first;
++n;
if( first == last )
{
break;
}
v1 |= static_cast<std::uint32_t>( static_cast<unsigned char>( *first ) ) << 8;
++first;
++n;
if( first == last )
{
break;
}
v1 |= static_cast<std::uint32_t>( static_cast<unsigned char>( *first ) ) << 16;
++first;
++n;
if( first == last )
{
break;
}
v1 |= static_cast<std::uint32_t>( static_cast<unsigned char>( *first ) ) << 24;
++first;
++n;
w += q;
h ^= mul32( v1 + w, k );
}
h ^= n;
w += q;
h ^= mul32( v1 + w, k );
w += q;
h ^= mul32( static_cast<std::uint32_t>( h & 0xFFFFFFFF ) + w, static_cast<std::uint32_t>( h >> 32 ) + w + k );
return static_cast<std::uint32_t>( h & 0xFFFFFFFF ) ^ static_cast<std::uint32_t>( h >> 32 );
}
// specialized char[] version, 64 bit
template<class It> inline std::uint64_t read64le( It p )
{
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 std::uint64_t read64le( T* p )
{
std::uint64_t w;
std::memcpy( &w, p, 8 );
return w;
}
#endif
template<class It>
inline typename std::enable_if<
is_char_type<typename std::iterator_traits<It>::value_type>::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 )
{
It p = first;
std::size_t n = static_cast<std::size_t>( last - first );
std::uint64_t const q = 0x9e3779b97f4a7c15;
std::uint64_t const k = 0xdf442d22ce4859b9; // q * q
std::uint64_t w = mulx( seed + q, k );
std::uint64_t h = w ^ n;
while( n >= 8 )
{
std::uint64_t v1 = read64le( p );
w += q;
h ^= mulx( v1 + w, k );
p += 8;
n -= 8;
}
{
std::uint64_t v1 = 0;
if( n >= 4 )
{
v1 = static_cast<std::uint64_t>( read32le( p + static_cast<std::ptrdiff_t>( n - 4 ) ) ) << ( n - 4 ) * 8 | read32le( p );
}
else if( n >= 1 )
{
std::size_t const x1 = ( n - 1 ) & 2; // 1: 0, 2: 0, 3: 2
std::size_t const x2 = n >> 1; // 1: 0, 2: 1, 3: 1
v1 =
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;
h ^= mulx( v1 + w, k );
}
return mulx( h + w, k );
}
template<class It>
inline typename std::enable_if<
is_char_type<typename std::iterator_traits<It>::value_type>::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;
std::uint64_t const q = 0x9e3779b97f4a7c15;
std::uint64_t const k = 0xdf442d22ce4859b9; // q * q
std::uint64_t w = mulx( seed + q, k );
std::uint64_t h = w;
std::uint64_t v1 = 0;
for( ;; )
{
v1 = 0;
if( first == last )
{
break;
}
v1 |= static_cast<std::uint64_t>( static_cast<unsigned char>( *first ) );
++first;
++n;
if( first == last )
{
break;
}
v1 |= static_cast<std::uint64_t>( static_cast<unsigned char>( *first ) ) << 8;
++first;
++n;
if( first == last )
{
break;
}
v1 |= static_cast<std::uint64_t>( static_cast<unsigned char>( *first ) ) << 16;
++first;
++n;
if( first == last )
{
break;
}
v1 |= static_cast<std::uint64_t>( static_cast<unsigned char>( *first ) ) << 24;
++first;
++n;
if( first == last )
{
break;
}
v1 |= static_cast<std::uint64_t>( static_cast<unsigned char>( *first ) ) << 32;
++first;
++n;
if( first == last )
{
break;
}
v1 |= static_cast<std::uint64_t>( static_cast<unsigned char>( *first ) ) << 40;
++first;
++n;
if( first == last )
{
break;
}
v1 |= static_cast<std::uint64_t>( static_cast<unsigned char>( *first ) ) << 48;
++first;
++n;
if( first == last )
{
break;
}
v1 |= static_cast<std::uint64_t>( static_cast<unsigned char>( *first ) ) << 56;
++first;
++n;
w += q;
h ^= mulx( v1 + w, k );
}
h ^= n;
w += q;
h ^= mulx( v1 + w, k );
return mulx( h + w, k );
}
} // namespace hash_detail
} // namespace boost
#endif // #ifndef BOOST_HASH_DETAIL_HASH_RANGE_HPP

62
include/boost/container_hash/detail/hash_tuple_like.hpp Normal file
View File

@@ -0,0 +1,62 @@
// Copyright 2005-2009 Daniel James.
// Copyright 2021 Peter Dimov.
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt
#ifndef BOOST_HASH_DETAIL_HASH_TUPLE_LIKE_HPP
#define BOOST_HASH_DETAIL_HASH_TUPLE_LIKE_HPP
#include <boost/container_hash/hash_fwd.hpp>
#include <boost/container_hash/is_tuple_like.hpp>
#include <boost/container_hash/is_range.hpp>
#include <type_traits>
#include <utility>
namespace boost
{
namespace hash_detail
{
template <std::size_t I, typename T>
inline
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 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;
boost::hash_combine( seed, get<I>( v ) );
boost::hash_detail::hash_combine_tuple_like<I + 1>( seed, v );
}
template <typename T>
inline std::size_t hash_tuple_like( T const& v )
{
std::size_t seed = 0;
boost::hash_detail::hash_combine_tuple_like<0>( seed, v );
return seed;
}
} // namespace hash_detail
template <class T>
inline
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 )
{
return boost::hash_detail::hash_tuple_like( v );
}
} // namespace boost
#endif // #ifndef BOOST_HASH_DETAIL_HASH_TUPLE_LIKE_HPP

19
include/boost/container_hash/detail/limits.hpp Normal file
View File

@@ -0,0 +1,19 @@
// Copyright 2005-2009 Daniel James.
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#ifndef BOOST_FUNCTIONAL_HASH_DETAIL_LIMITS_HEADER
#define BOOST_FUNCTIONAL_HASH_DETAIL_LIMITS_HEADER
#include <limits>
namespace boost
{
namespace hash_detail
{
template <class T>
struct limits : std::numeric_limits<T> {};
}
}
#endif // #ifndef BOOST_FUNCTIONAL_HASH_DETAIL_LIMITS_HEADER

79
include/boost/container_hash/detail/mulx.hpp Normal file
View File

@@ -0,0 +1,79 @@
// Copyright 2022, 2023 Peter Dimov
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt
#ifndef BOOST_HASH_DETAIL_MULX_HPP
#define BOOST_HASH_DETAIL_MULX_HPP
#include <cstdint>
#if defined(_MSC_VER)
# include <intrin.h>
#endif
namespace boost
{
namespace hash_detail
{
#if defined(_MSC_VER) && defined(_M_X64) && !defined(__clang__)
__forceinline std::uint64_t mulx( std::uint64_t x, std::uint64_t y )
{
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 std::uint64_t mulx( std::uint64_t x, std::uint64_t y )
{
std::uint64_t r = x * y;
std::uint64_t r2 = __umulh( x, y );
return r ^ r2;
}
#elif defined(__SIZEOF_INT128__)
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<std::uint64_t>( r ) ^ static_cast<std::uint64_t>( r >> 64 );
}
#else
inline std::uint64_t mulx( std::uint64_t x, std::uint64_t y )
{
std::uint64_t x1 = static_cast<std::uint32_t>( x );
std::uint64_t x2 = x >> 32;
std::uint64_t y1 = static_cast<std::uint32_t>( y );
std::uint64_t y2 = y >> 32;
std::uint64_t r3 = x2 * y2;
std::uint64_t r2a = x1 * y2;
r3 += r2a >> 32;
std::uint64_t r2b = x2 * y1;
r3 += r2b >> 32;
std::uint64_t r1 = x1 * y1;
std::uint64_t r2 = (r1 >> 32) + static_cast<std::uint32_t>( r2a ) + static_cast<std::uint32_t>( r2b );
r1 = (r2 << 32) + static_cast<std::uint32_t>( r1 );
r3 += r2 >> 32;
return r1 ^ r3;
}
#endif
} // namespace hash_detail
} // namespace boost
#endif // #ifndef BOOST_HASH_DETAIL_MULX_HPP

10
include/boost/container_hash/extensions.hpp Normal file
View File

@@ -0,0 +1,10 @@
// Copyright 2005-2009 Daniel James.
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#ifndef BOOST_FUNCTIONAL_HASH_EXTENSIONS_HPP
#define BOOST_FUNCTIONAL_HASH_EXTENSIONS_HPP
#include <boost/container_hash/hash.hpp>
#endif // #ifndef BOOST_FUNCTIONAL_HASH_EXTENSIONS_HPP

573
include/boost/container_hash/hash.hpp Normal file
View File

@@ -0,0 +1,573 @@
// Copyright 2005-2014 Daniel James.
// Copyright 2021, 2022, 2025 Peter Dimov.
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt
// Based on Peter Dimov's proposal
// http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2005/n1756.pdf
// issue 6.18.
#ifndef BOOST_FUNCTIONAL_HASH_HASH_HPP
#define BOOST_FUNCTIONAL_HASH_HASH_HPP
#include <boost/container_hash/hash_fwd.hpp>
#include <boost/container_hash/hash_is_avalanching.hpp>
#include <boost/container_hash/is_range.hpp>
#include <boost/container_hash/is_contiguous_range.hpp>
#include <boost/container_hash/is_unordered_range.hpp>
#include <boost/container_hash/is_described_class.hpp>
#include <boost/container_hash/detail/hash_integral.hpp>
#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/describe/bases.hpp>
#include <boost/describe/members.hpp>
#include <type_traits>
#include <cstdint>
#if defined(BOOST_DESCRIBE_CXX14)
# include <boost/mp11/algorithm.hpp>
#endif
#include <string>
#include <iterator>
#include <complex>
#include <utility>
#include <limits>
#include <climits>
#include <cstring>
#if !defined(BOOST_NO_CXX11_SMART_PTR)
# include <memory>
#endif
#if !defined(BOOST_NO_CXX11_HDR_TYPEINDEX)
#include <typeindex>
#endif
#if !defined(BOOST_NO_CXX11_HDR_SYSTEM_ERROR)
#include <system_error>
#endif
#if !defined(BOOST_NO_CXX17_HDR_OPTIONAL)
#include <optional>
#endif
#if !defined(BOOST_NO_CXX17_HDR_VARIANT)
#include <variant>
#endif
#if !defined(BOOST_NO_CXX17_HDR_STRING_VIEW)
# include <string_view>
#endif
namespace boost
{
//
// boost::hash_value
//
// integral types
// in detail/hash_integral.hpp
// enumeration types
template <typename T>
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
//
// boost::hash_value( to_underlying(v) );
//
// However, the C++03 implementation of underlying_type,
//
// conditional<is_signed<T>, make_signed<T>, make_unsigned<T>>::type::type
//
// generates a legitimate -Wconversion warning in is_signed,
// because -1 is not a valid enum value when all the enumerators
// are nonnegative.
//
// So the legacy implementation will have to do for now.
return static_cast<std::size_t>( v );
}
// floating point types
namespace hash_detail
{
template<class T,
std::size_t Bits = sizeof(T) * CHAR_BIT,
int Digits = std::numeric_limits<T>::digits>
struct hash_float_impl;
// float
template<class T, int Digits> struct hash_float_impl<T, 32, Digits>
{
static std::size_t fn( T v )
{
std::uint32_t w;
std::memcpy( &w, &v, sizeof( v ) );
return w;
}
};
// double
template<class T, int Digits> struct hash_float_impl<T, 64, Digits>
{
static std::size_t fn( T v )
{
std::uint64_t w;
std::memcpy( &w, &v, sizeof( v ) );
return hash_value( w );
}
};
// 80 bit long double in 12 bytes
template<class T> struct hash_float_impl<T, 96, 64>
{
static std::size_t fn( T v )
{
std::uint64_t w[ 2 ] = {};
std::memcpy( &w, &v, 80 / CHAR_BIT );
std::size_t seed = 0;
seed = hash_value( w[0] ) + hash_detail::hash_mix( seed );
seed = hash_value( w[1] ) + hash_detail::hash_mix( seed );
return seed;
}
};
// 80 bit long double in 16 bytes
template<class T> struct hash_float_impl<T, 128, 64>
{
static std::size_t fn( T v )
{
std::uint64_t w[ 2 ] = {};
std::memcpy( &w, &v, 80 / CHAR_BIT );
std::size_t seed = 0;
seed = hash_value( w[0] ) + hash_detail::hash_mix( seed );
seed = hash_value( w[1] ) + hash_detail::hash_mix( seed );
return seed;
}
};
// 128 bit long double
template<class T, int Digits> struct hash_float_impl<T, 128, Digits>
{
static std::size_t fn( T v )
{
std::uint64_t w[ 2 ];
std::memcpy( &w, &v, sizeof( v ) );
std::size_t seed = 0;
#if defined(__FLOAT_WORD_ORDER__) && defined(__ORDER_BIG_ENDIAN__) && __FLOAT_WORD_ORDER__ == __ORDER_BIG_ENDIAN__
seed = hash_value( w[1] ) + hash_detail::hash_mix( seed );
seed = hash_value( w[0] ) + hash_detail::hash_mix( seed );
#else
seed = hash_value( w[0] ) + hash_detail::hash_mix( seed );
seed = hash_value( w[1] ) + hash_detail::hash_mix( seed );
#endif
return seed;
}
};
} // namespace hash_detail
template <typename T>
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 );
}
// pointer types
// `x + (x >> 3)` adjustment by Alberto Barbati and Dave Harris.
template <class T> std::size_t hash_value( T* const& v )
{
std::uintptr_t x = reinterpret_cast<std::uintptr_t>( v );
return boost::hash_value( x + (x >> 3) );
}
// array types
template<class T, std::size_t N>
inline std::size_t hash_value( T const (&x)[ N ] )
{
return boost::hash_range( x, x + N );
}
template<class T, std::size_t N>
inline std::size_t hash_value( T (&x)[ N ] )
{
return boost::hash_range( x, x + N );
}
// complex
template <class T>
std::size_t hash_value( std::complex<T> const& v )
{
std::size_t re = boost::hash<T>()( v.real() );
std::size_t im = boost::hash<T>()( v.imag() );
return re + hash_detail::hash_mix( im );
}
// pair
template <class A, class B>
std::size_t hash_value( std::pair<A, B> const& v )
{
std::size_t seed = 0;
boost::hash_combine( seed, v.first );
boost::hash_combine( seed, v.second );
return seed;
}
// ranges (list, set, deque...)
template <typename T>
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() );
}
// contiguous ranges (string, vector, array)
template <typename T>
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() );
}
// unordered ranges (unordered_set, unordered_map)
template <typename T>
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() );
}
#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && ( \
( defined(_MSVC_STL_VERSION) && _MSVC_STL_VERSION < 142 ) || \
( !defined(_MSVC_STL_VERSION) && defined(_CPPLIB_VER) && _CPPLIB_VER >= 520 ) )
// resolve ambiguity with unconstrained stdext::hash_value in <xhash> :-/
template<template<class...> class L, class... T>
typename 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() );
}
// contiguous ranges (string, vector, array)
template<template<class...> class L, class... T>
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 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() );
}
// unordered ranges (unordered_set, unordered_map)
template<template<class...> class L, class... T>
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() );
}
#endif
// described classes
#if defined(BOOST_DESCRIBE_CXX14)
#if defined(_MSC_VER) && _MSC_VER == 1900
# pragma warning(push)
# pragma warning(disable: 4100) // unreferenced formal parameter
#endif
template <typename T>
typename std::enable_if<container_hash::is_described_class<T>::value, std::size_t>::type
hash_value( T const& v )
{
static_assert( !std::is_union<T>::value, "described unions are not supported" );
std::size_t r = 0;
using Bd = describe::describe_bases<T, describe::mod_any_access>;
mp11::mp_for_each<Bd>([&](auto D){
using B = typename decltype(D)::type;
boost::hash_combine( r, (B const&)v );
});
using Md = describe::describe_members<T, describe::mod_any_access>;
mp11::mp_for_each<Md>([&](auto D){
boost::hash_combine( r, v.*D.pointer );
});
return r;
}
#if defined(_MSC_VER) && _MSC_VER == 1900
# pragma warning(pop)
#endif
#endif
// std::unique_ptr, std::shared_ptr
#if !defined(BOOST_NO_CXX11_SMART_PTR)
template <typename T>
std::size_t hash_value( std::shared_ptr<T> const& x )
{
return boost::hash_value( x.get() );
}
template <typename T, typename Deleter>
std::size_t hash_value( std::unique_ptr<T, Deleter> const& x )
{
return boost::hash_value( x.get() );
}
#endif
// std::type_index
#if !defined(BOOST_NO_CXX11_HDR_TYPEINDEX)
inline std::size_t hash_value( std::type_index const& v )
{
return v.hash_code();
}
#endif
// std::error_code, std::error_condition
#if !defined(BOOST_NO_CXX11_HDR_SYSTEM_ERROR)
inline std::size_t hash_value( std::error_code const& v )
{
std::size_t seed = 0;
boost::hash_combine( seed, v.value() );
boost::hash_combine( seed, &v.category() );
return seed;
}
inline std::size_t hash_value( std::error_condition const& v )
{
std::size_t seed = 0;
boost::hash_combine( seed, v.value() );
boost::hash_combine( seed, &v.category() );
return seed;
}
#endif
// std::nullptr_t
#if !defined(BOOST_NO_CXX11_NULLPTR)
template <typename T>
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 ) );
}
#endif
// std::optional
#if !defined(BOOST_NO_CXX17_HDR_OPTIONAL)
template <typename T>
std::size_t hash_value( std::optional<T> const& v )
{
if( !v )
{
// Arbitrary value for empty optional.
return 0x12345678;
}
else
{
return boost::hash<T>()(*v);
}
}
#endif
// std::variant
#if !defined(BOOST_NO_CXX17_HDR_VARIANT)
inline std::size_t hash_value( std::monostate )
{
return 0x87654321;
}
template <typename... Types>
std::size_t hash_value( std::variant<Types...> const& v )
{
std::size_t seed = 0;
hash_combine( seed, v.index() );
std::visit( [&seed](auto&& x) { hash_combine(seed, x); }, v );
return seed;
}
#endif
//
// boost::hash_combine
//
template <class T>
inline void hash_combine( std::size_t& seed, T const& v )
{
seed = boost::hash_detail::hash_mix( seed + 0x9e3779b9 + boost::hash<T>()( v ) );
}
//
// boost::hash_range
//
template <class It>
inline void hash_range( std::size_t& seed, It first, It last )
{
seed = hash_detail::hash_range( seed, first, last );
}
template <class It>
inline std::size_t hash_range( It first, It last )
{
std::size_t seed = 0;
hash_range( seed, first, last );
return seed;
}
//
// boost::hash_unordered_range
//
template <class It>
inline void hash_unordered_range( std::size_t& seed, It first, It last )
{
std::size_t r = 0;
std::size_t const s2( seed );
for( ; first != last; ++first )
{
std::size_t s3( s2 );
hash_combine<typename std::iterator_traits<It>::value_type>( s3, *first );
r += s3;
}
seed += r;
}
template <class It>
inline std::size_t hash_unordered_range( It first, It last )
{
std::size_t seed = 0;
hash_unordered_range( seed, first, last );
return seed;
}
//
// boost::hash
//
template <class T> struct hash
{
typedef T argument_type;
typedef std::size_t result_type;
std::size_t operator()( T const& val ) const
{
return hash_value( val );
}
};
#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && ( \
( defined(_MSVC_STL_VERSION) && _MSVC_STL_VERSION < 142 ) || \
( !defined(_MSVC_STL_VERSION) && defined(_CPPLIB_VER) && _CPPLIB_VER >= 520 ) )
// Dinkumware has stdext::hash_value for basic_string in <xhash> :-/
template<class E, class T, class A> struct hash< std::basic_string<E, T, A> >
{
typedef std::basic_string<E, T, A> argument_type;
typedef std::size_t result_type;
std::size_t operator()( std::basic_string<E, T, A> const& val ) const
{
return boost::hash_value( val );
}
};
#endif
// hash_is_avalanching
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> > >: std::is_integral<Ch> {};
#endif
} // namespace boost
#endif // #ifndef BOOST_FUNCTIONAL_HASH_HASH_HPP

39
include/boost/container_hash/hash_fwd.hpp Normal file
View File

@@ -0,0 +1,39 @@
// Copyright 2005-2009 Daniel James.
// Copyright 2021, 2022, 2025 Peter Dimov.
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt
#ifndef BOOST_FUNCTIONAL_HASH_FWD_HPP
#define BOOST_FUNCTIONAL_HASH_FWD_HPP
#include <cstddef>
namespace boost
{
namespace container_hash
{
template<class T> struct is_range;
template<class T> struct is_contiguous_range;
template<class T> struct is_unordered_range;
template<class T> struct is_described_class;
template<class T> struct is_tuple_like;
} // namespace container_hash
template<class T> struct hash;
template<class T> void hash_combine( std::size_t& seed, T const& v );
template<class It> void hash_range( std::size_t&, It, It );
template<class It> std::size_t hash_range( It, It );
template<class It> void hash_unordered_range( std::size_t&, It, It );
template<class It> std::size_t hash_unordered_range( It, It );
template<class Hash> struct hash_is_avalanching;
} // namespace boost
#endif // #ifndef BOOST_FUNCTIONAL_HASH_FWD_HPP

57
include/boost/container_hash/hash_is_avalanching.hpp Normal file
View File

@@ -0,0 +1,57 @@
// Copyright 2025 Joaquin M Lopez Munoz.
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt
#ifndef BOOST_HASH_HASH_IS_AVALANCHING_HPP_INCLUDED
#define BOOST_HASH_HASH_IS_AVALANCHING_HPP_INCLUDED
#include <type_traits>
namespace boost
{
namespace hash_detail
{
template<class... Ts> struct make_void
{
using type = void;
};
template<class... Ts> using void_t = typename make_void<Ts...>::type;
template<class IsAvalanching> struct avalanching_value
{
static constexpr bool value = IsAvalanching::value;
};
// may be explicitly marked as BOOST_DEPRECATED in the future
template<> struct avalanching_value<void>
{
static constexpr bool value = true;
};
template<class Hash, class = void> struct hash_is_avalanching_impl: std::false_type
{
};
template<class Hash> struct hash_is_avalanching_impl<Hash, void_t<typename Hash::is_avalanching> >:
std::integral_constant<bool, avalanching_value<typename Hash::is_avalanching>::value>
{
};
template<class Hash>
struct hash_is_avalanching_impl<Hash, typename std::enable_if< ((void)Hash::is_avalanching, true) >::type>
{
// Hash::is_avalanching is not a type: we don't define value to produce
// a compile error downstream
};
} // namespace hash_detail
template<class Hash> struct hash_is_avalanching: hash_detail::hash_is_avalanching_impl<Hash>::type
{
};
} // namespace boost
#endif // #ifndef BOOST_HASH_HASH_IS_AVALANCHING_HPP_INCLUDED

98
include/boost/container_hash/is_contiguous_range.hpp Normal file
View File

@@ -0,0 +1,98 @@
// Copyright 2017, 2018 Peter Dimov.
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt
#ifndef BOOST_HASH_IS_CONTIGUOUS_RANGE_HPP_INCLUDED
#define BOOST_HASH_IS_CONTIGUOUS_RANGE_HPP_INCLUDED
#include <boost/container_hash/is_range.hpp>
#include <boost/config.hpp>
#include <boost/config/workaround.hpp>
#include <type_traits>
#if !BOOST_WORKAROUND(BOOST_MSVC, < 1910)
#include <iterator>
namespace boost
{
namespace hash_detail
{
template<class It, class T, class S>
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( 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 ) )
{
};
} // namespace hash_detail
namespace container_hash
{
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 // !BOOST_WORKAROUND(BOOST_MSVC, < 1910)
#include <cstddef>
#include <vector>
#include <string>
#include <array>
namespace boost
{
namespace container_hash
{
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> >: std::true_type
{
};
template<class E, class T, class A> struct is_contiguous_range< std::basic_string<E, T, A> const >: std::true_type
{
};
template<class T, class A> struct is_contiguous_range< std::vector<T, A> >: std::true_type
{
};
template<class T, class A> struct is_contiguous_range< std::vector<T, A> const >: std::true_type
{
};
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 // !BOOST_WORKAROUND(BOOST_MSVC, < 1910)
#endif // #ifndef BOOST_HASH_IS_CONTIGUOUS_RANGE_HPP_INCLUDED

37
include/boost/container_hash/is_described_class.hpp Normal file
View File

@@ -0,0 +1,37 @@
// Copyright 2022 Peter Dimov.
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt
#ifndef BOOST_HASH_IS_DESCRIBED_CLASS_HPP_INCLUDED
#define BOOST_HASH_IS_DESCRIBED_CLASS_HPP_INCLUDED
#include <boost/describe/bases.hpp>
#include <boost/describe/members.hpp>
#include <type_traits>
namespace boost
{
namespace container_hash
{
#if defined(BOOST_DESCRIBE_CXX11)
template<class T> struct is_described_class: std::integral_constant<bool,
describe::has_describe_bases<T>::value &&
describe::has_describe_members<T>::value &&
!std::is_union<T>::value>
{
};
#else
template<class T> struct is_described_class: std::false_type
{
};
#endif
} // namespace container_hash
} // namespace boost
#endif // #ifndef BOOST_HASH_IS_DESCRIBED_CLASS_HPP_INCLUDED

41
include/boost/container_hash/is_range.hpp Normal file
View File

@@ -0,0 +1,41 @@
// Copyright 2017 Peter Dimov.
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt
#ifndef BOOST_HASH_IS_RANGE_HPP_INCLUDED
#define BOOST_HASH_IS_RANGE_HPP_INCLUDED
#include <iterator>
#include <type_traits>
namespace boost
{
namespace hash_detail
{
template<class T> struct iterator_traits: std::iterator_traits<T> {};
template<> struct iterator_traits< void* > {};
template<> struct iterator_traits< void const* > {};
template<class T, class It>
std::integral_constant< bool, !std::is_same<typename std::remove_cv<T>::type, typename iterator_traits<It>::value_type>::value >
is_range_check( It first, It last );
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
namespace container_hash
{
template<class T> struct is_range: decltype( hash_detail::is_range_<T>( 0 ) )
{
};
} // namespace container_hash
} // namespace boost
#endif // #ifndef BOOST_HASH_IS_RANGE_HPP_INCLUDED

36
include/boost/container_hash/is_tuple_like.hpp Normal file
View File

@@ -0,0 +1,36 @@
#ifndef BOOST_HASH_IS_TUPLE_LIKE_HPP_INCLUDED
#define BOOST_HASH_IS_TUPLE_LIKE_HPP_INCLUDED
// Copyright 2017, 2022 Peter Dimov.
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt
#include <type_traits>
#include <utility>
namespace boost
{
namespace hash_detail
{
template<class T, class E = std::true_type> struct is_tuple_like_: std::false_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
{
};
} // namespace hash_detail
namespace container_hash
{
template<class T> struct is_tuple_like: hash_detail::is_tuple_like_< typename std::remove_cv<T>::type >
{
};
} // namespace container_hash
} // namespace boost
#endif // #ifndef BOOST_HASH_IS_TUPLE_LIKE_HPP_INCLUDED

38
include/boost/container_hash/is_unordered_range.hpp Normal file
View File

@@ -0,0 +1,38 @@
// Copyright 2017 Peter Dimov.
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt
#ifndef BOOST_HASH_IS_UNORDERED_RANGE_HPP_INCLUDED
#define BOOST_HASH_IS_UNORDERED_RANGE_HPP_INCLUDED
#include <boost/container_hash/is_range.hpp>
#include <type_traits>
namespace boost
{
namespace hash_detail
{
template<class T, class E = std::true_type> struct has_hasher_: std::false_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
{
};
} // namespace hash_detail
namespace container_hash
{
template<class T> struct is_unordered_range: std::integral_constant< bool, is_range<T>::value && hash_detail::has_hasher_<T>::value >
{
};
} // namespace container_hash
} // namespace boost
#endif // #ifndef BOOST_HASH_IS_UNORDERED_RANGE_HPP_INCLUDED