Struct LruCache

pub struct LruCache<K, V, S = DefaultHashBuilder> { /* private fields */ }

A least-recently-used (LRU) Cache with lazy eviction. Each entry maintains an associated ordinal value representing when the entry was last accessed. The cache is allowed to grow up to 2 times specified capacity with no evictions, at which point, the excess entries are evicted based on LRU policy resulting in an amortized O(1) performance.

Implementations

impl<K, V> LruCache<K, V, DefaultHashBuilder>

pub fn new(capacity: usize) -> Self

impl<K, V, S> LruCache<K, V, S>

pub fn with_capacity_and_hasher(capacity: usize, hasher: S) -> Self

pub fn hasher(&self) -> &S

impl<K, V, S> LruCache<K, V, S>

pub fn iter(&self) -> Iter<'_, K, V>

An iterator visiting all key-value pairs in arbitrary order. The iterator element type is (&'a K, &'a V).

pub fn iter_mut(&mut self) -> IterMut<'_, K, V>

An iterator visiting all key-value pairs in arbitrary order, with mutable references to the values. The iterator element type is (&'a K, &'a mut V).

impl<K: Eq + Hash + PartialEq, V, S: BuildHasher> LruCache<K, V, S>

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

Inserts a key-value pair into the cache. If the cache 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. The key is not updated, though; this matters for types that can be == without being identical.

pub fn contains_key<Q>(&self, key: &Q) -> bool

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

Returns true if the cache contains a value for the specified key. Unlike self.get(key).is_some(), this method does not update the LRU ordinal value associated with the entry.

The key may be any borrowed form of the cache’s key type, but Hash and Eq on the borrowed form must match those for the key type.

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

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

Returns a reference to the value corresponding to the key. Updates the LRU ordinal value associated with the entry.

The key may be any borrowed form of the cache’s key type, but Hash and Eq on the borrowed form must match those for the key type.

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

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

Returns a mutable reference to the value corresponding to the key. Updates the LRU ordinal value associated with the entry.

The key may be any borrowed form of the cache’s key type, but Hash and Eq on the borrowed form must match those for the key type.

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

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

Returns the key-value pair corresponding to the supplied key. Updates the LRU ordinal value associated with the entry.

The supplied key may be any borrowed form of the cache’s key type, but Hash and Eq on the borrowed form must match those for the key type.

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

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

Returns a reference to the value corresponding to the key. Unlike get, peek does not updates the LRU ordinal value associated with the entry.

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

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

Returns a mutable reference to the value corresponding to the key. Unlike get_mut, peek_mut does not updates the LRU ordinal value associated with the entry.

The key may be any borrowed form of the cache’s key type, but Hash and Eq on the borrowed form must match those for the key type.

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

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

Returns the key-value pair corresponding to the supplied key. Unlike get_key_value, peek_key_value does not updates the ordinal value associated with the entry.

The supplied key may be any borrowed form of the cache’s key type, but Hash and Eq on the borrowed form must match those for the key type.

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

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

Removes a key from the cache, returning the value at the key if the key was previously in the cache.

The key may be any borrowed form of the cache’s key type, but Hash and Eq on the borrowed form must match those for the key type.

pub fn remove_entry<Q>(&mut self, key: &Q) -> Option<(K, V)>

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

Removes a key from the cache, returning the stored key and value if the key was previously in the cache.

The key may be any borrowed form of the cache’s key type, but Hash and Eq on the borrowed form must match those for the key type.

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

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

Synonym for remove.

pub fn pop_entry<Q>(&mut self, key: &Q) -> Option<(K, V)>

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

Synonym for remove_entry.

impl<K, V, S> LruCache<K, V, S>

pub fn len(&self) -> usize

Returns the number of elements in the cache.

pub fn is_empty(&self) -> bool

Returns true if the cache contains no entries.

pub fn clear(&mut self)

Clears the cache, removing all key-value pairs.

pub fn retain<F>(&mut self, f: F)

where F: FnMut(&K, &mut V) -> bool,

Retains only the elements specified by the predicate. In other words, remove all pairs (k, v) for which f(&k, &mut v) returns false. The elements are visited in unsorted (and unspecified) order.

impl<K: Clone + Eq + Hash + PartialEq, V: Clone, S: Clone + BuildHasher> LruCache<K, V, S>

pub fn clone(&mut self) -> Self

Clones the LruCache.

Note: &mut self is necessary to prevent interior mutation from concurrent access while the cache is cloned.

Trait Implementations

impl<K: Debug, V: Debug, S: Debug> Debug for LruCache<K, V, S>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a, K, V, S> IntoIterator for &'a LruCache<K, V, S>

type Item = (&'a K, &'a V)

The type of the elements being iterated over.

type IntoIter = Iter<'a, K, V>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Iter<'a, K, V>

Creates an iterator from a value.

impl<'a, K, V, S> IntoIterator for &'a mut LruCache<K, V, S>

type Item = (&'a K, &'a mut V)

The type of the elements being iterated over.

type IntoIter = IterMut<'a, K, V>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IterMut<'a, K, V>

Creates an iterator from a value.

impl<K, V, S> IntoIterator for LruCache<K, V, S>

type Item = (K, V)

The type of the elements being iterated over.

type IntoIter = IntoIter<K, V>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IntoIter<K, V>

Creates an iterator from a value.