Struct CachedBlockStore 

pub struct CachedBlockStore<S: BlockStore> { /* private fields */ }

A two-level cache that wraps any BlockStore (L2) with an in-process LRU cache (L1).

Cache behaviour

Operation	L1 action	L2 action
put	insert (if ≤ max_block_bytes)	always written
get hit	return from L1	not consulted
get miss	populate on L2 hit	queried; result promoted to L1
delete	evict	deleted
has	cheap presence check	consulted only on L1 miss

Implementations

impl<S: BlockStore> CachedBlockStore<S>

pub fn new(inner: S, config: CacheConfig) -> Self

Construct a new CachedBlockStore with explicit configuration.

pub fn with_default_config(inner: S) -> Self

Construct a new CachedBlockStore using CacheConfig::default.

pub fn stats(&self) -> CacheStatsSnapshot

Return a point-in-time snapshot of cache statistics.

pub fn cache_size(&self) -> usize

Current number of entries in L1.

pub fn invalidate(&self, cid: &Cid)

Remove a single CID from L1 (does not affect L2).

pub fn clear_cache(&self)

Evict all entries from L1 (does not affect L2).

pub fn inner(&self) -> &S

Borrow the underlying backing store.

Trait Implementations

impl<S: BlockStore> BlockStore for CachedBlockStore<S>

fn put<'life0, 'life1, 'async_trait>( &'life0 self, block: &'life1 Block, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Write to L2 first, then promote to L1 if the block is small enough.

fn get<'life0, 'life1, 'async_trait>( &'life0 self, cid: &'life1 Cid, ) -> Pin<Box<dyn Future<Output = Result<Option<Block>>> + Send + 'async_trait>>

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

Check L1 first; on miss fetch from L2 and populate L1.

fn has<'life0, 'life1, 'async_trait>( &'life0 self, cid: &'life1 Cid, ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>

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

has() checks L1 (cheap) then L2.

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

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

Remove from L1 and L2.

fn list_cids(&self) -> Result<Vec<Cid>>

List all CIDs in the store

fn len(&self) -> usize

Get number of blocks

fn is_empty(&self) -> bool

Check if store is empty

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

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

Flush any pending writes

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

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

Close the store and release resources

fn get_many<'life0, 'life1, 'async_trait>( &'life0 self, cids: &'life1 [Cid], ) -> Pin<Box<dyn Future<Output = Result<Vec<Option<Block>>>> + Send + 'async_trait>>

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

Retrieve multiple blocks

fn put_many<'life0, 'life1, 'async_trait>( &'life0 self, blocks: &'life1 [Block], ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Store multiple blocks atomically

fn has_many<'life0, 'life1, 'async_trait>( &'life0 self, cids: &'life1 [Cid], ) -> Pin<Box<dyn Future<Output = Result<Vec<bool>>> + Send + 'async_trait>>

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

Check if multiple blocks exist

fn delete_many<'life0, 'life1, 'async_trait>( &'life0 self, cids: &'life1 [Cid], ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Delete multiple blocks