hash-fct.H

Go to the documentation of this file.

/*
                          Aleph_w
 
  Data structures & Algorithms
  version 2.0.0b
  https://github.com/lrleon/Aleph-w
 
  This file is part of Aleph-w library
 
  Copyright (c) 2002-2026 Leandro Rabindranath Leon
 
  Permission is hereby granted, free of charge, to any person obtaining a copy
  of this software and associated documentation files (the "Software"), to deal
  in the Software without restriction, including without limitation the rights
  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  copies of the Software, and to permit persons to whom the Software is
  furnished to do so, subject to the following conditions:
 
  The above copyright notice and this permission notice shall be included in all
  copies or substantial portions of the Software.
 
  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  SOFTWARE.
*/
 
# ifndef HASH_FCT_H
# define HASH_FCT_H
 
# include <cstddef>
# include <cstring>
# include <string>
# include <concepts>
# include <type_traits>
# include <cstdint>
 
namespace Aleph
{
  extern const unsigned Default_Hash_Seed;
 
  void init_jsw() noexcept;
 
  void init_jsw(std::uint32_t seed) noexcept;
 
  bool is_jsw_initialized() noexcept;
 
  inline size_t add_hash(const void * key, const size_t len) noexcept
  {
    const auto *p = static_cast<const unsigned char *>(key);
    size_t h = 0;
 
    for (size_t i = 0; i < len; i++)
      h += p[i];
 
    return h;
  }
 
  inline size_t xor_hash(const void * key, const size_t len) noexcept
  {
    const auto *p = static_cast<const unsigned char *>(key);
    size_t h = 0;
 
    for (size_t i = 0; i < len; i++)
      h ^= p[i];
 
    return h;
  }
 
  inline size_t rot_hash(const void * key, const size_t len) noexcept
  {
    const auto *p = static_cast<const unsigned char *>(key);
    size_t h = 0;
 
    for (size_t i = 0; i < len; i++)
      h = (h << 4) ^ (h >> 28) ^ p[i];
 
    return h;
  }
 
  inline size_t djb_hash(const void * key, const size_t len) noexcept
  {
    const auto *p = static_cast<const unsigned char *>(key);
    size_t h = 0;
 
    for (size_t i = 0; i < len; i++)
      h = 33 * h ^ p[i];
 
    return h;
  }
 
  inline size_t sax_hash(const void * key, const size_t len) noexcept
  {
    const auto *p = static_cast<const unsigned char *>(key);
    size_t h = 0;
 
    for (size_t i = 0; i < len; i++)
      h ^= (h << 5) + (h >> 2) + p[i];
 
    return h;
  }
 
  inline size_t fnv_hash(const void * key, const size_t len) noexcept
  {
    const auto *p = static_cast<const unsigned char *>(key);
    size_t h = 2166136261;
 
    for (size_t i = 0; i < len; i++)
      h = (h * 16777619) ^ p[i];
 
    return h;
  }
 
  inline size_t oat_hash(const void * key, const size_t len) noexcept
  {
    const auto *p = static_cast<const unsigned char *>(key);
    size_t h = 0;
 
    for (size_t i = 0; i < len; i++)
      {
        h += p[i];
        h += (h << 10);
        h ^= (h >> 6);
      }
 
    h += (h << 3);
    h ^= (h >> 11);
    h += (h << 15);
 
    return h;
  }
 
  extern size_t jsw_hash(const void * key, size_t len) noexcept;
 
  inline size_t elf_hash(const void * key, const size_t len) noexcept
  {
    const auto *p = static_cast<const unsigned char *>(key);
    size_t h = 0;
 
    for (size_t i = 0; i < len; i++)
      {
        h = (h << 4) + p[i];
        size_t g = h & 0xf0000000L;
 
        if (g != 0)
          h ^= g >> 24;
 
        h &= ~g;
      }
 
    return h;
  }
 
  extern size_t jen_hash(const void *key, size_t len, unsigned initval) noexcept;
 
