Struct GenericCache 

pub struct GenericCache { /* private fields */ }

Generic cache for storing arbitrary data with LRU eviction

Implementations

impl GenericCache

pub async fn new() -> Result<Self>

Create a new generic cache with the default directory

pub async fn with_subdirectory(subdir: &str) -> Result<Self>

Create a new generic cache with a custom subdirectory

pub async fn with_limits( max_size_bytes: Option<u64>, max_entries: Option<usize>, ) -> Result<Self>

Create a new cache with size and entry limits

pub async fn with_config( subdir: Option<&str>, max_size_bytes: Option<u64>, max_entries: Option<usize>, ) -> Result<Self>

Create a cache with full configuration

pub async fn with_config_and_path( base_dir: PathBuf, max_size_bytes: Option<u64>, max_entries: Option<usize>, stats: Option<Arc<CacheStats>>, ) -> Result<Self>

Create a cache with full configuration and custom path

pub fn get_path(&self, key: &str) -> PathBuf

Get the full path for a cache key

pub fn stats(&self) -> Arc<CacheStats>

Get cache statistics

pub fn current_size(&self) -> u64

Get current cache size in bytes

pub fn current_entries(&self) -> usize

Get current number of entries

pub fn config(&self) -> (Option<u64>, Option<usize>)

Get cache configuration

pub async fn exists(&self, key: &str) -> bool

Check if a cache entry exists

pub async fn write(&self, key: &str, data: &[u8]) -> Result<()>

Write data to the cache

pub async fn read(&self, key: &str) -> Result<Vec<u8>>

Read data from the cache

pub async fn read_to_writer<W>(&self, key: &str, writer: W) -> Result<u64>

where W: AsyncWrite + Unpin,

Stream data from cache to a writer (memory-efficient for large cached files)

pub async fn delete(&self, key: &str) -> Result<()>

Delete a cache entry

pub async fn clear(&self) -> Result<()>

Clear all entries in this cache

pub async fn warm_cache(&self, keys: &[String]) -> Result<()>

Warm cache with a list of keys by pre-loading them into LRU order

pub fn get_lru_keys(&self) -> Vec<String>

Get LRU ordered list of cache keys (least recently used first)

pub fn get_mru_keys(&self, limit: usize) -> Vec<String>

Get most recently used keys (up to limit)

pub fn get_entry_info(&self, key: &str) -> Option<(u64, u64, u64)>

Get cache entry metadata

pub fn base_dir(&self) -> &Path

Get the base directory of this cache

pub async fn write_batch(&self, entries: &[(String, Vec<u8>)]) -> Result<()>

Write multiple entries to the cache in parallel

This is more efficient than calling write() multiple times sequentially.

pub async fn read_batch(&self, keys: &[String]) -> Vec<Result<Vec<u8>>>

Read multiple entries from the cache in parallel

Returns a vector of results in the same order as the input keys. Failed reads will be represented as Err values in the vector.

pub async fn delete_batch(&self, keys: &[String]) -> Result<()>

Delete multiple entries from the cache in parallel

This is more efficient than calling delete() multiple times sequentially.

pub async fn exists_batch(&self, keys: &[String]) -> Vec<bool>

Check existence of multiple entries in parallel

Returns a vector of booleans in the same order as the input keys.

pub async fn read_streaming<W>(&self, key: &str, writer: W) -> Result<u64>

where W: AsyncWrite + Unpin,

Stream data from cache to a writer

This is more memory-efficient than read() for large files.

pub async fn write_streaming<R>(&self, key: &str, reader: R) -> Result<u64>

where R: AsyncRead + Unpin,

Stream data from a reader to cache

This is more memory-efficient than write() for large data.

pub async fn read_chunked<F>(&self, key: &str, callback: F) -> Result<u64>

where F: FnMut(&[u8]) -> Result<()>,

Process cache data in chunks without loading it all into memory

The callback is called for each chunk read from the cache file.

pub async fn write_chunked<I>(&self, key: &str, chunks: I) -> Result<u64>

where I: IntoIterator<Item = Result<Vec<u8>>>,

Write data to cache in chunks from an iterator

This allows writing large data without keeping it all in memory.

pub async fn copy(&self, from_key: &str, to_key: &str) -> Result<u64>

Copy data between cache entries efficiently

This is more efficient than read + write for large files.

pub async fn size(&self, key: &str) -> Result<u64>

Get the size of a cache entry without reading it

pub async fn read_streaming_buffered<W>( &self, key: &str, writer: W, buffer_size: usize, ) -> Result<u64>

where W: AsyncWrite + Unpin,

Stream data from cache with a custom buffer size

Useful for optimizing I/O based on expected data size.