Struct AsyncKeyedCache 

pub struct AsyncKeyedCache<K, V>
where
    K: Hash + Eq + Clone + Debug,
    V: Clone,
{ /* private fields */ }

A bounded keyed cache where each key has its own async lock.

lookup acquires the key’s lock and returns an AsyncKeyedCacheEntry that holds it for the entry’s lifetime. While the entry is held, get/insert/remove/take operate on that key’s slot atomically with respect to other lookups of the same key; other keys are never blocked.

This encapsulates the common “lock the key, check the cache, maybe fill it, all without racing another filler” pattern in one place, so the lock and the cache can’t drift out of sync.

Implementations

impl<K, V> AsyncKeyedCache<K, V>

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

pub fn new(capacity: usize) -> Self

Create a new keyed cache holding at most capacity entries (LRU eviction).

pub async fn lookup(&self, key: K) -> AsyncKeyedCacheEntry<K, V>

Lock key and return an entry for operating on its cache slot. The key stays locked until the returned entry is dropped; other keys are not blocked.

pub fn purge(&self) -> bool

Clear the cache entries if the cache is not in use Returns true if the cache was cleared Returns false if the cache was not cleared because it is in use

Trait Implementations

impl<K, V> Clone for AsyncKeyedCache<K, V>

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

fn clone(&self) -> AsyncKeyedCache<K, V>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<K, V> Debug for AsyncKeyedCache<K, V>

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

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

Formats the value using the given formatter.