  /* The following is just a exact copy of functions implemented by Peter
     Scott. They are at:
 
     https://github.com/PeterScott/murmur3
 
     They are a port of MurmurHash  by Austin Appleby. See
 
     http://en.wikipedia.org/wiki/MurmurHash
 
     For more details
  */
 
  void MurmurHash3_x86_32 (const void *key, int len, uint32_t seed, void *out);
 
  void MurmurHash3_x86_128(const void *key, int len, uint32_t seed, void *out);
 
  void MurmurHash3_x64_128(const void *key, int len, uint32_t seed, void *out);
 
  struct Buf128Bits
  {
    std::uint32_t a[4];
  };
 
  // Pick the 128-bit MurmurHash3 mixer on every 64-bit architecture, not
  // just x86-64. The earlier `# ifdef __x86_64__` was misnamed: the
  // implementation `MurmurHash3_x64_128` is plain C using `uint64_t`
  // arithmetic with no x86 intrinsics, so it runs identically on AArch64
  // and Windows ARM64. Routing those targets through `MurmurHash3_x86_32`
  // produced 32 bits of payload written into a 64-bit `size_t`, leaving
  // the high half uninitialised — undefined behaviour that the ARM64
  // Clang Release pipeline happily folded into garbage hashes, breaking
  // Count-Min Sketch / HyperLogLog / MinHash / Quotient-Filter tests.
# if defined(__x86_64__) || defined(__aarch64__) \
   || defined(_M_X64)    || defined(_M_ARM64)
#   define ALEPH_HASH_USE_MURMUR3_64 1
# else
#   define ALEPH_HASH_USE_MURMUR3_64 0
# endif
 
  template <typename Key>
    requires std::is_trivially_copyable_v<Key>
  inline size_t murmur3hash(const Key & key, std::uint32_t seed)
  {
# if ALEPH_HASH_USE_MURMUR3_64
    Buf128Bits buf;
    MurmurHash3_x64_128(&key, sizeof(key), seed, &buf);
# else
    std::uint32_t buf = 0;
    MurmurHash3_x86_32(&key, sizeof(key), seed, &buf);
# endif
 
    size_t ret = 0;
    memcpy(&ret, &buf, std::min(sizeof(ret), sizeof(buf)));
 
    return ret;
  }
 
 
  inline size_t murmur3hash(const char * key, const std::uint32_t seed)
  {
    const size_t len = strlen(key);
# if ALEPH_HASH_USE_MURMUR3_64
    Buf128Bits buf;
    MurmurHash3_x64_128(key, len, seed, &buf);
# else
    std::uint32_t buf = 0;
    MurmurHash3_x86_32(key, len, seed, &buf);
# endif
 
    size_t ret = 0;
    memcpy(&ret, &buf, std::min(sizeof(ret), sizeof(buf)));
 
    return ret;
  }
 
  inline size_t murmur3hash(const std::string & key, const std::uint32_t seed)
  {
# if ALEPH_HASH_USE_MURMUR3_64
    Buf128Bits buf;
    MurmurHash3_x64_128(key.c_str(), key.size(), seed, &buf);
# else
    std::uint32_t buf = 0;
    MurmurHash3_x86_32(key.c_str(), key.size(), seed, &buf);
# endif
 
    size_t ret = 0;
    memcpy(&ret, &buf, std::min(sizeof(ret), sizeof(buf)));
 
    return ret;
  }
 
 
  /* Paul Hsieh superfast hash function.
 
     Taken from
 
     http://www.azillionmonkeys.com/qed/hash.html
  */
 
#undef get16bits
inline std::uint16_t get16bits(const void * p) noexcept
{
  std::uint16_t val;
  memcpy(&val, p, sizeof(val));
  return val;
}
 
