Add get_mut() to the thread-safe variants

Author: jedisct1

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sieve-cache"
-version = "1.0.0"
+version = "1.0.1"
 edition = "2021"
 description = "SIEVE cache replacement policy with thread-safe wrappers"
 homepage = "https://github.com/jedisct1/rust-sieve-cache"
@@ -44,4 +44,4 @@ strip = true
 [profile.bench]
 opt-level = 3
 debug = true
-lto = "thin"
+lto = "thin"

src/lib.rs

@@ -628,4 +628,4 @@ fn test_visited_flag_update() {
     // new entry is added.
     cache.insert("key3".to_string(), "value3".to_string());
     assert_eq!(cache.get("key1"), Some(&"updated".to_string()));
-}
+}

src/sharded.rs

@@ -304,6 +304,44 @@ where
         guard.get(key).cloned()
     }
 
+    /// Gets a mutable reference to the value in the cache mapped to by `key` via a callback function.
+    ///
+    /// If no value exists for `key`, the callback will not be invoked and this returns `false`.
+    /// Otherwise, the callback is invoked with a mutable reference to the value and this returns `true`.
+    /// This operation only locks the specific shard containing the key.
+    ///
+    /// This operation marks the entry as "visited" in the SIEVE algorithm,
+    /// which affects eviction decisions.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use sieve_cache::ShardedSieveCache;
+    /// let cache: ShardedSieveCache<String, String> = ShardedSieveCache::new(100).unwrap();
+    /// cache.insert("key".to_string(), "value".to_string());
+    ///
+    /// // Modify the value in-place
+    /// cache.get_mut(&"key".to_string(), |value| {
+    ///     *value = "new_value".to_string();
+    /// });
+    ///
+    /// assert_eq!(cache.get(&"key".to_string()), Some("new_value".to_string()));
+    /// ```
+    pub fn get_mut<Q, F>(&self, key: &Q, f: F) -> bool
+    where
+        Q: Hash + Eq + ?Sized,
+        K: Borrow<Q>,
+        F: FnOnce(&mut V),
+    {
+        let mut guard = self.locked_shard(key);
+        if let Some(value) = guard.get_mut(key) {
+            f(value);
+            true
+        } else {
+            false
+        }
+    }
+
     /// Maps `key` to `value` in the cache, possibly evicting old entries from the appropriate shard.
     ///
     /// This method returns `true` when this is a new entry, and `false` if an existing entry was
@@ -611,4 +649,64 @@ mod tests {
             assert!(cache.contains_key(&key));
         }
     }
+
+    #[test]
+    fn test_get_mut() {
+        let cache = ShardedSieveCache::new(100).unwrap();
+        cache.insert("key".to_string(), "value".to_string());
+
+        // Modify the value in-place
+        let modified = cache.get_mut(&"key".to_string(), |value| {
+            *value = "new_value".to_string();
+        });
+        assert!(modified);
+
+        // Verify the value was updated
+        assert_eq!(cache.get(&"key".to_string()), Some("new_value".to_string()));
+
+        // Try to modify a non-existent key
+        let modified = cache.get_mut(&"missing".to_string(), |_| {
+            panic!("This should not be called");
+        });
+        assert!(!modified);
+    }
+
+    #[test]
+    fn test_get_mut_concurrent() {
+        let cache = Arc::new(ShardedSieveCache::with_shards(100, 8).unwrap());
+
+        // Insert initial values
+        for i in 0..10 {
+            cache.insert(format!("key{}", i), 0);
+        }
+
+        let mut handles = vec![];
+
+        // Spawn 5 threads that modify values concurrently
+        for _ in 0..5 {
+            let cache_clone = Arc::clone(&cache);
+
+            let handle = thread::spawn(move || {
+                for i in 0..10 {
+                    for _ in 0..100 {
+                        cache_clone.get_mut(&format!("key{}", i), |value| {
+                            *value += 1;
+                        });
+                    }
+                }
+            });
+
+            handles.push(handle);
+        }
+
+        // Wait for all threads to complete
+        for handle in handles {
+            handle.join().unwrap();
+        }
+
+        // Each key should have been incremented 500 times (5 threads * 100 increments each)
+        for i in 0..10 {
+            assert_eq!(cache.get(&format!("key{}", i)), Some(500));
+        }
+    }
 }

src/sync.rs

@@ -163,6 +163,43 @@ where
         guard.get(key).cloned()
     }
 
+    /// Gets a mutable reference to the value in the cache mapped to by `key` via a callback function.
+    ///
+    /// If no value exists for `key`, the callback will not be invoked and this returns `false`.
+    /// Otherwise, the callback is invoked with a mutable reference to the value and this returns `true`.
+    ///
+    /// This operation marks the entry as "visited" in the SIEVE algorithm,
+    /// which affects eviction decisions.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use sieve_cache::SyncSieveCache;
+    /// let cache = SyncSieveCache::new(100).unwrap();
+    /// cache.insert("key".to_string(), "value".to_string());
+    ///
+    /// // Modify the value in-place
+    /// cache.get_mut(&"key".to_string(), |value| {
+    ///     *value = "new_value".to_string();
+    /// });
+    ///
+    /// assert_eq!(cache.get(&"key".to_string()), Some("new_value".to_string()));
+    /// ```
+    pub fn get_mut<Q, F>(&self, key: &Q, f: F) -> bool
+    where
+        Q: Hash + Eq + ?Sized,
+        K: Borrow<Q>,
+        F: FnOnce(&mut V),
+    {
+        let mut guard = self.locked_cache();
+        if let Some(value) = guard.get_mut(key) {
+            f(value);
+            true
+        } else {
+            false
+        }
+    }
+
     /// Maps `key` to `value` in the cache, possibly evicting old entries.
     ///
     /// This method returns `true` when this is a new entry, and `false` if an existing entry was
@@ -348,4 +385,25 @@ mod tests {
 
         assert_eq!(cache.len(), 3);
     }
+
+    #[test]
+    fn test_get_mut() {
+        let cache = SyncSieveCache::new(100).unwrap();
+        cache.insert("key".to_string(), "value".to_string());
+
+        // Modify the value in-place
+        let modified = cache.get_mut(&"key".to_string(), |value| {
+            *value = "new_value".to_string();
+        });
+        assert!(modified);
+
+        // Verify the value was updated
+        assert_eq!(cache.get(&"key".to_string()), Some("new_value".to_string()));
+
+        // Try to modify a non-existent key
+        let modified = cache.get_mut(&"missing".to_string(), |_| {
+            panic!("This should not be called");
+        });
+        assert!(!modified);
+    }
 }