371 lines
11 KiB
Java
371 lines
11 KiB
Java
package gnu.trove;
|
|
|
|
import gnu.trove.TLinkable;
|
|
import java.io.Serializable;
|
|
import java.util.AbstractSequentialList;
|
|
import java.util.ListIterator;
|
|
import java.util.NoSuchElementException;
|
|
|
|
/* loaded from: classes2.dex */
|
|
public class TLinkedList<T extends TLinkable> extends AbstractSequentialList<T> implements Serializable {
|
|
protected T _head;
|
|
protected int _size;
|
|
protected T _tail;
|
|
|
|
protected final class IteratorImpl implements ListIterator<T> {
|
|
private int a;
|
|
private T b;
|
|
private T c;
|
|
|
|
IteratorImpl(int i) {
|
|
int i2;
|
|
if (i < 0 || i > (i2 = TLinkedList.this._size)) {
|
|
throw new IndexOutOfBoundsException();
|
|
}
|
|
this.a = i;
|
|
if (i == 0) {
|
|
this.b = TLinkedList.this._head;
|
|
return;
|
|
}
|
|
if (i == i2) {
|
|
this.b = null;
|
|
return;
|
|
}
|
|
if (i < (i2 >> 1)) {
|
|
this.b = TLinkedList.this._head;
|
|
for (int i3 = 0; i3 < i; i3++) {
|
|
this.b = (T) this.b.getNext();
|
|
}
|
|
return;
|
|
}
|
|
this.b = TLinkedList.this._tail;
|
|
for (int i4 = i2 - 1; i4 > i; i4--) {
|
|
this.b = (T) this.b.getPrevious();
|
|
}
|
|
}
|
|
|
|
@Override // java.util.ListIterator
|
|
/* renamed from: a, reason: merged with bridge method [inline-methods] */
|
|
public final void add(T t) {
|
|
this.c = null;
|
|
this.a++;
|
|
TLinkedList tLinkedList = TLinkedList.this;
|
|
if (tLinkedList._size == 0) {
|
|
tLinkedList.add((TLinkedList) t);
|
|
} else {
|
|
tLinkedList.addBefore(this.b, t);
|
|
}
|
|
}
|
|
|
|
@Override // java.util.ListIterator
|
|
/* renamed from: b, reason: merged with bridge method [inline-methods] */
|
|
public final void set(T t) {
|
|
T t2 = this.c;
|
|
if (t2 == null) {
|
|
throw new IllegalStateException();
|
|
}
|
|
TLinkedList tLinkedList = TLinkedList.this;
|
|
if (t2 == tLinkedList._head) {
|
|
tLinkedList._head = t;
|
|
}
|
|
T t3 = this.c;
|
|
TLinkedList tLinkedList2 = TLinkedList.this;
|
|
if (t3 == tLinkedList2._tail) {
|
|
tLinkedList2._tail = t;
|
|
}
|
|
a(this.c, t);
|
|
this.c = t;
|
|
}
|
|
|
|
@Override // java.util.ListIterator, java.util.Iterator
|
|
public final boolean hasNext() {
|
|
return this.a != TLinkedList.this._size;
|
|
}
|
|
|
|
@Override // java.util.ListIterator
|
|
public final boolean hasPrevious() {
|
|
return this.a != 0;
|
|
}
|
|
|
|
@Override // java.util.ListIterator
|
|
public final int nextIndex() {
|
|
return this.a;
|
|
}
|
|
|
|
@Override // java.util.ListIterator
|
|
public final int previousIndex() {
|
|
return this.a - 1;
|
|
}
|
|
|
|
@Override // java.util.ListIterator, java.util.Iterator
|
|
public final void remove() {
|
|
T t = this.c;
|
|
if (t == null) {
|
|
throw new IllegalStateException("must invoke next or previous before invoking remove");
|
|
}
|
|
if (t != this.b) {
|
|
this.a--;
|
|
}
|
|
this.b = (T) this.c.getNext();
|
|
TLinkedList.this.remove(this.c);
|
|
this.c = null;
|
|
}
|
|
|
|
@Override // java.util.ListIterator, java.util.Iterator
|
|
public final T next() {
|
|
if (this.a == TLinkedList.this._size) {
|
|
throw new NoSuchElementException();
|
|
}
|
|
T t = this.b;
|
|
this.c = t;
|
|
this.b = (T) t.getNext();
|
|
this.a++;
|
|
return this.c;
|
|
}
|
|
|
|
@Override // java.util.ListIterator
|
|
public final T previous() {
|
|
int i = this.a;
|
|
if (i == 0) {
|
|
throw new NoSuchElementException();
|
|
}
|
|
TLinkedList tLinkedList = TLinkedList.this;
|
|
if (i == tLinkedList._size) {
|
|
T t = tLinkedList._tail;
|
|
this.b = t;
|
|
this.c = t;
|
|
} else {
|
|
T t2 = (T) this.b.getPrevious();
|
|
this.b = t2;
|
|
this.c = t2;
|
|
}
|
|
this.a--;
|
|
return this.c;
|
|
}
|
|
|
|
private void a(T t, T t2) {
|
|
TLinkable previous = t.getPrevious();
|
|
TLinkable next = t.getNext();
|
|
if (previous != null) {
|
|
t2.setPrevious(previous);
|
|
previous.setNext(t2);
|
|
}
|
|
if (next != null) {
|
|
t2.setNext(next);
|
|
next.setPrevious(t2);
|
|
}
|
|
t.setNext(null);
|
|
t.setPrevious(null);
|
|
}
|
|
}
|
|
|
|
public void addBefore(T t, T t2) {
|
|
if (t == this._head) {
|
|
addFirst(t2);
|
|
return;
|
|
}
|
|
if (t == null) {
|
|
addLast(t2);
|
|
return;
|
|
}
|
|
TLinkable previous = t.getPrevious();
|
|
t2.setNext(t);
|
|
previous.setNext(t2);
|
|
t2.setPrevious(previous);
|
|
t.setPrevious(t2);
|
|
this._size++;
|
|
}
|
|
|
|
public void addFirst(T t) {
|
|
insert(0, t);
|
|
}
|
|
|
|
public void addLast(T t) {
|
|
insert(size(), t);
|
|
}
|
|
|
|
@Override // java.util.AbstractList, java.util.AbstractCollection, java.util.Collection, java.util.List
|
|
public void clear() {
|
|
T t = this._head;
|
|
if (t != null) {
|
|
for (TLinkable next = t.getNext(); next != null; next = next.getNext()) {
|
|
next.getPrevious().setNext(null);
|
|
next.setPrevious(null);
|
|
}
|
|
this._tail = null;
|
|
this._head = null;
|
|
}
|
|
this._size = 0;
|
|
}
|
|
|
|
@Override // java.util.AbstractCollection, java.util.Collection, java.util.List
|
|
public boolean contains(Object obj) {
|
|
for (TLinkable tLinkable = this._head; tLinkable != null; tLinkable = tLinkable.getNext()) {
|
|
if (obj.equals(tLinkable)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public T getFirst() {
|
|
return this._head;
|
|
}
|
|
|
|
public T getLast() {
|
|
return this._tail;
|
|
}
|
|
|
|
protected void insert(int i, T t) {
|
|
TLinkable tLinkable;
|
|
int i2 = this._size;
|
|
if (i2 == 0) {
|
|
this._tail = t;
|
|
this._head = t;
|
|
} else if (i == 0) {
|
|
t.setNext(this._head);
|
|
this._head.setPrevious(t);
|
|
this._head = t;
|
|
} else if (i == i2) {
|
|
this._tail.setNext(t);
|
|
t.setPrevious(this._tail);
|
|
this._tail = t;
|
|
} else {
|
|
if (i > (i2 >> 1)) {
|
|
tLinkable = this._tail;
|
|
for (int i3 = i2 - 1; i3 > i; i3--) {
|
|
tLinkable = tLinkable.getPrevious();
|
|
}
|
|
} else {
|
|
tLinkable = this._head;
|
|
for (int i4 = 0; i4 < i; i4++) {
|
|
tLinkable = tLinkable.getNext();
|
|
}
|
|
}
|
|
TLinkable next = tLinkable.getNext();
|
|
t.setNext(next);
|
|
t.setPrevious(tLinkable);
|
|
next.setPrevious(t);
|
|
tLinkable.setNext(t);
|
|
}
|
|
this._size++;
|
|
}
|
|
|
|
@Override // java.util.AbstractSequentialList, java.util.AbstractList, java.util.List
|
|
public ListIterator<T> listIterator(int i) {
|
|
return new IteratorImpl(i);
|
|
}
|
|
|
|
@Override // java.util.AbstractCollection, java.util.Collection, java.util.List
|
|
public boolean remove(Object obj) {
|
|
if (!(obj instanceof TLinkable)) {
|
|
return false;
|
|
}
|
|
TLinkable tLinkable = (TLinkable) obj;
|
|
TLinkableAdaptor tLinkableAdaptor = (T) tLinkable.getPrevious();
|
|
TLinkableAdaptor tLinkableAdaptor2 = (T) tLinkable.getNext();
|
|
if (tLinkableAdaptor2 == null && tLinkableAdaptor == null) {
|
|
this._tail = null;
|
|
this._head = null;
|
|
} else if (tLinkableAdaptor2 == null) {
|
|
tLinkable.setPrevious(null);
|
|
tLinkableAdaptor.setNext(null);
|
|
this._tail = tLinkableAdaptor;
|
|
} else if (tLinkableAdaptor == null) {
|
|
tLinkable.setNext(null);
|
|
tLinkableAdaptor2.setPrevious(null);
|
|
this._head = tLinkableAdaptor2;
|
|
} else {
|
|
tLinkableAdaptor.setNext(tLinkableAdaptor2);
|
|
tLinkableAdaptor2.setPrevious(tLinkableAdaptor);
|
|
tLinkable.setNext(null);
|
|
tLinkable.setPrevious(null);
|
|
}
|
|
this._size--;
|
|
return true;
|
|
}
|
|
|
|
public T removeFirst() {
|
|
T t = this._head;
|
|
T t2 = (T) t.getNext();
|
|
t.setNext(null);
|
|
if (t2 != null) {
|
|
t2.setPrevious(null);
|
|
}
|
|
this._head = t2;
|
|
int i = this._size - 1;
|
|
this._size = i;
|
|
if (i == 0) {
|
|
this._tail = null;
|
|
}
|
|
return t;
|
|
}
|
|
|
|
public T removeLast() {
|
|
T t = this._tail;
|
|
T t2 = (T) t.getPrevious();
|
|
t.setPrevious(null);
|
|
if (t2 != null) {
|
|
t2.setNext(null);
|
|
}
|
|
this._tail = t2;
|
|
int i = this._size - 1;
|
|
this._size = i;
|
|
if (i == 0) {
|
|
this._head = null;
|
|
}
|
|
return t;
|
|
}
|
|
|
|
@Override // java.util.AbstractCollection, java.util.Collection, java.util.List
|
|
public int size() {
|
|
return this._size;
|
|
}
|
|
|
|
@Override // java.util.AbstractCollection, java.util.Collection, java.util.List
|
|
public Object[] toArray() {
|
|
Object[] objArr = new Object[this._size];
|
|
TLinkable tLinkable = this._head;
|
|
int i = 0;
|
|
while (tLinkable != null) {
|
|
objArr[i] = tLinkable;
|
|
tLinkable = tLinkable.getNext();
|
|
i++;
|
|
}
|
|
return objArr;
|
|
}
|
|
|
|
public Object[] toUnlinkedArray() {
|
|
Object[] objArr = new Object[this._size];
|
|
T t = this._head;
|
|
int i = 0;
|
|
while (t != null) {
|
|
objArr[i] = t;
|
|
TLinkable next = t.getNext();
|
|
t.setNext(null);
|
|
t.setPrevious(null);
|
|
i++;
|
|
t = next;
|
|
}
|
|
this._size = 0;
|
|
this._tail = null;
|
|
this._head = null;
|
|
return objArr;
|
|
}
|
|
|
|
@Override // java.util.AbstractSequentialList, java.util.AbstractList, java.util.List
|
|
public void add(int i, T t) {
|
|
if (i >= 0 && i <= size()) {
|
|
insert(i, t);
|
|
return;
|
|
}
|
|
throw new IndexOutOfBoundsException("index:" + i);
|
|
}
|
|
|
|
@Override // java.util.AbstractList, java.util.AbstractCollection, java.util.Collection, java.util.List
|
|
public boolean add(T t) {
|
|
insert(this._size, t);
|
|
return true;
|
|
}
|
|
}
|