Struct LruCache 

pub struct LruCache<K: Eq + Hash, V, S: BuildHasher = DefaultHashBuilder, M: CountableMeter<K, V> = Count> { /* private fields */ }

An LRU cache.

Implementations

impl<K: Eq + Hash, V> LruCache<K, V>

pub fn new(capacity: u64) -> Self

Creates an empty cache that can hold at most capacity items.

Examples

use ritecache::{Cache, LruCache};
let mut cache: LruCache<i32, &str> = LruCache::new(10);

impl<K: Eq + Hash, V, M: CountableMeter<K, V>> LruCache<K, V, DefaultHashBuilder, M>

pub fn with_meter( capacity: u64, meter: M, ) -> LruCache<K, V, DefaultHashBuilder, M>

Creates an empty cache that can hold at most capacity as measured by meter.

You can implement the Meter trait to allow custom metrics.

Examples

use ritecache::{Cache, LruCache, Meter};
use std::borrow::Borrow;

/// Measure Vec items by their length
struct VecLen;

impl<K, T> Meter<K, Vec<T>> for VecLen {
    // Use `Measure = usize` or implement `CountableMeter` as well.
    type Measure = usize;
    fn measure<Q: ?Sized>(&self, _: &Q, v: &Vec<T>) -> usize
        where K: Borrow<Q>
    {
        v.len()
    }
}

let mut cache = LruCache::with_meter(5, VecLen);
cache.put(1, vec![1, 2]);
assert_eq!(cache.size(), 2);
cache.put(2, vec![3, 4]);
cache.put(3, vec![5, 6]);
assert_eq!(cache.size(), 4);
assert_eq!(cache.len(), 2);

impl<K: Eq + Hash, V, S: BuildHasher> LruCache<K, V, S, Count>

pub fn with_hasher(capacity: u64, hash_builder: S) -> LruCache<K, V, S, Count>

Creates an empty cache that can hold at most capacity items with the given hash builder.

impl<K: Eq + Hash, V, S: BuildHasher, M: CountableMeter<K, V>> LruCache<K, V, S, M>

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

Returns an iterator over the cache’s key-value pairs in least- to most-recently-used order.

Accessing the cache through the iterator does not affect the cache’s LRU state.

Examples

use ritecache::{Cache, LruCache};

let mut cache = LruCache::new(2);

cache.put(1, 10);
cache.put(2, 20);
cache.put(3, 30);

let kvs: Vec<_> = cache.iter().collect();
assert_eq!(kvs, [(&2, &20), (&3, &30)]);

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

Returns an iterator over the cache’s key-value pairs in least- to most-recently-used order, with mutable references to the values.

Accessing the cache through the iterator does not affect the cache’s LRU state. Note that this method is not available for cache objects using Meter implementations. other than Count.

Examples

use ritecache::{Cache, LruCache};

let mut cache = LruCache::new(2);

cache.put(1, 10);
cache.put(2, 20);
cache.put(3, 30);

let mut n = 2;

for (k, v) in cache.iter_mut() {
    assert_eq!(*k, n);
    assert_eq!(*v, n * 10);
    *v *= 10;
    n += 1;
}

assert_eq!(n, 4);
assert_eq!(cache.get_mut(&2), Some(&mut 200));
assert_eq!(cache.get_mut(&3), Some(&mut 300));

Trait Implementations

impl<K: Eq + Hash, V, S: BuildHasher, M: CountableMeter<K, V>> Cache<K, V, S, M> for LruCache<K, V, S, M>

fn with_meter_and_hasher(capacity: u64, meter: M, hash_builder: S) -> Self

Creates an empty cache that can hold at most capacity as measured by meter with the given hash builder.

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

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

Returns a reference to the value corresponding to the given key in the cache, if any.

Note that this method is not available for cache objects using Meter implementations other than Count.

Examples

use ritecache::{Cache, 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"));

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

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

Returns a mutable reference to the value corresponding to the given key in the cache, if any.

Note that this method is not available for cache objects using Meter implementations other than Count.

Examples

use ritecache::{Cache, 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_mut(&1), None);
assert_eq!(cache.get_mut(&2), Some(&mut "c"));

fn peek<'a, Q>(&'a self, k: &Q) -> Option<&'a V>

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

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 ritecache::{Cache, 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"));

fn peek_mut<'a, Q>(&'a mut self, k: &Q) -> Option<&'a mut V>

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

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 ritecache::{Cache, LruCache};
let mut cache = LruCache::new(2);

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"));

