Struct FifoCache 

pub struct FifoCache<K, V> { /* private fields */ }

A First In, First Out (FIFO) cache for reusing expensive results. Keeps up to your chosen limit and removes the oldest added result when full.

Example

use tiny_cache::FifoCache;

let mut cache = FifoCache::new(2);
cache.insert("first", 10);
cache.insert("second", 20);
assert_eq!(cache.get(&"first"), Some(&10));

cache.insert("third", 30);
assert!(cache.get(&"first").is_none());
assert_eq!(cache.get(&"third"), Some(&30));
assert_eq!(cache.len(), 2);

Implementations

impl<K, V> FifoCache<K, V>

pub fn new(capacity: usize) -> Self

Examples found in repository

examples/caches.rs (line 9)

fn main() {
    let mut fifo = FifoCache::new(2);
    for key in 0..2 {
        fifo.insert(key, format!("Value {key}"));
    }
    fifo.insert(2, "Newest value".to_owned());
    assert!(fifo.get(&0).is_none());
    assert_eq!(fifo.len(), 2);
    fifo.set_capacity(1);
    assert_eq!(fifo.get(&1), None);
    assert_eq!(fifo.len(), 1);

    let mut shared = LRUCache::<String, u64>::default();
    let first = shared
        .utilize(1, &"greeting")
        .unwrap_or_else(|| shared.insert(1, &"greeting", "Hello".to_owned()));
    let second = shared
        .utilize(2, &"greeting")
        .unwrap_or_else(|| shared.insert(2, &"greeting", "Hello".to_owned()));
    assert!(Rc::ptr_eq(&first, &second));

    shared.remove(&1);
    assert_eq!(shared.len(), 1);
    shared.remove(&2);
    assert!(shared.is_empty());
    assert_eq!(first.as_str(), "Hello");
}

impl<K, V> FifoCache<K, V>

where K: Clone + Eq + Hash,

pub fn set_capacity(&mut self, capacity: usize)

Changes how many results to keep, removing the oldest added results if the limit shrinks.

Examples found in repository

examples/caches.rs (line 16)

fn main() {
    let mut fifo = FifoCache::new(2);
    for key in 0..2 {
        fifo.insert(key, format!("Value {key}"));
    }
    fifo.insert(2, "Newest value".to_owned());
    assert!(fifo.get(&0).is_none());
    assert_eq!(fifo.len(), 2);
    fifo.set_capacity(1);
    assert_eq!(fifo.get(&1), None);
    assert_eq!(fifo.len(), 1);

    let mut shared = LRUCache::<String, u64>::default();
    let first = shared
        .utilize(1, &"greeting")
        .unwrap_or_else(|| shared.insert(1, &"greeting", "Hello".to_owned()));
    let second = shared
        .utilize(2, &"greeting")
        .unwrap_or_else(|| shared.insert(2, &"greeting", "Hello".to_owned()));
    assert!(Rc::ptr_eq(&first, &second));

    shared.remove(&1);
    assert_eq!(shared.len(), 1);
    shared.remove(&2);
    assert!(shared.is_empty());
    assert_eq!(first.as_str(), "Hello");
}

pub fn insert(&mut self, key: K, value: V)

Saves a result to reuse later, removing the oldest added result if there is no room. Replacing an existing result does not move it to the back of the line.

Examples found in repository

examples/caches.rs (line 11)

fn main() {
    let mut fifo = FifoCache::new(2);
    for key in 0..2 {
        fifo.insert(key, format!("Value {key}"));
    }
    fifo.insert(2, "Newest value".to_owned());
    assert!(fifo.get(&0).is_none());
    assert_eq!(fifo.len(), 2);
    fifo.set_capacity(1);
    assert_eq!(fifo.get(&1), None);
    assert_eq!(fifo.len(), 1);

    let mut shared = LRUCache::<String, u64>::default();
    let first = shared
        .utilize(1, &"greeting")
        .unwrap_or_else(|| shared.insert(1, &"greeting", "Hello".to_owned()));
    let second = shared
        .utilize(2, &"greeting")
        .unwrap_or_else(|| shared.insert(2, &"greeting", "Hello".to_owned()));
    assert!(Rc::ptr_eq(&first, &second));

    shared.remove(&1);
    assert_eq!(shared.len(), 1);
    shared.remove(&2);
    assert!(shared.is_empty());
    assert_eq!(first.as_str(), "Hello");
}

pub fn get(&self, key: &K) -> Option<&V>

Examples found in repository

examples/caches.rs (line 14)

fn main() {
    let mut fifo = FifoCache::new(2);
    for key in 0..2 {
        fifo.insert(key, format!("Value {key}"));
    }
    fifo.insert(2, "Newest value".to_owned());
    assert!(fifo.get(&0).is_none());
    assert_eq!(fifo.len(), 2);
    fifo.set_capacity(1);
    assert_eq!(fifo.get(&1), None);
    assert_eq!(fifo.len(), 1);

    let mut shared = LRUCache::<String, u64>::default();
    let first = shared
        .utilize(1, &"greeting")
        .unwrap_or_else(|| shared.insert(1, &"greeting", "Hello".to_owned()));
    let second = shared
        .utilize(2, &"greeting")
        .unwrap_or_else(|| shared.insert(2, &"greeting", "Hello".to_owned()));
    assert!(Rc::ptr_eq(&first, &second));

    shared.remove(&1);
    assert_eq!(shared.len(), 1);
    shared.remove(&2);
    assert!(shared.is_empty());
    assert_eq!(first.as_str(), "Hello");
}

pub fn get_mut(&mut self, key: &K) -> Option<&mut V>

Lets you update a saved result without creating a replacement or changing its place in line.

pub fn capacity(&self) -> usize

pub fn len(&self) -> usize

Examples found in repository

examples/caches.rs (line 15)

fn main() {
    let mut fifo = FifoCache::new(2);
    for key in 0..2 {
        fifo.insert(key, format!("Value {key}"));
    }
    fifo.insert(2, "Newest value".to_owned());
    assert!(fifo.get(&0).is_none());
    assert_eq!(fifo.len(), 2);
    fifo.set_capacity(1);
    assert_eq!(fifo.get(&1), None);
    assert_eq!(fifo.len(), 1);

    let mut shared = LRUCache::<String, u64>::default();
    let first = shared
        .utilize(1, &"greeting")
        .unwrap_or_else(|| shared.insert(1, &"greeting", "Hello".to_owned()));
    let second = shared
        .utilize(2, &"greeting")
        .unwrap_or_else(|| shared.insert(2, &"greeting", "Hello".to_owned()));
    assert!(Rc::ptr_eq(&first, &second));

    shared.remove(&1);
    assert_eq!(shared.len(), 1);
    shared.remove(&2);
    assert!(shared.is_empty());
    assert_eq!(first.as_str(), "Hello");
}

pub fn is_empty(&self) -> bool

pub fn clear(&mut self)

Trait Implementations

impl<K, V> Debug for FifoCache<K, V>

where K: Debug, V: Debug,

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

Formats the value using the given formatter.