kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual > Class Template Reference

Thread-safe LRU cache with TTL support. More...

#include <simple_lru_cache.h>

Inheritance diagram for kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >:

Collaboration diagram for kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >:

Classes
struct	cache_entry

Public Types
using	key_type = Key
using	value_type = Value
using	size_type = std::size_t
using	clock_type = std::chrono::steady_clock
using	time_point = clock_type::time_point

Public Member Functions
	simple_lru_cache (const cache_config &config=cache_config{})
	Construct a cache with the given configuration.
	simple_lru_cache (size_type max_size, std::chrono::seconds ttl)
	Construct a cache with size and TTL.
	simple_lru_cache (const simple_lru_cache &)=delete
	Non-copyable.
simple_lru_cache &	operator= (const simple_lru_cache &)=delete
	simple_lru_cache (simple_lru_cache &&other) noexcept
	Movable.
simple_lru_cache &	operator= (simple_lru_cache &&other) noexcept
	~simple_lru_cache ()=default
std::optional< Value >	get (const Key &key)
	Retrieve a value from the cache.
void	put (const Key &key, const Value &value)
	Store a value in the cache.
void	put (const Key &key, Value &&value)
	Store a value in the cache (move semantics)
bool	contains (const Key &key) const
	Check if a key exists in the cache (without affecting LRU order)
bool	invalidate (const Key &key)
	Remove a specific entry from the cache.
template<typename Predicate >
size_type	invalidate_if (Predicate pred)
	Remove all entries matching a predicate.
void	clear ()
	Remove all entries from the cache.
size_type	purge_expired ()
	Remove all expired entries from the cache.
size_type	size () const
	Get the current number of entries in the cache.
bool	empty () const
	Check if the cache is empty.
size_type	max_size () const noexcept
	Get the maximum cache size.
std::chrono::seconds	ttl () const noexcept
	Get the TTL duration.
const std::string &	name () const noexcept
	Get the cache name (for metrics identification)
const cache_config &	config () const noexcept
	Get the cache configuration.
const cache_stats &	stats () const noexcept
	Get cache statistics.
double	hit_rate () const noexcept
	Get the cache hit rate.
void	reset_stats () noexcept
	Reset cache statistics.

Private Types
using	list_type = std::list<cache_entry>
using	list_iterator = typename list_type::iterator
using	map_type = std::unordered_map<Key, list_iterator, Hash, KeyEqual>

Private Member Functions
time_point	calculate_expiry () const
bool	is_expired (time_point expiry) const
bool	is_expired (time_point expiry, time_point now) const
void	evict_oldest ()
void	remove_entry (typename map_type::iterator map_it)

Private Attributes
cache_config	config_
size_type	max_size_
std::shared_mutex	mutex_
list_type	lru_list_
map_type	cache_map_
cache_stats	stats_

Detailed Description

template<typename Key, typename Value, typename Hash = std::hash<Key>, typename KeyEqual = std::equal_to<Key>>
class kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >

Thread-safe LRU cache with TTL support.

This class provides a least-recently-used (LRU) cache that automatically evicts the oldest entries when the cache reaches its maximum size. Each entry has a configurable time-to-live (TTL) after which it expires.

The implementation uses:

• std::list for O(1) insertion/removal and LRU ordering
• std::unordered_map for O(1) key lookups
• std::shared_mutex for reader-writer locking (multiple readers, single writer)

Thread Safety: All public methods are thread-safe. Read operations (get) use shared locks allowing concurrent reads. Write operations (put, invalidate, clear) use exclusive locks.

Template Parameters

Key	The key type (must be hashable and equality comparable)
Value	The value type (must be copy constructible)
Hash	Hash function for keys (defaults to std::hash<Key>)
KeyEqual	Equality comparison for keys (defaults to std::equal_to<Key>)

Example:

// Create a cache for query results
cache_config config;
config.max_size = 1000;
config.ttl = std::chrono::seconds{300};  // 5 minutes
config.cache_name = "cfind_cache";
 
simple_lru_cache<std::string, QueryResult> cache(config);
 
// Store a result
cache.put("patient_123", query_result);
 
