Struct CacheManager 

pub struct CacheManager<B, S = JsonSerializer, M = NoopMetrics>
where
    B: CacheBackend + DependencyBackend,
    S: Serializer,
    M: CacheMetrics,
{ /* private fields */ }

High-level cache manager with pluggable serialization and metrics

Generic over:

• B: The cache backend (Memory, Redis, MultiTier)
• S: The serializer (JSON, MessagePack, Bincode)
• M: The metrics collector

Implementations

impl<B: CacheBackend + DependencyBackend> CacheManager<B, JsonSerializer, NoopMetrics>

pub fn new(backend: B) -> Self

Create a new CacheManager with default JSON serializer and no metrics

pub fn with_config(backend: B, config: CacheManagerConfig) -> Self

Create with custom config

impl<B, S, M> CacheManager<B, S, M>

where B: CacheBackend + DependencyBackend, S: Serializer, M: CacheMetrics,

pub fn with_serializer_and_metrics( backend: B, serializer: S, metrics: M, config: CacheManagerConfig, ) -> Self

Create a CacheManager with custom serializer and metrics

pub fn group(&self, namespace: impl Into<String>) -> CacheGroup<'_, B, S, M>

Create a namespaced cache group

pub async fn get<T>(&self, key: impl CacheKey) -> Result<CacheResult<T>>

where T: DeserializeOwned,

Get a value from cache

pub async fn set<T>( &self, key: impl CacheKey, value: T, options: impl Into<CacheOptions>, ) -> Result<()>

where T: Serialize,

Set a value in cache

pub async fn get_or_compute<T, F, Fut>( &self, key: impl CacheKey, computer: F, options: Option<CacheOptions>, ) -> Result<CacheResult<T>>

where T: Serialize + DeserializeOwned + Send + 'static, F: FnOnce() -> Fut + Send + 'static, Fut: Future<Output = Result<T>> + Send + 'static,

Get a value from cache, or compute it if missing (coalesced)

pub async fn delete(&self, key: impl CacheKey) -> Result<bool>

Delete a key from cache (with cascade invalidation)

pub async fn invalidate(&self, key: impl CacheKey) -> Result<u64>

Invalidate a key and all its dependents (cascade invalidation)

Returns the number of entries invalidated

pub async fn exists(&self, key: impl CacheKey) -> Result<bool>

Check if key exists in cache

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

Clear all entries from cache

pub async fn stats(&self) -> Result<CacheStats>

Get cache statistics

pub async fn len(&self) -> Result<usize>

Get the number of entries

pub async fn is_empty(&self) -> Result<bool>

Check if cache is empty

impl<B, S, M> CacheManager<B, S, M>

where B: CacheBackend + DependencyBackend + TaggableBackend, S: Serializer, M: CacheMetrics,

pub async fn delete_by_tag(&self, tag: &str) -> Result<u64>

Delete all entries with a specific tag

pub async fn get_keys_by_tag(&self, tag: &str) -> Result<Vec<String>>

Get all keys by tag

Trait Implementations

impl<B, S, M> CacheManagerReadThroughExt<B, S, M> for CacheManager<B, S, M>

where B: CacheBackend + DependencyBackend, S: Serializer, M: CacheMetrics,

fn read_through<K, V, L>( self, loader: L, options: CacheOptions, ) -> ReadThroughCache<B, S, M, K, V, L>

where L: Loader<K, V>, K: CacheKey + Clone + Send + Sync + 'static, V: Serialize + DeserializeOwned + Send + Sync + Clone + 'static,

impl<B, S, M> Clone for CacheManager<B, S, M>

where B: CacheBackend + DependencyBackend, S: Serializer, M: CacheMetrics,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.