Struct MokaCacheBackend 

pub struct MokaCacheBackend { /* private fields */ }

Default CacheBackend backed by a moka cache.

Nonzero capacities provide weighted eviction and concurrent-load deduplication. A zero capacity invokes each loader independently without caching.

Implementations

impl MokaCacheBackend

pub fn with_capacity(capacity: usize) -> Self

pub fn no_cache() -> Self

pub fn capacity(&self) -> usize

Configured weighted capacity in bytes.

Trait Implementations

impl CacheBackend for MokaCacheBackend

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

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

Moka does not count contains_key as a read: the entry’s popularity estimate and recency order stay unchanged.

fn get_resident<'life0, 'life1, 'async_trait>( &'life0 self, key: &'life1 InternalCacheKey, ) -> Pin<Box<dyn Future<Output = Option<CacheEntry>> + Send + 'async_trait>>

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

Look up RAM only, without reading or promoting a persistent entry. Backends without a resident lookup return a miss safely.

fn get<'life0, 'life1, 'async_trait>( &'life0 self, key: &'life1 InternalCacheKey, _codec: Option<CacheCodec>, ) -> Pin<Box<dyn Future<Output = Option<CacheEntry>> + Send + 'async_trait>>

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

Look up an entry by its key.

fn insert<'life0, 'life1, 'async_trait>( &'life0 self, key: &'life1 InternalCacheKey, entry: CacheEntry, size_bytes: usize, _codec: Option<CacheCodec>, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

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

Store an entry. size_bytes is used for eviction accounting.

fn get_or_insert<'a, 'life0, 'life1, 'async_trait>( &'life0 self, key: &'life1 InternalCacheKey, loader: Pin<Box<dyn Future<Output = Result<(CacheEntry, usize)>> + Send + 'a>>, _codec: Option<CacheCodec>, ) -> Pin<Box<dyn Future<Output = Result<(CacheEntry, bool)>> + Send + 'async_trait>>

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

Get an existing entry or compute it from loader.

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

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

Remove all entries.

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

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

Number of entries currently stored (may flush pending operations).

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

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

Total weighted size in bytes of all stored entries (may flush pending operations).

fn capacity_bytes(&self) -> Option<usize>

Weighted capacity in bytes, or None when the backend has no fixed capacity or cannot report it. Lets callers skip loading entries that could never be retained.

fn approx_num_entries(&self) -> usize

Approximate number of entries, callable from synchronous contexts. Backends that cannot provide this cheaply should return 0.

fn approx_size_bytes(&self) -> usize

Approximate weighted size in bytes, callable from synchronous contexts. Used as a DeepSizeOf fallback when exact entry traversal is unavailable. Backends that cannot provide this cheaply should return 0.

fn deep_size_of_entries( &self, context: &mut Context, size_of_entry: &dyn Fn(&CacheEntry, &mut Context) -> Option<usize>, ) -> Option<usize>

Computes the size of the entries currently held in memory.

fn peek_tier<'life0, 'life1, 'async_trait>( &'life0 self, key: &'life1 InternalCacheKey, ) -> Pin<Box<dyn Future<Output = CacheTier> + Send + 'async_trait>>

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

Predict which tier would serve a read of key, without reading the entry or counting as an access, so the check changes neither what the backend evicts next nor its hit statistics. The default knows RAM only, through peek_resident, and reports every other entry as CacheTier::Absent; backends with a local tier below RAM override it.

fn plane_admission_gated(&self) -> bool

Whether layered index planes should gate lower-plane RAM admission on their sign plane being resident. Backends that admit plane entries through their ordinary policy return false, so lower planes are loaded and admitted like any other entry.

fn get_without_promotion<'life0, 'life1, 'async_trait>( &'life0 self, key: &'life1 InternalCacheKey, _codec: Option<CacheCodec>, ) -> Pin<Box<dyn Future<Output = Option<CacheEntry>> + Send + 'async_trait>>

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

Read an entry without admitting a persistent hit into RAM. Backends without this capability safely fall back to resident entries.

fn get_rows<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _key: &'life1 InternalCacheKey, _rows: &'life2 [u32], _codec: Option<CacheCodec>, ) -> Pin<Box<dyn Future<Output = Option<CacheEntry>> + Send + 'async_trait>>

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

Gather selected rows from persistent storage, without RAM admission.

impl Debug for MokaCacheBackend

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

Formats the value using the given formatter.