cache.h

#ifndef CACHEMERE_CACHE_H
#define CACHEMERE_CACHE_H
 
#include <cstdint>
#include <functional>
#include <memory>
#include <mutex>
#include <optional>
#include <vector>
 
#include <absl/container/node_hash_map.h>
#include <absl/hash/hash.h>
 
#ifdef _WIN32
#    pragma warning(push)
#    pragma warning(disable : 4244)
#    pragma warning(disable : 4018)
#endif
 
#include <boost/accumulators/accumulators.hpp>
#include <boost/accumulators/statistics/rolling_mean.hpp>
#include <boost/accumulators/statistics/stats.hpp>
#include <boost/hana.hpp>
 
#ifdef _WIN32
#    pragma warning(pop)
#endif
 
#include "item.h"
#include "measurement.h"
#include "detail/transparent_eq.h"
#include "detail/traits.h"
 
namespace cachemere {
 
template<typename Key,
         typename Value,
         template<class, class, class>
         class InsertionPolicy,
         template<class, class, class>
         class EvictionPolicy,
         template<class, class, class>
         class ConstraintPolicy,
         typename MeasureValue = measurement::Size<Value>,
         typename MeasureKey   = measurement::Size<Key>,
         typename KeyHash      = absl::Hash<Key>,
         bool ThreadSafe       = true>
class Cache
{
public:
    using MyInsertionPolicy  = InsertionPolicy<Key, KeyHash, Value>;
    using MyEvictionPolicy   = EvictionPolicy<Key, KeyHash, Value>;
    using MyConstraintPolicy = ConstraintPolicy<Key, KeyHash, Value>;
    using CacheType          = Cache<Key, Value, InsertionPolicy, EvictionPolicy, ConstraintPolicy, MeasureValue, MeasureKey, KeyHash, ThreadSafe>;
    using LockGuard          = std::unique_lock<std::recursive_mutex>;
 
    template<typename... Args> Cache(Args... args);
 
    template<typename C, typename... Args> Cache(C& collection, std::tuple<Args...> args);
 
    template<typename KeyView> bool contains(const KeyView& key) const;
 
    template<typename KeyView> std::optional<Value> find(const KeyView& key) const;
 
    template<typename C> void collect_into(C& container) const;
 
    bool insert(Key key, Value value);
 
    bool remove(const Key& key);
 
    void clear();
 
    template<typename P> void retain(P predicate_fn);
 
    template<typename F> void for_each(F unary_function);
 
    void swap(CacheType& other) noexcept;
 
    [[nodiscard]] size_t number_of_items() const;
 
    template<typename... Args> void update_constraint(Args... args);
 
    [[nodiscard]] MyInsertionPolicy& insertion_policy();
 
    [[nodiscard]] const MyInsertionPolicy& insertion_policy() const;
 
    [[nodiscard]] MyEvictionPolicy& eviction_policy();
 
    [[nodiscard]] const MyEvictionPolicy& eviction_policy() const;
 
    [[nodiscard]] MyConstraintPolicy& constraint_policy();
 
    [[nodiscard]] const MyConstraintPolicy& constraint_policy() const;
 
    [[nodiscard]] double hit_rate() const;
 
    [[nodiscard]] double byte_hit_rate() const;
 
    [[nodiscard]] uint32_t statistics_window_size() const;
 
    void statistics_window_size(uint32_t window_size);
 
protected:
    LockGuard                       lock() const;
    LockGuard                       lock(std::defer_lock_t defer_lock_tag) const;
    std::pair<LockGuard, LockGuard> lock_pair(CacheType& other) const;
 
    template<typename C> void import(C& collection);
 
private:
    using CacheItem = Item<Value>;
 
    using DataMap = absl::node_hash_map<Key, CacheItem, KeyHash, detail::TransparentEq<Key>>;
 
    using DataMapIt = typename DataMap::iterator;
 
    using MyInsertionPolicySP  = std::unique_ptr<MyInsertionPolicy>;
    using MyEvictionPolicySP   = std::unique_ptr<MyEvictionPolicy>;
    using MyConstraintPolicySP = std::unique_ptr<MyConstraintPolicy>;
 
    using RollingMeanTag        = boost::accumulators::tag::rolling_mean;
    using RollingMeanStatistics = boost::accumulators::stats<RollingMeanTag>;
    using MeanAccumulator       = boost::accumulators::accumulator_set<uint32_t, RollingMeanStatistics>;
 
    uint32_t m_statistics_window_size = 1000;
 
    MyInsertionPolicySP  m_insertion_policy;
    MyEvictionPolicySP   m_eviction_policy;
    MyConstraintPolicySP m_constraint_policy;
 
    MeasureKey   m_measure_key;
    MeasureValue m_measure_value;
 
    mutable std::recursive_mutex m_mutex;
    DataMap                      m_data;
 
    mutable MeanAccumulator m_hit_rate_acc;
    mutable MeanAccumulator m_byte_hit_rate_acc;
 
    bool check_insert(const Key& candidate_key, const CacheItem& item);
    bool check_replace(const Key& candidate_key, const CacheItem& old_item, const CacheItem& new_item);
 
    void insert_or_update(Key&& key, CacheItem&& value);
    void remove(DataMapIt it);
 
    void                            on_insert(const Key& key, const CacheItem& item) const;
    void                            on_update(const Key& key, const CacheItem& old_item, const CacheItem& new_item) const;
    void                            on_cache_hit(const Key& key, const CacheItem& item) const;
    template<typename KeyView> void on_cache_miss(const KeyView& key) const;
    void                            on_evict(const Key& key, const CacheItem& item) const;
};
 
template<class K,
         class V,
         template<class, class, class>
         class I,
         template<class, class, class>
         class E,
         template<class, class, class>
         class C,
         class SV,
         class SK,
         class KH,
         bool TS>
void swap(Cache<K, V, I, E, C, SV, SK, KH, TS>& lhs, Cache<K, V, I, E, C, SV, SK, KH, TS>& rhs) noexcept;
 
}  // namespace cachemere
 
#include "cache.hpp"
 
#endif