eviction_lru.h

#ifndef CACHEMERE_EVICTION_LRU
#define CACHEMERE_EVICTION_LRU
 
#include <cassert>
#include <functional>
#include <list>
#include <map>
 
#include <absl/container/flat_hash_map.h>
 
#include "cachemere/item.h"
 
namespace cachemere::policy {
 
template<typename Key, typename KeyHash, typename Value> class EvictionLRU
{
private:
    using KeyRef    = std::reference_wrapper<const Key>;
    using KeyRefIt  = typename std::list<KeyRef>::iterator;
    using KeyRefMap = absl::flat_hash_map<KeyRef, KeyRefIt, KeyHash, std::equal_to<Key>>;
 
public:
    using CacheItem = cachemere::Item<Value>;
 
    class VictimIterator
    {
    public:
        using KeyRefReverseIt = typename std::list<KeyRef>::const_reverse_iterator;
 
        VictimIterator(const KeyRefReverseIt& p_Iterator);
 
        const Key&      operator*() const;
        VictimIterator& operator++();
        VictimIterator  operator++(int);
        bool            operator==(const VictimIterator& other) const;
        bool            operator!=(const VictimIterator& other) const;
 
    private:
        KeyRefReverseIt m_iterator;
    };
 
    void clear();
 
    void on_insert(const Key& key, const CacheItem& item);
 
    void on_update(const Key& key, const CacheItem& old_item, const CacheItem& new_item);
 
    void on_cache_hit(const Key& key, const CacheItem& item);
 
    void on_evict(const Key& key, const CacheItem& item);
 
    [[nodiscard]] VictimIterator victim_begin() const;
 
    [[nodiscard]] VictimIterator victim_end() const;
 
private:
    std::list<KeyRef> m_keys;
    KeyRefMap         m_nodes;
};
 
}  // namespace cachemere::policy
 
#include "eviction_lru.hpp"
 
#endif