Files
NotEnoughItems/src/main/java/codechicken/nei/guihook/HideousLinkedList.java
T

282 lines
5.7 KiB
Java

package codechicken.nei.guihook;
import java.util.Collection;
import java.util.Comparator;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.ListIterator;
import java.util.NoSuchElementException;
import java.util.Spliterator;
import java.util.function.Consumer;
import java.util.function.Predicate;
import java.util.function.UnaryOperator;
import java.util.stream.Stream;
/**
* A hideous LinkedList that is backed by an arbitrary list, for alternative characteristics while preserving binary
* compatibility...
*
* @param <E>
*/
public final class HideousLinkedList<E> extends LinkedList<E> {
private static final long serialVersionUID = -8504433551965776915L;
private final List<E> backing;
public HideousLinkedList(List<E> backing) {
this.backing = backing;
}
@Override
public int size() {
return backing.size();
}
@Override
public boolean isEmpty() {
return backing.isEmpty();
}
@Override
public boolean contains(Object o) {
return backing.contains(o);
}
@Override
public Iterator<E> iterator() {
return backing.iterator();
}
@Override
public Object[] toArray() {
return backing.toArray();
}
@Override
public <T> T[] toArray(T[] a) {
return backing.toArray(a);
}
@Override
public boolean add(E e) {
return backing.add(e);
}
@Override
public void addFirst(E e) {
backing.add(0, e);
}
@Override
public E getFirst() {
if (backing.size() == 0) throw new NoSuchElementException();
return (backing.get(0));
}
@Override
public E removeFirst() {
E item = getFirst();
backing.remove(0);
return item;
}
@Override
public void addLast(E e) {
backing.add(backing.size(), e);
}
@Override
public E getLast() {
if (backing.size() == 0) throw new NoSuchElementException();
return backing.get(backing.size() - 1);
}
@Override
public E removeLast() {
E item = getLast();
backing.remove(backing.size() - 1);
return item;
}
@Override
public E peek() {
return backing.size() > 0 ? backing.get(0) : null;
}
@Override
public E peekFirst() {
return backing.size() > 0 ? getFirst() : null;
}
@Override
public E peekLast() {
return backing.size() > 0 ? getLast() : null;
}
@Override
public E poll() {
return backing.size() > 0 ? removeFirst() : null;
}
@Override
public E pollFirst() {
return poll();
}
@Override
public E pollLast() {
return backing.size() > 0 ? removeLast() : null;
}
@Override
public void push(E e) {
addFirst(e);
}
@Override
public E pop() {
return removeFirst();
}
@Override
public boolean removeFirstOccurrence(Object e) {
return remove(e);
}
@Override
public boolean removeLastOccurrence(Object e) {
int idx = this.backing.lastIndexOf(e);
if (idx != -1) {
this.backing.remove(idx);
return true;
}
return false;
}
@Override
public boolean remove(Object o) {
return backing.remove(o);
}
@Override
public boolean containsAll(Collection<?> c) {
return backing.containsAll(c);
}
@Override
public boolean addAll(Collection<? extends E> c) {
return backing.addAll(c);
}
@Override
public boolean addAll(int index, Collection<? extends E> c) {
return backing.addAll(index, c);
}
@Override
public boolean removeAll(Collection<?> c) {
return backing.removeAll(c);
}
@Override
public boolean retainAll(Collection<?> c) {
return backing.retainAll(c);
}
@Override
public void replaceAll(UnaryOperator<E> operator) {
backing.replaceAll(operator);
}
@Override
public void sort(Comparator<? super E> c) {
backing.sort(c);
}
@Override
public void clear() {
backing.clear();
}
@Override
public boolean equals(Object o) {
return backing.equals(o);
}
@Override
public int hashCode() {
return backing.hashCode();
}
@Override
public E get(int index) {
return backing.get(index);
}
@Override
public E set(int index, E element) {
return backing.set(index, element);
}
@Override
public void add(int index, E element) {
backing.add(index, element);
}
@Override
public E remove(int index) {
return backing.remove(index);
}
@Override
public int indexOf(Object o) {
return backing.indexOf(o);
}
@Override
public int lastIndexOf(Object o) {
return backing.lastIndexOf(o);
}
@Override
public ListIterator<E> listIterator() {
return backing.listIterator();
}
@Override
public ListIterator<E> listIterator(int index) {
return backing.listIterator(index);
}
@Override
public List<E> subList(int fromIndex, int toIndex) {
return backing.subList(fromIndex, toIndex);
}
@Override
public Spliterator<E> spliterator() {
return backing.spliterator();
}
@Override
public boolean removeIf(Predicate<? super E> filter) {
return backing.removeIf(filter);
}
@Override
public Stream<E> stream() {
return backing.stream();
}
@Override
public Stream<E> parallelStream() {
return backing.parallelStream();
}
@Override
public void forEach(Consumer<? super E> action) {
backing.forEach(action);
}
}