Struct Cache 

pub struct Cache<K, V> {
    inner: Cache<K, V>,
    capacity: u64,
    size_registration: Option<CacheSizeRegistration>,
    metrics: Option<Arc<CacheMetrics>>,
}

A weighted memory cache with backend-provided asynchronous load deduplication. Values should be inexpensive to clone, such as Arc<T> or Bytes. Capacity is maintained asynchronously; insertion does not guarantee retention.

Fields

inner: Cache<K, V>

capacity: u64

size_registration: Option<CacheSizeRegistration>

metrics: Option<Arc<CacheMetrics>>

Implementations

impl<K, V> Cache<K, V>

where K: Eq + Hash + Send + Sync + 'static, V: Clone + Send + Sync + 'static,

pub fn new<W, L>(name: &str, capacity: u64, weigher: W, listener: L) -> Self

where W: Fn(&K, &V) -> u32 + Send + Sync + 'static, L: Fn(Arc<K>, V, RemovalCause) + Send + Sync + 'static,

Creates a cache with the caller’s weight and eviction accounting.

pub fn with_metrics(self, metrics: Arc<CacheMetrics>) -> Self

Attaches caller-bound metrics without changing existing hit/miss accounting.

pub fn with_size_metric(self, metric: CacheSizeMetric) -> Self

Samples this cache’s retained weight when the caller collects byte metrics.

pub fn get<'a, Q>( &'a self, key: &'a Q, ) -> impl Future<Output = Option<V>> + Send + 'a

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

Gets a completed value without starting a load.

pub async fn try_get_with<Q, F, E>(&self, key: &Q, load: F) -> Result<V, Arc<E>>

where K: Borrow<Q>, Q: ToOwned<Owned = K> + Hash + Eq + ?Sized, F: Future<Output = Result<V, E>>, E: Send + Sync + 'static,

Shares a successful load among concurrent callers with the same key and error type. Errors are shared with current waiters but are not retained as cached values. Cancelling the active loader lets a remaining caller execute its own loader.

pub async fn insert(&self, key: K, value: V)

Submits a completed value to the cache’s admission and eviction policy.

pub async fn invalidate<Q>(&self, key: &Q)

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

Invalidates a completed entry. This does not cancel a concurrent loader.

pub fn invalidate_if<F>(&self, predicate: F) -> Result<()>

where F: Fn(&K, &V) -> bool + Send + Sync + 'static,

Invalidates completed entries matching a predicate. Pending loaders are not fenced. Physical removal and eviction accounting run asynchronously.

pub fn capacity(&self) -> u64

Returns the configured weight capacity.

pub fn entry_count(&self) -> u64

Returns the approximate number of retained entries.

pub fn weighted_size(&self) -> u64

Returns the approximate total retained weight.

pub async fn run_pending_tasks(&self)

Applies pending admission, eviction, and accounting work.

Trait Implementations

impl<K: Clone, V: Clone> Clone for Cache<K, V>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.