hash.hpp

浏览该文件的文档.

#ifndef NEFORCE_CORE_FUNCTIONAL_HASH_HPP__
#define NEFORCE_CORE_FUNCTIONAL_HASH_HPP__

 
#include "NeForce/core/typeinfo/type_traits.hpp"
NEFORCE_BEGIN_NAMESPACE__


template <typename Key, typename Dummy = void>
struct hash;

template <typename T>
struct hash<T*> {
    NEFORCE_NODISCARD NEFORCE_CONSTEXPR20 size_t operator()(const T* ptr) const noexcept {
        return static_cast<size_t>(reinterpret_cast<uintptr_t>(ptr));
    }
};
 // HashPrimary
 
NEFORCE_BEGIN_CONSTANTS__


NEFORCE_INLINE17 constexpr size_t FNV_OFFSET_BASIS =
#ifdef NEFORCE_ARCH_BITS_64
        14695981039346656037ULL;
#else
        2166136261U;
#endif

NEFORCE_INLINE17 constexpr size_t FNV_PRIME
#ifdef NEFORCE_ARCH_BITS_64
        = 1099511628211ULL;
#else
        = 16777619U;
#endif
 // HashPrimary
 
NEFORCE_END_CONSTANTS__


NEFORCE_CONSTEXPR14 size_t FNV_hash(const byte_t* first, const size_t count) noexcept {
    size_t result = constants::FNV_OFFSET_BASIS;
    for (size_t i = 0; i < count; i++) {
        result ^= static_cast<size_t>(first[i]);
        result *= constants::FNV_PRIME;
    }
    return result;
}

template <typename T>
NEFORCE_CONSTEXPR14 size_t FNV_hash_integer(const T value) noexcept {
    static_assert(is_integral<T>::value, "T must be integral");
 
    size_t result = constants::FNV_OFFSET_BASIS;
    for (size_t i = 0; i < sizeof(T); ++i) {
        const byte_t byte_val = static_cast<byte_t>((value >> (i * 8)) & 0xFF);
        result ^= static_cast<size_t>(byte_val);
        result *= constants::FNV_PRIME;
    }
    return result;
}

template <typename CharT>
NEFORCE_CONSTEXPR14 size_t FNV_hash_string(const CharT* str, const size_t len) noexcept {
    static_assert(is_character<CharT>::value, "CharT must be character types");
 
    size_t result = constants::FNV_OFFSET_BASIS;
    for (size_t i = 0; i < len; ++i) {
        result ^= static_cast<size_t>(static_cast<byte_t>(str[i]));
        result *= constants::FNV_PRIME;
    }
    return result;
}
 // HashPrimary

 
template <>
struct hash<bool> {
    NEFORCE_NODISCARD constexpr size_t operator()(const bool x) const noexcept { return x ? 0x9e3779b9 : 0x7f4a7c15; }
};
 
#define __NEFORCE_BUILD_INTEGER_HASH_STRUCT(OPT)                                    \
    template <>                                                                     \
    struct hash<OPT> {                                                              \
        NEFORCE_NODISCARD constexpr size_t operator()(const OPT x) const noexcept { \
            return x == 0.0f ? 0 : FNV_hash_integer(x);                             \
        }                                                                           \
    };
 
NEFORCE_MACRO_RANGE_CHARS(__NEFORCE_BUILD_INTEGER_HASH_STRUCT)
NEFORCE_MACRO_RANGE_INT(__NEFORCE_BUILD_INTEGER_HASH_STRUCT)
#undef __NEFORCE_BUILD_INTEGER_HASH_STRUCT
 
#define __NEFORCE_BUILD_FLOAT_HASH_STRUCT(OPT)                                                \
    template <>                                                                               \
    struct hash<OPT> {                                                                        \
    private:                                                                                  \
        union __float_converter {                                                             \
            OPT f;                                                                            \
            uint64_t i;                                                                       \
        };                                                                                    \
                                                                                              \
    public:                                                                                   \
        NEFORCE_NODISCARD NEFORCE_CONSTEXPR14 size_t operator()(const OPT x) const noexcept { \
            if (x == 0.0f)                                                                    \
                return 0;                                                                     \
            __float_converter converter{};                                                    \
            converter.f = x;                                                                  \
            return FNV_hash_integer(converter.i);                                             \
        }                                                                                     \
    };
 
NEFORCE_MACRO_RANGE_FLOAT(__NEFORCE_BUILD_FLOAT_HASH_STRUCT)
#undef __NEFORCE_BUILD_FLOAT_HASH_STRUCT



template <typename T>
struct hash<T, enable_if_t<is_enum_v<T>>> {
    NEFORCE_NODISCARD NEFORCE_CONSTEXPR14 size_t operator()(const T e) const {
        using UT = underlying_type_t<T>;
        return hash<UT>()(static_cast<UT>(e));
    }
};

NEFORCE_CONSTEXPR14 size_t DJB2_hash(const char* str, const size_t len) noexcept {
    size_t hash = 5381;
    for (size_t i = 0; i < len; ++i) {
        hash = (hash << 5) + hash + static_cast<byte_t>(str[i]);
    }
    return hash;
}
 
 
#if defined(NEFORCE_ARCH_BITS_64) || defined(NEXUSFORCE_ENABLE_DOXYGEN)

struct murmur_hash {
    size_t low = 0;  
    size_t high = 0; 
 
    murmur_hash() noexcept = default;
    ~murmur_hash() noexcept = default;

    murmur_hash(const size_t l, const size_t h) noexcept :
    low(l),
    high(h) {}
};

murmur_hash NEFORCE_API MurmurHash_x64(const void* key, size_t len, uint32_t seed) noexcept;
#endif

uint32_t NEFORCE_API MurmurHash_x32(const void* key, size_t len, uint32_t seed) noexcept;
 

template <typename Key, typename Dummy = void>
struct is_nothrow_hashable : false_type {};

template <typename Key>
struct is_nothrow_hashable<Key, void_t<decltype(_NEFORCE hash<Key>{}(_NEFORCE declval<const Key&>()))>>
: bool_constant<noexcept(_NEFORCE hash<Key>{}(_NEFORCE declval<const Key&>()))> {};
 
#ifdef NEFORCE_STANDARD_14
template <typename Key>
NEFORCE_INLINE17 constexpr bool is_nothrow_hashable_v = is_nothrow_hashable<Key>::value;
#endif
 

template <typename Func, typename Arg, typename Dummy = void>
struct is_hash : false_type {};

template <typename Func, typename Arg>
struct is_hash<Func, Arg,
               enable_if_t<is_convertible<decltype(_NEFORCE declval<Func>()(_NEFORCE declval<Arg>())), size_t>::value>>
: true_type {};
 
#ifdef NEFORCE_STANDARD_14
template <typename Func, typename Arg>
constexpr bool is_hash_v = is_hash<Func, Arg>::value;
#endif
 // HashPrimary
 
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_CORE_FUNCTIONAL_HASH_HPP__