Struct ConcurrentLfudaCache 

pub struct ConcurrentLfudaCache<K, V, S = DefaultHashBuilder> { /* private fields */ }

A thread-safe LFUDA cache with segmented storage for high concurrency.

Implementations

impl<K, V> ConcurrentLfudaCache<K, V, DefaultHashBuilder>

where K: Hash + Eq + Clone + Send, V: Clone + Send,

pub fn init( config: ConcurrentLfudaCacheConfig, hasher: Option<DefaultHashBuilder>, ) -> Self

Creates a new concurrent LFUDA cache from a configuration.

This is the recommended way to create a concurrent LFUDA cache.

Arguments

• config - The cache configuration specifying capacity, segments, etc.
• hasher - Optional custom hash builder. If None, uses the default.

impl<K, V, S> ConcurrentLfudaCache<K, V, S>

where K: Hash + Eq + Clone + Send, V: Clone + Send, S: BuildHasher + Clone + Send,

pub fn capacity(&self) -> usize

Returns the total capacity across all segments.

pub fn segment_count(&self) -> usize

Returns the number of segments in the cache.

pub fn len(&self) -> usize

Returns the total number of entries across all segments.

pub fn is_empty(&self) -> bool

Returns true if the cache contains no entries.

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

where K: Borrow<Q>, Q: ?Sized + Hash + Eq,

Gets a value from the cache.

This clones the value to avoid holding the lock. For zero-copy access, use get_with() instead.

pub fn get_with<Q, F, R>(&self, key: &Q, f: F) -> Option<R>

where K: Borrow<Q>, Q: ?Sized + Hash + Eq, F: FnOnce(&V) -> R,

Gets a value and applies a function to it while holding the lock.

This is more efficient than get() when you only need to read from the value, as it avoids cloning.

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

Inserts a key-value pair into the cache.

If the cache is at capacity, the entry with lowest priority (frequency + age) is evicted.

pub fn put_with_size(&self, key: K, value: V, size: u64) -> Option<(K, V)>

Inserts a key-value pair with explicit size tracking.

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

where K: Borrow<Q>, Q: ?Sized + Hash + Eq,

Removes a key from the cache, returning the value if it existed.

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

where K: Borrow<Q>, Q: ?Sized + Hash + Eq,

Returns true if the cache contains the specified key.

pub fn clear(&self)

Clears all entries from the cache.

pub fn current_size(&self) -> u64

Returns the current total size of cached content across all segments.

pub fn max_size(&self) -> u64

Returns the maximum content size the cache can hold across all segments.

Trait Implementations

impl<K, V, S> CacheMetrics for ConcurrentLfudaCache<K, V, S>

where K: Hash + Eq + Clone + Send, V: Clone + Send, S: BuildHasher + Clone + Send,

fn metrics(&self) -> BTreeMap<String, f64>

Returns all metrics as key-value pairs in deterministic order

fn algorithm_name(&self) -> &'static str

Algorithm name for identification

impl<K, V, S> Debug for ConcurrentLfudaCache<K, V, S>

where K: Hash + Eq + Clone + Send, V: Clone + Send, S: BuildHasher + Clone + Send,

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

Formats the value using the given formatter.

impl<K: Send, V: Send, S: Send> Send for ConcurrentLfudaCache<K, V, S>

impl<K: Send, V: Send, S: Send + Sync> Sync for ConcurrentLfudaCache<K, V, S>