* Copyright 2014 Goldman Sachs.

*

* Licensed under the Apache License, Version 2.0 (the "License");

* you may not use this file except in compliance with the License.

* You may obtain a copy of the License at

*

*     http://www.apache.org/licenses/LICENSE-2.0

*

* Unless required by applicable law or agreed to in writing, software

* distributed under the License is distributed on an "AS IS" BASIS,

* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

* See the License for the specific language governing permissions and

* limitations under the License.

*/

* FastList is an attempt to provide the same functionality as ArrayList without the support for concurrent

* modification exceptions.  It also attempts to correct the problem with subclassing ArrayList

* in that the data elements are protected, not private.  It is this issue that caused this class

* to be created in the first place.  The intent was to provide optimized internal iterators which use direct access

* against the array of items, which is currently not possible by subclassing ArrayList.

* <p/>

* An empty FastList created by calling the default constructor starts with a shared reference to a static

* empty array (DEFAULT_SIZED_EMPTY_ARRAY).  This makes empty FastLists very memory efficient.  The

* first call to add will lazily create an array of size 10.

* <p/>

* An empty FastList created by calling the pre-size constructor with a value of 0 (new FastList(0)) starts

* with a shared reference to a static  empty array (ZERO_SIZED_ARRAY).  This makes FastLists presized to 0 very

* memory efficient as well.  The first call to add will lazily create an array of size 1.

