TARAXA
Public Member Functions | Protected Member Functions | Protected Attributes | List of all members
ExpirationCacheMap< Key, Value > Class Template Reference

#include <util.hpp>

Public Member Functions

 ExpirationCacheMap (uint32_t max_size, uint32_t delete_step)
 
bool insert (Key const &key, Value const &value)
 Inserts <key,value> pair into the cache map. In case provided key is already in cache, only shared lock is acquired and function returns false. This means insert does not need to be used together with count() to save the performance by not acquiring unique lock. More...
 
std::size_t count (Key const &key) const
 
std::size_t size () const
 
std::pair< Value, bool > get (Key const &key) const
 
void clear ()
 
void update (Key const &key, Value value)
 
void erase (const Key &key)
 
std::pair< Value, bool > updateWithGet (Key const &key, Value value)
 
std::unordered_map< Key, Value > getRawMap ()
 
bool update (Key const &key, Value value, Value expected_value)
 

Protected Member Functions

virtual void eraseOldest ()
 

Protected Attributes

std::unordered_map< Key, Value > cache_
 
std::deque< Key > expiration_
 
const uint32_t kMaxSize
 
const uint32_t kDeleteStep
 
std::shared_mutex mtx_
 

Constructor & Destructor Documentation

◆ ExpirationCacheMap()

template<class Key , class Value >
ExpirationCacheMap< Key, Value >::ExpirationCacheMap ( uint32_t  max_size,
uint32_t  delete_step 
)
inline

Member Function Documentation

◆ clear()

template<class Key , class Value >
void ExpirationCacheMap< Key, Value >::clear ( )
inline

◆ count()

template<class Key , class Value >
std::size_t ExpirationCacheMap< Key, Value >::count ( Key const &  key) const
inline

◆ erase()

template<class Key , class Value >
void ExpirationCacheMap< Key, Value >::erase ( const Key &  key)
inline

◆ eraseOldest()

template<class Key , class Value >
virtual void ExpirationCacheMap< Key, Value >::eraseOldest ( )
inlineprotectedvirtual

◆ get()

template<class Key , class Value >
std::pair<Value, bool> ExpirationCacheMap< Key, Value >::get ( Key const &  key) const
inline

◆ getRawMap()

template<class Key , class Value >
std::unordered_map<Key, Value> ExpirationCacheMap< Key, Value >::getRawMap ( )
inline

◆ insert()

template<class Key , class Value >
bool ExpirationCacheMap< Key, Value >::insert ( Key const &  key,
Value const &  value 
)
inline

Inserts <key,value> pair into the cache map. In case provided key is already in cache, only shared lock is acquired and function returns false. This means insert does not need to be used together with count() to save the performance by not acquiring unique lock.

Parameters
key
value
Returns
true if actual insertion took place, otherwise false

◆ size()

template<class Key , class Value >
std::size_t ExpirationCacheMap< Key, Value >::size ( ) const
inline

◆ update() [1/2]

template<class Key , class Value >
void ExpirationCacheMap< Key, Value >::update ( Key const &  key,
Value  value 
)
inline

◆ update() [2/2]

template<class Key , class Value >
bool ExpirationCacheMap< Key, Value >::update ( Key const &  key,
Value  value,
Value  expected_value 
)
inline

◆ updateWithGet()

template<class Key , class Value >
std::pair<Value, bool> ExpirationCacheMap< Key, Value >::updateWithGet ( Key const &  key,
Value  value 
)
inline

Member Data Documentation

◆ cache_

template<class Key , class Value >
std::unordered_map<Key, Value> ExpirationCacheMap< Key, Value >::cache_
protected

◆ expiration_

template<class Key , class Value >
std::deque<Key> ExpirationCacheMap< Key, Value >::expiration_
protected

◆ kDeleteStep

template<class Key , class Value >
const uint32_t ExpirationCacheMap< Key, Value >::kDeleteStep
protected

◆ kMaxSize

template<class Key , class Value >
const uint32_t ExpirationCacheMap< Key, Value >::kMaxSize
protected

◆ mtx_

template<class Key , class Value >
std::shared_mutex ExpirationCacheMap< Key, Value >::mtx_
mutableprotected
The documentation for this class was generated from the following file: