Struct SmallLruCache 

pub struct SmallLruCache<K, V, const N: usize, I: IndexType = u8, S = HeaplessBTreeLruCache<K, V, N, I>>
where
    S: AnyLruCache<K, V>,
{ /* private fields */ }

A structure representing SmallLruCache.

This LRU cache limits its entries natively using a stack layout up to size N. Beyond N, operations will cause the cache to spill transparently into a heap allocated lru::LruCache.

Implementations

impl<K, V, const N: usize, I, S> SmallLruCache<K, V, N, I, S>

where K: Hash + Eq + Ord + Clone, I: IndexType, S: AnyLruCache<K, V>,

pub fn len(&self) -> usize

Returns the number of key-value pairs currently in the cache.

pub fn is_empty(&self) -> bool

Returns true if the cache is empty.

pub fn capacity(&self) -> NonZeroUsize

Returns the maximum capacity of the cache.

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

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

Returns a reference to the value corresponding to the key, moving it to the MRU position.

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

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

Returns a mutable reference to the value corresponding to the key, moving it to the MRU position.

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

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

Returns a reference to the value corresponding to the key without updating the LRU state.

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

Pushes a key-value pair into the cache. If the key already exists, updates the value and returns it.

If the stack capacity N is exceeded during put, this will transparently allocate a lru::LruCache and spill all elements to the heap.

pub fn clear(&mut self)

Clears the cache, removing all key-value pairs.

pub fn is_on_stack(&self) -> bool

Returns true if this cache is currently allocated entirely on the stack.

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

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

Returns true if the cache contains a value for the specified key.

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

Pushes a key-value pair into the cache. If the key already exists, updates the value. If pushing causes the capacity to be exceeded, returns the evicted LRU pair.

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

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

Removes and returns the value corresponding to the key from the cache.

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

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

Removes and returns the key-value pair corresponding to the key from the cache.

pub fn pop_lru(&mut self) -> Option<(K, V)>

Removes and returns the Least Recently Used (LRU) key-value pair.

pub fn promote<Q>(&mut self, key: &Q)

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

Explictly promotes the corresponding key to the Most Recently Used (MRU) position.

pub fn demote<Q>(&mut self, key: &Q)

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

Explicitly demotes the corresponding key to the Least Recently Used (LRU) position.

pub fn peek_lru(&self) -> Option<(&K, &V)>

Returns references to the Least Recently Used (LRU) key-value pair without removing it.

pub fn resize(&mut self, cap: NonZeroUsize)

Resizes the cache to a new maximum capacity. If the new capacity exceeds the stack limit N, it transparently spills to the heap.

pub fn get_or_insert<F>(&mut self, key: K, f: F) -> &V

where F: FnOnce() -> V,

Returns a reference to the value for the key, or inserts a new one.

pub fn get_or_insert_mut<F>(&mut self, key: K, f: F) -> &mut V

where F: FnOnce() -> V,

Returns a mutable reference to the value for the key, or inserts a new one.

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

where for<'a> S: LruIteratorSupport<'a, K, V>,

Returns an iterator over the elements.

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

where for<'a> S: LruIteratorSupport<'a, K, V>,

Returns an iterator over the elements.

impl<K, V, const N: usize, I, S> SmallLruCache<K, V, N, I, S>

where K: Hash + Eq + Ord + Clone, I: IndexType, S: AnyLruCache<K, V> + Default,

pub fn new(cap: NonZeroUsize) -> Self

Automatically generated documentation for this item.

Trait Implementations

impl<K, V, const N: usize, I, S> AnyLruCache<K, V> for SmallLruCache<K, V, N, I, S>

where K: Hash + Eq + Ord + Clone, I: IndexType, S: AnyLruCache<K, V>,

fn len(&self) -> usize

Returns the number of key-value pairs that are currently on this backend.

fn cap(&self) -> NonZeroUsize

Returns the logical maximum capacity of this cache backend.

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

Inserts a key-value pair, updating the value if the key already exists. Returns the old value if the key was present.

fn put_with_cap( &mut self, key: K, value: V, cap: NonZeroUsize, ) -> (Option<V>, Result<(), (K, V)>)

Inserts a key-value pair with a specific maximum capacity enforcement. Returns (old_value, Result<(), (key, value)>). The result is an error if capacity is reached and the backend cannot grow.

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

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

Returns a reference to the value corresponding to the key, moving it to the MRU position.

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

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

Returns a mutable reference to the value corresponding to the key, moving it to the MRU position.

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

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

