Add method wrapCopy to primitive lists to mirror functionality in Fas…

…tList. Fixes #742.

Signed-off-by: Donald Raab <Donald.Raab@bnymellon.com>

eclipse-collections-api/src/main/java/org/eclipse/collections/api/factory/list/MutableListFactory.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019 Goldman Sachs and others.
+ * Copyright (c) 2020 Goldman Sachs and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * and Eclipse Distribution License v. 1.0 which accompany this distribution.
@@ -46,8 +46,24 @@ default <T> MutableList<T> of(T... items)
         return this.with(items);
     }
 
+    /**
+     * Creates a new list using the passed {@code items} argument as the backing store.
+     * <p>
+     * !!! WARNING: This method uses the passed in array, so can be very unsafe if the original
+     * array is held onto anywhere else. !!!
+     */
     <T> MutableList<T> with(T... items);
 
+    /**
+     * Creates a new list by first copying the array passed in.
+     */
+    default <T> MutableList<T> wrapCopy(T... array)
+    {
+        T[] newArray = (T[]) new Object[array.length];
+        System.arraycopy(array, 0, newArray, 0, array.length);
+        return this.with(newArray);
+    }
+
     /**
      * Same as {@link #empty()}. but takes in initial capacity.
      */

eclipse-collections-code-generator/src/main/resources/api/factory/list/mutablePrimitiveListFactory.stg

@@ -42,8 +42,24 @@ public interface Mutable<name>ListFactory
      */
     Mutable<name>List of(<type>... items);
 
+    /**
+     * Creates a new list using the passed {@code items} argument as the backing store.
+     * \<p>
+     * !!! WARNING: This method uses the passed in array, so can be very unsafe if the original
+     * array is held onto anywhere else. !!!
+     */
     Mutable<name>List with(<type>... items);
 
+    /**
+     * Creates a new list by first copying the array passed in.
+     */
+    default Mutable<name>List wrapCopy(<type>... array)
+    {
+        <type>[] newArray = new <type>[array.length];
+        System.arraycopy(array, 0, newArray, 0, array.length);
+        return this.with(newArray);
+    }
+
     /**
      * Same as {@link #withAll(<name>Iterable)}.
      */

eclipse-collections-code-generator/src/main/resources/copyrightAndOthers.stg

@@ -1,6 +1,6 @@
 copyrightAndOthers() ::= <<
 /*
- * Copyright (c) 2018 Goldman Sachs and others.
+ * Copyright (c) 2020 Goldman Sachs and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * and Eclipse Distribution License v. 1.0 which accompany this distribution.

eclipse-collections-code-generator/src/main/resources/impl/list/mutable/mutablePrimitiveListFactoryImpl.stg

@@ -54,6 +54,12 @@ public enum Mutable<name>ListFactoryImpl implements Mutable<name>ListFactory
         return this.with(items);
     }
 
+    /**
+     * Creates a new list using the passed {@code items} argument as the backing store.
+     * \<p>
+     * !!! WARNING: This method uses the passed in array, so can be very unsafe if the original
+     * array is held onto anywhere else. !!!
+     */
     @Override
     public Mutable<name>List with(<type>... items)
     {

eclipse-collections-code-generator/src/main/resources/impl/list/mutable/primitiveArrayList.stg

@@ -114,6 +114,16 @@ public class <name>ArrayList extends Abstract<name>Iterable
         return newList;
     }
 
+    /**
+     * Creates a new list by first copying the array passed in.
+     */
+    public static <name>ArrayList wrapCopy(<type>... array)
+    {
+        <type>[] newArray = new <type>[array.length];
+        System.arraycopy(array, 0, newArray, 0, array.length);
+        return new <name>ArrayList(newArray);
+    }
+
     @Override
     public int size()
     {

eclipse-collections-code-generator/src/main/resources/test/factory/primitiveListsTest.stg

@@ -1,4 +1,4 @@
-import "copyright.stg"
+import "copyrightAndOthers.stg"
 import "primitiveHashCode.stg"
 import "primitiveLiteral.stg"
 
@@ -13,7 +13,7 @@ class(primitive) ::= <<
 >>
 
 body(type, wrapperName, name) ::= <<
-<copyright()>
+<copyrightAndOthers()>
 
 package org.eclipse.collections.impl.factory.primitive;
 
@@ -138,6 +138,16 @@ public class <name>ListsTest
         Assert.assertEquals(list, <name>Lists.immutable.of(new <type>[]{<["1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11"]:(literal.(type))(); separator=", ">}));
     }
 
