Struct TtlCache 

pub struct TtlCache<T> { /* private fields */ }

String-keyed cache where hits and misses expire on independent TTLs.

A TTL of zero disables caching for that outcome kind. lock_for hands out a per-key async mutex so concurrent fetchers of the same key collapse into one upstream request.

Implementations

impl<T: Clone> TtlCache<T>

pub fn new(positive_ttl: Duration, negative_ttl: Duration) -> Self

pub fn set_ttls(&self, positive_ttl: Duration, negative_ttl: Duration)

pub fn positive_ttl(&self) -> Duration

pub fn negative_ttl(&self) -> Duration

pub fn read(&self, key: &str) -> Option<Cached<T>>

Read a live entry, honouring the current TTL configuration.

Expired entries are evicted. Hits are returned only when the positive TTL is non-zero; misses only when the negative TTL is non-zero.

pub fn write_hit(&self, key: String, value: T)

Store a hit under the positive TTL. No-op when the TTL is zero.

pub fn write_miss(&self, key: String, detail: String)

Store a miss under the negative TTL. No-op when the TTL is zero.

pub fn lock_for(&self, key: &str) -> Arc<Mutex<()>>

Get (or create) the in-flight lock for key.

pub fn release_lock(&self, key: &str, lock: &Arc<Mutex<()>>)

Drop the in-flight lock for key once no other fetcher holds it.