Struct SizedCache

pub struct SizedCache<K, V> { /* private fields */ }

Least Recently Used / Sized Cache

Stores up to a specified size before beginning to evict the least recently used keys

Note: This cache is in-memory only

Implementations

impl<K: Hash Eq Clone, V> SizedCache<K, V>

pub fn with_capacity(size: usize) -> SizedCache<K, V>

👎Deprecated since 0.5.1: method renamed to with_size

pub fn with_size(size: usize) -> SizedCache<K, V>

Creates a new SizedCache with a given size limit and pre-allocated backing data

Panics

Will panic if size is 0

pub fn try_with_size(size: usize) -> Result<SizedCache<K, V>>

Creates a new SizedCache with a given size limit and pre-allocated backing data

Errors

Will return a std::io::Error, depending on the error

pub fn key_order(&self) -> impl Iterator<Item = &K>

Return an iterator of keys in the current order from most to least recently used.

pub fn value_order(&self) -> impl Iterator<Item = &V>

Return an iterator of values in the current order from most to least recently used.

pub fn get_order(&self) -> &LRUList<(K, V)>

Returns a reference to the cache’s order

pub fn retain<F: Fn(&K, &V) -> bool>(&mut self, keep: F)

Trait Implementations

impl<K: Hash Eq Clone, V> Cached<K, V> for SizedCache<K, V>

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

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

Attempt to retrieve a cached value

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

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

Attempt to retrieve a cached value with mutable access

fn cache_set(&mut self, key: K, val: V) -> Option<V>

Insert a key, value pair and return the previous value

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

Get or insert a key, value pair

fn cache_try_get_or_set_with<F: FnOnce() -> Result<V, E>, E>( &mut self, k: K, f: F, ) -> Result<&mut V, E>

Get or insert a key, value pair with error handling

fn cache_remove<Q>(&mut self, k: &Q) -> Option<V>

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

Remove a cached value

fn cache_clear(&mut self)

Remove all cached values. Keeps the allocated memory for reuse.

fn cache_reset(&mut self)

Remove all cached values. Free memory and return to initial state

fn cache_reset_metrics(&mut self)

Reset misses/hits counters

fn cache_size(&self) -> usize

Return the current cache size (number of elements)

fn cache_hits(&self) -> Option<u64>

Return the number of times a cached value was successfully retrieved

fn cache_misses(&self) -> Option<u64>

Return the number of times a cached value was unable to be retrieved

fn cache_capacity(&self) -> Option<usize>

Return the cache capacity

fn cache_lifespan(&self) -> Option<u64>

Return the lifespan of cached values (time to eviction)

fn cache_set_lifespan(&mut self, _seconds: u64) -> Option<u64>

Set the lifespan of cached values, returns the old value

fn cache_unset_lifespan(&mut self) -> Option<u64>

Remove the lifespan for cached values, returns the old value.

impl<K, V> CachedAsync<K, V> for SizedCache<K, V>

where K: Hash Eq Clone Send,

fn get_or_set_with<'life0, 'async_trait, F, Fut>( &'life0 mut self, k: K, f: F, ) -> Pin<Box<dyn Future<Output = &mut V> Send 'async_trait>>

where V: Send, F: FnOnce() -> Fut Send 'async_trait, Fut: Future<Output = V> Send 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

Available on crate feature async only.

fn try_get_or_set_with<'life0, 'async_trait, F, Fut, E>( &'life0 mut self, k: K, f: F, ) -> Pin<Box<dyn Future<Output = Result<&mut V, E>> Send 'async_trait>>

where V: Send, F: FnOnce() -> Fut Send 'async_trait, Fut: Future<Output = Result<V, E>> Send 'async_trait, E: 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

Available on crate feature async only.

impl<K: Clone, V: Clone> Clone for SizedCache<K, V>

fn clone(&self) -> SizedCache<K, V>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<K, V> Debug for SizedCache<K, V>

where K: Debug, V: Debug,

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

Formats the value using the given formatter.

impl<K, V> PartialEq for SizedCache<K, V>

where K: Eq Hash Clone, V: PartialEq,

fn eq(&self, other: &SizedCache<K, V>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<K, V> Eq for SizedCache<K, V>

where K: Eq Hash Clone, V: PartialEq,