  inline size_t SuperFastHash(const void * key, const size_t len, std::uint32_t seed = 0) noexcept
  {
    const auto * data = static_cast<const unsigned char *>(key);
    std::uint32_t hash = static_cast<std::uint32_t>(len) ^ seed;
 
    if (len <= 0 || data == nullptr)
      return static_cast<size_t>(hash);
 
    const int rem = len & 3;
    const size_t nblocks = len >> 2;
 
    /* Main loop */
    for (size_t i = 0; i < nblocks; ++i)
      {
        hash  += get16bits (data);
        const std::uint32_t tmp = (static_cast<std::uint32_t>(get16bits(data+2)) << 11) ^ hash;
        hash   = (hash << 16) ^ tmp;
        data  += 2*sizeof (uint16_t);
        hash  += hash >> 11;
      }
 
    /* Handle end cases */
    switch (rem)
      {
      case 3:
        hash += get16bits (data);
        hash ^= hash << 16;
        hash ^= static_cast<signed char>(data[sizeof(uint16_t)]) << 18;
        hash += hash >> 11;
        break;
      case 2:
        hash += get16bits (data);
        hash ^= hash << 11;
        hash += hash >> 17;
        break;
      case 1:
        hash += static_cast<signed char>(*data);
        hash ^= hash << 10;
        hash += hash >> 1;
        break;
      default:
        break;
      }
 
    /* Force "avalanching" of final 127 bits */
    hash ^= hash << 3;
    hash += hash >> 5;
    hash ^= hash << 4;
    hash += hash >> 17;
    hash ^= hash << 25;
    hash += hash >> 6;
 
    return static_cast<size_t>(hash);
  }
 
  size_t xxhash64_hash(const void * key, size_t len,
                       std::uint64_t seed = Default_Hash_Seed) noexcept;
 
  size_t wyhash_hash(const void * key, size_t len,
                     std::uint64_t seed = Default_Hash_Seed) noexcept;
 
  size_t siphash24_hash(const void * key, size_t len,
                        std::uint64_t key0 = 0x0706050403020100ULL,
                        std::uint64_t key1 = 0x0f0e0d0c0b0a0908ULL) noexcept;
 
  template <typename Key>
    requires std::is_trivially_copyable_v<Key>
  inline size_t add_hash(const Key & key) noexcept
  {
    return add_hash(&key, sizeof(key));
  }
 
  template <typename Key>
    requires std::is_trivially_copyable_v<Key>
  inline size_t xor_hash(const Key & key) noexcept
  {
    return xor_hash(&key, sizeof(key));
  }
 
  template <typename Key>
    requires std::is_trivially_copyable_v<Key>
  inline size_t rot_hash(const Key & key) noexcept
  {
    return rot_hash(&key, sizeof(key));
  }
 
  template <typename Key>
    requires std::is_trivially_copyable_v<Key>
  inline size_t djb_hash(const Key & key) noexcept
  {
    return djb_hash(&key, sizeof(key));
  }
 
  template <typename Key>
    requires std::is_trivially_copyable_v<Key>
  inline size_t sax_hash(const Key & key) noexcept
  {
    return sax_hash(&key, sizeof(key));
  }
 
  template <typename Key>
    requires std::is_trivially_copyable_v<Key>
  inline size_t fnv_hash(const Key & key) noexcept
  {
    return fnv_hash(&key, sizeof(key));
  }
 
  template <typename Key>
    requires std::is_trivially_copyable_v<Key>
  inline size_t oat_hash(const Key & key) noexcept
  {
    return oat_hash(&key, sizeof(key));
  }
 
  template <typename Key>
    requires std::is_trivially_copyable_v<Key>
  inline size_t jsw_hash(const Key & key) noexcept
  {
    return jsw_hash(&key, sizeof(key));
  }
 
  template <typename Key>
    requires std::is_trivially_copyable_v<Key>
  inline size_t elf_hash(const Key & key) noexcept
  {
    return elf_hash(&key, sizeof(key));
  }
 
  template <typename Key>
    requires std::is_trivially_copyable_v<Key>
  inline size_t jen_hash(const Key &  key, const unsigned initval) noexcept
  {
    return jen_hash(&key, sizeof(key), initval);
  }
 
