Free least recently used

src/recently_used.rs

@@ -0,0 +1,127 @@
+use std::{
+    borrow::Borrow,
+    collections::{hash_map::Entry, HashMap},
+    hash::Hash,
+};
+
+struct RecentlyUsedItem<V> {
+    entry_idx: usize,
+    value: V,
+}
+
+pub struct RecentlyUsedMap<K: Clone + Copy + Eq + Hash, V> {
+    keys: Vec<K>,
+    map: HashMap<K, RecentlyUsedItem<V>>,
+}
+
+impl<K: Clone + Copy + Eq + Hash, V> RecentlyUsedMap<K, V> {
+    pub fn new() -> Self {
+        Self::with_capacity(0)
+    }
+
+    pub fn with_capacity(capacity: usize) -> Self {
+        Self {
+            keys: Vec::with_capacity(capacity),
+            map: HashMap::with_capacity(capacity),
+        }
+    }
+
+    pub fn insert(&mut self, key: K, value: V) {
+        let new_idx = self.keys.len();
+        match self.map.entry(key) {
+            Entry::Occupied(mut occupied) => {
+                let old = occupied.insert(RecentlyUsedItem {
+                    entry_idx: new_idx,
+                    value,
+                });
+                let removed = self.keys.remove(old.entry_idx);
+                self.keys.push(removed);
+            }
+            Entry::Vacant(vacant) => {
+                vacant.insert(RecentlyUsedItem {
+                    entry_idx: new_idx,
+                    value,
+                });
+                self.keys.push(key);
+            }
+        }
+    }
+
+    pub fn remove<Q: ?Sized>(&mut self, key: &Q)
+    where
+        K: Borrow<Q>,
+        Q: Hash + Eq,
+    {
+        if let Some(entry) = self.map.remove(key.borrow()) {
+            self.keys.remove(entry.entry_idx);
+        }
+    }
+
+    pub fn get<Q: ?Sized>(&self, k: &Q) -> Option<&V>
+    where
+        K: Borrow<Q>,
+        Q: Hash + Eq,
+    {
+        self.map.get(k).map(|item| &item.value)
+    }
+
+    pub fn contains_key<Q: ?Sized>(&self, k: &Q) -> bool
+    where
+        K: Borrow<Q>,
+        Q: Hash + Eq,
+    {
+        self.map.contains_key(k)
+    }
+
+    pub fn entries_least_recently_used(&self) -> impl Iterator<Item = (K, &V)> + '_ {
+        self.keys.iter().map(|k| (*k, &self.map[k].value))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn insert() {
+        let mut rus = RecentlyUsedMap::new();
+        rus.insert("a", ());
+        rus.insert("b", ());
+        assert_eq!(
+            rus.entries_least_recently_used()
+                .map(|(k, _)| k)
+                .collect::<String>(),
+            "ab"
+        );
+    }
+
+    #[test]
+    fn reinsert() {
+        let mut rus = RecentlyUsedMap::new();
+        rus.insert("a", ());
+        rus.insert("b", ());
+        rus.insert("c", ());
+        rus.insert("a", ());
+        assert_eq!(
+            rus.entries_least_recently_used()
+                .map(|(k, _)| k)
+                .collect::<String>(),
+            "bca"
+        );
+    }
+
+    #[test]
+    fn remove() {
+        let mut rus = RecentlyUsedMap::new();
+        rus.insert("a", ());
+        rus.insert("b", ());
+        rus.remove("a");
+        rus.remove("c");
+        assert_eq!(
+            rus.entries_least_recently_used()
+                .map(|(k, _)| k)
+                .collect::<String>(),
+            "b"
+        );
+    }
+}