hash.hpp

浏览该文件的文档.

#ifndef MSTL_CORE_FUNCTIONAL_HASH_HPP__
#define MSTL_CORE_FUNCTIONAL_HASH_HPP__

 
#include "MSTL/core/typeinfo/type_traits.hpp"
MSTL_BEGIN_NAMESPACE__


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

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


MSTL_BEGIN_CONSTANTS__

MSTL_INLINE17 constexpr size_t FNV_OFFSET_BASIS =
#ifdef MSTL_DATA_BUS_WIDTH_64__
    14695981039346656037ULL;
#else
    2166136261U
#endif

MSTL_INLINE17 constexpr size_t FNV_PRIME
#ifdef MSTL_DATA_BUS_WIDTH_64__
     = 1099511628211ULL;
#else
     = 16777619U;
#endif
 
MSTL_END_CONSTANTS__

MSTL_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;
}
 

MSTL_BEGIN_INNER__

template <typename T>
MSTL_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>
MSTL_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;
}
 
MSTL_END_INNER__
 // FNVHash

 
template <>
struct hash<bool> {
    MSTL_NODISCARD constexpr size_t operator ()(const bool x) const noexcept {
        return x ? 0x9e3779b9 : 0x7f4a7c15;
    }
};
 
#define __MSTL_BUILD_INTEGER_HASH_STRUCT(OPT) \
template <> struct hash<OPT> { \
    MSTL_NODISCARD constexpr size_t operator ()(const OPT& x) const noexcept { \
        return x == 0.0f ? 0 : _INNER FNV_hash_integer(x); \
    } \
};
 
MSTL_MACRO_RANGE_CHARS(__MSTL_BUILD_INTEGER_HASH_STRUCT)
MSTL_MACRO_RANGE_INT(__MSTL_BUILD_INTEGER_HASH_STRUCT)
#undef FLOAT_HASH_STRUCT__
 
MSTL_BEGIN_INNER__
template <typename T>
union __float_converter { T f; uint64_t i; };
MSTL_END_INNER__
 
#define __MSTL_BUILD_FLOAT_HASH_STRUCT(OPT) \
template <> \
struct hash<OPT> { \
    MSTL_NODISCARD MSTL_CONSTEXPR14 size_t operator ()(const OPT x) const noexcept { \
        if (x == 0.0f) return 0; \
        _INNER __float_converter<OPT> converter{}; \
        converter.f = x; \
        return _INNER FNV_hash_integer(converter.i); \
    } \
};
 
MSTL_MACRO_RANGE_FLOAT(__MSTL_BUILD_FLOAT_HASH_STRUCT)
#undef __MSTL_BUILD_FLOAT_HASH_STRUCT



MSTL_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;
}
 // DJB2Hash

 
#ifdef MSTL_DATA_BUS_WIDTH_64__

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 MurmurHash_x64(const void* key, size_t len, uint32_t seed) noexcept;
#endif

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


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

template <typename Key>
struct is_nothrow_hashable<Key, void_t<decltype(_MSTL hash<Key>{}(_MSTL declval<const Key&>()))>>
    : bool_constant<noexcept(_MSTL hash<Key>{}(_MSTL declval<const Key&>()))> {};
 
#ifdef MSTL_STANDARD_14__
template <typename Key>
MSTL_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(_MSTL declval<Func>()(_MSTL declval<Arg>())), size_t>::value
>> : true_type {};
 
#ifdef MSTL_STANDARD_14__
template <typename Func, typename Arg>
constexpr bool is_hash_v = is_hash<Func, Arg>::value;
#endif
 // HashTraits
 
MSTL_END_NAMESPACE__
#endif // MSTL_CORE_FUNCTIONAL_HASH_HPP__