  template <typename Key>
    requires (std::is_trivially_copyable_v<Key> and 
              (not std::is_pointer_v<Key>) and (not std::is_array_v<Key>))
  inline size_t SuperFastHash(const Key & key, std::uint32_t seed = 0) noexcept
  {
    return SuperFastHash(&key, sizeof(key), seed);
  }
 
  template <typename Key>
    requires std::is_trivially_copyable_v<Key>
  size_t xxhash64_hash(const Key & key,
                       std::uint64_t seed = Default_Hash_Seed) noexcept
  {
    return xxhash64_hash(&key, sizeof(key), seed);
  }
 
  template <typename Key>
    requires std::is_trivially_copyable_v<Key>
  size_t wyhash_hash(const Key & key,
                     std::uint64_t seed = Default_Hash_Seed) noexcept
  {
    return wyhash_hash(&key, sizeof(key), seed);
  }
 
  template <typename Key>
    requires std::is_trivially_copyable_v<Key>
  size_t siphash24_hash(const Key & key,
                        std::uint64_t key0 = 0x0706050403020100ULL,
                        std::uint64_t key1 = 0x0f0e0d0c0b0a0908ULL) noexcept
  {
    return siphash24_hash(&key, sizeof(key), key0, key1);
  }
 
  inline size_t add_hash(const char * key) noexcept
  {
    auto p = reinterpret_cast<const unsigned char *>(key);
    size_t h = 0;
  
    while (*p)
      h += *p++;
  
    return h;
  }
 
  inline size_t xor_hash(const char * key) noexcept
  {
    auto p = reinterpret_cast<const unsigned char *>(key);
    size_t h = 0;
  
    while (*p)
      h ^= *p++;
  
    return h;
  }
 
  inline size_t rot_hash(const char * key) noexcept
  {
    auto p = reinterpret_cast<const unsigned char *>(key);
    size_t h = 0;
 
    while (*p)
      h = (h << 4) ^(h >> 28) ^ *p++;
 
    return h;
  }
 
  inline size_t djb_hash(const char * key) noexcept
  {
    auto p = reinterpret_cast<const unsigned char *>(key);
    size_t h = 0;
 
    while (*p)
      h = 33 * h ^ *p++;
 
    return h;
  }
 
  inline size_t sax_hash(const char * key) noexcept
  {
    auto p = reinterpret_cast<const unsigned char *>(key);
    size_t h = 0;
 
    while (*p)
      h ^= (h << 5) +(h >> 2) + *p++;
 
    return h;
  }
 
  inline size_t fnv_hash(const char * key) noexcept
  {
    auto p = reinterpret_cast<const unsigned char *>(key);
    size_t h = 2166136261;
 
    while (*p)
      h = (h * 16777619) ^ *p++;
 
    return h;
  }
 
  inline size_t oat_hash(const char * key) noexcept
  {
    auto p = reinterpret_cast<const unsigned char *>(key);
    size_t h = 0;
 
    while (*p)
      {
        h += *p++;
        h += (h << 10);
        h ^= (h >> 6);
      }
 
    h += (h << 3);
    h ^= (h >> 11);
    h += (h << 15);
 
    return h;
  }
 
  extern size_t jsw_hash(const char * key) noexcept;
 
  inline size_t elf_hash(const char * key) noexcept
  {
    auto p = reinterpret_cast<const unsigned char *>(key);
    size_t h = 0;
 
    while (*p)
      {
        h =(h << 4) + *p++;
        size_t g = h & 0xf0000000L;
 
        if(g != 0)
          h ^= g >> 24;
 
        h &= ~g;
      }
 
    return h;
  }
 
  inline size_t SuperFastHash(const char * key, std::uint32_t seed = 0) noexcept
  {
    return SuperFastHash(key, strlen(key), seed);
  }
 
  inline size_t xxhash64_hash(const char * key,
                              std::uint64_t seed = Default_Hash_Seed) noexcept
  {
    return xxhash64_hash(key, strlen(key), seed);
  }
 
