Struct lru::LruCache

source · [−]
pub struct LruCache<K, V, S = DefaultHasher> { /* private fields */ }
Expand description

An LRU Cache

Implementations

Creates a new LRU Cache that holds at most cap items.

Example
use lru::LruCache;
let mut cache: LruCache<isize, &str> = LruCache::new(10);

Creates a new LRU Cache that never automatically evicts items.

Example
use lru::LruCache;
let mut cache: LruCache<isize, &str> = LruCache::unbounded();

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};

let s = DefaultHasher::default();
let mut cache: LruCache<isize, &str> = LruCache::with_hasher(10, 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);

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;
let mut cache = LruCache::new(2);

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

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;
let mut cache = LruCache::new(2);

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

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

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

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.

This method will only return None when the capacity of the cache is 0 and no entries can be populated.

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_or_insert(2, ||"a"), Some(&"c"));
assert_eq!(cache.get_or_insert(3, ||"a"), Some(&"d"));
assert_eq!(cache.get_or_insert(1, ||"a"), Some(&"a"));
assert_eq!(cache.get_or_insert(1, ||"b"), Some(&"a"));

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

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

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

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

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

pub fn pop_entry<Q>(&mut self, k: &Q) -> Option<(K, V)> where
    KeyRef<K>: Borrow<Q>,
    Q: Hash + Eq + ?Sized, 

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;
let mut cache = LruCache::new(2);

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

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

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

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

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

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

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

An iterator visiting all entries in most-recently used order. The iterator element type is (&K, &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);
}

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;

struct HddBlock {
    dirty: bool,
    data: [u8; 512]
}

let mut cache = LruCache::new(3);
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

Formats the value using the given formatter. Read more

Executes the destructor for this type. Read more

The type of the elements being iterated over.

Which kind of iterator are we turning this into?

Creates an iterator from a value. Read more

The type of the elements being iterated over.

Which kind of iterator are we turning this into?

Creates an iterator from a value. Read more

The type of the elements being iterated over.

Which kind of iterator are we turning this into?

Creates an iterator from a value. Read more

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

Immutably borrows from an owned value. Read more

Mutably borrows from an owned value. Read more

Returns the argument unchanged.

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

The type returned in the event of a conversion error.

Performs the conversion.

The type returned in the event of a conversion error.

Performs the conversion.