Struct Cache

pub struct Cache<K, V, S = RandomState> { /* private fields */ }

Highly performant, thread-safe cache with a focus on simplicity.

It implements the S3-FIFO eviction algorithm as specified in FIFO Queues are All You Need for Cache Eviction. The cache is divided into multiple shards to reduce contention during concurrent access. This crate does not use any unsafe code.

Wrap the cache in a std::sync::Arc to share it between threads. Both reads and writes only require shared references to the cache.

Implementations

impl<K, V> Cache<K, V, RandomState>

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

pub fn with_capacity(capacity: usize) -> Cache<K, V, RandomState>

Creates a new cache with at least the specified capacity.

The actual capacity may be slightly higher due to sharding and rounding.

impl<K, V, S> Cache<K, V, S>

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

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

Inserts a key-value pair into the cache.

If the cache did not have this key present, None is returned.

If the cache did have this key present, the value is updated, and the old value is returned.

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

where K: Borrow<Q>, Q: ?Sized + Hash + Eq,

Returns the value corresponding to the key.

This method clones the value when returning the item. Consider wrapping your values in std::sync::Arc if cloning is too expensive for you use-case.

impl<K, V, S> Cache<K, V, S>

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

pub fn with_capacity_and_hasher( capacity: usize, hash_builder: S, ) -> Cache<K, V, S>

Creates a new cache with the at least the specified capacity, using hasher to hash the keys.

The actual capacity may be slightly higher due to sharding and rounding.