417 lines
9.3 KiB
Java
417 lines
9.3 KiB
Java
package org.warp.jcwdb;
|
|
|
|
import java.io.IOException;
|
|
import java.util.*;
|
|
import java.util.function.Consumer;
|
|
import java.util.function.Predicate;
|
|
|
|
import it.unimi.dsi.fastutil.longs.LongArrayList;
|
|
import it.unimi.dsi.fastutil.objects.ObjectArrayList;
|
|
|
|
public class LightList<T> implements List<T> {
|
|
|
|
public final LongArrayList internalList;
|
|
private final transient JCWDatabase db;
|
|
|
|
public LightList(JCWDatabase db, LongArrayList internalList) {
|
|
this.internalList = internalList;
|
|
this.db = db;
|
|
}
|
|
|
|
@Override
|
|
public int size() {
|
|
return internalList.size();
|
|
}
|
|
|
|
@Override
|
|
public boolean isEmpty() {
|
|
return internalList.isEmpty();
|
|
}
|
|
|
|
@Override
|
|
public boolean contains(Object o) {
|
|
if (o != null) {
|
|
for (Long element : internalList) {
|
|
EntryReference<T> ref = null;
|
|
try {
|
|
ref = db.get(element);
|
|
if (o.equals(ref.getValueReadOnly())) {
|
|
return true;
|
|
}
|
|
} catch (IOException e) {
|
|
e.printStackTrace();
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Use iteratorReferences()
|
|
*/
|
|
@Deprecated
|
|
@SuppressWarnings("unchecked")
|
|
@Override
|
|
public Iterator<T> iterator() {
|
|
System.out.println("WARNING! YOU ARE USING iterator()! PLEASE USE ITERATORREFERENCES TO AVOID OUTOFMEMORY!");
|
|
final ArrayList<T> elements = new ArrayList<>();
|
|
for (Long element : internalList) {
|
|
try {
|
|
elements.add((T) db.get(element).getValueReadOnly());
|
|
} catch (IOException e) {
|
|
e.printStackTrace();
|
|
}
|
|
}
|
|
return elements.iterator();
|
|
}
|
|
|
|
@SuppressWarnings("unchecked")
|
|
public Iterator<EntryReference<T>> iteratorReferences() {
|
|
final ArrayList<EntryReference<T>> elements = new ArrayList<>();
|
|
for (Long element : internalList) {
|
|
try {
|
|
elements.add(db.get(element));
|
|
} catch (IOException e) {
|
|
e.printStackTrace();
|
|
}
|
|
}
|
|
return elements.iterator();
|
|
}
|
|
|
|
/**
|
|
* USE forEachReference INSTEAD, TO AVOID OUTOFMEMORY
|
|
* @param action
|
|
*/
|
|
@Deprecated
|
|
@Override
|
|
public void forEach(Consumer<? super T> action) {
|
|
Objects.requireNonNull(action);
|
|
for (T t : this) {
|
|
action.accept(t);
|
|
}
|
|
}
|
|
|
|
public void forEachReference(Consumer<? super EntryReference<T>> action) {
|
|
Objects.requireNonNull(action);
|
|
for (long index : this.internalList) {
|
|
try {
|
|
action.accept(db.get(index));
|
|
} catch (IOException e) {
|
|
throw (RuntimeException) new RuntimeException().initCause(e);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
@SuppressWarnings("unchecked")
|
|
@Override
|
|
public T[] toArray() {
|
|
final T[] elements = (T[]) new Objects[internalList.size()];
|
|
for (int i = 0; i < elements.length; i++) {
|
|
try {
|
|
elements[i] = (T) db.get(internalList.getLong(i)).getValueReadOnly();
|
|
} catch (IOException e) {
|
|
e.printStackTrace();
|
|
}
|
|
}
|
|
return elements;
|
|
}
|
|
|
|
@SuppressWarnings("unchecked")
|
|
@Override
|
|
public <T1> T1[] toArray(T1[] a) {
|
|
final T1[] elements = (T1[]) new Objects[internalList.size()];
|
|
for (int i = 0; i < elements.length; i++) {
|
|
try {
|
|
elements[i] = (T1) db.get(internalList.getLong(i)).getValueReadOnly();
|
|
} catch (IOException e) {
|
|
e.printStackTrace();
|
|
}
|
|
}
|
|
return elements;
|
|
}
|
|
|
|
@Override
|
|
public boolean add(T o) {
|
|
EntryReference<T> ref = addEntry(o);
|
|
return ref != null;
|
|
}
|
|
|
|
public EntryReference<T> addEntry(T o) {
|
|
EntryReference<T> ref = addToDatabase(o);
|
|
if (internalList.add(ref.getIndex())) {
|
|
return ref;
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public boolean remove(Object o) {
|
|
int removeIndex = indexOf(o);
|
|
if (removeIndex >= 0) {
|
|
internalList.removeLong(removeIndex);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public boolean remove(EntryReference<T> ref) {
|
|
int removeIndex = indexOfEntry(ref);
|
|
if (removeIndex >= 0) {
|
|
internalList.removeLong(removeIndex);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
@Override
|
|
public boolean containsAll(Collection<?> c) {
|
|
for (Object o : c) {
|
|
int objIndex = indexOf(o);
|
|
if (objIndex < 0) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
@SuppressWarnings("unchecked")
|
|
@Override
|
|
public boolean addAll(Collection<? extends T> c) {
|
|
boolean result = false;
|
|
for (Object o : c) {
|
|
result |= add((T) o);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
@SuppressWarnings("unchecked")
|
|
@Override
|
|
public boolean addAll(int index, Collection<? extends T> c) {
|
|
boolean result = false;
|
|
int delta = 0;
|
|
for (Object o : c) {
|
|
add(index + delta, (T) o);
|
|
result = true;
|
|
delta++;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
@SuppressWarnings("unchecked")
|
|
@Override
|
|
public boolean removeAll(Collection<?> c) {
|
|
boolean result = false;
|
|
for (Object o : c) {
|
|
result |= remove((T) o);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
@Override
|
|
public boolean retainAll(Collection<?> c) {
|
|
boolean result = false;
|
|
LongArrayList collectionHashes = new LongArrayList();
|
|
ObjectArrayList<Object> collection = new ObjectArrayList<>();
|
|
collection.addAll(c);
|
|
for (Object o : c) {
|
|
collectionHashes.add(db.calculateHash(o));
|
|
}
|
|
for (int i = 0; i < internalList.size(); i++) {
|
|
long hash = internalList.getLong(i);
|
|
int positionInCollection = collectionHashes.indexOf(hash);
|
|
if (positionInCollection == -1) {
|
|
remove(collection.get(positionInCollection));
|
|
result = true;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
@Override
|
|
public void clear() {
|
|
internalList.clear();
|
|
}
|
|
|
|
/**
|
|
* Use getReference or getReadOnlyValue
|
|
*/
|
|
@Deprecated
|
|
@Override
|
|
public T get(int index) {
|
|
return getReadOnlyValue(index);
|
|
}
|
|
|
|
@SuppressWarnings("unchecked")
|
|
public T getReadOnlyValue(int index) {
|
|
try {
|
|
return (T) db.get(internalList.getLong(index)).getValueReadOnly();
|
|
} catch (IOException e) {
|
|
e.printStackTrace();
|
|
return null;
|
|
}
|
|
}
|
|
|
|
public EntryReference<T> getReference(int index) {
|
|
try {
|
|
return db.get(internalList.getLong(index)).cast();
|
|
} catch (IOException e) {
|
|
e.printStackTrace();
|
|
return null;
|
|
}
|
|
}
|
|
|
|
@SuppressWarnings("unchecked")
|
|
@Override
|
|
public T set(int index, T element) {
|
|
EntryReference<T> ref = addToDatabase(element);
|
|
long oldIndex = internalList.set(index, ref.getIndex());
|
|
try {
|
|
ref.close();
|
|
return ((EntryReference<T>) (db.get(oldIndex))).getValueReadOnly();
|
|
} catch (IOException e) {
|
|
throw (NullPointerException) new NullPointerException().initCause(e);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void add(int index, T element) {
|
|
EntryReference<T> ref = addToDatabase(element);
|
|
internalList.add(index, ref.getIndex());
|
|
}
|
|
|
|
@SuppressWarnings("unchecked")
|
|
@Override
|
|
public T remove(int index) {
|
|
long oldIndex = internalList.removeLong(index);
|
|
try {
|
|
return ((EntryReference<T>) (db.get(oldIndex))).getValueReadOnly();
|
|
} catch (IOException e) {
|
|
throw (NullPointerException) new NullPointerException().initCause(e);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public int indexOf(Object o) {
|
|
EntryReference<?> ref = addToDatabase(o);
|
|
long objToRemoveHash = ref.calculateHash();
|
|
LongArrayList hashes = new LongArrayList();
|
|
|
|
|
|
for (int i = 0; i < hashes.size(); i++) {
|
|
long hash = hashes.getLong(i);
|
|
if (objToRemoveHash == hash) {
|
|
try {
|
|
if (ref.equals(db.get(internalList.getLong(i)))) {
|
|
return i;
|
|
}
|
|
} catch (IOException e) {
|
|
throw (NullPointerException) new NullPointerException().initCause(e);
|
|
}
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
public int indexOfEntry(EntryReference<T> ref) {
|
|
for (int i = 0; i < internalList.size(); i++) {
|
|
long index = internalList.getLong(i);
|
|
try {
|
|
EntryReference<?> ref2 = db.get(index);
|
|
if (ref.getValueReadOnly().equals(ref2.getValueReadOnly())) {
|
|
return i;
|
|
}
|
|
} catch (IOException e) {
|
|
throw (NullPointerException) new NullPointerException().initCause(e);
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
@Override
|
|
public int lastIndexOf(Object o) {
|
|
EntryReference<?> ref = addToDatabase(o);
|
|
long objToRemoveHash = ref.calculateHash();
|
|
|
|
int lastValue = -1;
|
|
|
|
for (int i = 0; i < internalList.size(); i++) {
|
|
long index2 = internalList.getLong(i);
|
|
try {
|
|
EntryReference<?> ref2 = db.get(index2);
|
|
if (objToRemoveHash == ref2.calculateHash()) {
|
|
if (ref.getValueReadOnly().equals(ref2.getValueReadOnly())) {
|
|
lastValue = i;
|
|
}
|
|
}
|
|
} catch (IOException e) {
|
|
throw (NullPointerException) new NullPointerException().initCause(e);
|
|
}
|
|
}
|
|
return lastValue;
|
|
}
|
|
|
|
@Deprecated
|
|
@Override
|
|
public ListIterator<T> listIterator() {
|
|
// TODO: implement
|
|
throw new RuntimeException("Not implemented!");
|
|
}
|
|
|
|
@Deprecated
|
|
@Override
|
|
public ListIterator<T> listIterator(int index) {
|
|
// TODO: implement
|
|
throw new RuntimeException("Not implemented!");
|
|
}
|
|
|
|
@Deprecated
|
|
@Override
|
|
public List<T> subList(int fromIndex, int toIndex) {
|
|
// TODO: implement
|
|
throw new RuntimeException("Not implemented!");
|
|
}
|
|
|
|
private <U> EntryReference<U> addToDatabase(U obj) {
|
|
EntryReference<U> ref;
|
|
try {
|
|
ref = db.add(obj);
|
|
} catch (IOException e) {
|
|
throw (NullPointerException) new NullPointerException().initCause(e);
|
|
}
|
|
return ref;
|
|
}
|
|
|
|
@Deprecated
|
|
@Override
|
|
public int hashCode() {
|
|
final int prime = 31;
|
|
int result = 1;
|
|
result = prime * result + ((internalList == null) ? 0 : internalList.hashCode());
|
|
return result;
|
|
}
|
|
|
|
@SuppressWarnings("unchecked")
|
|
@Override
|
|
public boolean removeIf(Predicate<? super T> filter) {
|
|
Objects.requireNonNull(filter);
|
|
boolean removed = false;
|
|
for (int i = 0; i < internalList.size(); ) {
|
|
T obj;
|
|
try {
|
|
obj = ((EntryReference<T>) (db.get(internalList.getLong(i)).cast())).getValueReadOnly();
|
|
} catch (IOException e) {
|
|
throw (NullPointerException) new NullPointerException().initCause(e);
|
|
}
|
|
if (filter.test(obj)) {
|
|
internalList.removeLong(i);
|
|
removed = true;
|
|
} else {
|
|
i++;
|
|
}
|
|
}
|
|
return removed;
|
|
}
|
|
}
|