Struct LruCache 

pub struct LruCache<K, V> { /* private fields */ }

An LRU cache with a fixed capacity and optional per-entry TTL.

Type parameters

• K: key type – must be Eq + Hash.
• V: value type.

Implementations

impl<K, V> LruCache<K, V>

where K: Eq + Hash,

pub fn new(cap: usize) -> Self

Create a new LruCache with the given capacity.

A capacity of 0 is valid but every put will immediately evict the newly inserted entry on the next insertion.

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

Return the value associated with key, moving it to the MRU position.

If the entry has expired, it is removed and None is returned.

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

Insert or update key -> value (no TTL), evicting the LRU entry if at capacity.

• If key already exists: updates the value and promotes to MRU; no eviction.
• If key is new and the cache is at capacity: evicts the LRU entry first.

Returns the evicted value (not the replaced value on key updates).

pub fn put_with_ttl(&mut self, key: K, value: V, ttl: Duration) -> Option<V>

Insert or update key -> value with a TTL.

pub fn len(&self) -> usize

Return the number of entries currently in the cache (including unexpired).

pub fn is_empty(&self) -> bool

Return true if the cache contains no entries.

pub fn cap(&self) -> usize

Return the maximum capacity of the cache.

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

Return true if key is present and not expired (without promoting).

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

Read the value for key without promoting it to MRU.

Returns None if the key is not present or has expired. Note: this method takes &self, so it cannot remove the expired entry; the removal happens lazily on the next mutable access.

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

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

pub fn clear(&mut self)

Remove all entries from the cache.

pub fn resize(&mut self, new_cap: usize)

Dynamically resize the cache capacity.

If new_cap is smaller than the current length, LRU entries are evicted until the length fits.

pub fn iter(&self) -> impl Iterator<Item = (&K, &V)>

Return an iterator over (&K, &V) pairs in LRU-to-MRU order (front to back, oldest to newest).

Expired entries are included in the iterator; callers should check expiry if needed.

pub fn entry(&mut self, key: K) -> Entry<'_, K, V>

where K: Clone,

Return an entry handle for key.

• Entry::Occupied if the key is present (and not expired).
• Entry::Vacant otherwise.

The entry API mirrors HashMap::entry, enabling efficient insert-or-modify patterns without double hash lookups in most cases.

Trait Implementations

impl<K, V> Cache<K, V> for LruCache<K, V>

where K: Eq + Hash,

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

Look up key, returning a reference to the value if present.

fn put(&mut self, key: K, value: V) -> Option<V>

Insert or update key -> value without a TTL.

fn put_with_ttl(&mut self, key: K, value: V, ttl: Duration) -> Option<V>

Insert or update key -> value with a time-to-live.

fn len(&self) -> usize

Return the number of live entries currently in the cache.

fn cap(&self) -> usize

Return the maximum number of entries the cache can hold.

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

Remove the entry associated with key, returning its value if present.

fn clear(&mut self)

Remove all entries from the cache.

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

Look up key without updating access metadata (no promotion).

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

Return true if key is present in the cache (without promotion).

fn resize(&mut self, new_cap: usize)

Dynamically resize the cache capacity.

fn values(&self) -> Vec<&V>

Return all live (non-expired) values currently stored in the cache.

fn is_empty(&self) -> bool

Return true if the cache holds no entries.

fn get_or_insert(&mut self, key: K, default: impl FnOnce() -> V) -> &V

where K: Clone,

Return &V for key, inserting default() if the key is absent.

fn warm(&mut self, iter: impl IntoIterator<Item = (K, V)>)

Pre-populate the cache with (key, value) pairs from an iterator.

impl<K: Debug, V> Debug for LruCache<K, V>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<K: Eq + Hash, V> From<Vec<(K, V)>> for LruCache<K, V>

fn from(pairs: Vec<(K, V)>) -> Self

Build an LruCache from a vector of (key, value) pairs.

The cache capacity is set to pairs.len().max(1) so that all pairs fit without eviction.