extend API, update network connection API, add builders for array and dictionary

Author: JavaSaBr

README.md

@@ -14,7 +14,7 @@ repositories {
 }
 
 ext {
-   rlibVersion = "10.0.alpha8"
+   rlibVersion = "10.0.alpha9"
 }
 
 dependencies {

build.gradle

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

rlib-collections/src/main/java/javasabr/rlib/collections/array/Array.java

@@ -23,6 +23,10 @@ static <E> Array<E> empty(Class<? super E> type) {
     return new ImmutableArray<>(ClassUtils.unsafeCast(type));
   }
 
+  static <E> ArrayBuilder<E> builder(Class<? super E> type) {
+    return new ArrayBuilder<>(type);
+  }
+  
   static <E> Array<E> of(E single) {
     @SuppressWarnings("unchecked")
     Class<E> type = (Class<E>) single.getClass();
@@ -95,6 +99,14 @@ static <E> Array<E> copyOf(Array<E> array) {
     return new ImmutableArray<>(array.type(), array.toArray());
   }
 
+  static <E> Array<E> copyOf(Class<? super E> type, Collection<E> collection) {
+    if (collection instanceof MutableArray<E> mutableArray) {
+      return copyOf(mutableArray);
+    }
+    E[] array = collection.toArray(ArrayUtils.create(type, collection.size()));
+    return ImmutableArray.trustWrap(array);
+  }
+
   Class<E> type();
 
   /**

rlib-collections/src/main/java/javasabr/rlib/collections/array/ArrayBuilder.java

@@ -0,0 +1,40 @@
+package javasabr.rlib.collections.array;
+
+import java.util.Collection;
+import lombok.AccessLevel;
+import lombok.experimental.FieldDefaults;
+
+@FieldDefaults(level = AccessLevel.PRIVATE, makeFinal = true)
+public final class ArrayBuilder<E> {
+
+  MutableArray<E> elements;
+
+  public ArrayBuilder(Class<? super E> type) {
+    this.elements = ArrayFactory.mutableArray(type);
+  }
+
+  public ArrayBuilder<E> add(E element) {
+    elements.add(element);
+    return this;
+  }
+
+  @SafeVarargs
+  public final ArrayBuilder<E> add(E... other) {
+    elements.addAll(other);
+    return this;
+  }
+
+  public ArrayBuilder<E> add(Collection<E> other) {
+    elements.addAll(other);
+    return this;
+  }
+
+  public ArrayBuilder<E> add(Array<E> other) {
+    elements.addAll(other);
+    return this;
+  }
+
+  public Array<E> build() {
+    return Array.copyOf(elements);
+  }
+}

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

@@ -6,6 +6,21 @@
 
 public interface RefToRefDictionary<K, V> extends Dictionary<K, V> {
 
+  static <K, V> RefToRefDictionaryBuilder<K, V> builder() {
+    return new RefToRefDictionaryBuilder<>();
+  }
+
+  static <K, V> RefToRefDictionaryBuilder<K, V> builder(
+      Class<? super K> keyType, 
+      Class<? super V> valueType) {
+    return new RefToRefDictionaryBuilder<>();
+  }
+
+  static <K, V> RefToRefDictionaryBuilder<K, V> startWith(K key, V value) {
+    return new RefToRefDictionaryBuilder<K, V>()
+        .put(key, value);
+  }
+  
   static <K, V> RefToRefEntry<K, V> entry(K key, V value) {
     return new SimpleRefToRefEntry<>(key, value);
   }
@@ -22,6 +37,14 @@ static <K, V> RefToRefDictionary<K, V> of(K k1, V v1, K k2, V v2) {
     return ofEntries(entry(k1, v1), entry(k2, v2));
   }
 
+  static <K, V> RefToRefDictionary<K, V> of(K k1, V v1, K k2, V v2, K k3, V v3) {
+    return ofEntries(entry(k1, v1), entry(k2, v2), entry(k3, v3));
+  }
+
+  static <K, V> RefToRefDictionary<K, V> of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4) {
+    return ofEntries(entry(k1, v1), entry(k2, v2), entry(k3, v3), entry(k4, v4));
+  }
+
   @SafeVarargs
   static <K, V> RefToRefDictionary<K, V> ofEntries(RefToRefEntry<K, V>... entries) {
     MutableRefToRefDictionary<K, V> mutable = DictionaryFactory.mutableRefToRefDictionary();

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

@@ -0,0 +1,36 @@
+package javasabr.rlib.collections.dictionary;
+
+import java.util.Map;
+import lombok.AccessLevel;
+import lombok.experimental.FieldDefaults;
+
+@FieldDefaults(level = AccessLevel.PRIVATE, makeFinal = true)
+public class RefToRefDictionaryBuilder<K, V> {
+  
+  MutableRefToRefDictionary<K, V> elements;
+
+  public RefToRefDictionaryBuilder() {
+    this.elements = DictionaryFactory.mutableRefToRefDictionary();
+  }
+  
+  public RefToRefDictionaryBuilder<K, V> put(K key, V value) {
+    this.elements.put(key, value);
+    return this;
+  }
+
+  public RefToRefDictionaryBuilder<K, V> put(RefToRefDictionary<K, V> other) {
+    this.elements.putAll(other);
+    return this;
+  }
+
+  public RefToRefDictionaryBuilder<K, V> put(Map<K, V> other) {
+    for (Map.Entry<K, V> entry : other.entrySet()) {
+      elements.put(entry.getKey(), entry.getValue());
+    }
+    return this;
+  }
+  
+  public RefToRefDictionary<K, V> build() {
+    return elements.toReadOnly();
+  }
+}

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

@@ -3,4 +3,5 @@
 import javasabr.rlib.collections.dictionary.Dictionary;
 
 public abstract class AbstractDictionary<K, V> implements Dictionary<K, V> {
+  
 }

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

@@ -1,5 +1,6 @@
 package javasabr.rlib.collections.dictionary.impl;
 
+import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.Iterator;
@@ -11,6 +12,7 @@
 import javasabr.rlib.collections.array.MutableArray;
 import javasabr.rlib.collections.array.UnsafeMutableArray;
 import javasabr.rlib.collections.dictionary.LinkedHashEntry;
+import javasabr.rlib.collections.dictionary.RefToRefDictionary;
 import javasabr.rlib.collections.dictionary.UnsafeRefToRefDictionary;
 import org.jspecify.annotations.Nullable;
 
@@ -161,6 +163,37 @@ public MutableArray<V> values(MutableArray<V> container) {
     return container;
   }
 
+  @Override
+  public int hashCode() {
+    return Arrays.hashCode(entries());
+  }
+
+  @Override
+  public boolean equals(Object obj) {
+    if (!(obj instanceof RefToRefDictionary<?, ?> another)) {
+      return false;
+    } else if (size() != another.size()) {
+      return false;
+    }
+
+    RefToRefDictionary<Object, Object> toCompare = (RefToRefDictionary<Object, Object>) obj;
+
+    for (E entry : entries()) {
+      while (entry != null) {
+        if (!toCompare.containsKey(entry.key())) {
+          return false;
+        }
+        V value = entry.value();
+        Object anotherValue = toCompare.get(entry.key());
+        if (!Objects.equals(value, anotherValue)) {
+          return false;
+        }
+        entry = entry.next();
+      }
+    }
+    return true;
+  }
+
   @Override
   public String toString() {
 

rlib-collections/src/test/java/javasabr/rlib/collections/array/ArrayBuilderTest.java

@@ -0,0 +1,26 @@
+package javasabr.rlib.collections.array;
+
+import java.util.List;
+import org.assertj.core.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+public class ArrayBuilderTest {
+
+  @Test
+  void shouldBuildArray() {
+    // when:
+    Array<String> result = Array
+        .builder(String.class)
+        .add("first")
+        .add("second")
+        .add(Array.of("third", "fourth"))
+        .add("fifth", "sixth")
+        .add(List.of("seventh", "eight"))
+        .build();
+
+    // then:
+    Assertions
+        .assertThat(result)
+        .isEqualTo(Array.of("first", "second", "third", "fourth", "fifth", "sixth", "seventh", "eight"));
+  }
+}

rlib-collections/src/test/java/javasabr/rlib/collections/dictionary/RefToRefDictionaryBuilderTest.java

@@ -0,0 +1,70 @@
+package javasabr.rlib.collections.dictionary;
+
+import java.util.Map;
+import org.assertj.core.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+public class RefToRefDictionaryBuilderTest {
+
+  @Test
+  void shouldBuildDictionaryCorrectly() {
+    // when:
+    RefToRefDictionary<Integer, String> dictionary = RefToRefDictionary
+        .<Integer, String>builder()
+        .put(15, "15")
+        .put(22, "22")
+        .put(RefToRefDictionary.of(30, "30", 45, "45"))
+        .build();
+
+    // then:
+    Assertions
+        .assertThat(dictionary)
+        .isEqualTo(RefToRefDictionary.of(15, "15", 22, "22", 30, "30", 45, "45"));
+  }
+
+  @Test
+  void shouldBuildWithTypesDictionaryCorrectly() {
+    // when:
+    RefToRefDictionary<Integer, String> dictionary = RefToRefDictionary
+        .builder(Integer.class, String.class)
+        .put(15, "15")
+        .put(22, "22")
+        .put(RefToRefDictionary.of(30, "30", 45, "45"))
+        .build();
+
+    // then:
+    Assertions
+        .assertThat(dictionary)
+        .isEqualTo(RefToRefDictionary.of(15, "15", 22, "22", 30, "30", 45, "45"));
+  }
+
+  @Test
+  void shouldBuildDictionaryUsingStartWithCorrectly() {
+    // when:
+    RefToRefDictionary<Integer, String> dictionary = RefToRefDictionary
+        .startWith(15, "15")
+        .put(22, "22")
+        .put(RefToRefDictionary.of(30, "30", 45, "45"))
+        .build();
+
+    // then:
+    Assertions
+        .assertThat(dictionary)
+        .isEqualTo(RefToRefDictionary.of(15, "15", 22, "22", 30, "30", 45, "45"));
+  }
+
+  @Test
+  void shouldBuildDictionaryBasedOnMap() {
+    // when:
+    RefToRefDictionary<Integer, String> dictionary = RefToRefDictionary
+        .builder(Integer.class, String.class)
+        .put(Map.of(15, "15", 22, "22"))
+        .put(Map.of(30, "30", 45, "45"))
+        .build();
+
+    // then:
+    Assertions
+        .assertThat(dictionary)
+        .isEqualTo(RefToRefDictionary.of(15, "15", 22, "22", 30, "30", 45, "45"));
+  }
+}