gnu.trove.list.array.TShortArrayList Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of trove4j Show documentation
Show all versions of trove4j Show documentation
The Trove library provides high speed regular and primitive
collections for Java.
///////////////////////////////////////////////////////////////////////////////
// Copyright (c) 2001, Eric D. Friedman All Rights Reserved.
// Copyright (c) 2009, Rob Eden All Rights Reserved.
// Copyright (c) 2009, Jeff Randall All Rights Reserved.
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
///////////////////////////////////////////////////////////////////////////////
package gnu.trove.list.array;
import gnu.trove.function.TShortFunction;
import gnu.trove.list.TShortList;
import gnu.trove.procedure.TShortProcedure;
import gnu.trove.iterator.TShortIterator;
import gnu.trove.TShortCollection;
import gnu.trove.impl.*;
import java.io.Externalizable;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
import java.util.*;
//////////////////////////////////////////////////
// THIS IS A GENERATED CLASS. DO NOT HAND EDIT! //
//////////////////////////////////////////////////
/**
* A resizable, array-backed list of short primitives.
*/
public class TShortArrayList implements TShortList, Externalizable {
static final long serialVersionUID = 1L;
/** the data of the list */
protected short[] _data;
/** the index after the last entry in the list */
protected int _pos;
/** the default capacity for new lists */
protected static final int DEFAULT_CAPACITY = Constants.DEFAULT_CAPACITY;
/** the short value that represents null */
protected short no_entry_value;
/**
* Creates a new TShortArrayList instance with the
* default capacity.
*/
@SuppressWarnings({"RedundantCast"})
public TShortArrayList() {
this( DEFAULT_CAPACITY, ( short ) 0 );
}
/**
* Creates a new TShortArrayList instance with the
* specified capacity.
*
* @param capacity an int value
*/
@SuppressWarnings({"RedundantCast"})
public TShortArrayList( int capacity ) {
this( capacity, ( short ) 0 );
}
/**
* Creates a new TShortArrayList instance with the
* specified capacity.
*
* @param capacity an int value
* @param no_entry_value an short value that represents null.
*/
public TShortArrayList( int capacity, short no_entry_value ) {
_data = new short[ capacity ];
_pos = 0;
this.no_entry_value = no_entry_value;
}
/**
* Creates a new TShortArrayList instance that contains
* a copy of the collection passed to us.
*
* @param collection the collection to copy
*/
public TShortArrayList ( TShortCollection collection ) {
this( collection.size() );
addAll( collection );
}
/**
* Creates a new TShortArrayList instance whose
* capacity is the length of values array and whose
* initial contents are the specified values.
*
* A defensive copy of the given values is held by the new instance.
*
* @param values an short[] value
*/
public TShortArrayList( short[] values ) {
this( values.length );
add( values );
}
protected TShortArrayList(short[] values, short no_entry_value, boolean wrap) {
if (!wrap)
throw new IllegalStateException("Wrong call");
if (values == null)
throw new IllegalArgumentException("values can not be null");
_data = values;
_pos = values.length;
this.no_entry_value = no_entry_value;
}
/**
* Returns a primitive List implementation that wraps around the given primitive array.
*
* NOTE: mutating operation are allowed as long as the List does not grow. In that case
* an IllegalStateException will be thrown
*
* @param values
* @return
*/
public static TShortArrayList wrap(short[] values) {
return wrap(values, ( short ) 0);
}
/**
* Returns a primitive List implementation that wraps around the given primitive array.
*
* NOTE: mutating operation are allowed as long as the List does not grow. In that case
* an IllegalStateException will be thrown
*
* @param values
* @param no_entry_value
* @return
*/
public static TShortArrayList wrap(short[] values, short no_entry_value) {
return new TShortArrayList(values, no_entry_value, true) {
/**
* Growing the wrapped external array is not allow
*/
@Override
public void ensureCapacity(int capacity) {
if (capacity > _data.length)
throw new IllegalStateException("Can not grow ArrayList wrapped external array");
}
};
}
/** {@inheritDoc} */
public short getNoEntryValue() {
return no_entry_value;
}
// sizing
/**
* Grow the internal array as needed to accommodate the specified number of elements.
* The size of the array bytes on each resize unless capacity requires more than twice
* the current capacity.
*/
public void ensureCapacity( int capacity ) {
if ( capacity > _data.length ) {
int newCap = Math.max( _data.length << 1, capacity );
short[] tmp = new short[ newCap ];
System.arraycopy( _data, 0, tmp, 0, _data.length );
_data = tmp;
}
}
/** {@inheritDoc} */
public int size() {
return _pos;
}
/** {@inheritDoc} */
public boolean isEmpty() {
return _pos == 0;
}
/**
* Sheds any excess capacity above and beyond the current size of the list.
*/
public void trimToSize() {
if ( _data.length > size() ) {
short[] tmp = new short[ size() ];
toArray( tmp, 0, tmp.length );
_data = tmp;
}
}
// modifying
/** {@inheritDoc} */
public boolean add( short val ) {
ensureCapacity( _pos + 1 );
_data[ _pos++ ] = val;
return true;
}
/** {@inheritDoc} */
public void add( short[] vals ) {
add( vals, 0, vals.length );
}
/** {@inheritDoc} */
public void add( short[] vals, int offset, int length ) {
ensureCapacity( _pos + length );
System.arraycopy( vals, offset, _data, _pos, length );
_pos += length;
}
/** {@inheritDoc} */
public void insert( int offset, short value ) {
if ( offset == _pos ) {
add( value );
return;
}
ensureCapacity( _pos + 1 );
// shift right
System.arraycopy( _data, offset, _data, offset + 1, _pos - offset );
// insert
_data[ offset ] = value;
_pos++;
}
/** {@inheritDoc} */
public void insert( int offset, short[] values ) {
insert( offset, values, 0, values.length );
}
/** {@inheritDoc} */
public void insert( int offset, short[] values, int valOffset, int len ) {
if ( offset == _pos ) {
add( values, valOffset, len );
return;
}
ensureCapacity( _pos + len );
// shift right
System.arraycopy( _data, offset, _data, offset + len, _pos - offset );
// insert
System.arraycopy( values, valOffset, _data, offset, len );
_pos += len;
}
/** {@inheritDoc} */
public short get( int offset ) {
if ( offset >= _pos ) {
throw new ArrayIndexOutOfBoundsException( offset );
}
return _data[ offset ];
}
/**
* Returns the value at the specified offset without doing any bounds checking.
*/
public short getQuick( int offset ) {
return _data[ offset ];
}
/** {@inheritDoc} */
public short set( int offset, short val ) {
if ( offset >= _pos ) {
throw new ArrayIndexOutOfBoundsException( offset );
}
short prev_val = _data[ offset ];
_data[ offset ] = val;
return prev_val;
}
/** {@inheritDoc} */
public short replace( int offset, short val ) {
if ( offset >= _pos ) {
throw new ArrayIndexOutOfBoundsException( offset );
}
short old = _data[ offset ];
_data[ offset ] = val;
return old;
}
/** {@inheritDoc} */
public void set( int offset, short[] values ) {
set( offset, values, 0, values.length );
}
/** {@inheritDoc} */
public void set( int offset, short[] values, int valOffset, int length ) {
if ( offset < 0 || offset + length > _pos ) {
throw new ArrayIndexOutOfBoundsException( offset );
}
System.arraycopy( values, valOffset, _data, offset, length );
}
/**
* Sets the value at the specified offset without doing any bounds checking.
*/
public void setQuick( int offset, short val ) {
_data[ offset ] = val;
}
/** {@inheritDoc} */
public void clear() {
clear( DEFAULT_CAPACITY );
}
/**
* Flushes the internal state of the list, setting the capacity of the empty list to
* capacity.
*/
public void clear( int capacity ) {
_data = new short[ capacity ];
_pos = 0;
}
/**
* Sets the size of the list to 0, but does not change its capacity. This method can
* be used as an alternative to the {@link #clear()} method if you want to recycle a
* list without allocating new backing arrays.
*/
public void reset() {
_pos = 0;
Arrays.fill( _data, no_entry_value );
}
/**
* Sets the size of the list to 0, but does not change its capacity. This method can
* be used as an alternative to the {@link #clear()} method if you want to recycle a
* list without allocating new backing arrays. This method differs from
* {@link #reset()} in that it does not clear the old values in the backing array.
* Thus, it is possible for getQuick to return stale data if this method is used and
* the caller is careless about bounds checking.
*/
public void resetQuick() {
_pos = 0;
}
/** {@inheritDoc} */
public boolean remove( short value ) {
for ( int index = 0; index < _pos; index++ ) {
if ( value == _data[index] ) {
remove( index, 1 );
return true;
}
}
return false;
}
/** {@inheritDoc} */
public short removeAt( int offset ) {
short old = get( offset );
remove( offset, 1 );
return old;
}
/** {@inheritDoc} */
public void remove( int offset, int length ) {
if ( length == 0 ) return;
if ( offset < 0 || offset >= _pos ) {
throw new ArrayIndexOutOfBoundsException(offset);
}
if ( offset == 0 ) {
// data at the front
System.arraycopy( _data, length, _data, 0, _pos - length );
}
else if ( _pos - length == offset ) {
// no copy to make, decrementing pos "deletes" values at
// the end
}
else {
// data in the middle
System.arraycopy( _data, offset + length, _data, offset,
_pos - ( offset + length ) );
}
_pos -= length;
// no need to clear old values beyond _pos, because this is a
// primitive collection and 0 takes as much room as any other
// value
}
/** {@inheritDoc} */
public TShortIterator iterator() {
return new TShortArrayIterator( 0 );
}
/** {@inheritDoc} */
public boolean containsAll( Collection collection ) {
for ( Object element : collection ) {
if ( element instanceof Short ) {
short c = ( ( Short ) element ).shortValue();
if ( ! contains( c ) ) {
return false;
}
} else {
return false;
}
}
return true;
}
/** {@inheritDoc} */
public boolean containsAll( TShortCollection collection ) {
if ( this == collection ) {
return true;
}
TShortIterator iter = collection.iterator();
while ( iter.hasNext() ) {
short element = iter.next();
if ( ! contains( element ) ) {
return false;
}
}
return true;
}
/** {@inheritDoc} */
public boolean containsAll( short[] array ) {
for ( int i = array.length; i-- > 0; ) {
if ( ! contains( array[i] ) ) {
return false;
}
}
return true;
}
/** {@inheritDoc} */
public boolean addAll( Collection collection ) {
boolean changed = false;
for ( Short element : collection ) {
short e = element.shortValue();
if ( add( e ) ) {
changed = true;
}
}
return changed;
}
/** {@inheritDoc} */
public boolean addAll( TShortCollection collection ) {
boolean changed = false;
TShortIterator iter = collection.iterator();
while ( iter.hasNext() ) {
short element = iter.next();
if ( add( element ) ) {
changed = true;
}
}
return changed;
}
/** {@inheritDoc} */
public boolean addAll( short[] array ) {
boolean changed = false;
for ( short element : array ) {
if ( add( element ) ) {
changed = true;
}
}
return changed;
}
/** {@inheritDoc} */
@SuppressWarnings({"SuspiciousMethodCalls"})
public boolean retainAll( Collection collection ) {
boolean modified = false;
TShortIterator iter = iterator();
while ( iter.hasNext() ) {
if ( ! collection.contains( Short.valueOf ( iter.next() ) ) ) {
iter.remove();
modified = true;
}
}
return modified;
}
/** {@inheritDoc} */
public boolean retainAll( TShortCollection collection ) {
if ( this == collection ) {
return false;
}
boolean modified = false;
TShortIterator iter = iterator();
while ( iter.hasNext() ) {
if ( ! collection.contains( iter.next() ) ) {
iter.remove();
modified = true;
}
}
return modified;
}
/** {@inheritDoc} */
public boolean retainAll( short[] array ) {
boolean changed = false;
Arrays.sort( array );
short[] data = _data;
for ( int i = data.length; i-- > 0; ) {
if ( Arrays.binarySearch( array, data[i] ) < 0 ) {
remove( i, 1 );
changed = true;
}
}
return changed;
}
/** {@inheritDoc} */
public boolean removeAll( Collection collection ) {
boolean changed = false;
for ( Object element : collection ) {
if ( element instanceof Short ) {
short c = ( ( Short ) element ).shortValue();
if ( remove( c ) ) {
changed = true;
}
}
}
return changed;
}
/** {@inheritDoc} */
public boolean removeAll( TShortCollection collection ) {
if ( collection == this ) {
clear();
return true;
}
boolean changed = false;
TShortIterator iter = collection.iterator();
while ( iter.hasNext() ) {
short element = iter.next();
if ( remove( element ) ) {
changed = true;
}
}
return changed;
}
/** {@inheritDoc} */
public boolean removeAll( short[] array ) {
boolean changed = false;
for ( int i = array.length; i-- > 0; ) {
if ( remove(array[i]) ) {
changed = true;
}
}
return changed;
}
/** {@inheritDoc} */
public void transformValues( TShortFunction function ) {
for ( int i = _pos; i-- > 0; ) {
_data[ i ] = function.execute( _data[ i ] );
}
}
/** {@inheritDoc} */
public void reverse() {
reverse( 0, _pos );
}
/** {@inheritDoc} */
public void reverse( int from, int to ) {
if ( from == to ) {
return; // nothing to do
}
if ( from > to ) {
throw new IllegalArgumentException( "from cannot be greater than to" );
}
for ( int i = from, j = to - 1; i < j; i++, j-- ) {
swap( i, j );
}
}
/** {@inheritDoc} */
public void shuffle( Random rand ) {
for ( int i = _pos; i-- > 1; ) {
swap( i, rand.nextInt( i ) );
}
}
/**
* Swap the values at offsets i and j.
*
* @param i an offset into the data array
* @param j an offset into the data array
*/
private void swap( int i, int j ) {
short tmp = _data[ i ];
_data[ i ] = _data[ j ];
_data[ j ] = tmp;
}
// copying
/** {@inheritDoc} */
public TShortList subList( int begin, int end ) {
if ( end < begin ) {
throw new IllegalArgumentException( "end index " + end +
" greater than begin index " + begin );
}
if ( begin < 0 ) {
throw new IndexOutOfBoundsException( "begin index can not be < 0" );
}
if ( end > _data.length ) {
throw new IndexOutOfBoundsException( "end index < " + _data.length );
}
TShortArrayList list = new TShortArrayList( end - begin );
for ( int i = begin; i < end; i++ ) {
list.add( _data[ i ] );
}
return list;
}
/** {@inheritDoc} */
public short[] toArray() {
return toArray( 0, _pos );
}
/** {@inheritDoc} */
public short[] toArray( int offset, int len ) {
short[] rv = new short[ len ];
toArray( rv, offset, len );
return rv;
}
/** {@inheritDoc} */
public short[] toArray( short[] dest ) {
int len = dest.length;
if ( dest.length > _pos ) {
len = _pos;
dest[len] = no_entry_value;
}
toArray( dest, 0, len );
return dest;
}
/** {@inheritDoc} */
public short[] toArray( short[] dest, int offset, int len ) {
if ( len == 0 ) {
return dest; // nothing to copy
}
if ( offset < 0 || offset >= _pos ) {
throw new ArrayIndexOutOfBoundsException( offset );
}
System.arraycopy( _data, offset, dest, 0, len );
return dest;
}
/** {@inheritDoc} */
public short[] toArray( short[] dest, int source_pos, int dest_pos, int len ) {
if ( len == 0 ) {
return dest; // nothing to copy
}
if ( source_pos < 0 || source_pos >= _pos ) {
throw new ArrayIndexOutOfBoundsException( source_pos );
}
System.arraycopy( _data, source_pos, dest, dest_pos, len );
return dest;
}
// comparing
/** {@inheritDoc} */
@Override
public boolean equals( Object other ) {
if ( other == this ) {
return true;
}
else if ( other instanceof TShortArrayList ) {
TShortArrayList that = ( TShortArrayList )other;
if ( that.size() != this.size() ) return false;
else {
for ( int i = _pos; i-- > 0; ) {
if ( this._data[ i ] != that._data[ i ] ) {
return false;
}
}
return true;
}
}
else return false;
}
/** {@inheritDoc} */
@Override
public int hashCode() {
int h = 0;
for ( int i = _pos; i-- > 0; ) {
h += HashFunctions.hash( _data[ i ] );
}
return h;
}
// procedures
/** {@inheritDoc} */
public boolean forEach( TShortProcedure procedure ) {
for ( int i = 0; i < _pos; i++ ) {
if ( !procedure.execute( _data[ i ] ) ) {
return false;
}
}
return true;
}
/** {@inheritDoc} */
public boolean forEachDescending( TShortProcedure procedure ) {
for ( int i = _pos; i-- > 0; ) {
if ( !procedure.execute( _data[ i ] ) ) {
return false;
}
}
return true;
}
// sorting
/** {@inheritDoc} */
public void sort() {
Arrays.sort( _data, 0, _pos );
}
/** {@inheritDoc} */
public void sort( int fromIndex, int toIndex ) {
Arrays.sort( _data, fromIndex, toIndex );
}
// filling
/** {@inheritDoc} */
public void fill( short val ) {
Arrays.fill( _data, 0, _pos, val );
}
/** {@inheritDoc} */
public void fill( int fromIndex, int toIndex, short val ) {
if ( toIndex > _pos ) {
ensureCapacity( toIndex );
_pos = toIndex;
}
Arrays.fill( _data, fromIndex, toIndex, val );
}
// searching
/** {@inheritDoc} */
public int binarySearch( short value ) {
return binarySearch( value, 0, _pos );
}
/** {@inheritDoc} */
public int binarySearch(short value, int fromIndex, int toIndex) {
if ( fromIndex < 0 ) {
throw new ArrayIndexOutOfBoundsException( fromIndex );
}
if ( toIndex > _pos ) {
throw new ArrayIndexOutOfBoundsException( toIndex );
}
int low = fromIndex;
int high = toIndex - 1;
while ( low <= high ) {
int mid = ( low + high ) >>> 1;
short midVal = _data[ mid ];
if ( midVal < value ) {
low = mid + 1;
}
else if ( midVal > value ) {
high = mid - 1;
}
else {
return mid; // value found
}
}
return -( low + 1 ); // value not found.
}
/** {@inheritDoc} */
public int indexOf( short value ) {
return indexOf( 0, value );
}
/** {@inheritDoc} */
public int indexOf( int offset, short value ) {
for ( int i = offset; i < _pos; i++ ) {
if ( _data[ i ] == value ) {
return i;
}
}
return -1;
}
/** {@inheritDoc} */
public int lastIndexOf( short value ) {
return lastIndexOf( _pos, value );
}
/** {@inheritDoc} */
public int lastIndexOf( int offset, short value ) {
for ( int i = offset; i-- > 0; ) {
if ( _data[ i ] == value ) {
return i;
}
}
return -1;
}
/** {@inheritDoc} */
public boolean contains( short value ) {
return lastIndexOf( value ) >= 0;
}
/** {@inheritDoc} */
public TShortList grep( TShortProcedure condition ) {
TShortArrayList list = new TShortArrayList();
for ( int i = 0; i < _pos; i++ ) {
if ( condition.execute( _data[ i ] ) ) {
list.add( _data[ i ] );
}
}
return list;
}
/** {@inheritDoc} */
public TShortList inverseGrep( TShortProcedure condition ) {
TShortArrayList list = new TShortArrayList();
for ( int i = 0; i < _pos; i++ ) {
if ( !condition.execute( _data[ i ] ) ) {
list.add( _data[ i ] );
}
}
return list;
}
/** {@inheritDoc} */
public short max() {
if ( size() == 0 ) {
throw new IllegalStateException("cannot find maximum of an empty list");
}
short max = Short.MIN_VALUE;
for ( int i = 0; i < _pos; i++ ) {
if ( _data[ i ] > max ) {
max = _data[ i ];
}
}
return max;
}
/** {@inheritDoc} */
public short min() {
if ( size() == 0 ) {
throw new IllegalStateException( "cannot find minimum of an empty list" );
}
short min = Short.MAX_VALUE;
for ( int i = 0; i < _pos; i++ ) {
if ( _data[i] < min ) {
min = _data[i];
}
}
return min;
}
/** {@inheritDoc} */
public short sum() {
short sum = 0;
for ( int i = 0; i < _pos; i++ ) {
sum += _data[ i ];
}
return sum;
}
// stringification
/** {@inheritDoc} */
@Override
public String toString() {
final StringBuilder buf = new StringBuilder( "{" );
for ( int i = 0, end = _pos - 1; i < end; i++ ) {
buf.append( _data[ i ] );
buf.append( ", " );
}
if ( size() > 0 ) {
buf.append( _data[ _pos - 1 ] );
}
buf.append( "}" );
return buf.toString();
}
/** TShortArrayList iterator */
class TShortArrayIterator implements TShortIterator {
/** Index of element to be returned by subsequent call to next. */
private int cursor = 0;
/**
* Index of element returned by most recent call to next or
* previous. Reset to -1 if this element is deleted by a call
* to remove.
*/
int lastRet = -1;
TShortArrayIterator( int index ) {
cursor = index;
}
/** {@inheritDoc} */
public boolean hasNext() {
return cursor < size();
}
/** {@inheritDoc} */
public short next() {
try {
short next = get( cursor );
lastRet = cursor++;
return next;
} catch ( IndexOutOfBoundsException e ) {
throw new NoSuchElementException();
}
}
/** {@inheritDoc} */
public void remove() {
if ( lastRet == -1 )
throw new IllegalStateException();
try {
TShortArrayList.this.remove( lastRet, 1);
if ( lastRet < cursor )
cursor--;
lastRet = -1;
} catch ( IndexOutOfBoundsException e ) {
throw new ConcurrentModificationException();
}
}
}
public void writeExternal( ObjectOutput out ) throws IOException {
// VERSION
out.writeByte( 0 );
// POSITION
out.writeInt( _pos );
// NO_ENTRY_VALUE
out.writeShort( no_entry_value );
// ENTRIES
int len = _data.length;
out.writeInt( len );
for( int i = 0; i < len; i++ ) {
out.writeShort( _data[ i ] );
}
}
public void readExternal( ObjectInput in )
throws IOException, ClassNotFoundException {
// VERSION
in.readByte();
// POSITION
_pos = in.readInt();
// NO_ENTRY_VALUE
no_entry_value = in.readShort();
// ENTRIES
int len = in.readInt();
_data = new short[ len ];
for( int i = 0; i < len; i++ ) {
_data[ i ] = in.readShort();
}
}
} // TShortArrayList