hashed_string.hpp

#ifndef ENTT_CORE_HASHED_STRING_HPP
#define ENTT_CORE_HASHED_STRING_HPP


#include <cstddef>
#include <cstdint>


namespace entt {


class HashedString final {
    struct ConstCharWrapper final {
        // non-explicit constructor on purpose
        constexpr ConstCharWrapper(const char *str) noexcept: str{str} {}
        const char *str;
    };

    static constexpr std::uint64_t offset = 14695981039346656037ull;
    static constexpr std::uint64_t prime = 1099511628211ull;

    // Fowler–Noll–Vo hash function v. 1a - the good
    static constexpr std::uint64_t helper(std::uint64_t partial, const char *str) noexcept {
        return str[0] == 0 ? partial : helper((partial^str[0])*prime, str+1);
    }

public:
    using hash_type = std::uint64_t;

    template <std::size_t N>
    constexpr HashedString(const char (&str)[N]) noexcept
        : hash{helper(offset, str)}, str{str}
    {}

    explicit constexpr HashedString(ConstCharWrapper wrapper) noexcept
        : hash{helper(offset, wrapper.str)}, str{wrapper.str}
    {}

    constexpr operator const char *() const noexcept { return str; }

    constexpr operator hash_type() const noexcept { return hash; }

    constexpr bool operator==(const HashedString &other) const noexcept {
        return hash == other.hash;
    }

private:
    const hash_type hash;
    const char *str;
};


constexpr bool operator!=(const HashedString &lhs, const HashedString &rhs) noexcept {
    return !(lhs == rhs);
}


}


#endif // ENTT_CORE_HASHED_STRING_HPP