Struct CacheConfigBuilder 

pub struct CacheConfigBuilder<Req, K> { /* private fields */ }

Builder for configuring and constructing a cache.

Implementations

impl<Req, K> CacheConfigBuilder<Req, K>

where K: Hash + Eq + Clone + Send + 'static,

pub fn new() -> Self

Creates a new builder with default values.

pub fn max_size(self, size: usize) -> Self

Sets the maximum number of entries in the cache.

Default: 100

pub fn ttl(self, ttl: Duration) -> Self

Sets the time-to-live for cached entries.

If set, entries will expire after the specified duration. Default: None (no expiration)

pub fn key_extractor<F>(self, f: F) -> Self

where F: Fn(&Req) -> K + Send + Sync + 'static,

Sets the function that extracts a cache key from a request.

This function must be provided before building.

pub fn name(self, name: impl Into<String>) -> Self

Sets the name of this cache instance for observability.

Default: "<unnamed>"

pub fn on_hit<F>(self, f: F) -> Self

where F: Fn() + Send + Sync + 'static,

Registers a callback when a cache hit occurs.

A cache hit occurs when a requested entry is found in the cache and has not expired.

Callback Signature

Fn() - Called with no parameters when a cache hit is detected.

Example

use tower_resilience_cache::CacheConfig;
use std::sync::atomic::{AtomicUsize, Ordering};
use std::sync::Arc;

#[derive(Clone, Hash, Eq, PartialEq)]
struct Request {
    id: String,
}

let hit_count = Arc::new(AtomicUsize::new(0));
let counter = Arc::clone(&hit_count);

let config = CacheConfig::<Request, String>::builder()
    .key_extractor(|req| req.id.clone())
    .on_hit(move || {
        let count = counter.fetch_add(1, Ordering::SeqCst);
        println!("Cache hit #{}", count + 1);
    })
    .build();

pub fn on_miss<F>(self, f: F) -> Self

where F: Fn() + Send + Sync + 'static,

Registers a callback when a cache miss occurs.

A cache miss occurs when a requested entry is not found in the cache or has expired. The underlying service will be called to fetch the value, which will then be cached.

Callback Signature

Fn() - Called with no parameters when a cache miss is detected.

Example

use tower_resilience_cache::CacheConfig;
use std::sync::atomic::{AtomicUsize, Ordering};
use std::sync::Arc;

#[derive(Clone, Hash, Eq, PartialEq)]
struct Request {
    id: String,
}

let miss_count = Arc::new(AtomicUsize::new(0));
let counter = Arc::clone(&miss_count);

let config = CacheConfig::<Request, String>::builder()
    .key_extractor(|req| req.id.clone())
    .on_miss(move || {
        let count = counter.fetch_add(1, Ordering::SeqCst);
        println!("Cache miss #{} - fetching from service", count + 1);
    })
    .build();

pub fn on_eviction<F>(self, f: F) -> Self

where F: Fn() + Send + Sync + 'static,

Registers a callback when an entry is evicted from the cache.

Eviction occurs when:

• The cache reaches its maximum size and needs to make room for new entries
• An entry expires due to TTL (time-to-live) configuration

Callback Signature

Fn() - Called with no parameters when a cache eviction occurs.

Example

use tower_resilience_cache::CacheConfig;
use std::sync::atomic::{AtomicUsize, Ordering};
use std::sync::Arc;
use std::time::Duration;

#[derive(Clone, Hash, Eq, PartialEq)]
struct Request {
    id: String,
}

let eviction_count = Arc::new(AtomicUsize::new(0));
let counter = Arc::clone(&eviction_count);

let config = CacheConfig::<Request, String>::builder()
    .key_extractor(|req| req.id.clone())
    .max_size(100)
    .ttl(Duration::from_secs(300))
    .on_eviction(move || {
        let count = counter.fetch_add(1, Ordering::SeqCst);
        println!("Entry evicted (total: {})", count + 1);
    })
    .build();

pub fn build(self) -> CacheLayer<Req, K>

Builds the cache layer.

Panics

Panics if key_extractor was not set.

Trait Implementations

impl<Req, K> Default for CacheConfigBuilder<Req, K>

where K: Hash + Eq + Clone + Send + 'static,

fn default() -> Self

Returns the “default value” for a type.