feat: add Cache#compute and Cache#computeIfPresent (#31)

Author: iProdigy

api/src/main/java/io/github/xanthic/cache/api/Cache.java

@@ -67,6 +67,18 @@ public interface Cache<K, V> {
 	 */
 	long size();
 
+	/**
+	 * Computes what value should be associated with the specified key, or null if the mapping should be removed.
+	 *
+	 * @param key         the key with which the specified value is to be associated
+	 * @param computeFunc the function to compute a value
+	 * @return the new value associated with the specified key, or null if none
+	 * @throws NullPointerException if the specified key is null and this cache does not support null keys, or the compute function is null
+	 * @implNote atomicity is dependent on provider characteristics
+	 */
+	@Nullable
+	V compute(K key, @NotNull BiFunction<? super K, ? super V, ? extends V> computeFunc);
+
 	/**
 	 * Obtains the value currently associated with the specified key,
 	 * or atomically stores the computed value if no prior mapping existed.
@@ -78,6 +90,19 @@ public interface Cache<K, V> {
 	 */
 	V computeIfAbsent(K key, @NotNull Function<K, V> computeFunc);
 
+	/**
+	 * Computes a new value for a specific key, if a mapping already existed.
+	 * <p>
+	 * If the compute function yields null, the mapping should be removed.
+	 *
+	 * @param key         the key whose mapping should be updated
+	 * @param computeFunc the function to compute the new value for an already existing mapping
+	 * @return the new value associated with the key, or null if none
+	 * @throws NullPointerException if the specified key is null and this cache does not support null keys, or the compute function is null
+	 */
+	@Nullable
+	V computeIfPresent(K key, @NotNull BiFunction<? super K, ? super V, ? extends V> computeFunc);
+
 	/**
 	 * Creates a mapping from the specified key to the specified value,
 	 * if no mapping for the key already existed.

core/src/main/java/io/github/xanthic/cache/core/AbstractCache.java

@@ -2,6 +2,7 @@
 
 import io.github.xanthic.cache.api.Cache;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
 
 import java.util.Objects;
 import java.util.function.BiFunction;
@@ -37,6 +38,39 @@ public V computeIfAbsent(K key, @NotNull Function<K, V> computeFunc) {
 		}
 	}
 
+	@Nullable
+	@Override
+	public V compute(K key, @NotNull BiFunction<? super K, ? super V, ? extends V> computeFunc) {
+		synchronized (getLock()) {
+			V oldValue = this.get(key);
+			V newValue = computeFunc.apply(key, oldValue);
+			if (newValue != null) {
+				this.put(key, newValue);
+				return newValue;
+			} else if (oldValue != null) {
+				this.remove(key);
+			}
+		}
+		return null;
+	}
+
+	@Override
+	public V computeIfPresent(K key, @NotNull BiFunction<? super K, ? super V, ? extends V> computeFunc) {
+		synchronized (getLock()) {
+			V oldValue = this.get(key);
+			if (oldValue != null) {
+				V newValue = computeFunc.apply(key, oldValue);
+				if (newValue != null) {
+					this.put(key, newValue);
+					return newValue;
+				} else {
+					this.remove(key);
+				}
+			}
+		}
+		return null;
+	}
+
 	@Override
 	public V putIfAbsent(K key, V value) {
 		synchronized (getLock()) {

core/src/main/java/io/github/xanthic/cache/core/delegate/GenericMapCacheDelegate.java

@@ -5,6 +5,7 @@
 import io.github.xanthic.cache.api.ICacheSpec;
 import lombok.Data;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
 
 import java.util.Map;
 import java.util.function.BiFunction;
@@ -32,11 +33,22 @@ public V put(K key, V value) {
 		return map.put(key, value);
 	}
 
+	@Nullable
+	@Override
+	public V compute(K key, @NotNull BiFunction<? super K, ? super V, ? extends V> computeFunc) {
+		return map.compute(key, computeFunc);
+	}
+
 	@Override
 	public V computeIfAbsent(K key, @NotNull Function<K, V> computeFunc) {
 		return map.computeIfAbsent(key, computeFunc);
 	}
 
+	@Override
+	public V computeIfPresent(K key, @NotNull BiFunction<? super K, ? super V, ? extends V> computeFunc) {
+		return map.computeIfPresent(key, computeFunc);
+	}
+
 	@Override
 	public V remove(K key) {
 		return map.remove(key);

core/src/testFixtures/java/io/github/xanthic/cache/core/provider/ProviderTestBase.java

@@ -59,7 +59,7 @@ public void putGetClearTest() {
 	}
 
 	@Test
-	@DisplayName("Tests cache computeIfAbsent, merge, and remove")
+	@DisplayName("Tests cache compute, computeIfAbsent, computeIfPresent, merge, and remove")
 	public void computeMergeRemoveTest() {
 		// Build cache
 		Cache<String, Integer> cache = build(null);
@@ -71,9 +71,30 @@ public void computeMergeRemoveTest() {
 		// Test merge
 		Assertions.assertEquals(420 + 69, cache.merge("4/20", 69, Integer::sum));
 
+		// Test computeIfPresent
+		Assertions.assertNull(cache.computeIfPresent("", (k, v) -> 0));
+		Assertions.assertNull(cache.put("", 0));
+		Assertions.assertNull(cache.computeIfPresent("", (k, v) -> null));
+		Assertions.assertNull(cache.get(""));
+
+		Assertions.assertEquals(420 + 69 + 1, cache.computeIfPresent("4/20", (k, v) -> v + 1));
+
 		// Test remove
-		Assertions.assertEquals(420 + 69, cache.remove("4/20"));
+		Assertions.assertEquals(420 + 70, cache.remove("4/20"));
 		Assertions.assertNull(cache.get("4/20"));
+
+		// Test compute
+		Assertions.assertNull(cache.compute("a", (k, v) -> null));
+		Assertions.assertNull(cache.get("a"));
+
+		Assertions.assertEquals(9, cache.compute("a", (k, v) -> 9));
+		Assertions.assertEquals(9, cache.get("a"));
+
+		Assertions.assertEquals(10, cache.compute("a", (k, v) -> v + 1));
+		Assertions.assertEquals(10, cache.get("a"));
+
+		Assertions.assertNull(cache.compute("a", (k, v) -> null));
+		Assertions.assertNull(cache.get("a"));
 	}
 
 	@Test

provider-infinispan/src/main/java/io/github/xanthic/cache/provider/infinispan/InfinispanDelegate.java

@@ -3,6 +3,7 @@
 import io.github.xanthic.cache.api.Cache;
 import lombok.Value;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
 
 import java.util.Map;
 import java.util.function.BiFunction;
@@ -37,11 +38,22 @@ public long size() {
 		return cache.size();
 	}
 
+	@Nullable
+	@Override
+	public V compute(K key, @NotNull BiFunction<? super K, ? super V, ? extends V> computeFunc) {
+		return cache.compute(key, computeFunc);
+	}
+
 	@Override
 	public V computeIfAbsent(K key, @NotNull Function<K, V> computeFunc) {
 		return cache.computeIfAbsent(key, computeFunc);
 	}
 
+	@Override
+	public V computeIfPresent(K key, @NotNull BiFunction<? super K, ? super V, ? extends V> computeFunc) {
+		return cache.computeIfPresent(key, computeFunc);
+	}
+
 	@Override
 	public V putIfAbsent(K key, V value) {
 		return cache.putIfAbsent(key, value);