Struct LRUCache 

pub struct LRUCache<V, ID: Hash, const USER_CAPACITY: usize = 2> {
    pub users: FxHashMap<ID, SmallVec<[u64; 2]>>,
    /* private fields */
}

Reuse costly results across users, such as text measurements shared by several labels. Each user keeps its last USER_CAPACITY results. Saved results leave when no user needs them.

Fields

users: FxHashMap<ID, SmallVec<[u64; 2]>>

Tracks which saved results each user still needs.

Implementations

impl<V, ID: Hash + Eq, const USER_CAPACITY: usize> LRUCache<V, ID, USER_CAPACITY>

pub fn utilize<H: Hash>(&mut self, id: ID, hash_value: &H) -> Option<Rc<V>>

Reuses a saved result for this user and makes room by letting go of their oldest results. If it returns None, create the result and save it with insert.

Examples found in repository

examples/caches.rs (line 22)

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<H: Hash>(&mut self, id: ID, hash_value: &H, value: V) -> Rc<V>

Saves a newly created result for this user so others can reuse it without repeating the work. Call utilize first to check for a saved result and make room for this one.

Examples found in repository

examples/caches.rs (line 23)

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 len(&self) -> usize

Counts saved results, counting a result shared by several users only once.

Examples found in repository

examples/caches.rs (line 30)

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

Examples found in repository

examples/caches.rs (line 32)

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 users_len(&self) -> usize

Counts users being tracked, including those with no saved results yet.

pub fn remove(&mut self, id: &ID)

Stops keeping results for a user that has gone away, such as a label removed from the screen. Results still needed by other users stay saved, and copies already handed out remain usable.

Examples found in repository

examples/caches.rs (line 29)

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 reset(&mut self)

Clears saved results and user tracking.

Trait Implementations

impl<V, ID: Hash, const USER_CAPACITY: usize> Debug for LRUCache<V, ID, USER_CAPACITY>

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

Formats the value using the given formatter.

impl<V, ID: Hash, const USER_CAPACITY: usize> Default for LRUCache<V, ID, USER_CAPACITY>

fn default() -> Self

Returns the “default value” for a type.