Add retain method

src/iter.rs

@@ -82,7 +82,7 @@ where
         let key = self.next_unexpired(now)?;
         self.list.push_back(key);
         let key = self.list.back()?;
-        let mut value = self.map.get_mut(&key)?;
+        let mut value = self.map.get_mut(key)?;
         value.1 = now;
 
         unsafe {
@@ -225,7 +225,7 @@ where
         let now = Instant::now();
         self.next_unexpired(now)?;
         let key = &self.list[self.item_index];
-        let value = self.map.get(&key)?;
+        let value = self.map.get(key)?;
 
         unsafe {
             let key = std::mem::transmute::<&Key, &'a Key>(key);

src/lib.rs

@@ -85,6 +85,7 @@
 #[cfg(feature = "sn_fake_clock")]
 use sn_fake_clock::FakeClock as Instant;
 use std::borrow::Borrow;
+use std::collections::btree_map::Entry as BTreeMapEntry;
 use std::collections::{BTreeMap, VecDeque};
 use std::time::Duration;
 #[cfg(not(feature = "sn_fake_clock"))]
@@ -325,6 +326,32 @@ where
         PeekIter::new(&self.map, &self.list, self.time_to_live)
     }
 
+    /// Retains only the elements specified by the predicate. Also removes expired elements
+    /// before passing them to the predicate.
+    pub fn retain<F>(&mut self, mut f: F)
+    where
+        F: FnMut((&'_ Key, &'_ Value)) -> bool,
+    {
+        let (map, list) = (&mut self.map, &mut self.list);
+
+        let now = Instant::now();
+        let ttl = self.time_to_live;
+
+        list.retain(|key| match map.entry(key.clone()) {
+            BTreeMapEntry::Occupied(entry) => {
+                if matches!(ttl, Some(ttl) if entry.get().1 + ttl < now)
+                    || !f((key, &entry.get().0))
+                {
+                    let _ = entry.remove();
+                    false
+                } else {
+                    true
+                }
+            }
+            BTreeMapEntry::Vacant(_) => false,
+        });
+    }
+
     // Move `key` in the ordered list to the last
     fn update_key<Q: ?Sized>(list: &mut VecDeque<Key>, key: &Q)
     where
@@ -753,6 +780,25 @@ mod test {
         }
     }
 
+    mod retain {
+        use super::*;
+
+        #[test]
+        fn it_removes_all_invalid_entries() {
+            let mut lru_cache = LruCache::<usize, usize>::with_capacity(4);
+            let _ = lru_cache.insert(2, 2);
+            let _ = lru_cache.insert(0, 0);
+            let _ = lru_cache.insert(3, 3);
+            let _ = lru_cache.insert(1, 1);
+
+            lru_cache.retain(|(_, &value)| value > 1);
+
+            let cached = lru_cache.peek_iter().collect::<Vec<_>>();
+
+            assert_eq!(cached, vec![(&3, &3), (&2, &2)]);
+        }
+    }
+
     mod notify_iter {
         use super::*;