mirror of
https://github.com/SlimeVR/SlimeVR-Server.git
synced 2026-11-20 00:51:20 -08:00
548 lines
12 KiB
Java
548 lines
12 KiB
Java
package io.eiren.util.collections;
|
|
|
|
import java.util.*;
|
|
import java.util.function.Consumer;
|
|
import java.util.function.Predicate;
|
|
import java.util.function.UnaryOperator;
|
|
|
|
|
|
@SuppressWarnings("unchecked")
|
|
public class FastList<E> extends AbstractList<E>
|
|
implements RandomAccess, Cloneable, RemoveAtSwapList<E> {
|
|
|
|
private static final Object[] emptyArray = new Object[0];
|
|
|
|
public static final int MAX_ARRAY_SIZE = 2147483639;
|
|
|
|
protected int size = 0;
|
|
protected Object[] array;
|
|
|
|
public FastList(int capacity) {
|
|
array = capacity == 0 ? emptyArray : new Object[capacity];
|
|
}
|
|
|
|
public FastList() {
|
|
this(5);
|
|
}
|
|
|
|
public FastList(Collection<E> source) {
|
|
this(source.size());
|
|
addAll(source);
|
|
}
|
|
|
|
public FastList(FastList<E> source) {
|
|
this(source.size);
|
|
addAllInternal(0, source.array, source.size);
|
|
}
|
|
|
|
public FastList(E[] source) {
|
|
this(source.length);
|
|
addAll(source);
|
|
}
|
|
|
|
public FastList(E source) {
|
|
this();
|
|
add(source);
|
|
}
|
|
|
|
private FastList(Object[] arr, int size) {
|
|
this(size);
|
|
System.arraycopy(arr, 0, array, 0, size);
|
|
this.size = size;
|
|
}
|
|
|
|
private FastList(boolean f) {
|
|
}
|
|
|
|
public static <E> FastList<E> reuseArray(E[] source) {
|
|
FastList<E> list = new FastList<>(true);
|
|
list.array = source;
|
|
list.size = source.length;
|
|
return list;
|
|
}
|
|
|
|
private void checkBounds(int index) {
|
|
if (index < 0 || index >= size)
|
|
throw new ArrayIndexOutOfBoundsException(
|
|
new StringBuilder("Index: ")
|
|
.append(index)
|
|
.append(", size: ")
|
|
.append(size)
|
|
.toString()
|
|
);
|
|
}
|
|
|
|
public void ensureCapacity(int numToFit) {
|
|
if (array.length < size + numToFit)
|
|
grow(numToFit + size);
|
|
}
|
|
|
|
private void grow(int i) {
|
|
int j = array.length;
|
|
int k = j + (j >> 1);
|
|
if (k - i < 0)
|
|
k = i;
|
|
if (k - 2147483639 > 0)
|
|
k = hugeCapacity(i);
|
|
array = Arrays.copyOf(array, k);
|
|
}
|
|
|
|
private static int hugeCapacity(int i) {
|
|
if (i < 0)
|
|
throw new OutOfMemoryError("Huge capacity negative: " + i);
|
|
else
|
|
return i <= MAX_ARRAY_SIZE ? MAX_ARRAY_SIZE : 2147483647;
|
|
}
|
|
|
|
public void copyInto(Object[] anArray) {
|
|
System.arraycopy(array, 0, anArray, 0, size);
|
|
}
|
|
|
|
@Override
|
|
public E get(int index) {
|
|
checkBounds(index);
|
|
return (E) array[index];
|
|
}
|
|
|
|
public E unsafeGet(int index) {
|
|
return (E) array[index];
|
|
}
|
|
|
|
@Override
|
|
public boolean isEmpty() {
|
|
return size == 0;
|
|
}
|
|
|
|
@Override
|
|
public int size() {
|
|
return size;
|
|
}
|
|
|
|
@Override
|
|
public int indexOf(Object obj) {
|
|
for (int j = 0; j < size; j++)
|
|
if (obj == array[j])
|
|
return j;
|
|
return -1;
|
|
}
|
|
|
|
@Override
|
|
public int lastIndexOf(Object obj) {
|
|
for (int j = size - 1; j >= 0; j--)
|
|
if (obj == array[j])
|
|
return j;
|
|
return -1;
|
|
}
|
|
|
|
@Override
|
|
public boolean contains(Object obj) {
|
|
return indexOf(obj) >= 0;
|
|
}
|
|
|
|
public void trimToSize() {
|
|
int i = array.length;
|
|
if (size < i)
|
|
array = Arrays.copyOf(array, size);
|
|
}
|
|
|
|
@Override
|
|
public Object[] toArray() {
|
|
return Arrays.copyOf(array, size);
|
|
}
|
|
|
|
@Override
|
|
public <T> T[] toArray(T aobj[]) {
|
|
if (aobj.length < size)
|
|
return (T[]) Arrays.copyOf(array, size, aobj.getClass());
|
|
System.arraycopy(array, 0, aobj, 0, size);
|
|
if (aobj.length > size)
|
|
aobj[size] = null;
|
|
return aobj;
|
|
}
|
|
|
|
@Override
|
|
public boolean add(E e) {
|
|
ensureCapacity(1);
|
|
array[size++] = e;
|
|
return true;
|
|
}
|
|
|
|
@Override
|
|
public E remove(int i) {
|
|
checkBounds(i);
|
|
E obj = (E) array[i];
|
|
removeInternal(i);
|
|
return obj;
|
|
}
|
|
|
|
@Override
|
|
public boolean remove(Object obj) {
|
|
for (int j = 0; j < size; j++)
|
|
if (obj == array[j]) {
|
|
removeInternal(j);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public boolean removeAll(Object[] toRemove) {
|
|
boolean removed = false;
|
|
for (int i = toRemove.length - 1; i >= 0; --i) {
|
|
int index = indexOf(toRemove[i]);
|
|
if (index != -1) {
|
|
removeInternal(index);
|
|
removed = true;
|
|
}
|
|
}
|
|
return removed;
|
|
}
|
|
|
|
protected void removeInternal(int i) {
|
|
int j = size - i - 1;
|
|
if (j > 0)
|
|
System.arraycopy(array, i + 1, array, i, j);
|
|
array[--size] = null;
|
|
}
|
|
|
|
public void unsafeRemove(int i) {
|
|
removeInternal(i);
|
|
}
|
|
|
|
@Override
|
|
public boolean removeAll(Collection<?> c) {
|
|
Objects.requireNonNull(c);
|
|
return batchRemove(c, false);
|
|
}
|
|
|
|
@Override
|
|
public boolean retainAll(Collection<?> c) {
|
|
Objects.requireNonNull(c);
|
|
return batchRemove(c, true);
|
|
}
|
|
|
|
private boolean batchRemove(Collection<?> c, boolean complement) {
|
|
final Object[] elementData = this.array;
|
|
int r = 0, w = 0;
|
|
boolean modified = false;
|
|
try {
|
|
for (; r < size; r++)
|
|
if (c.contains(elementData[r]) == complement)
|
|
elementData[w++] = elementData[r];
|
|
} finally {
|
|
// Preserve behavioral compatibility with AbstractCollection,
|
|
// even if c.contains() throws.
|
|
if (r != size) {
|
|
System.arraycopy(elementData, r, elementData, w, size - r);
|
|
w += size - r;
|
|
}
|
|
if (w != size) {
|
|
for (int i = w; i < size; i++)
|
|
elementData[i] = null;
|
|
size = w;
|
|
modified = true;
|
|
}
|
|
}
|
|
return modified;
|
|
}
|
|
|
|
@Override
|
|
public void clear() {
|
|
for (int i = 0; i < size; i++)
|
|
array[i] = null;
|
|
size = 0;
|
|
}
|
|
|
|
public void fakeClear() {
|
|
size = 0;
|
|
}
|
|
|
|
@Override
|
|
public boolean addAll(Collection<? extends E> collection) {
|
|
return addAll(size, collection);
|
|
}
|
|
|
|
public void addAll(E[] arr) {
|
|
addAllInternal(size, arr, arr.length);
|
|
}
|
|
|
|
public void addAll(E[] arr, int limit) {
|
|
addAllInternal(size, arr, limit);
|
|
}
|
|
|
|
public void addAll(int index, E[] arr) {
|
|
addAllInternal(index, arr, arr.length);
|
|
}
|
|
|
|
public void addAll(int index, E[] arr, int limit) {
|
|
addAllInternal(index, arr, limit);
|
|
}
|
|
|
|
private void addAllInternal(int index, Object[] arr, int limit) {
|
|
if (limit > arr.length)
|
|
limit = arr.length;
|
|
if (limit == 1) {
|
|
add(index, (E) arr[0]);
|
|
} else if (limit > 0) {
|
|
if (index >= size) {
|
|
ensureCapacity(size - index + limit);
|
|
System.arraycopy(arr, 0, array, index, limit);
|
|
size = index + limit;
|
|
} else {
|
|
if (array.length < size + limit) {
|
|
Object[] newArray = new Object[size + limit];
|
|
System.arraycopy(array, 0, newArray, 0, index);
|
|
System.arraycopy(arr, 0, newArray, index, limit);
|
|
System.arraycopy(array, index, newArray, index + limit, size - index);
|
|
array = newArray;
|
|
} else {
|
|
System.arraycopy(array, index, array, index + 1, size - index);
|
|
System.arraycopy(arr, 0, array, index, limit);
|
|
}
|
|
size += limit;
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public boolean addAll(int index, Collection<? extends E> collection) {
|
|
if (collection.size() > 0) {
|
|
if (collection instanceof FastList) {
|
|
addAllInternal(
|
|
index,
|
|
((FastList<? extends E>) collection).array,
|
|
collection.size()
|
|
);
|
|
} else if (collection instanceof RandomAccess) {
|
|
Object[] arr = collection.toArray(new Object[collection.size()]);
|
|
addAllInternal(index, arr, arr.length);
|
|
} else {
|
|
if (index >= size) {
|
|
ensureCapacity(size - index + collection.size());
|
|
Iterator<? extends E> iterator = collection.iterator();
|
|
int i = index;
|
|
while (iterator.hasNext())
|
|
array[i++] = iterator.next();
|
|
size = index + collection.size();
|
|
} else {
|
|
if (array.length < size + collection.size()) {
|
|
Object[] newArray = new Object[size + collection.size()];
|
|
System.arraycopy(array, 0, newArray, 0, index);
|
|
Iterator<? extends E> iterator = collection.iterator();
|
|
int i = index;
|
|
while (iterator.hasNext())
|
|
newArray[i++] = iterator.next();
|
|
System
|
|
.arraycopy(
|
|
array,
|
|
index,
|
|
newArray,
|
|
index + collection.size(),
|
|
size - index
|
|
);
|
|
array = newArray;
|
|
} else {
|
|
System.arraycopy(array, index, array, index + 1, size - index);
|
|
Iterator<? extends E> iterator = collection.iterator();
|
|
while (iterator.hasNext())
|
|
array[index++] = iterator.next();
|
|
}
|
|
size += collection.size();
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
@Override
|
|
public void add(int index, E element) {
|
|
if (index >= size) {
|
|
ensureCapacity(size - index + 1);
|
|
size = index + 1;
|
|
array[index] = element;
|
|
} else {
|
|
if (array.length < size + 1) {
|
|
Object[] newArray = new Object[size + 1];
|
|
System.arraycopy(array, 0, newArray, 0, index);
|
|
newArray[index] = element;
|
|
System.arraycopy(array, index, newArray, index + 1, size - index);
|
|
array = newArray;
|
|
} else {
|
|
System.arraycopy(array, index, array, index + 1, size - index);
|
|
array[index] = element;
|
|
}
|
|
size++;
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public E set(int index, E element) {
|
|
checkBounds(index);
|
|
E oldValue = (E) array[index];
|
|
array[index] = element;
|
|
return oldValue;
|
|
}
|
|
|
|
@Override
|
|
public FastList<E> clone() {
|
|
return new FastList<E>(array, size);
|
|
}
|
|
|
|
@Override
|
|
public void forEach(Consumer<? super E> action) {
|
|
Objects.requireNonNull(action);
|
|
final int expectedModCount = modCount;
|
|
final E[] elementData = (E[]) this.array;
|
|
final int size = this.size;
|
|
for (int i = 0; modCount == expectedModCount && i < size; i++) {
|
|
action.accept(elementData[i]);
|
|
}
|
|
if (modCount != expectedModCount) {
|
|
throw new ConcurrentModificationException();
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public E removeAtSwap(int i) {
|
|
checkBounds(i);
|
|
E obj = (E) array[i];
|
|
removeAtSwapInternal(i);
|
|
return obj;
|
|
}
|
|
|
|
@Override
|
|
public boolean removeAtSwap(Object obj) {
|
|
for (int j = 0; j < size; j++)
|
|
if (obj == array[j]) {
|
|
removeAtSwapInternal(j);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
protected void removeAtSwapInternal(int i) {
|
|
int j = size - i - 1;
|
|
if (j > 0)
|
|
array[i] = array[size - 1];
|
|
array[--size] = null;
|
|
}
|
|
|
|
@Override
|
|
public void removeRange(int i, int toIndex) {
|
|
checkBounds(i);
|
|
checkBounds(toIndex);
|
|
int j = size - toIndex - 1;
|
|
if (j > 0)
|
|
System.arraycopy(array, toIndex + 1, array, i, j);
|
|
size -= (toIndex - i + 1);
|
|
Arrays.fill(array, i, toIndex, null);
|
|
}
|
|
|
|
@Override
|
|
public void replaceAll(UnaryOperator<E> operator) {
|
|
Objects.requireNonNull(operator);
|
|
for (int i = 0; i < size; ++i)
|
|
set(i, operator.apply(get(i)));
|
|
}
|
|
|
|
@Override
|
|
public void sort(Comparator<? super E> c) {
|
|
Arrays.sort((E[]) array, 0, size, c);
|
|
}
|
|
|
|
@Override
|
|
public int hashCode() {
|
|
int hashCode = 1;
|
|
for (int i = 0; i < size; ++i) {
|
|
Object o = array[i];
|
|
hashCode = 31 * hashCode + (o == null ? 0 : o.hashCode());
|
|
}
|
|
return hashCode;
|
|
}
|
|
|
|
@Override
|
|
public Spliterator<E> spliterator() {
|
|
return Spliterators.spliterator(array, 0, size, Spliterator.ORDERED);
|
|
}
|
|
|
|
/**
|
|
* Special comodification iterator. <b>Use with caution.</b>
|
|
* <p>
|
|
* <i>To get element type correctly assign result to reference type
|
|
* {@code FastList<T>.SkipFastListIterator}</i>
|
|
*
|
|
* @return skip iterator to iterate this list in thread-safe manner
|
|
*/
|
|
public SkipFastListIterator skipIterator() {
|
|
return new SkipFastListIterator();
|
|
}
|
|
|
|
@Override
|
|
public boolean removeIf(Predicate<? super E> filter) {
|
|
Objects.requireNonNull(filter);
|
|
// figure out which elements are to be removed
|
|
// any exception thrown from the filter predicate at this stage
|
|
// will leave the collection unmodified
|
|
int removeCount = 0;
|
|
final BitSet removeSet = new BitSet(size);
|
|
final int expectedModCount = modCount;
|
|
final int size = this.size;
|
|
for (int i = 0; modCount == expectedModCount && i < size; i++) {
|
|
final E element = (E) array[i];
|
|
if (filter.test(element)) {
|
|
removeSet.set(i);
|
|
removeCount++;
|
|
}
|
|
}
|
|
if (modCount != expectedModCount) {
|
|
throw new ConcurrentModificationException();
|
|
}
|
|
|
|
// shift surviving elements left over the spaces left by removed
|
|
// elements
|
|
final boolean anyToRemove = removeCount > 0;
|
|
if (anyToRemove) {
|
|
final int newSize = size - removeCount;
|
|
for (int i = 0, j = 0; (i < size) && (j < newSize); i++, j++) {
|
|
i = removeSet.nextClearBit(i);
|
|
array[j] = array[i];
|
|
}
|
|
for (int k = newSize; k < size; k++) {
|
|
array[k] = null; // Let gc do its work
|
|
}
|
|
this.size = newSize;
|
|
if (modCount != expectedModCount) {
|
|
throw new ConcurrentModificationException();
|
|
}
|
|
modCount++;
|
|
}
|
|
|
|
return anyToRemove;
|
|
}
|
|
|
|
public class SkipFastListIterator implements ResettableIterator<E>, SkipIterator<E> {
|
|
|
|
public int position;
|
|
|
|
@Override
|
|
public boolean hasNext() {
|
|
return position < size;
|
|
}
|
|
|
|
@Override
|
|
public E next() {
|
|
Object[] arr = array;
|
|
if (arr.length > position) {
|
|
return (E) arr[position++];
|
|
}
|
|
position++; // Increase position so hasNext() never loops infinitely
|
|
return null;
|
|
}
|
|
|
|
@Override
|
|
public void reset() {
|
|
position = 0;
|
|
}
|
|
}
|
|
}
|