Class Cache

libs/base/cache.hpp:15–102

// Simple cache that stores list of values.
template <typename KeyT, typename ValueT>
class Cache
{
  DISALLOW_COPY(Cache);

public:
  Cache() = default;
  Cache(Cache && r) = default;

  /// @param[in] logCacheSize is pow of two for number of elements in cache.
  explicit Cache(uint32_t logCacheSize) { Init(logCacheSize); }

  /// @param[in] logCacheSize is pow of two for number of elements in cache.
  void Init(uint32_t logCacheSize)
  {
    ASSERT(logCacheSize > 0 && logCacheSize < 32, (logCacheSize));
    static_assert((std::is_same<KeyT, uint32_t>::value || std::is_same<KeyT, uint64_t>::value), "");

    m_cache.reset(new Data[1 << logCacheSize]);
    m_hashMask = (1 << logCacheSize) - 1;

    Reset();
  }

  uint32_t GetCacheSize() const { return m_hashMask + 1; }

  // Find value by @key. If @key is found, returns reference to its value.
  // If @key is not found, some other key is removed and it's value is reused without
  // re-initialization. It's up to caller to re-initialize the new value if @found == false.
  // TODO: Return pair<ValueT *, bool> instead?
  ValueT & Find(KeyT const & key, bool & found)
  {
    Data & data = m_cache[Index(key)];
    if (data.m_Key == key)
    {
      found = true;
    }
    else
    {
      found = false;
      data.m_Key = key;
    }
    return data.m_Value;
  }

  template <typename F>
  void ForEachValue(F && f)
  {
    for (uint32_t i = 0; i <= m_hashMask; ++i)
      f(m_cache[i].m_Value);
  }

  void Reset()
  {
    // Initialize m_Cache such, that Index(m_Cache[i].m_Key) != i.
    for (uint32_t i = 0; i <= m_hashMask; ++i)
    {
      KeyT & key = m_cache[i].m_Key;
      for (key = 0; Index(key) == i; ++key)