flat_hash_set test passing

parallel_hashmap/phmap.h

@@ -3992,8 +3992,7 @@ public:
 template <class T, class E = void>
 struct HashEq 
 {
-    //using Hash = phmap::Hash<T>;
-    using Hash = std::hash<T>;
+    using Hash = phmap::Hash<T>;
     using Eq   = std::equal_to<T>;
 };
 
@@ -4013,12 +4012,16 @@ struct HashEq<int64_t> {
     using Eq   = std::equal_to<int64_t>;
 };
 
+#endif
+
+#if PHMAP_HAVE_STD_STRING_VIEW
+
 struct StringHash 
 {
     using is_transparent = void;
 
-    size_t operator()(phmap::string_view v) const {
-        return phmap::Hash<phmap::string_view>{}(v);
+    size_t operator()(std::string_view v) const {
+        return phmap::Hash<std::string_view>{}(v);
     }
 };
 
@@ -4028,7 +4031,7 @@ struct StringHashEq
     using Hash = StringHash;
     struct Eq {
         using is_transparent = void;
-        bool operator()(phmap::string_view lhs, phmap::string_view rhs) const {
+        bool operator()(std::string_view lhs, std::string_view rhs) const {
             return lhs == rhs;
         }
     };
@@ -4038,7 +4041,7 @@ template <>
 struct HashEq<std::string> : StringHashEq {};
 
 template <>
-struct HashEq<phmap::string_view> : StringHashEq {};
+struct HashEq<std::string_view> : StringHashEq {};
 
 #endif
 
@@ -4050,8 +4053,8 @@ struct HashEq<T*>
         using is_transparent = void;
         template <class U>
         size_t operator()(const U& ptr) const {
-            //return phmap::Hash<const T*>{}(HashEq::ToPtr(ptr));
-            return std::hash<const T*>{}(HashEq::ToPtr(ptr));
+            return phmap::Hash<const T*>{}(HashEq::ToPtr(ptr));
+            //return std::hash<const T*>{}(HashEq::ToPtr(ptr));
         }
     };
 

parallel_hashmap/phmap_base.h

@@ -1707,7 +1707,7 @@ struct nullopt_t
     explicit constexpr nullopt_t(init_t& /*unused*/) {}
 };
 