fn peek_by_policy(&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 ritecache::{Cache, LruCache};
let mut cache = LruCache::new(2);

cache.put(1, "a");
cache.put(2, "b");

assert_eq!(cache.peek_by_policy(), Some((&1, &"a")));

fn contains<Q>(&self, key: &Q) -> bool

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

Checks if the map contains the given key.

Examples

use ritecache::{Cache, LruCache};

let mut cache = LruCache::new(1);

cache.put(1, "a");
assert!(cache.contains(&1));

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

Inserts a key-value pair into the cache. If the key already existed, the old value is returned.

Examples

use ritecache::{Cache, LruCache};

let mut cache = LruCache::new(2);

cache.put(1, "a");
cache.put(2, "b");
assert_eq!(cache.get_mut(&1), Some(&mut "a"));
assert_eq!(cache.get_mut(&2), Some(&mut "b"));

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

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

Removes the given key from the cache and returns its corresponding value.

Examples

use ritecache::{Cache, 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);

fn pop_by_policy(&mut self) -> Option<(K, V)>

Removes and returns the least recently used key-value pair as a tuple.

Examples

use ritecache::{Cache, LruCache};

let mut cache = LruCache::new(2);

cache.put(1, "a");
cache.put(2, "b");

assert_eq!(cache.pop_by_policy(), Some((1, "a")));
assert_eq!(cache.len(), 1);

fn set_capacity(&mut self, capacity: u64)

Sets the size of the key-value pairs the cache can hold, as measured by the Meter used by the cache.

Removes least-recently-used key-value pairs if necessary.

Examples

use ritecache::{Cache, LruCache};

let mut cache = LruCache::new(2);

cache.put(1, "a");
cache.put(2, "b");
cache.put(3, "c");

assert_eq!(cache.get_mut(&1), None);
assert_eq!(cache.get_mut(&2), Some(&mut "b"));
assert_eq!(cache.get_mut(&3), Some(&mut "c"));

cache.set_capacity(3);
cache.put(1, "a");
cache.put(2, "b");

assert_eq!(cache.get_mut(&1), Some(&mut "a"));
assert_eq!(cache.get_mut(&2), Some(&mut "b"));
assert_eq!(cache.get_mut(&3), Some(&mut "c"));

cache.set_capacity(1);

assert_eq!(cache.get_mut(&1), None);
assert_eq!(cache.get_mut(&2), None);
assert_eq!(cache.get_mut(&3), Some(&mut "c"));

fn len(&self) -> usize

Returns the number of key-value pairs in the cache.

fn size(&self) -> u64

Returns the size of all the key-value pairs in the cache, as measured by the Meter used by the cache.

fn capacity(&self) -> u64

Returns the maximum size of the key-value pairs the cache can hold, as measured by the Meter used by the cache.

Examples

use ritecache::{Cache, LruCache};
let mut cache: LruCache<i32, &str> = LruCache::new(2);
assert_eq!(cache.capacity(), 2);

fn is_empty(&self) -> bool

Returns true if the cache contains no key-value pairs.

fn clear(&mut self)

Removes all key-value pairs from the cache.

impl<K: Clone + Eq + Hash, V: Clone, S: Clone + BuildHasher, M: Clone + CountableMeter<K, V>> Clone for LruCache<K, V, S, M>

where M::Measure: Clone,

fn clone(&self) -> LruCache<K, V, S, M>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<K: Debug + Eq + Hash, V: Debug, S: BuildHasher, M: CountableMeter<K, V>> Debug for LruCache<K, V, S, M>

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

Formats the value using the given formatter.

impl<K: Eq + Hash, V, S: BuildHasher, M: CountableMeter<K, V>> Extend<(K, V)> for LruCache<K, V, S, M>

fn extend<I: IntoIterator<Item = (K, V)>>(&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)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

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

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

impl<'a, K: Eq + Hash, V, S: BuildHasher, M: CountableMeter<K, V>> IntoIterator for &'a LruCache<K, V, S, M>

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?

fn into_iter(self) -> Iter<'a, K, V>

Creates an iterator from a value.

impl<'a, K: Eq + Hash, V, S: BuildHasher, M: CountableMeter<K, V>> IntoIterator for &'a mut LruCache<K, V, S, M>

type Item = (&'a K, &'a mut V)

The type of the elements being iterated over.

type IntoIter = IterMut<'a, K, V>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IterMut<'a, K, V>

Creates an iterator from a value.

impl<K: Eq + Hash, V, S: BuildHasher, M: CountableMeter<K, V>> IntoIterator for LruCache<K, V, S, M>

type Item = (K, V)

The type of the elements being iterated over.

type IntoIter = IntoIter<K, V>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IntoIter<K, V>

Creates an iterator from a value.