Struct GenericCache

pub struct GenericCache { /* private fields */ }

Generic cache for storing arbitrary data

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 fn get_path(&self, key: &str) -> PathBuf

Get the full path for a cache key

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 delete(&self, key: &str) -> Result<()>

Delete a cache entry

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

Clear all entries in this cache

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.