cached_hash.hpp

Go to the documentation of this file.

#pragma once
 
/// @file userver/utils/cached_hash.hpp
/// @brief @copybrief utils::CachedHash
 
#include <functional>
#include <type_traits>
 
USERVER_NAMESPACE_BEGIN
 
namespace utils {
 
/// @ingroup userver_universal
///
/// @brief Holds the key and its hash for faster comparisons and hashing
template <class Key>
struct CachedHash final {
    std::size_t hash;
    Key key;
};
 
/// @brief Compares utils::CachedHash by hash first and then by keys
template <class T>
constexpr bool operator==(const CachedHash<T>& x, const CachedHash<T>& y) {
    return x.hash == y.hash && x.key == y.key;
}
 
/// @brief Compares utils::CachedHash by hash first and then by keys
template <class T>
constexpr bool operator!=(const CachedHash<T>& x, const CachedHash<T>& y) {
    return !(x.key == y.key);
}
 
/// @brief Compares utils::CachedHash only by keys
template <class Equal, class = std::enable_if_t<!std::is_final_v<Equal>>>
class CachedHashKeyEqual : private Equal {
public:
    explicit constexpr CachedHashKeyEqual(const Equal& eq)
        : Equal(eq)
    {}
 
    template <class T>
    constexpr bool operator()(const CachedHash<T>& x, const CachedHash<T>& y) const {
        return Equal::operator()(x.key, y.key);
    }
};
 
template <class Equal>
class CachedHashKeyEqual<Equal, std::false_type> {
public:
    explicit constexpr CachedHashKeyEqual(const Equal& eq)
        : equality_(eq)
    {}
 
    template <class T>
    constexpr bool operator()(const CachedHash<T>& x, const CachedHash<T>& y) const {
        return equality_(x.key, y.key);
    }
 
private:
    Equal equality_;
};
 
}  // namespace utils
 
USERVER_NAMESPACE_END
 
template <class T>
struct std::hash<USERVER_NAMESPACE::utils::CachedHash<T>> {
    constexpr std::size_t operator()(const USERVER_NAMESPACE::utils::CachedHash<T>& value) const noexcept {
        return value.hash;
    }
};