work on extending API

Author: JavaSaBr

README.md

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

build.gradle

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

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

@@ -126,6 +126,13 @@ public interface Dictionary<K, V> extends Iterable<V> {
    */
   MutableArray<V> values(MutableArray<V> container);
 
+  /**
+   * Collects part of values from this dictionary with starting from index with provided soft limit.
+   * 
+   * @return the index which can be used as startIndex for next iteration or -1
+   */
+  int values(MutableArray<V> container, int startIndex, int limit);
+  
   /**
    * Returns all values as an immutable array.
    *

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

@@ -225,4 +225,56 @@ public MutableArray<V> values(MutableArray<V> container) {
     }
     return container;
   }
+
+  @Override
+  public int values(MutableArray<V> container, int startIndex, int limit) {
+    if (isEmpty()) {
+      return -1;
+    }
+    UnsafeMutableArray<V> unsafe = container.asUnsafe();
+    unsafe.prepareForSize(Math.min(limit, size()));
+    E[] entries = entries();
+    for (int i = startIndex, length = entries.length; i < length; i++) {
+      if (unsafe.size() >= limit) {
+        return i;
+      }
+      E entry = entries[i];
+      while (entry != null) {
+        V value = entry.value();
+        if (value != null) {
+          unsafe.unsafeAdd(value);
+        }
+        entry = entry.next();
+      }
+    }
+    return -1;
+  }
+
+  @Override
+  public String toString() {
+    if (isEmpty()) {
+      return "[]";
+    }
+    StringBuilder builder = new StringBuilder("[");
+    for (E entry : entries()) {
+      while (entry != null) {
+        builder
+            .append('\'')
+            .append(entry.key())
+            .append('\'')
+            .append(":")
+            .append('\'')
+            .append(entry.value())
+            .append('\'')
+            .append(", ");
+
+        entry = entry.next();
+      }
+    }
+    if (builder.length() > 1) {
+      builder.delete(builder.length() - 2, builder.length());
+    }
+    builder.append("]");
+    return builder.toString();
+  }
 }

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

@@ -225,4 +225,56 @@ public MutableArray<V> values(MutableArray<V> container) {
     }
     return container;
   }
+
+  @Override
+  public int values(MutableArray<V> container, int startIndex, int limit) {
+    if (isEmpty()) {
+      return -1;
+    }
+    UnsafeMutableArray<V> unsafe = container.asUnsafe();
+    unsafe.prepareForSize(Math.min(limit, size()));
+    E[] entries = entries();
+    for (int i = startIndex, length = entries.length; i < length; i++) {
+      if (unsafe.size() >= limit) {
+        return i;
+      }
+      E entry = entries[i];
+      while (entry != null) {
+        V value = entry.value();
+        if (value != null) {
+          unsafe.unsafeAdd(value);
+        }
+        entry = entry.next();
+      }
+    }
+    return -1;
+  }
+
+  @Override
+  public String toString() {
+    if (isEmpty()) {
+      return "[]";
+    }
+    StringBuilder builder = new StringBuilder("[");
+    for (E entry : entries()) {
+      while (entry != null) {
+        builder
+            .append('\'')
+            .append(entry.key())
+            .append('\'')
+            .append(":")
+            .append('\'')
+            .append(entry.value())
+            .append('\'')
+            .append(", ");
+
+        entry = entry.next();
+      }
+    }
+    if (builder.length() > 1) {
+      builder.delete(builder.length() - 2, builder.length());
+    }
+    builder.append("]");
+    return builder.toString();
+  }
 }

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

@@ -181,6 +181,30 @@ public MutableArray<V> values(MutableArray<V> container) {
     return container;
   }
 
+  @Override
+  public int values(MutableArray<V> container, int startIndex, int limit) {
+    if (isEmpty()) {
+      return -1;
+    }
+    UnsafeMutableArray<V> unsafe = container.asUnsafe();
+    unsafe.prepareForSize(Math.min(limit, size()));
+    E[] entries = entries();
+    for (int i = startIndex, length = entries.length; i < length; i++) {
+      if (unsafe.size() >= limit) {
+        return i;
+      }
+      E entry = entries[i];
+      while (entry != null) {
+        V value = entry.value();
+        if (value != null) {
+          unsafe.unsafeAdd(value);
+        }
+        entry = entry.next();
+      }
+    }
+    return -1;
+  }
+
   @Override
   public int hashCode() {
     return Arrays.hashCode(entries());
@@ -214,13 +238,10 @@ public boolean equals(Object obj) {
 
   @Override
   public String toString() {
-
     if (isEmpty()) {
       return "[]";
     }
-
     StringBuilder builder = new StringBuilder("[");
-
     for (E entry : entries()) {
       while (entry != null) {
         builder
@@ -236,13 +257,10 @@ public String toString() {
         entry = entry.next();
       }
     }
-
     if (builder.length() > 1) {
       builder.delete(builder.length() - 2, builder.length());
     }
-
     builder.append("]");
-
     return builder.toString();
   }
 }

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

@@ -5,6 +5,7 @@
 
 import java.util.Optional;
 import java.util.stream.Stream;
+import javasabr.rlib.collections.array.ArrayFactory;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.Arguments;
 import org.junit.jupiter.params.provider.MethodSource;
@@ -207,6 +208,35 @@ void shouldBeEmptyAfterClear(MutableIntToRefDictionary<String> dictionary) {
     assertThat(dictionary.containsKey(1)).isFalse();
   }
 
+  @ParameterizedTest
+  @MethodSource("generateDictionaries")
+  void shouldIterateAllValuesUsingPartIndex(MutableIntToRefDictionary<String> dictionary) {
+    // given:
+    var expectedValues = ArrayFactory.mutableArray(String.class);
+    for (int i = 10; i < 1000; i += 8) {
+      var value = "value_" + i;
+      expectedValues.add(value);
+      dictionary.put(i, value);
+    }
+
+    expectedValues.sort();
+
+    var accumulatedValues = ArrayFactory.mutableArray(String.class);
+    var extractedPart = ArrayFactory.mutableArray(String.class);
+
+    // when:
+    int partIndex = 0;
+    while (partIndex >= 0) {
+      extractedPart.clear();
+      partIndex = dictionary.values(extractedPart, partIndex, 20);
+      accumulatedValues.addAll(extractedPart);
+    }
+    accumulatedValues.sort();
+
+    // then:
+    assertThat(accumulatedValues).isEqualTo(expectedValues);
+  }
+  
   private static Stream<Arguments> generateDictionaries() {
     return Stream.of(
         Arguments.of(MutableIntToRefDictionary.ofTypes(String.class)),

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

@@ -5,6 +5,7 @@
 
 import java.util.Optional;
 import java.util.stream.Stream;
+import javasabr.rlib.collections.array.ArrayFactory;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.Arguments;
 import org.junit.jupiter.params.provider.MethodSource;
@@ -207,6 +208,35 @@ void shouldBeEmptyAfterClear(MutableLongToRefDictionary<String> dictionary) {
     assertThat(dictionary.containsKey(1)).isFalse();
   }
 
+  @ParameterizedTest
+  @MethodSource("generateDictionaries")
+  void shouldIterateAllValuesUsingPartIndex(MutableLongToRefDictionary<String> dictionary) {
+    // given:
+    var expectedValues = ArrayFactory.mutableArray(String.class);
+    for (int i = 10; i < 1000; i += 8) {
+      var value = "value_" + i;
+      expectedValues.add(value);
+      dictionary.put(i, value);
+    }
+
+    expectedValues.sort();
+
+    var accumulatedValues = ArrayFactory.mutableArray(String.class);
+    var extractedPart = ArrayFactory.mutableArray(String.class);
+
+    // when:
+    int partIndex = 0;
+    while (partIndex >= 0) {
+      extractedPart.clear();
+      partIndex = dictionary.values(extractedPart, partIndex, 20);
+      accumulatedValues.addAll(extractedPart);
+    }
+    accumulatedValues.sort();
+
+    // then:
+    assertThat(accumulatedValues).isEqualTo(expectedValues);
+  }
+
   private static Stream<Arguments> generateDictionaries() {
     return Stream.of(
         Arguments.of(MutableLongToRefDictionary.ofTypes(String.class)),

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

@@ -5,6 +5,7 @@
 
 import java.util.Optional;
 import java.util.stream.Stream;
+import javasabr.rlib.collections.array.ArrayFactory;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.Arguments;
 import org.junit.jupiter.params.provider.MethodSource;
@@ -207,6 +208,36 @@ void shouldAppendDictionary(MutableRefToRefDictionary<String, String> dictionary
     assertThat(dictionary.size()).isEqualTo(5);
   }
 
+  @ParameterizedTest
+  @MethodSource("generateDictionaries")
+  void shouldIterateAllValuesUsingPartIndex(MutableRefToRefDictionary<String, String> dictionary) {
+    // given:
+    var expectedValues = ArrayFactory.mutableArray(String.class);
+    for (int i = 10; i < 1000; i += 8) {
+      var value = "value_" + i;
+      var key = "key_" + i;
+      expectedValues.add(value);
+      dictionary.put(key, value);
+    }
+
+    expectedValues.sort();
+    
+    var accumulatedValues = ArrayFactory.mutableArray(String.class);
+    var extractedPart = ArrayFactory.mutableArray(String.class);
+
+    // when:
+    int partIndex = 0;
+    while (partIndex >= 0) {
+      extractedPart.clear();
+      partIndex = dictionary.values(extractedPart, partIndex, 20);
+      accumulatedValues.addAll(extractedPart);
+    }
+    accumulatedValues.sort();
+    
+    // then:
+    assertThat(accumulatedValues).isEqualTo(expectedValues);
+  }
+
   private static Stream<Arguments> generateDictionaries() {
     return Stream.of(
         Arguments.of(MutableRefToRefDictionary.ofTypes(String.class, String.class)),

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

@@ -157,7 +157,7 @@ void shouldHaveExpectedResultFromForEach(RefToRefDictionary<String, String> dict
     // then:
     assertThat(pairs).isEqualTo(expectedPairs);
   }
-
+  
   private static Stream<Arguments> generateDictionaries() {
 
     RefToRefDictionary<String, String> source = RefToRefDictionary.ofEntries(