// Retrieve a result
auto result = cache.get("patient_123");
if (result) {
    // Use cached result
    process(*result);
}
 
// Check cache performance
const auto& stats = cache.stats();
logger_adapter::info("Cache hit rate: {:.2f}%", stats.hit_rate());

Definition at line 177 of file simple_lru_cache.h.

Member Typedef Documentation

clock_type

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

using kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::clock_type = std::chrono::steady_clock

Definition at line 182 of file simple_lru_cache.h.

key_type

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

using kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::key_type = Key

Definition at line 179 of file simple_lru_cache.h.

list_iterator

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

using kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::list_iterator = typename list_type::iterator

private

Definition at line 562 of file simple_lru_cache.h.

list_type

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

using kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::list_type = std::list<cache_entry>

private

Definition at line 561 of file simple_lru_cache.h.

map_type

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

using kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::map_type = std::unordered_map<Key, list_iterator, Hash, KeyEqual>

private

Definition at line 563 of file simple_lru_cache.h.

size_type

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

using kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::size_type = std::size_t

Definition at line 181 of file simple_lru_cache.h.

time_point

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

using kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::time_point = clock_type::time_point

Definition at line 183 of file simple_lru_cache.h.

value_type

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

using kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::value_type = Value

Definition at line 180 of file simple_lru_cache.h.

Constructor & Destructor Documentation

simple_lru_cache() [1/4]

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

kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::simple_lru_cache ( const cache_config & config = cache_config{} )

inlineexplicit

Construct a cache with the given configuration.

Parameters

config

Cache configuration options

Definition at line 193 of file simple_lru_cache.h.

                                                                       {})
        : config_(config)
        , max_size_(config.max_size > 0 ? config.max_size : 1) {
    }

simple_lru_cache() [2/4]

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

kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::simple_lru_cache ( size_type max_size, std::chrono::seconds ttl )

inline

Construct a cache with size and TTL.

Parameters

max_size	Maximum number of entries
ttl	Time-to-live for entries

Definition at line 203 of file simple_lru_cache.h.

        : max_size_(max_size > 0 ? max_size : 1) {
        config_.max_size = max_size_;
        config_.ttl = ttl;
    }

References kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::config_, kcenon::pacs::services::cache::cache_config::max_size, kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::max_size_, kcenon::pacs::services::cache::cache_config::ttl, and kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::ttl().

Here is the call graph for this function:

simple_lru_cache() [3/4]

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

kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::simple_lru_cache ( const simple_lru_cache< Key, Value, Hash, KeyEqual > & )

delete

Non-copyable.

simple_lru_cache() [4/4]

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

kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::simple_lru_cache ( simple_lru_cache< Key, Value, Hash, KeyEqual > && other )

inlinenoexcept

Movable.

Definition at line 214 of file simple_lru_cache.h.

                                                        {
        std::unique_lock lock(other.mutex_);
        config_ = std::move(other.config_);
        max_size_ = other.max_size_;
        lru_list_ = std::move(other.lru_list_);
        cache_map_ = std::move(other.cache_map_);
        // Stats are not moved (fresh start for moved-to instance)
    }

References kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::cache_map_, kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::config_, kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::lru_list_, kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::max_size_, and kcenon::pacs::services::other.

~simple_lru_cache()

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

kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::~simple_lru_cache ( )

default

Member Function Documentation

calculate_expiry()

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

time_point kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::calculate_expiry ( ) const

inlinenodiscardprivate

Definition at line 569 of file simple_lru_cache.h.

                                                      {
        return clock_type::now() + config_.ttl;
    }

References kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::config_, and kcenon::pacs::services::cache::cache_config::ttl.

Referenced by kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::put(), and kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::put().

Here is the caller graph for this function:

clear()

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

void kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::clear ( )

inline

Remove all entries from the cache.

Definition at line 429 of file simple_lru_cache.h.

                 {
        std::unique_lock lock(mutex_);
 
        lru_list_.clear();
        cache_map_.clear();
        stats_.current_size.store(0, std::memory_order_relaxed);
    }

References kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::cache_map_, kcenon::pacs::services::cache::cache_stats::current_size, kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::lru_list_, kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::mutex_, and kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::stats_.

config()

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

const cache_config & kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::config ( ) const

inlinenodiscardnoexcept

Get the cache configuration.

Returns

Cache configuration

Definition at line 517 of file simple_lru_cache.h.

                                                              {
        return config_;
    }

References kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::config_.

contains()

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

bool kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::contains ( const Key & key ) const

inlinenodiscard

Check if a key exists in the cache (without affecting LRU order)

Note: This does not check TTL expiration for performance reasons. Use get() if you need TTL-aware existence checking.

Parameters

key	The key to check

Returns

true if the key exists in the cache

Definition at line 357 of file simple_lru_cache.h.

                                                      {
        std::shared_lock lock(mutex_);
        return cache_map_.find(key) != cache_map_.end();
    }

References kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::cache_map_, and kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::mutex_.

empty()

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

bool kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::empty ( ) const

inlinenodiscard

Check if the cache is empty.

Returns

true if the cache contains no entries

Definition at line 484 of file simple_lru_cache.h.

                                     {
        std::shared_lock lock(mutex_);
        return cache_map_.empty();
    }

References kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::cache_map_, and kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::mutex_.

evict_oldest()

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

void kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::evict_oldest ( )

inlineprivate

Definition at line 581 of file simple_lru_cache.h.

                        {
        // Evict from the back (least recently used)
        if (lru_list_.empty()) {
            return;
        }
 
        auto& oldest = lru_list_.back();
        cache_map_.erase(oldest.key);
        lru_list_.pop_back();
 
        stats_.evictions.fetch_add(1, std::memory_order_relaxed);
        stats_.current_size.store(cache_map_.size(), std::memory_order_relaxed);
    }

References kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::cache_map_, kcenon::pacs::services::cache::cache_stats::current_size, kcenon::pacs::services::cache::cache_stats::evictions, kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::lru_list_, and kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::stats_.

Referenced by kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::put(), and kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::put().

Here is the caller graph for this function:

get()

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

std::optional< Value > kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::get ( const Key & key )

inlinenodiscard

Retrieve a value from the cache.

If the key exists and the entry has not expired, returns the value and moves the entry to the front of the LRU list (most recently used). Expired entries are automatically removed.

Parameters

key	The key to look up

Returns

The cached value if found and not expired, std::nullopt otherwise

Definition at line 253 of file simple_lru_cache.h.

                                                         {
        std::unique_lock lock(mutex_);
 
        auto it = cache_map_.find(key);
        if (it == cache_map_.end()) {
            // Cache miss
            stats_.misses.fetch_add(1, std::memory_order_relaxed);
            return std::nullopt;
        }
 
        auto& entry = it->second;
 
        // Check TTL expiration
        if (is_expired(entry->expiry_time)) {
            // Entry expired - remove it
            stats_.expirations.fetch_add(1, std::memory_order_relaxed);
            stats_.misses.fetch_add(1, std::memory_order_relaxed);
            remove_entry(it);
            return std::nullopt;
        }
 
        // Cache hit - move to front (most recently used)
        stats_.hits.fetch_add(1, std::memory_order_relaxed);
        lru_list_.splice(lru_list_.begin(), lru_list_, entry);
 
        return entry->value;
    }

References kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::cache_map_, kcenon::pacs::services::cache::cache_stats::expirations, kcenon::pacs::services::cache::cache_stats::hits, kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::is_expired(), kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::lru_list_, kcenon::pacs::services::cache::cache_stats::misses, kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::mutex_, kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::remove_entry(), and kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::stats_.

Here is the call graph for this function:

hit_rate()

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

double kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::hit_rate ( ) const

inlinenodiscardnoexcept

Get the cache hit rate.

Returns

Hit rate as a percentage (0.0 to 100.0)

Definition at line 537 of file simple_lru_cache.h.

                                                   {
        return stats_.hit_rate();
    }

References kcenon::pacs::services::cache::cache_stats::hit_rate(), and kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::stats_.

Here is the call graph for this function:

invalidate()

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

bool kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::invalidate ( const Key & key )

inline

