drv.AbstractBigList.drv Maven / Gradle / Ivy
Show all versions of fastutil Show documentation
/*
* Copyright (C) 2010-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;
#if KEYS_REFERENCE
import it.unimi.dsi.fastutil.Stack;
#endif
import java.util.Iterator;
import java.util.Collection;
import java.util.NoSuchElementException;
import it.unimi.dsi.fastutil.BigList;
import it.unimi.dsi.fastutil.BigListIterator;
/** An abstract class providing basic methods for big lists implementing a type-specific big list interface. */
public abstract class ABSTRACT_BIG_LIST KEY_GENERIC extends ABSTRACT_COLLECTION KEY_GENERIC implements BIG_LIST KEY_GENERIC, STACK KEY_GENERIC {
protected ABSTRACT_BIG_LIST() {}
/** Ensures that the given index is nonnegative and not greater than this big-list size.
*
* @param index an index.
* @throws IndexOutOfBoundsException if the given index is negative or greater than this big-list size.
*/
protected void ensureIndex(final long index) {
if (index < 0) throw new IndexOutOfBoundsException("Index (" + index + ") is negative");
if (index > size64()) throw new IndexOutOfBoundsException("Index (" + index + ") is greater than list size (" + (size64()) + ")");
}
/** Ensures that the given index is nonnegative and smaller than this big-list size.
*
* @param index an index.
* @throws IndexOutOfBoundsException if the given index is negative or not smaller than this big-list size.
*/
protected void ensureRestrictedIndex(final long index) {
if (index < 0) throw new IndexOutOfBoundsException("Index (" + index + ") is negative");
if (index >= size64()) throw new IndexOutOfBoundsException("Index (" + index + ") is greater than or equal to list size (" + (size64()) + ")");
}
/** {@inheritDoc}
*
* This implementation always throws an {@link UnsupportedOperationException}.
*/
@Override
public void add(final long index, final KEY_GENERIC_TYPE k) {
throw new UnsupportedOperationException();
}
/** {@inheritDoc}
*
*
This implementation delegates to the type-specific version of {@link BigList#add(long, Object)}.
*/
@Override
public boolean add(final KEY_GENERIC_TYPE k) {
add(size64(), k);
return true;
}
/** {@inheritDoc}
*
*
This implementation always throws an {@link UnsupportedOperationException}.
*/
@Override
public KEY_GENERIC_TYPE REMOVE_KEY(long i) {
throw new UnsupportedOperationException();
}
/** {@inheritDoc}
*
*
This implementation always throws an {@link UnsupportedOperationException}.
*/
@Override
public KEY_GENERIC_TYPE set(final long 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(long index, final Collection c) {
ensureIndex(index);
final Iterator i = c.iterator();
final boolean retVal = i.hasNext();
while(i.hasNext()) add(index++, i.next());
return retVal;
}
/** {@inheritDoc}
*
*
This implementation delegates to the type-specific version of {@link BigList#addAll(long, Collection)}.
*/
@Override
public boolean addAll(final Collection c) {
return addAll(size64(), c);
}
/** {@inheritDoc}
*
*
This implementation delegates to {@link #listIterator()}.
*/
@Override
public KEY_BIG_LIST_ITERATOR KEY_GENERIC iterator() {
return listIterator();
}
/** {@inheritDoc}
*
*
This implementation delegates to {@link BigList#listIterator(long) listIterator(0)}.
*/
@Override
public KEY_BIG_LIST_ITERATOR KEY_GENERIC listIterator() {
return listIterator(0L);
}
/** {@inheritDoc}
*
This implementation is based on the random-access methods. */
@Override
public KEY_BIG_LIST_ITERATOR KEY_GENERIC listIterator(final long index) {
ensureIndex(index);
return new KEY_BIG_LIST_ITERATOR KEY_GENERIC() {
long pos = index, last = -1;
@Override
public boolean hasNext() { return pos < ABSTRACT_BIG_LIST.this.size64(); }
@Override
public boolean hasPrevious() { return pos > 0; }
@Override
public KEY_GENERIC_TYPE NEXT_KEY() { if (! hasNext()) throw new NoSuchElementException(); return ABSTRACT_BIG_LIST.this.GET_KEY(last = pos++); }
@Override
public KEY_GENERIC_TYPE PREV_KEY() { if (! hasPrevious()) throw new NoSuchElementException(); return ABSTRACT_BIG_LIST.this.GET_KEY(last = --pos); }
@Override
public long nextIndex() { return pos; }
@Override
public long previousIndex() { return pos - 1; }
@Override
public void add(KEY_GENERIC_TYPE k) {
ABSTRACT_BIG_LIST.this.add(pos++, k);
last = -1;
}
@Override
public void set(KEY_GENERIC_TYPE k) {
if (last == -1) throw new IllegalStateException();
ABSTRACT_BIG_LIST.this.set(last, k);
}
@Override
public void remove() {
if (last == -1) throw new IllegalStateException();
ABSTRACT_BIG_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;
}
};
}
/** Returns true if this list contains the specified element.
*
This implementation delegates to {@code indexOf()}.
* @see BigList#contains(Object)
*/
@Override
public boolean contains(final KEY_TYPE k) { return indexOf(k) >= 0; }
@Override
public long indexOf(final KEY_TYPE k) {
final KEY_BIG_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 long lastIndexOf(final KEY_TYPE k) {
KEY_BIG_LIST_ITERATOR KEY_GENERIC i = listIterator(size64());
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 long size) {
long i = size64();
if (size > i) while(i++ < size) add(KEY_NULL);
else while(i-- != size) remove(i);
}
@Override
public BIG_LIST KEY_GENERIC subList(final long from, final long to) {
ensureIndex(from);
ensureIndex(to);
if (from > to) throw new IndexOutOfBoundsException("Start index (" + from + ") is greater than end index (" + to + ")");
return new SUBLIST KEY_GENERIC_DIAMOND(this, from, to);
}
/** {@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 removeElements(final long from, final long to) {
ensureIndex(to);
KEY_BIG_LIST_ITERATOR KEY_GENERIC i = listIterator(from);
long 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(long index, final KEY_GENERIC_TYPE a[][], long offset, long length) {
ensureIndex(index);
BIG_ARRAYS.ensureOffsetLength(a, offset, length);
while(length-- != 0) add(index++, BIG_ARRAYS.get(a, offset++));
}
/** {@inheritDoc}
*
*
This implementation delegates to the analogous method for big-array fragments.
*/
@Override
public void addElements(final long index, final KEY_GENERIC_TYPE a[][]) {
addElements(index, a, 0, BIG_ARRAYS.length(a));
}
/** {@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 long from, final KEY_TYPE a[][], long offset, long length) {
KEY_BIG_LIST_ITERATOR KEY_GENERIC i = listIterator(from);
BIG_ARRAYS.ensureOffsetLength(a, offset, length);
if (from + length > size64()) throw new IndexOutOfBoundsException("End index (" + (from + length) + ") is greater than list size (" + size64() + ")");
while(length-- != 0) BIG_ARRAYS.set(a, offset++, i.NEXT_KEY());
}
/** {@inheritDoc}
*
This implementation delegates to {@link #removeElements(long, long)}.*/
@Override
public void clear() {
removeElements(0, size64());
}
/** {@inheritDoc}
*
*
This implementation delegates to {@link #size64()}.
* @deprecated Please use {@link #size64()} instead. */
@Override
@Deprecated
public int size() {
return (int)Math.min(Integer.MAX_VALUE, size64());
}
#if ! KEY_CLASS_Reference
private boolean valEquals(final Object a, final Object b) { return a == null ? b == null : a.equals(b); }
#endif
/** Returns the hash code for this big list, which is identical to {@link java.util.List#hashCode()}.
*
* @return the hash code for this big list.
*/
@Override
public int hashCode() {
KEY_ITERATOR KEY_GENERIC i = iterator();
int h = 1;
long s = size64();
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 BigList)) return false;
final BigList l = (BigList)o;
long s = size64();
if (s != l.size64()) return false;
#if KEYS_PRIMITIVE
if (l instanceof BIG_LIST) {
final KEY_BIG_LIST_ITERATOR KEY_GENERIC i1 = listIterator(), i2 = ((BIG_LIST KEY_GENERIC)l).listIterator();
while(s-- != 0) if (i1.NEXT_KEY() != i2.NEXT_KEY()) return false;
return true;
}
#endif
final BigListIterator i1 = listIterator(), i2 = l.listIterator();
#if KEY_CLASS_Reference
while(s-- != 0) if (i1.next() != i2.next()) return false;
#else
while(s-- != 0) if (! valEquals(i1.next(), i2.next())) return false;
#endif
return true;
}
#if ! KEY_CLASS_Reference
/** Compares this big list to another object. If the
* argument is a {@link BigList}, this method performs a lexicographical comparison; otherwise,
* it throws a {@code ClassCastException}.
*
* @param l a big list.
* @return if the argument is a {@link BigList}, 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 big list.
*/
SUPPRESS_WARNINGS_KEY_UNCHECKED
@Override
public int compareTo(final BigList l) {
if (l == this) return 0;
if (l instanceof BIG_LIST) {
final KEY_BIG_LIST_ITERATOR KEY_GENERIC i1 = listIterator(), i2 = ((BIG_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);
}
BigListIterator 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(KEY_GENERIC_TYPE o) {
add(o);
}
@Override
public KEY_GENERIC_TYPE POP() {
if (isEmpty()) throw new NoSuchElementException();
return REMOVE_KEY(size64() - 1);
}
@Override
public KEY_GENERIC_TYPE TOP() {
if (isEmpty()) throw new NoSuchElementException();
return GET_KEY(size64() - 1);
}
@Override
public KEY_GENERIC_TYPE PEEK(int i) {
return GET_KEY(size64() - 1 - i);
}
#if KEYS_PRIMITIVE
/** Removes a single instance of the specified element from this collection, if it is present (optional operation).
*
This implementation delegates to {@code indexOf()}.
* @see BigList#remove(Object)
*/
@Override
public boolean rem(KEY_TYPE k) {
long index = indexOf(k);
if (index == -1) return false;
REMOVE_KEY(index);
return true;
}
/** {@inheritDoc}
*
*
This implementation delegates to the type-specific version of {@link #addAll(long, Collection)}.
*/
@Override
public boolean addAll(final long index, final COLLECTION c) { return addAll(index, (Collection)c); }
/** {@inheritDoc}
*
*
This implementation delegates to the type-specific version of {@link #addAll(long, Collection)}.
*/
@Override
public boolean addAll(final long index, final BIG_LIST l) { return addAll(index, (COLLECTION)l); }
/** {@inheritDoc}
*
*
This implementation delegates to the type-specific version of {@link #addAll(long, Collection)}.
*/
@Override
public boolean addAll(final COLLECTION c) { return addAll(size64(), c); }
/** {@inheritDoc}
*
*
This implementation delegates to the type-specific list version of {@link #addAll(long, Collection)}.
*/
@Override
public boolean addAll(final BIG_LIST l) { return addAll(size64(), l); }
/** {@inheritDoc}
*
*
This implementation delegates to the corresponding type-specific method.
* @deprecated Please use the corresponding type-specific method instead.
*/
@Deprecated
@Override
public void add(final long index, final KEY_CLASS ok) { add(index, ok.KEY_VALUE()); }
/** {@inheritDoc}
*
*
This implementation delegates to the corresponding type-specific method.
* @deprecated Please use the corresponding type-specific method instead.
*/
@Deprecated
@Override
public KEY_CLASS set(final long index, final KEY_CLASS ok) { return KEY2OBJ(set(index, ok.KEY_VALUE())); }
/** {@inheritDoc}
*
*
This implementation delegates to the corresponding type-specific method.
* @deprecated Please use the corresponding type-specific method instead.
*/
@Deprecated
@Override
public KEY_CLASS get(final long index) { return KEY2OBJ(GET_KEY(index)); }
/** {@inheritDoc}
*
*
This implementation delegates to the corresponding type-specific method.
* @deprecated Please use the corresponding type-specific method instead.
*/
@Deprecated
@Override
public long indexOf(final Object ok) { return indexOf(KEY_OBJ2TYPE(ok)); }
/** {@inheritDoc}
*
*
This implementation delegates to the corresponding type-specific method.
* @deprecated Please use the corresponding type-specific method instead.
*/
@Deprecated
@Override
public long lastIndexOf(final Object ok) { return lastIndexOf(KEY_OBJ2TYPE(ok)); }
/** {@inheritDoc}
*
*
This implementation delegates to the corresponding type-specific method.
* @deprecated Please use the corresponding type-specific method instead.
*/
@Deprecated
@Override
public KEY_CLASS remove(final long index) { return KEY2OBJ(REMOVE_KEY(index)); }
/** {@inheritDoc}
*
*
This implementation delegates to the corresponding type-specific method.
* @deprecated Please use the corresponding type-specific method instead.
*/
@Deprecated
@Override
public void push(KEY_CLASS o) { push(o.KEY_VALUE()); }
/** {@inheritDoc}
*
*
This implementation delegates to the corresponding type-specific method.
* @deprecated Please use the corresponding type-specific method instead.
*/
@Deprecated
@Override
public KEY_CLASS pop() { return KEY_CLASS.valueOf(POP()); }
/** {@inheritDoc}
*
*
This implementation delegates to the corresponding type-specific method.
* @deprecated Please use the corresponding type-specific method instead.
*/
@Deprecated
@Override
public KEY_CLASS top() { return KEY_CLASS.valueOf(TOP()); }
/** {@inheritDoc}
*
*
This implementation delegates to the corresponding type-specific method.
* @deprecated Please use the corresponding type-specific method instead.
*/
@Deprecated
@Override
public KEY_CLASS peek(int i) { return KEY_CLASS.valueOf(PEEK(i)); }
#endif
@Override
public String toString() {
final StringBuilder s = new StringBuilder();
final KEY_ITERATOR KEY_GENERIC i = iterator();
long n = size64();
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 big 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_BIG_LIST KEY_GENERIC implements java.io.Serializable {
private static final long serialVersionUID = -7046029254386353129L;
/** The list this sublist restricts. */
protected final BIG_LIST KEY_GENERIC l;
/** Initial (inclusive) index of this sublist. */
protected final long from;
/** Final (exclusive) index of this sublist. */
protected long to;
public SUBLIST(final BIG_LIST KEY_GENERIC l, final long from, final long to) {
this.l = l;
this.from = from;
this.to = to;
}
private boolean assertRange() {
assert from <= l.size64();
assert to <= l.size64();
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 long index, final KEY_GENERIC_TYPE k) {
ensureIndex(index);
l.add(from + index, k);
to++;
assert assertRange();
}
@Override
public boolean addAll(final long index, final Collection c) {
ensureIndex(index);
to += c.size();
return l.addAll(from + index, c);
}
@Override
public KEY_GENERIC_TYPE GET_KEY(long index) {
ensureRestrictedIndex(index);
return l.GET_KEY(from + index);
}
@Override
public KEY_GENERIC_TYPE REMOVE_KEY(long index) {
ensureRestrictedIndex(index);
to--;
return l.REMOVE_KEY(from + index);
}
@Override
public KEY_GENERIC_TYPE set(long index, KEY_GENERIC_TYPE k) {
ensureRestrictedIndex(index);
return l.set(from + index, k);
}
@Override
public long size64() { return to - from; }
@Override
public void getElements(final long from, final KEY_TYPE[][] a, final long offset, final long length) {
ensureIndex(from);
if (from + length > size64()) throw new IndexOutOfBoundsException("End index (" + from + length + ") is greater than list size (" + size64() + ")");
l.getElements(this.from + from, a, offset, length);
}
@Override
public void removeElements(final long from, final long to) {
ensureIndex(from);
ensureIndex(to);
l.removeElements(this.from + from, this.from + to);
this.to -= (to - from);
assert assertRange();
}
@Override
public void addElements(final long index, final KEY_GENERIC_TYPE a[][], long offset, long length) {
ensureIndex(index);
l.addElements(this.from + index, a, offset, length);
this.to += length;
assert assertRange();
}
@Override
public KEY_BIG_LIST_ITERATOR KEY_GENERIC listIterator(final long index) {
ensureIndex(index);
return new KEY_BIG_LIST_ITERATOR KEY_GENERIC() {
long pos = index, last = -1;
@Override
public boolean hasNext() { return pos < size64(); }
@Override
public boolean hasPrevious() { return pos > 0; }
@Override
public KEY_GENERIC_TYPE NEXT_KEY() { if (! hasNext()) throw new NoSuchElementException(); return l.GET_KEY(from + (last = pos++)); }
@Override
public KEY_GENERIC_TYPE PREV_KEY() { if (! hasPrevious()) throw new NoSuchElementException(); return l.GET_KEY(from + (last = --pos)); }
@Override
public long nextIndex() { return pos; }
@Override
public long previousIndex() { return pos - 1; }
@Override
public void add(KEY_GENERIC_TYPE k) {
if (last == -1) throw new IllegalStateException();
SUBLIST.this.add(pos++, k);
last = -1;
assert assertRange();
}
@Override
public void set(KEY_GENERIC_TYPE k) {
if (last == -1) throw new IllegalStateException();
SUBLIST.this.set(last, k);
}
@Override
public void remove() {
if (last == -1) throw new IllegalStateException();
SUBLIST.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;
assert assertRange();
}
};
}
@Override
public BIG_LIST KEY_GENERIC subList(final long from, final long to) {
ensureIndex(from);
ensureIndex(to);
if (from > to) throw new IllegalArgumentException("Start index (" + from + ") is greater than end index (" + to + ")");
return new SUBLIST KEY_GENERIC_DIAMOND(this, from, to);
}
#if KEYS_PRIMITIVE
@Override
public boolean rem(KEY_TYPE k) {
long index = indexOf(k);
if (index == -1) return false;
to--;
l.REMOVE_KEY(from + index);
assert assertRange();
return true;
}
@Override
public boolean addAll(final long index, final COLLECTION c) {
ensureIndex(index);
return super.addAll(index, c);
}
@Override
public boolean addAll(final long index, final BIG_LIST l) {
ensureIndex(index);
return super.addAll(index, l);
}
#endif
}
}