Adding ToArray for conveniently creating an A[] from Iterable<A>

jnape · jnape · commit 4f9304704a3d · 2018-05-13T16:50:33.000-05:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -13,6 +13,7 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/).
 ### Added
 - `Upcast` for safely casting up a type hierarchy
 - `SetLens`, lenses operating on `Set`s
+- `ToArray`, for converting `Iterable<A>` to `A[]` 
 
 ## [3.0.0] - 2018-05-04
 ### Changed
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/ToArray.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/ToArray.java
@@ -0,0 +1,50 @@
+package com.jnape.palatable.lambda.functions.builtin.fn2;
+
+import com.jnape.palatable.lambda.functions.Fn1;
+import com.jnape.palatable.lambda.functions.Fn2;
+
+import java.lang.reflect.Array;
+import java.util.Collection;
+
+import static com.jnape.palatable.lambda.functions.builtin.fn1.Size.size;
+
+/**
+ * Write all the elements of an {@link Iterable} directly into an array of the specified type. If the {@link Iterable}
+ * is an instance of {@link Collection}, use {@link Collection#toArray(Object[])}.
+ *
+ * @param <A> the {@link Iterable} element type
+ */
+public final class ToArray<A> implements Fn2<Class<A[]>, Iterable<? extends A>, A[]> {
+
+    private static final ToArray INSTANCE = new ToArray<>();
+
+    private ToArray() {
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public A[] apply(Class<A[]> arrayType, Iterable<? extends A> as) {
+        A[] array = (A[]) Array.newInstance(arrayType.getComponentType(), size(as).intValue());
+        if (as instanceof Collection)
+            return ((Collection<A>) as).toArray(array);
+
+        int index = 0;
+        for (A a : as) {
+            array[index++] = a;
+        }
+        return array;
+    }
+
+    @SuppressWarnings("unchecked")
+    public static <A> ToArray<A> toArray() {
+        return INSTANCE;
+    }
+
+    public static <A> Fn1<Iterable<? extends A>, A[]> toArray(Class<A[]> arrayType) {
+        return ToArray.<A>toArray().apply(arrayType);
+    }
+
+    public static <A> A[] toArray(Class<A[]> arrayType, Iterable<? extends A> as) {
+        return toArray(arrayType).apply(as);
+    }
+}
diff --git a/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/ToArrayTest.java b/src/test/java/com/jnape/palatable/lambda/functions/builtin/fn2/ToArrayTest.java
@@ -0,0 +1,50 @@
+package com.jnape.palatable.lambda.functions.builtin.fn2;
+
+import org.junit.Test;
+
+import java.util.AbstractCollection;
+import java.util.Arrays;
+import java.util.Iterator;
+import java.util.List;
+
+import static com.jnape.palatable.lambda.functions.builtin.fn2.ToArray.toArray;
+import static java.util.Arrays.asList;
+import static java.util.Collections.emptyIterator;
+import static org.junit.Assert.assertArrayEquals;
+
+public class ToArrayTest {
+
+    @Test
+    public void writesIterableToArray() {
+        assertArrayEquals(new Integer[]{1, 2, 3}, toArray(Integer[].class, asList(1, 2, 3)));
+
+        List<? extends Integer> variance = asList(1, 2, 3);
+        assertArrayEquals(new Object[]{1, 2, 3}, toArray(Object[].class, variance));
+    }
+
+    @Test
+    public void usesCollectionToArrayIfPossible() {
+        Object sentinel = new Object();
+        class CustomCollection extends AbstractCollection<Object> {
+            @Override
+            public Iterator<Object> iterator() {
+                return emptyIterator();
+            }
+
+            @Override
+            public int size() {
+                return 0;
+            }
+
+            @Override
+            @SuppressWarnings("unchecked")
+            public <T> T[] toArray(T[] a) {
+                T[] result = Arrays.copyOf(a, 1);
+                result[0] = (T) sentinel;
+                return result;
+            }
+        }
+
+        assertArrayEquals(new Object[]{sentinel}, toArray(Object[].class, new CustomCollection()));
+    }
+}
