737 lines
23 KiB
Java
737 lines
23 KiB
Java
package com.discord.utilities.collections;
|
|
|
|
import c.d.b.a.a;
|
|
import d0.t.n;
|
|
import d0.t.q;
|
|
import d0.t.s;
|
|
import d0.z.d.g;
|
|
import d0.z.d.g0.c;
|
|
import d0.z.d.m;
|
|
import java.util.ArrayList;
|
|
import java.util.Collection;
|
|
import java.util.HashSet;
|
|
import java.util.Iterator;
|
|
import java.util.List;
|
|
import java.util.ListIterator;
|
|
import kotlin.jvm.functions.Function1;
|
|
import kotlin.jvm.internal.DefaultConstructorMarker;
|
|
/* compiled from: SparseMutableList.kt */
|
|
public final class SparseMutableList<T> implements List<T>, c {
|
|
private final List<Chunk<T>> chunks;
|
|
private final int expectedChunkSize;
|
|
private int size;
|
|
|
|
/* compiled from: SparseMutableList.kt */
|
|
public static final class Chunk<T> implements Comparable<Chunk<T>> {
|
|
public static final Companion Companion = new Companion(null);
|
|
private List<T> list;
|
|
private int startIndex;
|
|
|
|
/* compiled from: SparseMutableList.kt */
|
|
public static final class Companion {
|
|
private Companion() {
|
|
}
|
|
|
|
public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
|
|
this();
|
|
}
|
|
|
|
public final <T> Chunk<T> create(T t, int i, int i2) {
|
|
ArrayList arrayList = new ArrayList(i2);
|
|
arrayList.add(t);
|
|
return new Chunk<>(i, arrayList);
|
|
}
|
|
|
|
public final <T> Chunk<T> tryMergeChunks(Chunk<T> chunk, Chunk<T> chunk2) {
|
|
Chunk<T> chunk3;
|
|
m.checkNotNullParameter(chunk, "chunk1");
|
|
m.checkNotNullParameter(chunk2, "chunk2");
|
|
if (Chunk.access$getStartIndex$p(chunk) < Chunk.access$getStartIndex$p(chunk2)) {
|
|
chunk3 = chunk;
|
|
} else if (Chunk.access$getStartIndex$p(chunk2) < Chunk.access$getStartIndex$p(chunk)) {
|
|
chunk3 = chunk2;
|
|
} else {
|
|
throw new IllegalArgumentException("both chunks begin at the same index");
|
|
}
|
|
Chunk<T> chunk4 = chunk == chunk3 ? chunk2 : chunk;
|
|
int size = (chunk3.getSize() + Chunk.access$getStartIndex$p(chunk3)) - 1;
|
|
if (size >= Chunk.access$getStartIndex$p(chunk4)) {
|
|
throw new IllegalArgumentException("chunks overlap: " + chunk + ", " + chunk2);
|
|
} else if (size != Chunk.access$getStartIndex$p(chunk4) - 1) {
|
|
return null;
|
|
} else {
|
|
List<T> list = chunk3.getList();
|
|
list.addAll(chunk4.getList());
|
|
return new Chunk<>(Chunk.access$getStartIndex$p(chunk3), list);
|
|
}
|
|
}
|
|
}
|
|
|
|
public Chunk(int i, List<T> list) {
|
|
m.checkNotNullParameter(list, "list");
|
|
this.startIndex = i;
|
|
this.list = list;
|
|
}
|
|
|
|
public static final /* synthetic */ int access$getStartIndex$p(Chunk chunk) {
|
|
return chunk.startIndex;
|
|
}
|
|
|
|
public static final /* synthetic */ void access$setStartIndex$p(Chunk chunk, int i) {
|
|
chunk.startIndex = i;
|
|
}
|
|
|
|
private final int component1() {
|
|
return this.startIndex;
|
|
}
|
|
|
|
/* JADX DEBUG: Multi-variable search result rejected for r0v0, resolved type: com.discord.utilities.collections.SparseMutableList$Chunk */
|
|
/* JADX WARN: Multi-variable type inference failed */
|
|
public static /* synthetic */ Chunk copy$default(Chunk chunk, int i, List list, int i2, Object obj) {
|
|
if ((i2 & 1) != 0) {
|
|
i = chunk.startIndex;
|
|
}
|
|
if ((i2 & 2) != 0) {
|
|
list = chunk.list;
|
|
}
|
|
return chunk.copy(i, list);
|
|
}
|
|
|
|
public final void addAtListIndex(int i, T t) {
|
|
int i2 = i - this.startIndex;
|
|
if (i2 == 0 && t == null) {
|
|
incrementStartIndex();
|
|
} else {
|
|
this.list.add(i2, t);
|
|
}
|
|
}
|
|
|
|
public final boolean beginsAfterListIndex(int i) {
|
|
return this.startIndex > i;
|
|
}
|
|
|
|
public int compareTo(Chunk<T> chunk) {
|
|
m.checkNotNullParameter(chunk, "other");
|
|
return this.startIndex - chunk.startIndex;
|
|
}
|
|
|
|
@Override // java.lang.Comparable
|
|
public /* bridge */ /* synthetic */ int compareTo(Object obj) {
|
|
return compareTo((Chunk) ((Chunk) obj));
|
|
}
|
|
|
|
public final List<T> component2() {
|
|
return this.list;
|
|
}
|
|
|
|
public final boolean containsListIndex(int i) {
|
|
return this.startIndex <= i && n.getLastIndex(this.list) + this.startIndex >= i;
|
|
}
|
|
|
|
public final Chunk<T> copy(int i, List<T> list) {
|
|
m.checkNotNullParameter(list, "list");
|
|
return new Chunk<>(i, list);
|
|
}
|
|
|
|
public final void decrementStartIndex() {
|
|
this.startIndex--;
|
|
}
|
|
|
|
public final Chunk<T> deepCopy() {
|
|
return new Chunk<>(this.startIndex, new ArrayList(this.list));
|
|
}
|
|
|
|
public final <R> Chunk<R> deepCopy(Function1<? super T, ? extends R> function1) {
|
|
m.checkNotNullParameter(function1, "transform");
|
|
ArrayList arrayList = new ArrayList(this.list.size());
|
|
Iterator<T> it = this.list.iterator();
|
|
while (it.hasNext()) {
|
|
T next = it.next();
|
|
arrayList.add(next != null ? function1.invoke(next) : null);
|
|
}
|
|
return new Chunk<>(this.startIndex, arrayList);
|
|
}
|
|
|
|
@Override // java.lang.Object
|
|
public boolean equals(Object obj) {
|
|
if (this == obj) {
|
|
return true;
|
|
}
|
|
if (!(obj instanceof Chunk)) {
|
|
return false;
|
|
}
|
|
Chunk chunk = (Chunk) obj;
|
|
return this.startIndex == chunk.startIndex && m.areEqual(this.list, chunk.list);
|
|
}
|
|
|
|
public final int firstListIndexOf(T t) {
|
|
int lastIndex = n.getLastIndex(this.list);
|
|
if (lastIndex < 0) {
|
|
return -1;
|
|
}
|
|
int i = 0;
|
|
while (!m.areEqual(this.list.get(i), t)) {
|
|
if (i == lastIndex) {
|
|
return -1;
|
|
}
|
|
i++;
|
|
}
|
|
return this.startIndex + i;
|
|
}
|
|
|
|
public final T getAtListIndex(int i) {
|
|
return this.list.get(i - this.startIndex);
|
|
}
|
|
|
|
public final List<T> getList() {
|
|
return this.list;
|
|
}
|
|
|
|
public final int getSize() {
|
|
return this.list.size();
|
|
}
|
|
|
|
@Override // java.lang.Object
|
|
public int hashCode() {
|
|
int i = this.startIndex * 31;
|
|
List<T> list = this.list;
|
|
return i + (list != null ? list.hashCode() : 0);
|
|
}
|
|
|
|
public final void incrementStartIndex() {
|
|
this.startIndex++;
|
|
}
|
|
|
|
public final boolean isEmpty() {
|
|
return this.list.isEmpty();
|
|
}
|
|
|
|
public final int lastListIndexOf(T t) {
|
|
for (int lastIndex = n.getLastIndex(this.list); lastIndex >= 0; lastIndex--) {
|
|
if (m.areEqual(this.list.get(lastIndex), t)) {
|
|
return this.startIndex + lastIndex;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
public final void removeAfterInclusive(int i) {
|
|
int i2 = i - this.startIndex;
|
|
if (i2 <= n.getLastIndex(this.list)) {
|
|
if (i2 <= 0) {
|
|
this.list.clear();
|
|
} else {
|
|
this.list = this.list.subList(0, i2);
|
|
}
|
|
}
|
|
}
|
|
|
|
public final T removeAtListIndex(int i) {
|
|
return this.list.remove(i - this.startIndex);
|
|
}
|
|
|
|
public final T setAtListIndex(int i, T t) {
|
|
int i2 = i - this.startIndex;
|
|
if (t != null) {
|
|
return this.list.set(i2, t);
|
|
}
|
|
if (i2 != 0) {
|
|
return this.list.set(i2, t);
|
|
}
|
|
incrementStartIndex();
|
|
return this.list.remove(0);
|
|
}
|
|
|
|
public final void setList(List<T> list) {
|
|
m.checkNotNullParameter(list, "<set-?>");
|
|
this.list = list;
|
|
}
|
|
|
|
@Override // java.lang.Object
|
|
public String toString() {
|
|
StringBuilder L = a.L("Chunk(startIndex=");
|
|
L.append(this.startIndex);
|
|
L.append(", list=");
|
|
return a.E(L, this.list, ")");
|
|
}
|
|
}
|
|
|
|
/* compiled from: SparseMutableList.kt */
|
|
public static final class SparseMutableListIterator<T> implements ListIterator<T>, d0.z.d.g0.a {
|
|
private int index;
|
|
private final SparseMutableList<T> sparseMutableList;
|
|
|
|
public SparseMutableListIterator(SparseMutableList<T> sparseMutableList, int i) {
|
|
m.checkNotNullParameter(sparseMutableList, "sparseMutableList");
|
|
this.sparseMutableList = sparseMutableList;
|
|
this.index = i;
|
|
}
|
|
|
|
/* JADX INFO: this call moved to the top of the method (can break code semantics) */
|
|
public /* synthetic */ SparseMutableListIterator(SparseMutableList sparseMutableList, int i, int i2, DefaultConstructorMarker defaultConstructorMarker) {
|
|
this(sparseMutableList, (i2 & 2) != 0 ? -1 : i);
|
|
}
|
|
|
|
@Override // java.util.ListIterator
|
|
public void add(T t) {
|
|
throw new UnsupportedOperationException("add not supported during iteration");
|
|
}
|
|
|
|
public final int getIndex() {
|
|
return this.index;
|
|
}
|
|
|
|
@Override // java.util.ListIterator, java.util.Iterator
|
|
public boolean hasNext() {
|
|
return nextIndex() < n.getLastIndex(this.sparseMutableList);
|
|
}
|
|
|
|
@Override // java.util.ListIterator
|
|
public boolean hasPrevious() {
|
|
return this.index > 0;
|
|
}
|
|
|
|
@Override // java.util.ListIterator, java.util.Iterator
|
|
public T next() {
|
|
int i = this.index + 1;
|
|
this.index = i;
|
|
return this.sparseMutableList.get(i);
|
|
}
|
|
|
|
@Override // java.util.ListIterator
|
|
public int nextIndex() {
|
|
return this.index + 1;
|
|
}
|
|
|
|
@Override // java.util.ListIterator
|
|
public T previous() {
|
|
int i = this.index - 1;
|
|
this.index = i;
|
|
return this.sparseMutableList.get(i);
|
|
}
|
|
|
|
@Override // java.util.ListIterator
|
|
public int previousIndex() {
|
|
return this.index - 1;
|
|
}
|
|
|
|
@Override // java.util.ListIterator, java.util.Iterator
|
|
public void remove() {
|
|
this.sparseMutableList.remove(this.index);
|
|
}
|
|
|
|
@Override // java.util.ListIterator
|
|
public void set(T t) {
|
|
this.sparseMutableList.set(this.index, t);
|
|
}
|
|
|
|
public final void setIndex(int i) {
|
|
this.index = i;
|
|
}
|
|
}
|
|
|
|
public SparseMutableList() {
|
|
this(0, 0, 3, null);
|
|
}
|
|
|
|
public SparseMutableList(int i, int i2) {
|
|
this.expectedChunkSize = i2;
|
|
this.chunks = new ArrayList();
|
|
this.size = i;
|
|
}
|
|
|
|
/* JADX INFO: this call moved to the top of the method (can break code semantics) */
|
|
public /* synthetic */ SparseMutableList(int i, int i2, int i3, DefaultConstructorMarker defaultConstructorMarker) {
|
|
this((i3 & 1) != 0 ? 0 : i, (i3 & 2) != 0 ? 5 : i2);
|
|
}
|
|
|
|
private final void addChunk(int i, Chunk<T> chunk) {
|
|
this.chunks.add(i, chunk);
|
|
q.sort(this.chunks);
|
|
}
|
|
|
|
private final void addChunk(Chunk<T> chunk) {
|
|
this.chunks.add(chunk);
|
|
q.sort(this.chunks);
|
|
}
|
|
|
|
private final void decrementChunksFromIndex(int i) {
|
|
int lastIndex;
|
|
int lastIndex2 = n.getLastIndex(this.chunks);
|
|
if (i >= 0 && lastIndex2 >= i && i <= (lastIndex = n.getLastIndex(this.chunks))) {
|
|
while (true) {
|
|
this.chunks.get(i).decrementStartIndex();
|
|
if (i != lastIndex) {
|
|
i++;
|
|
} else {
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private final int getChunkIndex(int i) {
|
|
int i2 = 0;
|
|
for (Chunk<T> chunk : this.chunks) {
|
|
if (chunk.containsListIndex(i)) {
|
|
return i2;
|
|
}
|
|
i2++;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
private final int getFirstChunkIndexAfter(int i) {
|
|
int i2 = 0;
|
|
for (Chunk<T> chunk : this.chunks) {
|
|
if (chunk.beginsAfterListIndex(i)) {
|
|
return i2;
|
|
}
|
|
i2++;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
private final void incrementChunksFromIndex(int i) {
|
|
int lastIndex;
|
|
int lastIndex2 = n.getLastIndex(this.chunks);
|
|
if (i >= 0 && lastIndex2 >= i && i <= (lastIndex = n.getLastIndex(this.chunks))) {
|
|
while (true) {
|
|
this.chunks.get(i).incrementStartIndex();
|
|
if (i != lastIndex) {
|
|
i++;
|
|
} else {
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private final void resolveChunks() {
|
|
q.sort(this.chunks);
|
|
int i = 0;
|
|
while (i < this.chunks.size() - 1) {
|
|
Chunk<T> chunk = this.chunks.get(i);
|
|
if (chunk.isEmpty()) {
|
|
this.chunks.remove(i);
|
|
} else {
|
|
int i2 = i + 1;
|
|
Chunk<T> tryMergeChunks = Chunk.Companion.tryMergeChunks(chunk, this.chunks.get(i2));
|
|
if (tryMergeChunks != null) {
|
|
this.chunks.set(i, tryMergeChunks);
|
|
this.chunks.remove(i2);
|
|
} else {
|
|
i = i2;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override // java.util.List
|
|
public void add(int i, T t) {
|
|
if (i == size()) {
|
|
add(t);
|
|
} else if (i <= size()) {
|
|
int chunkIndex = getChunkIndex(i);
|
|
if (t != null) {
|
|
if (chunkIndex >= 0) {
|
|
this.chunks.get(chunkIndex).addAtListIndex(i, t);
|
|
incrementChunksFromIndex(chunkIndex + 1);
|
|
} else {
|
|
Chunk<T> create = Chunk.Companion.create(t, i, this.expectedChunkSize);
|
|
int firstChunkIndexAfter = getFirstChunkIndexAfter(i);
|
|
if (firstChunkIndexAfter == -1) {
|
|
addChunk(create);
|
|
} else {
|
|
addChunk(firstChunkIndexAfter, create);
|
|
incrementChunksFromIndex(firstChunkIndexAfter + 1);
|
|
}
|
|
}
|
|
} else if (chunkIndex >= 0) {
|
|
this.chunks.get(chunkIndex).addAtListIndex(i, null);
|
|
incrementChunksFromIndex(chunkIndex + 1);
|
|
} else {
|
|
int firstChunkIndexAfter2 = getFirstChunkIndexAfter(i);
|
|
if (firstChunkIndexAfter2 != -1) {
|
|
incrementChunksFromIndex(firstChunkIndexAfter2);
|
|
}
|
|
}
|
|
setSize(size() + 1);
|
|
resolveChunks();
|
|
} else {
|
|
throw new IndexOutOfBoundsException();
|
|
}
|
|
}
|
|
|
|
@Override // java.util.List, java.util.Collection
|
|
public boolean add(T t) {
|
|
set(size(), t);
|
|
return true;
|
|
}
|
|
|
|
@Override // java.util.List
|
|
public boolean addAll(int i, Collection<? extends T> collection) {
|
|
m.checkNotNullParameter(collection, "elements");
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
|
|
@Override // java.util.List, java.util.Collection
|
|
public boolean addAll(Collection<? extends T> collection) {
|
|
m.checkNotNullParameter(collection, "elements");
|
|
return addAll(size(), collection);
|
|
}
|
|
|
|
@Override // java.util.List, java.util.Collection
|
|
public void clear() {
|
|
this.chunks.clear();
|
|
setSize(0);
|
|
}
|
|
|
|
@Override // java.util.List, java.util.Collection
|
|
public boolean contains(Object obj) {
|
|
if (isEmpty()) {
|
|
return false;
|
|
}
|
|
for (T t : this) {
|
|
if (m.areEqual(t, obj)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
@Override // java.util.List, java.util.Collection
|
|
public boolean containsAll(Collection<? extends Object> collection) {
|
|
m.checkNotNullParameter(collection, "elements");
|
|
HashSet hashSet = new HashSet(collection);
|
|
if (hashSet.size() > size()) {
|
|
return false;
|
|
}
|
|
for (T t : this) {
|
|
if (hashSet.contains(t)) {
|
|
hashSet.remove(t);
|
|
if (hashSet.isEmpty()) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public final SparseMutableList<T> deepCopy() {
|
|
SparseMutableList<T> sparseMutableList = new SparseMutableList<>(size(), 0, 2, null);
|
|
Iterator<T> it = this.chunks.iterator();
|
|
while (it.hasNext()) {
|
|
sparseMutableList.chunks.add(it.next().deepCopy());
|
|
}
|
|
return sparseMutableList;
|
|
}
|
|
|
|
public final <R> SparseMutableList<R> deepCopy(Function1<? super T, ? extends R> function1) {
|
|
m.checkNotNullParameter(function1, "transform");
|
|
SparseMutableList<R> sparseMutableList = new SparseMutableList<>(size(), 0, 2, null);
|
|
Iterator<T> it = this.chunks.iterator();
|
|
while (it.hasNext()) {
|
|
sparseMutableList.chunks.add(it.next().deepCopy(function1));
|
|
}
|
|
return sparseMutableList;
|
|
}
|
|
|
|
@Override // java.util.List
|
|
public T get(int i) {
|
|
if (i <= n.getLastIndex(this)) {
|
|
int chunkIndex = getChunkIndex(i);
|
|
Chunk<T> chunk = chunkIndex >= 0 ? this.chunks.get(chunkIndex) : null;
|
|
if (chunk != null) {
|
|
return chunk.getAtListIndex(i);
|
|
}
|
|
return null;
|
|
}
|
|
StringBuilder M = a.M("index ", i, " invalid in list of size ");
|
|
M.append(size());
|
|
throw new IndexOutOfBoundsException(M.toString());
|
|
}
|
|
|
|
public int getSize() {
|
|
return this.size;
|
|
}
|
|
|
|
@Override // java.util.List
|
|
public int indexOf(Object obj) {
|
|
if (obj != null) {
|
|
Iterator<T> it = this.chunks.iterator();
|
|
while (it.hasNext()) {
|
|
int firstListIndexOf = it.next().firstListIndexOf(obj);
|
|
if (firstListIndexOf >= 0) {
|
|
return firstListIndexOf;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
int i = 0;
|
|
for (T t : this) {
|
|
int i2 = i + 1;
|
|
if (i < 0) {
|
|
n.throwIndexOverflow();
|
|
}
|
|
if (m.areEqual(t, obj)) {
|
|
return i;
|
|
}
|
|
i = i2;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
@Override // java.util.List, java.util.Collection
|
|
public boolean isEmpty() {
|
|
return size() == 0;
|
|
}
|
|
|
|
@Override // java.util.List, java.util.Collection, java.lang.Iterable
|
|
public Iterator<T> iterator() {
|
|
return new SparseMutableListIterator(this, 0, 2, null);
|
|
}
|
|
|
|
@Override // java.util.List
|
|
public int lastIndexOf(Object obj) {
|
|
if (obj != null) {
|
|
for (T t : s.asReversedMutable(this.chunks)) {
|
|
int lastListIndexOf = t.lastListIndexOf(obj);
|
|
if (lastListIndexOf >= 0) {
|
|
return lastListIndexOf;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
for (int lastIndex = n.getLastIndex(this); lastIndex >= 0; lastIndex--) {
|
|
if (m.areEqual(get(lastIndex), obj)) {
|
|
return lastIndex;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
@Override // java.util.List
|
|
public ListIterator<T> listIterator() {
|
|
return new SparseMutableListIterator(this, 0, 2, null);
|
|
}
|
|
|
|
@Override // java.util.List
|
|
public ListIterator<T> listIterator(int i) {
|
|
return new SparseMutableListIterator(this, 0, 2, null);
|
|
}
|
|
|
|
@Override // java.util.List
|
|
public final /* bridge */ T remove(int i) {
|
|
return removeAt(i);
|
|
}
|
|
|
|
@Override // java.util.List, java.util.Collection
|
|
public boolean remove(Object obj) {
|
|
SparseMutableListIterator sparseMutableListIterator = new SparseMutableListIterator(this, 0, 2, null);
|
|
while (sparseMutableListIterator.hasNext()) {
|
|
if (m.areEqual(sparseMutableListIterator.next(), obj)) {
|
|
sparseMutableListIterator.remove();
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
@Override // java.util.List, java.util.Collection
|
|
public boolean removeAll(Collection<? extends Object> collection) {
|
|
m.checkNotNullParameter(collection, "elements");
|
|
boolean z2 = false;
|
|
SparseMutableListIterator sparseMutableListIterator = new SparseMutableListIterator(this, 0, 2, null);
|
|
while (sparseMutableListIterator.hasNext()) {
|
|
if (collection.contains(sparseMutableListIterator.next())) {
|
|
sparseMutableListIterator.remove();
|
|
z2 = true;
|
|
}
|
|
}
|
|
return z2;
|
|
}
|
|
|
|
public T removeAt(int i) {
|
|
T t;
|
|
if (i < 0 || i >= size()) {
|
|
StringBuilder M = a.M("index: ", i, " -- size: ");
|
|
M.append(size());
|
|
throw new ArrayIndexOutOfBoundsException(M.toString());
|
|
}
|
|
int chunkIndex = getChunkIndex(i);
|
|
if (chunkIndex >= 0) {
|
|
t = this.chunks.get(chunkIndex).removeAtListIndex(i);
|
|
decrementChunksFromIndex(chunkIndex + 1);
|
|
} else {
|
|
int firstChunkIndexAfter = getFirstChunkIndexAfter(i);
|
|
if (firstChunkIndexAfter != -1) {
|
|
decrementChunksFromIndex(firstChunkIndexAfter);
|
|
}
|
|
t = null;
|
|
}
|
|
setSize(size() - 1);
|
|
resolveChunks();
|
|
return t;
|
|
}
|
|
|
|
@Override // java.util.List, java.util.Collection
|
|
public boolean retainAll(Collection<? extends Object> collection) {
|
|
m.checkNotNullParameter(collection, "elements");
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
|
|
@Override // java.util.List
|
|
public T set(int i, T t) {
|
|
if (i >= size()) {
|
|
setSize(i + 1);
|
|
}
|
|
int chunkIndex = getChunkIndex(i);
|
|
if (chunkIndex >= 0) {
|
|
T atListIndex = this.chunks.get(chunkIndex).setAtListIndex(i, t);
|
|
resolveChunks();
|
|
return atListIndex;
|
|
} else if (t == null) {
|
|
return null;
|
|
} else {
|
|
addChunk(Chunk.Companion.create(t, i, this.expectedChunkSize));
|
|
resolveChunks();
|
|
return null;
|
|
}
|
|
}
|
|
|
|
public void setSize(int i) {
|
|
int i2 = this.size;
|
|
if (i > i2) {
|
|
this.size = i;
|
|
} else if (i < i2) {
|
|
Iterator<T> it = this.chunks.iterator();
|
|
while (it.hasNext()) {
|
|
it.next().removeAfterInclusive(i);
|
|
}
|
|
this.size = i;
|
|
resolveChunks();
|
|
}
|
|
}
|
|
|
|
@Override // java.util.List, java.util.Collection
|
|
public final /* bridge */ int size() {
|
|
return getSize();
|
|
}
|
|
|
|
@Override // java.util.List
|
|
public List<T> subList(int i, int i2) {
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
|
|
@Override // java.util.List, java.util.Collection
|
|
public Object[] toArray() {
|
|
return g.toArray(this);
|
|
}
|
|
|
|
@Override // java.util.List, java.util.Collection
|
|
public <T> T[] toArray(T[] tArr) {
|
|
return (T[]) g.toArray(this, tArr);
|
|
}
|
|
}
|