346 lines
12 KiB
Java
346 lines
12 KiB
Java
package j0.l.a;
|
|
|
|
import j0.l.e.i;
|
|
import j0.l.e.n.e;
|
|
import j0.o.l;
|
|
import java.util.ArrayList;
|
|
import java.util.Arrays;
|
|
import java.util.Iterator;
|
|
import java.util.List;
|
|
import java.util.Queue;
|
|
import java.util.concurrent.atomic.AtomicInteger;
|
|
import java.util.concurrent.atomic.AtomicLong;
|
|
import java.util.concurrent.atomic.AtomicReference;
|
|
import rx.Observable;
|
|
import rx.Producer;
|
|
import rx.Subscriber;
|
|
import rx.Subscription;
|
|
import rx.exceptions.CompositeException;
|
|
import rx.functions.FuncN;
|
|
/* compiled from: OnSubscribeCombineLatest.java */
|
|
/* loaded from: classes3.dex */
|
|
public final class f<T, R> implements Observable.a<R> {
|
|
public final Iterable<? extends Observable<? extends T>> j;
|
|
public final FuncN<? extends R> k;
|
|
public final int l;
|
|
|
|
/* compiled from: OnSubscribeCombineLatest.java */
|
|
/* loaded from: classes3.dex */
|
|
public static final class a<T, R> extends Subscriber<T> {
|
|
public final b<T, R> j;
|
|
public final int k;
|
|
public boolean l;
|
|
|
|
public a(b<T, R> bVar, int i) {
|
|
this.j = bVar;
|
|
this.k = i;
|
|
request(bVar.bufferSize);
|
|
}
|
|
|
|
@Override // j0.g
|
|
public void onCompleted() {
|
|
if (!this.l) {
|
|
this.l = true;
|
|
this.j.c(null, this.k);
|
|
}
|
|
}
|
|
|
|
@Override // j0.g
|
|
public void onError(Throwable th) {
|
|
Throwable th2;
|
|
Throwable th3;
|
|
if (this.l) {
|
|
l.b(th);
|
|
return;
|
|
}
|
|
AtomicReference<Throwable> atomicReference = this.j.error;
|
|
do {
|
|
th2 = atomicReference.get();
|
|
if (th2 == null) {
|
|
th3 = th;
|
|
} else if (th2 instanceof CompositeException) {
|
|
ArrayList arrayList = new ArrayList(((CompositeException) th2).b());
|
|
arrayList.add(th);
|
|
th3 = new CompositeException(arrayList);
|
|
} else {
|
|
th3 = new CompositeException(Arrays.asList(th2, th));
|
|
}
|
|
} while (!atomicReference.compareAndSet(th2, th3));
|
|
this.l = true;
|
|
this.j.c(null, this.k);
|
|
}
|
|
|
|
@Override // j0.g
|
|
public void onNext(T t) {
|
|
if (!this.l) {
|
|
b<T, R> bVar = this.j;
|
|
if (t == null) {
|
|
t = (T) e.f3753b;
|
|
}
|
|
bVar.c(t, this.k);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* compiled from: OnSubscribeCombineLatest.java */
|
|
/* loaded from: classes3.dex */
|
|
public static final class b<T, R> extends AtomicInteger implements Producer, Subscription {
|
|
public static final Object j = new Object();
|
|
private static final long serialVersionUID = 8567835998786448817L;
|
|
public int active;
|
|
public final Subscriber<? super R> actual;
|
|
public final int bufferSize;
|
|
public volatile boolean cancelled;
|
|
public final FuncN<? extends R> combiner;
|
|
public int complete;
|
|
public final boolean delayError;
|
|
public volatile boolean done;
|
|
public final Object[] latest;
|
|
public final e<Object> queue;
|
|
public final a<T, R>[] subscribers;
|
|
public final AtomicLong requested = new AtomicLong();
|
|
public final AtomicReference<Throwable> error = new AtomicReference<>();
|
|
|
|
public b(Subscriber<? super R> subscriber, FuncN<? extends R> funcN, int i, int i2, boolean z2) {
|
|
this.actual = subscriber;
|
|
this.combiner = funcN;
|
|
this.bufferSize = i2;
|
|
this.delayError = z2;
|
|
Object[] objArr = new Object[i];
|
|
this.latest = objArr;
|
|
Arrays.fill(objArr, j);
|
|
this.subscribers = new a[i];
|
|
this.queue = new e<>(i2);
|
|
}
|
|
|
|
public void a(Queue<?> queue) {
|
|
queue.clear();
|
|
for (a<T, R> aVar : this.subscribers) {
|
|
aVar.unsubscribe();
|
|
}
|
|
}
|
|
|
|
public boolean b(boolean z2, boolean z3, Subscriber<?> subscriber, Queue<?> queue, boolean z4) {
|
|
if (this.cancelled) {
|
|
a(queue);
|
|
return true;
|
|
} else if (!z2) {
|
|
return false;
|
|
} else {
|
|
if (!z4) {
|
|
Throwable th = this.error.get();
|
|
if (th != null) {
|
|
a(queue);
|
|
subscriber.onError(th);
|
|
return true;
|
|
} else if (!z3) {
|
|
return false;
|
|
} else {
|
|
subscriber.onCompleted();
|
|
return true;
|
|
}
|
|
} else if (!z3) {
|
|
return false;
|
|
} else {
|
|
Throwable th2 = this.error.get();
|
|
if (th2 != null) {
|
|
subscriber.onError(th2);
|
|
} else {
|
|
subscriber.onCompleted();
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
public void c(Object obj, int i) {
|
|
boolean z2;
|
|
a<T, R> aVar = this.subscribers[i];
|
|
synchronized (this) {
|
|
Object[] objArr = this.latest;
|
|
int length = objArr.length;
|
|
Object obj2 = objArr[i];
|
|
int i2 = this.active;
|
|
Object obj3 = j;
|
|
if (obj2 == obj3) {
|
|
i2++;
|
|
this.active = i2;
|
|
}
|
|
int i3 = this.complete;
|
|
if (obj == null) {
|
|
i3++;
|
|
this.complete = i3;
|
|
} else {
|
|
objArr[i] = e.b(obj);
|
|
}
|
|
boolean z3 = false;
|
|
z2 = i2 == length;
|
|
if (i3 == length || (obj == null && obj2 == obj3)) {
|
|
z3 = true;
|
|
}
|
|
if (z3) {
|
|
this.done = true;
|
|
} else if (obj != null && z2) {
|
|
this.queue.e(aVar, this.latest.clone());
|
|
} else if (obj == null && this.error.get() != null && (obj2 == obj3 || !this.delayError)) {
|
|
this.done = true;
|
|
}
|
|
}
|
|
if (z2 || obj == null) {
|
|
d();
|
|
} else {
|
|
aVar.request(1L);
|
|
}
|
|
}
|
|
|
|
/* JADX WARN: Code restructure failed: missing block: B:32:0x0093, code lost:
|
|
if (r3 == 0) goto L_0x00a1;
|
|
*/
|
|
/* JADX WARN: Code restructure failed: missing block: B:34:0x009c, code lost:
|
|
if (r13 == androidx.recyclerview.widget.RecyclerView.FOREVER_NS) goto L_0x00a1;
|
|
*/
|
|
/* JADX WARN: Code restructure failed: missing block: B:35:0x009e, code lost:
|
|
b.i.a.f.e.o.f.U0(r10, r3);
|
|
*/
|
|
/* JADX WARN: Code restructure failed: missing block: B:36:0x00a1, code lost:
|
|
r12 = addAndGet(-r12);
|
|
*/
|
|
/* JADX WARN: Code restructure failed: missing block: B:37:0x00a6, code lost:
|
|
if (r12 != 0) goto L_0x0013;
|
|
*/
|
|
/* JADX WARN: Code restructure failed: missing block: B:38:0x00a8, code lost:
|
|
return;
|
|
*/
|
|
/*
|
|
Code decompiled incorrectly, please refer to instructions dump.
|
|
*/
|
|
public void d() {
|
|
long j2;
|
|
if (getAndIncrement() == 0) {
|
|
e<Object> eVar = this.queue;
|
|
Subscriber<? super R> subscriber = this.actual;
|
|
boolean z2 = this.delayError;
|
|
AtomicLong atomicLong = this.requested;
|
|
int i = 1;
|
|
while (!b(this.done, eVar.isEmpty(), subscriber, eVar, z2)) {
|
|
long j3 = atomicLong.get();
|
|
long j4 = 0;
|
|
while (true) {
|
|
if (j4 == j3) {
|
|
j2 = j4;
|
|
break;
|
|
}
|
|
boolean z3 = this.done;
|
|
a aVar = (a) eVar.peek();
|
|
boolean z4 = aVar == null;
|
|
if (!b(z3, z4, subscriber, eVar, z2)) {
|
|
if (z4) {
|
|
j2 = j4;
|
|
break;
|
|
}
|
|
eVar.poll();
|
|
Object[] objArr = (Object[]) eVar.poll();
|
|
if (objArr == null) {
|
|
this.cancelled = true;
|
|
a(eVar);
|
|
subscriber.onError(new IllegalStateException("Broken queue?! Sender received but not the array."));
|
|
return;
|
|
}
|
|
try {
|
|
subscriber.onNext((Object) this.combiner.call(objArr));
|
|
aVar.request(1L);
|
|
j4++;
|
|
} catch (Throwable th) {
|
|
this.cancelled = true;
|
|
a(eVar);
|
|
subscriber.onError(th);
|
|
return;
|
|
}
|
|
} else {
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override // rx.Subscription
|
|
public boolean isUnsubscribed() {
|
|
return this.cancelled;
|
|
}
|
|
|
|
@Override // rx.Producer
|
|
public void j(long j2) {
|
|
int i = (j2 > 0L ? 1 : (j2 == 0L ? 0 : -1));
|
|
if (i < 0) {
|
|
throw new IllegalArgumentException(b.d.b.a.a.s("n >= required but it was ", j2));
|
|
} else if (i != 0) {
|
|
b.i.a.f.e.o.f.c0(this.requested, j2);
|
|
d();
|
|
}
|
|
}
|
|
|
|
@Override // rx.Subscription
|
|
public void unsubscribe() {
|
|
if (!this.cancelled) {
|
|
this.cancelled = true;
|
|
if (getAndIncrement() == 0) {
|
|
a(this.queue);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public f(Iterable<? extends Observable<? extends T>> iterable, FuncN<? extends R> funcN) {
|
|
int i = i.j;
|
|
this.j = iterable;
|
|
this.k = funcN;
|
|
this.l = i;
|
|
}
|
|
|
|
@Override // rx.functions.Action1
|
|
public void call(Object obj) {
|
|
Observable[] observableArr;
|
|
int i;
|
|
Subscriber subscriber = (Subscriber) obj;
|
|
Iterable<? extends Observable<? extends T>> iterable = this.j;
|
|
if (iterable instanceof List) {
|
|
List list = (List) iterable;
|
|
observableArr = (Observable[]) list.toArray(new Observable[list.size()]);
|
|
i = observableArr.length;
|
|
} else {
|
|
Observable[] observableArr2 = new Observable[8];
|
|
Iterator<? extends Observable<? extends T>> it = iterable.iterator();
|
|
int i2 = 0;
|
|
while (it.hasNext()) {
|
|
Observable observable = (Observable) it.next();
|
|
if (i2 == observableArr2.length) {
|
|
Observable[] observableArr3 = new Observable[(i2 >> 2) + i2];
|
|
System.arraycopy(observableArr2, 0, observableArr3, 0, i2);
|
|
observableArr2 = observableArr3;
|
|
}
|
|
i2++;
|
|
observableArr2[i2] = observable;
|
|
}
|
|
observableArr = observableArr2;
|
|
i = i2;
|
|
}
|
|
if (i == 0) {
|
|
subscriber.onCompleted();
|
|
return;
|
|
}
|
|
b bVar = new b(subscriber, this.k, i, this.l, false);
|
|
a<T, R>[] aVarArr = bVar.subscribers;
|
|
int length = aVarArr.length;
|
|
for (int i3 = 0; i3 < length; i3++) {
|
|
aVarArr[i3] = new a<>(bVar, i3);
|
|
}
|
|
bVar.lazySet(0);
|
|
bVar.actual.add(bVar);
|
|
bVar.actual.setProducer(bVar);
|
|
for (int i4 = 0; i4 < length && !bVar.cancelled; i4++) {
|
|
observableArr[i4].U(aVarArr[i4]);
|
|
}
|
|
}
|
|
}
|