hash.h

Go to the documentation of this file.

#ifndef HASH_H
#define HASH_H
 
#include "config.h"
#include <cstring>
#include <string>
 
namespace original {
 
    template <typename TYPE>
    class hash;
 
    template <typename DERIVED>
    class hashable;
 
    template <typename DERIVED>
    concept isHashable =
    requires(const DERIVED& t, const DERIVED& other) {
        { t.toHash() } -> std::same_as<u_integer>;
        { t.equals(other) } -> std::same_as<bool>;
    };
 
    template <typename TYPE>
    class hash {
        template <typename T>
        static inline void hashCombine(u_integer& seed, const T& value) noexcept;
 
        template <typename T>
        static u_integer hashFuncImpl(const T& t) noexcept;
 
    public:
        template <typename>
        friend class hashable;
 
        static constexpr u_integer FNV_OFFSET_BASIS = 0x811C9DC5;
 
        static constexpr u_integer FNV_32_PRIME = 0x01000193;
 
        static u_integer fnv1a(const byte* data, u_integer size) noexcept;
 
        template <typename T, typename... Rest>
        static void hashCombine(u_integer& seed, const T& value, const Rest&... rest) noexcept;
 
        template <typename T>
        static u_integer hashFunc(const T& t) noexcept;
 
        template <isHashable T>
        static u_integer hashFunc(const T& t) noexcept;
 
        template<std::integral T>
        static u_integer hashFunc(const T& t) noexcept;
 
        template <typename T>
        static u_integer hashFunc(T* const& t) noexcept;
 
        static u_integer hashFunc(const std::nullptr_t& null) noexcept;
 
        static u_integer hashFunc(const char& t) noexcept;
 
        static u_integer hashFunc(const char* str) noexcept;
 
        static u_integer hashFunc(const std::string& str) noexcept;
 
        u_integer operator()(const TYPE& t) const noexcept;
    };
 
    template <typename DERIVED>
    class hashable {
    public:
        [[nodiscard]] virtual u_integer toHash() const noexcept;
 
        virtual bool equals(const DERIVED& other) const noexcept;
 
        virtual ~hashable() = 0;
    };
}
 
 
template <typename T>
requires original::isHashable<T>
struct std::hash<T> { // NOLINT
    std::size_t operator()(const T& t) const noexcept;
};
 
template<typename TYPE>
template<typename T>
void original::hash<TYPE>::hashCombine(u_integer &seed, const T& value) noexcept {
    seed ^= hash<T>::hashFunc(value) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
}
 
template<typename TYPE>
template<typename T>
original::u_integer original::hash<TYPE>::hashFuncImpl(const T &t) noexcept {
    if constexpr (std::is_trivially_copyable_v<T>) {
        byte buffer[sizeof(T)];
        std::memcpy(buffer, &t, sizeof(T));
        return fnv1a(buffer, sizeof(T));
    } else {
        return static_cast<u_integer>(reinterpret_cast<uintptr_t>(&t));
    }
}
 
template<typename TYPE>
original::u_integer original::hash<TYPE>::fnv1a(const byte* data, const u_integer size) noexcept {
    u_integer hash = FNV_OFFSET_BASIS;
    for (u_integer i = 0; i < size; ++i) {
        hash ^= data[i];
        hash *= FNV_32_PRIME;
    }
    return hash;
}
 
template<typename TYPE>
template<typename T, typename... Rest>
void original::hash<TYPE>::hashCombine(u_integer &seed, const T& value, const Rest&... rest) noexcept {
    hashCombine(seed, value);
    (hashCombine(seed, rest), ...);
}
 
template<typename TYPE>
template<typename T>
original::u_integer original::hash<TYPE>::hashFunc(const T &t) noexcept {
    return hashFuncImpl(t);
}
 
template<typename TYPE>
template<original::isHashable T>
original::u_integer original::hash<TYPE>::hashFunc(const T &t) noexcept {
    return t.toHash();
}
 
template<typename TYPE>
original::u_integer original::hash<TYPE>::hashFunc(const std::nullptr_t&) noexcept {
    return 0;
}
 
template<typename TYPE>
template<std::integral T>
original::u_integer original::hash<TYPE>::hashFunc(const T &t) noexcept {
    return static_cast<u_integer>(t);
}
 
template<typename TYPE>
template<typename T>
original::u_integer original::hash<TYPE>::hashFunc(T* const& t) noexcept {
    return static_cast<u_integer>(reinterpret_cast<uintptr_t>(t));
}
 
template<typename TYPE>
original::u_integer original::hash<TYPE>::hashFunc(const char &t) noexcept {
    return static_cast<u_integer>(t);
}
 
template<typename TYPE>
original::u_integer original::hash<TYPE>::hashFunc(const char* str) noexcept {
    if (str == nullptr) return 0;
    return fnv1a(reinterpret_cast<const byte*>(str), std::strlen(str));
}
 
template<typename TYPE>
original::u_integer original::hash<TYPE>::hashFunc(const std::string& str) noexcept {
    return fnv1a(reinterpret_cast<const byte*>(str.data()), str.size());
}
 
template<typename TYPE>
original::u_integer original::hash<TYPE>::operator()(const TYPE &t) const noexcept {
    return hashFunc(t);
}
 
template <typename DERIVED>
original::u_integer original::hashable<DERIVED>::toHash() const noexcept {
    return hash<DERIVED>::hashFuncImpl(static_cast<const DERIVED&>(*this));
}
 
template<typename DERIVED>
bool original::hashable<DERIVED>::equals(const DERIVED &other) const noexcept {
    return static_cast<const DERIVED&>(*this) == other;
}
 
template <typename DERIVED>
original::hashable<DERIVED>::~hashable() = default;
 
template <typename T>
requires original::isHashable<T>
std::size_t std::hash<T>::operator()(const T &t) const noexcept {
    return static_cast<std::size_t>(t.toHash());
}
 
#endif //HASH_H