hashing_policy.h

#pragma once
#include "gaia/config/config.h"
 
#include <cstdint>
#include <type_traits>
 
namespace gaia {
  namespace core {
 
    namespace detail {
      template <typename, typename = void>
      struct is_direct_hash_key: std::false_type {};
      template <typename T>
      struct is_direct_hash_key<T, std::void_t<decltype(T::IsDirectHashKey)>>: std::true_type {};
 
      //-----------------------------------------------------------------------------------
 
      constexpr void hash_combine2_out(uint32_t& lhs, uint32_t rhs) {
        lhs ^= rhs + 0x9e3779b9 + (lhs << 6) + (lhs >> 2);
      }
      constexpr void hash_combine2_out(uint64_t& lhs, uint64_t rhs) {
        lhs ^= rhs + 0x9e3779B97f4a7c15ULL + (lhs << 6) + (lhs >> 2);
      }
 
      template <typename T>
      GAIA_NODISCARD constexpr T hash_combine2(T lhs, T rhs) {
        hash_combine2_out(lhs, rhs);
        return lhs;
      }
    } // namespace detail
 
    template <typename T>
    inline constexpr bool is_direct_hash_key_v = detail::is_direct_hash_key<T>::value;
 
    template <typename T>
    struct direct_hash_key {
      using Type = T;
 
      static_assert(std::is_integral_v<T>);
      static constexpr bool IsDirectHashKey = true;
 
      T hash;
      bool operator==(direct_hash_key other) const {
        return hash == other.hash;
      }
      bool operator!=(direct_hash_key other) const {
        return hash != other.hash;
      }
    };
 
    template <typename... T>
    constexpr auto combine_or([[maybe_unused]] T... t) {
      return (... | t);
    }
 
    template <typename T, typename... Rest>
    constexpr T hash_combine(T first, T next, Rest... rest) {
      auto h = detail::hash_combine2(first, next);
      (detail::hash_combine2_out(h, rest), ...);
      return h;
    }
 
    constexpr uint64_t calculate_hash64(uint64_t value) {
      value ^= value >> 33U;
      value *= 0xff51afd7ed558ccdULL;
      value ^= value >> 33U;
 
      value *= 0xc4ceb9fe1a85ec53ULL;
      value ^= value >> 33U;
      return value;
    }
 
#if GAIA_ECS_HASH == GAIA_ECS_HASH_FNV1A
 
    namespace detail {
      namespace fnv1a {
        constexpr uint64_t val_64_const = 0xcbf29ce484222325;
        constexpr uint64_t prime_64_const = 0x100000001b3;
      } // namespace fnv1a
    } // namespace detail
 
    constexpr uint64_t calculate_hash64(const char* const str) noexcept {
      uint64_t hash = detail::fnv1a::val_64_const;
 
      uint64_t i = 0;
      while (str[i] != '\0') {
        hash = (hash ^ uint64_t(uint8_t(str[i]))) * detail::fnv1a::prime_64_const;
        ++i;
      }
 
      return hash;
    }
 
    constexpr uint64_t calculate_hash64(const char* const str, const uint64_t length) noexcept {
      uint64_t hash = detail::fnv1a::val_64_const;
 
      for (uint64_t i = 0; i < length; ++i)
        hash = (hash ^ uint64_t(uint8_t(str[i]))) * detail::fnv1a::prime_64_const;
 
      return hash;
    }
 
#elif GAIA_ECS_HASH == GAIA_ECS_HASH_MURMUR2A
 
    // Thank you https://gist.github.com/oteguro/10538695
 
    GAIA_MSVC_WARNING_PUSH()
    GAIA_MSVC_WARNING_DISABLE(4592)
 
    namespace detail {
      namespace murmur2a {
        constexpr uint64_t seed_64_const = 0xe17a1465ULL;
        constexpr uint64_t m = 0xc6a4a7935bd1e995ULL;
        constexpr uint64_t r = 47;
 
        constexpr uint64_t Load8(const char* data) {
          return (uint64_t(uint8_t(data[7])) << 56) | (uint64_t(uint8_t(data[6])) << 48) |
                 (uint64_t(uint8_t(data[5])) << 40) | (uint64_t(uint8_t(data[4])) << 32) |
                 (uint64_t(uint8_t(data[3])) << 24) | (uint64_t(uint8_t(data[2])) << 16) |
                 (uint64_t(uint8_t(data[1])) << 8) | (uint64_t(uint8_t(data[0])) << 0);
        }
 
