drv.ArrayList.drv Maven / Gradle / Ivy
Show all versions of fastutil Show documentation
/*
* Copyright (C) 2002-2016 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 removeElements(),
* addElements() and 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 removeElements(),
* addElements() and 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 final static int DEFAULT_INITIAL_CAPACITY = 16;
#if ! KEYS_PRIMITIVE
/** Whether the backing array was passed to 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;
private static final boolean ASSERTS = ASSERTS_VALUE;
/** 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.
*/
@SuppressWarnings("unused")
protected ARRAY_LIST( final KEY_GENERIC_TYPE a[], 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" );
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.
*/
public ARRAY_LIST() {
this( DEFAULT_INITIAL_CAPACITY );
}
/** 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( 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 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( 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 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
if ( ASSERTS ) assert size <= a.length;
}
/** Grows this array list, ensuring that it can contain the given number of entries without resizing,
* and in case enlarging it at least by a factor of two.
*
* @param capacity the new minimum capacity for this array list.
*/
SUPPRESS_WARNINGS_KEY_UNCHECKED
private void grow( final int capacity ) {
#if KEYS_PRIMITIVE
a = ARRAYS.grow( a, capacity, size );
#else
if ( wrapped ) a = ARRAYS.grow( a, capacity, size );
else {
if ( capacity > a.length ) {
final int newLength = (int)Math.max( Math.min( 2L * a.length, it.unimi.dsi.fastutil.Arrays.MAX_ARRAY_SIZE ), capacity );
final Object t[] = new Object[ newLength ];
System.arraycopy( a, 0, t, 0, size );
a = (KEY_GENERIC_TYPE[])t;
}
}
#endif
if ( ASSERTS ) assert size <= a.length;
}
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++;
if ( ASSERTS ) assert size <= a.length;
}
public boolean add( final KEY_GENERIC_TYPE k ) {
grow( size + 1 );
a[ size++ ] = k;
if ( ASSERTS ) assert size <= a.length;
return true;
}
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 ];
}
public int indexOf( final KEY_TYPE k ) {
for( int i = 0; i < size; i++ ) if ( KEY_EQUALS( k, a[ i ] ) ) return i;
return -1;
}
public int lastIndexOf( final KEY_TYPE k ) {
for( int i = size; i-- != 0; ) if ( KEY_EQUALS( k, a[ i ] ) ) return i;
return -1;
}
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
if ( ASSERTS ) assert size <= a.length;
return old;
}
public boolean rem( final KEY_TYPE k ) {
int index = indexOf( k );
if ( index == -1 ) return false;
REMOVE_KEY( index );
if ( ASSERTS ) assert size <= a.length;
return true;
}
#if KEYS_REFERENCE
public boolean remove( final Object o ) {
return rem( o );
}
#endif
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;
}
public void clear() {
#if KEYS_REFERENCE
Arrays.fill( a, 0, size, null );
#endif
size = 0;
if ( ASSERTS ) assert size <= a.length;
}
public int size() {
return size;
}
public void size( final int size ) {
if ( size > a.length ) ensureCapacity( 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;
}
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
* n, this method does nothing. Otherwise, it trims the
* array length to the maximum between 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;
if ( ASSERTS ) 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.
*/
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).
*/
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.
*/
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
public KEY_TYPE[] TO_KEY_ARRAY( KEY_TYPE a[] ) {
if ( a == null || a.length < size ) a = new KEY_TYPE[ size ];
System.arraycopy( this.a, 0, a, 0, size );
return a;
}
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();
if ( ASSERTS ) assert size <= a.length;
return true;
}
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;
if ( ASSERTS ) 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 ];
final boolean modified = size != j;
size = j;
return modified;
}
@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 ];
final boolean modified = size != j;
size = j;
return modified;
}
#else
@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 ];
Arrays.fill( a, j, size, null );
final boolean modified = size != j;
size = j;
return modified;
}
#endif
public KEY_LIST_ITERATOR KEY_GENERIC listIterator( final int index ) {
ensureIndex( index );
return new KEY_ABSTRACT_LIST_ITERATOR KEY_GENERIC() {
int pos = index, last = -1;
public boolean hasNext() { return pos < size; }
public boolean hasPrevious() { return pos > 0; }
public KEY_GENERIC_TYPE NEXT_KEY() { if ( ! hasNext() ) throw new NoSuchElementException(); return a[ last = pos++ ]; }
public KEY_GENERIC_TYPE PREV_KEY() { if ( ! hasPrevious() ) throw new NoSuchElementException(); return a[ last = --pos ]; }
public int nextIndex() { return pos; }
public int previousIndex() { return pos - 1; }
public void add( KEY_GENERIC_TYPE k ) {
ARRAY_LIST.this.add( pos++, k );
last = -1;
}
public void set( KEY_GENERIC_TYPE k ) {
if ( last == -1 ) throw new IllegalStateException();
ARRAY_LIST.this.set( last, k );
}
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;
}
};
}
public ARRAY_LIST KEY_GENERIC clone() {
ARRAY_LIST KEY_GENERIC c = new ARRAY_LIST KEY_GENERIC( 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 test( 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] ) ) test(n);
} catch( Throwable e ) {
e.printStackTrace( System.err );
System.err.println( "seed: " + seed );
}
}
#endif
}