  inline size_t wyhash_hash(const char * key,
                            std::uint64_t seed = Default_Hash_Seed) noexcept
  {
    return wyhash_hash(key, strlen(key), seed);
  }
 
  inline size_t siphash24_hash(const char * key,
                               std::uint64_t key0 = 0x0706050403020100ULL,
                               std::uint64_t key1 = 0x0f0e0d0c0b0a0908ULL) noexcept
  {
    return siphash24_hash(key, strlen(key), key0, key1);
  }
 
  // String overloads use data()+size() so that embedded NUL bytes are hashed
  // correctly.  Calling c_str() delegates to the NUL-terminated char* overload
  // which would stop at the first '\0'.
 
  inline size_t add_hash(const std::string & key) noexcept
  {
    return add_hash(key.data(), key.size());
  }
 
  inline size_t xor_hash(const std::string & key) noexcept
  {
    return xor_hash(key.data(), key.size());
  }
 
  inline size_t rot_hash(const std::string & key) noexcept
  {
    return rot_hash(key.data(), key.size());
  }
 
  inline size_t djb_hash(const std::string & key) noexcept
  {
    return djb_hash(key.data(), key.size());
  }
 
  inline size_t sax_hash(const std::string & key) noexcept
  {
    return sax_hash(key.data(), key.size());
  }
 
  inline size_t fnv_hash(const std::string & key) noexcept
  {
    return fnv_hash(key.data(), key.size());
  }
 
  inline size_t oat_hash(const std::string & key) noexcept
  {
    return oat_hash(key.data(), key.size());
  }
 
  inline size_t jsw_hash(const std::string & key) noexcept
  {
    return jsw_hash(key.data(), key.size());
  }
 
  inline size_t elf_hash(const std::string & key) noexcept
  {
    return elf_hash(key.data(), key.size());
  }
 
  inline size_t jen_hash(const std::string & key, unsigned initval) noexcept
  {
    return jen_hash(key.c_str(), key.size(), initval);
  }
 
  inline size_t SuperFastHash(const std::string & key, std::uint32_t seed = 0) noexcept
  {
    return SuperFastHash(key.c_str(), key.size(), seed);
  }
 
  inline size_t xxhash64_hash(const std::string & key,
                              std::uint64_t seed = Default_Hash_Seed) noexcept
  {
    return xxhash64_hash(key.data(), key.size(), seed);
  }
 
  inline size_t wyhash_hash(const std::string & key,
                            std::uint64_t seed = Default_Hash_Seed) noexcept
  {
    return wyhash_hash(key.data(), key.size(), seed);
  }
 
  inline size_t siphash24_hash(const std::string & key,
                               std::uint64_t key0 = 0x0706050403020100ULL,
                               std::uint64_t key1 = 0x0f0e0d0c0b0a0908ULL) noexcept
  {
    return siphash24_hash(key.data(), key.size(), key0, key1);
  }
 
  // ──────────────────────────────────────────────────────────────────────
  // hash_combine  (non-commutative fold used by pair helpers and Aleph_Hash)
  // ──────────────────────────────────────────────────────────────────────
 
  inline void hash_combine(size_t & seed, size_t h) noexcept
  {
    seed ^= h + size_t{0x9e3779b97f4a7c15ULL} + (seed << 12) + (seed >> 4);
  }
 
  // ──────────────────────────────────────────────────────────────────────
  // Semantic Hash Customization Layer  (HASH-005)
  // ──────────────────────────────────────────────────────────────────────
 
  template <typename T>
  concept HashableByADL = requires(const T & t)
  {
    { aleph_hash_value(t) } -> std::convertible_to<size_t>;
  };
 
