Extend API v10

README.md

@@ -45,7 +45,7 @@ repositories {
 }
 
 ext {
-    rlibVersion = "10.0.alpha10"
+    rlibVersion = "10.0.alpha11"
 }
 
 dependencies {

build.gradle

@@ -1,4 +1,4 @@
-rootProject.version = "10.0.alpha10"
+rootProject.version = "10.0.alpha11"
 group = 'javasabr.rlib'
 
 allprojects {

rlib-classpath/src/test/java/javasabr/rlib/classpath/ClasspathScannerTests.java

@@ -1,11 +1,12 @@
 package javasabr.rlib.classpath;
 
+import static org.assertj.core.api.Assertions.assertThat;
+
 import java.util.Collection;
 import javasabr.rlib.collections.array.Array;
 import javasabr.rlib.collections.array.impl.AbstractArray;
 import javasabr.rlib.logger.api.LoggerLevel;
 import javasabr.rlib.logger.api.LoggerManager;
-import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
 
 /**
@@ -26,10 +27,10 @@ void testSystemClasspathScanner() {
 
     Array<Class<Collection>> implementations = scanner.findImplementations(Collection.class);
 
-    Assertions.assertFalse(implementations.isEmpty());
+    assertThat(implementations.isEmpty()).isFalse();
 
     Array<Class<AbstractArray>> inherited = scanner.findInherited(AbstractArray.class);
 
-    Assertions.assertFalse(inherited.isEmpty());
+    assertThat(inherited.isEmpty()).isFalse();
   }
 }

rlib-collections/src/main/java/javasabr/rlib/collections/array/impl/AbstractMutableArray.java

@@ -11,7 +11,6 @@
 import java.util.stream.StreamSupport;
 import javasabr.rlib.collections.array.Array;
 import javasabr.rlib.collections.array.UnsafeMutableArray;
-import javasabr.rlib.common.util.ObjectUtils;
 import lombok.AccessLevel;
 import lombok.experimental.FieldDefaults;
 import org.jspecify.annotations.Nullable;

rlib-collections/src/main/java/javasabr/rlib/collections/dictionary/MutableIntToRefDictionary.java

@@ -25,6 +25,12 @@ static <V> MutableIntToRefDictionary<V> ofTypes(Class<V> valueType) {
   @Nullable
   V put(int key, V value);
 
+  /**
+   * @return the existing value if the key is already present, or null if the key was absent and the new mapping was added.
+   */
+  @Nullable
+  V putIfAbsent(int key, V value);
+
   void putAll(IntToRefDictionary<? extends V> dictionary);
 
   MutableIntToRefDictionary<V> append(IntToRefDictionary<? extends V> dictionary);
@@ -40,6 +46,11 @@ static <V> MutableIntToRefDictionary<V> ofTypes(Class<V> valueType) {
   @Nullable
   V remove(int key);
 
+  /**
+   * @return true if the expectedValue was removed
+   */
+  boolean remove(int key, V expectedValue);
+
   /**
    * @return the optional value of the previous value for the key.
    */

rlib-collections/src/main/java/javasabr/rlib/collections/dictionary/MutableLongToRefDictionary.java

@@ -25,6 +25,12 @@ static <V> MutableLongToRefDictionary<V> ofTypes(Class<V> valueType) {
   @Nullable
   V put(long key, V value);
 
+  /**
+   * @return the existing value if the key is already present, or null if the key was absent and the new mapping was added.
+   */
+  @Nullable
+  V putIfAbsent(long key, V value);
+
   void putAll(LongToRefDictionary<? extends V> dictionary);
 
   MutableLongToRefDictionary<V> append(LongToRefDictionary<? extends V> dictionary);
@@ -40,6 +46,11 @@ static <V> MutableLongToRefDictionary<V> ofTypes(Class<V> valueType) {
   @Nullable
   V remove(long key);
 
+  /**
+   * @return true if the expectedValue was removed
+   */
+  boolean remove(long key, V expectedValue);
+
   /**
    * @return the optional value of the previous value for the key.
    */

rlib-collections/src/main/java/javasabr/rlib/collections/dictionary/MutableRefToRefDictionary.java

@@ -26,6 +26,12 @@ static <K, V> MutableRefToRefDictionary<K, V> ofTypes(
   @Nullable
   V put(K key, V value);
 
+  /**
+   * @return the existing value if the key is already present, or null if the key was absent and the new mapping was added.
+   */
+  @Nullable 
+  V putIfAbsent(K key, V value);
+
   void putAll(RefToRefDictionary<? extends K, ? extends V> dictionary);
 
   MutableRefToRefDictionary<K, V> append(RefToRefDictionary<? extends K, ? extends V> dictionary);
@@ -41,6 +47,11 @@ static <K, V> MutableRefToRefDictionary<K, V> ofTypes(
   @Nullable
   V remove(K key);
 
+  /**
+   * @return true if the expectedValue was removed
+   */
+  boolean remove(K key, V expectedValue);
+
   /**
    * @return the optional value of the previous value for the key.
    */

rlib-collections/src/main/java/javasabr/rlib/collections/dictionary/impl/AbstractMutableHashBasedIntToRefDictionary.java

@@ -1,5 +1,6 @@
 package javasabr.rlib.collections.dictionary.impl;
 
+import java.util.Objects;
 import java.util.Optional;
 import java.util.function.Function;
 import java.util.function.IntFunction;
@@ -84,6 +85,23 @@ public V put(int key, V value) {
     return null;
   }
 
+  @Nullable
+  @Override
+  public V putIfAbsent(int key, V value) {
+    @Nullable E[] entries = entries();
+    int hash = hash(key);
+    int entryIndex = indexFor(hash, entries.length);
+
+    for (E entry = entries[entryIndex]; entry != null; entry = entry.next()) {
+      if (entry.hash() == hash && key == entry.key()) {
+        return entry.value();
+      }
+    }
+
+    addEntry(hash, key, value, entryIndex);
+    return null;
+  }
+
   @Override
   public Optional<V> putOptional(int key, V value) {
     return Optional.ofNullable(put(key, value));
@@ -120,6 +138,37 @@ public V remove(int key) {
     return removed.value();
   }
 
+  @Override
+  public boolean remove(int key, V expectedValue) {
+    @Nullable E[] entries = entries();
+    int hash = hash(key);
+    int entryIndex = indexFor(hash, entries.length);
+
+    E previousEntry = entries[entryIndex];
+    E entry = previousEntry;
+
+    while (entry != null) {
+      E nextEntry = entry.next();
+      if (entry.hash() == hash && key == entry.key()) {
+        if (Objects.equals(entry.value(), expectedValue)) {
+          decrementSize();
+          if (previousEntry == entry) {
+            entries[entryIndex] = nextEntry;
+          } else {
+            previousEntry.next(nextEntry);
+          }
+          return true;
+        } else {
+          return false;
+        }
+      }
+      previousEntry = entry;
+      entry = nextEntry;
+    }
+
+    return false;
+  }
+
   @Override
   public Optional<V> removeOptional(int key) {
     return Optional.ofNullable(remove(key));

rlib-collections/src/main/java/javasabr/rlib/collections/dictionary/impl/AbstractMutableHashBasedLongToRefDictionary.java

@@ -1,5 +1,6 @@
 package javasabr.rlib.collections.dictionary.impl;
 
+import java.util.Objects;
 import java.util.Optional;
 import java.util.function.Function;
 import java.util.function.LongFunction;
@@ -83,7 +84,24 @@ public V put(long key, V value) {
     addEntry(hash, key, value, entryIndex);
     return null;
   }
+
+  @Nullable
+  @Override
+  public V putIfAbsent(long key, V value) {
+    @Nullable E[] entries = entries();
+    int hash = hash(Long.hashCode(key));
+    int entryIndex = indexFor(hash, entries.length);
 
+    for (E entry = entries[entryIndex]; entry != null; entry = entry.next()) {
+      if (entry.hash() == hash && key == entry.key()) {
+        return entry.value();
+      }
+    }
+
+    addEntry(hash, key, value, entryIndex);
+    return null;
+  }
+
   @Override
   public Optional<V> putOptional(long key, V value) {
     return Optional.ofNullable(put(key, value));
@@ -120,6 +138,37 @@ public V remove(long key) {
     return removed.value();
   }
 
+  @Override
+  public boolean remove(long key, V expectedValue) {
+    @Nullable E[] entries = entries();
+    int hash = hash(Long.hashCode(key));
+    int entryIndex = indexFor(hash, entries.length);
+
+    E previousEntry = entries[entryIndex];
+    E entry = previousEntry;
+
+    while (entry != null) {
+      E nextEntry = entry.next();
+      if (entry.hash() == hash && key == entry.key()) {
+        if (Objects.equals(entry.value(), expectedValue)) {
+          decrementSize();
+          if (previousEntry == entry) {
+            entries[entryIndex] = nextEntry;
+          } else {
+            previousEntry.next(nextEntry);
+          }
+          return true;
+        } else {
+          return false;
+        }
+      }
+      previousEntry = entry;
+      entry = nextEntry;
+    }
+
+    return false;
+  }
+
   @Override
   public Optional<V> removeOptional(long key) {
     return Optional.ofNullable(remove(key));

rlib-collections/src/main/java/javasabr/rlib/collections/dictionary/impl/AbstractMutableHashBasedRefToRefDictionary.java

@@ -1,5 +1,6 @@
 package javasabr.rlib.collections.dictionary.impl;
 
+import java.util.Objects;
 import java.util.Optional;
 import java.util.function.Function;
 import java.util.function.Supplier;
@@ -83,6 +84,23 @@ public V put(K key, V value) {
     return null;
   }
 
+  @Nullable
+  @Override
+  public V putIfAbsent(K key, V value) {
+    @Nullable E[] entries = entries();
+    int hash = hash(key.hashCode());
+    int entryIndex = indexFor(hash, entries.length);
+
+    for (E entry = entries[entryIndex]; entry != null; entry = entry.next()) {
+      if (entry.hash() == hash && key.equals(entry.key())) {
+        return entry.value();
+      }
+    }
+
+    addEntry(hash, key, value, entryIndex);
+    return null;
+  }
+
   @Override
   public Optional<V> putOptional(K key, V value) {
     return Optional.ofNullable(put(key, value));
@@ -119,6 +137,37 @@ public V remove(K key) {
     return removed.value();
   }
 
+  @Override
+  public boolean remove(K key, V expectedValue) {
+    @Nullable E[] entries = entries();
+    int hash = hash(key.hashCode());
+    int entryIndex = indexFor(hash, entries.length);
+
+    E previousEntry = entries[entryIndex];
+    E entry = previousEntry;
+
+    while (entry != null) {
+      E nextEntry = entry.next();
+      if (entry.hash() == hash && key.equals(entry.key())) {
+        if (Objects.equals(entry.value(), expectedValue)) {
+          decrementSize();
+          if (previousEntry == entry) {
+            entries[entryIndex] = nextEntry;
+          } else {
+            previousEntry.next(nextEntry);
+          }
+          return true;
+        } else {
+          return false;
+        }
+      }
+      previousEntry = entry;
+      entry = nextEntry;
+    }
+
+    return false;
+  }
+
   @Override
   public Optional<V> removeOptional(K key) {
     return Optional.ofNullable(remove(key));