Struct LruCache

pub struct LruCache<T: Hash + Eq + Debug> { /* private fields */ }

A minimal LRU cache based on a LruMap with limited capacity.

If the length exceeds the set capacity, the oldest element will be removed In the limit, for each element inserted the oldest existing element will be removed.

Implementations

impl<T: Hash + Eq + Debug> LruCache<T>

pub fn new(limit: u32) -> Self

Creates a new LruCache using the given limit

pub fn insert(&mut self, entry: T) -> bool

Insert an element into the set.

This operation uses get_or_insert from the underlying schnellru::LruMap which:

• Automatically evicts the least recently used item if capacity is exceeded

This method is more efficient than insert_and_get_evicted as it performs fewer checks. Use this method when you don’t need information about evicted values.

If the set did not have this value present, true is returned. If the set did have this value present, false is returned.

pub fn insert_and_get_evicted(&mut self, entry: T) -> (bool, Option<T>)

Same as insert but returns a tuple, where the second index is the evicted value, if one was evicted.

pub fn get(&mut self, entry: &T) -> Option<&T>

Gets the given element, if exists, and promotes to lru.

pub fn find(&self, entry: &T) -> Option<&T>

Iterates through entries and returns a reference to the given entry, if exists, without promoting to lru.

NOTE: Use this for type that have custom impl of PartialEq and Eq, that aren’t unique by all fields. If PartialEq and Eq are derived for a type, it’s more efficient to call contains.

pub fn remove(&mut self, value: &T) -> bool

Expels the given value. Returns true if the value existed.

pub fn contains(&self, value: &T) -> bool

Returns true if the set contains a value.

pub fn iter(&self) -> impl Iterator<Item = &T> + '_

Returns an iterator over all cached entries in lru order

pub fn len(&self) -> usize

Returns number of elements currently in cache.

pub fn is_empty(&self) -> bool

Returns true if there are currently no elements in the cache.

Trait Implementations

impl<T> Debug for LruCache<T>

where T: Debug + Hash + Eq,

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

Formats the value using the given formatter.

impl<T> Extend<T> for LruCache<T>

where T: Eq + Hash + Debug,

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

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 #72631)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

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

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

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 88 bytes