331 lines
11 KiB
Java
331 lines
11 KiB
Java
package j0.l.a;
|
|
|
|
import j0.l.e.h;
|
|
import j0.l.e.m.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 */
|
|
public final class f<T, R> implements Observable.a<R> {
|
|
public final Iterable<? extends Observable<? extends T>> i;
|
|
public final FuncN<? extends R> j;
|
|
public final int k;
|
|
|
|
/* compiled from: OnSubscribeCombineLatest */
|
|
public static final class a<T, R> extends Subscriber<T> {
|
|
public final b<T, R> i;
|
|
public final int j;
|
|
public boolean k;
|
|
|
|
public a(b<T, R> bVar, int i) {
|
|
this.i = bVar;
|
|
this.j = i;
|
|
request((long) bVar.bufferSize);
|
|
}
|
|
|
|
@Override // j0.g
|
|
public void onCompleted() {
|
|
if (!this.k) {
|
|
this.k = true;
|
|
this.i.c(null, this.j);
|
|
}
|
|
}
|
|
|
|
@Override // j0.g
|
|
public void onError(Throwable th) {
|
|
Throwable th2;
|
|
Throwable th3;
|
|
if (this.k) {
|
|
l.b(th);
|
|
return;
|
|
}
|
|
AtomicReference<Throwable> atomicReference = this.i.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.k = true;
|
|
this.i.c(null, this.j);
|
|
}
|
|
|
|
@Override // j0.g
|
|
public void onNext(T t) {
|
|
if (!this.k) {
|
|
b<T, R> bVar = this.i;
|
|
if (t == null) {
|
|
t = (T) e.b;
|
|
}
|
|
bVar.c(t, this.j);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* compiled from: OnSubscribeCombineLatest */
|
|
public static final class b<T, R> extends AtomicInteger implements Producer, Subscription {
|
|
public static final Object i = 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 AtomicReference<Throwable> error = new AtomicReference<>();
|
|
public final Object[] latest;
|
|
public final e<Object> queue;
|
|
public final AtomicLong requested = new AtomicLong();
|
|
public final a<T, R>[] subscribers;
|
|
|
|
public b(Subscriber<? super R> subscriber, FuncN<? extends R> funcN, int i2, int i3, boolean z2) {
|
|
this.actual = subscriber;
|
|
this.combiner = funcN;
|
|
this.bufferSize = i3;
|
|
this.delayError = z2;
|
|
Object[] objArr = new Object[i2];
|
|
this.latest = objArr;
|
|
Arrays.fill(objArr, i);
|
|
this.subscribers = new a[i2];
|
|
this.queue = new e<>(i3);
|
|
}
|
|
|
|
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 i2) {
|
|
boolean z2;
|
|
a<T, R> aVar = this.subscribers[i2];
|
|
synchronized (this) {
|
|
Object[] objArr = this.latest;
|
|
int length = objArr.length;
|
|
Object obj2 = objArr[i2];
|
|
int i3 = this.active;
|
|
Object obj3 = i;
|
|
if (obj2 == obj3) {
|
|
i3++;
|
|
this.active = i3;
|
|
}
|
|
int i4 = this.complete;
|
|
if (obj == null) {
|
|
i4++;
|
|
this.complete = i4;
|
|
} else {
|
|
objArr[i2] = e.b(obj);
|
|
}
|
|
boolean z3 = false;
|
|
z2 = i3 == length;
|
|
if (i4 == 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(1);
|
|
}
|
|
}
|
|
|
|
public void d() {
|
|
long j;
|
|
if (getAndIncrement() == 0) {
|
|
e<Object> eVar = this.queue;
|
|
Subscriber<?> subscriber = this.actual;
|
|
boolean z2 = this.delayError;
|
|
AtomicLong atomicLong = this.requested;
|
|
int i2 = 1;
|
|
while (!b(this.done, eVar.isEmpty(), subscriber, eVar, z2)) {
|
|
long j2 = atomicLong.get();
|
|
long j3 = 0;
|
|
while (true) {
|
|
if (j3 == j2) {
|
|
j = j3;
|
|
break;
|
|
}
|
|
boolean z3 = this.done;
|
|
a aVar = (a) eVar.peek();
|
|
boolean z4 = aVar == null;
|
|
if (!b(z3, z4, subscriber, eVar, z2)) {
|
|
if (z4) {
|
|
j = j3;
|
|
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(1);
|
|
j3++;
|
|
} catch (Throwable th) {
|
|
this.cancelled = true;
|
|
a(eVar);
|
|
subscriber.onError(th);
|
|
return;
|
|
}
|
|
} else {
|
|
return;
|
|
}
|
|
}
|
|
if (!(j == 0 || j2 == Long.MAX_VALUE)) {
|
|
c.q.a.k.a.I(atomicLong, j);
|
|
}
|
|
i2 = addAndGet(-i2);
|
|
if (i2 == 0) {
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override // rx.Subscription
|
|
public boolean isUnsubscribed() {
|
|
return this.cancelled;
|
|
}
|
|
|
|
@Override // rx.Producer
|
|
public void j(long j) {
|
|
int i2 = (j > 0 ? 1 : (j == 0 ? 0 : -1));
|
|
if (i2 < 0) {
|
|
throw new IllegalArgumentException(c.d.b.a.a.q("n >= required but it was ", j));
|
|
} else if (i2 != 0) {
|
|
c.q.a.k.a.p(this.requested, j);
|
|
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 = h.i;
|
|
this.i = iterable;
|
|
this.j = funcN;
|
|
this.k = i;
|
|
}
|
|
|
|
/* JADX DEBUG: Multi-variable search result rejected for r9v5, resolved type: java.util.List */
|
|
/* JADX WARN: Multi-variable type inference failed */
|
|
@Override // rx.functions.Action1
|
|
public void call(Object obj) {
|
|
Observable[] observableArr;
|
|
int i;
|
|
Subscriber subscriber = (Subscriber) obj;
|
|
Iterable<? extends Observable<? extends T>> iterable = this.i;
|
|
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;
|
|
}
|
|
observableArr2[i2] = observable;
|
|
i2++;
|
|
}
|
|
observableArr = observableArr2;
|
|
i = i2;
|
|
}
|
|
if (i == 0) {
|
|
subscriber.onCompleted();
|
|
return;
|
|
}
|
|
b bVar = new b(subscriber, this.j, i, this.k, 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]);
|
|
}
|
|
}
|
|
}
|