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)

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>)

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

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/services/cache/simple_lru_cache.h.

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

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/services/cache/simple_lru_cache.h.

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

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/services/cache/simple_lru_cache.h.

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

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/services/cache/simple_lru_cache.h.

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

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/services/cache/simple_lru_cache.h.

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

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/services/cache/simple_lru_cache.h.

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

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/services/cache/simple_lru_cache.h.

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

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/services/cache/simple_lru_cache.h.

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

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/services/cache/simple_lru_cache.h.

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

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/services/cache/simple_lru_cache.h.

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

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/services/cache/simple_lru_cache.h.

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.

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/services/cache/simple_lru_cache.h.

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

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/services/cache/simple_lru_cache.h.

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

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/services/cache/simple_lru_cache.h.

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

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/services/cache/simple_lru_cache.h.

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

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/services/cache/simple_lru_cache.h.

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

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/services/cache/simple_lru_cache.h.

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)

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/services/cache/simple_lru_cache.h.

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

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/services/cache/simple_lru_cache.h.

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

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/services/cache/simple_lru_cache.h.

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

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/services/cache/simple_lru_cache.h.

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

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/services/cache/simple_lru_cache.h.

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

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/services/cache/simple_lru_cache.h.

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

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/services/cache/simple_lru_cache.h.

◆ 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

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/services/cache/simple_lru_cache.h.

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

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/services/cache/simple_lru_cache.h.

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);
    }

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);
    }

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

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/services/cache/simple_lru_cache.h.

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.

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/services/cache/simple_lru_cache.h.

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

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/services/cache/simple_lru_cache.h.

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

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/services/cache/simple_lru_cache.h.

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

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/services/cache/simple_lru_cache.h.

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

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/services/cache/simple_lru_cache.h.

Definition at line 610 of file simple_lru_cache.h.

◆ 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

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/services/cache/simple_lru_cache.h.

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

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/services/cache/simple_lru_cache.h.

Definition at line 609 of file simple_lru_cache.h.

◆ 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

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/services/cache/simple_lru_cache.h.

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

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/services/cache/simple_lru_cache.h.

Definition at line 608 of file simple_lru_cache.h.

◆ 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

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/services/cache/simple_lru_cache.h.

Definition at line 612 of file simple_lru_cache.h.

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

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

Classes

Public Types

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ clock_type

◆ key_type

◆ list_iterator

◆ list_type

◆ map_type

◆ size_type

◆ time_point

◆ value_type

Constructor & Destructor Documentation

◆ simple_lru_cache() [1/4]

◆ simple_lru_cache() [2/4]

◆ simple_lru_cache() [3/4]

◆ simple_lru_cache() [4/4]

◆ ~simple_lru_cache()

Member Function Documentation

◆ calculate_expiry()

◆ clear()

◆ config()

◆ contains()

◆ empty()

◆ evict_oldest()

◆ get()

◆ hit_rate()

◆ invalidate()

◆ invalidate_if()

◆ is_expired() [1/2]

◆ is_expired() [2/2]

◆ max_size()

◆ name()

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ purge_expired()

◆ put() [1/2]

◆ put() [2/2]

◆ remove_entry()

◆ reset_stats()

◆ size()

◆ stats()

◆ ttl()

Member Data Documentation

◆ cache_map_

◆ config_

◆ lru_list_

◆ max_size_

◆ mutex_

◆ stats_