New methods for maps (computeIfAbsent, computeIfPresent) (#11)

* Add computeIfAbsent and computeIfPresent

Adds computeIfAbsent() and computeIfPresent() methods to all versions of the maps.

* Upgrade to Java 11

* More unit tests

* Move pom properties to build script

* Update fastutil library

* release v0.2.0

Author: erdoganf

build.gradle

@@ -16,10 +16,42 @@ allprojects {
 }
 
 group 'com.trivago'
-version '0.1.1-SNAPSHOT'
+version '0.2.0'
 
-sourceCompatibility = 1.8
-targetCompatibility = 1.8
+mavenPublishing {
+    pom {
+        name = "fastutil-concurrent-wrapper"
+        description = "Set of concurrent wrappers around fastutil primitive maps."
+        url = "https://github.com/trivago/fastutil-concurrent-wrapper"
+        licenses {
+            license {
+                name = "The Apache Software License, Version 2.0"
+                url = "https://opensource.org/licenses/Apache-2.0"
+                distribution = "repo"
+            }
+        }
+        developers {
+            developer {
+                id = "mchernyakov"
+                name = "Mikhail Chernyakov"
+                url = "https://github.com/mchernyakov"
+            }
+            developer {
+                id = "erdoganf"
+                name = "Fehim Erdogan"
+                url = "https://github.com/erdoganf"
+            }
+        }
+        scm {
+            url = "https://github.com/trivago/fastutil-concurrent-wrapper"
+            connection = "scm:git:https://github.com/trivago/fastutil-concurrent-wrapper"
+            developerConnection = "scm:git:https://github.com/trivago/fastutil-concurrent-wrapper"
+        }
+    }
+}
+
+sourceCompatibility = 11
+targetCompatibility = 11
 
 sourceSets {
     jmh {
@@ -30,7 +62,7 @@ sourceSets {
 }
 
 dependencies {
-    implementation group: 'it.unimi.dsi', name: 'fastutil', version: '8.5.6'
+    implementation group: 'it.unimi.dsi', name: 'fastutil', version: '8.5.9'
 
     testImplementation 'org.junit.jupiter:junit-jupiter-api:5.8.2'
     testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.8.2'

gradle.properties

@@ -1,5 +1,9 @@
 package com.trivago.fastutilconcurrentwrapper;
 
+import it.unimi.dsi.fastutil.ints.Int2FloatFunction;
+
+import java.util.function.BiFunction;
+
 public interface IntFloatMap extends PrimitiveIntKeyMap {
 
     float DEFAULT_VALUE = 0.0f;
@@ -13,4 +17,8 @@ public interface IntFloatMap extends PrimitiveIntKeyMap {
     float remove(int key);
 
     boolean remove(int key, float value);
+
+    float computeIfAbsent(int key, Int2FloatFunction mappingFunction);
+
+    float computeIfPresent(int key, BiFunction<Integer, Float, Float> mappingFunction);
 }

src/main/java/com/trivago/fastutilconcurrentwrapper/IntFloatMap.java

@@ -1,5 +1,9 @@
 package com.trivago.fastutilconcurrentwrapper;
 
+import it.unimi.dsi.fastutil.ints.Int2IntFunction;
+
+import java.util.function.BiFunction;
+
 public interface IntIntMap extends PrimitiveIntKeyMap {
 
     int DEFAULT_VALUE = 0;
@@ -17,4 +21,8 @@ public interface IntIntMap extends PrimitiveIntKeyMap {
     int remove(int key);
 
     boolean remove(int key, int value);
+
+    int computeIfAbsent(int key, Int2IntFunction mappingFunction);
+
+    int computeIfPresent(int key, BiFunction<Integer, Integer, Integer> mappingFunction);
 }

src/main/java/com/trivago/fastutilconcurrentwrapper/IntIntMap.java

@@ -1,5 +1,9 @@
 package com.trivago.fastutilconcurrentwrapper;
 
+import it.unimi.dsi.fastutil.longs.Long2FloatFunction;
+
+import java.util.function.BiFunction;
+
 public interface LongFloatMap extends PrimitiveLongKeyMap {
 
     float DEFAULT_VALUE = 0.0f;
@@ -18,9 +22,14 @@ public interface LongFloatMap extends PrimitiveLongKeyMap {
 
     /**
      * Remove this key only if it has the given value.
+     *
      * @param key
      * @param value
      * @return
      */
     boolean remove(long key, float value);
+
+    float computeIfAbsent(long key, Long2FloatFunction mappingFunction);
+
+    float computeIfPresent(int key, BiFunction<Long, Float, Float> mappingFunction);
 }

src/main/java/com/trivago/fastutilconcurrentwrapper/LongFloatMap.java

@@ -1,5 +1,9 @@
 package com.trivago.fastutilconcurrentwrapper;
 
+import it.unimi.dsi.fastutil.longs.Long2LongFunction;
+
+import java.util.function.BiFunction;
+
 public interface LongLongMap extends PrimitiveLongKeyMap {
 
     long DEFAULT_VALUE = 0;
@@ -17,4 +21,8 @@ public interface LongLongMap extends PrimitiveLongKeyMap {
     long remove(long key);
 
     boolean remove(long key, long value);
+
+    long computeIfAbsent(long key, Long2LongFunction mappingFunction);
+
+    long computeIfPresent(long key, BiFunction<Long, Long, Long> mappingFunction);
 }

src/main/java/com/trivago/fastutilconcurrentwrapper/LongLongMap.java

@@ -2,8 +2,10 @@
 
 import com.trivago.fastutilconcurrentwrapper.IntFloatMap;
 import com.trivago.fastutilconcurrentwrapper.wrapper.PrimitiveFastutilIntFloatWrapper;
+import it.unimi.dsi.fastutil.ints.Int2FloatFunction;
 
 import java.util.concurrent.locks.Lock;
+import java.util.function.BiFunction;
 
 public class ConcurrentBusyWaitingIntFloatMap extends PrimitiveConcurrentMap implements IntFloatMap {
 
@@ -124,4 +126,37 @@ public boolean remove(int key, float value) {
         }
     }
 
+    @Override
+    public float computeIfAbsent(int key, Int2FloatFunction mappingFunction) {
+        int bucket = getBucket(key);
+
+        Lock writeLock = locks[bucket].writeLock();
+
+        while (true) {
+            if (writeLock.tryLock()) {
+                try {
+                    return maps[bucket].computeIfAbsent(key, mappingFunction);
+                } finally {
+                    writeLock.unlock();
+                }
+            }
+        }
+    }
+
+    @Override
+    public float computeIfPresent(int key, BiFunction<Integer, Float, Float> mappingFunction) {
+        int bucket = getBucket(key);
+
+        Lock writeLock = locks[bucket].writeLock();
+
+        while (true) {
+            if (writeLock.tryLock()) {
+                try {
+                    return maps[bucket].computeIfPresent(key, mappingFunction);
+                } finally {
+                    writeLock.unlock();
+                }
+            }
+        }
+    }
 }

src/main/java/com/trivago/fastutilconcurrentwrapper/map/ConcurrentBusyWaitingIntFloatMap.java

@@ -2,8 +2,10 @@
 
 import com.trivago.fastutilconcurrentwrapper.IntIntMap;
 import com.trivago.fastutilconcurrentwrapper.wrapper.PrimitiveFastutilIntIntWrapper;
+import it.unimi.dsi.fastutil.ints.Int2IntFunction;
 
 import java.util.concurrent.locks.Lock;
+import java.util.function.BiFunction;
 
 public class ConcurrentBusyWaitingIntIntMap extends PrimitiveConcurrentMap implements IntIntMap {
 
@@ -123,4 +125,38 @@ public boolean remove(int key, int value) {
             }
         }
     }
+
+    @Override
+    public int computeIfAbsent(int key, Int2IntFunction mappingFunction) {
+        int bucket = getBucket(key);
+
+        Lock writeLock = locks[bucket].writeLock();
+
+        while (true) {
+            if (writeLock.tryLock()) {
+                try {
+                    return maps[bucket].computeIfAbsent(key, mappingFunction);
+                } finally {
+                    writeLock.unlock();
+                }
+            }
+        }
+    }
+
+    @Override
+    public int computeIfPresent(int key, BiFunction<Integer, Integer, Integer> mappingFunction) {
+        int bucket = getBucket(key);
+
+        Lock writeLock = locks[bucket].writeLock();
+
+        while (true) {
+            if (writeLock.tryLock()) {
+                try {
+                    return maps[bucket].computeIfPresent(key, mappingFunction);
+                } finally {
+                    writeLock.unlock();
+                }
+            }
+        }
+    }
 }

src/main/java/com/trivago/fastutilconcurrentwrapper/map/ConcurrentBusyWaitingIntIntMap.java

@@ -2,8 +2,10 @@
 
 import com.trivago.fastutilconcurrentwrapper.LongFloatMap;
 import com.trivago.fastutilconcurrentwrapper.wrapper.PrimitiveFastutilLongFloatWrapper;
+import it.unimi.dsi.fastutil.longs.Long2FloatFunction;
 
 import java.util.concurrent.locks.Lock;
+import java.util.function.BiFunction;
 
 public class ConcurrentBusyWaitingLongFloatMap extends PrimitiveConcurrentMap implements LongFloatMap {
 
@@ -121,4 +123,38 @@ public boolean remove(long key, float value) {
             }
         }
     }
+
+    @Override
+    public float computeIfAbsent(long key, Long2FloatFunction mappingFunction) {
+        int bucket = getBucket(key);
+
+        Lock writeLock = locks[bucket].writeLock();
+
+        while (true) {
+            if (writeLock.tryLock()) {
+                try {
+                    return maps[bucket].computeIfAbsent(key, mappingFunction);
+                } finally {
+                    writeLock.unlock();
+                }
+            }
+        }
+    }
+
+    @Override
+    public float computeIfPresent(int key, BiFunction<Long, Float, Float> mappingFunction) {
+        int bucket = getBucket(key);
+
+        Lock writeLock = locks[bucket].writeLock();
+
+        while (true) {
+            if (writeLock.tryLock()) {
+                try {
+                    return maps[bucket].computeIfPresent(key, mappingFunction);
+                } finally {
+                    writeLock.unlock();
+                }
+            }
+        }
+    }
 }

src/main/java/com/trivago/fastutilconcurrentwrapper/map/ConcurrentBusyWaitingLongFloatMap.java

@@ -2,8 +2,10 @@
 
 import com.trivago.fastutilconcurrentwrapper.LongLongMap;
 import com.trivago.fastutilconcurrentwrapper.wrapper.PrimitiveFastutilLongLongWrapper;
+import it.unimi.dsi.fastutil.longs.Long2LongFunction;
 
 import java.util.concurrent.locks.Lock;
+import java.util.function.BiFunction;
 
 public class ConcurrentBusyWaitingLongLongMap extends PrimitiveConcurrentMap implements LongLongMap {
 
@@ -123,4 +125,38 @@ public boolean remove(long key, long value) {
             }
         }
     }
+
+    @Override
+    public long computeIfAbsent(long key, Long2LongFunction mappingFunction) {
+        int bucket = getBucket(key);
+
+        Lock writeLock = locks[bucket].writeLock();
+
+        while (true) {
+            if (writeLock.tryLock()) {
+                try {
+                    return maps[bucket].computeIfAbsent(key, mappingFunction);
+                } finally {
+                    writeLock.unlock();
+                }
+            }
+        }
+    }
+
+    @Override
+    public long computeIfPresent(long key, BiFunction<Long, Long, Long> mappingFunction) {
+        int bucket = getBucket(key);
+
+        Lock writeLock = locks[bucket].writeLock();
+
+        while (true) {
+            if (writeLock.tryLock()) {
+                try {
+                    return maps[bucket].computeIfPresent(key, mappingFunction);
+                } finally {
+                    writeLock.unlock();
+                }
+            }
+        }
+    }
 }