Struct MultiConsumerLruCache 

pub struct MultiConsumerLruCache<K, V, S, H = DefaultHashBuilder>
where
    K: Hash + Eq,
{ /* private fields */ }

Available on crate feature rpc only.

A multi-consumer LRU cache bounded by entry count and estimated payload size.

H hashes the keys of the cached values.

Implementations

impl<K, V, S, H> MultiConsumerLruCache<K, V, S, H>

where K: Hash + Eq, H: BuildHasher,

pub fn new( max_len: u32, max_bytes: usize, cache_id: &str, ) -> MultiConsumerLruCache<K, V, S, H>

where H: Default,

Creates an empty cache with entry and payload byte limits and a metric label.

Setting either limit to zero disables caching, but consumers can still queue requests.

pub fn queue(&mut self, key: K, sender: S) -> bool

Adds the sender to the queue for the given key.

Returns true if this is the first queued sender for the key.

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

Removes consumers for a given key, also removing the key from the cache.

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

Returns a reference to the value and refreshes its recency and idle timestamp.

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

Returns a reference to the value and refreshes its recency using the supplied timestamp.

Use nondecreasing timestamps for lookups and Self::insert_at to keep idle eviction in LRU order.

pub fn insert(&mut self, key: K, value: V) -> bool

where V: InMemorySize,

Inserts a new element, evicting the oldest entries until both limits are satisfied.

Oversized values are rejected without evicting existing entries or queued consumers.

pub fn insert_at(&mut self, key: K, value: V, now: Instant) -> bool

where V: InMemorySize,

Inserts an element using the supplied timestamp, enforcing the same limits as Self::insert.

Use the same nondecreasing timestamps as Self::get_at when batching cache operations.

pub fn shrink_to(&mut self, min_capacity: usize)

Shrinks the capacity of the queue with a lower limit.

pub fn update_cached_metrics(&mut self) -> bool

Publishes the cached count and memory usage gauges if either changed since the last call.

Returns whether the gauges were written, so lookups that only hit the cache cost nothing.

Trait Implementations

impl<K, V, S, H> Debug for MultiConsumerLruCache<K, V, S, H>

where K: Hash + Eq,

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

Formats the value using the given formatter.

Layout

Note: Unable to compute type layout, possibly due to this type having generic parameters. Layout can only be computed for concrete, fully-instantiated types.