Struct sccache::lru_disk_cache::lru_cache::LruCache

pub struct LruCache<K: Eq + Hash, V, S: BuildHasher = RandomState, 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 lru_cache::LruCache;
let mut cache: LruCache<i32, &str> = LruCache::new(10);

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

pub fn with_meter(capacity: u64, meter: M) -> LruCache<K, V, RandomState, 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 lru_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.insert(1, vec![1, 2]);
assert_eq!(cache.size(), 2);
cache.insert(2, vec![3, 4]);
cache.insert(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.

pub 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 lru_cache::LruCache;

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

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

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

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 lru_cache::LruCache;

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

cache.insert(1, 10);
cache.insert(2, 20);
cache.insert(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));

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

pub 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.

pub 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 lru_cache::LruCache;
let mut cache: LruCache<i32, &str> = LruCache::new(2);
assert_eq!(cache.capacity(), 2);

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

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

Checks if the map contains the given key.

Examples

use lru_cache::LruCache;

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

cache.insert(1, "a");
assert!(cache.contains_key(&1));

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

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

pub fn insert(&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 lru_cache::LruCache;

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

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

pub fn remove<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 lru_cache::LruCache;

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

cache.insert(2, "a");

assert_eq!(cache.remove(&1), None);
assert_eq!(cache.remove(&2), Some("a"));
assert_eq!(cache.remove(&2), None);
assert_eq!(cache.len(), 0);

pub 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 lru_cache::LruCache;

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

cache.insert(1, "a");
cache.insert(2, "b");
cache.insert(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.insert(1, "a");
cache.insert(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"));

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

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

Examples

use lru_cache::LruCache;

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

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

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

pub fn len(&self) -> usize

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

pub 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.

pub fn is_empty(&self) -> bool

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

pub fn clear(&mut self)

Removes all key-value pairs from the cache.

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 lru_cache::LruCache;

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

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

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

Trait Implementations

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 copy 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.