Hash.hpp

Go to the documentation of this file.

//
//  CeresEngine - A game development framework
//
//  Created by Rogiel Sulzbach.
//  Copyright (c) 2018-2022 Rogiel Sulzbach. All rights reserved.
//
 
#pragma once
 
#include "CeresEngine/DataTypes.hpp"
 
#include "CeresEngine/Foundation/String.hpp"
 
#include <functional>
#include <utility>
#include <string>
 
namespace CeresEngine {
 
    template<typename T> constexpr size_t hash(const T& v) { return std::hash<T>{}(v); }
 
    template<typename T> constexpr void combine(std::size_t& seed, const T& v) {
        seed ^= hash(v) + 0x9e3779b9 + (seed << 6) + (seed >> 2); // NOLINT
    }
 
    template<typename... Ts> constexpr size_t hash(const Ts&... values) {
        size_t hash = 0;
        ((void)combine<decltype(values)>(hash, values), ...);
        return hash;
    }
 
    template<typename T> struct Hasher {
        using ReflectedType = std::decay_t<T>;
 
        T& object;
 
        size_t hash;
 
        explicit constexpr Hasher(T& object, const size_t hash = 0) noexcept : object(object), hash(hash) {}
 
        template<auto P> constexpr void data(StringView) noexcept { combine(hash, object.*P); }
 
        template<auto P> constexpr void func(StringView) noexcept {}
    };
 
    // ---------------------------------------------------------------------------------------------
 
    // FNV1a c++11 constexpr compile time hash functions, 32 and 64 bit
    // str should be implicitly convertible BasicStringView<T>, value should
    // be left out e.g staticHash32("example")
    // code license: public domain or equivalent
    // post: https://notes.underscorediscovery.com/constexpr-fnv1a/
 
    template<typename T> inline constexpr UInt32 staticHash32(BasicStringView<T> string, const UInt32 value = 0x811c9dc5) noexcept {
        constexpr UInt32 prime = 0x1000193;
        return (string.size() == 0) ? value : staticHash32(BasicStringView<T>(string.data() + 1, string.size() - 1), (value ^ UInt32(string[0])) * prime);
    }
 
    template<typename T> inline constexpr UInt64 staticHash64(BasicStringView<T> string, const UInt64 value = 0xcbf29ce484222325) noexcept {
        constexpr UInt64 prime = 0x100000001b3;
        return (string.size() == 0) ? value : staticHash64(BasicStringView<T>(string.data() + 1, string.size() - 1), (value ^ UInt64(string[0])) * prime);
    }
 
} // namespace CeresEngine
 
#define CE_REFLECT_HASH(T)                                                   \
    template<> struct std::hash<T> {                                         \
        inline constexpr size_t operator()(const T& object) const noexcept { \
            ::CeresEngine::Hasher hasher{object};                            \
            T::reflect(hasher);                                              \
            return hasher.hash;                                              \
        }                                                                    \
    }
 
template<typename T, size_t N> struct std::hash<T[N]> {
    inline constexpr size_t operator()(const T values[N]) const noexcept {
        size_t seed = 0;
        for(size_t i = 0; i < N; i++) {
            CeresEngine::combine(seed, values[i]);
        }
        return seed;
    }
};
 
template<typename T, typename CharTraits, typename RawAllocator>
struct std::hash<CeresEngine::BasicString<T, CharTraits, RawAllocator>>
        : public std::hash<std::basic_string<T, CharTraits, CeresEngine::StdAllocator<T, RawAllocator>>> {};
 
template<typename T, typename CharTraits>
struct std::hash<CeresEngine::BasicStringView<T, CharTraits>> : public std::hash<std::basic_string_view<T, CharTraits>> {};