Rust Thread-Safe In-Memory Cache with LRU Eviction

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
use std::collections::HashMap;
use std::sync::{Arc, RwLock};

pub struct SafeCache<K, V> {
    store: Arc<RwLock<HashMap<K, V>>>,
    capacity: usize,
}

impl<K: std::hash::Hash + Eq + Clone, V: Clone> SafeCache<K, V> {
    pub fn new(capacity: usize) -> Self {
        Self {
            store: Arc::new(RwLock::new(HashMap::with_capacity(capacity))),
            capacity,
        }
    }

    pub fn get(&self, key: &K) -> Option<V> {
        self.store.read().ok()?.get(key).cloned()
    }

    pub fn set(&self, key: K, val: V) {
        if let Ok(mut lock) = self.store.write() {
            if lock.len() >= self.capacity {
                if let Some(first_key) = lock.keys().next().cloned() {
                    lock.remove(&first_key);
                }
            }
            lock.insert(key, val);
        }
    }
}