HashFunctions.h

#pragma once
 
#include "FoundationBase.h"
 
#include <string_view>
#include <type_traits>
 
namespace Cogs
{
  [[nodiscard]]
  COGSFOUNDATION_API size_t murmur2(const void* bytes, const size_t length) noexcept;
 
  namespace Details
  {
    constexpr size_t FNV_offset_basis = (sizeof(size_t) == 8) ? static_cast<size_t>(14695981039346656037ULL) : 2166136261U;
    constexpr size_t FNV_prime = (sizeof(size_t) == 8) ? static_cast<size_t>(1099511628211ULL) : 16777619U;
  }
 
  [[nodiscard]]
  constexpr size_t fnv1a(uint8_t data, size_t hashValue) noexcept {
    return (hashValue ^ data) * Details::FNV_prime;
  }
 
  [[nodiscard]]
  constexpr size_t fnv1a(const void* bytes, size_t length, size_t hashValue = Details::FNV_offset_basis) noexcept {
    for (const uint8_t* read = static_cast<const uint8_t*>(bytes); length--; ++read) {
      hashValue = fnv1a(*read, hashValue);
    }
    return hashValue;
  }
 
  [[nodiscard]]
  constexpr size_t hash() noexcept {
    return Details::FNV_offset_basis;
  }
 
  template<typename T, typename std::enable_if<std::is_integral<T>::value || std::is_enum<T>::value || std::is_floating_point<T>::value, int>::type* = nullptr>
  [[nodiscard]]
  constexpr size_t hash(T data, size_t hashValue = hash()) noexcept {
    return fnv1a(&data, sizeof(data), hashValue);
  }
 
  [[nodiscard]]
  constexpr size_t hash(const char* str, size_t hashValue = hash()) noexcept {
    for (; *str; ++str) {
      hashValue = fnv1a(static_cast<uint8_t>(*str), hashValue);
    }
    return hashValue;
  }
 
  [[nodiscard]]
  COGSFOUNDATION_API size_t hashLowercase(std::string_view str, size_t hashValue = Cogs::hash()) noexcept;
 
 
  [[nodiscard]]
  constexpr size_t hash(const void* mem, size_t size, size_t hashValue = hash()) noexcept {
    return fnv1a(mem, size, hashValue);
  }
 
  [[nodiscard]]
  constexpr size_t hash(std::string_view str, size_t hashValue = hash()) noexcept {
    for (const char read : str) {
      hashValue = fnv1a(read, hashValue);
    }
    return hashValue;
  }
}