Struct LruCache 

pub struct LruCache<K: Eq + Hash + Clone, V> { /* private fields */ }

High-performance LRU cache backed by an arena of Option<LruNode> slots.

Type parameters

• K – key type; must implement Eq + Hash + Clone.
• V – value type.

Implementations

impl<K: Eq + Hash + Clone, V> LruCache<K, V>

pub fn new(capacity: usize) -> Self

Create a new LruCache with the given entry capacity.

pub fn with_default_ttl(capacity: usize, ttl: Duration) -> Self

Create a new LruCache with a default TTL applied to all entries unless overridden by insert_with_ttl.

pub fn get(&mut self, key: &K) -> Option<&V>

Look up key, move it to the MRU head, and return a shared reference to its value. Records a cache hit/miss in the statistics.

If the entry has a TTL and has expired, it is lazily evicted and None is returned (counted as a miss).

pub fn insert(&mut self, key: K, value: V, size_bytes: usize)

Insert (key, value) into the cache.

• If the key already exists, its value is updated and it is promoted to the MRU head.
• If the cache is at capacity the LRU entry is evicted first.

The default TTL (if configured via with_default_ttl) is applied.

pub fn insert_with_ttl( &mut self, key: K, value: V, size_bytes: usize, ttl: Duration, )

Insert (key, value) with an explicit TTL duration.

Overrides any default TTL configured on the cache.

pub fn insert_pinned(&mut self, key: K, value: V, size_bytes: usize)

Insert a pinned entry that will not be evicted by LRU eviction.

Pinned entries remain in the cache until explicitly removed via remove or unpin + subsequent eviction.

pub fn remove(&mut self, key: &K) -> Option<V>

Remove the entry for key, returning its value if present.

pub fn contains(&self, key: &K) -> bool

Returns true if the cache contains an entry for key.

pub fn len(&self) -> usize

Returns the number of entries currently resident in the cache.

pub fn is_empty(&self) -> bool

Returns true when the cache has no entries.

pub fn stats(&self) -> CacheStats

Return a snapshot of cache statistics.

pub fn peek(&self, key: &K) -> Option<&V>

Return a shared reference to the value for key without updating LRU order or statistics.

pub fn evict_lru(&mut self) -> Option<(K, V)>

Manually evict the least-recently-used unpinned entry, returning (key, value).

Pinned entries are skipped. Returns None if the cache is empty or every entry is pinned.

pub fn set_default_ttl(&mut self, ttl: Option<Duration>)

Set the default TTL for newly inserted entries.

pub fn purge_expired(&mut self) -> usize

Eagerly purge all expired entries. Returns the number of entries removed.

pub fn pin(&mut self, key: &K) -> bool

Pin an existing entry so it cannot be evicted by LRU eviction.

Returns true if the entry was found and pinned.

pub fn unpin(&mut self, key: &K) -> bool

Unpin an existing entry so it becomes eligible for LRU eviction again.

Returns true if the entry was found and unpinned.

pub fn is_pinned(&self, key: &K) -> bool

Returns true if the entry for key is pinned.

pub fn refresh_ttl(&mut self, key: &K) -> bool

Refresh the TTL of an existing entry, resetting its expiration clock.

If the entry has no TTL (neither explicit nor default), this is a no-op and returns false. Returns true if the TTL was successfully refreshed.

pub fn set_entry_ttl(&mut self, key: &K, ttl: Duration) -> bool

Set an explicit TTL on an existing entry, overriding any previous TTL.

Returns true if the entry was found and the TTL was set.

pub fn clear_entry_ttl(&mut self, key: &K) -> bool

Remove the TTL from an existing entry, making it live indefinitely (until evicted by LRU or explicitly removed).

Returns true if the entry was found and TTL cleared.

pub fn remaining_ttl(&self, key: &K) -> Option<Duration>

Return the remaining TTL for the entry, or None if the entry does not exist or has no TTL.

pub fn pinned_count(&self) -> usize

Return the number of pinned entries.

pub fn unpin_all(&mut self) -> usize

Unpin all currently pinned entries. Returns the number of entries unpinned.

pub fn resize(&mut self, new_capacity: usize) -> usize

Resize the cache to new_capacity, evicting excess entries if necessary.

Returns the number of entries evicted.

pub fn capacity(&self) -> usize

Return the current capacity (maximum number of entries).

pub fn keys(&self) -> Vec<K>

Return a vector of all keys currently in the cache (in no particular order).

pub fn clear(&mut self)

Remove all entries from the cache, resetting statistics.

pub fn access_count(&self, key: &K) -> Option<u64>

Return the access count for a specific entry, or None if the key does not exist.