Returns a reference to the value corresponding to the key without updating the LRU state.

fn clear(&mut self)

Clears the cache, removing all values.

fn pop_lru(&mut self) -> Option<(K, V)>

Removes and returns the explicitly Least Recently Used key-value pair.

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

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

Checks if the cache contains the given key.

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

Pushes a key-value pair into the cache. If the key already exists, updates the value. If pushing causes the capacity to be exceeded, returns the evicted LRU entry.

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

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

Removes the given key from the cache and returns its associated value.

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

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

Removes the given key from the cache and returns the (key, value) pair.

fn promote<Q>(&mut self, key: &Q)

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

Explicitly marks the given key as the Most Recently Used.

fn demote<Q>(&mut self, key: &Q)

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

Explicitly marks the given key as the Least Recently Used.

fn peek_lru(&self) -> Option<(&K, &V)>

Returns a reference to the Least Recently Used pair without removing it.

fn is_empty(&self) -> bool

Returns true if the cache is empty.

impl<K, V, const N: usize, I, S> Clone for SmallLruCache<K, V, N, I, S>

where K: Hash + Eq + Ord + Clone, V: Clone, I: IndexType, S: AnyLruCache<K, V> + Clone,

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<K, V, const N: usize, I, S> Debug for SmallLruCache<K, V, N, I, S>

where K: Hash + Eq + Ord + Clone + Debug, V: Debug, I: IndexType, S: AnyLruCache<K, V>,

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

Formats the value using the given formatter.

impl<K: Hash + Eq + Ord + Clone, V, const N: usize, I: IndexType, S> Default for SmallLruCache<K, V, N, I, S>

where S: AnyLruCache<K, V> + Default,

fn default() -> Self

Returns the “default value” for a type.

impl<K, V, const N: usize, I, S> Drop for SmallLruCache<K, V, N, I, S>

where I: IndexType, S: AnyLruCache<K, V>,

fn drop(&mut self)

Executes the destructor for this type.

impl<K, V, const N: usize, I, S> Extend<(K, V)> for SmallLruCache<K, V, N, I, S>

where K: Hash + Eq + Ord + Clone, I: IndexType, S: AnyLruCache<K, V>,

fn extend<T: IntoIterator<Item = (K, V)>>(&mut self, iter: T)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<K, V, const N: usize, I, S> FromIterator<(K, V)> for SmallLruCache<K, V, N, I, S>

where K: Hash + Eq + Ord + Clone, I: IndexType, S: AnyLruCache<K, V> + Default,

fn from_iter<T: IntoIterator<Item = (K, V)>>(iter: T) -> Self

Creates a value from an iterator.

impl<'a, K, V, const N: usize, I, S> IntoIterator for &'a SmallLruCache<K, V, N, I, S>

where K: Hash + Eq + Ord + Clone, I: IndexType, S: AnyLruCache<K, V> + for<'b> LruIteratorSupport<'b, K, V>,

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

The type of the elements being iterated over.

type IntoIter = Iter<'a, K, V, N, I, S>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, K, V, const N: usize, I, S> IntoIterator for &'a mut SmallLruCache<K, V, N, I, S>

where K: Hash + Eq + Ord + Clone, I: IndexType, S: AnyLruCache<K, V> + for<'b> LruIteratorSupport<'b, K, V>,

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

The type of the elements being iterated over.

type IntoIter = IterMut<'a, K, V, N, I, S>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<K, V, const N: usize, I, S> IntoIterator for SmallLruCache<K, V, N, I, S>

where K: Hash + Eq + Ord + Clone, I: IndexType, S: AnyLruCache<K, V> + IntoIterator<Item = (K, V)>,

type Item = (K, V)

The type of the elements being iterated over.

type IntoIter = IntoIter<K, V, N, I, S>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, K, V, const N: usize, I, S> LruIteratorSupport<'a, K, V> for SmallLruCache<K, V, N, I, S>

where K: Hash + Eq + Ord + Clone + 'a, V: 'a, I: IndexType, S: AnyLruCache<K, V> + for<'b> LruIteratorSupport<'b, K, V>,

type Iter = Iter<'a, K, V, N, I, S>

The associated specific type.

type IterMut = IterMut<'a, K, V, N, I, S>

The associated specific type.

fn iter(&'a self) -> Self::Iter

Returns an iterator over the elements.

fn iter_mut(&'a mut self) -> Self::IterMut

Returns an iterator over the elements.