hash.string.h

Go to the documentation of this file.

#pragma once
 
#include "base/ints.h"
 
#include <string_view>
#include <string>
#include <unordered_map>
 
// 1 = include text in hash, 0=don't
// todo(Gustav): move to a config instead
#define USE_HASH_TEXT 1
 
namespace eu
{
 
constexpr u64 hash64(const std::string_view str, u64 hash = 0xcbf29ce484222325)
    { return str.empty() ? hash : hash64(str.substr(1), (hash ^ str[0]) * 0x100000001b3); }
 
struct Hsh
{
    u64 hash;
 
    #if USE_HASH_TEXT == 1
    std::string_view text;
    #endif
 
    constexpr Hsh(const std::string_view s)
        : hash( hash64(s) )
        #if USE_HASH_TEXT == 1
        , text(s)
        #endif
          { }
};
 
struct HshO
{
    u64 hash;
 
#if USE_HASH_TEXT == 1
    std::string text;
#endif
 
    constexpr HshO(const std::string& s)
        : hash(hash64(s))
#if USE_HASH_TEXT == 1
        , text(s)
#endif
    { }
 
    constexpr HshO(const std::string_view& s)
        : hash(hash64(s))
#if USE_HASH_TEXT == 1
        , text(s)
#endif
    { }
 
    constexpr HshO(const Hsh& o)
        : hash(o.hash)
#if USE_HASH_TEXT == 1
        , text(o.text)
#endif
    { }
};
 
#define OP(op) \
    constexpr bool operator op(const Hsh& lhs, const Hsh& rhs)\
        { return lhs.hash op rhs.hash; }\
    constexpr bool operator op(const HshO& lhs, const Hsh& rhs)\
        { return lhs.hash op rhs.hash; }\
    constexpr bool operator op(const Hsh& lhs, const HshO& rhs)\
        { return lhs.hash op rhs.hash; }\
    constexpr bool operator op(const HshO& lhs, const HshO& rhs)\
        { return lhs.hash op rhs.hash; }
    OP(==) OP(!=) OP(<) OP(>) OP(<=) OP(>=)
#undef OP
 
 
std::string string_from(const Hsh h);
std::string string_from(const HshO& h);
 
 
ADD_CATCH_FORMATTER_DEF(Hsh)
ADD_CATCH_FORMATTER_DEF(HshO)
}
 
ADD_DEFAULT_FORMATTER(eu::Hsh, std::string, eu::string_from);
ADD_DEFAULT_FORMATTER(eu::HshO, std::string, eu::string_from);
 
 
namespace std
{
 
template <> struct hash<eu::Hsh>
{
    std::size_t operator()(const eu::Hsh& x) const
        { return x.hash; }
};
 
template <> struct hash<eu::HshO>
{
    std::size_t operator()(const eu::HshO& x) const
        { return x.hash; }
};
 
}