Struct MemoryCache 

pub struct MemoryCache { /* private fields */ }

In-memory LRU cache with per-entry time-to-live.

Cloning shares the same map. A poisoned mutex is recovered (into_inner) so a panic in one caller does not disable the cache. capacity of 0 is treated as 1. Retained key/value bytes are bounded by MemoryCacheLimits; writes beyond admission limits fail explicitly. Expiry is lazy on access; pressure evicts LRU entries without full scans.

set_if_absent_with_ttl is atomic: the check, deadline and insertion happen under one lock acquisition. TTLs round up to whole milliseconds and zero is CacheError::InvalidTtl.

increment matches Redis INCRBY: a missing or expired key starts at 0, the stored form is a decimal integer, and a non-integer value is CacheError::NotInteger.

Implementations

impl MemoryCache

pub fn new(capacity: usize) -> Self

Bound the cache to at most capacity live entries (minimum 1).

pub fn with_limits(n: usize, lim: MemoryCacheLimits) -> Result<Self, CacheError>

Configure entry count and retained key/value byte budgets.

Args: n: Maximum entry count, with zero treated as one. lim: Positive key/value/total byte limits.

Returns: Cache with size-aware LRU eviction and hard write admission.

Errors

Invalid zero limits or key/value maxima above the total budget.

pub fn stored_bytes(&self) -> usize

Retained key and value bytes currently counted against MemoryCacheLimits::max_total_bytes.

Expired entries still count until they are touched or evicted.

Trait Implementations

impl Cache for MemoryCache

fn get<'life0, 'life1, 'async_trait>( &'life0 self, key: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<Vec<u8>>, CacheError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Fetch key. Ok(None) when the key is missing or has expired.

fn set<'life0, 'life1, 'async_trait>( &'life0 self, key: &'life1 str, value: Vec<u8>, ttl: Option<Duration>, ) -> Pin<Box<dyn Future<Output = Result<(), CacheError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Store value at key. ttl of None means the entry does not expire.

fn set_if_absent<'life0, 'life1, 'async_trait>( &'life0 self, key: &'life1 str, v: Vec<u8>, ) -> Pin<Box<dyn Future<Output = Result<bool, CacheError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Atomically create a nonexpiring entry only when no live entry exists.

fn set_if_absent_with_ttl<'life0, 'life1, 'async_trait>( &'life0 self, key: &'life1 str, value: Vec<u8>, ttl: Duration, ) -> Pin<Box<dyn Future<Output = Result<bool, CacheError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Atomically create an expiring entry only when no live entry exists.

fn delete<'life0, 'life1, 'async_trait>( &'life0 self, key: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<bool, CacheError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Remove key. Ok(true) when a live entry was removed.

fn increment<'life0, 'life1, 'async_trait>( &'life0 self, key: &'life1 str, by: i64, ) -> Pin<Box<dyn Future<Output = Result<i64, CacheError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Add by to the integer stored at key (Redis INCRBY).

fn increment_with_expiry<'life0, 'life1, 'async_trait>( &'life0 self, key: &'life1 str, by: i64, ttl: Duration, ) -> Pin<Box<dyn Future<Output = Result<i64, CacheError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Atomically add by to a counter and give it an expiry when it has none.

fn clear<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<(), CacheError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Remove every entry this cache is responsible for.

fn admit_marker<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, req: &'life1 AdmitMarker<'life2>, ) -> Pin<Box<dyn Future<Output = Result<Admission, CacheError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Admit a route-cache generation marker (provided; overriding is an optimisation, never a requirement).

fn invalidate_marker<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, marker: &'life1 str, epoch_key: &'life2 str, epoch: &'life3 [u8], ttl: Duration, ) -> Pin<Box<dyn Future<Output = Result<(), CacheError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Replace the invalidation epoch and delete a marker (provided).

impl Clone for MemoryCache

fn clone(&self) -> MemoryCache

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for MemoryCache

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

Formats the value using the given formatter.