diff --git a/include/iris/hash.hpp b/include/iris/hash.hpp index ad9cead..0da9aef 100644 --- a/include/iris/hash.hpp +++ b/include/iris/hash.hpp @@ -12,8 +12,10 @@ #include #include #include +#include #include +#include namespace iris { @@ -54,22 +56,11 @@ template constexpr bool is_hash_enabled_v = is_hash_enabled::value; -template -struct is_nothrow_hashable : std::false_type -{ - static_assert( - !std::is_const_v && !std::is_volatile_v && !std::is_reference_v, - "Although the standard has no restriction on hashing potentially " - "cv-qualified and/or reference types, we intentionally disallow " - "them in our metafunction to prevent error-prone instantiations." - ); - - static_assert(is_hash_enabled_v, "is_nothrow_hashable must be used only after proper overload resolution in SFINAE-friendly context"); -}; - template -struct is_nothrow_hashable{}(std::declval()))>> - : std::bool_constant{}(std::declval()))> +struct is_nothrow_hashable + : std::bool_constant{}(x) } noexcept; + }> { static_assert( !std::is_const_v && !std::is_volatile_v && !std::is_reference_v, @@ -91,17 +82,7 @@ constexpr std::size_t hash_mix(std::size_t) noexcept = delete; // https://jonkagstrom.com/mx3/mx3_rev2.html -template<> -[[nodiscard]] constexpr std::size_t hash_mix<4>(std::size_t x) noexcept -{ - x ^= x >> 16; - x *= 0x21f0aaaduz; - x ^= x >> 15; - x *= 0x735a2d97uz; - x ^= x >> 15; - return x; -} - +#if SIZE_MAX >= 0xFFFFFFFFFFFFFFFFULL template<> [[nodiscard]] constexpr std::size_t hash_mix<8>(std::size_t x) noexcept { @@ -112,55 +93,106 @@ template<> x ^= x >> 28; return x; } +#endif -} // detail - -template -[[nodiscard]] constexpr std::size_t hash_combine(std::size_t const seed, T const& v) noexcept; - -template -[[nodiscard]] constexpr std::size_t hash_value(T const& var) noexcept +template<> +[[nodiscard]] constexpr std::size_t hash_mix<4>(std::size_t x) noexcept { - static_assert(is_hash_enabled_v); - return std::hash{}(var); + x ^= x >> 16; + x *= 0x21f0aaaduz; + x ^= x >> 15; + x *= 0x735a2d97uz; + x ^= x >> 15; + return x; } -template - requires std::ranges::input_range -[[nodiscard]] constexpr std::size_t hash_value(R const& r) - noexcept( - noexcept(std::ranges::begin(r)) && - noexcept(std::ranges::end(r)) && - noexcept(++std::declval&>()) && - noexcept(std::declval&>() != std::declval&>()) && - noexcept(iris::hash_value(*std::declval&>())) - ) -{ - std::size_t seed = 0; - auto it = std::ranges::begin(r); - auto const se = std::ranges::end(r); - for (; it != se; ++it) { - seed = iris::hash_combine(seed, iris::hash_value(*it)); - } - return seed; -} +} // detail // https://github.com/boostorg/container_hash/blob/5d8b8ac2b9d9d7cb3818f88fd7e6372e5f072ff5/include/boost/container_hash/hash.hpp#L472C53-L472C63 // https://softwareengineering.stackexchange.com/questions/402542/where-do-magic-hashing-constants-like-0x9e3779b9-and-0x9e3779b1-come-from -template -[[nodiscard]] constexpr std::size_t hash_combine(std::size_t const seed, T const& v) noexcept +[[nodiscard]] constexpr std::size_t hash_combine( + std::same_as auto const seed, std::same_as auto const additional_hash +) noexcept { +#if SIZE_MAX >= 0xFFFFFFFFFFFFFFFFULL + return detail::hash_mix( + seed + 0x9e3779b97f4a7c55uz + additional_hash + ); +#else return detail::hash_mix( - seed + 0x9e3779b97f4a7c55uz + iris::hash_value(v) + seed + 0x9e3779b9uz + additional_hash ); +#endif } +namespace detail { + +namespace adl_hashable_detail { + +void hash_value() = delete; // poison pill + +template +concept adl_hashable = requires(T const& x) { + { hash_value(x) } -> std::convertible_to; +}; + +} // adl_hashable_detail + +using adl_hashable_detail::adl_hashable; + +// This must be CPO to find nested `hash_value` (not solvable with free function) +struct hash_value_fn +{ + template + requires adl_hashable + [[nodiscard]] static constexpr std::size_t operator()(T const& x) + noexcept(noexcept(hash_value(x))) + { + return hash_value(x); + } + + template + requires (!adl_hashable) && is_hash_enabled_v + [[nodiscard]] static constexpr std::size_t operator()(T const& x) + noexcept(is_nothrow_hashable_v) + { + return std::hash{}(x); + } + + template + requires (!adl_hashable) && (!is_hash_enabled_v) && std::ranges::input_range + [[nodiscard]] static constexpr std::size_t operator()(R const& r) + noexcept( + noexcept(std::ranges::begin(r)) && + noexcept(std::ranges::end(r)) && + std::is_nothrow_move_constructible_v> && + std::is_nothrow_move_constructible_v> && + noexcept(++std::declval&>()) && + noexcept(std::declval&>() != std::declval const&>()) && + noexcept(std::declval()(*std::declval&>())) + ) + { + std::size_t seed = 0; + auto it = std::ranges::begin(r); + auto const se = std::ranges::end(r); + for (; it != se; ++it) { + seed = iris::hash_combine(seed, hash_value_fn{}(*it)); + } + return seed; + } +}; + +} // detail + +inline constexpr detail::hash_value_fn hash_value{}; + template -[[nodiscard]] constexpr std::size_t hash_all(T const& first, Ts const&... rest) noexcept +[[nodiscard]] constexpr std::size_t hash_all(T const& first, Ts const&... rest) + noexcept(noexcept(iris::hash_value(first)) && (noexcept(iris::hash_value(rest)) && ...)) { std::size_t seed = iris::hash_value(first); - ((seed = iris::hash_combine(seed, rest)), ...); + ((seed = iris::hash_combine(seed, iris::hash_value(rest))), ...); return seed; } diff --git a/include/iris/hash/FNV_hash.hpp b/include/iris/hash/FNV_hash.hpp index 47b1d60..8ce0200 100644 --- a/include/iris/hash/FNV_hash.hpp +++ b/include/iris/hash/FNV_hash.hpp @@ -9,6 +9,7 @@ #include #include // IWYU pragma: keep +#include // https://datatracker.ietf.org/doc/html/draft-eastlake-fnv-03#section-2 // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=59406 @@ -20,18 +21,20 @@ namespace detail { template struct FNV_hash_numbers; +#if SIZE_MAX >= 0xFFFFFFFFFFFFFFFFULL template<> -struct FNV_hash_numbers<4> +struct FNV_hash_numbers<8> { - static constexpr std::size_t FNV_offset_basis = 2166136261uz; - static constexpr std::size_t FNV_prime = 16777619uz; + static constexpr std::size_t FNV_offset_basis = 14695981039346656037uz; + static constexpr std::size_t FNV_prime = 1099511628211uz; }; +#endif template<> -struct FNV_hash_numbers<8> +struct FNV_hash_numbers<4> { - static constexpr std::size_t FNV_offset_basis = 14695981039346656037uz; - static constexpr std::size_t FNV_prime = 1099511628211uz; + static constexpr std::size_t FNV_offset_basis = 2166136261uz; + static constexpr std::size_t FNV_prime = 16777619uz; }; template diff --git a/include/iris/rvariant/rvariant.hpp b/include/iris/rvariant/rvariant.hpp index 295e576..5e8cc7a 100644 --- a/include/iris/rvariant/rvariant.hpp +++ b/include/iris/rvariant/rvariant.hpp @@ -1809,20 +1809,18 @@ operator<=>(rvariant const& v, rvariant const& w) } // iris -namespace std { - // https://eel.is/c++draft/variant.hash template - requires (::iris::is_hash_enabled_v> && ...) -struct hash<::iris::rvariant> // NOLINT(cert-dcl58-cpp) + requires (iris::is_hash_enabled_v> && ...) +struct std::hash> // NOLINT(cert-dcl58-cpp) { - [[nodiscard]] static /* constexpr */ std::size_t operator()(::iris::rvariant const& v) - noexcept(std::conjunction_v<::iris::is_nothrow_hashable>...>) + [[nodiscard]] static /* constexpr */ std::size_t operator()(iris::rvariant const& v) + noexcept(std::conjunction_v>...>) { - return ::iris::detail::raw_visit(v, [](std::in_place_index_t, T const& t) static + return iris::detail::raw_visit(v, [](std::in_place_index_t, T const& t) static noexcept(std::disjunction_v< std::bool_constant, - ::iris::is_nothrow_hashable + iris::is_nothrow_hashable >) { if constexpr (i == std::variant_npos) { @@ -1877,28 +1875,13 @@ struct hash<::iris::rvariant> // NOLINT(cert-dcl58-cpp) // We assume `hash_combine` is unnecessary here, since the collision // is very unlikely to occur as long as the `index_hash` is NOT // evaluated as the re-interpreted bit representation. - constexpr std::size_t index_hash = ::iris::FNV_hash<>::hash(i); + constexpr std::size_t index_hash = iris::FNV_hash<>::hash(i); return index_hash + std::hash{}(t); } }); } }; -} // std - - -namespace iris { - -template - requires (is_hash_enabled_v> && ...) -[[nodiscard]] std::size_t hash_value(rvariant const& v) - noexcept(std::conjunction_v>...>) -{ - return std::hash>{}(v); -} - -} // iris - #undef IRIS_RVARIANT_DISABLE_UNINITIALIZED_WARNING_BEGIN #undef IRIS_RVARIANT_DISABLE_UNINITIALIZED_WARNING_END diff --git a/test/core.cpp b/test/core.cpp index c0476af..0c8847d 100644 --- a/test/core.cpp +++ b/test/core.cpp @@ -562,6 +562,29 @@ TEST_CASE("throwf") ); } +} // unit_test + +namespace unit_test { + +struct HashSpecializedRange +{ + int const* begin() const { return nullptr; } + int const* end() const { return nullptr; } +}; + +} // unit_test + +template<> +struct std::hash +{ + static std::size_t operator()(unit_test::HashSpecializedRange const&) + { + return 114514uz; + } +}; + +namespace unit_test { + TEST_CASE("hash") { static_assert(iris::hash_all(std::vector{}) == 0); @@ -572,13 +595,16 @@ TEST_CASE("hash") } { std::vector const vec{1}; - CHECK(iris::hash_all(vec) == iris::hash_combine(0, iris::hash_value(1))); - CHECK(iris::hash_all(vec) == iris::hash_combine(0, std::hash{}(1))); + CHECK(iris::hash_all(vec) == iris::hash_combine(0uz, iris::hash_value(1))); } { std::vector const vec{1, 2}; - CHECK(iris::hash_all(vec) == iris::hash_combine(iris::hash_combine(0, iris::hash_value(1)), iris::hash_value(2))); - CHECK(iris::hash_all(vec) == iris::hash_combine(iris::hash_combine(0, std::hash{}(1)), std::hash{}(2))); + CHECK(iris::hash_all(vec) == iris::hash_combine(iris::hash_combine(0uz, iris::hash_value(1)), iris::hash_value(2))); + } + + { + static_assert(std::ranges::input_range); + CHECK(iris::hash_value(HashSpecializedRange{}) == 114514uz); // NOT `0` } } diff --git a/test/rvariant/iris_rvariant_test.hpp b/test/rvariant/iris_rvariant_test.hpp index 463652d..ccab790 100644 --- a/test/rvariant/iris_rvariant_test.hpp +++ b/test/rvariant/iris_rvariant_test.hpp @@ -137,24 +137,8 @@ template throw std::logic_error{"[BUG] failed to create valueless instance; exception was never thrown"}; } -template -struct HashForwarded -{ - T value; -}; - } // unit_test - -template -struct std::hash<::unit_test::HashForwarded> // NOLINT(bugprone-std-namespace-modification) -{ - std::size_t operator()(::unit_test::HashForwarded const& v) const - { - return std::hash{}(v.value); - } -}; - template struct std::formatter<::unit_test::MC_Thrower, charT> // NOLINT(cert-dcl58-cpp) { diff --git a/test/rvariant/rvariant.cpp b/test/rvariant/rvariant.cpp index 9d78351..724a793 100644 --- a/test/rvariant/rvariant.cpp +++ b/test/rvariant/rvariant.cpp @@ -2107,52 +2107,17 @@ TEST_CASE("relational operators") } } -namespace { - -template -[[nodiscard]] constexpr std::size_t do_hash(T const& t) noexcept(iris::is_nothrow_hashable_v) -{ - return std::hash{}(t); -} - -} // anonymous - TEST_CASE("rvariant.hash") { { STATIC_REQUIRE(iris::is_hash_enabled_v); STATIC_REQUIRE(iris::is_hash_enabled_v>); - CHECK(do_hash(iris::rvariant(42)) == hash_value(iris::rvariant(42))); } { struct NonExistent {}; STATIC_REQUIRE(!iris::is_hash_enabled_v); STATIC_REQUIRE(!iris::is_hash_enabled_v>); } - { - STATIC_REQUIRE(iris::is_hash_enabled_v>); - CHECK(std::hash{}(42) == std::hash>{}(HashForwarded(42))); - } - { - STATIC_REQUIRE(iris::is_hash_enabled_v>>); - iris::rvariant> v(HashForwarded(42)); - CHECK(do_hash(v) == hash_value(v)); - } - - // heuristic tests; may fail on collisions - { - using Int = HashForwarded; - using V = iris::rvariant; - CHECK(do_hash(V(std::in_place_type, 42)) != do_hash(V(std::in_place_type, 42))); - } - { - using V = iris::rvariant; - CHECK(do_hash(V(std::in_place_type, 42)) != do_hash(V(std::in_place_type, 42))); - } - { - using V = iris::rvariant; - CHECK(do_hash(V(std::in_place_type, 42)) != do_hash(V(std::in_place_type, 42))); - } } TEST_CASE("rvariant.hash", "[wrapper]") @@ -2160,13 +2125,6 @@ TEST_CASE("rvariant.hash", "[wrapper]") { STATIC_REQUIRE(iris::is_hash_enabled_v>); CHECK(std::hash{}(42) == std::hash>{}(iris::recursive_wrapper(42))); - CHECK(std::hash{}(42) == hash_value(iris::recursive_wrapper(42))); - } - { - iris::recursive_wrapper a(42); - auto b = std::move(a); - REQUIRE(a.valueless_after_move()); // NOLINT(bugprone-use-after-move) - CHECK(std::hash>{}(a) == hash_value(a)); } }