Remove a specific entry from the cache.

Parameters

key	The key to remove

Returns

true if the entry was found and removed, false otherwise

Definition at line 368 of file simple_lru_cache.h.

                                    {
        std::unique_lock lock(mutex_);
 
        auto it = cache_map_.find(key);
        if (it == cache_map_.end()) {
            return false;
        }
 
        remove_entry(it);
        return true;
    }

References kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::cache_map_, kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::mutex_, and kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::remove_entry().

Here is the call graph for this function:

invalidate_if()

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

template<typename Predicate >

size_type kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::invalidate_if ( Predicate pred )

inline

Remove all entries matching a predicate.

Iterates through all cache entries and removes those for which the predicate returns true. This is useful for invalidating related entries when data changes (e.g., invalidating all cached queries for a specific patient when new studies arrive).

Template Parameters

Predicate

A callable that takes (const Key&, const Value&) and returns bool

Parameters

pred	The predicate function; entries where pred(key, value) returns true are removed

Returns

Number of entries removed

Example:

// Invalidate all entries with keys starting with "PATIENT:"
cache.invalidate_if([](const std::string& key, const auto&) {
    return key.starts_with("PATIENT:");
});
 
// Invalidate entries older than a certain age
cache.invalidate_if([&](const auto&, const QueryResult& result) {
    return result.match_count > 1000;  // Remove large result sets
});

Definition at line 406 of file simple_lru_cache.h.

                                            {
        std::unique_lock lock(mutex_);
 
        size_type removed = 0;
        auto it = lru_list_.begin();
 
        while (it != lru_list_.end()) {
            if (pred(it->key, it->value)) {
                cache_map_.erase(it->key);
                it = lru_list_.erase(it);
                ++removed;
            } else {
                ++it;
            }
        }
 
        stats_.current_size.store(cache_map_.size(), std::memory_order_relaxed);
        return removed;
    }

References kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::cache_map_, kcenon::pacs::services::cache::cache_stats::current_size, kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::lru_list_, kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::mutex_, and kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::stats_.

is_expired() [1/2]

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

bool kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::is_expired ( time_point expiry ) const

inlinenodiscardprivate

Definition at line 573 of file simple_lru_cache.h.

                                                           {
        return clock_type::now() > expiry;
    }

Referenced by kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::get(), and kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::purge_expired().

Here is the caller graph for this function:

is_expired() [2/2]

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

bool kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::is_expired ( time_point expiry, time_point now ) const

inlinenodiscardprivate

Definition at line 577 of file simple_lru_cache.h.

                                                                           {
        return now > expiry;
    }

max_size()

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

size_type kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::max_size ( ) const

inlinenodiscardnoexcept

Get the maximum cache size.

Returns

Maximum number of entries

Definition at line 493 of file simple_lru_cache.h.

                                                      {
        return max_size_;
    }

References kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::max_size_.

name()

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

const std::string & kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::name ( ) const

inlinenodiscardnoexcept

Get the cache name (for metrics identification)

Returns

Cache name

Definition at line 509 of file simple_lru_cache.h.

                                                         {
        return config_.cache_name;
    }

References kcenon::pacs::services::cache::cache_config::cache_name, and kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::config_.

operator=() [1/2]

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

simple_lru_cache & kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::operator= ( const simple_lru_cache< Key, Value, Hash, KeyEqual > & )

delete

operator=() [2/2]

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

simple_lru_cache & kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::operator= ( simple_lru_cache< Key, Value, Hash, KeyEqual > && other )

inlinenoexcept

Definition at line 223 of file simple_lru_cache.h.

                                                                   {
        if (this != &other) {
            std::unique_lock lock1(mutex_, std::defer_lock);
            std::unique_lock lock2(other.mutex_, std::defer_lock);
            std::lock(lock1, lock2);
 
            config_ = std::move(other.config_);
            max_size_ = other.max_size_;
            lru_list_ = std::move(other.lru_list_);
            cache_map_ = std::move(other.cache_map_);
        }
        return *this;
    }

References kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::cache_map_, kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::config_, kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::lru_list_, kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::max_size_, kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::mutex_, and kcenon::pacs::services::other.