*/

        extends AbstractMutableList<T>

        implements Externalizable, RandomAccess, BatchIterable<T>

    private static final long serialVersionUID = 1L;

    private static final Object[] DEFAULT_SIZED_EMPTY_ARRAY = {};

    private static final Object[] ZERO_SIZED_ARRAY = {};

    private static final int MAXIMUM_ARRAY_SIZE = Integer.MAX_VALUE - 8;

    protected int size;

    protected transient T[] items = (T[]) DEFAULT_SIZED_EMPTY_ARRAY;

    public FastList()

    {

    }

    public FastList(int initialCapacity)

    {

        this.items = initialCapacity == 0 ? (T[]) ZERO_SIZED_ARRAY : (T[]) new Object[initialCapacity];

    }

    protected FastList(T[] array)

    {

        this(array.length, array);

    }

    protected FastList(int size, T[] array)

    {

        this.size = size;

        this.items = array;

    }

    public FastList(Collection<? extends T> source)

    {

        this.items = (T[]) source.toArray();

        this.size = this.items.length;

    }

    public static <E> FastList<E> newList()

    {

        return new FastList<E>();

    }

    public static <E> FastList<E> wrapCopy(E... array)

    {

        E[] newArray = (E[]) new Object[array.length];

        System.arraycopy(array, 0, newArray, 0, array.length);

        return new FastList<E>(newArray);

    }

    public static <E> FastList<E> newList(int initialCapacity)

    {

        return new FastList<E>(initialCapacity);

    }

    public static <E> FastList<E> newList(Iterable<? extends E> source)

    {

        return FastList.newListWith((E[]) Iterate.toArray(source));

    }

    /**

     * Creates a new list using the passed {@code elements} 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. !!!

     */

    public static <E> FastList<E> newListWith(E... elements)

    {

        return new FastList<E>(elements);

    }

    /**

     * Creates a new FastList pre-sized to the specified size filled with default values generated by the specified function.

     *

     * @since 3.0

     */

    public static <E> FastList<E> newWithNValues(int size, Function0<E> factory)

    {

        FastList<E> newFastList = FastList.newList(size);

        for (int i = 0; i < size; i++)

        {

            newFastList.add(factory.value());

        }

        return newFastList;

    }

    @Override

    public FastList<T> clone()

    {

        FastList<T> result = (FastList<T>) super.clone();

        if (this.items.length > 0)

        {

            result.items = this.items.clone();

        }

        return result;

    }

    public void clear()

    {

        Arrays.fill(this.items, null);

        this.size = 0;

    }

    @Override

    public void forEach(int from, int to, Procedure<? super T> procedure)

    {

        ListIterate.rangeCheck(from, to, this.size);

        InternalArrayIterate.forEachWithoutChecks(this.items, from, to, procedure);

    }

    @Override

    public void forEachWithIndex(int from, int to, ObjectIntProcedure<? super T> objectIntProcedure)

    {

        ListIterate.rangeCheck(from, to, this.size);

        InternalArrayIterate.forEachWithIndexWithoutChecks(this.items, from, to, objectIntProcedure);

    }

    public void batchForEach(Procedure<? super T> procedure, int sectionIndex, int sectionCount)

    {

        int sectionSize = this.size() / sectionCount;

        int start = sectionSize * sectionIndex;

        int end = sectionIndex == sectionCount - 1 ? this.size() : start + sectionSize;

        if (procedure instanceof FastListSelectProcedure)

        {

            this.batchFastListSelect(start, end, (FastListSelectProcedure<T>) procedure);

        }

        else if (procedure instanceof FastListCollectProcedure)

        {

            this.batchFastListCollect(start, end, (FastListCollectProcedure<T, ?>) procedure);

        }

        else if (procedure instanceof FastListCollectIfProcedure)

        {

            this.batchFastListCollectIf(start, end, (FastListCollectIfProcedure<T, ?>) procedure);

        }

        else if (procedure instanceof CountProcedure)

        {

            this.batchCount(start, end, (CountProcedure<T>) procedure);

        }

        else if (procedure instanceof FastListRejectProcedure)

        {

            this.batchReject(start, end, (FastListRejectProcedure<T>) procedure);

        }

        else if (procedure instanceof MultimapPutProcedure)

        {

            this.batchGroupBy(start, end, (MultimapPutProcedure<?, T>) procedure);

        }

        else

        {

            for (int i = start; i < end; i++)

            {

                procedure.value(this.items[i]);

            }

        }

    }

    /**

     * Implemented to avoid megamorphic call on castProcedure.

     */

    private void batchGroupBy(int start, int end, MultimapPutProcedure<?, T> castProcedure)

    {

        for (int i = start; i < end; i++)

        {

            castProcedure.value(this.items[i]);

        }

    }

    /**

     * Implemented to avoid megamorphic call on castProcedure.

     */

    private void batchReject(int start, int end, FastListRejectProcedure<T> castProcedure)

    {

        for (int i = start; i < end; i++)

        {

            castProcedure.value(this.items[i]);

        }

    }

    /**

     * Implemented to avoid megamorphic call on castProcedure.

     */

    private void batchCount(int start, int end, CountProcedure<T> castProcedure)

    {

        for (int i = start; i < end; i++)

        {

            castProcedure.value(this.items[i]);

        }

    }

    /**

     * Implemented to avoid megamorphic call on castProcedure.

     */

    private void batchFastListCollectIf(int start, int end, FastListCollectIfProcedure<T, ?> castProcedure)

    {

        for (int i = start; i < end; i++)

        {

            castProcedure.value(this.items[i]);

        }

    }

    /**

     * Implemented to avoid megamorphic call on castProcedure.

     */

    private void batchFastListCollect(int start, int end, FastListCollectProcedure<T, ?> castProcedure)

    {

        for (int i = start; i < end; i++)

        {

            castProcedure.value(this.items[i]);

        }

    }

    /**

     * Implemented to avoid megamorphic call on castProcedure.

     */

    private void batchFastListSelect(int start, int end, FastListSelectProcedure<T> castProcedure)

    {

        for (int i = start; i < end; i++)

        {

            castProcedure.value(this.items[i]);

        }

    }

    public int getBatchCount(int batchSize)

    {

        return Math.max(1, this.size() / batchSize);

    }

    public <E> E[] toArray(E[] array, int sourceFromIndex, int sourceToIndex, int destinationIndex)

    {

        System.arraycopy(this.items, sourceFromIndex, array, destinationIndex, sourceToIndex - sourceFromIndex + 1);

        return array;

    }

    public <E> E[] toArray(int sourceFromIndex, int sourceToIndex)

    {

        return this.toArray((E[]) new Object[sourceToIndex - sourceFromIndex + 1], sourceFromIndex, sourceToIndex, 0);

    }

    @Override

    public FastList<T> sortThis(Comparator<? super T> comparator)

    {

        ArrayIterate.sort(this.items, this.size, comparator);

        return this;

    }

    @Override

    public FastList<T> sortThis()

    {

        ArrayIterate.sort(this.items, this.size, null);

        return this;

    }

    @Override

    public FastList<T> reverseThis()

    {

        ArrayIterate.reverse(this.items, this.size);

        return this;

    }

    @Override

    public boolean addAll(Collection<? extends T> source)

    {

        if (source.isEmpty())

        {

            return false;

        }

        if (source.getClass() == FastList.class)

        {

            this.addAllFastList((FastList<T>) source);

        }

        else if (source.getClass() == ArrayList.class)

        {

            this.addAllArrayList((ArrayList<T>) source);

        }

        else

        {

            this.addAllCollection(source);

        }

        return true;

    }

    private void addAllFastList(FastList<T> source)

    {

        int sourceSize = source.size();

        int newSize = this.size + sourceSize;

        this.ensureCapacity(newSize);

        System.arraycopy(source.items, 0, this.items, this.size, sourceSize);

        this.size = newSize;

    }

    private void addAllArrayList(ArrayList<T> source)

    {

        int sourceSize = source.size();

        int newSize = this.size + sourceSize;

        this.ensureCapacity(newSize);

        ArrayListIterate.toArray(source, this.items, this.size, sourceSize);

        this.size = newSize;

    }

    private void addAllCollection(Collection<? extends T> source)

    {

        this.ensureCapacity(this.size + source.size());

        Iterate.forEachWith(source, Procedures2.<T>addToCollection(), this);

    }

    @Override

    public boolean containsAll(Collection<?> source)

    {

        return Iterate.allSatisfyWith(source, Predicates2.in(), this);

    }

    @Override

    public boolean containsAllArguments(Object... source)

    {

        return ArrayIterate.allSatisfyWith(source, Predicates2.in(), this);

    }

    @Override

    public <E> E[] toArray(E[] array)

    {

        if (array.length < this.size)

        {

            array = (E[]) Array.newInstance(array.getClass().getComponentType(), this.size);

        }

        System.arraycopy(this.items, 0, array, 0, this.size);

        if (array.length > this.size)

        {

            array[this.size] = null;

        }

        return array;

    }

    @Override

    public Object[] toArray()

    {

        return this.copyItemsWithNewCapacity(this.size);

    }

    public T[] toTypedArray(Class<T> clazz)

    {

        T[] array = (T[]) Array.newInstance(clazz, this.size);

        System.arraycopy(this.items, 0, array, 0, this.size);

        return array;

    }

    private void throwOutOfBounds(int index)

    {

        throw this.newIndexOutOfBoundsException(index);

    }

    public T set(int index, T element)

    {

        T previous = this.get(index);

        this.items[index] = element;

        return previous;

    }

    @Override

    public int indexOf(Object object)

    {

        for (int i = 0; i < this.size; i++)

        {

            if (Comparators.nullSafeEquals(this.items[i], object))

            {

                return i;

            }

        }

        return -1;

    }

    @Override

    public int lastIndexOf(Object object)

    {

        for (int i = this.size - 1; i >= 0; i--)

        {

            if (Comparators.nullSafeEquals(this.items[i], object))

            {

                return i;

            }

        }

        return -1;

    }

    public void trimToSize()

    {

        if (this.size < this.items.length)

        {

            this.transferItemsToNewArrayWithCapacity(this.size);

        }

    }

    /**

     * Express load factor as 0.25 to trim a collection with more than 25% excess capacity

     */

    public boolean trimToSizeIfGreaterThanPercent(double loadFactor)

    {

        double excessCapacity = 1.0 - (double) this.size / (double) this.items.length;

        if (excessCapacity > loadFactor)

        {

            this.trimToSize();

            return true;

        }

        return false;

    }

    public void ensureCapacity(int minCapacity)

    {

        int oldCapacity = this.items.length;

        if (minCapacity > oldCapacity)

        {

            int newCapacity = Math.max(this.sizePlusFiftyPercent(oldCapacity), minCapacity);

            this.transferItemsToNewArrayWithCapacity(newCapacity);

        }

    }

    private void transferItemsToNewArrayWithCapacity(int newCapacity)

    {

        this.items = (T[]) this.copyItemsWithNewCapacity(newCapacity);

    }

    private Object[] copyItemsWithNewCapacity(int newCapacity)

    {

        Object[] newItems = new Object[newCapacity];

        System.arraycopy(this.items, 0, newItems, 0, Math.min(this.size, newCapacity));

        return newItems;

    }

    public FastList<T> with(T element1, T element2)

    {

        this.add(element1);

        this.add(element2);

        return this;

    }

    public FastList<T> with(T element1, T element2, T element3)

    {

        this.add(element1);

        this.add(element2);

        this.add(element3);

        return this;

    }

    public FastList<T> with(T... elements)

    {

        return this.withArrayCopy(elements, 0, elements.length);

    }

    public FastList<T> withArrayCopy(T[] elements, int begin, int length)

    {

        this.ensureCapacity(this.size + length);

        System.arraycopy(elements, begin, this.items, this.size, length);

        this.size += length;

        return this;

    }

    @Override

    public T getFirst()

    {

        return this.isEmpty() ? null : this.items[0];

    }

    @Override

    public T getLast()

    {

        return this.isEmpty() ? null : this.items[this.size() - 1];

    }

    @Override

    public void forEach(Procedure<? super T> procedure)

    {

        for (int i = 0; i < this.size; i++)

        {

            procedure.value(this.items[i]);

        }

    }

    public void forEachIf(Predicate<? super T> predicate, Procedure<? super T> procedure)

    {

        for (int i = 0; i < this.size; i++)

        {

            T item = this.items[i];

            if (predicate.accept(item))

            {

                procedure.value(item);

            }

        }

    }

    @Override

    public void forEachWithIndex(ObjectIntProcedure<? super T> objectIntProcedure)

    {

        for (int i = 0; i < this.size; i++)

        {

            objectIntProcedure.value(this.items[i], i);

        }

    }

    @Override

    public <P> void forEachWith(Procedure2<? super T, ? super P> procedure, P parameter)

    {

        for (int i = 0; i < this.size; i++)

        {

            procedure.value(this.items[i], parameter);

        }

    }

    @Override

    public FastList<T> select(Predicate<? super T> predicate)

    {

        return this.select(predicate, FastList.<T>newList());

    }

    @Override

    public <R extends Collection<T>> R select(Predicate<? super T> predicate, R target)

    {

        for (int i = 0; i < this.size; i++)

        {

            T item = this.items[i];

            if (predicate.accept(item))

            {

                target.add(item);

            }

        }

        return target;

    }

    @Override

    public <P> FastList<T> selectWith(Predicate2<? super T, ? super P> predicate, P parameter)

    {

        return this.selectWith(predicate, parameter, FastList.<T>newList());

    }

    @Override

    public <P, R extends Collection<T>> R selectWith(

            Predicate2<? super T, ? super P> predicate,

            P parameter,

            R targetCollection)

    {

        for (int i = 0; i < this.size; i++)

        {

            T item = this.items[i];

            if (predicate.accept(item, parameter))

            {

                targetCollection.add(item);

            }

        }

        return targetCollection;

    }

    @Override

    public FastList<T> reject(Predicate<? super T> predicate)

    {

        return this.reject(predicate, FastList.<T>newList());

    }

    @Override

    public <R extends Collection<T>> R reject(Predicate<? super T> predicate, R target)

    {

        for (int i = 0; i < this.size; i++)

        {

            T item = this.items[i];

            if (!predicate.accept(item))

            {

                target.add(item);

            }

        }

        return target;

    }

    @Override

    public <P> FastList<T> rejectWith(Predicate2<? super T, ? super P> predicate, P parameter)

    {

        return this.rejectWith(predicate, parameter, FastList.<T>newList());

    }

    @Override

    public <P, R extends Collection<T>> R rejectWith(

            Predicate2<? super T, ? super P> predicate,

            P parameter,

            R target)

    {

        for (int i = 0; i < this.size; i++)

        {

            T item = this.items[i];

            if (!predicate.accept(item, parameter))

            {

                target.add(item);

            }

        }

        return target;

    }

    @Override

    public <P> Twin<MutableList<T>> selectAndRejectWith(

            Predicate2<? super T, ? super P> predicate,

            P parameter)

    {

        MutableList<T> positiveResult = FastList.newList();

        MutableList<T> negativeResult = FastList.newList();

        for (int i = 0; i < this.size; i++)

        {

            T item = this.items[i];

            (predicate.accept(item, parameter) ? positiveResult : negativeResult).add(item);

        }

        return Tuples.twin(positiveResult, negativeResult);

    }

    @Override

    public <S> FastList<S> selectInstancesOf(Class<S> clazz)

    {

        FastList<S> result = FastList.newList(this.size);

        for (int i = 0; i < this.size; i++)

        {

            T item = this.items[i];

            if (clazz.isInstance(item))

            {

                result.add((S) item);

            }

        }

        result.trimToSize();

        return result;

    }

    @Override

    public void removeIf(Predicate<? super T> predicate)

    {

        int currentFilledIndex = 0;

        for (int i = 0; i < this.size; i++)

        {

            T item = this.items[i];

            if (!predicate.accept(item))

            {

                // keep it

                if (currentFilledIndex != i)

                {

                    this.items[currentFilledIndex] = item;

                }

                currentFilledIndex++;

            }

        }

        this.wipeAndResetTheEnd(currentFilledIndex);

    }

    private void wipeAndResetTheEnd(int newCurrentFilledIndex)

    {

        for (int i = newCurrentFilledIndex; i < this.size; i++)

        {

            this.items[i] = null;

        }

        this.size = newCurrentFilledIndex;

    }

    @Override

    public <P> void removeIfWith(Predicate2<? super T, ? super P> predicate, P parameter)

    {

        int currentFilledIndex = 0;

        for (int i = 0; i < this.size; i++)

        {

            T item = this.items[i];

            if (!predicate.accept(item, parameter))

            {

                // keep it

                if (currentFilledIndex != i)

                {

                    this.items[currentFilledIndex] = item;

                }

                currentFilledIndex++;

            }

        }

        this.wipeAndResetTheEnd(currentFilledIndex);

    }

    @Override

    public <V> FastList<V> collect(Function<? super T, ? extends V> function)

    {

        return this.collect(function, FastList.<V>newList(this.size()));

    }

    @Override

    public MutableBooleanList collectBoolean(BooleanFunction<? super T> booleanFunction)

    {

        return this.collectBoolean(booleanFunction, new BooleanArrayList(this.size));

    }

    @Override

    public <R extends MutableBooleanCollection> R collectBoolean(BooleanFunction<? super T> booleanFunction, R target)

    {

        for (int i = 0; i < this.size; i++)

        {

            target.add(booleanFunction.booleanValueOf(this.items[i]));

        }

        return target;

    }

    @Override

    public MutableByteList collectByte(ByteFunction<? super T> byteFunction)

    {

        return this.collectByte(byteFunction, new ByteArrayList(this.size));

    }

    @Override

    public <R extends MutableByteCollection> R collectByte(ByteFunction<? super T> byteFunction, R target)

    {

        for (int i = 0; i < this.size; i++)

        {

            target.add(byteFunction.byteValueOf(this.items[i]));

        }

        return target;

    }

    @Override

    public MutableCharList collectChar(CharFunction<? super T> charFunction)

    {

        return this.collectChar(charFunction, new CharArrayList(this.size));

    }

    @Override

    public <R extends MutableCharCollection> R collectChar(CharFunction<? super T> charFunction, R target)

    {

        for (int i = 0; i < this.size; i++)

        {

            target.add(charFunction.charValueOf(this.items[i]));

        }

        return target;

    }

    @Override

    public MutableDoubleList collectDouble(DoubleFunction<? super T> doubleFunction)

    {

        return this.collectDouble(doubleFunction, new DoubleArrayList(this.size));

    }

    @Override

    public <R extends MutableDoubleCollection> R collectDouble(DoubleFunction<? super T> doubleFunction, R target)

    {

        for (int i = 0; i < this.size; i++)

        {

            target.add(doubleFunction.doubleValueOf(this.items[i]));

        }

        return target;

    }

    @Override

    public MutableFloatList collectFloat(FloatFunction<? super T> floatFunction)

    {

        return this.collectFloat(floatFunction, new FloatArrayList(this.size));

    }

    @Override

    public <R extends MutableFloatCollection> R collectFloat(FloatFunction<? super T> floatFunction, R target)

    {

        for (int i = 0; i < this.size; i++)

        {

            target.add(floatFunction.floatValueOf(this.items[i]));

        }

        return target;

    }

    @Override

    public MutableIntList collectInt(IntFunction<? super T> intFunction)

    {

        return this.collectInt(intFunction, new IntArrayList(this.size));

    }

    @Override

    public <R extends MutableIntCollection> R collectInt(IntFunction<? super T> intFunction, R target)

    {

        for (int i = 0; i < this.size; i++)

        {

            target.add(intFunction.intValueOf(this.items[i]));

        }

        return target;

    }

    @Override

    public MutableLongList collectLong(LongFunction<? super T> longFunction)

    {

        return this.collectLong(longFunction, new LongArrayList(this.size));

    }

    @Override

    public <R extends MutableLongCollection> R collectLong(LongFunction<? super T> longFunction, R target)

    {

        for (int i = 0; i < this.size; i++)

        {

            target.add(longFunction.longValueOf(this.items[i]));

        }

        return target;

    }

    @Override

    public MutableShortList collectShort(ShortFunction<? super T> shortFunction)

    {

        return this.collectShort(shortFunction, new ShortArrayList(this.size));

    }

    @Override

    public <R extends MutableShortCollection> R collectShort(ShortFunction<? super T> shortFunction, R target)

    {

        for (int i = 0; i < this.size; i++)

        {

            target.add(shortFunction.shortValueOf(this.items[i]));

        }

        return target;

    }

    @Override

    public <V, R extends Collection<V>> R collect(Function<? super T, ? extends V> function, R target)

    {

        for (int i = 0; i < this.size; i++)

        {

            target.add(function.valueOf(this.items[i]));

        }

        return target;

    }

    @Override

    public <V> FastList<V> flatCollect(Function<? super T, ? extends Iterable<V>> function)

    {

        return this.flatCollect(function, FastList.<V>newList(this.size()));

    }

    @Override

    public <V, R extends Collection<V>> R flatCollect(

            Function<? super T, ? extends Iterable<V>> function,

            R target)

    {

        for (int i = 0; i < this.size; i++)

        {

            Iterate.addAllTo(function.valueOf(this.items[i]), target);

        }

        return target;

    }

    @Override

    public <P, V> FastList<V> collectWith(Function2<? super T, ? super P, ? extends V> function, P parameter)

    {

        return this.collectWith(function, parameter, FastList.<V>newList(this.size()));

    }

    @Override

    public <P, V, R extends Collection<V>> R collectWith(

            Function2<? super T, ? super P, ? extends V> function,

            P parameter,

            R targetCollection)

    {

        for (int i = 0; i < this.size; i++)

        {

            targetCollection.add(function.value(this.items[i], parameter));

        }

        return targetCollection;

    }

    @Override

    public <V> FastList<V> collectIf(

            Predicate<? super T> predicate,

            Function<? super T, ? extends V> function)

    {

        return this.collectIf(predicate, function, FastList.<V>newList());

    }

    @Override

    public <V, R extends Collection<V>> R collectIf(

            Predicate<? super T> predicate,

            Function<? super T, ? extends V> function,

            R target)

    {

        for (int i = 0; i < this.size; i++)

        {

            T item = this.items[i];

            if (predicate.accept(item))

            {

                target.add(function.valueOf(item));

            }

        }

        return target;

    }

    @Override

    public T detect(Predicate<? super T> predicate)

    {

        for (int i = 0; i < this.size; i++)

        {

            T item = this.items[i];

            if (predicate.accept(item))

            {

                return item;

            }

        }

        return null;

    }

    @Override

    public T detectIfNone(Predicate<? super T> predicate, Function0<? extends T> defaultValueBlock)

    {

        T result = this.detect(predicate);

        return result == null ? defaultValueBlock.value() : result;

    }

    @Override

    public <V extends Comparable<? super V>> T minBy(Function<? super T, ? extends V> function)

    {

        return ArrayIterate.minBy(this.items, this.size, function);

    }

    @Override

    public <V extends Comparable<? super V>> T maxBy(Function<? super T, ? extends V> function)

    {

        return ArrayIterate.maxBy(this.items, this.size, function);

    }

    @Override

    public <P> T detectWith(Predicate2<? super T, ? super P> predicate, P parameter)

    {

        for (int i = 0; i < this.size; i++)

        {

            T item = this.items[i];

            if (predicate.accept(item, parameter))

            {

                return item;

            }

        }

        return null;

    }

    @Override

    public <P> T detectWithIfNone(

            Predicate2<? super T, ? super P> predicate,

            P parameter,

            Function0<? extends T> defaultValueBlock)

    {

        T result = this.detectWith(predicate, parameter);

        return result == null ? defaultValueBlock.value() : result;

    }

    public T get(int index)

    {

        if (index < this.size)

        {

            return this.items[index];

        }

        throw this.newIndexOutOfBoundsException(index);

    }

    private IndexOutOfBoundsException newIndexOutOfBoundsException(int index)

    {

        return new IndexOutOfBoundsException("Index: " + index + " Size: " + this.size);

    }

    @Override

    public boolean add(T newItem)

    {

        if (this.items.length == this.size)

        {

            this.ensureCapacityForAdd();

        }

        this.items[this.size++] = newItem;