drv.ArrayList.drv Maven / Gradle / Ivy
Show all versions of fastutil Show documentation
/*
* Copyright (C) 2002-2017 Sebastiano Vigna
*
* 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.
*/
package PACKAGE;
import java.util.Arrays;
import java.util.Collection;
import java.util.Iterator;
import java.util.RandomAccess;
import java.util.NoSuchElementException;
#if KEYS_PRIMITIVE
/** A type-specific array-based list; provides some additional methods that use polymorphism to avoid (un)boxing.
*
* This class implements a lightweight, fast, open, optimized,
* reuse-oriented version of array-based lists. Instances of this class
* represent a list with an array that is enlarged as needed when new entries
* are created (by doubling its current length), but is
* never made smaller (even on a {@link #clear()}). A family of
* {@linkplain #trim() trimming methods} lets you control the size of the
* backing array; this is particularly useful if you reuse instances of this class.
* Range checks are equivalent to those of {@link java.util}'s classes, but
* they are delayed as much as possible. The backing array is exposed by the
* {@link #elements()} method.
*
*
This class implements the bulk methods {@code removeElements()},
* {@code addElements()} and {@code getElements()} using
* high-performance system calls (e.g., {@link
* System#arraycopy(Object,int,Object,int,int) System.arraycopy()} instead of
* expensive loops.
*
* @see java.util.ArrayList
*/
public class ARRAY_LIST KEY_GENERIC extends ABSTRACT_LIST KEY_GENERIC implements RandomAccess, Cloneable, java.io.Serializable {
private static final long serialVersionUID = -7046029254386353130L;
#else
/** A type-specific array-based list; provides some additional methods that use polymorphism to avoid (un)boxing.
*
*
This class implements a lightweight, fast, open, optimized,
* reuse-oriented version of array-based lists. Instances of this class
* represent a list with an array that is enlarged as needed when new entries
* are created (by doubling the current length), but is
* never made smaller (even on a {@link #clear()}). A family of
* {@linkplain #trim() trimming methods} lets you control the size of the
* backing array; this is particularly useful if you reuse instances of this class.
* Range checks are equivalent to those of {@link java.util}'s classes, but
* they are delayed as much as possible.
*
*
The backing array is exposed by the {@link #elements()} method. If an instance
* of this class was created {@linkplain #wrap(Object[],int) by wrapping},
* backing-array reallocations will be performed using reflection, so that
* {@link #elements()} can return an array of the same type of the original array: the comments
* about efficiency made in {@link it.unimi.dsi.fastutil.objects.ObjectArrays} apply here.
* Moreover, you must take into consideration that assignment to an array
* not of type {@code Object[]} is slower due to type checking.
*
*
This class implements the bulk methods {@code removeElements()},
* {@code addElements()} and {@code getElements()} using
* high-performance system calls (e.g., {@link
* System#arraycopy(Object,int,Object,int,int) System.arraycopy()} instead of
* expensive loops.
*
* @see java.util.ArrayList
*/
public class ARRAY_LIST KEY_GENERIC extends ABSTRACT_LIST KEY_GENERIC implements RandomAccess, Cloneable, java.io.Serializable {
private static final long serialVersionUID = -7046029254386353131L;
#endif
/** The initial default capacity of an array list. */
public static final int DEFAULT_INITIAL_CAPACITY = 10;
#if ! KEYS_PRIMITIVE
/** Whether the backing array was passed to {@code wrap()}. In
* this case, we must reallocate with the same type of array. */
protected final boolean wrapped;
#endif
/** The backing array. */
protected transient KEY_GENERIC_TYPE a[];
/** The current actual size of the list (never greater than the backing-array length). */
protected int size;
/** Creates a new array list using a given array.
*
*
This constructor is only meant to be used by the wrapping methods.
*
* @param a the array that will be used to back this array list.
*/
protected ARRAY_LIST(final KEY_GENERIC_TYPE a[], @SuppressWarnings("unused") boolean dummy) {
this.a = a;
#if ! KEYS_PRIMITIVE
this.wrapped = true;
#endif
}
/** Creates a new array list with given capacity.
*
* @param capacity the initial capacity of the array list (may be 0).
*/
SUPPRESS_WARNINGS_KEY_UNCHECKED
public ARRAY_LIST(final int capacity) {
if (capacity < 0) throw new IllegalArgumentException("Initial capacity (" + capacity + ") is negative");
if (capacity == 0) a = KEY_GENERIC_ARRAY_CAST ARRAYS.EMPTY_ARRAY;
else a = KEY_GENERIC_ARRAY_CAST new KEY_TYPE[capacity];
#if ! KEYS_PRIMITIVE
wrapped = false;
#endif
}
/** Creates a new array list with {@link #DEFAULT_INITIAL_CAPACITY} capacity. */
SUPPRESS_WARNINGS_KEY_UNCHECKED
public ARRAY_LIST() {
a = KEY_GENERIC_ARRAY_CAST ARRAYS.DEFAULT_EMPTY_ARRAY; // We delay allocation
#if ! KEYS_PRIMITIVE
wrapped = false;
#endif
}
/** Creates a new array list and fills it with a given collection.
*
* @param c a collection that will be used to fill the array list.
*/
public ARRAY_LIST(final Collection c) {
this(c.size());
#if KEYS_PRIMITIVE
size = ITERATORS.unwrap(ITERATORS.AS_KEY_ITERATOR(c.iterator()), a);
#else
size = ITERATORS.unwrap(c.iterator(), a);
#endif
}
/** Creates a new array list and fills it with a given type-specific collection.
*
* @param c a type-specific collection that will be used to fill the array list.
*/
public ARRAY_LIST(final COLLECTION KEY_EXTENDS_GENERIC c) {
this(c.size());
size = ITERATORS.unwrap(c.iterator(), a);
}
/** Creates a new array list and fills it with a given type-specific list.
*
* @param l a type-specific list that will be used to fill the array list.
*/
public ARRAY_LIST(final LIST KEY_EXTENDS_GENERIC l) {
this(l.size());
l.getElements(0, a, 0, size = l.size());
}
/** Creates a new array list and fills it with the elements of a given array.
*
* @param a an array whose elements will be used to fill the array list.
*/
public ARRAY_LIST(final KEY_GENERIC_TYPE a[]) {
this(a, 0, a.length);
}
/** Creates a new array list and fills it with the elements of a given array.
*
* @param a an array whose elements will be used to fill the array list.
* @param offset the first element to use.
* @param length the number of elements to use.
*/
public ARRAY_LIST(final KEY_GENERIC_TYPE a[], final int offset, final int length) {
this(length);
System.arraycopy(a, offset, this.a, 0, length);
size = length;
}
/** Creates a new array list and fills it with the elements returned by an iterator..
*
* @param i an iterator whose returned elements will fill the array list.
*/
public ARRAY_LIST(final Iterator i) {
this();
while(i.hasNext()) this.add(KEY_CLASS2TYPE(i.next()));
}
/** Creates a new array list and fills it with the elements returned by a type-specific iterator..
*
* @param i a type-specific iterator whose returned elements will fill the array list.
*/
public ARRAY_LIST(final KEY_ITERATOR KEY_EXTENDS_GENERIC i) {
this();
while(i.hasNext()) this.add(i.NEXT_KEY());
}
#if KEYS_PRIMITIVE
/** Returns the backing array of this list.
*
* @return the backing array.
*/
public KEY_GENERIC_TYPE[] elements() {
return a;
}
#else
/** Returns the backing array of this list.
*
*
If this array list was created by wrapping a given array, it is guaranteed
* that the type of the returned array will be the same. Otherwise, the returned
* array will be of type {@link Object Object[]} (in spite of the declared return type).
*
*
Warning: This behaviour may cause (unfathomable)
* run-time errors if a method expects an array
* actually of type {@code K[]}, but this methods returns an array
* of type {@link Object Object[]}.
*
* @return the backing array.
*/
public K[] elements() {
return a;
}
#endif
/** Wraps a given array into an array list of given size.
*
*
Note it is guaranteed
* that the type of the array returned by {@link #elements()} will be the same
* (see the comments in the class documentation).
*
* @param a an array to wrap.
* @param length the length of the resulting array list.
* @return a new array list of the given size, wrapping the given array.
*/
public static KEY_GENERIC ARRAY_LIST KEY_GENERIC wrap(final KEY_GENERIC_TYPE a[], final int length) {
if (length > a.length) throw new IllegalArgumentException("The specified length (" + length + ") is greater than the array size (" + a.length + ")");
final ARRAY_LIST KEY_GENERIC l = new ARRAY_LIST KEY_GENERIC_DIAMOND(a, false);
l.size = length;
return l;
}
/** Wraps a given array into an array list.
*
*
Note it is guaranteed
* that the type of the array returned by {@link #elements()} will be the same
* (see the comments in the class documentation).
*
* @param a an array to wrap.
* @return a new array list wrapping the given array.
*/
public static KEY_GENERIC ARRAY_LIST KEY_GENERIC wrap(final KEY_GENERIC_TYPE a[]) {
return wrap(a, a.length);
}
/** Ensures that this array list can contain the given number of entries without resizing.
*
* @param capacity the new minimum capacity for this array list.
*/
SUPPRESS_WARNINGS_KEY_UNCHECKED
public void ensureCapacity(final int capacity) {
if (capacity <= a.length || a == ARRAYS.DEFAULT_EMPTY_ARRAY) return;
#if KEYS_PRIMITIVE
a = ARRAYS.ensureCapacity(a, capacity, size);
#else
if (wrapped) a = ARRAYS.ensureCapacity(a, capacity, size);
else {
if (capacity > a.length) {
final Object t[] = new Object[capacity];
System.arraycopy(a, 0, t, 0, size);
a = (KEY_GENERIC_TYPE[])t;
}
}
#endif
assert size <= a.length;
}
/** Grows this array list, ensuring that it can contain the given number of entries without resizing,
* and in case increasing the current capacity at least by a factor of 50%.
*
* @param capacity the new minimum capacity for this array list.
*/
SUPPRESS_WARNINGS_KEY_UNCHECKED
private void grow(int capacity) {
if (capacity <= a.length) return;
if (a != ARRAYS.DEFAULT_EMPTY_ARRAY)
capacity = (int)Math.max(Math.min((long)a.length + (a.length >> 1), it.unimi.dsi.fastutil.Arrays.MAX_ARRAY_SIZE), capacity);
else if (capacity < DEFAULT_INITIAL_CAPACITY) capacity = DEFAULT_INITIAL_CAPACITY;
#if KEYS_PRIMITIVE
a = ARRAYS.forceCapacity(a, capacity, size);
#else
if (wrapped) a = ARRAYS.forceCapacity(a, capacity, size);
else {
final Object t[] = new Object[capacity];
System.arraycopy(a, 0, t, 0, size);
a = (KEY_GENERIC_TYPE[])t;
}
#endif
assert size <= a.length;
}
@Override
public void add(final int index, final KEY_GENERIC_TYPE k) {
ensureIndex(index);
grow(size + 1);
if (index != size) System.arraycopy(a, index, a, index + 1, size - index);
a[index] = k;
size++;
assert size <= a.length;
}
@Override
public boolean add(final KEY_GENERIC_TYPE k) {
grow(size + 1);
a[size++] = k;
assert size <= a.length;
return true;
}
@Override
public KEY_GENERIC_TYPE GET_KEY(final int index) {
if (index >= size) throw new IndexOutOfBoundsException("Index (" + index + ") is greater than or equal to list size (" + size + ")");
return a[index];
}
@Override
public int indexOf(final KEY_TYPE k) {
for(int i = 0; i < size; i++) if (KEY_EQUALS(k, a[i])) return i;
return -1;
}
@Override
public int lastIndexOf(final KEY_TYPE k) {
for(int i = size; i-- != 0;) if (KEY_EQUALS(k, a[i])) return i;
return -1;
}
@Override
public KEY_GENERIC_TYPE REMOVE_KEY(final int index) {
if (index >= size) throw new IndexOutOfBoundsException("Index (" + index + ") is greater than or equal to list size (" + size + ")");
final KEY_GENERIC_TYPE old = a[index];
size--;
if (index != size) System.arraycopy(a, index + 1, a, index, size - index);
#if KEYS_REFERENCE
a[size] = null;
#endif
assert size <= a.length;
return old;
}
@Override
public boolean REMOVE(final KEY_TYPE k) {
int index = indexOf(k);
if (index == -1) return false;
REMOVE_KEY(index);
assert size <= a.length;
return true;
}
@Override
public KEY_GENERIC_TYPE set(final int index, final KEY_GENERIC_TYPE k) {
if (index >= size) throw new IndexOutOfBoundsException("Index (" + index + ") is greater than or equal to list size (" + size + ")");
KEY_GENERIC_TYPE old = a[index];
a[index] = k;
return old;
}
@Override
public void clear() {
#if KEYS_REFERENCE
Arrays.fill(a, 0, size, null);
#endif
size = 0;
assert size <= a.length;
}
@Override
public int size() {
return size;
}
@Override
public void size(final int size) {
if (size > a.length) a = ARRAYS.forceCapacity(a, size, this.size);
if (size > this.size) Arrays.fill(a, this.size, size, KEY_NULL);
#if KEYS_REFERENCE
else Arrays.fill(a, size, this.size, KEY_NULL);
#endif
this.size = size;
}
@Override
public boolean isEmpty() {
return size == 0;
}
/** Trims this array list so that the capacity is equal to the size.
*
* @see java.util.ArrayList#trimToSize()
*/
public void trim() {
trim(0);
}
/** Trims the backing array if it is too large.
*
* If the current array length is smaller than or equal to
* {@code n}, this method does nothing. Otherwise, it trims the
* array length to the maximum between {@code n} and {@link #size()}.
*
*
This method is useful when reusing lists. {@linkplain #clear() Clearing a
* list} leaves the array length untouched. If you are reusing a list
* many times, you can call this method with a typical
* size to avoid keeping around a very large array just
* because of a few large transient lists.
*
* @param n the threshold for the trimming.
*/
SUPPRESS_WARNINGS_KEY_UNCHECKED
public void trim(final int n) {
// TODO: use Arrays.trim() and preserve type only if necessary
if (n >= a.length || size == a.length) return;
final KEY_GENERIC_TYPE t[] = KEY_GENERIC_ARRAY_CAST new KEY_TYPE[Math.max(n, size)];
System.arraycopy(a, 0, t, 0, size);
a = t;
assert size <= a.length;
}
/** Copies element of this type-specific list into the given array using optimized system calls.
*
* @param from the start index (inclusive).
* @param a the destination array.
* @param offset the offset into the destination array where to store the first element copied.
* @param length the number of elements to be copied.
*/
@Override
public void getElements(final int from, final KEY_TYPE[] a, final int offset, final int length) {
ARRAYS.ensureOffsetLength(a, offset, length);
System.arraycopy(this.a, from, a, offset, length);
}
/** Removes elements of this type-specific list using optimized system calls.
*
* @param from the start index (inclusive).
* @param to the end index (exclusive).
*/
@Override
public void removeElements(final int from, final int to) {
it.unimi.dsi.fastutil.Arrays.ensureFromTo(size, from, to);
System.arraycopy(a, to, a, from, size - to);
size -= (to - from);
#if KEYS_REFERENCE
int i = to - from;
while(i-- != 0) a[size + i] = null;
#endif
}
/** Adds elements to this type-specific list using optimized system calls.
*
* @param index the index at which to add elements.
* @param a the array containing the elements.
* @param offset the offset of the first element to add.
* @param length the number of elements to add.
*/
@Override
public void addElements(final int index, final KEY_GENERIC_TYPE a[], final int offset, final int length) {
ensureIndex(index);
ARRAYS.ensureOffsetLength(a, offset, length);
grow(size + length);
System.arraycopy(this.a, index, this.a, index + length, size - index);
System.arraycopy(a, offset, this.a, index, length);
size += length;
}
#if KEYS_PRIMITIVE
@Override
public KEY_TYPE[] toArray(KEY_TYPE a[]) {
if (a == null || a.length < size) a = new KEY_TYPE[size];
System.arraycopy(this.a, 0, a, 0, size);
return a;
}
@Override
public boolean addAll(int index, final COLLECTION c) {
ensureIndex(index);
int n = c.size();
if (n == 0) return false;
grow(size + n);
if (index != size) System.arraycopy(a, index, a, index + n, size - index);
final KEY_ITERATOR i = c.iterator();
size += n;
while(n-- != 0) a[index++] = i.NEXT_KEY();
assert size <= a.length;
return true;
}
@Override
public boolean addAll(final int index, final LIST l) {
ensureIndex(index);
final int n = l.size();
if (n == 0) return false;
grow(size + n);
if (index != size) System.arraycopy(a, index, a, index + n, size - index);
l.getElements(0, a, index, n);
size += n;
assert size <= a.length;
return true;
}
@Override
public boolean removeAll(final COLLECTION c) {
final KEY_TYPE[] a = this.a;
int j = 0;
for(int i = 0; i < size; i++)
if (! c.contains(a[i])) a[j++] = a[i];
#if KEYS_REFERENCE
Arrays.fill(a, j, size, null);
#endif
final boolean modified = size != j;
size = j;
return modified;
}
#endif
@Override
public boolean removeAll(final Collection c) {
final KEY_TYPE[] a = this.a;
int j = 0;
for(int i = 0; i < size; i++)
if (! c.contains(KEY2OBJ(a[i]))) a[j++] = a[i];
#if KEYS_REFERENCE
Arrays.fill(a, j, size, null);
#endif
final boolean modified = size != j;
size = j;
return modified;
}
@Override
public KEY_LIST_ITERATOR KEY_GENERIC listIterator(final int index) {
ensureIndex(index);
return new KEY_LIST_ITERATOR KEY_GENERIC() {
int pos = index, last = -1;
@Override
public boolean hasNext() { return pos < size; }
@Override
public boolean hasPrevious() { return pos > 0; }
@Override
public KEY_GENERIC_TYPE NEXT_KEY() { if (! hasNext()) throw new NoSuchElementException(); return a[last = pos++]; }
@Override
public KEY_GENERIC_TYPE PREV_KEY() { if (! hasPrevious()) throw new NoSuchElementException(); return a[last = --pos]; }
@Override
public int nextIndex() { return pos; }
@Override
public int previousIndex() { return pos - 1; }
@Override
public void add(KEY_GENERIC_TYPE k) {
ARRAY_LIST.this.add(pos++, k);
last = -1;
}
@Override
public void set(KEY_GENERIC_TYPE k) {
if (last == -1) throw new IllegalStateException();
ARRAY_LIST.this.set(last, k);
}
@Override
public void remove() {
if (last == -1) throw new IllegalStateException();
ARRAY_LIST.this.REMOVE_KEY(last);
/* If the last operation was a next(), we are removing an element *before* us, and we must decrease pos correspondingly. */
if (last < pos) pos--;
last = -1;
}
};
}
@Override
public ARRAY_LIST KEY_GENERIC clone() {
ARRAY_LIST KEY_GENERIC c = new ARRAY_LIST KEY_GENERIC_DIAMOND(size);
System.arraycopy(a, 0, c.a, 0, size);
c.size = size;
return c;
}
#if KEY_CLASS_Object
private boolean valEquals(final K a, final K b) { return a == null ? b == null : a.equals(b); }
#endif
/** Compares this type-specific array list to another one.
*
*
This method exists only for sake of efficiency. The implementation
* inherited from the abstract implementation would already work.
*
* @param l a type-specific array list.
* @return true if the argument contains the same elements of this type-specific array list.
*/
public boolean equals(final ARRAY_LIST KEY_GENERIC l) {
if (l == this) return true;
int s = size();
if (s != l.size()) return false;
final KEY_GENERIC_TYPE[] a1 = a;
final KEY_GENERIC_TYPE[] a2 = l.a;
#if KEY_CLASS_Object
while(s-- != 0) if (! valEquals(a1[s], a2[s])) return false;
#else
while(s-- != 0) if (a1[s] != a2[s]) return false;
#endif
return true;
}
#if ! KEY_CLASS_Reference
/** Compares this array list to another array list.
*
*
This method exists only for sake of efficiency. The implementation
* inherited from the abstract implementation would already work.
*
* @param l an array list.
* @return a negative integer,
* zero, or a positive integer as this list is lexicographically less than, equal
* to, or greater than the argument.
*/
SUPPRESS_WARNINGS_KEY_UNCHECKED
public int compareTo(final ARRAY_LIST KEY_EXTENDS_GENERIC l) {
final int s1 = size(), s2 = l.size();
final KEY_GENERIC_TYPE a1[] = a, a2[] = l.a;
KEY_GENERIC_TYPE e1, e2;
int r, i;
for(i = 0; i < s1 && i < s2; i++) {
e1 = a1[i];
e2 = a2[i];
if ((r = KEY_CMP(e1, e2)) != 0) return r;
}
return i < s2 ? -1 : (i < s1 ? 1 : 0);
}
#endif
private void writeObject(java.io.ObjectOutputStream s) throws java.io.IOException {
s.defaultWriteObject();
for(int i = 0; i < size; i++) s.WRITE_KEY(a[i]);
}
SUPPRESS_WARNINGS_KEY_UNCHECKED
private void readObject(java.io.ObjectInputStream s) throws java.io.IOException, ClassNotFoundException {
s.defaultReadObject();
a = KEY_GENERIC_ARRAY_CAST new KEY_TYPE[size];
for(int i = 0; i < size; i++) a[i] = KEY_GENERIC_CAST s.READ_KEY();
}
#ifdef TEST
private static long seed = System.currentTimeMillis();
private static java.util.Random r = new java.util.Random(seed);
private static KEY_TYPE genKey() {
#if KEY_CLASS_Byte || KEY_CLASS_Short || KEY_CLASS_Character
return (KEY_TYPE)(r.nextInt());
#elif KEYS_PRIMITIVE
return r.NEXT_KEY();
#elif KEY_CLASS_Object
return Integer.toBinaryString(r.nextInt());
#else
return new java.io.Serializable() {};
#endif
}
private static java.text.NumberFormat format = new java.text.DecimalFormat("#,###.00");
private static java.text.FieldPosition p = new java.text.FieldPosition(0);
private static String format(double d) {
StringBuffer s = new StringBuffer();
return format.format(d, s, p).toString();
}
private static void speedTest(int n, boolean comp) {
System.out.println("There are presently no speed tests for this class.");
}
private static void fatal(String msg) {
System.out.println(msg);
System.exit(1);
}
private static void ensure(boolean cond, String msg) {
if (cond) return;
fatal(msg);
}
private static Object[] k, v, nk;
private static KEY_TYPE kt[];
private static KEY_TYPE nkt[];
private static ARRAY_LIST topList;
protected static void testLists(LIST m, java.util.List t, int n, int level) {
long ms;
Exception mThrowsIllegal, tThrowsIllegal, mThrowsOutOfBounds, tThrowsOutOfBounds;
Object rt = null;
KEY_TYPE rm = KEY_NULL;
if (level > 4) return;
/* Now we check that both sets agree on random keys. For m we use the polymorphic method. */
for(int i = 0; i < n; i++) {
int p = r.nextInt() % (n * 2);
KEY_TYPE T = genKey();
mThrowsOutOfBounds = tThrowsOutOfBounds = null;
try {
m.set(p, T);
}
catch (IndexOutOfBoundsException e) { mThrowsOutOfBounds = e; }
try {
t.set(p, KEY2OBJ(T));
}
catch (IndexOutOfBoundsException e) { tThrowsOutOfBounds = e; }
ensure((mThrowsOutOfBounds == null) == (tThrowsOutOfBounds == null), "Error (" + level + ", " + seed + "): set() divergence at start in IndexOutOfBoundsException for index " + p + " (" + mThrowsOutOfBounds + ", " + tThrowsOutOfBounds + ")");
if (mThrowsOutOfBounds == null) ensure(t.get(p).equals(KEY2OBJ(m.GET_KEY(p))), "Error (" + level + ", " + seed + "): m and t differ after set() on position " + p + " (" + m.GET_KEY(p) + ", " + t.get(p) + ")");
p = r.nextInt() % (n * 2);
mThrowsOutOfBounds = tThrowsOutOfBounds = null;
try {
m.GET_KEY(p);
}
catch (IndexOutOfBoundsException e) { mThrowsOutOfBounds = e; }
try {
t.get(p);
}
catch (IndexOutOfBoundsException e) { tThrowsOutOfBounds = e; }
ensure((mThrowsOutOfBounds == null) == (tThrowsOutOfBounds == null), "Error (" + level + ", " + seed + "): get() divergence at start in IndexOutOfBoundsException for index " + p + " (" + mThrowsOutOfBounds + ", " + tThrowsOutOfBounds + ")");
if (mThrowsOutOfBounds == null) ensure(t.get(p).equals(KEY2OBJ(m.GET_KEY(p))), "Error (" + level + ", " + seed + "): m and t differ aftre get() on position " + p + " (" + m.GET_KEY(p) + ", " + t.get(p) + ")");
}
/* Now we check that both sets agree on random keys. For m we use the standard method. */
for(int i = 0; i < n; i++) {
int p = r.nextInt() % (n * 2);
mThrowsOutOfBounds = tThrowsOutOfBounds = null;
try {
m.get(p);
}
catch (IndexOutOfBoundsException e) { mThrowsOutOfBounds = e; }
try {
t.get(p);
}
catch (IndexOutOfBoundsException e) { tThrowsOutOfBounds = e; }
ensure((mThrowsOutOfBounds == null) == (tThrowsOutOfBounds == null), "Error (" + level + ", " + seed + "): get() divergence at start in IndexOutOfBoundsException for index " + p + " (" + mThrowsOutOfBounds + ", " + tThrowsOutOfBounds + ")");
if (mThrowsOutOfBounds == null) ensure(t.get(p).equals(m.get(p)), "Error (" + level + ", " + seed + "): m and t differ at start on position " + p + " (" + m.get(p) + ", " + t.get(p) + ")");
}
/* Now we check that m and t are equal. */
if (!m.equals(t) || ! t.equals(m)) System.err.println("m: " + m + " t: " + t);
ensure(m.equals(t), "Error (" + level + ", " + seed + "): ! m.equals(t) at start");
ensure(t.equals(m), "Error (" + level + ", " + seed + "): ! t.equals(m) at start");
/* Now we check that m actually holds that data. */
for(Iterator i=t.iterator(); i.hasNext();) {
ensure(m.contains(i.next()), "Error (" + level + ", " + seed + "): m and t differ on an entry after insertion (iterating on t)");
}
/* Now we check that m actually holds that data, but iterating on m. */
for(Iterator i=m.listIterator(); i.hasNext();) {
ensure(t.contains(i.next()), "Error (" + level + ", " + seed + "): m and t differ on an entry after insertion (iterating on m)");
}
/* Now we check that inquiries about random data give the same answer in m and t. For
m we use the polymorphic method. */
for(int i=0; i n) {
m.size(n);
while(t.size() != n) t.remove(t.size() -1);
}
/* Now we add random data in m and t using addAll on a type-specific collection, checking that the result is the same. */
for(int i=0; i n) {
m.size(n);
while(t.size() != n) t.remove(t.size() -1);
}
/* Now we add random data in m and t using addAll on a list, checking that the result is the same. */
for(int i=0; i n) {
m.size(n);
while(t.size() != n) t.remove(t.size() -1);
}
/* Now we check that m actually holds the same data. */
for(Iterator i=t.iterator(); i.hasNext();) {
ensure(m.contains(i.next()), "Error (" + level + ", " + seed + "): m and t differ on an entry after removal (iterating on t)");
}
/* Now we check that m actually holds that data, but iterating on m. */
for(Iterator i=m.listIterator(); i.hasNext();) {
ensure(t.contains(i.next()), "Error (" + level + ", " + seed + "): m and t differ on an entry after removal (iterating on m)");
}
/* Now we check that both sets agree on random keys. For m we use the standard method. */
for(int i = 0; i < n; i++) {
int p = r.nextInt() % (n * 2);
mThrowsOutOfBounds = tThrowsOutOfBounds = null;
try {
m.get(p);
}
catch (IndexOutOfBoundsException e) { mThrowsOutOfBounds = e; }
try {
t.get(p);
}
catch (IndexOutOfBoundsException e) { tThrowsOutOfBounds = e; }
ensure((mThrowsOutOfBounds == null) == (tThrowsOutOfBounds == null), "Error (" + level + ", " + seed + "): get() divergence in IndexOutOfBoundsException for index " + p + " (" + mThrowsOutOfBounds + ", " + tThrowsOutOfBounds + ")");
if (mThrowsOutOfBounds == null) ensure(t.get(p).equals(m.get(p)), "Error (" + level + ", " + seed + "): m and t differ on position " + p + " (" + m.get(p) + ", " + t.get(p) +")");
}
/* Now we inquiry about the content with indexOf()/lastIndexOf(). */
for(int i=0; i<10*n; i++) {
KEY_TYPE T = genKey();
ensure(m.indexOf(KEY2OBJ(T)) == t.indexOf(KEY2OBJ(T)),
"Error (" + level + ", " + seed + "): indexOf() divergence for " + T + " (" + m.indexOf(KEY2OBJ(T)) + ", " + t.indexOf(KEY2OBJ(T)) + ")");
ensure(m.lastIndexOf(KEY2OBJ(T)) == t.lastIndexOf(KEY2OBJ(T)),
"Error (" + level + ", " + seed + "): lastIndexOf() divergence for " + T + " (" + m.lastIndexOf(KEY2OBJ(T)) + ", " + t.lastIndexOf(KEY2OBJ(T)) + ")");
ensure(m.indexOf(T) == t.indexOf(KEY2OBJ(T)),
"Error (" + level + ", " + seed + "): polymorphic indexOf() divergence for " + T + " (" + m.indexOf(T) + ", " + t.indexOf(KEY2OBJ(T)) + ")");
ensure(m.lastIndexOf(T) == t.lastIndexOf(KEY2OBJ(T)),
"Error (" + level + ", " + seed + "): polymorphic lastIndexOf() divergence for " + T + " (" + m.lastIndexOf(T) + ", " + t.lastIndexOf(KEY2OBJ(T)) + ")");
}
/* Now we check cloning. */
if (level == 0) {
ensure(m.equals(((ARRAY_LIST)m).clone()), "Error (" + level + ", " + seed + "): m does not equal m.clone()");
ensure(((ARRAY_LIST)m).clone().equals(m), "Error (" + level + ", " + seed + "): m.clone() does not equal m");
}
/* Now we play with constructors. */
ensure(m.equals(new ARRAY_LIST((Collection)m)), "Error (" + level + ", " + seed + "): m does not equal new (Collection m)");
ensure((new ARRAY_LIST((Collection)m)).equals(m), "Error (" + level + ", " + seed + "): new (Collection m)does not equal m");
ensure(m.equals(new ARRAY_LIST((COLLECTION)m)), "Error (" + level + ", " + seed + "): m does not equal new (type-specific Collection m)");
ensure((new ARRAY_LIST((COLLECTION)m)).equals(m), "Error (" + level + ", " + seed + "): new (type-specific Collection m) does not equal m");
ensure(m.equals(new ARRAY_LIST((LIST)m)), "Error (" + level + ", " + seed + "): m does not equal new (type-specific List m)");
ensure((new ARRAY_LIST((LIST)m)).equals(m), "Error (" + level + ", " + seed + "): new (type-specific List m) does not equal m");
ensure(m.equals(new ARRAY_LIST(m.listIterator())), "Error (" + level + ", " + seed + "): m does not equal new (m.listIterator())");
ensure((new ARRAY_LIST(m.listIterator())).equals(m), "Error (" + level + ", " + seed + "): new (m.listIterator()) does not equal m");
ensure(m.equals(new ARRAY_LIST(m.iterator())), "Error (" + level + ", " + seed + "): m does not equal new (m.type_specific_iterator())");
ensure((new ARRAY_LIST(m.iterator())).equals(m), "Error (" + level + ", " + seed + "): new (m.type_specific_iterator()) does not equal m");
/* Now we play with conversion to array, wrapping and copying. */
ensure(m.equals(new ARRAY_LIST(m.TO_KEY_ARRAY())), "Error (" + level + ", " + seed + "): m does not equal new (toArray(m))");
ensure((new ARRAY_LIST(m.TO_KEY_ARRAY())).equals(m), "Error (" + level + ", " + seed + "): new (toArray(m)) does not equal m");
ensure(m.equals(wrap(m.TO_KEY_ARRAY())), "Error (" + level + ", " + seed + "): m does not equal wrap (toArray(m))");
ensure((wrap(m.TO_KEY_ARRAY())).equals(m), "Error (" + level + ", " + seed + "): wrap (toArray(m)) does not equal m");
int h = m.hashCode();
/* Now we save and read m. */
LIST m2 = null;
try {
java.io.File ff = new java.io.File("it.unimi.dsi.fastutil.test");
java.io.OutputStream os = new java.io.FileOutputStream(ff);
java.io.ObjectOutputStream oos = new java.io.ObjectOutputStream(os);
oos.writeObject(m);
oos.close();
java.io.InputStream is = new java.io.FileInputStream(ff);
java.io.ObjectInputStream ois = new java.io.ObjectInputStream(is);
m2 = (LIST)ois.readObject();
ois.close();
ff.delete();
}
catch(Exception e) {
e.printStackTrace();
System.exit(1);
}
#if ! KEY_CLASS_Reference
ensure(m2.hashCode() == h, "Error (" + level + ", " + seed + "): hashCode() changed after save/read");
/* Now we check that m2 actually holds that data. */
ensure(m2.equals(t), "Error (" + level + ", " + seed + "): ! m2.equals(t) after save/read");
ensure(t.equals(m2), "Error (" + level + ", " + seed + "): ! t.equals(m2) after save/read");
/* Now we take out of m everything, and check that it is empty. */
for(Iterator i=t.iterator(); i.hasNext();) m2.remove(i.next());
ensure(m2.isEmpty(), "Error (" + level + ", " + seed + "): m2 is not empty (as it should be)");
#endif
/* Now we play with iterators. */
{
KEY_LIST_ITERATOR i;
java.util.ListIterator j;
Object J;
i = m.listIterator();
j = t.listIterator();
for(int k = 0; k < 2*n; k++) {
ensure(i.hasNext() == j.hasNext(), "Error (" + level + ", " + seed + "): divergence in hasNext()");
ensure(i.hasPrevious() == j.hasPrevious(), "Error (" + level + ", " + seed + "): divergence in hasPrevious()");
if (r.nextFloat() < .8 && i.hasNext()) {
ensure(i.next().equals(J = j.next()), "Error (" + level + ", " + seed + "): divergence in next()");
if (r.nextFloat() < 0.2) {
i.remove();
j.remove();
}
else if (r.nextFloat() < 0.2) {
KEY_TYPE T = genKey();
i.set(T);
j.set(KEY2OBJ(T));
}
else if (r.nextFloat() < 0.2) {
KEY_TYPE T = genKey();
i.add(T);
j.add(KEY2OBJ(T));
}
}
else if (r.nextFloat() < .2 && i.hasPrevious()) {
ensure(i.previous().equals(J = j.previous()), "Error (" + level + ", " + seed + "): divergence in previous()");
if (r.nextFloat() < 0.2) {
i.remove();
j.remove();
}
else if (r.nextFloat() < 0.2) {
KEY_TYPE T = genKey();
i.set(T);
j.set(KEY2OBJ(T));
}
else if (r.nextFloat() < 0.2) {
KEY_TYPE T = genKey();
i.add(T);
j.add(KEY2OBJ(T));
}
}
ensure(i.nextIndex() == j.nextIndex(), "Error (" + level + ", " + seed + "): divergence in nextIndex()");
ensure(i.previousIndex() == j.previousIndex(), "Error (" + level + ", " + seed + "): divergence in previousIndex()");
}
}
{
Object previous = null;
Object I, J;
int from = r.nextInt(m.size() +1);
KEY_LIST_ITERATOR i;
java.util.ListIterator j;
i = m.listIterator(from);
j = t.listIterator(from);
for(int k = 0; k < 2*n; k++) {
ensure(i.hasNext() == j.hasNext(), "Error (" + level + ", " + seed + "): divergence in hasNext() (iterator with starting point " + from + ")");
ensure(i.hasPrevious() == j.hasPrevious() , "Error (" + level + ", " + seed + "): divergence in hasPrevious() (iterator with starting point " + from + ")");
if (r.nextFloat() < .8 && i.hasNext()) {
ensure((I = i.next()).equals(J = j.next()), "Error (" + level + ", " + seed + "): divergence in next() (" + I + ", " + J + ", iterator with starting point " + from + ")");
//System.err.println("Done next " + I + " " + J + " " + badPrevious);
if (r.nextFloat() < 0.2) {
//System.err.println("Removing in next");
i.remove();
j.remove();
}
else if (r.nextFloat() < 0.2) {
KEY_TYPE T = genKey();
i.set(T);
j.set(KEY2OBJ(T));
}
else if (r.nextFloat() < 0.2) {
KEY_TYPE T = genKey();
i.add(T);
j.add(KEY2OBJ(T));
}
}
else if (r.nextFloat() < .2 && i.hasPrevious()) {
ensure((I = i.previous()).equals(J = j.previous()), "Error (" + level + ", " + seed + "): divergence in previous() (" + I + ", " + J + ", iterator with starting point " + from + ")");
if (r.nextFloat() < 0.2) {
//System.err.println("Removing in prev");
i.remove();
j.remove();
}
else if (r.nextFloat() < 0.2) {
KEY_TYPE T = genKey();
i.set(T);
j.set(KEY2OBJ(T));
}
else if (r.nextFloat() < 0.2) {
KEY_TYPE T = genKey();
i.add(T);
j.add(KEY2OBJ(T));
}
}
}
}
/* Now we check that m actually holds that data. */
ensure(m.equals(t), "Error (" + level + ", " + seed + "): ! m.equals(t) after iteration");
ensure(t.equals(m), "Error (" + level + ", " + seed + "): ! t.equals(m) after iteration");
/* Now we select a pair of keys and create a subset. */
if (! m.isEmpty()) {
int start = r.nextInt(m.size());
int end = start + r.nextInt(m.size() - start);
//System.err.println("Checking subList from " + start + " to " + end + " (level=" + (level+1) + ")...");
testLists(m.subList(start, end), t.subList(start, end), n, level + 1);
ensure(m.equals(t), "Error (" + level + ", " + seed + m + t + "): ! m.equals(t) after subList");
ensure(t.equals(m), "Error (" + level + ", " + seed + "): ! t.equals(m) after subList");
}
m.clear();
t.clear();
ensure(m.isEmpty(), "Error (" + level + ", " + seed + "): m is not empty after clear()");
}
protected static void runTest(int n) {
ARRAY_LIST m = new ARRAY_LIST();
java.util.ArrayList t = new java.util.ArrayList();
topList = m;
k = new Object[n];
nk = new Object[n];
kt = new KEY_TYPE[n];
nkt = new KEY_TYPE[n];
for(int i = 0; i < n; i++) {
#if KEYS_REFERENCE
k[i] = kt[i] = genKey();
nk[i] = nkt[i] = genKey();
#else
k[i] = new KEY_CLASS(kt[i] = genKey());
nk[i] = new KEY_CLASS(nkt[i] = genKey());
#endif
}
/* We add pairs to t. */
for(int i = 0; i < n; i++) t.add(k[i]);
/* We add to m the same data */
m.addAll(t);
testLists(m, t, n, 0);
System.out.println("Test OK");
return;
}
public static void main(String args[]) {
int n = Integer.parseInt(args[1]);
if (args.length > 2) r = new java.util.Random(seed = Long.parseLong(args[2]));
try {
if ("speedTest".equals(args[0]) || "speedComp".equals(args[0])) speedTest(n, "speedComp".equals(args[0]));
else if ("test".equals(args[0])) runTest(n);
} catch(Throwable e) {
e.printStackTrace(System.err);
System.err.println("seed: " + seed);
}
}
#endif
}