drv.AbstractList.drv Maven / Gradle / Ivy
Show all versions of fastutil-core Show documentation
/*
* Copyright (C) 2002-2021 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;
#if KEYS_REFERENCE
import it.unimi.dsi.fastutil.Stack;
#endif
import java.util.List;
import java.util.Iterator;
import java.util.ListIterator;
import java.util.Collection;
import java.util.NoSuchElementException;
#if KEYS_REFERENCE
import java.util.function.Consumer;
#endif
/** An abstract class providing basic methods for lists implementing a type-specific list interface.
*
* As an additional bonus, this class implements on top of the list operations a type-specific stack.
*
*
Most of the methods in this class are optimized with the assumption that the List will have
* {@link java.util.RandomAccess have constant-time random access}. If this is not the case, you
* should probably at least override {@link #listIterator(int)} and the {@code xAll()} methods
* (such as {@link #addAll}) with a more appropriate iteration scheme. Note the {@link #subList(int, int)}
* method is cognizant of random-access or not, so that need not be reimplemented.
*/
public abstract class ABSTRACT_LIST KEY_GENERIC extends ABSTRACT_COLLECTION KEY_GENERIC implements LIST KEY_GENERIC, STACK KEY_GENERIC {
protected ABSTRACT_LIST() {}
/** Ensures that the given index is nonnegative and not greater than the list size.
*
* @param index an index.
* @throws IndexOutOfBoundsException if the given index is negative or greater than the list size.
*/
protected void ensureIndex(final int index) {
// TODO When Java 9 becomes the minimum java, use Objects#checkIndex(index, size() + 1) (as can be an intrinsic)
if (index < 0) throw new IndexOutOfBoundsException("Index (" + index + ") is negative");
if (index > size()) throw new IndexOutOfBoundsException("Index (" + index + ") is greater than list size (" + (size()) + ")");
}
/** Ensures that the given index is nonnegative and smaller than the list size.
*
* @param index an index.
* @throws IndexOutOfBoundsException if the given index is negative or not smaller than the list size.
*/
protected void ensureRestrictedIndex(final int index) {
// TODO When Java 9 becomes the minimum java, use Objects#checkIndex (as can be an intrinsic)
if (index < 0) throw new IndexOutOfBoundsException("Index (" + index + ") is negative");
if (index >= size()) throw new IndexOutOfBoundsException("Index (" + index + ") is greater than or equal to list size (" + (size()) + ")");
}
/** {@inheritDoc}
*
* @implSpec This implementation always throws an {@link UnsupportedOperationException}.
*/
@Override
public void add(final int index, final KEY_GENERIC_TYPE k) {
throw new UnsupportedOperationException();
}
/** {@inheritDoc}
*
* @implSpec This implementation delegates to the type-specific version of {@link List#add(int, Object)}.
*/
@Override
public boolean add(final KEY_GENERIC_TYPE k) {
add(size(), k);
return true;
}
/** {@inheritDoc}
*
* @implSpec This implementation always throws an {@link UnsupportedOperationException}.
*/
@Override
public KEY_GENERIC_TYPE REMOVE_KEY(final int i) {
throw new UnsupportedOperationException();
}
/** {@inheritDoc}
*
* @implSpec This implementation always throws an {@link UnsupportedOperationException}.
*/
@Override
public KEY_GENERIC_TYPE set(final int index, final KEY_GENERIC_TYPE k) {
throw new UnsupportedOperationException();
}
/** Adds all of the elements in the specified collection to this list (optional operation). */
@Override
public boolean addAll(int index, final Collection c) {
#if KEYS_PRIMITIVE
if (c instanceof COLLECTION) {
return addAll(index, (COLLECTION) c);
}
#endif
ensureIndex(index);
final Iterator i = c.iterator();
final boolean retVal = i.hasNext();
while(i.hasNext()) add(index++, KEY_CLASS2TYPE(i.next()));
return retVal;
}
/** {@inheritDoc}
*
* @implSpec This implementation delegates to the type-specific version of {@link List#addAll(int, Collection)}.
*/
@Override
public boolean addAll(final Collection c) {
return addAll(size(), c);
}
/** {@inheritDoc}
*
* @implSpec This implementation delegates to {@link #listIterator()}.
*/
@Override
public KEY_LIST_ITERATOR KEY_GENERIC iterator() {
return listIterator();
}
/** {@inheritDoc}
*
* @implSpec This implementation delegates to {@link #listIterator(int) listIterator(0)}.
*/
@Override
public KEY_LIST_ITERATOR KEY_GENERIC listIterator() {
return listIterator(0);
}
/** {@inheritDoc}
* @implSpec This implementation is based on the random-access methods. */
@Override
public KEY_LIST_ITERATOR KEY_GENERIC listIterator(final int index) {
ensureIndex(index);
return new ITERATORS.AbstractIndexBasedListIterator KEY_GENERIC(0, index) {
@Override
protected final KEY_GENERIC_TYPE get(int i) { return ABSTRACT_LIST.this.GET_KEY(i); }
@Override
protected final void add(int i, KEY_GENERIC_TYPE k) { ABSTRACT_LIST.this.add(i, k); }
@Override
protected final void set(int i, KEY_GENERIC_TYPE k) { ABSTRACT_LIST.this.set(i, k); }
@Override
protected final void remove(int i) { ABSTRACT_LIST.this.REMOVE_KEY(i); }
@Override
protected final int getMaxPos() { return ABSTRACT_LIST.this.size(); }
};
}
static final class IndexBasedSpliterator KEY_GENERIC extends SPLITERATORS.LateBindingSizeIndexBasedSpliterator KEY_GENERIC {
final LIST KEY_GENERIC l;
IndexBasedSpliterator(LIST KEY_GENERIC l, int pos) {
super(pos);
this.l = l;
}
IndexBasedSpliterator(LIST KEY_GENERIC l, int pos, int maxPos) {
super(pos, maxPos);
this.l = l;
}
@Override
protected final int getMaxPosFromBackingStore() { return l.size(); }
@Override
protected final KEY_GENERIC_TYPE get(int i) { return l.GET_KEY(i); }
@Override
protected final IndexBasedSpliterator KEY_GENERIC makeForSplit(int pos, int maxPos) {
return new IndexBasedSpliterator KEY_GENERIC_DIAMOND(l, pos, maxPos);
}
}
/** Returns true if this list contains the specified element.
* @implSpec This implementation delegates to {@code indexOf()}.
* @see List#contains(Object)
*/
@Override
public boolean contains(final KEY_TYPE k) {
return indexOf(k) >= 0;
}
@Override
public int indexOf(final KEY_TYPE k) {
final KEY_LIST_ITERATOR KEY_GENERIC i = listIterator();
KEY_GENERIC_TYPE e;
while(i.hasNext()) {
e = i.NEXT_KEY();
if (KEY_EQUALS(k, e)) return i.previousIndex();
}
return -1;
}
@Override
public int lastIndexOf(final KEY_TYPE k) {
KEY_LIST_ITERATOR KEY_GENERIC i = listIterator(size());
KEY_GENERIC_TYPE e;
while(i.hasPrevious()) {
e = i.PREV_KEY();
if (KEY_EQUALS(k, e)) return i.nextIndex();
}
return -1;
}
@Override
public void size(final int size) {
int i = size();
if (size > i) while(i++ < size) add(KEY_NULL);
else while(i-- != size) REMOVE_KEY(i);
}
@Override
public LIST KEY_GENERIC subList(final int from, final int to) {
ensureIndex(from);
ensureIndex(to);
if (from > to) throw new IndexOutOfBoundsException("Start index (" + from + ") is greater than end index (" + to + ")");
return this instanceof java.util.RandomAccess ? new SUBLIST_RANDOM_ACCESS KEY_GENERIC_DIAMOND(this, from, to) : new SUBLIST KEY_GENERIC_DIAMOND(this, from, to);
}
/** {@inheritDoc}
*
* @implSpec If this list is {@link java.util.RandomAccess}, will iterate using a for
* loop and the type-specific {@link List#get(int)} method. Otherwise it will fallback
* to using the iterator based loop implementation from the superinterface.
*/
@Override
public void forEach(final METHOD_ARG_KEY_CONSUMER action) {
if (this instanceof java.util.RandomAccess) {
for (int i = 0, max = size(); i < max; ++i) {
action.accept(GET_KEY(i));
}
} else {
LIST.super.forEach(action);
}
}
/** {@inheritDoc}
*
*
This is a trivial iterator-based based implementation. It is expected that
* implementations will override this method with a more optimized version.
*/
@Override
public void removeElements(final int from, final int to) {
ensureIndex(to);
// Always use the iterator based implementation even for RandomAccess so we don't have to worry about shifting indexes.
KEY_LIST_ITERATOR KEY_GENERIC i = listIterator(from);
int n = to - from;
if (n < 0) throw new IllegalArgumentException("Start index (" + from + ") is greater than end index (" + to + ")");
while(n-- != 0) {
i.NEXT_KEY();
i.remove();
}
}
/** {@inheritDoc}
*
*
This is a trivial iterator-based implementation. It is expected that
* implementations will override this method with a more optimized version.
*/
@Override
public void addElements(int index, final KEY_GENERIC_TYPE a[], int offset, int length) {
ensureIndex(index);
ARRAYS.ensureOffsetLength(a, offset, length);
if (this instanceof java.util.RandomAccess) {
while(length-- != 0) add(index++, a[offset++]);
} else {
KEY_LIST_ITERATOR KEY_GENERIC iter = listIterator(index);
while(length-- != 0) iter.add(a[offset++]);
}
}
/** {@inheritDoc}
*
* @implSpec This implementation delegates to the analogous method for array fragments.
*/
@Override
public void addElements(final int index, final KEY_GENERIC_TYPE a[]) {
addElements(index, a, 0, a.length);
}
/** {@inheritDoc}
*
*
This is a trivial iterator-based implementation. It is expected that
* implementations will override this method with a more optimized version.
*/
@Override
public void getElements(final int from, final KEY_TYPE a[], int offset, int length) {
ensureIndex(from);
ARRAYS.ensureOffsetLength(a, offset, length);
if (from + length > size()) throw new IndexOutOfBoundsException("End index (" + (from + length) + ") is greater than list size (" + size() + ")");
if (this instanceof java.util.RandomAccess) {
int current = from;
while(length-- != 0) a[offset++] = GET_KEY(current++);
} else {
KEY_LIST_ITERATOR KEY_GENERIC i = listIterator(from);
while(length-- != 0) a[offset++] = i.NEXT_KEY();
}
}
@Override
public void setElements(int index, KEY_GENERIC_TYPE a[], int offset, int length) {
ensureIndex(index);
ARRAYS.ensureOffsetLength(a, offset, length);
if (index + length > size()) throw new IndexOutOfBoundsException("End index (" + (index + length) + ") is greater than list size (" + size() + ")");
if (this instanceof java.util.RandomAccess) {
for (int i = 0; i < length; ++i) {
set(i + index, a[i + offset]);
}
} else {
KEY_LIST_ITERATOR KEY_GENERIC iter = listIterator(index);
int i = 0;
while (i < length) {
iter.NEXT_KEY();
iter.set(a[offset + i++]);
}
}
}
/** {@inheritDoc}
* @implSpec This implementation delegates to {@link #removeElements(int, int)}.*/
@Override
public void clear() {
removeElements(0, size());
}
#if KEYS_REFERENCE
@Override
public Object[] toArray() {
final int size = size();
Object[] ret = new Object[size];
getElements(0, ret, 0, size);
return ret;
}
@Override
public T[] toArray(T[] a) {
final int size = size();
if (a.length < size) a = java.util.Arrays.copyOf(a, size);
getElements(0, a, 0, size);
if (a.length > size) a[size] = null;
return a;
}
#endif
/** Returns the hash code for this list, which is identical to {@link java.util.List#hashCode()}.
*
* @return the hash code for this list.
*/
@Override
public int hashCode() {
KEY_ITERATOR KEY_GENERIC i = iterator();
int h = 1, s = size();
while (s-- != 0) {
KEY_GENERIC_TYPE k = i.NEXT_KEY();
h = 31 * h + KEY2JAVAHASH(k);
}
return h;
}
@Override
public boolean equals(final Object o) {
if (o == this) return true;
if (! (o instanceof List)) return false;
final List l = (List)o;
int s = size();
if (s != l.size()) return false;
#if KEYS_PRIMITIVE
if (l instanceof LIST) {
final KEY_LIST_ITERATOR KEY_GENERIC i1 = listIterator(), i2 = ((LIST KEY_GENERIC)l).listIterator();
while(s-- != 0) if (i1.NEXT_KEY() != i2.NEXT_KEY()) return false;
return true;
}
#endif
final ListIterator i1 = listIterator(), i2 = l.listIterator();
#if KEYS_USE_REFERENCE_EQUALITY
while(s-- != 0) if (i1.next() != i2.next()) return false;
#else
while(s-- != 0) if (! java.util.Objects.equals(i1.next(), i2.next())) return false;
#endif
return true;
}
#if ! KEYS_USE_REFERENCE_EQUALITY
/** Compares this list to another object. If the
* argument is a {@link java.util.List}, this method performs a lexicographical comparison; otherwise,
* it throws a {@code ClassCastException}.
*
* @param l a list.
* @return if the argument is a {@link java.util.List}, a negative integer,
* zero, or a positive integer as this list is lexicographically less than, equal
* to, or greater than the argument.
* @throws ClassCastException if the argument is not a list.
*/
SUPPRESS_WARNINGS_KEY_UNCHECKED
@Override
public int compareTo(final List l) {
if (l == this) return 0;
if (l instanceof LIST) {
final KEY_LIST_ITERATOR KEY_GENERIC i1 = listIterator(), i2 = ((LIST KEY_GENERIC)l).listIterator();
int r;
KEY_GENERIC_TYPE e1, e2;
while(i1.hasNext() && i2.hasNext()) {
e1 = i1.NEXT_KEY();
e2 = i2.NEXT_KEY();
if ((r = KEY_CMP(e1, e2)) != 0) return r;
}
return i2.hasNext() ? -1 : (i1.hasNext() ? 1 : 0);
}
ListIterator i1 = listIterator(), i2 = l.listIterator();
int r;
while(i1.hasNext() && i2.hasNext()) {
if ((r = ((Comparable)i1.next()).compareTo(i2.next())) != 0) return r;
}
return i2.hasNext() ? -1 : (i1.hasNext() ? 1 : 0);
}
#endif
@Override
public void push(final KEY_GENERIC_TYPE o) {
add(o);
}
@Override
public KEY_GENERIC_TYPE POP() {
if (isEmpty()) throw new NoSuchElementException();
return REMOVE_KEY(size() - 1);
}
@Override
public KEY_GENERIC_TYPE TOP() {
if (isEmpty()) throw new NoSuchElementException();
return GET_KEY(size() - 1);
}
@Override
public KEY_GENERIC_TYPE PEEK(final int i) {
return GET_KEY(size() - 1 - i);
}
#if KEYS_PRIMITIVE
/** Removes a single instance of the specified element from this collection, if it is present (optional operation).
* @implSpec This implementation delegates to {@code indexOf()}.
* @see List#remove(Object)
*/
@Override
public boolean rem(final KEY_TYPE k) {
int index = indexOf(k);
if (index == -1) return false;
REMOVE_KEY(index);
return true;
}
@Override
public KEY_TYPE[] TO_KEY_ARRAY() {
final int size = size();
KEY_TYPE[] ret = new KEY_TYPE[size];
getElements(0, ret, 0, size);
return ret;
}
@Override
public KEY_TYPE[] toArray(KEY_TYPE a[]) {
final int size = size();
if (a.length < size) {
a = java.util.Arrays.copyOf(a, size);
}
getElements(0, a, 0, size);
return a;
}
@Override
public boolean addAll(int index, final COLLECTION c) {
ensureIndex(index);
final KEY_ITERATOR i = c.iterator();
final boolean retVal = i.hasNext();
while(i.hasNext()) add(index++, i.NEXT_KEY());
return retVal;
}
/** {@inheritDoc}
*
* @implSpec This implementation delegates to the type-specific version of {@link List#addAll(int, Collection)}.
*/
@Override
public boolean addAll(final COLLECTION c) {
return addAll(size(), c);
}
#if KEYS_INT_LONG_DOUBLE
/** {@inheritDoc}
* @implSpec This method just delegates to the interface default method,
* as the default method, but it is final, so it cannot be overridden.
*/
@Override
public final void replaceAll(final KEY_UNARY_OPERATOR operator) {
replaceAll((JDK_PRIMITIVE_UNARY_OPERATOR) operator);
}
#endif
#endif
@Override
public String toString() {
final StringBuilder s = new StringBuilder();
final KEY_ITERATOR KEY_GENERIC i = iterator();
int n = size();
KEY_GENERIC_TYPE k;
boolean first = true;
s.append("[");
while(n-- != 0) {
if (first) first = false;
else s.append(", ");
k = i.NEXT_KEY();
#if KEYS_REFERENCE
if (this == k) s.append("(this list)"); else
#endif
s.append(String.valueOf(k));
}
s.append("]");
return s.toString();
}
/** A class implementing a sublist view. */
public static class SUBLIST KEY_GENERIC extends ABSTRACT_LIST KEY_GENERIC implements java.io.Serializable {
private static final long serialVersionUID = -7046029254386353129L;
/** The list this sublist restricts. */
protected final LIST KEY_GENERIC l;
/** Initial (inclusive) index of this sublist. */
protected final int from;
/** Final (exclusive) index of this sublist. */
protected int to;
public SUBLIST(final LIST KEY_GENERIC l, final int from, final int to) {
this.l = l;
this.from = from;
this.to = to;
}
private boolean assertRange() {
assert from <= l.size();
assert to <= l.size();
assert to >= from;
return true;
}
@Override
public boolean add(final KEY_GENERIC_TYPE k) {
l.add(to, k);
to++;
assert assertRange();
return true;
}
@Override
public void add(final int index, final KEY_GENERIC_TYPE k) {
ensureIndex(index);
l.add(from + index, k);
to++;
assert assertRange();
}
@Override
public boolean addAll(final int index, final Collection c) {
ensureIndex(index);
to += c.size();
return l.addAll(from + index, c);
}
@Override
public KEY_GENERIC_TYPE GET_KEY(final int index) {
ensureRestrictedIndex(index);
return l.GET_KEY(from + index);
}
@Override
public KEY_GENERIC_TYPE REMOVE_KEY(final int index) {
ensureRestrictedIndex(index);
to--;
return l.REMOVE_KEY(from + index);
}
@Override
public KEY_GENERIC_TYPE set(final int index, final KEY_GENERIC_TYPE k) {
ensureRestrictedIndex(index);
return l.set(from + index, k);
}
@Override
public int size() {
return to - from;
}
@Override
public void getElements(final int from, final KEY_TYPE[] a, final int offset, final int length) {
ensureIndex(from);
if (from + length > size()) throw new IndexOutOfBoundsException("End index (" + from + length + ") is greater than list size (" + size() + ")");
l.getElements(this.from + from, a, offset, length);
}
@Override
public void removeElements(final int from, final int to) {
ensureIndex(from);
ensureIndex(to);
l.removeElements(this.from + from, this.from + to);
this.to -= (to - from);
assert assertRange();
}
@Override
public void addElements(int index, final KEY_GENERIC_TYPE a[], int offset, int length) {
ensureIndex(index);
l.addElements(this.from + index, a, offset, length);
this.to += length;
assert assertRange();
}
@Override
public void setElements(int index, final KEY_GENERIC_TYPE a[], int offset, int length) {
ensureIndex(index);
l.setElements(this.from + index, a, offset, length);
assert assertRange();
}
private final class RandomAccessIter extends ITERATORS.AbstractIndexBasedListIterator KEY_GENERIC {
// We don't set the minPos to be "from" because we need to call our containing class'
// add, set, and remove methods with 0 relative to the start of the sublist, not the
// start of the original list.
// Thus pos is relative to the start of the SubList, not the start of the original list.
RandomAccessIter(int pos) {
super(0, pos);
}
@Override
protected final KEY_GENERIC_TYPE get(int i) { return l.GET_KEY(from + i); }
// Remember, these are calling SUBLIST's methods, meaning 0 is the start of the sublist for these.
@Override
protected final void add(int i, KEY_GENERIC_TYPE k) { SUBLIST.this.add(i, k); }
@Override
protected final void set(int i, KEY_GENERIC_TYPE k) { SUBLIST.this.set(i, k); }
@Override
protected final void remove(int i) { SUBLIST.this.REMOVE_KEY(i); }
@Override
protected final int getMaxPos() { return to - from; }
@Override
public void add(KEY_GENERIC_TYPE k) {
super.add(k);
assert assertRange();
}
@Override
public void remove() {
super.remove();
assert assertRange();
}
}
private class ParentWrappingIter implements KEY_LIST_ITERATOR KEY_GENERIC {
private KEY_LIST_ITERATOR KEY_GENERIC parent;
ParentWrappingIter(KEY_LIST_ITERATOR KEY_GENERIC parent) {
this.parent = parent;
}
@Override
public int nextIndex() { return parent.nextIndex() - from; }
@Override
public int previousIndex() { return parent.previousIndex() - from; }
@Override
public boolean hasNext() { return parent.nextIndex() < to; }
@Override
public boolean hasPrevious() { return parent.previousIndex() >= from; }
@Override
public KEY_GENERIC_TYPE NEXT_KEY() { if (! hasNext()) throw new NoSuchElementException(); return parent.NEXT_KEY(); }
@Override
public KEY_GENERIC_TYPE PREV_KEY() { if (! hasPrevious()) throw new NoSuchElementException(); return parent.PREV_KEY(); }
@Override
public void add(KEY_GENERIC_TYPE k) { parent.add(k); }
@Override
public void set(KEY_GENERIC_TYPE k) { parent.set(k); }
@Override
public void remove() { parent.remove(); }
@Override
public int back(int n) {
if (n < 0) throw new IllegalArgumentException("Argument must be nonnegative: " + n);
int currentPos = parent.previousIndex();
int parentNewPos = currentPos - n;
// Remember, the minimum acceptable previousIndex is not from but (from - 1), since (from - 1)
// means this subList is at the beginning of our sub range.
// Same reason why previousIndex()'s minimum for the full list is not 0 but -1.
if (parentNewPos < (from - 1)) parentNewPos = (from - 1);
int toSkip = parentNewPos - currentPos;
return parent.back(toSkip);
}
@Override
public int skip(int n) {
if (n < 0) throw new IllegalArgumentException("Argument must be nonnegative: " + n);
int currentPos = parent.nextIndex();
int parentNewPos = currentPos + n;
if (parentNewPos > to) parentNewPos = to;
int toSkip = parentNewPos - currentPos;
return parent.skip(toSkip);
}
}
@Override
public KEY_LIST_ITERATOR KEY_GENERIC listIterator(final int index) {
ensureIndex(index);
// If this class wasn't public, then RandomAccessIter would live in SUBLISTRandomAccess,
// and the switching would be done in sublist(int, int). However, this is a public class
// that may have existing implementors, so to get the benefit of RandomAccessIter class for
// for existing uses, it has to be done in this class.
return l instanceof java.util.RandomAccess ? new RandomAccessIter(index) : new ParentWrappingIter(l.listIterator(index + from));
}
@Override
public KEY_SPLITERATOR KEY_GENERIC spliterator() {
return l instanceof java.util.RandomAccess ? new IndexBasedSpliterator KEY_GENERIC_DIAMOND(l, from, to) : super.spliterator();
}
@Override
public LIST KEY_GENERIC subList(final int from, final int to) {
ensureIndex(from);
ensureIndex(to);
if (from > to) throw new IllegalArgumentException("Start index (" + from + ") is greater than end index (" + to + ")");
// Sadly we have to rewrap this, because if there is a sublist of a sublist, and the
// subsublist adds, both sublists need to update their "to" value.
return new SUBLIST KEY_GENERIC_DIAMOND(this, from, to);
}
#if KEYS_PRIMITIVE
@Override
public boolean rem(final KEY_TYPE k) {
int index = indexOf(k);
if (index == -1) return false;
to--;
l.REMOVE_KEY(from + index);
assert assertRange();
return true;
}
@Override
public boolean addAll(final int index, final COLLECTION c) {
ensureIndex(index);
return super.addAll(index, c);
}
@Override
public boolean addAll(final int index, final LIST l) {
ensureIndex(index);
return super.addAll(index, l);
}
#endif
}
public static class SUBLIST_RANDOM_ACCESS KEY_GENERIC extends SUBLIST KEY_GENERIC implements java.util.RandomAccess {
private static final long serialVersionUID = -107070782945191929L;
public SUBLIST_RANDOM_ACCESS(final LIST KEY_GENERIC l, final int from, final int to) {
super(l, from, to);
}
@Override
public LIST KEY_GENERIC subList(final int from, final int to) {
ensureIndex(from);
ensureIndex(to);
if (from > to) throw new IllegalArgumentException("Start index (" + from + ") is greater than end index (" + to + ")");
// Sadly we have to rewrap this, because if there is a sublist of a sublist, and the
// subsublist adds, both sublists need to update their "to" value.
return new SUBLIST_RANDOM_ACCESS KEY_GENERIC_DIAMOND(this, from, to);
}
}
}