mirror of
https://github.com/bolero-MURAKAMI/Sprout
synced 2025-08-03 12:49:50 +00:00
fix adapt interface: container, tuple, hash, generator
This commit is contained in:
bolero-MURAKAMI
parent
61720b72c3
commit
74e0c8acd6
36 changed files with 975 additions and 1061 deletions
|
|
@ -15,7 +15,14 @@ namespace sprout {
|
|||
// to_hash
|
||||
//
|
||||
template<typename T>
|
||||
SPROUT_CONSTEXPR std::size_t to_hash(T const& v);
|
||||
SPROUT_CONSTEXPR std::size_t to_hash(T&& v);
|
||||
|
||||
//
|
||||
// hash_value
|
||||
//
|
||||
template<typename T>
|
||||
inline SPROUT_CONSTEXPR std::size_t
|
||||
hash_value(T const& v);
|
||||
|
||||
//
|
||||
// hash_combine
|
||||
|
|
@ -42,6 +49,12 @@ namespace sprout {
|
|||
SPROUT_CONSTEXPR std::size_t hash_range(std::size_t seed, InputRange const& rng);
|
||||
template<typename InputRange>
|
||||
SPROUT_CONSTEXPR std::size_t hash_range(InputRange const& rng);
|
||||
|
||||
//
|
||||
// hash_value_traits
|
||||
//
|
||||
template<typename T>
|
||||
struct hash_value_traits;
|
||||
} // namespace sprout
|
||||
|
||||
#endif // #ifndef SPROUT_FUNCTIONAL_HASH_HASH_FWD_HPP
|
||||
|
|
|
|||
|
|
@ -2,150 +2,20 @@
|
|||
#define SPROUT_FUNCTIONAL_HASH_HASH_VALUE_HPP
|
||||
|
||||
#include <cstddef>
|
||||
#include <limits>
|
||||
#include <type_traits>
|
||||
#include <sprout/config.hpp>
|
||||
#include <sprout/functional/hash/hash_fwd.hpp>
|
||||
#include <sprout/functional/hash/detail/hash_float.hpp>
|
||||
|
||||
namespace sprout {
|
||||
namespace hash_detail {
|
||||
template <typename T>
|
||||
struct is_basic_number
|
||||
: public std::integral_constant<
|
||||
bool,
|
||||
std::is_integral<T>::value
|
||||
&& (sizeof(T) <= sizeof(std::size_t))
|
||||
>
|
||||
{};
|
||||
template <typename T>
|
||||
struct is_long_number
|
||||
: public std::integral_constant<
|
||||
bool,
|
||||
std::is_integral<T>::value
|
||||
&& (sizeof(T) > sizeof(std::size_t))
|
||||
&& std::is_signed<T>::value
|
||||
>
|
||||
{};
|
||||
template <typename T>
|
||||
struct is_ulong_number
|
||||
: public std::integral_constant<
|
||||
bool,
|
||||
std::is_integral<T>::value
|
||||
&& (sizeof(T) > sizeof(std::size_t))
|
||||
&& std::is_unsigned<T>::value
|
||||
>
|
||||
{};
|
||||
|
||||
template<typename T>
|
||||
inline SPROUT_CONSTEXPR std::size_t
|
||||
hash_value_signed_2(T val, int length, std::size_t seed, T positive, std::size_t i) {
|
||||
return i > 0
|
||||
? hash_value_signed_2(
|
||||
val,
|
||||
length,
|
||||
seed ^ static_cast<std::size_t>((positive >> i) + (seed << 6) + (seed >> 2)),
|
||||
positive,
|
||||
i - std::numeric_limits<std::size_t>::digits
|
||||
)
|
||||
: seed ^ static_cast<std::size_t>(val + (seed << 6) + (seed >> 2))
|
||||
;
|
||||
}
|
||||
template<typename T>
|
||||
inline SPROUT_CONSTEXPR std::size_t
|
||||
hash_value_signed_1(T val, int length, std::size_t seed, T positive) {
|
||||
return hash_value_signed_2(val, length, seed, positive, length * std::numeric_limits<std::size_t>::digits);
|
||||
}
|
||||
template<typename T>
|
||||
inline SPROUT_CONSTEXPR std::size_t
|
||||
hash_value_signed(T val) {
|
||||
return sprout::hash_detail::hash_value_signed_1(
|
||||
val,
|
||||
(std::numeric_limits<T>::digits - 1) / std::numeric_limits<std::size_t>::digits,
|
||||
0,
|
||||
val < 0 ? -1 - val : val
|
||||
);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
inline SPROUT_CONSTEXPR std::size_t
|
||||
hash_value_unsigned_2(T val, int length, std::size_t seed, std::size_t i) {
|
||||
return i > 0
|
||||
? hash_value_unsigned_2(
|
||||
val,
|
||||
length,
|
||||
seed ^ static_cast<std::size_t>((val >> i) + (seed << 6) + (seed >> 2)),
|
||||
i - std::numeric_limits<std::size_t>::digits
|
||||
)
|
||||
: seed ^ static_cast<std::size_t>(val + (seed << 6) + (seed >> 2))
|
||||
;
|
||||
}
|
||||
template<typename T>
|
||||
inline SPROUT_CONSTEXPR std::size_t
|
||||
hash_value_unsigned_1(T val, int length, std::size_t seed) {
|
||||
return hash_value_unsigned_2(val, length, seed, length * std::numeric_limits<std::size_t>::digits);
|
||||
}
|
||||
template<typename T>
|
||||
inline SPROUT_CONSTEXPR std::size_t
|
||||
hash_value_unsigned(T val) {
|
||||
return sprout::hash_detail::hash_value_unsigned_1(
|
||||
val,
|
||||
(std::numeric_limits<T>::digits - 1) / std::numeric_limits<std::size_t>::digits,
|
||||
0
|
||||
);
|
||||
}
|
||||
|
||||
inline std::size_t
|
||||
hash_value_pointer_1(std::size_t x) {
|
||||
return x + (x >> 3);
|
||||
}
|
||||
template<typename T>
|
||||
std::size_t
|
||||
hash_value_pointer(T const* v) {
|
||||
return sprout::hash_detail::hash_value_pointer_1(static_cast<std::size_t>(reinterpret_cast<std::ptrdiff_t>(v)));
|
||||
}
|
||||
} // namespace hash_detail
|
||||
|
||||
//
|
||||
// hash_value
|
||||
//
|
||||
template<typename T>
|
||||
inline SPROUT_CONSTEXPR typename std::enable_if<sprout::hash_detail::is_basic_number<T>::value, std::size_t>::type
|
||||
hash_value(T v) {
|
||||
return static_cast<std::size_t>(v);
|
||||
}
|
||||
template<typename T>
|
||||
inline SPROUT_CONSTEXPR typename std::enable_if<sprout::hash_detail::is_long_number<T>::value, std::size_t>::type
|
||||
hash_value(T v) {
|
||||
return sprout::hash_detail::hash_value_signed(v);
|
||||
}
|
||||
template<typename T>
|
||||
inline SPROUT_CONSTEXPR typename std::enable_if<sprout::hash_detail::is_ulong_number<T>::value, std::size_t>::type
|
||||
hash_value(T v) {
|
||||
return sprout::hash_detail::hash_value_unsigned(v);
|
||||
}
|
||||
template<typename T>
|
||||
inline SPROUT_CONSTEXPR typename std::enable_if<std::is_enum<T>::value, std::size_t>::type
|
||||
hash_value(T v) {
|
||||
return sprout::hash_value(static_cast<typename std::underlying_type<T>::type>(v));
|
||||
}
|
||||
template<typename T>
|
||||
inline SPROUT_CONSTEXPR typename std::enable_if<std::is_floating_point<T>::value, std::size_t>::type
|
||||
hash_value(T v) {
|
||||
return sprout::detail::float_hash_value(v);
|
||||
}
|
||||
template<typename T>
|
||||
inline SPROUT_CONSTEXPR typename std::enable_if<std::is_pointer<typename std::remove_reference<T>::type>::value, std::size_t>::type
|
||||
hash_value(T&& v) {
|
||||
return sprout::hash_detail::hash_value_pointer(v);
|
||||
}
|
||||
template<typename T, std::size_t N>
|
||||
inline SPROUT_CONSTEXPR std::size_t
|
||||
hash_value(T const (&v)[N]) {
|
||||
return sprout::hash_range(v);
|
||||
hash_value(T const& v) {
|
||||
return sprout::hash_value_traits<T>::hash_value(v);
|
||||
}
|
||||
} // namespace sprout
|
||||
|
||||
#include <sprout/functional/hash/hash_range.hpp>
|
||||
#include <sprout/functional/hash/hash_value_traits.hpp>
|
||||
|
||||
#endif // #ifndef SPROUT_FUNCTIONAL_HASH_HASH_VALUE_HPP
|
||||
|
|
|
|||
181
sprout/functional/hash/hash_value_traits.hpp
Normal file
181
sprout/functional/hash/hash_value_traits.hpp
Normal file
|
|
@ -0,0 +1,181 @@
|
|||
#ifndef SPROUT_FUNCTIONAL_HASH_HASH_VALUE_TRAITS_HPP
|
||||
#define SPROUT_FUNCTIONAL_HASH_HASH_VALUE_TRAITS_HPP
|
||||
|
||||
#include <cstddef>
|
||||
#include <limits>
|
||||
#include <functional>
|
||||
#include <type_traits>
|
||||
#include <sprout/config.hpp>
|
||||
#include <sprout/functional/hash/hash_fwd.hpp>
|
||||
#include <sprout/functional/hash/detail/hash_float.hpp>
|
||||
|
||||
namespace sprout {
|
||||
namespace hash_detail {
|
||||
template <typename T>
|
||||
struct is_basic_number
|
||||
: public std::integral_constant<
|
||||
bool,
|
||||
std::is_integral<T>::value
|
||||
&& (sizeof(T) <= sizeof(std::size_t))
|
||||
>
|
||||
{};
|
||||
template <typename T>
|
||||
struct is_long_number
|
||||
: public std::integral_constant<
|
||||
bool,
|
||||
std::is_integral<T>::value
|
||||
&& (sizeof(T) > sizeof(std::size_t))
|
||||
&& std::is_signed<T>::value
|
||||
>
|
||||
{};
|
||||
template <typename T>
|
||||
struct is_ulong_number
|
||||
: public std::integral_constant<
|
||||
bool,
|
||||
std::is_integral<T>::value
|
||||
&& (sizeof(T) > sizeof(std::size_t))
|
||||
&& std::is_unsigned<T>::value
|
||||
>
|
||||
{};
|
||||
|
||||
template<typename T>
|
||||
inline SPROUT_CONSTEXPR std::size_t
|
||||
hash_value_signed_2(T val, int length, std::size_t seed, T positive, std::size_t i) {
|
||||
return i > 0
|
||||
? hash_value_signed_2(
|
||||
val,
|
||||
length,
|
||||
seed ^ static_cast<std::size_t>((positive >> i) + (seed << 6) + (seed >> 2)),
|
||||
positive,
|
||||
i - std::numeric_limits<std::size_t>::digits
|
||||
)
|
||||
: seed ^ static_cast<std::size_t>(val + (seed << 6) + (seed >> 2))
|
||||
;
|
||||
}
|
||||
template<typename T>
|
||||
inline SPROUT_CONSTEXPR std::size_t
|
||||
hash_value_signed_1(T val, int length, std::size_t seed, T positive) {
|
||||
return hash_value_signed_2(val, length, seed, positive, length * std::numeric_limits<std::size_t>::digits);
|
||||
}
|
||||
template<typename T>
|
||||
inline SPROUT_CONSTEXPR std::size_t
|
||||
hash_value_signed(T val) {
|
||||
return sprout::hash_detail::hash_value_signed_1(
|
||||
val,
|
||||
(std::numeric_limits<T>::digits - 1) / std::numeric_limits<std::size_t>::digits,
|
||||
0,
|
||||
val < 0 ? -1 - val : val
|
||||
);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
inline SPROUT_CONSTEXPR std::size_t
|
||||
hash_value_unsigned_2(T val, int length, std::size_t seed, std::size_t i) {
|
||||
return i > 0
|
||||
? hash_value_unsigned_2(
|
||||
val,
|
||||
length,
|
||||
seed ^ static_cast<std::size_t>((val >> i) + (seed << 6) + (seed >> 2)),
|
||||
i - std::numeric_limits<std::size_t>::digits
|
||||
)
|
||||
: seed ^ static_cast<std::size_t>(val + (seed << 6) + (seed >> 2))
|
||||
;
|
||||
}
|
||||
template<typename T>
|
||||
inline SPROUT_CONSTEXPR std::size_t
|
||||
hash_value_unsigned_1(T val, int length, std::size_t seed) {
|
||||
return hash_value_unsigned_2(val, length, seed, length * std::numeric_limits<std::size_t>::digits);
|
||||
}
|
||||
template<typename T>
|
||||
inline SPROUT_CONSTEXPR std::size_t
|
||||
hash_value_unsigned(T val) {
|
||||
return sprout::hash_detail::hash_value_unsigned_1(
|
||||
val,
|
||||
(std::numeric_limits<T>::digits - 1) / std::numeric_limits<std::size_t>::digits,
|
||||
0
|
||||
);
|
||||
}
|
||||
|
||||
inline std::size_t
|
||||
hash_value_pointer_1(std::size_t x) {
|
||||
return x + (x >> 3);
|
||||
}
|
||||
template<typename T>
|
||||
std::size_t
|
||||
hash_value_pointer(T const* v) {
|
||||
return sprout::hash_detail::hash_value_pointer_1(static_cast<std::size_t>(reinterpret_cast<std::ptrdiff_t>(v)));
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
inline SPROUT_CONSTEXPR typename std::enable_if<sprout::hash_detail::is_basic_number<T>::value, std::size_t>::type
|
||||
hash_value_impl(T v) {
|
||||
return static_cast<std::size_t>(v);
|
||||
}
|
||||
template<typename T>
|
||||
inline SPROUT_CONSTEXPR typename std::enable_if<sprout::hash_detail::is_long_number<T>::value, std::size_t>::type
|
||||
hash_value_impl(T v) {
|
||||
return sprout::hash_detail::hash_value_signed(v);
|
||||
}
|
||||
template<typename T>
|
||||
inline SPROUT_CONSTEXPR typename std::enable_if<sprout::hash_detail::is_ulong_number<T>::value, std::size_t>::type
|
||||
hash_value_impl(T v) {
|
||||
return sprout::hash_detail::hash_value_unsigned(v);
|
||||
}
|
||||
template<typename T>
|
||||
inline SPROUT_CONSTEXPR typename std::enable_if<std::is_enum<T>::value, std::size_t>::type
|
||||
hash_value_impl(T v) {
|
||||
return sprout::hash_detail::hash_value_impl(static_cast<typename std::underlying_type<T>::type>(v));
|
||||
}
|
||||
template<typename T>
|
||||
inline SPROUT_CONSTEXPR typename std::enable_if<std::is_floating_point<T>::value, std::size_t>::type
|
||||
hash_value_impl(T v) {
|
||||
return sprout::detail::float_hash_value(v);
|
||||
}
|
||||
template<typename T>
|
||||
inline SPROUT_CONSTEXPR typename std::enable_if<std::is_pointer<typename std::remove_reference<T>::type>::value, std::size_t>::type
|
||||
hash_value_impl(T&& v) {
|
||||
return sprout::hash_detail::hash_value_pointer(v);
|
||||
}
|
||||
template<typename T, std::size_t N>
|
||||
inline SPROUT_CONSTEXPR std::size_t
|
||||
hash_value_impl(T const (&v)[N]) {
|
||||
return sprout::hash_range(v);
|
||||
}
|
||||
template<typename T>
|
||||
inline SPROUT_CONSTEXPR typename std::enable_if<
|
||||
!std::is_arithmetic<T>::value && !std::is_enum<T>::value && !std::is_pointer<T>::value,
|
||||
std::size_t
|
||||
>::type
|
||||
hash_value_impl(T const &v) {
|
||||
return std::hash<typename std::decay<T>::type>()(v);
|
||||
}
|
||||
} // namespace hash_detail
|
||||
|
||||
//
|
||||
// hash_value_traits
|
||||
//
|
||||
template<typename T>
|
||||
struct hash_value_traits {
|
||||
public:
|
||||
static SPROUT_CONSTEXPR std::size_t
|
||||
hash_value(T const& v) {
|
||||
return sprout::hash_detail::hash_value_impl(v);
|
||||
}
|
||||
};
|
||||
template<typename T>
|
||||
struct hash_value_traits<T const>
|
||||
: public sprout::hash_value_traits<T>
|
||||
{};
|
||||
template<typename T>
|
||||
struct hash_value_traits<T volatile>
|
||||
: public sprout::hash_value_traits<T>
|
||||
{};
|
||||
template<typename T>
|
||||
struct hash_value_traits<T const volatile>
|
||||
: public sprout::hash_value_traits<T>
|
||||
{};
|
||||
} // namespace sprout
|
||||
|
||||
#include <sprout/functional/hash/hash_range.hpp>
|
||||
|
||||
#endif // #ifndef SPROUT_FUNCTIONAL_HASH_HASH_VALUE_TRAITS_HPP
|
||||
|
|
@ -4,17 +4,21 @@
|
|||
#include <cstddef>
|
||||
#include <sscrisk/cel/array.hpp>
|
||||
#include <sprout/config.hpp>
|
||||
#include <sprout/functional/hash.hpp>
|
||||
#include <sprout/functional/hash/hash_value_traits.hpp>
|
||||
#include <sprout/functional/hash/hash_range.hpp>
|
||||
|
||||
namespace sprout {
|
||||
//
|
||||
// hash_value
|
||||
// hash_value_traits
|
||||
//
|
||||
template<typename T, std::size_t N>
|
||||
inline SPROUT_CONSTEXPR std::size_t
|
||||
hash_value(sscrisk::cel::array<T, N> const& v) {
|
||||
return sprout::hash_range(v);
|
||||
}
|
||||
struct hash_value_traits<sscrisk::cel::array<T, N> > {
|
||||
public:
|
||||
static SPROUT_CONSTEXPR std::size_t
|
||||
hash_value(sscrisk::cel::array<T, N> const& v) {
|
||||
return sprout::hash_range(v);
|
||||
}
|
||||
};
|
||||
} // namespace sprout
|
||||
|
||||
#endif // #ifndef SPROUT_FUNCTIONAL_HASH_SSCRISK_CEL_ARRAY_HPP
|
||||
|
|
|
|||
|
|
@ -4,17 +4,21 @@
|
|||
#include <cstddef>
|
||||
#include <sscrisk/cel/utility.hpp>
|
||||
#include <sprout/config.hpp>
|
||||
#include <sprout/functional/hash.hpp>
|
||||
#include <sprout/functional/hash/hash_value_traits.hpp>
|
||||
#include <sprout/functional/hash/hash_values.hpp>
|
||||
|
||||
namespace sprout {
|
||||
//
|
||||
// hash_value
|
||||
// hash_value_traits
|
||||
//
|
||||
template<typename T1, typename T2>
|
||||
inline SPROUT_CONSTEXPR std::size_t
|
||||
hash_value(sscrisk::cel::pair<T1, T2> const& v) {
|
||||
return sprout::hash_values(v.first, v.second);
|
||||
}
|
||||
struct hash_value_traits<sscrisk::cel::pair<T1, T2> > {
|
||||
public:
|
||||
static SPROUT_CONSTEXPR std::size_t
|
||||
hash_value(sscrisk::cel::pair<T1, T2> const& v) {
|
||||
return sprout::hash_values(v.first, v.second);
|
||||
}
|
||||
};
|
||||
} // namespace sprout
|
||||
|
||||
#endif // #ifndef SPROUT_FUNCTIONAL_HASH_SSCRISK_CEL_UTILITY_HPP
|
||||
|
|
|
|||
|
|
@ -4,17 +4,21 @@
|
|||
#include <cstddef>
|
||||
#include <array>
|
||||
#include <sprout/config.hpp>
|
||||
#include <sprout/functional/hash.hpp>
|
||||
#include <sprout/functional/hash/hash_value_traits.hpp>
|
||||
#include <sprout/functional/hash/hash_range.hpp>
|
||||
|
||||
namespace sprout {
|
||||
//
|
||||
// hash_value
|
||||
// hash_value_traits
|
||||
//
|
||||
template<typename T, std::size_t N>
|
||||
inline SPROUT_CONSTEXPR std::size_t
|
||||
hash_value(std::array<T, N> const& v) {
|
||||
return sprout::hash_range(v);
|
||||
}
|
||||
struct hash_value_traits<std::array<T, N> > {
|
||||
public:
|
||||
static SPROUT_CONSTEXPR std::size_t
|
||||
hash_value(std::array<T, N> const& v) {
|
||||
return sprout::hash_range(v);
|
||||
}
|
||||
};
|
||||
} // namespace sprout
|
||||
|
||||
#endif // #ifndef SPROUT_FUNCTIONAL_HASH_STD_ARRAY_HPP
|
||||
|
|
|
|||
|
|
@ -4,17 +4,21 @@
|
|||
#include <cstddef>
|
||||
#include <utility>
|
||||
#include <sprout/config.hpp>
|
||||
#include <sprout/functional/hash.hpp>
|
||||
#include <sprout/functional/hash/hash_value_traits.hpp>
|
||||
#include <sprout/functional/hash/hash_values.hpp>
|
||||
|
||||
namespace sprout {
|
||||
//
|
||||
// hash_value
|
||||
// hash_value_traits
|
||||
//
|
||||
template<typename T1, typename T2>
|
||||
inline SPROUT_CONSTEXPR std::size_t
|
||||
hash_value(std::pair<T1, T2> const& v) {
|
||||
return sprout::hash_values(v.first, v.second);
|
||||
}
|
||||
struct hash_value_traits<std::pair<T1, T2> > {
|
||||
public:
|
||||
static SPROUT_CONSTEXPR std::size_t
|
||||
hash_value(std::pair<T1, T2> const& v) {
|
||||
return sprout::hash_values(v.first, v.second);
|
||||
}
|
||||
};
|
||||
} // namespace sprout
|
||||
|
||||
#endif // #ifndef SPROUT_FUNCTIONAL_HASH_STD_UTILITY_HPP
|
||||
|
|
|
|||
|
|
@ -2,144 +2,28 @@
|
|||
#define SPROUT_FUNCTIONAL_HASH_TO_HASH_HPP
|
||||
|
||||
#include <cstddef>
|
||||
#include <utility>
|
||||
#include <type_traits>
|
||||
#include <sprout/config.hpp>
|
||||
#include <sprout/functional/hash/hash_fwd.hpp>
|
||||
#include <sprout/functional/hash/hash_value.hpp>
|
||||
#include <sprout/utility/forward.hpp>
|
||||
#include <sprout/type_traits/enabler_if.hpp>
|
||||
#include <sprout/adl/not_found.hpp>
|
||||
|
||||
namespace sprout_adl {
|
||||
sprout::not_found_via_adl hash_value(...);
|
||||
} // namespace sprout_adl
|
||||
|
||||
namespace sprout_hash_detail {
|
||||
using sprout::hash_value;
|
||||
using sprout_adl::hash_value;
|
||||
|
||||
template<typename T>
|
||||
struct has_adl_hash_value_test {
|
||||
public:
|
||||
template<
|
||||
typename U = T,
|
||||
typename sprout::enabler_if<
|
||||
sprout::is_found_via_adl<decltype(hash_value(std::declval<U>()))>::value
|
||||
>::type = sprout::enabler
|
||||
>
|
||||
static std::true_type test(int);
|
||||
static std::false_type test(...);
|
||||
};
|
||||
#if defined(_MSC_VER)
|
||||
template<typename T, typename Base_ = decltype(sprout_hash_detail::has_adl_hash_value_test<T>::test(0))>
|
||||
struct has_adl_hash_value
|
||||
: public Base_
|
||||
{};
|
||||
#else
|
||||
template<typename T>
|
||||
struct has_adl_hash_value
|
||||
: public decltype(sprout_hash_detail::has_adl_hash_value_test<T>::test(0))
|
||||
{};
|
||||
#endif
|
||||
|
||||
template<typename T, typename Enable = void>
|
||||
struct select_adl_hash_value;
|
||||
template<typename T>
|
||||
struct select_adl_hash_value<
|
||||
T,
|
||||
typename std::enable_if<
|
||||
sprout_hash_detail::has_adl_hash_value<T>::value
|
||||
>::type
|
||||
>
|
||||
: public std::true_type
|
||||
{};
|
||||
template<typename T>
|
||||
struct select_adl_hash_value<
|
||||
T,
|
||||
typename std::enable_if<!(
|
||||
sprout_hash_detail::has_adl_hash_value<T>::value
|
||||
)>::type
|
||||
>
|
||||
: public std::false_type
|
||||
{};
|
||||
|
||||
template<typename T, typename Enable = void>
|
||||
struct select_std_hash;
|
||||
template<typename T>
|
||||
struct select_std_hash<
|
||||
T,
|
||||
typename std::enable_if<
|
||||
!sprout_hash_detail::has_adl_hash_value<T>::value
|
||||
>::type
|
||||
>
|
||||
: public std::true_type
|
||||
{};
|
||||
template<typename T>
|
||||
struct select_std_hash<
|
||||
T,
|
||||
typename std::enable_if<!(
|
||||
!sprout_hash_detail::has_adl_hash_value<T>::value
|
||||
)>::type
|
||||
>
|
||||
: public std::false_type
|
||||
{};
|
||||
|
||||
template<typename T, typename = void>
|
||||
struct noexcept_to_hash;
|
||||
template<typename T>
|
||||
struct noexcept_to_hash<T, typename std::enable_if<sprout_hash_detail::select_adl_hash_value<T>::value>::type>
|
||||
: public std::integral_constant<bool, SPROUT_NOEXCEPT_EXPR_OR_DEFAULT(hash_value(std::declval<T>()), false)>
|
||||
{};
|
||||
template<typename T>
|
||||
struct noexcept_to_hash<T, typename std::enable_if<sprout_hash_detail::select_std_hash<T>::value>::type>
|
||||
: public std::integral_constant<bool, SPROUT_NOEXCEPT_EXPR_OR_DEFAULT(std::hash<typename std::decay<T>::type>()(std::declval<T>()), false)>
|
||||
{};
|
||||
|
||||
template<typename T, typename = void>
|
||||
struct to_hash_result;
|
||||
template<typename T>
|
||||
struct to_hash_result<T, typename std::enable_if<sprout_hash_detail::select_adl_hash_value<T>::value>::type> {
|
||||
public:
|
||||
typedef decltype(hash_value(std::declval<T>())) type;
|
||||
};
|
||||
template<typename T>
|
||||
struct to_hash_result<T, typename std::enable_if<sprout_hash_detail::select_std_hash<T>::value>::type> {
|
||||
public:
|
||||
typedef decltype(std::hash<typename std::decay<T>::type>()(std::declval<T>())) type;
|
||||
};
|
||||
|
||||
template<
|
||||
typename T,
|
||||
typename sprout::enabler_if<sprout_hash_detail::select_adl_hash_value<T>::value>::type = sprout::enabler
|
||||
>
|
||||
inline SPROUT_CONSTEXPR typename sprout_hash_detail::to_hash_result<T>::type
|
||||
to_hash_impl(T&& t)
|
||||
SPROUT_NOEXCEPT_EXPR((sprout_hash_detail::noexcept_to_hash<T>::value))
|
||||
{
|
||||
return hash_value(sprout::forward<T>(t));
|
||||
}
|
||||
template<
|
||||
typename T,
|
||||
typename sprout::enabler_if<sprout_hash_detail::select_std_hash<T>::value>::type = sprout::enabler
|
||||
>
|
||||
inline SPROUT_CONSTEXPR typename sprout_hash_detail::to_hash_result<T>::type
|
||||
to_hash_impl(T&& t)
|
||||
SPROUT_NOEXCEPT_EXPR((sprout_hash_detail::noexcept_to_hash<T>::value))
|
||||
{
|
||||
return std::hash<typename std::decay<T>::type>()(sprout::forward<T>(t));
|
||||
}
|
||||
} // namespace sprout_hash_detail
|
||||
|
||||
namespace sprout {
|
||||
//
|
||||
// to_hash
|
||||
//
|
||||
template<typename T>
|
||||
inline SPROUT_CONSTEXPR std::size_t
|
||||
to_hash(T const& v) {
|
||||
return sprout_hash_detail::to_hash_impl(v);
|
||||
to_hash(T&& v) {
|
||||
using sprout::hash_value;
|
||||
using sprout_adl::hash_value;
|
||||
return hash_value(sprout::forward<T>(v));
|
||||
}
|
||||
} // namespace sprout
|
||||
|
||||
#include <sprout/functional/hash/hash_value.hpp>
|
||||
|
||||
#endif // #ifndef SPROUT_FUNCTIONAL_HASH_TO_HASH_HPP
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue