repackage

assira as assira.core
assira.all as assira.core8 & assira.core11

.gitignore

@@ -1,22 +1,7 @@
-/assira/target/
-/assira.asm/target/
-/assira.rules/target/
-/assira.rules.test/target/
-/assira.junit/target/
-/assira.drafts/target/
-/assira.test/target/
-/assira.archetype/target/
-/assira.benchmark/target/
-/assira.all/target/
-/assira.enterprise/target/
-/assira.lambda/target/
-/assira.jdk8/target/
-/assira.jdk11/target/
-/assira.debugger/target/
-/assira1/target/
+target/
 pom.xml.versionsBackup
 nbproject
-/.idea/
+.idea/
 *.iml
-assira.asm/dependency-reduced-pom.xml
+dependency-reduced-pom.xml
 

assira.all/dependency-reduced-pom.xml

@@ -1,33 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
-  <parent>
-    <artifactId>assira.project</artifactId>
-    <groupId>net.ranides</groupId>
-    <version>2.5.0</version>
-  </parent>
-  <modelVersion>4.0.0</modelVersion>
-  <artifactId>assira.all</artifactId>
-  <name>assira.all</name>
-  <build>
-    <plugins>
-      <plugin>
-        <artifactId>maven-shade-plugin</artifactId>
-        <version>2.4.3</version>
-        <executions>
-          <execution>
-            <phase>package</phase>
-            <goals>
-              <goal>shade</goal>
-            </goals>
-            <configuration>
-              <shadedArtifactAttached>false</shadedArtifactAttached>
-              <createDependencyReducedPom>true</createDependencyReducedPom>
-              <minimizeJar>false</minimizeJar>
-            </configuration>
-          </execution>
-        </executions>
-      </plugin>
-    </plugins>
-  </build>
-</project>
-

assira.archetype/pom.xml

@@ -4,7 +4,7 @@
     <parent>
         <groupId>net.ranides</groupId>
         <artifactId>assira.project</artifactId>
-        <version>2.5.0</version>
+        <version>2.6.0</version>
     </parent>
 
     <groupId>net.ranides</groupId>

assira.archetype/src/main/resources/archetype-resources/pom.xml

@@ -83,13 +83,13 @@
     <dependencies>
         <dependency>
             <groupId>net.ranides</groupId>
-            <artifactId>assira</artifactId>
-            <version>2.5.0</version>
+            <artifactId>assira.core</artifactId>
+            <version>2.6.0</version>
         </dependency>
         <dependency>
             <groupId>net.ranides</groupId>
             <artifactId>assira.junit</artifactId>
-            <version>2.5.0</version>
+            <version>2.6.0</version>
             <scope>test</scope>
         </dependency>
     </dependencies>

assira.asm/pom.xml

@@ -4,8 +4,8 @@
     <parent>
         <groupId>net.ranides</groupId>
         <artifactId>assira.project</artifactId>
-        <version>2.5.0</version>
-        <relativePath>..</relativePath>
+        <version>2.6.0</version>
+        <relativePath>../pom.xml</relativePath>
     </parent>
     <groupId>net.ranides</groupId>
     <artifactId>assira.asm</artifactId>

assira.benchmark/pom.xml

@@ -4,8 +4,8 @@
     <parent>
 		<groupId>net.ranides</groupId>
 		<artifactId>assira.project</artifactId>
-		<version>2.5.0</version>
-        <relativePath>..</relativePath>
+		<version>2.6.0</version>
+        <relativePath>../pom.xml</relativePath>
 	</parent>
     <name>assira.benchmark</name>
     <groupId>net.ranides</groupId>
@@ -37,7 +37,7 @@
         </dependency>
         <dependency>
             <groupId>net.ranides</groupId>
-            <artifactId>assira</artifactId>
+            <artifactId>assira.core</artifactId>
         </dependency>
         <dependency>
             <groupId>net.ranides</groupId>

assira/pom.xml

@@ -4,12 +4,12 @@
     <parent>
         <groupId>net.ranides</groupId>
         <artifactId>assira.project</artifactId>
-        <version>2.5.0</version>
+        <version>2.6.0</version>
         <relativePath>..</relativePath>
     </parent>
-    <name>assira</name>
+    <name>assira.core</name>
     <groupId>net.ranides</groupId>
-    <artifactId>assira</artifactId>
+    <artifactId>assira.core</artifactId>
     <packaging>jar</packaging>
 	
     <properties>
@@ -125,16 +125,5 @@
             <artifactId>lombok</artifactId>
             <scope>provided</scope>
         </dependency>
-        <dependency>
-            <groupId>javax</groupId>
-            <artifactId>javaee-api</artifactId>
-            <version>7.0</version>
-            <scope>test</scope>
-        </dependency>
-        <dependency>
-            <groupId>org.jetbrains</groupId>
-            <artifactId>annotations</artifactId>
-            <version>21.0.0</version>
-        </dependency>
     </dependencies>
 </project>

assira/src/main/java/net/ranides/assira/collection/arrays/ArrayUtils.java

@@ -1,247 +1,247 @@
-/*
- * @author Ranides Atterwim <ranides@gmail.com>
- * @copyright Ranides Atterwim
- * @license WTFPL
- * @url http://ranides.net/projects/assira
- */
-package net.ranides.assira.collection.arrays;
-
-import java.lang.reflect.Array;
-import java.util.Comparator;
-import java.util.Iterator;
-import java.util.ListIterator;
-import java.util.Random;
-import java.util.function.BiPredicate;
-import net.ranides.assira.collection.iterators.IntIterator;
-
-@SuppressWarnings({
-    "PMD.AvoidReassigningParameters"
-})
-public final class ArrayUtils {
-
-    private ArrayUtils() {
-        // utility class
-    }
-    
-    /**
-     * Unwraps an iterator into an array starting at a given offset for a given
-     * number of elements.
-     *
-     * <P>This method iterates over the given type-specific iterator and stores
-     * the elements returned, up to a maximum of
-     * <code>length</code>, in the given array starting at
-     * <code>offset</code>. The number of actually unwrapped elements is
-     * returned (it may be less than
-     * <code>max</code> if the iterator emits less than
-     * <code>max</code> elements).
-     *
-     * @param iterator a type-specific iterator.
-     * @param target an array to contain the output of the iterator.
-     * @param begin the first element of the array to be returned.
-     * @param end the maximum number of elements to collect.
-     * @return the number of elements unwrapped.
-     */
-    public static <A,T> int collect(Iterator<? extends T> iterator, A target, int begin, int end) {
-        if($isint(target)) {
-            return $collect(IntIterator.$wrap(iterator), (int[])target, begin, end);
-        } else {
-            return NativeArrayUtils.collect(iterator, NativeArray.wrap(target), begin, end);
-        }
-    }
-
-    private static <A> boolean $isint(A array) {
-        return null!=array && int[].class.equals(array.getClass());
-    }
-    
-    /**
-     * Unwraps an iterator into an array.
-     *
-     * <P>This method iterates over the given type-specific iterator and stores
-     * the elements returned in the given array. The iteration will stop when
-     * the iterator has no more elements or when the end of the array has been
-     * reached.
-     *
-     * @param iterator a type-specific iterator.
-     * @param target an array to contain the output of the iterator.
-     * @return the number of elements unwrapped.
-     */
-    public static <A,T> int collect(Iterator<? extends T> iterator, A target) {
-        if($isint(target)) {
-            int[] array = (int[])target;
-            return $collect(IntIterator.$wrap(iterator), array, 0, array.length);
-        } else {
-            return NativeArrayUtils.collect(iterator, NativeArray.wrap(target));
-        }
-    }
-    
-    static int $collect(IntIterator iterator, int target[], int begin, int end) {
-        NativeArrayAllocator.ensureFromTo(target.length, begin, end);
-        int j = end;
-        while (j-- != 0 && iterator.hasNext()) {
-            target[begin++] = iterator.nextInt();
-        }
-        return end - j - 1;
-    }
-        
-    /**
-     * Fills the given array with the given value.
-     *
-     * <P>This method uses a backward loop. It is significantly faster than the
-     * corresponding method in {@link java.util.Arrays}.
-     *
-     * @param array an array.
-     * @param value the new value for all elements of the array.
-     */
-    public static <A,T> void fill(A array, T value) {
-        NativeArrayUtils.fill(NativeArray.wrap(array), value);
-    }
-
-    /**
-     * Fills a portion of the given array with the given value.
-     *
-     * <P>If possible (i.e.,
-     * <code>from</code> is 0) this method uses a backward loop. In this case,
-     * it is significantly faster than the corresponding method in
-     * {@link java.util.Arrays}.
-     *
-     * @param array an array.
-     * @param begin the starting index of the portion to fill (inclusive).
-     * @param end the end index of the portion to fill (exclusive).
-     * @param value the new value for all elements of the specified portion of
-     * the array.
-     */
-    public static <A,T> void fill(A array, int begin, int end, T value) {
-        NativeArrayUtils.fill(NativeArray.wrap(array), begin, end, value);
-    }
-    
-    public static <A> A reverse(A array, int begin, int end){
-        NativeArrayUtils.reverse(NativeArray.wrap(array), begin, end);
-        return array;
-    }
-
-    /**
-     * Reverses the order of the elements in the specified array.
-     *
-     * @param array the array to be reversed.
-     * @return <code>a</code>.
-     */
-    public static <A> A reverse(A array) {
-        NativeArrayUtils.reverse(NativeArray.wrap(array));
-        return array;
-    }
-    
-    /**
-     * Returns true if the two arrays are elementwise equal.
-     * @param array1 an array.
-     * @param array2 another array.
-     * @return true if the two arrays are of the same length, and their elements
-     * are equal.
-     */
-    public static <A> boolean equals(A array1, A array2) {
-        return NativeArrayUtils.equals(NativeArray.wrap(array1), NativeArray.wrap(array2));
-    }
-    
-    public static <A,T> A head(A array, int index) {
-        return NativeArrayUtils.head(NativeArray.wrap(array), index).$array();
-    }
-
-    public static <A,T> A head(A array, T value, Comparator<? super T> cmp) {
-        return NativeArrayUtils.head(NativeArray.wrap(array), value, cmp).$array();
-    }
-    
-    public static <A,T> A tail(A array, int index) {
-        return NativeArrayUtils.tail(NativeArray.wrap(array), index).$array();
-    }
-    
-    public static <A,T> A tail(A array, T value, Comparator<? super T> cmp) {
-        return NativeArrayUtils.tail(NativeArray.wrap(array), value, cmp).$array();
-    }
-   
-    public static <A,T> A slice(A values, T begin, T end, Comparator<? super T> cmp) {
-        return NativeArrayUtils.slice(NativeArray.wrap(values), begin, end, cmp).$array();
-    }
-    
-    public static <A> A slice(A array, int begin, int end) {
-        return NativeArrayUtils.slice(NativeArray.wrap(array), begin, end).$array();
-    }
-    
-    public static <A> A rotate(A array, int offset) {
-        return NativeArrayUtils.rotate(NativeArray.wrap(array), offset).$array();
-    }
-    
-    public static <A> A shuffle(Random random, A array) {
-        return NativeArrayUtils.shuffle(random, NativeArray.wrap(array)).$array();
-    }
-    
-    public static <A> int size(A array) {
-        return null == array ? 0 : Array.getLength(array);
-    }
-    
-    @SuppressWarnings("SuspiciousSystemArraycopy")
-    public static <A> A copy(A src, int srcpos, A dst, int dstpos, int size) {
-        System.arraycopy(src, srcpos, dst, dstpos, size);
-        return dst;
-    }
-    
-    public static <A> A copy(A array) {
-        if(null == array) {
-            return null;
-        }
-        int n = Array.getLength(array);
-        return copy(array, 0, ArrayAllocator.forPrototype(array, n), 0, n);
-    }
-    
-    public static <A> A concat(A a, A b) {
-        return NativeArrayUtils.concat(NativeArray.wrap(a), NativeArray.wrap(b)).$array();
-    }
-    
-    public static <A> A append(A a, Object value) {
-        return NativeArrayUtils.append(NativeArray.wrap(a), value).$array();
-    }
-
-    public static <A> A prepend(A a, Object value) {
-        return NativeArrayUtils.prepend(NativeArray.wrap(a), value).$array();
-    }
-
-    /**
-     * Removes first element from array and moves all elements to the left.
-     * Note that last element in array will be duplicated.
-     * @param a
-     * @param <A>
-     * @return
-     */
-    public static <A,T> T shift(A a) {
-        return NativeArrayUtils.shift(NativeArray.wrap(a));
-    }
-
-    /**
-     * Removes last element from array and moves all elements to the right.
-     * Note that first element in array will be duplicated.
-     * @param a
-     * @param <A>
-     * @return
-     */
-    public static <A,T> T unshift(A a) {
-        return NativeArrayUtils.unshift(NativeArray.wrap(a));
-    }
-
-    public static <A,T> ListIterator<T> iterator(A array) {
-        return NativeArrayUtils.iterator(NativeArray.wrap(array));
-    }
-
-    public static <A,T> ListIterator<T> iterator(A array, int begin, int end) {
-        return NativeArrayUtils.iterator(NativeArray.wrap(array), begin, end);
-    }
-    
-    public static <A,T> boolean equals(A a, A b, BiPredicate<T,T> predicate) {
-        return NativeArrayUtils.equals(NativeArray.wrap(a), NativeArray.wrap(b), predicate);
-    }
-    
-    public static <A,T> int compare(A a, A b) {
-        return NativeArrayUtils.compare(NativeArray.wrap(a), NativeArray.wrap(b));
-    }
-    
-    public static <A,T> int compare(A a, A b, Comparator<T> cmp) {
-        return NativeArrayUtils.compare(NativeArray.wrap(a), NativeArray.wrap(b), cmp);
-    }
-}
+/*
+ * @author Ranides Atterwim <ranides@gmail.com>
+ * @copyright Ranides Atterwim
+ * @license WTFPL
+ * @url http://ranides.net/projects/assira
+ */
+package net.ranides.assira.collection.arrays;
+
+import java.lang.reflect.Array;
+import java.util.Comparator;
+import java.util.Iterator;
+import java.util.ListIterator;
+import java.util.Random;
+import java.util.function.BiPredicate;
+import net.ranides.assira.collection.iterators.IntIterator;
+
+@SuppressWarnings({
+    "PMD.AvoidReassigningParameters"
+})
+public final class ArrayUtils {
+
+    private ArrayUtils() {
+        // utility class
+    }
+    
+    /**
+     * Unwraps an iterator into an array starting at a given offset for a given
+     * number of elements.
+     *
+     * <P>This method iterates over the given type-specific iterator and stores
+     * the elements returned, up to a maximum of
+     * <code>length</code>, in the given array starting at
+     * <code>offset</code>. The number of actually unwrapped elements is
+     * returned (it may be less than
+     * <code>max</code> if the iterator emits less than
+     * <code>max</code> elements).
+     *
+     * @param iterator a type-specific iterator.
+     * @param target an array to contain the output of the iterator.
+     * @param begin the first element of the array to be returned.
+     * @param end the maximum number of elements to collect.
+     * @return the number of elements unwrapped.
+     */
+    public static <A,T> int collect(Iterator<? extends T> iterator, A target, int begin, int end) {
+        if($isint(target)) {
+            return $collect(IntIterator.$wrap(iterator), (int[])target, begin, end);
+        } else {
+            return NativeArrayUtils.collect(iterator, NativeArray.wrap(target), begin, end);
+        }
+    }
+
+    private static <A> boolean $isint(A array) {
+        return null!=array && int[].class.equals(array.getClass());
+    }
+    
+    /**
+     * Unwraps an iterator into an array.
+     *
+     * <P>This method iterates over the given type-specific iterator and stores
+     * the elements returned in the given array. The iteration will stop when
+     * the iterator has no more elements or when the end of the array has been
+     * reached.
+     *
+     * @param iterator a type-specific iterator.
+     * @param target an array to contain the output of the iterator.
+     * @return the number of elements unwrapped.
+     */
+    public static <A,T> int collect(Iterator<? extends T> iterator, A target) {
+        if($isint(target)) {
+            int[] array = (int[])target;
+            return $collect(IntIterator.$wrap(iterator), array, 0, array.length);
+        } else {
+            return NativeArrayUtils.collect(iterator, NativeArray.wrap(target));
+        }
+    }
+    
+    static int $collect(IntIterator iterator, int target[], int begin, int end) {
+        NativeArrayAllocator.ensureFromTo(target.length, begin, end);
+        int j = end;
+        while (j-- != 0 && iterator.hasNext()) {
+            target[begin++] = iterator.nextInt();
+        }
+        return end - j - 1;
+    }
+        
+    /**
+     * Fills the given array with the given value.
+     *
+     * <P>This method uses a backward loop. It is significantly faster than the
+     * corresponding method in {@link java.util.Arrays}.
+     *
+     * @param array an array.
+     * @param value the new value for all elements of the array.
+     */
+    public static <A,T> void fill(A array, T value) {
+        NativeArrayUtils.fill(NativeArray.wrap(array), value);
+    }
+
+    /**
+     * Fills a portion of the given array with the given value.
+     *
+     * <P>If possible (i.e.,
+     * <code>from</code> is 0) this method uses a backward loop. In this case,
+     * it is significantly faster than the corresponding method in
+     * {@link java.util.Arrays}.
+     *
+     * @param array an array.
+     * @param begin the starting index of the portion to fill (inclusive).
+     * @param end the end index of the portion to fill (exclusive).
+     * @param value the new value for all elements of the specified portion of
+     * the array.
+     */
+    public static <A,T> void fill(A array, int begin, int end, T value) {
+        NativeArrayUtils.fill(NativeArray.wrap(array), begin, end, value);
+    }
+    
+    public static <A> A reverse(A array, int begin, int end){
+        NativeArrayUtils.reverse(NativeArray.wrap(array), begin, end);
+        return array;
+    }
+
+    /**
+     * Reverses the order of the elements in the specified array.
+     *
+     * @param array the array to be reversed.
+     * @return <code>a</code>.
+     */
+    public static <A> A reverse(A array) {
+        NativeArrayUtils.reverse(NativeArray.wrap(array));
+        return array;
+    }
+    
+    /**
+     * Returns true if the two arrays are elementwise equal.
+     * @param array1 an array.
+     * @param array2 another array.
+     * @return true if the two arrays are of the same length, and their elements
+     * are equal.
+     */
+    public static <A> boolean equals(A array1, A array2) {
+        return NativeArrayUtils.equals(NativeArray.wrap(array1), NativeArray.wrap(array2));
+    }
+    
+    public static <A,T> A head(A array, int index) {
+        return NativeArrayUtils.head(NativeArray.wrap(array), index).$array();
+    }
+
+    public static <A,T> A head(A array, T value, Comparator<? super T> cmp) {
+        return NativeArrayUtils.head(NativeArray.wrap(array), value, cmp).$array();
+    }
+    
+    public static <A,T> A tail(A array, int index) {
+        return NativeArrayUtils.tail(NativeArray.wrap(array), index).$array();
+    }
+    
+    public static <A,T> A tail(A array, T value, Comparator<? super T> cmp) {
+        return NativeArrayUtils.tail(NativeArray.wrap(array), value, cmp).$array();
+    }
+   
+    public static <A,T> A slice(A values, T begin, T end, Comparator<? super T> cmp) {
+        return NativeArrayUtils.slice(NativeArray.wrap(values), begin, end, cmp).$array();
+    }
+    
+    public static <A> A slice(A array, int begin, int end) {
+        return NativeArrayUtils.slice(NativeArray.wrap(array), begin, end).$array();
+    }
+    
+    public static <A> A rotate(A array, int offset) {
+        return NativeArrayUtils.rotate(NativeArray.wrap(array), offset).$array();
+    }
+    
+    public static <A> A shuffle(Random random, A array) {
+        return NativeArrayUtils.shuffle(random, NativeArray.wrap(array)).$array();
+    }
+    
+    public static <A> int size(A array) {
+        return null == array ? 0 : Array.getLength(array);
+    }
+    
+    @SuppressWarnings("SuspiciousSystemArraycopy")
+    public static <A> A copy(A src, int srcpos, A dst, int dstpos, int size) {
+        System.arraycopy(src, srcpos, dst, dstpos, size);
+        return dst;
+    }
+    
+    public static <A> A copy(A array) {
+        if(null == array) {
+            return null;
+        }
+        int n = Array.getLength(array);
+        return copy(array, 0, ArrayAllocator.forPrototype(array, n), 0, n);
+    }
+    
+    public static <A> A concat(A a, A b) {
+        return NativeArrayUtils.concat(NativeArray.wrap(a), NativeArray.wrap(b)).$array();
+    }
+    
+    public static <A> A append(A a, Object value) {
+        return NativeArrayUtils.append(NativeArray.wrap(a), value).$array();
+    }
+
+    public static <A> A prepend(A a, Object value) {
+        return NativeArrayUtils.prepend(NativeArray.wrap(a), value).$array();
+    }
+
+    /**
+     * Removes first element from array and moves all elements to the left.
+     * Note that last element in array will be duplicated.
+     * @param a
+     * @param <A>
+     * @return
+     */
+    public static <A,T> T shift(A a) {
+        return NativeArrayUtils.shift(NativeArray.wrap(a));
+    }
+
+    /**
+     * Removes last element from array and moves all elements to the right.
+     * Note that first element in array will be duplicated.
+     * @param a
+     * @param <A>
+     * @return
+     */
+    public static <A,T> T unshift(A a) {
+        return NativeArrayUtils.unshift(NativeArray.wrap(a));
+    }
+
+    public static <A,T> ListIterator<T> iterator(A array) {
+        return NativeArrayUtils.iterator(NativeArray.wrap(array));
+    }
+
+    public static <A,T> ListIterator<T> iterator(A array, int begin, int end) {
+        return NativeArrayUtils.iterator(NativeArray.wrap(array), begin, end);
+    }
+    
+    public static <A,T> boolean equals(A a, A b, BiPredicate<T,T> predicate) {
+        return NativeArrayUtils.equals(NativeArray.wrap(a), NativeArray.wrap(b), predicate);
+    }
+    
+    public static <A,T> int compare(A a, A b) {
+        return NativeArrayUtils.compare(NativeArray.wrap(a), NativeArray.wrap(b));
+    }
+    
+    public static <A,T> int compare(A a, A b, Comparator<T> cmp) {
+        return NativeArrayUtils.compare(NativeArray.wrap(a), NativeArray.wrap(b), cmp);
+    }
+}