-extern const nullopt_t nullopt;
+constexpr nullopt_t nullopt(nullopt_t::init);
 
 namespace optional_internal {
 

parallel_hashmap/phmap_utils.h

@@ -34,7 +34,212 @@
 // limitations under the License.
 // ---------------------------------------------------------------------------
 
+//#include <cstddef>
+#include <functional>
+#define PHMAP_HASH_CLASS std::hash
 
+namespace phmap
+{
+
+template <class T>  T phmap_min(T a, T b) { return a < b  ? a : b; }
+template <class T>  T phmap_max(T a, T b) { return a >= b ? a : b; }
+
+template <class T>
+struct Hash
+{
+    inline size_t operator()(const T &__v) const noexcept
+    {
+        PHMAP_HASH_CLASS<T> hasher;
+        return hasher(__v);
+    }
+};
+
+template <class T>
+struct Hash<T *>
+{
+    static size_t spp_log2 (size_t val) noexcept
+    {
+        size_t res = 0;
+        while (val > 1)
+        {
+            val >>= 1;
+            res++;
+        }
+        return res;
+    }
+
+    inline size_t operator()(const T *__v) const noexcept
+    {
+        static const size_t shift = 3; // spp_log2(1 + sizeof(T)); // T might be incomplete!
+        const uintptr_t i = (const uintptr_t)__v;
+        return static_cast<size_t>(i >> shift);
+    }
+};
+
+// from http://burtleburtle.net/bob/hash/integer.html
+// fast and efficient for power of two table sizes where we always
+// consider the last bits.
+// ---------------------------------------------------------------
+inline size_t spp_mix_32(uint32_t a)
+{
+    a = a ^ (a >> 4);
+    a = (a ^ 0xdeadbeef) + (a << 5);
+    a = a ^ (a >> 11);
+    return static_cast<size_t>(a);
+}
+
+// More thorough scrambling as described in
+// https://gist.github.com/badboy/6267743
+// ----------------------------------------
+inline size_t spp_mix_64(uint64_t a)
+{
+    a = (~a) + (a << 21); // a = (a << 21) - a - 1;
+    a = a ^ (a >> 24);
+    a = (a + (a << 3)) + (a << 8); // a * 265
+    a = a ^ (a >> 14);
+    a = (a + (a << 2)) + (a << 4); // a * 21
+    a = a ^ (a >> 28);
+    a = a + (a << 31);
+    return static_cast<size_t>(a);
+}
+
+template<class ArgumentType, class ResultType>
+struct spp_unary_function
+{
+    typedef ArgumentType argument_type;
+    typedef ResultType result_type;
+};
+
+template <>
+struct Hash<bool> : public spp_unary_function<bool, size_t>
+{
+    inline size_t operator()(bool __v) const noexcept
+    { return static_cast<size_t>(__v); }
+};
+
+template <>
+struct Hash<char> : public spp_unary_function<char, size_t>
+{
+    inline size_t operator()(char __v) const noexcept
+    { return static_cast<size_t>(__v); }
+};
+
+template <>
+struct Hash<signed char> : public spp_unary_function<signed char, size_t>
+{
+    inline size_t operator()(signed char __v) const noexcept
+    { return static_cast<size_t>(__v); }
+};
+
+template <>
+struct Hash<unsigned char> : public spp_unary_function<unsigned char, size_t>
+{
+    inline size_t operator()(unsigned char __v) const noexcept
+    { return static_cast<size_t>(__v); }
+};
+
+template <>
+struct Hash<wchar_t> : public spp_unary_function<wchar_t, size_t>
+{
+    inline size_t operator()(wchar_t __v) const noexcept
+    { return static_cast<size_t>(__v); }
+};
+
+template <>
+struct Hash<int16_t> : public spp_unary_function<int16_t, size_t>
+{
+    inline size_t operator()(int16_t __v) const noexcept
+    { return spp_mix_32(static_cast<uint32_t>(__v)); }
+};
+
+template <>
+struct Hash<uint16_t> : public spp_unary_function<uint16_t, size_t>
+{
+    inline size_t operator()(uint16_t __v) const noexcept
+    { return spp_mix_32(static_cast<uint32_t>(__v)); }
+};
+
+template <>
+struct Hash<int32_t> : public spp_unary_function<int32_t, size_t>
+{
+    inline size_t operator()(int32_t __v) const noexcept
+    { return spp_mix_32(static_cast<uint32_t>(__v)); }
+};
+
+template <>
+struct Hash<uint32_t> : public spp_unary_function<uint32_t, size_t>
+{
+    inline size_t operator()(uint32_t __v) const noexcept
+    { return spp_mix_32(static_cast<uint32_t>(__v)); }
+};
+
+template <>
+struct Hash<int64_t> : public spp_unary_function<int64_t, size_t>
+{
+    inline size_t operator()(int64_t __v) const noexcept
+    { return spp_mix_64(static_cast<uint64_t>(__v)); }
+};
+
+template <>
+struct Hash<uint64_t> : public spp_unary_function<uint64_t, size_t>
+{
+    inline size_t operator()(uint64_t __v) const noexcept
+    { return spp_mix_64(static_cast<uint64_t>(__v)); }
+};
+
+template <>
+struct Hash<float> : public spp_unary_function<float, size_t>
+{
+    inline size_t operator()(float __v) const noexcept
+    {
+        // -0.0 and 0.0 should return same hash
+        uint32_t *as_int = reinterpret_cast<uint32_t *>(&__v);
+        return (__v == 0) ? static_cast<size_t>(0) : spp_mix_32(*as_int);
+    }
+};
+
+template <>
+struct Hash<double> : public spp_unary_function<double, size_t>
+{
+    inline size_t operator()(double __v) const noexcept
+    {
+        // -0.0 and 0.0 should return same hash
+        uint64_t *as_int = reinterpret_cast<uint64_t *>(&__v);
+        return (__v == 0) ? static_cast<size_t>(0) : spp_mix_64(*as_int);
+    }
+};
+
+template <class T, int sz> struct Combiner
+{
+    inline void operator()(T& seed, T value);
+};
+
+template <class T> struct Combiner<T, 4>
+{
+    inline void  operator()(T& seed, T value)
+    {
+        seed ^= value + 0x9e3779b9 + (seed << 6) + (seed >> 2);
+    }
+};
+
+template <class T> struct Combiner<T, 8>
+{
+    inline void  operator()(T& seed, T value)
+    {
+        seed ^= value + T(0xc6a4a7935bd1e995) + (seed << 6) + (seed >> 2);
+    }
+};
+
+template <class T>
+inline void hash_combine(std::size_t& seed, T const& v)
+{
+    spp_::Hash<T> hasher;
+    Combiner<std::size_t, sizeof(std::size_t)> combiner;
+
+    combiner(seed, hasher(v));
+}
+
+}
 
 
 #endif // phmap_utils_h_guard_