presets.h

#ifndef CACHEMERE_PRESETS_H
#define CACHEMERE_PRESETS_H
 
#include <absl/hash/hash.h>
 
#include "cache.h"
#include "measurement.h"
 
#include "policy/bind.h"
#include "policy/constraint_count.h"
#include "policy/constraint_memory.h"
#include "policy/eviction_lru.h"
#include "policy/eviction_segmented_lru.h"
#include "policy/eviction_gdsf.h"
#include "policy/insertion_always.h"
#include "policy/insertion_tinylfu.h"
 
namespace cachemere::presets {
 
namespace memory {
 
template<typename Key,
         typename Value,
         template<class, class, class>
         class InsertionPolicy,
         template<class, class, class>
         class EvictionPolicy,
         typename MeasureValue = measurement::Size<Value>,
         typename MeasureKey   = measurement::Size<Key>,
         typename KeyHash      = absl::Hash<Key>,
         bool ThreadSafe       = true>
using MemoryConstrainedCache = Cache<Key, Value, InsertionPolicy, EvictionPolicy, policy::ConstraintMemory, MeasureValue, MeasureKey, KeyHash, ThreadSafe>;
 
template<typename Key,
         typename Value,
         typename MeasureValue = measurement::Size<Value>,
         typename MeasureKey   = measurement::Size<Key>,
         typename KeyHash      = absl::Hash<Key>,
         bool ThreadSafe       = true>
using LRUCache = MemoryConstrainedCache<Key, Value, policy::InsertionAlways, policy::EvictionLRU, MeasureValue, MeasureKey, KeyHash, ThreadSafe>;
 
template<typename Key,
         typename Value,
         typename MeasureValue = measurement::Size<Value>,
         typename MeasureKey   = measurement::Size<Key>,
         typename KeyHash      = absl::Hash<Key>,
         bool ThreadSafe       = true>
using TinyLFUCache = MemoryConstrainedCache<Key, Value, policy::InsertionTinyLFU, policy::EvictionSegmentedLRU, MeasureValue, MeasureKey, KeyHash, ThreadSafe>;
 
template<typename Key,
         typename Value,
         typename Cost,
         typename MeasureValue = measurement::Size<Value>,
         typename MeasureKey   = measurement::Size<Key>,
         typename KeyHash      = absl::Hash<Key>,
         bool ThreadSafe       = true>
using CustomCostCache = MemoryConstrainedCache<Key,
                                               Value,
                                               policy::InsertionAlways,
                                               policy::bind<policy::EvictionGDSF, Cost>::template ttype,
                                               MeasureValue,
                                               MeasureKey,
                                               KeyHash,
                                               ThreadSafe>;
 
}  // namespace memory
 
namespace count {
 
template<typename Key,
         typename Value,
         template<class, class, class>
         class InsertionPolicy,
         template<class, class, class>
         class EvictionPolicy,
         typename MeasureValue = measurement::Size<Value>,
         typename MeasureKey   = measurement::Size<Key>,
         typename KeyHash      = absl::Hash<Key>,
         bool ThreadSafe       = true>
using CountConstrainedCache = Cache<Key, Value, InsertionPolicy, EvictionPolicy, policy::ConstraintCount, MeasureValue, MeasureKey, KeyHash, ThreadSafe>;
 
template<typename Key,
         typename Value,
         typename MeasureValue = measurement::Size<Value>,
         typename MeasureKey   = measurement::Size<Key>,
         typename KeyHash      = absl::Hash<Key>,
         bool ThreadSafe       = true>
using LRUCache = CountConstrainedCache<Key, Value, policy::InsertionAlways, policy::EvictionLRU, MeasureValue, MeasureKey, KeyHash, ThreadSafe>;
 
template<typename Key,
         typename Value,
         typename MeasureValue = measurement::Size<Value>,
         typename MeasureKey   = measurement::Size<Key>,
         typename KeyHash      = absl::Hash<Key>,
         bool ThreadSafe       = true>
using TinyLFUCache = CountConstrainedCache<Key, Value, policy::InsertionTinyLFU, policy::EvictionSegmentedLRU, MeasureValue, MeasureKey, KeyHash, ThreadSafe>;
 
template<typename Key,
         typename Value,
         typename Cost,
         typename MeasureValue = measurement::Size<Value>,
         typename MeasureKey   = measurement::Size<Key>,
         typename KeyHash      = absl::Hash<Key>,
         bool ThreadSafe       = true>
using CustomCostCache = CountConstrainedCache<Key,
                                              Value,
                                              policy::InsertionAlways,
                                              policy::bind<policy::EvictionGDSF, Cost>::template ttype,
                                              MeasureValue,
                                              MeasureKey,
                                              KeyHash,
                                              ThreadSafe>;
}  // namespace count
 
}  // namespace cachemere::presets
 
#endif