assira/src/main/java/net/ranides/assira/collection/arrays/NativeArrayUtils.java

@@ -1,292 +1,292 @@
-/*
- * @author Ranides Atterwim <ranides@gmail.com>
- * @copyright Ranides Atterwim
- * @license WTFPL
- * @url http://ranides.net/projects/assira
- */
-package net.ranides.assira.collection.arrays;
-
-import java.util.Comparator;
-import java.util.Iterator;
-import java.util.ListIterator;
-import java.util.Random;
-import java.util.function.BiPredicate;
-import net.ranides.assira.collection.IntComparator;
-import net.ranides.assira.collection.Swapper;
-import net.ranides.assira.collection.arrays.NativeArray.NativeComparator;
-import net.ranides.assira.collection.iterators.RandomAccessIterator;
-import net.ranides.assira.generic.CompareUtils;
-
-@SuppressWarnings({
-    "PMD.AvoidReassigningParameters"
-})
-public final class NativeArrayUtils {
-
-    private NativeArrayUtils() {
-        // utility class
-    }
-    
-    public static <T> int collect(Iterator<? extends T> iterator, NativeArray target, int begin, int end) {
-        NativeArrayAllocator.ensureFromTo(target, begin, end);
-        int j = end;
-        while (j-- != 0 && iterator.hasNext()) {
-            target.set(begin++, iterator.next());
-        }
-        return end - j - 1;
-    }
-
-    public static <T> int collect(Iterator<? extends T> iterator, NativeArray target) {
-        return collect(iterator, target, 0, target.size());
-    }
-
-    /**
-     * Fills the given array with the given value.
-     *
-     * <P>This method uses a backward loop. It is significantly faster than the
-     * corresponding method in {@link java.util.Arrays}.
-     *
-     * @param array an array.
-     * @param value the new value for all elements of the array.
-     */
-    public static <T> void fill(NativeArray array, T value) {
-        array.set(0, array.size(), value);
-    }
-
-    public static <T> void fill(NativeArray array, int begin, int end, T value) {
-        NativeArrayAllocator.ensureFromTo(array, begin, end);
-        array.set(begin, end, value);
-    }
-    
-    public static <S extends Swapper> S reverse(S swapper, int begin, int end){
-        while(begin < --end){
-            swapper.swap(begin++, end);
-        }
-        return swapper;
-    }
-
-    public static <S extends Swapper> S reverse(S swapper, int size) {
-        return reverse(swapper, 0, size);
-    }
-    
-    public static NativeArray reverse(NativeArray array) {
-        reverse(array, array.size());
-        return array;
-    }
-    
-    public static boolean equals(NativeArray array1, NativeArray array2) {
-        return array1.equals(array2);
-    }
-    
-    public static <T> NativeArray head(NativeArray values, int index) {
-        return slice(values, 0, index);
-    }
-
-    public static <T> NativeArray head(NativeArray values, T value, Comparator<? super T> cmp) {
-        return slice(values, 0, ifind(values, value, 0, cmp));
-    }
-    
-    public static <T> NativeArray tail(NativeArray values, int index) {
-        return slice(values, index, values.size());
-    }
-    
-    public static <T> NativeArray tail(NativeArray values, T value, Comparator<? super T> cmp) {
-        return slice(values, ifind(values, value, 0, cmp), values.size());
-    }
-    
-    public static <T> NativeArray slice(NativeArray values, T begin, T end, Comparator<? super T> cmp) {
-        int bi = ifind(values, begin, 0, cmp);
-        int ei = ifind(values, end, bi, cmp);
-        return slice(values, bi, ei);
-    }
-
-    public static NativeArray slice(NativeArray values, int begin, int end) {
-        int size = end - begin;
-        NativeArray result = values.allocate(size);
-        NativeArrayUtils.copy(values, begin, result, 0, size);
-        return result;
-    }
-    
-    public static NativeArray rotate(NativeArray array, int offset) {
-        int n = array.size();
-        offset = offset % n;
-        if( offset > 0) {
-            int a = n - offset; 
-            reverse(array, 0, a);
-            reverse(array, a, n);
-            reverse(array, 0, n);
-        } 
-        else if( offset < 0) {
-            rotate(array, offset+n);
-        }
-        return array;
-    }
-    
-    private static <T> int ifind(NativeArray values, T value, int begin, Comparator<? super T> cmp) {
-        NativeComparator icmp = values.rcmp(value, cmp);
-        int i = begin, n = values.size();
-        while(i<n && icmp.compare(i) < 0) {
-            i++;
-        }
-        return i;
-    }
-    
-    public static NativeArray shuffle(Random random, NativeArray array) {
-        shuffle(random, array.size(), array);
-        return array;
-    }
-    
-    public static void shuffle(Random random, int size, Swapper swapper) {
-        for(int i=size; i>1; i--) {
-            swapper.swap(i-1, random.nextInt(i));
-        }
-    }
-
-    public static int size(NativeArray array) {
-        return array.size();
-    }
-    
-    @SuppressWarnings("SuspiciousSystemArraycopy")
-    public static <T> NativeArray copy(NativeArray src, int srcpos, NativeArray dst, int dstpos, int size) {
-        System.arraycopy(src.array(), srcpos, dst.array(), dstpos, size);
-        return dst;
-    }
-    
-    public static NativeArray copy(NativeArray array) {
-        int n = array.size();
-        return copy(array, 0, NativeArrayAllocator.forPrototype(array, n), 0, n);
-    }
-    
-    public static NativeArray concat(NativeArray a, NativeArray b) {
-        int as = a.size();
-        int bs = b.size();
-        NativeArray result = a.allocate(as+bs);
-        copy(a, 0, result, 0, as);
-        copy(b, 0, result, as, bs);
-        return result;
-    }
-    
-    public static NativeArray append(NativeArray a, Object value) {
-        int as = a.size();
-        NativeArray result = a.allocate(as + 1);
-        copy(a, 0, result, 0, as);
-        result.set(as, value);
-        return result;
-    }
-    
-    public static NativeArray prepend(NativeArray a, Object value) {
-        int as = a.size();
-        NativeArray result = a.allocate(as + 1);
-        copy(a, 0, result, 1, as);
-        result.set(0, value);
-        return result;
-    }
-
-    /**
-     * Removes first element from array and moves all elements to the left.
-     * Note that last element in array will be duplicated.
-     * @param a
-     * @return removed value
-     */
-    @SuppressWarnings("unchecked")
-    public static <T> T shift(NativeArray a) {
-        int n = a.size();
-        if(n == 0) {
-            return null;
-        }
-        Object value = a.get(0);
-        for(int i=1; i<n; i++) {
-            a.move(i-1, i);
-        }
-        return (T)value;
-    }
-
-    /**
-     * Removes last element from array and moves all elements to the right.
-     * Note that first element in array will be duplicated.
-     * @param a
-     * @return
-     */
-    @SuppressWarnings("unchecked")
-    public static <T> T unshift(NativeArray a) {
-        int n = a.size();
-        if(n == 0) {
-            return null;
-        }
-        Object value = a.get(n-1);
-        for(int i=n-1; i>0; i--) {
-            a.move(i, i-1);
-        }
-        return (T)value;
-    }
-    
-    public static <T> ListIterator<T> iterator(NativeArray array) {
-        return iterator(array, 0, array.size());
-    }
-
-    @SuppressWarnings("unchecked")
-    public static <T> ListIterator<T> iterator(NativeArray array, int begin, int end) {
-        return new RandomAccessIterator<T>() {
-            @Override
-            protected int size() {
-                return end-begin;
-            }
-
-            @Override
-            protected T get(int index) {
-                return (T)array.get(begin+index);
-            }
-
-            @Override
-            protected void set(int index, T value) {
-                array.set(begin+index, value);
-            }
-            
-        };
-    }
-    
-    public static <T> boolean equals(NativeArray a, NativeArray b, Comparator<? super T> cmp) {
-        if(a.size() != b.size()) {
-            return false;
-        }
-        IntComparator icmp = a.comparator(b, cmp);
-        for(int i=0, n=a.size(); i<n; i++) {
-            if( 0 != icmp.compare(i,i)) {
-                return false;
-            }
-        }
-        return true;
-    }
-    
-    public static <T> boolean equals(NativeArray a, NativeArray b, BiPredicate<? super T,? super T> predicate) {
-        if(a.size() != b.size()) {
-            return false;
-        }
-        Comparator<T> vcmp = (av,bv) -> predicate.test(av, bv) ? 0 : -1;
-        IntComparator icmp = a.comparator(b, vcmp);
-        for(int i=0, n=a.size(); i<n; i++) {
-            if( 0 != icmp.compare(i,i)) {
-                return false;
-            }
-        }
-        return true;
-    }
-    
-    public static <T> int compare(NativeArray a, NativeArray b) {
-        return icompare(a.size(), b.size(), a.comparator(b));
-    }
-    
-    public static <T> int compare(NativeArray a, NativeArray b, Comparator<? super T> cmp) {
-        return icompare(a.size(), b.size(), a.comparator(b, cmp));
-    }
-    
-    private static <T> int icompare(int a, int b, IntComparator cmp) {
-        for(int i=0, n=Math.min(a,b); i<n; i++) {
-            int ic = cmp.compare(i,i);
-            if(ic != 0) {
-                return ic;
-            }
-        }
-        return CompareUtils.cmp(a,b);
-    }
-    
-}
+/*
+ * @author Ranides Atterwim <ranides@gmail.com>
+ * @copyright Ranides Atterwim
+ * @license WTFPL
+ * @url http://ranides.net/projects/assira
+ */
+package net.ranides.assira.collection.arrays;
+
+import java.util.Comparator;
+import java.util.Iterator;
+import java.util.ListIterator;
+import java.util.Random;
+import java.util.function.BiPredicate;
+import net.ranides.assira.collection.IntComparator;
+import net.ranides.assira.collection.Swapper;
+import net.ranides.assira.collection.arrays.NativeArray.NativeComparator;
+import net.ranides.assira.collection.iterators.RandomAccessIterator;
+import net.ranides.assira.generic.CompareUtils;
+
+@SuppressWarnings({
+    "PMD.AvoidReassigningParameters"
+})
+public final class NativeArrayUtils {
+
+    private NativeArrayUtils() {
+        // utility class
+    }
+    
+    public static <T> int collect(Iterator<? extends T> iterator, NativeArray target, int begin, int end) {
+        NativeArrayAllocator.ensureFromTo(target, begin, end);
+        int j = end;
+        while (j-- != 0 && iterator.hasNext()) {
+            target.set(begin++, iterator.next());
+        }
+        return end - j - 1;
+    }
+
+    public static <T> int collect(Iterator<? extends T> iterator, NativeArray target) {
+        return collect(iterator, target, 0, target.size());
+    }
+
+    /**
+     * Fills the given array with the given value.
+     *
+     * <P>This method uses a backward loop. It is significantly faster than the
+     * corresponding method in {@link java.util.Arrays}.
+     *
+     * @param array an array.
+     * @param value the new value for all elements of the array.
+     */
+    public static <T> void fill(NativeArray array, T value) {
+        array.set(0, array.size(), value);
+    }
+
+    public static <T> void fill(NativeArray array, int begin, int end, T value) {
+        NativeArrayAllocator.ensureFromTo(array, begin, end);
+        array.set(begin, end, value);
+    }
+    
+    public static <S extends Swapper> S reverse(S swapper, int begin, int end){
+        while(begin < --end){
+            swapper.swap(begin++, end);
+        }
+        return swapper;
+    }
+
+    public static <S extends Swapper> S reverse(S swapper, int size) {
+        return reverse(swapper, 0, size);
+    }
+    
+    public static NativeArray reverse(NativeArray array) {
+        reverse(array, array.size());
+        return array;
+    }
+    
+    public static boolean equals(NativeArray array1, NativeArray array2) {
+        return array1.equals(array2);
+    }
+    
+    public static <T> NativeArray head(NativeArray values, int index) {
+        return slice(values, 0, index);
+    }
+
+    public static <T> NativeArray head(NativeArray values, T value, Comparator<? super T> cmp) {
+        return slice(values, 0, ifind(values, value, 0, cmp));
+    }
+    
+    public static <T> NativeArray tail(NativeArray values, int index) {
+        return slice(values, index, values.size());
+    }
+    
+    public static <T> NativeArray tail(NativeArray values, T value, Comparator<? super T> cmp) {
+        return slice(values, ifind(values, value, 0, cmp), values.size());
+    }
+    
+    public static <T> NativeArray slice(NativeArray values, T begin, T end, Comparator<? super T> cmp) {
+        int bi = ifind(values, begin, 0, cmp);
+        int ei = ifind(values, end, bi, cmp);
+        return slice(values, bi, ei);
+    }
+
+    public static NativeArray slice(NativeArray values, int begin, int end) {
+        int size = end - begin;
+        NativeArray result = values.allocate(size);
+        NativeArrayUtils.copy(values, begin, result, 0, size);
+        return result;
+    }
+    
+    public static NativeArray rotate(NativeArray array, int offset) {
+        int n = array.size();
+        offset = offset % n;
+        if( offset > 0) {
+            int a = n - offset; 
+            reverse(array, 0, a);
+            reverse(array, a, n);
+            reverse(array, 0, n);
+        } 
+        else if( offset < 0) {
+            rotate(array, offset+n);
+        }
+        return array;
+    }
+    
+    private static <T> int ifind(NativeArray values, T value, int begin, Comparator<? super T> cmp) {
+        NativeComparator icmp = values.rcmp(value, cmp);
+        int i = begin, n = values.size();
+        while(i<n && icmp.compare(i) < 0) {
+            i++;
+        }
+        return i;
+    }
+    
+    public static NativeArray shuffle(Random random, NativeArray array) {
+        shuffle(random, array.size(), array);
+        return array;
+    }
+    
+    public static void shuffle(Random random, int size, Swapper swapper) {
+        for(int i=size; i>1; i--) {
+            swapper.swap(i-1, random.nextInt(i));
+        }
+    }
+
+    public static int size(NativeArray array) {
+        return array.size();
+    }
+    
+    @SuppressWarnings("SuspiciousSystemArraycopy")
+    public static <T> NativeArray copy(NativeArray src, int srcpos, NativeArray dst, int dstpos, int size) {
+        System.arraycopy(src.array(), srcpos, dst.array(), dstpos, size);
+        return dst;
+    }
+    
+    public static NativeArray copy(NativeArray array) {
+        int n = array.size();
+        return copy(array, 0, NativeArrayAllocator.forPrototype(array, n), 0, n);
+    }
+    
+    public static NativeArray concat(NativeArray a, NativeArray b) {
+        int as = a.size();
+        int bs = b.size();
+        NativeArray result = a.allocate(as+bs);
+        copy(a, 0, result, 0, as);
+        copy(b, 0, result, as, bs);
+        return result;
+    }
+    
+    public static NativeArray append(NativeArray a, Object value) {
+        int as = a.size();
+        NativeArray result = a.allocate(as + 1);
+        copy(a, 0, result, 0, as);
+        result.set(as, value);
+        return result;
+    }
+    
+    public static NativeArray prepend(NativeArray a, Object value) {
+        int as = a.size();
+        NativeArray result = a.allocate(as + 1);
+        copy(a, 0, result, 1, as);
+        result.set(0, value);
+        return result;
+    }
+
+    /**
+     * Removes first element from array and moves all elements to the left.
+     * Note that last element in array will be duplicated.
+     * @param a
+     * @return removed value
+     */
+    @SuppressWarnings("unchecked")
+    public static <T> T shift(NativeArray a) {
+        int n = a.size();
+        if(n == 0) {
+            return null;
+        }
+        Object value = a.get(0);
+        for(int i=1; i<n; i++) {
+            a.move(i-1, i);
+        }
+        return (T)value;
+    }
+
+    /**
+     * Removes last element from array and moves all elements to the right.
+     * Note that first element in array will be duplicated.
+     * @param a
+     * @return
+     */
+    @SuppressWarnings("unchecked")
+    public static <T> T unshift(NativeArray a) {
+        int n = a.size();
+        if(n == 0) {
+            return null;
+        }
+        Object value = a.get(n-1);
+        for(int i=n-1; i>0; i--) {
+            a.move(i, i-1);
+        }
+        return (T)value;
+    }
+    
+    public static <T> ListIterator<T> iterator(NativeArray array) {
+        return iterator(array, 0, array.size());
+    }
+
+    @SuppressWarnings("unchecked")
+    public static <T> ListIterator<T> iterator(NativeArray array, int begin, int end) {
+        return new RandomAccessIterator<T>() {
+            @Override
+            protected int size() {
+                return end-begin;
+            }
+
+            @Override
+            protected T get(int index) {
+                return (T)array.get(begin+index);
+            }
+
+            @Override
+            protected void set(int index, T value) {
+                array.set(begin+index, value);
+            }
+            
+        };
+    }
+    
+    public static <T> boolean equals(NativeArray a, NativeArray b, Comparator<? super T> cmp) {
+        if(a.size() != b.size()) {
+            return false;
+        }
+        IntComparator icmp = a.comparator(b, cmp);
+        for(int i=0, n=a.size(); i<n; i++) {
+            if( 0 != icmp.compare(i,i)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    
+    public static <T> boolean equals(NativeArray a, NativeArray b, BiPredicate<? super T,? super T> predicate) {
+        if(a.size() != b.size()) {
+            return false;
+        }
+        Comparator<T> vcmp = (av,bv) -> predicate.test(av, bv) ? 0 : -1;
+        IntComparator icmp = a.comparator(b, vcmp);
+        for(int i=0, n=a.size(); i<n; i++) {
+            if( 0 != icmp.compare(i,i)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    
+    public static <T> int compare(NativeArray a, NativeArray b) {
+        return icompare(a.size(), b.size(), a.comparator(b));
+    }
+    
+    public static <T> int compare(NativeArray a, NativeArray b, Comparator<? super T> cmp) {
+        return icompare(a.size(), b.size(), a.comparator(b, cmp));
+    }
+    
+    private static <T> int icompare(int a, int b, IntComparator cmp) {
+        for(int i=0, n=Math.min(a,b); i<n; i++) {
+            int ic = cmp.compare(i,i);
+            if(ic != 0) {
+                return ic;
+            }
+        }
+        return CompareUtils.cmp(a,b);
+    }
+    
+}