Struct ConstLru 

pub struct ConstLru<K, V, const CAP: usize, I: PrimInt + Unsigned = usize> { /* private fields */ }

Constant capacity key-addressed LRU cache.

Generics:

• K. Type of key. Ord is used for lookup and to address entries.
• V. Type of value.
• CAP. Capacity of the cache.
• I. Type of the index used. Must be an unsigned primitive type with bitwidth <= usize’s bitwidth.

Implementations

impl<K, V, const CAP: usize, I: PrimInt + Unsigned> ConstLru<K, V, CAP, I>

pub fn new() -> Self

Creates a new empty ConstLru on the stack

panics if

• CAP > I::MAX
• I::MAX > usize::MAX

WARNING: this might result in runtime stack overflow errors for large CAP. Use Self::init_at_alloc to initialize larger variants at preallocated memory

pub unsafe fn init_at_alloc(ptr: *mut Self)

Initializes the ConstLru at a region of allocated memory

Safety

ptr must point to uninitialized memory, since init() overwrites the data at ptr

panics if

• CAP > I::MAX
• I::MAX > usize::MAX

Example:

use const_lru::ConstLru;
use std::alloc::{alloc, Layout};

let layout = Layout::new::<ConstLru<u32, u16, 1_000, u16>>();
let container: Box<ConstLru<u32, u16, 1_000, u16>> = unsafe {
    let ptr = alloc(layout) as *mut ConstLru<u32, u16, 1_000, u16>;
    ConstLru::init_at_alloc(ptr);
    Box::from_raw(ptr)
};

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

Creates an iterator that iterates through the keys and values of the ConstLru from most-recently-used to least-recently-used

Does not change the LRU order of the elements.

Double-ended: reversing iterates from least-recently-used to most-recently-used

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

Creates an iterator that iterates through the keys and mutable values of the ConstLru from most-recently-used to least-recently-used

Does not change the LRU order of the elements, even if mutated.

Double-ended: reversing iterates from least-recently-used to most-recently-used

pub fn iter_key_order(&self) -> IterKeyOrder<'_, K, V, CAP, I>

Creates an iterator that iterates through the keys and values of the ConstLru in the order of its keys

Does not change the LRU order of the elements.

Double-ended: reversing iterates from descending order of its keys

pub fn iter_key_order_mut(&mut self) -> IterKeyOrderMut<'_, K, V, CAP, I>

Creates an iterator that iterates through the keys and mutable values of the ConstLru in the order of its keys

Does not change the LRU order of the elements, even if mutated.

Double-ended: reversing iterates from descending order of its keys

pub fn clear(&mut self)

Clears the ConstLru, removing all key-value pairs.

pub fn cap(&self) -> I

Returns the maximum number of elements this ConstLru can hold

pub fn is_empty(&self) -> bool

Returns true if the ConstLru contains no elements.

pub fn is_full(&self) -> bool

Returns true if the ConstLru has reached max capacity.

pub fn len(&self) -> I

Returns the number of elements in the ConstLru.

impl<K: Ord, V, const CAP: usize, I: PrimInt + Unsigned> ConstLru<K, V, CAP, I>

pub fn insert(&mut self, k: K, v: V) -> Option<InsertReplaced<K, V>>

Inserts a key-value pair into the map. The entry is moved to the most-recently-used slot

If CAP == 0, None is returned.

If the map did not have this key present and is not full, None is returned.

If the map did have this key present, the value is updated, and the old value is returned in a InsertReplaced::OldValue. The key is not updated, though; this matters for types that can be == without being identical.

If the map is full, the least-recently used key-value pair is evicted and returned in a InsertReplaced::LruEvicted.

pub fn remove<Q: Ord + ?Sized>(&mut self, k: &Q) -> Option<V>

where K: Borrow<Q>,

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

pub fn get<Q: Ord + ?Sized>(&mut self, k: &Q) -> Option<&V>

where K: Borrow<Q>,

Returns a reference to the value corresponding to the key and moves entry to most-recently-used slot.

To not update to most-recently-used, use Self::get_untouched

pub fn get_mut<Q: Ord + ?Sized>(&mut self, k: &Q) -> Option<&mut V>

where K: Borrow<Q>,

Returns a mutable reference to the value corresponding to the key and moves entry to most-recently-used slot.

To not update to most-recently-used, use Self::get_mut_untouched

pub fn get_untouched<Q: Ord + ?Sized>(&self, k: &Q) -> Option<&V>

where K: Borrow<Q>,

Returns a reference to the value corresponding to the key without updating the entry to most-recently-used slot

To update to most-recently-used, use Self::get

pub fn get_mut_untouched<Q: Ord + ?Sized>(&mut self, k: &Q) -> Option<&mut V>

where K: Borrow<Q>,

Returns a mutable reference to the value corresponding to the key without updating the entry to most-recently-used slot

To update to most-recently-used, use Self::get_mut

pub fn entry(&mut self, k: K) -> Entry<'_, K, V, CAP, I>

Gets the given key’s corresponding entry in the map for in-place manipulation.

panics if CAP == 0

impl<K: Clone, V: Clone, const CAP: usize, I: PrimInt + Unsigned> ConstLru<K, V, CAP, I>

pub unsafe fn clone_to_alloc(&self, dst: *mut Self)

Clones the ConstLru to a region of allocated memory

Safety

dst must point to uninitialized memory, since this overwrites the data at dst

Trait Implementations

impl<K: Clone, V: Clone, const CAP: usize, I: PrimInt + Unsigned> Clone for ConstLru<K, V, CAP, I>

WARNING: this might result in runtime stack overflow errors for large CAP. To clone a large ConstLru, use ConstLru::clone_to_alloc

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<K: Debug, V: Debug, const CAP: usize, I: Debug + PrimInt + Unsigned> Debug for ConstLru<K, V, CAP, I>

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

Formats the value using the given formatter.

impl<K, V, const CAP: usize, I: PrimInt + Unsigned> Default for ConstLru<K, V, CAP, I>

fn default() -> Self

Returns the “default value” for a type.

impl<K, V, const CAP: usize, I: PrimInt + Unsigned> Drop for ConstLru<K, V, CAP, I>

fn drop(&mut self)

Executes the destructor for this type.

impl<K, V, const CAP: usize, I: PrimInt + Unsigned> IntoIterator for ConstLru<K, V, CAP, I>

type Item = <IntoIter<K, V, CAP, I> as Iterator>::Item

The type of the elements being iterated over.

type IntoIter = IntoIter<K, V, CAP, I>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<K: Ord, V, const CAP: usize, I: PrimInt + Unsigned> TryFrom<[(K, V); CAP]> for ConstLru<K, V, CAP, I>

Creates a full ConstLru cache from an entries array.

Assumes entries is in MRU -> LRU order.

Returns error if duplicate keys found.

WARNING: this might result in runtime stack overflow errors for large CAP.

type Error = DuplicateKeysError<K>

The type returned in the event of a conversion error.

fn try_from(entries: [(K, V); CAP]) -> Result<Self, Self::Error>

Performs the conversion.