Class for expirable LRU cache. Use cache::LruMap for not expirable LRU Cache. More...

#include <userver/cache/expirable_lru_cache.hpp>

Public Types
enum class	ReadMode { kSkipCache , kUseCache }
	Cache read mode. More...

using	UpdateValueFunc = std::function< Value(const Key &)>

Public Member Functions
	ExpirableLruCache (size_t ways, size_t way_size, const Hash &hash=Hash(), const Equal &equal=Equal())

void	SetWaySize (size_t way_size)

std::chrono::milliseconds	GetMaxLifetime () const noexcept

void	SetMaxLifetime (std::chrono::milliseconds max_lifetime)

void	SetBackgroundUpdate (BackgroundUpdateMode background_update)

Value	Get (const Key &key, const UpdateValueFunc &update_func, ReadMode read_mode=ReadMode::kUseCache)

std::optional< Value >	GetOptional (const Key &key, const UpdateValueFunc &update_func)

std::optional< Value >	GetOptionalUnexpirable (const Key &key)

std::optional< Value >	GetOptionalUnexpirableWithUpdate (const Key &key, const UpdateValueFunc &update_func)

std::optional< Value >	GetOptionalNoUpdate (const Key &key)

void	Put (const Key &key, const Value &value)

void	Put (const Key &key, Value &&value)

const impl::ExpirableLruCacheStatistics &	GetStatistics () const

size_t	GetSizeApproximate () const

void	Invalidate ()
	Clear cache.

void	InvalidateByKey (const Key &key)
	Erase key from cache.

void	UpdateInBackground (const Key &key, UpdateValueFunc update_func)
	Add async task for updating value by update_func(key)

void	Write (dump::Writer &writer) const

void	Read (dump::Reader &reader)

void	SetDumper (std::shared_ptr< dump::Dumper > dumper)

Detailed Description

template<typename Key, typename Value, typename Hash = std::hash<Key>, typename Equal = std::equal_to<Key>>
class cache::ExpirableLruCache< Key, Value, Hash, Equal >

Class for expirable LRU cache. Use cache::LruMap for not expirable LRU Cache.

Example usage:

  using Key = std::string;
  using Value = int;
  using Cache = cache::ExpirableLruCache<Key, Value>;
 
  Cache cache(/*ways*/ 1, /*way_size*/ 1);
  cache.SetMaxLifetime(std::chrono::seconds(3));  // by default not bounded
 
  utils::datetime::MockNowSet(std::chrono::system_clock::now());
 
  Key key1 = "first-key";
  Key key2 = "second-key";
  cache.Put(key1, 41);
  EXPECT_EQ(41, cache.GetOptionalNoUpdate(key1));
  cache.Put(key2, 42);
  EXPECT_EQ(std::nullopt, cache.GetOptionalNoUpdate(key1));
  EXPECT_EQ(42, cache.GetOptionalNoUpdate(key2));
 
  utils::datetime::MockSleep(std::chrono::seconds(2));
  EXPECT_EQ(42, cache.GetOptionalNoUpdate(key2));
 
  utils::datetime::MockSleep(std::chrono::seconds(2));
  EXPECT_EQ(std::nullopt, cache.GetOptionalNoUpdate(key2));

Definition at line 61 of file expirable_lru_cache.hpp.

Member Typedef Documentation

◆ UpdateValueFunc

template<typename Key , typename Value , typename Hash = std::hash<Key>, typename Equal = std::equal_to<Key>>

using cache::ExpirableLruCache< Key, Value, Hash, Equal >::UpdateValueFunc = std::function<Value(const Key&)>

Definition at line 63 of file expirable_lru_cache.hpp.

Member Enumeration Documentation

◆ ReadMode

template<typename Key , typename Value , typename Hash = std::hash<Key>, typename Equal = std::equal_to<Key>>

enum class cache::ExpirableLruCache::ReadMode

strong

Cache read mode.

Enumerator
kSkipCache	Do not cache value got from update function.
kUseCache	Cache value got from update function.

Definition at line 66 of file expirable_lru_cache.hpp.