182 lines
5.9 KiB
Java
182 lines
5.9 KiB
Java
package d0.t;
|
|
|
|
import d0.d0.f;
|
|
import d0.z.d.m;
|
|
import java.util.Arrays;
|
|
import java.util.Iterator;
|
|
import java.util.RandomAccess;
|
|
/* compiled from: SlidingWindow.kt */
|
|
public final class l0<T> extends c<T> implements RandomAccess {
|
|
public final int j;
|
|
public int k;
|
|
public int l;
|
|
public final Object[] m;
|
|
|
|
/* compiled from: SlidingWindow.kt */
|
|
public static final class a extends b<T> {
|
|
public int k;
|
|
public int l;
|
|
public final /* synthetic */ l0 m;
|
|
|
|
public a(l0 l0Var) {
|
|
this.m = l0Var;
|
|
this.k = l0Var.size();
|
|
this.l = l0.access$getStartIndex$p(l0Var);
|
|
}
|
|
|
|
/* JADX DEBUG: Multi-variable search result rejected for r2v0, resolved type: d0.t.l0$a */
|
|
/* JADX WARN: Multi-variable type inference failed */
|
|
@Override // d0.t.b
|
|
public void a() {
|
|
if (this.k == 0) {
|
|
this.i = 3;
|
|
return;
|
|
}
|
|
b(l0.access$getBuffer$p(this.m)[this.l]);
|
|
this.l = (this.l + 1) % l0.access$getCapacity$p(this.m);
|
|
this.k--;
|
|
}
|
|
}
|
|
|
|
public l0(int i) {
|
|
this(new Object[i], 0);
|
|
}
|
|
|
|
public l0(Object[] objArr, int i) {
|
|
m.checkNotNullParameter(objArr, "buffer");
|
|
this.m = objArr;
|
|
boolean z2 = true;
|
|
if (i >= 0) {
|
|
if (i > objArr.length ? false : z2) {
|
|
this.j = objArr.length;
|
|
this.l = i;
|
|
return;
|
|
}
|
|
StringBuilder M = c.d.b.a.a.M("ring buffer filled size: ", i, " cannot be larger than the buffer size: ");
|
|
M.append(objArr.length);
|
|
throw new IllegalArgumentException(M.toString().toString());
|
|
}
|
|
throw new IllegalArgumentException(c.d.b.a.a.k("ring buffer filled size should not be negative but it is ", i).toString());
|
|
}
|
|
|
|
public static final /* synthetic */ Object[] access$getBuffer$p(l0 l0Var) {
|
|
return l0Var.m;
|
|
}
|
|
|
|
public static final /* synthetic */ int access$getCapacity$p(l0 l0Var) {
|
|
return l0Var.j;
|
|
}
|
|
|
|
public static final /* synthetic */ int access$getStartIndex$p(l0 l0Var) {
|
|
return l0Var.k;
|
|
}
|
|
|
|
@Override // d0.t.a, java.util.Collection
|
|
public final void add(T t) {
|
|
if (!isFull()) {
|
|
this.m[(size() + this.k) % access$getCapacity$p(this)] = t;
|
|
this.l = size() + 1;
|
|
return;
|
|
}
|
|
throw new IllegalStateException("ring buffer is full");
|
|
}
|
|
|
|
/* JADX DEBUG: Multi-variable search result rejected for r2v0, resolved type: d0.t.l0<T> */
|
|
/* JADX WARN: Multi-variable type inference failed */
|
|
public final l0<T> expanded(int i) {
|
|
Object[] objArr;
|
|
int i2 = this.j;
|
|
int coerceAtMost = f.coerceAtMost(i2 + (i2 >> 1) + 1, i);
|
|
if (this.k == 0) {
|
|
objArr = Arrays.copyOf(this.m, coerceAtMost);
|
|
m.checkNotNullExpressionValue(objArr, "java.util.Arrays.copyOf(this, newSize)");
|
|
} else {
|
|
objArr = toArray(new Object[coerceAtMost]);
|
|
}
|
|
return new l0<>(objArr, size());
|
|
}
|
|
|
|
@Override // d0.t.c, java.util.List
|
|
public T get(int i) {
|
|
c.i.checkElementIndex$kotlin_stdlib(i, size());
|
|
return (T) this.m[(this.k + i) % access$getCapacity$p(this)];
|
|
}
|
|
|
|
@Override // d0.t.a
|
|
public int getSize() {
|
|
return this.l;
|
|
}
|
|
|
|
public final boolean isFull() {
|
|
return size() == this.j;
|
|
}
|
|
|
|
@Override // d0.t.c, java.util.Collection, java.lang.Iterable, java.util.List
|
|
public Iterator<T> iterator() {
|
|
return new a(this);
|
|
}
|
|
|
|
public final void removeFirst(int i) {
|
|
boolean z2 = true;
|
|
if (i >= 0) {
|
|
if (i > size()) {
|
|
z2 = false;
|
|
}
|
|
if (!z2) {
|
|
StringBuilder M = c.d.b.a.a.M("n shouldn't be greater than the buffer size: n = ", i, ", size = ");
|
|
M.append(size());
|
|
throw new IllegalArgumentException(M.toString().toString());
|
|
} else if (i > 0) {
|
|
int i2 = this.k;
|
|
int access$getCapacity$p = (i2 + i) % access$getCapacity$p(this);
|
|
if (i2 > access$getCapacity$p) {
|
|
j.fill(this.m, (Object) null, i2, this.j);
|
|
j.fill(this.m, (Object) null, 0, access$getCapacity$p);
|
|
} else {
|
|
j.fill(this.m, (Object) null, i2, access$getCapacity$p);
|
|
}
|
|
this.k = access$getCapacity$p;
|
|
this.l = size() - i;
|
|
}
|
|
} else {
|
|
throw new IllegalArgumentException(c.d.b.a.a.k("n shouldn't be negative but it is ", i).toString());
|
|
}
|
|
}
|
|
|
|
/* JADX DEBUG: Multi-variable search result rejected for r1v0, resolved type: d0.t.l0<T> */
|
|
/* JADX WARN: Multi-variable type inference failed */
|
|
@Override // d0.t.a, java.util.Collection
|
|
public Object[] toArray() {
|
|
return toArray(new Object[size()]);
|
|
}
|
|
|
|
/* JADX DEBUG: Multi-variable search result rejected for r6v6, resolved type: T[] */
|
|
/* JADX DEBUG: Multi-variable search result rejected for r6v7, resolved type: T[] */
|
|
/* JADX WARN: Multi-variable type inference failed */
|
|
@Override // d0.t.a, java.util.Collection
|
|
public <T> T[] toArray(T[] tArr) {
|
|
m.checkNotNullParameter(tArr, "array");
|
|
if (tArr.length < size()) {
|
|
tArr = (T[]) Arrays.copyOf(tArr, size());
|
|
m.checkNotNullExpressionValue(tArr, "java.util.Arrays.copyOf(this, newSize)");
|
|
}
|
|
int size = size();
|
|
int i = this.k;
|
|
int i2 = 0;
|
|
int i3 = 0;
|
|
while (i3 < size && i < this.j) {
|
|
tArr[i3] = this.m[i];
|
|
i3++;
|
|
i++;
|
|
}
|
|
while (i3 < size) {
|
|
tArr[i3] = this.m[i2];
|
|
i3++;
|
|
i2++;
|
|
}
|
|
if (tArr.length > size()) {
|
|
tArr[size()] = null;
|
|
}
|
|
return tArr;
|
|
}
|
|
}
|