+    @Test
+    public void wrapCopy()
+    {
+        <type>[] array = {<["0", "1"]:(literal.(type))(); separator=", ">};
+        Mutable<name>List actual = <name>Lists.mutable.wrapCopy(array);
+        Mutable<name>List expected = <name>ArrayList.newListWith(<["0", "1"]:(literal.(type))(); separator=", ">);
+        array[0] = <(literal.(type))("1")>;
+        Assert.assertEquals(expected, actual);
+    }
+
     @Test
     public void newListWithList()
     {

eclipse-collections-code-generator/src/main/resources/test/list/mutable/primitiveArrayListTest.stg

@@ -73,6 +73,15 @@ public class <name>ArrayListTest extends Abstract<name>ListTestCase
         <name>ArrayList newList = <name>ArrayList.newWithNValues(-5, <(literal.(type))("42")>);
     }
 
+    @Test
+    public void wrapCopy()
+    {
+        <type>[] array = {<(literal.(type))("0")>, <(literal.(type))("1")>};
+        <name>ArrayList list = <name>ArrayList.wrapCopy(array);
+        array[0] = <(literal.(type))("1")>;
+        Assert.assertTrue(list.get(0) \< <(literal.(type))("1")>);
+    }
+
     @Test
     public void addAtIndexAtCapacity() throws Exception
     {

eclipse-collections/src/main/java/org/eclipse/collections/impl/list/mutable/MutableListFactoryImpl.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019 Goldman Sachs and others.
+ * Copyright (c) 2020 Goldman Sachs and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * and Eclipse Distribution License v. 1.0 which accompany this distribution.
@@ -27,6 +27,12 @@ public <T> MutableList<T> empty()
         return FastList.newList();
     }
 
+    /**
+     * Creates a new list using the passed {@code items} argument as the backing store.
+     * <p>
+     * !!! WARNING: This method uses the passed in array, so can be very unsafe if the original
+     * array is held onto anywhere else. !!!
+     */
     @Override
     public <T> MutableList<T> with(T... items)
     {

unit-tests/src/test/java/org/eclipse/collections/impl/factory/ListsTest.java

@@ -105,6 +105,16 @@ public void mutables()
         Verify.assertInstanceOf(MutableList.class, listFactory.fromStream(Stream.of(1, 2, 3)));
     }
 
+    @Test
+    public void wrapCopy()
+    {
+        Integer[] integers = {1, 2, 3, 4};
+        MutableList<Integer> actual = Lists.mutable.wrapCopy(integers);
+        MutableList<Integer> expected = Lists.mutable.with(1, 2, 3, 4);
+        integers[0] = Integer.valueOf(4);
+        Assert.assertEquals(expected, actual);
+    }
+
     @Test
     public void immutableWithListTest()
     {

unit-tests/src/test/java/org/eclipse/collections/impl/list/mutable/FastListTest.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016 Goldman Sachs.
+ * Copyright (c) 2020 Goldman Sachs and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * and Eclipse Distribution License v. 1.0 which accompany this distribution.
@@ -116,9 +116,13 @@ public void testAddWithZeroBasedConstructor()
     }
 
     @Test
-    public void testWrapCopy()
+    public void wrapCopy()
     {
-        Assert.assertEquals(this.newWith(1, 2, 3, 4), FastList.wrapCopy(1, 2, 3, 4));
+        Integer[] integers = {1, 2, 3, 4};
+        FastList<Integer> actual = FastList.wrapCopy(integers);
+        FastList<Integer> expected = this.newWith(1, 2, 3, 4);
+        integers[0] = Integer.valueOf(4);
+        Assert.assertEquals(expected, actual);
     }
 
     @Override