  template <typename T>
  struct Aleph_Hash
  {
    // Floating-point types are excluded from the raw-byte fallback because equal
    // values can have different bit patterns (e.g., -0.0 == +0.0, NaN != NaN
    // but multiple bit representations exist).  Implement aleph_hash_value() or
    // specialize Aleph_Hash<> for float/double.
    static_assert(
      HashableByADL<T> or
      (std::is_trivially_copyable_v<T>
       and not std::is_pointer_v<T>
       and not std::is_floating_point_v<T>),
      "Aleph_Hash<T>: T has no aleph_hash_value() in its namespace and cannot "
      "be safely byte-hashed (pointer, floating-point, or non-trivially-copyable "
      "type).  Define:\n"
      "  size_t aleph_hash_value(const T &) noexcept;\n"
      "in T's namespace, or specialize Aleph_Hash<T>."
    );
 
    [[nodiscard]] size_t operator()(const T & key) const noexcept
    {
      if constexpr (HashableByADL<T>)
        return aleph_hash_value(key);
      else
        return wyhash_hash(key);
    }
 
    [[nodiscard]] size_t operator()(const T & key, std::uint32_t seed) const noexcept
    {
      if constexpr (HashableByADL<T>)
        {
          size_t h = aleph_hash_value(key);
          hash_combine(h, static_cast<size_t>(seed));
          return h;
        }
      else
        return wyhash_hash(key, seed);
    }
  };
 
  // Explicit specializations for floating-point types.
  // The raw-byte fallback is excluded for floats because equal values can have
  // different bit patterns (-0.0 == +0.0, multiple NaN encodings).  These
  // specializations normalize -0.0 to +0.0 before hashing the bits.
 
  // Note on NaN: distinct NaN bit-patterns hash differently because NaN != NaN
  // is not handled here — normalization is applied only to -0.0 (mapped to +0.0).
  // Callers that store NaN keys must canonicalize them before hashing.
  template <>
  struct Aleph_Hash<float>
  {
    [[nodiscard]] size_t operator()(float key) const noexcept
    {
      if (key == 0.0f) key = 0.0f;  // normalize -0.0 → +0.0
      std::uint32_t bits = 0;
      std::memcpy(&bits, &key, sizeof(bits));
      return SuperFastHash(&bits, sizeof(bits));
    }
    [[nodiscard]] size_t operator()(float key, std::uint32_t seed) const noexcept
    {
      if (key == 0.0f) key = 0.0f;
      std::uint32_t bits = 0;
      std::memcpy(&bits, &key, sizeof(bits));
      return SuperFastHash(&bits, sizeof(bits), seed);
    }
  };
 
  template <>
  struct Aleph_Hash<double>
  {
    [[nodiscard]] size_t operator()(double key) const noexcept
    {
      if (key == 0.0) key = 0.0;  // normalize -0.0
      std::uint64_t bits = 0;
      std::memcpy(&bits, &key, sizeof(bits));
      return wyhash_hash(bits);  // pass by value → wyhash_hash<uint64_t> overload
    }
    [[nodiscard]] size_t operator()(double key, std::uint32_t seed) const noexcept
    {
      if (key == 0.0) key = 0.0;
      std::uint64_t bits = 0;
      std::memcpy(&bits, &key, sizeof(bits));
      return wyhash_hash(bits, seed);
    }
  };
 
  // ──────────────────────────────────────────────────────────────────────
  // Default hash functions  (route through Aleph_Hash)
  // ──────────────────────────────────────────────────────────────────────
 
  static constexpr std::uint32_t Aleph_Snd_Hash_Seed = 0x9e3779b9u;
 
  template <typename Key>
    requires (not std::is_pointer_v<Key> and
              not std::is_array_v<Key> and
              not std::is_same_v<std::remove_cvref_t<Key>, std::string>)
  inline size_t dft_hash_fct(const Key & key) noexcept
  {
    return Aleph_Hash<Key>{}(key);
  }
 
  template <typename Key>
    requires std::is_pointer_v<Key>
  inline size_t dft_hash_fct(const Key & key) noexcept
  {
    return SuperFastHash(&key, sizeof(key));
  }
 
  inline size_t dft_hash_fct(const char * key) noexcept
  {
    return wyhash_hash(key);
  }
 
