Struct BlockCache 

pub struct BlockCache { /* private fields */ }

LRU cache for blocks

This cache uses a Least Recently Used eviction policy to maintain a bounded set of frequently accessed blocks in memory. It’s thread-safe and can be shared across multiple threads.

Example

use ipfrs_core::{BlockCache, Block};
use bytes::Bytes;

let cache = BlockCache::new(1024 * 1024, Some(100)); // 1MB or 100 blocks max

let block = Block::new(Bytes::from_static(b"cached data")).unwrap();
cache.insert(block.clone());

assert!(cache.get(block.cid()).is_some());

Implementations

impl BlockCache

pub fn new(max_size_bytes: u64, max_blocks: Option<usize>) -> Self

Create a new block cache

Arguments

• max_size_bytes - Maximum total size of cached blocks in bytes
• max_blocks - Optional maximum number of blocks (None = unlimited)

Example

use ipfrs_core::BlockCache;

// Cache up to 10MB of blocks
let cache = BlockCache::new(10 * 1024 * 1024, None);

// Cache up to 1MB or 100 blocks, whichever limit is hit first
let cache2 = BlockCache::new(1024 * 1024, Some(100));

pub fn insert(&self, block: Block)

Insert a block into the cache

If the cache is full, the least recently used block will be evicted.

Example

use ipfrs_core::{BlockCache, Block};
use bytes::Bytes;

let cache = BlockCache::new(1024 * 1024, None);
let block = Block::new(Bytes::from_static(b"data")).unwrap();

cache.insert(block);

pub fn get(&self, cid: &Cid) -> Option<Block>

Get a block from the cache

Returns Some(block) if found, None otherwise. Updates the access time for LRU tracking.

Example

use ipfrs_core::{BlockCache, Block};
use bytes::Bytes;

let cache = BlockCache::new(1024 * 1024, None);
let block = Block::new(Bytes::from_static(b"data")).unwrap();
let cid = *block.cid();

cache.insert(block);

if let Some(cached) = cache.get(&cid) {
    assert_eq!(cached.len(), 4);
}

pub fn contains(&self, cid: &Cid) -> bool

Check if the cache contains a block with the given CID

This does not update LRU access time.

pub fn remove(&self, cid: &Cid) -> Option<Block>

Remove a block from the cache

pub fn clear(&self)

Clear all blocks from the cache

pub fn stats(&self) -> CacheStats

Get the current cache statistics

Example

use ipfrs_core::{BlockCache, Block};
use bytes::Bytes;

let cache = BlockCache::new(1024 * 1024, None);
let block = Block::new(Bytes::from_static(b"data")).unwrap();

cache.insert(block.clone());
cache.get(block.cid()); // Hit
cache.get(block.cid()); // Another hit

let stats = cache.stats();
assert_eq!(stats.hits, 2);
assert_eq!(stats.misses, 0);

pub fn len(&self) -> usize

Get the number of blocks currently in the cache

pub fn is_empty(&self) -> bool

Check if the cache is empty

pub fn size(&self) -> u64

Get the current total size of cached blocks in bytes

pub fn max_size(&self) -> u64

Get the maximum cache size in bytes

pub fn max_blocks(&self) -> Option<usize>

Get the maximum number of blocks (if configured)

Trait Implementations

impl Clone for BlockCache

fn clone(&self) -> BlockCache

Returns a duplicate of the value.

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

Performs copy-assignment from source.