hashed_string.hpp

#ifndef ENTT_CORE_HASHED_STRING_HPP
#define ENTT_CORE_HASHED_STRING_HPP


#include <cstddef>
#include <cstdint>
#include "../config/config.h"


namespace entt {


class HashedString final {
    struct ConstCharWrapper final {
        // non-explicit constructor on purpose
        constexpr ConstCharWrapper(const char *str) ENTT_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) ENTT_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]) ENTT_NOEXCEPT
        : hash{helper(offset, str)}, str{str}
    {}

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

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

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

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

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


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


}


constexpr entt::HashedString operator"" ENTT_HS_SUFFIX(const char *str, std::size_t) ENTT_NOEXCEPT {
    return entt::HashedString{str};
}


#endif // ENTT_CORE_HASHED_STRING_HPP