  inline size_t dft_hash_fct(const std::string & key) noexcept
  {
    return wyhash_hash(key);
  }
 
  template <typename Key>
    requires (not std::is_pointer_v<Key> and
              not std::is_array_v<Key> and
              not std::is_same_v<std::remove_cvref_t<Key>, std::string>)
  inline size_t dft_hash_fct(const Key & key, std::uint32_t seed) noexcept
  {
    return Aleph_Hash<Key>{}(key, seed);
  }
 
  template <typename Key>
    requires std::is_pointer_v<Key>
  inline size_t dft_hash_fct(const Key & key, std::uint32_t seed) noexcept
  {
    return SuperFastHash(&key, sizeof(key), seed);
  }
 
  inline size_t dft_hash_fct(const char * key, std::uint32_t seed) noexcept
  {
    return wyhash_hash(key, seed);
  }
 
  inline size_t dft_hash_fct(const std::string & key, std::uint32_t seed) noexcept
  {
    return wyhash_hash(key, seed);
  }
 
  template <typename Key>
  inline size_t dft_hash_ptr_fct(const Key & key) noexcept
  {
    return dft_hash_fct(key);
  }
 
  template <typename Key>
  inline size_t dft_seed_hash_ptr_fct(const Key & key, const unsigned long seed) noexcept
  {
    return dft_hash_fct(key, static_cast<std::uint32_t>(seed));
  }
 
  template <typename Key>
    requires (not std::is_pointer_v<Key> and
              not std::is_array_v<Key> and
              not std::is_same_v<std::remove_cvref_t<Key>, std::string>)
  inline size_t snd_hash_fct(const Key & key) noexcept
  {
    return Aleph_Hash<Key>{}(key, Aleph_Snd_Hash_Seed);
  }
 
  template <typename Key>
    requires std::is_pointer_v<Key>
  inline size_t snd_hash_fct(const Key & key) noexcept
  {
    return SuperFastHash(&key, sizeof(key), Aleph_Snd_Hash_Seed);
  }
 
  inline size_t snd_hash_fct(const char * key) noexcept
  {
    return wyhash_hash(key, Aleph_Snd_Hash_Seed);
  }
 
  inline size_t snd_hash_fct(const std::string & key) noexcept
  {
    return wyhash_hash(key, Aleph_Snd_Hash_Seed);
  }
 
  template <typename Key>
  inline size_t snd_hash_ptr_fct(const Key & key) noexcept
  {
    return snd_hash_fct(key);
  }
 
  template<typename Key, typename Data, typename Fct>
  inline size_t map_hash_fct(Fct fct, const std::pair<Key, Data> & p) noexcept
  {
    return fct(p.first);
  }
 
  template <typename K1, typename K2>
    requires requires(const K1 & k1, const K2 & k2)
    {
      dft_hash_fct(k1);
      dft_hash_fct(k2);
    }
  inline size_t pair_dft_hash_fct(const std::pair<K1, K2> & p) noexcept
  {
    size_t seed = dft_hash_fct(p.first);
    hash_combine(seed, dft_hash_fct(p.second));
    return seed;
  }
 
  template <typename K1, typename K2>
    requires requires(const K1 & k1, const K2 & k2)
    {
      dft_hash_fct(k1);
      snd_hash_fct(k2);
    }
  inline size_t pair_snd_hash_fct(const std::pair<K1, K2> & p) noexcept
  {
    size_t seed = dft_hash_fct(p.first);
    hash_combine(seed, snd_hash_fct(p.second));
    return seed;
  }
 
  template <typename K1, typename K2>
  inline size_t pair_dft_hash_ptr_fct(const std::pair<K1, K2> & p) noexcept
  {
    return pair_dft_hash_fct(p);
  }
 
  template <typename K1, typename K2>
  inline size_t pair_snd_hash_ptr_fct(const std::pair<K1, K2> & p) noexcept
  {
    return pair_snd_hash_fct(p);
  }
 
} // end namespace Aleph
 
 
# endif // HASH_FCT_H