[−][src]Struct lru::LruCache
An LRU Cache
Methods
impl<K: Hash + Eq, V> LruCache<K, V>
[src]
pub fn new(cap: usize) -> LruCache<K, V>
[src]
Creates a new LRU Cache that holds at most cap
items.
Example
use lru::LruCache; let mut cache: LruCache<isize, &str> = LruCache::new(10);
pub fn unbounded() -> LruCache<K, V>
[src]
Creates a new LRU Cache that never automatically evicts items.
Example
use lru::LruCache; let mut cache: LruCache<isize, &str> = LruCache::unbounded();
impl<K: Hash + Eq, V, S: BuildHasher> LruCache<K, V, S>
[src]
pub fn with_hasher(cap: usize, hash_builder: S) -> LruCache<K, V, S>
[src]
Creates a new LRU Cache that holds at most cap
items and
uses the providedash builder to hash keys.
Example
extern crate hashbrown; use hashbrown; use hashbrown::HashMap; use hashbrown::hash_map::DefaultHashBuilder; use lru::LruCache; let s = DefaultHashBuilder::default(); let mut cache: LruCache<isize, &str> = LruCache::with_hasher(10, s);
pub fn put(&mut self, k: K, v: V)
[src]
Puts a key-value pair into cache. If the key already exists it updates its value.
Example
use lru::LruCache; let mut cache = LruCache::new(2); cache.put(1, "a"); cache.put(2, "b"); assert_eq!(cache.get(&1), Some(&"a")); assert_eq!(cache.get(&2), Some(&"b"));
pub fn get<'a>(&'a mut self, k: &K) -> Option<&'a V>
[src]
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; let mut cache = LruCache::new(2); 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"));
pub fn get_mut<'a>(&'a mut self, k: &K) -> Option<&'a mut V>
[src]
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; let mut cache = LruCache::new(2); 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));
pub fn peek<'a>(&'a self, k: &K) -> Option<&'a V>
[src]
Returns 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; let mut cache = LruCache::new(2); cache.put(1, "a"); cache.put(2, "b"); assert_eq!(cache.peek(&1), Some(&"a")); assert_eq!(cache.peek(&2), Some(&"b"));
pub fn peek_lru<'a>(&'a self) -> Option<(&'a K, &'a V)>
[src]
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; let mut cache = LruCache::new(2); cache.put(1, "a"); cache.put(2, "b"); assert_eq!(cache.peek_lru(), Some((&1, &"a")));
pub fn contains(&self, k: &K) -> bool
[src]
Returns a bool indicating whether the given key is in the cache. Does not update the LRU list.
Example
use lru::LruCache; let mut cache = LruCache::new(2); cache.put(1, "a"); cache.put(2, "b"); cache.put(3, "c"); assert!(!cache.contains(&1)); assert!(cache.contains(&2)); assert!(cache.contains(&3));
pub fn pop(&mut self, k: &K) -> Option<V>
[src]
Removes and returns the value corresponding to the key from the cache or
None
if it does not exist.
Example
use lru::LruCache; let mut cache = LruCache::new(2); 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);
pub fn pop_lru(&mut self) -> Option<(K, V)>
[src]
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; let mut cache = LruCache::new(2); 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);
pub fn len(&self) -> usize
[src]
Returns the number of key-value pairs that are currently in the the cache.
Example
use lru::LruCache; let mut cache = LruCache::new(2); 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);
pub fn is_empty(&self) -> bool
[src]
Returns a bool indicating whether the cache is empty or not.
Example
use lru::LruCache; let mut cache = LruCache::new(2); assert!(cache.is_empty()); cache.put(1, "a"); assert!(!cache.is_empty());
pub fn cap(&self) -> usize
[src]
Returns the maximum number of key-value pairs the cache can hold.
Example
use lru::LruCache; let mut cache: LruCache<isize, &str> = LruCache::new(2); assert_eq!(cache.cap(), 2);
pub fn resize(&mut self, cap: usize)
[src]
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; let mut cache: LruCache<isize, &str> = LruCache::new(2); cache.put(1, "a"); cache.put(2, "b"); cache.resize(4); 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"));
pub fn clear(&mut self)
[src]
Clears the contents of the cache.
Example
use lru::LruCache; let mut cache: LruCache<isize, &str> = LruCache::new(2); 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);
ⓘImportant traits for Iter<'a, K, V>pub fn iter<'a>(&'a self) -> Iter<'a, K, V>
[src]
An iterator visiting all entries in order. The iterator element type is (&'a K, &'a V)
.
Examples
use lru::LruCache; let mut cache = LruCache::new(3); cache.put("a", 1); cache.put("b", 2); cache.put("c", 3); for (key, val) in cache.iter() { println!("key: {} val: {}", key, val); }
Trait Implementations
impl<K, V, S> Drop for LruCache<K, V, S>
[src]
impl<'a, K: Hash + Eq, V, S: BuildHasher> IntoIterator for &'a LruCache<K, V, S>
[src]
type Item = (&'a K, &'a V)
The type of the elements being iterated over.
type IntoIter = Iter<'a, K, V>
Which kind of iterator are we turning this into?
ⓘImportant traits for Iter<'a, K, V>fn into_iter(self) -> Iter<'a, K, V>
[src]
impl<K: Sync, V: Sync> Sync for LruCache<K, V>
[src]
impl<K: Send, V: Send> Send for LruCache<K, V>
[src]
Auto Trait Implementations
impl<K, V, S = BuildHasherDefault<FxHasher>> !Send for LruCache<K, V, S>
impl<K, V, S = BuildHasherDefault<FxHasher>> !Sync for LruCache<K, V, S>
Blanket Implementations
impl<T, U> Into for T where
U: From<T>,
[src]
U: From<T>,
impl<T> From for T
[src]
impl<T, U> TryFrom for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T> Borrow for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut for T where
T: ?Sized,
[src]
T: ?Sized,
fn borrow_mut(&mut self) -> &mut T
[src]
impl<T, U> TryInto for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
[src]
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,