pub struct LruCache<K, V, S = DefaultHasher> { /* private fields */ }
Expand description
An LRU Cache
Implementations§
source§impl<K: Hash + Eq, V> LruCache<K, V>
impl<K: Hash + Eq, V> LruCache<K, V>
sourcepub fn new(cap: NonZeroUsize) -> LruCache<K, V>
pub fn new(cap: NonZeroUsize) -> LruCache<K, V>
Creates a new LRU Cache that holds at most cap
items.
§Example
use lru::LruCache;
use std::num::NonZeroUsize;
let mut cache: LruCache<isize, &str> = LruCache::new(NonZeroUsize::new(10).unwrap());
source§impl<K: Hash + Eq, V, S: BuildHasher> LruCache<K, V, S>
impl<K: Hash + Eq, V, S: BuildHasher> LruCache<K, V, S>
sourcepub fn with_hasher(cap: NonZeroUsize, hash_builder: S) -> LruCache<K, V, S>
pub fn with_hasher(cap: NonZeroUsize, hash_builder: S) -> LruCache<K, V, S>
Creates a new LRU Cache that holds at most cap
items and
uses the provided hash builder to hash keys.
§Example
use lru::{LruCache, DefaultHasher};
use std::num::NonZeroUsize;
let s = DefaultHasher::default();
let mut cache: LruCache<isize, &str> = LruCache::with_hasher(NonZeroUsize::new(10).unwrap(), s);
sourcepub fn unbounded_with_hasher(hash_builder: S) -> LruCache<K, V, S>
pub fn unbounded_with_hasher(hash_builder: S) -> LruCache<K, V, S>
Creates a new LRU Cache that never automatically evicts items and uses the provided hash builder to hash keys.
§Example
use lru::{LruCache, DefaultHasher};
let s = DefaultHasher::default();
let mut cache: LruCache<isize, &str> = LruCache::unbounded_with_hasher(s);
sourcepub fn put(&mut self, k: K, v: V) -> Option<V>
pub fn put(&mut self, k: K, v: V) -> Option<V>
Puts a key-value pair into cache. If the key already exists in the cache, then it updates
the key’s value and returns the old value. Otherwise, None
is returned.
§Example
use lru::LruCache;
use std::num::NonZeroUsize;
let mut cache = LruCache::new(NonZeroUsize::new(2).unwrap());
assert_eq!(None, cache.put(1, "a"));
assert_eq!(None, cache.put(2, "b"));
assert_eq!(Some("b"), cache.put(2, "beta"));
assert_eq!(cache.get(&1), Some(&"a"));
assert_eq!(cache.get(&2), Some(&"beta"));
sourcepub fn push(&mut self, k: K, v: V) -> Option<(K, V)>
pub fn push(&mut self, k: K, v: V) -> Option<(K, V)>
Pushes a key-value pair into the cache. If an entry with key k
already exists in
the cache or another cache entry is removed (due to the lru’s capacity),
then it returns the old entry’s key-value pair. Otherwise, returns None
.
§Example
use lru::LruCache;
use std::num::NonZeroUsize;
let mut cache = LruCache::new(NonZeroUsize::new(2).unwrap());
assert_eq!(None, cache.push(1, "a"));
assert_eq!(None, cache.push(2, "b"));
// This push call returns (2, "b") because that was previously 2's entry in the cache.
assert_eq!(Some((2, "b")), cache.push(2, "beta"));
// This push call returns (1, "a") because the cache is at capacity and 1's entry was the lru entry.
assert_eq!(Some((1, "a")), cache.push(3, "alpha"));
assert_eq!(cache.get(&1), None);
assert_eq!(cache.get(&2), Some(&"beta"));
assert_eq!(cache.get(&3), Some(&"alpha"));
sourcepub fn get<'a, Q>(&'a mut self, k: &Q) -> Option<&'a V>
pub fn get<'a, Q>(&'a mut self, k: &Q) -> Option<&'a V>
Returns a reference to the value of the key in the cache or None
if it is not
present in the cache. Moves the key to the head of the LRU list if it exists.
§Example
use lru::LruCache;
use std::num::NonZeroUsize;
let mut cache = LruCache::new(NonZeroUsize::new(2).unwrap());
cache.put(1, "a");
cache.put(2, "b");
cache.put(2, "c");
cache.put(3, "d");
assert_eq!(cache.get(&1), None);
assert_eq!(cache.get(&2), Some(&"c"));
assert_eq!(cache.get(&3), Some(&"d"));
sourcepub fn get_mut<'a, Q>(&'a mut self, k: &Q) -> Option<&'a mut V>
pub fn get_mut<'a, Q>(&'a mut self, k: &Q) -> Option<&'a mut V>
Returns a mutable reference to the value of the key in the cache or None
if it
is not present in the cache. Moves the key to the head of the LRU list if it exists.
§Example
use lru::LruCache;
use std::num::NonZeroUsize;
let mut cache = LruCache::new(NonZeroUsize::new(2).unwrap());
cache.put("apple", 8);
cache.put("banana", 4);
cache.put("banana", 6);
cache.put("pear", 2);
assert_eq!(cache.get_mut(&"apple"), None);
assert_eq!(cache.get_mut(&"banana"), Some(&mut 6));
assert_eq!(cache.get_mut(&"pear"), Some(&mut 2));
sourcepub fn get_key_value<'a, Q>(&'a mut self, k: &Q) -> Option<(&'a K, &'a V)>
pub fn get_key_value<'a, Q>(&'a mut self, k: &Q) -> Option<(&'a K, &'a V)>
Returns a key-value references pair of the key in the cache or None
if it is not
present in the cache. Moves the key to the head of the LRU list if it exists.
§Example
use lru::LruCache;
use std::num::NonZeroUsize;
let mut cache = LruCache::new(NonZeroUsize::new(2).unwrap());
cache.put(String::from("1"), "a");
cache.put(String::from("2"), "b");
cache.put(String::from("2"), "c");
cache.put(String::from("3"), "d");
assert_eq!(cache.get_key_value("1"), None);
assert_eq!(cache.get_key_value("2"), Some((&String::from("2"), &"c")));
assert_eq!(cache.get_key_value("3"), Some((&String::from("3"), &"d")));
sourcepub fn get_key_value_mut<'a, Q>(
&'a mut self,
k: &Q,
) -> Option<(&'a K, &'a mut V)>
pub fn get_key_value_mut<'a, Q>( &'a mut self, k: &Q, ) -> Option<(&'a K, &'a mut V)>
Returns a key-value references pair of the key in the cache or None
if it is not
present in the cache. The reference to the value of the key is mutable. Moves the key to
the head of the LRU list if it exists.
§Example
use lru::LruCache;
use std::num::NonZeroUsize;
let mut cache = LruCache::new(NonZeroUsize::new(2).unwrap());
cache.put(1, "a");
cache.put(2, "b");
let (k, v) = cache.get_key_value_mut(&1).unwrap();
assert_eq!(k, &1);
assert_eq!(v, &mut "a");
*v = "aa";
cache.put(3, "c");
assert_eq!(cache.get_key_value(&2), None);
assert_eq!(cache.get_key_value(&1), Some((&1, &"aa")));
assert_eq!(cache.get_key_value(&3), Some((&3, &"c")));
sourcepub fn get_or_insert<F>(&mut self, k: K, f: F) -> &Vwhere
F: FnOnce() -> V,
pub fn get_or_insert<F>(&mut self, k: K, f: F) -> &Vwhere
F: FnOnce() -> V,
Returns a reference to the value of the key in the cache if it is
present in the cache and moves the key to the head of the LRU list.
If the key does not exist the provided FnOnce
is used to populate
the list and a reference is returned.
§Example
use lru::LruCache;
use std::num::NonZeroUsize;
let mut cache = LruCache::new(NonZeroUsize::new(2).unwrap());
cache.put(1, "a");
cache.put(2, "b");
cache.put(2, "c");
cache.put(3, "d");
assert_eq!(cache.get_or_insert(2, ||"a"), &"c");
assert_eq!(cache.get_or_insert(3, ||"a"), &"d");
assert_eq!(cache.get_or_insert(1, ||"a"), &"a");
assert_eq!(cache.get_or_insert(1, ||"b"), &"a");
sourcepub fn get_or_insert_ref<'a, Q, F>(&'a mut self, k: &Q, f: F) -> &'a V
pub fn get_or_insert_ref<'a, Q, F>(&'a mut self, k: &Q, f: F) -> &'a V
Returns a reference to the value of the key in the cache if it is
present in the cache and moves the key to the head of the LRU list.
If the key does not exist the provided FnOnce
is used to populate
the list and a reference is returned. The value referenced by the
key is only cloned (using to_owned()
) if it doesn’t exist in the
cache.
§Example
use lru::LruCache;
use std::num::NonZeroUsize;
use std::rc::Rc;
let key1 = Rc::new("1".to_owned());
let key2 = Rc::new("2".to_owned());
let mut cache = LruCache::<Rc<String>, String>::new(NonZeroUsize::new(2).unwrap());
assert_eq!(cache.get_or_insert_ref(&key1, ||"One".to_owned()), "One");
assert_eq!(cache.get_or_insert_ref(&key2, ||"Two".to_owned()), "Two");
assert_eq!(cache.get_or_insert_ref(&key2, ||"Not two".to_owned()), "Two");
assert_eq!(cache.get_or_insert_ref(&key2, ||"Again not two".to_owned()), "Two");
assert_eq!(Rc::strong_count(&key1), 2);
assert_eq!(Rc::strong_count(&key2), 2); // key2 was only cloned once even though we
// queried it 3 times
sourcepub fn try_get_or_insert<F, E>(&mut self, k: K, f: F) -> Result<&V, E>
pub fn try_get_or_insert<F, E>(&mut self, k: K, f: F) -> Result<&V, E>
Returns a reference to the value of the key in the cache if it is
present in the cache and moves the key to the head of the LRU list.
If the key does not exist the provided FnOnce
is used to populate
the list and a reference is returned. If FnOnce
returns Err
,
returns the Err
.
§Example
use lru::LruCache;
use std::num::NonZeroUsize;
let mut cache = LruCache::new(NonZeroUsize::new(2).unwrap());
cache.put(1, "a");
cache.put(2, "b");
cache.put(2, "c");
cache.put(3, "d");
let f = ||->Result<&str, String> {Err("failed".to_owned())};
let a = ||->Result<&str, String> {Ok("a")};
let b = ||->Result<&str, String> {Ok("b")};
assert_eq!(cache.try_get_or_insert(2, a), Ok(&"c"));
assert_eq!(cache.try_get_or_insert(3, a), Ok(&"d"));
assert_eq!(cache.try_get_or_insert(4, f), Err("failed".to_owned()));
assert_eq!(cache.try_get_or_insert(5, b), Ok(&"b"));
assert_eq!(cache.try_get_or_insert(5, a), Ok(&"b"));
sourcepub fn try_get_or_insert_ref<'a, Q, F, E>(
&'a mut self,
k: &Q,
f: F,
) -> Result<&'a V, E>
pub fn try_get_or_insert_ref<'a, Q, F, E>( &'a mut self, k: &Q, f: F, ) -> Result<&'a V, E>
Returns a reference to the value of the key in the cache if it is
present in the cache and moves the key to the head of the LRU list.
If the key does not exist the provided FnOnce
is used to populate
the list and a reference is returned. If FnOnce
returns Err
,
returns the Err
. The value referenced by the key is only cloned
(using to_owned()
) if it doesn’t exist in the cache and FnOnce
succeeds.
§Example
use lru::LruCache;
use std::num::NonZeroUsize;
use std::rc::Rc;
let key1 = Rc::new("1".to_owned());
let key2 = Rc::new("2".to_owned());
let mut cache = LruCache::<Rc<String>, String>::new(NonZeroUsize::new(2).unwrap());
let f = ||->Result<String, ()> {Err(())};
let a = ||->Result<String, ()> {Ok("One".to_owned())};
let b = ||->Result<String, ()> {Ok("Two".to_owned())};
assert_eq!(cache.try_get_or_insert_ref(&key1, a), Ok(&"One".to_owned()));
assert_eq!(cache.try_get_or_insert_ref(&key2, f), Err(()));
assert_eq!(cache.try_get_or_insert_ref(&key2, b), Ok(&"Two".to_owned()));
assert_eq!(cache.try_get_or_insert_ref(&key2, a), Ok(&"Two".to_owned()));
assert_eq!(Rc::strong_count(&key1), 2);
assert_eq!(Rc::strong_count(&key2), 2); // key2 was only cloned once even though we
// queried it 3 times
sourcepub fn get_or_insert_mut<F>(&mut self, k: K, f: F) -> &mut Vwhere
F: FnOnce() -> V,
pub fn get_or_insert_mut<F>(&mut self, k: K, f: F) -> &mut Vwhere
F: FnOnce() -> V,
Returns a mutable reference to the value of the key in the cache if it is
present in the cache and moves the key to the head of the LRU list.
If the key does not exist the provided FnOnce
is used to populate
the list and a mutable reference is returned.
§Example
use lru::LruCache;
use std::num::NonZeroUsize;
let mut cache = LruCache::new(NonZeroUsize::new(2).unwrap());
cache.put(1, "a");
cache.put(2, "b");
let v = cache.get_or_insert_mut(2, ||"c");
assert_eq!(v, &"b");
*v = "d";
assert_eq!(cache.get_or_insert_mut(2, ||"e"), &mut "d");
assert_eq!(cache.get_or_insert_mut(3, ||"f"), &mut "f");
assert_eq!(cache.get_or_insert_mut(3, ||"e"), &mut "f");
sourcepub fn get_or_insert_mut_ref<'a, Q, F>(&mut self, k: &Q, f: F) -> &'a mut V
pub fn get_or_insert_mut_ref<'a, Q, F>(&mut self, k: &Q, f: F) -> &'a mut V
Returns a mutable reference to the value of the key in the cache if it is
present in the cache and moves the key to the head of the LRU list.
If the key does not exist the provided FnOnce
is used to populate
the list and a mutable reference is returned. The value referenced by the
key is only cloned (using to_owned()
) if it doesn’t exist in the cache.
§Example
use lru::LruCache;
use std::num::NonZeroUsize;
use std::rc::Rc;
let key1 = Rc::new("1".to_owned());
let key2 = Rc::new("2".to_owned());
let mut cache = LruCache::<Rc<String>, &'static str>::new(NonZeroUsize::new(2).unwrap());
cache.get_or_insert_mut_ref(&key1, ||"One");
let v = cache.get_or_insert_mut_ref(&key2, ||"Two");
*v = "New two";
assert_eq!(cache.get_or_insert_mut_ref(&key2, ||"Two"), &mut "New two");
assert_eq!(Rc::strong_count(&key1), 2);
assert_eq!(Rc::strong_count(&key2), 2); // key2 was only cloned once even though we
// queried it 2 times
sourcepub fn try_get_or_insert_mut<F, E>(&mut self, k: K, f: F) -> Result<&mut V, E>
pub fn try_get_or_insert_mut<F, E>(&mut self, k: K, f: F) -> Result<&mut V, E>
Returns a mutable reference to the value of the key in the cache if it is
present in the cache and moves the key to the head of the LRU list.
If the key does not exist the provided FnOnce
is used to populate
the list and a mutable reference is returned. If FnOnce
returns Err
,
returns the Err
.
§Example
use lru::LruCache;
use std::num::NonZeroUsize;
let mut cache = LruCache::new(NonZeroUsize::new(2).unwrap());
cache.put(1, "a");
cache.put(2, "b");
cache.put(2, "c");
let f = ||->Result<&str, String> {Err("failed".to_owned())};
let a = ||->Result<&str, String> {Ok("a")};
let b = ||->Result<&str, String> {Ok("b")};
if let Ok(v) = cache.try_get_or_insert_mut(2, a) {
*v = "d";
}
assert_eq!(cache.try_get_or_insert_mut(2, a), Ok(&mut "d"));
assert_eq!(cache.try_get_or_insert_mut(3, f), Err("failed".to_owned()));
assert_eq!(cache.try_get_or_insert_mut(4, b), Ok(&mut "b"));
assert_eq!(cache.try_get_or_insert_mut(4, a), Ok(&mut "b"));
sourcepub fn try_get_or_insert_mut_ref<'a, Q, F, E>(
&'a mut self,
k: &Q,
f: F,
) -> Result<&'a mut V, E>
pub fn try_get_or_insert_mut_ref<'a, Q, F, E>( &'a mut self, k: &Q, f: F, ) -> Result<&'a mut V, E>
Returns a mutable reference to the value of the key in the cache if it is
present in the cache and moves the key to the head of the LRU list.
If the key does not exist the provided FnOnce
is used to populate
the list and a mutable reference is returned. If FnOnce
returns Err
,
returns the Err
. The value referenced by the key is only cloned
(using to_owned()
) if it doesn’t exist in the cache and FnOnce
succeeds.
§Example
use lru::LruCache;
use std::num::NonZeroUsize;
use std::rc::Rc;
let key1 = Rc::new("1".to_owned());
let key2 = Rc::new("2".to_owned());
let mut cache = LruCache::<Rc<String>, String>::new(NonZeroUsize::new(2).unwrap());
let f = ||->Result<String, ()> {Err(())};
let a = ||->Result<String, ()> {Ok("One".to_owned())};
let b = ||->Result<String, ()> {Ok("Two".to_owned())};
assert_eq!(cache.try_get_or_insert_mut_ref(&key1, a), Ok(&mut "One".to_owned()));
assert_eq!(cache.try_get_or_insert_mut_ref(&key2, f), Err(()));
if let Ok(v) = cache.try_get_or_insert_mut_ref(&key2, b) {
*v = "New two".to_owned();
}
assert_eq!(cache.try_get_or_insert_mut_ref(&key2, a), Ok(&mut "New two".to_owned()));
assert_eq!(Rc::strong_count(&key1), 2);
assert_eq!(Rc::strong_count(&key2), 2); // key2 was only cloned once even though we
// queried it 3 times
sourcepub fn peek<'a, Q>(&'a self, k: &Q) -> Option<&'a V>
pub fn peek<'a, Q>(&'a self, k: &Q) -> Option<&'a V>
Returns a reference to the value corresponding to the key in the cache or None
if it is
not present in the cache. Unlike get
, peek
does not update the LRU list so the key’s
position will be unchanged.
§Example
use lru::LruCache;
use std::num::NonZeroUsize;
let mut cache = LruCache::new(NonZeroUsize::new(2).unwrap());
cache.put(1, "a");
cache.put(2, "b");
assert_eq!(cache.peek(&1), Some(&"a"));
assert_eq!(cache.peek(&2), Some(&"b"));
sourcepub fn peek_mut<'a, Q>(&'a mut self, k: &Q) -> Option<&'a mut V>
pub fn peek_mut<'a, Q>(&'a mut self, k: &Q) -> Option<&'a mut V>
Returns a mutable reference to the value corresponding to the key in the cache or None
if it is not present in the cache. Unlike get_mut
, peek_mut
does not update the LRU
list so the key’s position will be unchanged.
§Example
use lru::LruCache;
use std::num::NonZeroUsize;
let mut cache = LruCache::new(NonZeroUsize::new(2).unwrap());
cache.put(1, "a");
cache.put(2, "b");
assert_eq!(cache.peek_mut(&1), Some(&mut "a"));
assert_eq!(cache.peek_mut(&2), Some(&mut "b"));
sourcepub fn peek_lru(&self) -> Option<(&K, &V)>
pub fn peek_lru(&self) -> Option<(&K, &V)>
Returns the value corresponding to the least recently used item or None
if the
cache is empty. Like peek
, peek_lru
does not update the LRU list so the item’s
position will be unchanged.
§Example
use lru::LruCache;
use std::num::NonZeroUsize;
let mut cache = LruCache::new(NonZeroUsize::new(2).unwrap());
cache.put(1, "a");
cache.put(2, "b");
assert_eq!(cache.peek_lru(), Some((&1, &"a")));
sourcepub fn contains<Q>(&self, k: &Q) -> bool
pub fn contains<Q>(&self, k: &Q) -> bool
Returns a bool indicating whether the given key is in the cache. Does not update the LRU list.
§Example
use lru::LruCache;
use std::num::NonZeroUsize;
let mut cache = LruCache::new(NonZeroUsize::new(2).unwrap());
cache.put(1, "a");
cache.put(2, "b");
cache.put(3, "c");
assert!(!cache.contains(&1));
assert!(cache.contains(&2));
assert!(cache.contains(&3));
sourcepub fn pop<Q>(&mut self, k: &Q) -> Option<V>
pub fn pop<Q>(&mut self, k: &Q) -> Option<V>
Removes and returns the value corresponding to the key from the cache or
None
if it does not exist.
§Example
use lru::LruCache;
use std::num::NonZeroUsize;
let mut cache = LruCache::new(NonZeroUsize::new(2).unwrap());
cache.put(2, "a");
assert_eq!(cache.pop(&1), None);
assert_eq!(cache.pop(&2), Some("a"));
assert_eq!(cache.pop(&2), None);
assert_eq!(cache.len(), 0);
sourcepub fn pop_entry<Q>(&mut self, k: &Q) -> Option<(K, V)>
pub fn pop_entry<Q>(&mut self, k: &Q) -> Option<(K, V)>
Removes and returns the key and the value corresponding to the key from the cache or
None
if it does not exist.
§Example
use lru::LruCache;
use std::num::NonZeroUsize;
let mut cache = LruCache::new(NonZeroUsize::new(2).unwrap());
cache.put(1, "a");
cache.put(2, "a");
assert_eq!(cache.pop(&1), Some("a"));
assert_eq!(cache.pop_entry(&2), Some((2, "a")));
assert_eq!(cache.pop(&1), None);
assert_eq!(cache.pop_entry(&2), None);
assert_eq!(cache.len(), 0);
sourcepub fn pop_lru(&mut self) -> Option<(K, V)>
pub fn pop_lru(&mut self) -> Option<(K, V)>
Removes and returns the key and value corresponding to the least recently
used item or None
if the cache is empty.
§Example
use lru::LruCache;
use std::num::NonZeroUsize;
let mut cache = LruCache::new(NonZeroUsize::new(2).unwrap());
cache.put(2, "a");
cache.put(3, "b");
cache.put(4, "c");
cache.get(&3);
assert_eq!(cache.pop_lru(), Some((4, "c")));
assert_eq!(cache.pop_lru(), Some((3, "b")));
assert_eq!(cache.pop_lru(), None);
assert_eq!(cache.len(), 0);
sourcepub fn promote<Q>(&mut self, k: &Q)
pub fn promote<Q>(&mut self, k: &Q)
Marks the key as the most recently used one.
§Example
use lru::LruCache;
use std::num::NonZeroUsize;
let mut cache = LruCache::new(NonZeroUsize::new(3).unwrap());
cache.put(1, "a");
cache.put(2, "b");
cache.put(3, "c");
cache.get(&1);
cache.get(&2);
// If we do `pop_lru` now, we would pop 3.
// assert_eq!(cache.pop_lru(), Some((3, "c")));
// By promoting 3, we make sure it isn't popped.
cache.promote(&3);
assert_eq!(cache.pop_lru(), Some((1, "a")));
sourcepub fn demote<Q>(&mut self, k: &Q)
pub fn demote<Q>(&mut self, k: &Q)
Marks the key as the least recently used one.
§Example
use lru::LruCache;
use std::num::NonZeroUsize;
let mut cache = LruCache::new(NonZeroUsize::new(3).unwrap());
cache.put(1, "a");
cache.put(2, "b");
cache.put(3, "c");
cache.get(&1);
cache.get(&2);
// If we do `pop_lru` now, we would pop 3.
// assert_eq!(cache.pop_lru(), Some((3, "c")));
// By demoting 1 and 2, we make sure those are popped first.
cache.demote(&2);
cache.demote(&1);
assert_eq!(cache.pop_lru(), Some((1, "a")));
assert_eq!(cache.pop_lru(), Some((2, "b")));
sourcepub fn len(&self) -> usize
pub fn len(&self) -> usize
Returns the number of key-value pairs that are currently in the the cache.
§Example
use lru::LruCache;
use std::num::NonZeroUsize;
let mut cache = LruCache::new(NonZeroUsize::new(2).unwrap());
assert_eq!(cache.len(), 0);
cache.put(1, "a");
assert_eq!(cache.len(), 1);
cache.put(2, "b");
assert_eq!(cache.len(), 2);
cache.put(3, "c");
assert_eq!(cache.len(), 2);
sourcepub fn is_empty(&self) -> bool
pub fn is_empty(&self) -> bool
Returns a bool indicating whether the cache is empty or not.
§Example
use lru::LruCache;
use std::num::NonZeroUsize;
let mut cache = LruCache::new(NonZeroUsize::new(2).unwrap());
assert!(cache.is_empty());
cache.put(1, "a");
assert!(!cache.is_empty());
sourcepub fn cap(&self) -> NonZeroUsize
pub fn cap(&self) -> NonZeroUsize
Returns the maximum number of key-value pairs the cache can hold.
§Example
use lru::LruCache;
use std::num::NonZeroUsize;
let mut cache: LruCache<isize, &str> = LruCache::new(NonZeroUsize::new(2).unwrap());
assert_eq!(cache.cap().get(), 2);
sourcepub fn resize(&mut self, cap: NonZeroUsize)
pub fn resize(&mut self, cap: NonZeroUsize)
Resizes the cache. If the new capacity is smaller than the size of the current cache any entries past the new capacity are discarded.
§Example
use lru::LruCache;
use std::num::NonZeroUsize;
let mut cache: LruCache<isize, &str> = LruCache::new(NonZeroUsize::new(2).unwrap());
cache.put(1, "a");
cache.put(2, "b");
cache.resize(NonZeroUsize::new(4).unwrap());
cache.put(3, "c");
cache.put(4, "d");
assert_eq!(cache.len(), 4);
assert_eq!(cache.get(&1), Some(&"a"));
assert_eq!(cache.get(&2), Some(&"b"));
assert_eq!(cache.get(&3), Some(&"c"));
assert_eq!(cache.get(&4), Some(&"d"));
sourcepub fn clear(&mut self)
pub fn clear(&mut self)
Clears the contents of the cache.
§Example
use lru::LruCache;
use std::num::NonZeroUsize;
let mut cache: LruCache<isize, &str> = LruCache::new(NonZeroUsize::new(2).unwrap());
assert_eq!(cache.len(), 0);
cache.put(1, "a");
assert_eq!(cache.len(), 1);
cache.put(2, "b");
assert_eq!(cache.len(), 2);
cache.clear();
assert_eq!(cache.len(), 0);
sourcepub fn iter(&self) -> Iter<'_, K, V> ⓘ
pub fn iter(&self) -> Iter<'_, K, V> ⓘ
An iterator visiting all entries in most-recently used order. The iterator element type is
(&K, &V)
.
§Examples
use lru::LruCache;
use std::num::NonZeroUsize;
let mut cache = LruCache::new(NonZeroUsize::new(3).unwrap());
cache.put("a", 1);
cache.put("b", 2);
cache.put("c", 3);
for (key, val) in cache.iter() {
println!("key: {} val: {}", key, val);
}
sourcepub fn iter_mut(&mut self) -> IterMut<'_, K, V> ⓘ
pub fn iter_mut(&mut self) -> IterMut<'_, K, V> ⓘ
An iterator visiting all entries in most-recently-used order, giving a mutable reference on
V. The iterator element type is (&K, &mut V)
.
§Examples
use lru::LruCache;
use std::num::NonZeroUsize;
struct HddBlock {
dirty: bool,
data: [u8; 512]
}
let mut cache = LruCache::new(NonZeroUsize::new(3).unwrap());
cache.put(0, HddBlock { dirty: false, data: [0x00; 512]});
cache.put(1, HddBlock { dirty: true, data: [0x55; 512]});
cache.put(2, HddBlock { dirty: true, data: [0x77; 512]});
// write dirty blocks to disk.
for (block_id, block) in cache.iter_mut() {
if block.dirty {
// write block to disk
block.dirty = false
}
}
Trait Implementations§
source§impl<'a, K: Hash + Eq, V, S: BuildHasher> IntoIterator for &'a LruCache<K, V, S>
impl<'a, K: Hash + Eq, V, S: BuildHasher> IntoIterator for &'a LruCache<K, V, S>
source§impl<'a, K: Hash + Eq, V, S: BuildHasher> IntoIterator for &'a mut LruCache<K, V, S>
impl<'a, K: Hash + Eq, V, S: BuildHasher> IntoIterator for &'a mut LruCache<K, V, S>
impl<K: Send, V: Send, S: Send> Send for LruCache<K, V, S>
impl<K: Sync, V: Sync, S: Sync> Sync for LruCache<K, V, S>
Auto Trait Implementations§
impl<K, V, S> Freeze for LruCache<K, V, S>where
S: Freeze,
impl<K, V, S> RefUnwindSafe for LruCache<K, V, S>
impl<K, V, S> Unpin for LruCache<K, V, S>where
S: Unpin,
impl<K, V, S> UnwindSafe for LruCache<K, V, S>
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
source§impl<T> CloneToUninit for Twhere
T: Clone,
impl<T> CloneToUninit for Twhere
T: Clone,
source§unsafe fn clone_to_uninit(&self, dst: *mut T)
unsafe fn clone_to_uninit(&self, dst: *mut T)
clone_to_uninit
)