Struct LfuCache 

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

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

Entries with equal frequency are evicted in FIFO order (the entry inserted earlier at that frequency is evicted first).

Type parameters

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

Implementations

impl<K, V> LfuCache<K, V>

where K: Eq + Hash + Clone,

pub fn new(cap: usize) -> Self

Create a new LfuCache with the given capacity.

A capacity of 0 is valid; every insert will immediately be evicted on the next insert.

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

Return the value for key, incrementing its frequency.

If the entry has expired (TTL), it is removed and None is returned without updating frequency or recency.

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

Insert or update key -> value (no TTL).

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

Number of entries currently in the cache.

pub fn is_empty(&self) -> bool

Return true if the cache is empty.

pub fn cap(&self) -> usize

Cache capacity.

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

Read a value without updating frequency or recency.

Returns None if absent or expired.

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

Return true if key is present and not expired.

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

Remove the entry for key, returning its value.

pub fn clear(&mut self)

Remove all entries.

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

Dynamically resize the cache capacity.

If new_cap < current len, entries at min_freq are evicted first (FIFO within that frequency), then the next lowest frequency, etc.

Trait Implementations

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

where K: Eq + Hash + Clone,

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 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 values(&self) -> Vec<&V>

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

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

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