        constexpr uint64_t StaticHashValueLast64(uint64_t h) {
          return (((h * m) ^ ((h * m) >> r)) * m) ^ ((((h * m) ^ ((h * m) >> r)) * m) >> r);
        }
 
        constexpr uint64_t StaticHashValueLast64_(uint64_t h) {
          return (((h) ^ ((h) >> r)) * m) ^ ((((h) ^ ((h) >> r)) * m) >> r);
        }
 
        constexpr uint64_t StaticHashValue64Tail1(uint64_t h, const char* data) {
          return StaticHashValueLast64((h ^ uint64_t(uint8_t(data[0]))));
        }
 
        constexpr uint64_t StaticHashValue64Tail2(uint64_t h, const char* data) {
          return StaticHashValue64Tail1((h ^ uint64_t(uint8_t(data[1])) << 8), data);
        }
 
        constexpr uint64_t StaticHashValue64Tail3(uint64_t h, const char* data) {
          return StaticHashValue64Tail2((h ^ uint64_t(uint8_t(data[2])) << 16), data);
        }
 
        constexpr uint64_t StaticHashValue64Tail4(uint64_t h, const char* data) {
          return StaticHashValue64Tail3((h ^ uint64_t(uint8_t(data[3])) << 24), data);
        }
 
        constexpr uint64_t StaticHashValue64Tail5(uint64_t h, const char* data) {
          return StaticHashValue64Tail4((h ^ uint64_t(uint8_t(data[4])) << 32), data);
        }
 
        constexpr uint64_t StaticHashValue64Tail6(uint64_t h, const char* data) {
          return StaticHashValue64Tail5((h ^ uint64_t(uint8_t(data[5])) << 40), data);
        }
 
        constexpr uint64_t StaticHashValue64Tail7(uint64_t h, const char* data) {
          return StaticHashValue64Tail6((h ^ uint64_t(uint8_t(data[6])) << 48), data);
        }
 
        constexpr uint64_t StaticHashValueRest64(uint64_t h, uint64_t len, const char* data) {
          return ((len & 7) == 7)   ? StaticHashValue64Tail7(h, data)
                 : ((len & 7) == 6) ? StaticHashValue64Tail6(h, data)
                 : ((len & 7) == 5) ? StaticHashValue64Tail5(h, data)
                 : ((len & 7) == 4) ? StaticHashValue64Tail4(h, data)
                 : ((len & 7) == 3) ? StaticHashValue64Tail3(h, data)
                 : ((len & 7) == 2) ? StaticHashValue64Tail2(h, data)
                 : ((len & 7) == 1) ? StaticHashValue64Tail1(h, data)
                                    : StaticHashValueLast64_(h);
        }
 
        constexpr uint64_t StaticHashValueLoop64(uint64_t i, uint64_t h, uint64_t len, const char* data) {
          return (
              i == 0 ? StaticHashValueRest64(h, len, data)
                     : StaticHashValueLoop64(
                           i - 1, (h ^ (((Load8(data) * m) ^ ((Load8(data) * m) >> r)) * m)) * m, len, data + 8));
        }
 
        constexpr uint64_t hash_murmur2a_64_ct(const char* key, uint64_t len, uint64_t seed) {
          return StaticHashValueLoop64(len / 8, seed ^ (len * m), (len), key);
        }
      } // namespace murmur2a
    } // namespace detail
 
    constexpr uint64_t calculate_hash64(const char* str) {
      uint64_t length = 0;
      while (str[length] != '\0')
        ++length;
 
      return detail::murmur2a::hash_murmur2a_64_ct(str, length, detail::murmur2a::seed_64_const);
    }
 
    constexpr uint64_t calculate_hash64(const char* str, uint64_t length) {
      return detail::murmur2a::hash_murmur2a_64_ct(str, length, detail::murmur2a::seed_64_const);
    }
 
    GAIA_MSVC_WARNING_POP()
 
#else
  #error "Unknown hashing type defined"
#endif
 
  } // namespace core
} // namespace gaia