gnu.trove.impl.unmodifiable.TUnmodifiableDoubleList Maven / Gradle / Ivy

///////////////////////////////////////////////////////////////////////////////
// Copyright (c) 2008, Robert D. 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.impl.unmodifiable;


//////////////////////////////////////////////////
// THIS IS A GENERATED CLASS. DO NOT HAND EDIT! //
//////////////////////////////////////////////////

////////////////////////////////////////////////////////////
// THIS IS AN IMPLEMENTATION CLASS. DO NOT USE DIRECTLY!  //
// Access to these methods should be through TCollections //
////////////////////////////////////////////////////////////


import gnu.trove.iterator.*;
import gnu.trove.procedure.*;
import gnu.trove.set.*;
import gnu.trove.list.*;
import gnu.trove.function.*;
import gnu.trove.map.*;
import gnu.trove.*;

import java.util.Collection;
import java.util.Iterator;
import java.util.Set;
import java.util.Map;
import java.util.RandomAccess;
import java.util.Random;
import java.io.Serializable;
import java.io.ObjectOutputStream;
import java.io.IOException;


public class TUnmodifiableDoubleList extends TUnmodifiableDoubleCollection implements TDoubleList {
	static final long serialVersionUID = -283967356065247728L;

	final TDoubleList list;

	public TUnmodifiableDoubleList( TDoubleList list ) {
		super( list );
		this.list = list;
	}

	public boolean equals( Object o )   { return o == this || list.equals( o ); }
	public int hashCode()               { return list.hashCode(); }

	public double get( int index )         { return list.get( index ); }
	public int indexOf( double o )         { return list.indexOf( o ); }
	public int lastIndexOf( double o )     { return list.lastIndexOf( o ); }

	public double[] toArray( int offset, int len ) {
		return list.toArray( offset, len );
	}
	public double[] toArray( double[] dest, int offset, int len ) {
		return list.toArray( dest, offset, len );
	}
	public double[] toArray( double[] dest, int source_pos, int dest_pos, int len ) {
		return list.toArray( dest, source_pos, dest_pos, len );
	}

	public boolean forEachDescending( TDoubleProcedure procedure ) {
		return list.forEachDescending( procedure );
	}

	public int binarySearch( double value ) { return list.binarySearch( value ); }
	public int binarySearch( double value, int fromIndex, int toIndex ) {
		return list.binarySearch( value, fromIndex, toIndex );
	}

	public int indexOf( int offset, double value )     { return list.indexOf( offset, value ); }
	public int lastIndexOf( int offset, double value ) { return list.lastIndexOf( offset, value ); }
	public TDoubleList grep( TDoubleProcedure condition ) { return list.grep( condition ); }
	public TDoubleList inverseGrep( TDoubleProcedure condition ) { return list.inverseGrep( condition ); }

	public double max()    { return list.max(); }
	public double min()    { return list.min(); }
	public double sum()    { return list.sum(); }

	public TDoubleList subList( int fromIndex, int toIndex ) {
		return new TUnmodifiableDoubleList( list.subList( fromIndex, toIndex ) );
	}

	// TODO: Do we want to fullt implement ListIterator?
//        public TIntListIterator listIterator() 	{return listIterator(0);}
//
//        public ListIterator listIterator(final int index) {
//            return new ListIterator() {
//                ListIterator i = list.listIterator(index);
//
//                public boolean hasNext()     {return i.hasNext();}
//                public E next()		     {return i.next();}
//                public boolean hasPrevious() {return i.hasPrevious();}
//                public E previous()	     {return i.previous();}
//                public int nextIndex()       {return i.nextIndex();}
//                public int previousIndex()   {return i.previousIndex();}
//
//                public void remove() {
//                    throw new UnsupportedOperationException();
//                }
//                public void set(E e) {
//                    throw new UnsupportedOperationException();
//                }
//                public void add(E e) {
//                    throw new UnsupportedOperationException();
//                }
//            };
//        }

	/**
	 * UnmodifiableRandomAccessList instances are serialized as
	 * UnmodifiableList instances to allow them to be deserialized
	 * in pre-1.4 JREs (which do not have UnmodifiableRandomAccessList).
	 * This method inverts the transformation.  As a beneficial
	 * side-effect, it also grafts the RandomAccess marker onto
	 * UnmodifiableList instances that were serialized in pre-1.4 JREs.
	 *
	 * Note: Unfortunately, UnmodifiableRandomAccessList instances
	 * serialized in 1.4.1 and deserialized in 1.4 will become
	 * UnmodifiableList instances, as this method was missing in 1.4.
	 */
	private Object readResolve() {
		return ( list instanceof RandomAccess
		? new TUnmodifiableRandomAccessDoubleList( list )
		: this);
	}

	public void add( double[] vals ) { throw new UnsupportedOperationException(); }
	public void add( double[] vals, int offset, int length ) { throw new UnsupportedOperationException(); }

	public double removeAt( int offset ) { throw new UnsupportedOperationException(); }
	public void remove( int offset, int length ) { throw new UnsupportedOperationException(); }

	public void insert( int offset, double value ) { throw new UnsupportedOperationException(); }
	public void insert( int offset, double[] values ) { throw new UnsupportedOperationException(); }
	public void insert( int offset, double[] values, int valOffset, int len ) { throw new UnsupportedOperationException(); }

	public double set( int offset, double val ) { throw new UnsupportedOperationException(); }
	public void set( int offset, double[] values ) { throw new UnsupportedOperationException(); }
	public void set( int offset, double[] values, int valOffset, int length ) { throw new UnsupportedOperationException(); }

	public double replace( int offset, double val ) { throw new UnsupportedOperationException(); }

	public void transformValues( TDoubleFunction function ) { throw new UnsupportedOperationException(); }

	public void reverse() { throw new UnsupportedOperationException(); }
	public void reverse( int from, int to ) { throw new UnsupportedOperationException(); }
	public void shuffle( Random rand ) { throw new UnsupportedOperationException(); }

	public void sort() { throw new UnsupportedOperationException(); }
	public void sort( int fromIndex, int toIndex ) { throw new UnsupportedOperationException(); }
	public void fill( double val ) { throw new UnsupportedOperationException(); }
	public void fill( int fromIndex, int toIndex, double val ) { throw new UnsupportedOperationException(); }
}