purge_expired()

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

size_type kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::purge_expired ( )

inline

Remove all expired entries from the cache.

This is useful for periodic cleanup to free memory from expired entries that haven't been accessed.

Returns

Number of expired entries removed

Definition at line 445 of file simple_lru_cache.h.

                              {
        std::unique_lock lock(mutex_);
 
        size_type removed = 0;
        const auto now = clock_type::now();
 
        auto it = lru_list_.begin();
        while (it != lru_list_.end()) {
            if (is_expired(it->expiry_time, now)) {
                cache_map_.erase(it->key);
                it = lru_list_.erase(it);
                ++removed;
                stats_.expirations.fetch_add(1, std::memory_order_relaxed);
            } else {
                ++it;
            }
        }
 
        stats_.current_size.store(cache_map_.size(), std::memory_order_relaxed);
        return removed;
    }

References kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::cache_map_, kcenon::pacs::services::cache::cache_stats::current_size, kcenon::pacs::services::cache::cache_stats::expirations, kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::is_expired(), kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::lru_list_, kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::mutex_, and kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::stats_.

Here is the call graph for this function:

put() [1/2]

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

void kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::put ( const Key & key, const Value & value )

inline

Store a value in the cache.

If the key already exists, updates the value and moves to front. If the cache is full, evicts the least recently used entry.

Parameters

key	The key to store
value	The value to cache

Definition at line 290 of file simple_lru_cache.h.

                                                 {
        std::unique_lock lock(mutex_);
 
        auto it = cache_map_.find(key);
        if (it != cache_map_.end()) {
            // Update existing entry
            auto& entry = it->second;
            entry->value = value;
            entry->expiry_time = calculate_expiry();
            lru_list_.splice(lru_list_.begin(), lru_list_, entry);
            return;
        }
 
        // Evict if at capacity
        while (cache_map_.size() >= max_size_ && !lru_list_.empty()) {
            evict_oldest();
        }
 
        // Insert new entry at front
        lru_list_.emplace_front(cache_entry{key, value, calculate_expiry()});
        cache_map_[key] = lru_list_.begin();
 
        stats_.insertions.fetch_add(1, std::memory_order_relaxed);
        stats_.current_size.store(cache_map_.size(), std::memory_order_relaxed);
    }

References kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::cache_map_, kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::calculate_expiry(), kcenon::pacs::services::cache::cache_stats::current_size, kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::evict_oldest(), kcenon::pacs::services::cache::cache_stats::insertions, kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::lru_list_, kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::max_size_, kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::mutex_, and kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::stats_.

Here is the call graph for this function:

put() [2/2]

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

void kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::put ( const Key & key, Value && value )

inline

Store a value in the cache (move semantics)

Parameters

key	The key to store
value	The value to cache (moved)

Definition at line 322 of file simple_lru_cache.h.

                                            {
        std::unique_lock lock(mutex_);
 
        auto it = cache_map_.find(key);
        if (it != cache_map_.end()) {
            // Update existing entry
            auto& entry = it->second;
            entry->value = std::move(value);
            entry->expiry_time = calculate_expiry();
            lru_list_.splice(lru_list_.begin(), lru_list_, entry);
            return;
        }
 
        // Evict if at capacity
        while (cache_map_.size() >= max_size_ && !lru_list_.empty()) {
            evict_oldest();
        }
 
        // Insert new entry at front
        lru_list_.emplace_front(cache_entry{key, std::move(value), calculate_expiry()});
        cache_map_[key] = lru_list_.begin();
 
        stats_.insertions.fetch_add(1, std::memory_order_relaxed);
        stats_.current_size.store(cache_map_.size(), std::memory_order_relaxed);
    }

References kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::cache_map_, kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::calculate_expiry(), kcenon::pacs::services::cache::cache_stats::current_size, kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::evict_oldest(), kcenon::pacs::services::cache::cache_stats::insertions, kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::lru_list_, kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::max_size_, kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::mutex_, and kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::stats_.

Here is the call graph for this function:

remove_entry()

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

void kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::remove_entry ( typename map_type::iterator map_it )

