Struct TtlCache 

pub struct TtlCache<K, V> { /* private fields */ }

Thread-safe TTL cache with LRU eviction.

The cache is keyed by any Eq + Hash + Clone type and stores any Clone value. Each insert takes a per-entry TTL. Entries expire on the first get/insert that observes the expired deadline; an explicit TtlCache::prune is also provided for bulk collection.

Implementations

impl<K, V> TtlCache<K, V>

where K: Eq + Hash + Clone, V: Clone,

pub fn new(capacity: NonZeroUsize) -> Self

Create a new cache with the given capacity, backed by TokioClock.

Capacity is a non-zero usize because a zero-capacity cache is degenerate (every insert would immediately evict itself).

pub fn with_clock(capacity: NonZeroUsize, clock: Arc<dyn Clock>) -> Self

Create a cache backed by a custom Clock implementation.

pub fn capacity(&self) -> usize

Configured maximum number of live entries.

pub fn len(&self) -> usize

Current number of entries in the cache (may include not-yet-pruned expired entries).

pub fn is_empty(&self) -> bool

Returns true when the cache holds no entries.

pub fn get(&self, key: &K) -> Option<V>

Look up key. Returns Some(value) on cache hit (and bumps the entry’s recency); None on miss or expired entry. Expired entries are removed on observation.

pub fn insert(&self, key: K, value: V, ttl: Duration)

Insert value under key with the given ttl. If the cache is at capacity, evicts the least recently used live entry first.

pub fn prune(&self) -> usize

Remove every entry whose TTL has expired relative to the clock’s current “now”. Returns the number of entries removed.

pub fn clear(&self)

Remove all entries.