Struct WTinyLfuCache 

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

Window TinyLFU cache with near-optimal hit rates on skewed workloads.

Capacity split

window_cap    = max(1, total_cap / 100)
main_cap      = total_cap - window_cap
protected_cap = main_cap * 4 / 5

Type parameters

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

Implementations

impl<K, V> WTinyLfuCache<K, V>

where K: Eq + Hash + Clone,

pub fn new(total_cap: usize) -> Self

Create a new WTinyLfuCache with the given total capacity.

Minimum capacity is 2.

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

Look up key, updating recency and frequency.

Expired entries are lazily removed and treated as misses.

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

Insert or update key -> value without 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

Total number of live entries.

pub fn is_empty(&self) -> bool

Return true if the cache holds no entries.

pub fn cap(&self) -> usize

Total capacity.

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

Read a value without updating recency or frequency.

Returns None if absent or expired.

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

Return true if key is present and not expired (no recency update).

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

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

pub fn clear(&mut self)

Remove all entries from the cache.

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

Dynamically resize the cache capacity.

Recomputes segment sizes and evicts LRU entries as needed.

Trait Implementations

impl<K, V> Cache<K, V> for WTinyLfuCache<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.