inlineprivate

Definition at line 595 of file simple_lru_cache.h.

                                                        {
        lru_list_.erase(map_it->second);
        cache_map_.erase(map_it);
        stats_.current_size.store(cache_map_.size(), std::memory_order_relaxed);
    }

References kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::cache_map_, kcenon::pacs::services::cache::cache_stats::current_size, kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::lru_list_, and kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::stats_.

Referenced by kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::get(), and kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::invalidate().

Here is the caller graph for this function:

reset_stats()

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

void kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::reset_stats ( )

inlinenoexcept

Reset cache statistics.

Resets all counters except current_size which reflects actual cache state.

Definition at line 546 of file simple_lru_cache.h.

                                {
        stats_.reset();
    }

References kcenon::pacs::services::cache::cache_stats::reset(), and kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::stats_.

Here is the call graph for this function:

size()

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

size_type kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::size ( ) const

inlinenodiscard

Get the current number of entries in the cache.

Returns

Current cache size

Definition at line 475 of file simple_lru_cache.h.

                                         {
        std::shared_lock lock(mutex_);
        return cache_map_.size();
    }

References kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::cache_map_, and kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::mutex_.

stats()

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

const cache_stats & kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::stats ( ) const

inlinenodiscardnoexcept

Get cache statistics.

Returns

Reference to cache statistics

Definition at line 529 of file simple_lru_cache.h.

                                                            {
        return stats_;
    }

References kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::stats_.

ttl()

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

std::chrono::seconds kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::ttl ( ) const

inlinenodiscardnoexcept

Get the TTL duration.

Returns

Time-to-live for entries

Definition at line 501 of file simple_lru_cache.h.

                                                        {
        return config_.ttl;
    }

References kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::config_, and kcenon::pacs::services::cache::cache_config::ttl.

Referenced by kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::simple_lru_cache().

Here is the caller graph for this function:

Member Data Documentation

cache_map_

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

map_type kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::cache_map_

private

Definition at line 610 of file simple_lru_cache.h.

Referenced by kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::clear(), kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::contains(), kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::empty(), kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::evict_oldest(), kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::get(), kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::invalidate(), kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::invalidate_if(), kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::operator=(), kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::purge_expired(), kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::put(), kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::put(), kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::remove_entry(), kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::simple_lru_cache(), and kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::size().

config_

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

cache_config kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::config_

private

Definition at line 605 of file simple_lru_cache.h.

Referenced by kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::calculate_expiry(), kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::config(), kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::name(), kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::operator=(), kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::simple_lru_cache(), kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::simple_lru_cache(), and kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::ttl().

lru_list_

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

list_type kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::lru_list_

private

Definition at line 609 of file simple_lru_cache.h.

Referenced by kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::clear(), kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::evict_oldest(), kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::get(), kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::invalidate_if(), kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::operator=(), kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::purge_expired(), kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::put(), kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::put(), kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::remove_entry(), and kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::simple_lru_cache().

max_size_

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

size_type kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::max_size_

private

Definition at line 606 of file simple_lru_cache.h.

Referenced by kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::max_size(), kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::operator=(), kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::put(), kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::put(), kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::simple_lru_cache(), and kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::simple_lru_cache().

mutex_

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

std::shared_mutex kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::mutex_

mutableprivate

Definition at line 608 of file simple_lru_cache.h.

Referenced by kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::clear(), kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::contains(), kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::empty(), kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::get(), kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::invalidate(), kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::invalidate_if(), kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::operator=(), kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::purge_expired(), kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::put(), kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::put(), and kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::size().

stats_

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

cache_stats kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::stats_

private

Definition at line 612 of file simple_lru_cache.h.

Referenced by kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::clear(), kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::evict_oldest(), kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::get(), kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::hit_rate(), kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::invalidate_if(), kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::purge_expired(), kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::put(), kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::put(), kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::remove_entry(), kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::reset_stats(), and kcenon::pacs::services::cache::simple_lru_cache< Key, Value, Hash, KeyEqual >::stats().

---

The documentation for this class was generated from the following file:

• include/kcenon/pacs/services/cache/simple_lru_cache.h