525 lines
19 KiB
Java
525 lines
19 KiB
Java
package io.reactivex.internal.operators.observable;
|
|
|
|
import io.reactivex.ObservableSource;
|
|
import io.reactivex.Observer;
|
|
import io.reactivex.disposables.Disposable;
|
|
import io.reactivex.exceptions.Exceptions;
|
|
import io.reactivex.functions.Function;
|
|
import io.reactivex.internal.disposables.DisposableHelper;
|
|
import io.reactivex.internal.functions.ObjectHelper;
|
|
import io.reactivex.internal.fuseable.QueueDisposable;
|
|
import io.reactivex.internal.fuseable.SimplePlainQueue;
|
|
import io.reactivex.internal.fuseable.SimpleQueue;
|
|
import io.reactivex.internal.queue.SpscArrayQueue;
|
|
import io.reactivex.internal.queue.SpscLinkedArrayQueue;
|
|
import io.reactivex.internal.util.AtomicThrowable;
|
|
import io.reactivex.internal.util.ExceptionHelper;
|
|
import io.reactivex.plugins.RxJavaPlugins;
|
|
import java.util.ArrayDeque;
|
|
import java.util.Queue;
|
|
import java.util.concurrent.Callable;
|
|
import java.util.concurrent.atomic.AtomicInteger;
|
|
import java.util.concurrent.atomic.AtomicReference;
|
|
|
|
/* loaded from: classes2.dex */
|
|
public final class ObservableFlatMap<T, U> extends AbstractObservableWithUpstream<T, U> {
|
|
final Function<? super T, ? extends ObservableSource<? extends U>> b;
|
|
final boolean c;
|
|
final int d;
|
|
final int e;
|
|
|
|
static final class InnerObserver<T, U> extends AtomicReference<Disposable> implements Observer<U> {
|
|
final long a;
|
|
final MergeObserver<T, U> b;
|
|
volatile boolean c;
|
|
volatile SimpleQueue<U> d;
|
|
int e;
|
|
|
|
InnerObserver(MergeObserver<T, U> mergeObserver, long j) {
|
|
this.a = j;
|
|
this.b = mergeObserver;
|
|
}
|
|
|
|
public void a() {
|
|
DisposableHelper.dispose(this);
|
|
}
|
|
|
|
@Override // io.reactivex.Observer
|
|
public void onComplete() {
|
|
this.c = true;
|
|
this.b.c();
|
|
}
|
|
|
|
@Override // io.reactivex.Observer
|
|
public void onError(Throwable th) {
|
|
if (!this.b.h.addThrowable(th)) {
|
|
RxJavaPlugins.b(th);
|
|
return;
|
|
}
|
|
MergeObserver<T, U> mergeObserver = this.b;
|
|
if (!mergeObserver.c) {
|
|
mergeObserver.b();
|
|
}
|
|
this.c = true;
|
|
this.b.c();
|
|
}
|
|
|
|
@Override // io.reactivex.Observer
|
|
public void onNext(U u) {
|
|
if (this.e == 0) {
|
|
this.b.a(u, this);
|
|
} else {
|
|
this.b.c();
|
|
}
|
|
}
|
|
|
|
@Override // io.reactivex.Observer
|
|
public void onSubscribe(Disposable disposable) {
|
|
if (DisposableHelper.setOnce(this, disposable) && (disposable instanceof QueueDisposable)) {
|
|
QueueDisposable queueDisposable = (QueueDisposable) disposable;
|
|
int requestFusion = queueDisposable.requestFusion(7);
|
|
if (requestFusion == 1) {
|
|
this.e = requestFusion;
|
|
this.d = queueDisposable;
|
|
this.c = true;
|
|
this.b.c();
|
|
return;
|
|
}
|
|
if (requestFusion == 2) {
|
|
this.e = requestFusion;
|
|
this.d = queueDisposable;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public ObservableFlatMap(ObservableSource<T> observableSource, Function<? super T, ? extends ObservableSource<? extends U>> function, boolean z, int i, int i2) {
|
|
super(observableSource);
|
|
this.b = function;
|
|
this.c = z;
|
|
this.d = i;
|
|
this.e = i2;
|
|
}
|
|
|
|
@Override // io.reactivex.Observable
|
|
public void subscribeActual(Observer<? super U> observer) {
|
|
if (ObservableScalarXMap.a(this.a, observer, this.b)) {
|
|
return;
|
|
}
|
|
this.a.subscribe(new MergeObserver(observer, this.b, this.c, this.d, this.e));
|
|
}
|
|
|
|
static final class MergeObserver<T, U> extends AtomicInteger implements Disposable, Observer<T> {
|
|
static final InnerObserver<?, ?>[] q = new InnerObserver[0];
|
|
static final InnerObserver<?, ?>[] r = new InnerObserver[0];
|
|
final Observer<? super U> a;
|
|
final Function<? super T, ? extends ObservableSource<? extends U>> b;
|
|
final boolean c;
|
|
final int d;
|
|
final int e;
|
|
volatile SimplePlainQueue<U> f;
|
|
volatile boolean g;
|
|
final AtomicThrowable h = new AtomicThrowable();
|
|
volatile boolean i;
|
|
final AtomicReference<InnerObserver<?, ?>[]> j;
|
|
Disposable k;
|
|
long l;
|
|
long m;
|
|
int n;
|
|
Queue<ObservableSource<? extends U>> o;
|
|
int p;
|
|
|
|
MergeObserver(Observer<? super U> observer, Function<? super T, ? extends ObservableSource<? extends U>> function, boolean z, int i, int i2) {
|
|
this.a = observer;
|
|
this.b = function;
|
|
this.c = z;
|
|
this.d = i;
|
|
this.e = i2;
|
|
if (i != Integer.MAX_VALUE) {
|
|
this.o = new ArrayDeque(i);
|
|
}
|
|
this.j = new AtomicReference<>(q);
|
|
}
|
|
|
|
void a(ObservableSource<? extends U> observableSource) {
|
|
ObservableSource<? extends U> poll;
|
|
while (observableSource instanceof Callable) {
|
|
if (!a((Callable) observableSource) || this.d == Integer.MAX_VALUE) {
|
|
return;
|
|
}
|
|
boolean z = false;
|
|
synchronized (this) {
|
|
poll = this.o.poll();
|
|
if (poll == null) {
|
|
this.p--;
|
|
z = true;
|
|
}
|
|
}
|
|
if (z) {
|
|
c();
|
|
return;
|
|
}
|
|
observableSource = poll;
|
|
}
|
|
long j = this.l;
|
|
this.l = 1 + j;
|
|
InnerObserver<T, U> innerObserver = new InnerObserver<>(this, j);
|
|
if (a(innerObserver)) {
|
|
observableSource.subscribe(innerObserver);
|
|
}
|
|
}
|
|
|
|
/* JADX WARN: Multi-variable type inference failed */
|
|
void b(InnerObserver<T, U> innerObserver) {
|
|
InnerObserver<?, ?>[] innerObserverArr;
|
|
InnerObserver<?, ?>[] innerObserverArr2;
|
|
do {
|
|
innerObserverArr = this.j.get();
|
|
int length = innerObserverArr.length;
|
|
if (length == 0) {
|
|
return;
|
|
}
|
|
int i = -1;
|
|
int i2 = 0;
|
|
while (true) {
|
|
if (i2 >= length) {
|
|
break;
|
|
}
|
|
if (innerObserverArr[i2] == innerObserver) {
|
|
i = i2;
|
|
break;
|
|
}
|
|
i2++;
|
|
}
|
|
if (i < 0) {
|
|
return;
|
|
}
|
|
if (length == 1) {
|
|
innerObserverArr2 = q;
|
|
} else {
|
|
InnerObserver<?, ?>[] innerObserverArr3 = new InnerObserver[length - 1];
|
|
System.arraycopy(innerObserverArr, 0, innerObserverArr3, 0, i);
|
|
System.arraycopy(innerObserverArr, i + 1, innerObserverArr3, i, (length - i) - 1);
|
|
innerObserverArr2 = innerObserverArr3;
|
|
}
|
|
} while (!this.j.compareAndSet(innerObserverArr, innerObserverArr2));
|
|
}
|
|
|
|
void c() {
|
|
if (getAndIncrement() == 0) {
|
|
d();
|
|
}
|
|
}
|
|
|
|
/* JADX WARN: Multi-variable type inference failed */
|
|
void d() {
|
|
int i;
|
|
boolean z;
|
|
Observer<? super U> observer = this.a;
|
|
int i2 = 1;
|
|
while (!a()) {
|
|
SimplePlainQueue<U> simplePlainQueue = this.f;
|
|
if (simplePlainQueue != null) {
|
|
while (!a()) {
|
|
U poll = simplePlainQueue.poll();
|
|
if (poll != null) {
|
|
observer.onNext(poll);
|
|
} else if (poll == null) {
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
boolean z2 = this.g;
|
|
SimplePlainQueue<U> simplePlainQueue2 = this.f;
|
|
InnerObserver<?, ?>[] innerObserverArr = this.j.get();
|
|
int length = innerObserverArr.length;
|
|
if (this.d != Integer.MAX_VALUE) {
|
|
synchronized (this) {
|
|
i = this.o.size();
|
|
}
|
|
} else {
|
|
i = 0;
|
|
}
|
|
if (z2 && ((simplePlainQueue2 == null || simplePlainQueue2.isEmpty()) && length == 0 && i == 0)) {
|
|
Throwable terminate = this.h.terminate();
|
|
if (terminate != ExceptionHelper.a) {
|
|
if (terminate == null) {
|
|
observer.onComplete();
|
|
return;
|
|
} else {
|
|
observer.onError(terminate);
|
|
return;
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
if (length != 0) {
|
|
long j = this.m;
|
|
int i3 = this.n;
|
|
if (length <= i3 || innerObserverArr[i3].a != j) {
|
|
if (length <= i3) {
|
|
i3 = 0;
|
|
}
|
|
int i4 = i3;
|
|
for (int i5 = 0; i5 < length && innerObserverArr[i4].a != j; i5++) {
|
|
i4++;
|
|
if (i4 == length) {
|
|
i4 = 0;
|
|
}
|
|
}
|
|
this.n = i4;
|
|
this.m = innerObserverArr[i4].a;
|
|
i3 = i4;
|
|
}
|
|
int i6 = 0;
|
|
z = false;
|
|
while (i6 < length) {
|
|
if (a()) {
|
|
return;
|
|
}
|
|
InnerObserver<T, U> innerObserver = innerObserverArr[i3];
|
|
while (!a()) {
|
|
SimpleQueue<U> simpleQueue = innerObserver.d;
|
|
if (simpleQueue != null) {
|
|
do {
|
|
try {
|
|
U poll2 = simpleQueue.poll();
|
|
if (poll2 != null) {
|
|
observer.onNext(poll2);
|
|
} else if (poll2 == null) {
|
|
}
|
|
} catch (Throwable th) {
|
|
Exceptions.b(th);
|
|
innerObserver.a();
|
|
this.h.addThrowable(th);
|
|
if (a()) {
|
|
return;
|
|
}
|
|
b(innerObserver);
|
|
i6++;
|
|
z = true;
|
|
}
|
|
} while (!a());
|
|
return;
|
|
}
|
|
boolean z3 = innerObserver.c;
|
|
SimpleQueue<U> simpleQueue2 = innerObserver.d;
|
|
if (z3 && (simpleQueue2 == null || simpleQueue2.isEmpty())) {
|
|
b(innerObserver);
|
|
if (a()) {
|
|
return;
|
|
} else {
|
|
z = true;
|
|
}
|
|
}
|
|
i3++;
|
|
if (i3 == length) {
|
|
i3 = 0;
|
|
}
|
|
i6++;
|
|
}
|
|
return;
|
|
}
|
|
this.n = i3;
|
|
this.m = innerObserverArr[i3].a;
|
|
} else {
|
|
z = false;
|
|
}
|
|
if (!z) {
|
|
i2 = addAndGet(-i2);
|
|
if (i2 == 0) {
|
|
return;
|
|
}
|
|
} else if (this.d != Integer.MAX_VALUE) {
|
|
synchronized (this) {
|
|
ObservableSource<? extends U> poll3 = this.o.poll();
|
|
if (poll3 == null) {
|
|
this.p--;
|
|
} else {
|
|
a(poll3);
|
|
}
|
|
}
|
|
} else {
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override // io.reactivex.disposables.Disposable
|
|
public void dispose() {
|
|
Throwable terminate;
|
|
if (this.i) {
|
|
return;
|
|
}
|
|
this.i = true;
|
|
if (!b() || (terminate = this.h.terminate()) == null || terminate == ExceptionHelper.a) {
|
|
return;
|
|
}
|
|
RxJavaPlugins.b(terminate);
|
|
}
|
|
|
|
@Override // io.reactivex.Observer
|
|
public void onComplete() {
|
|
if (this.g) {
|
|
return;
|
|
}
|
|
this.g = true;
|
|
c();
|
|
}
|
|
|
|
@Override // io.reactivex.Observer
|
|
public void onError(Throwable th) {
|
|
if (this.g) {
|
|
RxJavaPlugins.b(th);
|
|
} else if (!this.h.addThrowable(th)) {
|
|
RxJavaPlugins.b(th);
|
|
} else {
|
|
this.g = true;
|
|
c();
|
|
}
|
|
}
|
|
|
|
@Override // io.reactivex.Observer
|
|
public void onNext(T t) {
|
|
if (this.g) {
|
|
return;
|
|
}
|
|
try {
|
|
ObservableSource<? extends U> apply = this.b.apply(t);
|
|
ObjectHelper.a(apply, "The mapper returned a null ObservableSource");
|
|
ObservableSource<? extends U> observableSource = apply;
|
|
if (this.d != Integer.MAX_VALUE) {
|
|
synchronized (this) {
|
|
if (this.p == this.d) {
|
|
this.o.offer(observableSource);
|
|
return;
|
|
}
|
|
this.p++;
|
|
}
|
|
}
|
|
a(observableSource);
|
|
} catch (Throwable th) {
|
|
Exceptions.b(th);
|
|
this.k.dispose();
|
|
onError(th);
|
|
}
|
|
}
|
|
|
|
@Override // io.reactivex.Observer
|
|
public void onSubscribe(Disposable disposable) {
|
|
if (DisposableHelper.validate(this.k, disposable)) {
|
|
this.k = disposable;
|
|
this.a.onSubscribe(this);
|
|
}
|
|
}
|
|
|
|
boolean b() {
|
|
InnerObserver<?, ?>[] andSet;
|
|
this.k.dispose();
|
|
InnerObserver<?, ?>[] innerObserverArr = this.j.get();
|
|
InnerObserver<?, ?>[] innerObserverArr2 = r;
|
|
if (innerObserverArr == innerObserverArr2 || (andSet = this.j.getAndSet(innerObserverArr2)) == r) {
|
|
return false;
|
|
}
|
|
for (InnerObserver<?, ?> innerObserver : andSet) {
|
|
innerObserver.a();
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/* JADX WARN: Multi-variable type inference failed */
|
|
boolean a(InnerObserver<T, U> innerObserver) {
|
|
InnerObserver<?, ?>[] innerObserverArr;
|
|
InnerObserver[] innerObserverArr2;
|
|
do {
|
|
innerObserverArr = this.j.get();
|
|
if (innerObserverArr == r) {
|
|
innerObserver.a();
|
|
return false;
|
|
}
|
|
int length = innerObserverArr.length;
|
|
innerObserverArr2 = new InnerObserver[length + 1];
|
|
System.arraycopy(innerObserverArr, 0, innerObserverArr2, 0, length);
|
|
innerObserverArr2[length] = innerObserver;
|
|
} while (!this.j.compareAndSet(innerObserverArr, innerObserverArr2));
|
|
return true;
|
|
}
|
|
|
|
boolean a(Callable<? extends U> callable) {
|
|
try {
|
|
U call = callable.call();
|
|
if (call == null) {
|
|
return true;
|
|
}
|
|
if (get() == 0 && compareAndSet(0, 1)) {
|
|
this.a.onNext(call);
|
|
if (decrementAndGet() == 0) {
|
|
return true;
|
|
}
|
|
} else {
|
|
SimplePlainQueue<U> simplePlainQueue = this.f;
|
|
if (simplePlainQueue == null) {
|
|
int i = this.d;
|
|
if (i == Integer.MAX_VALUE) {
|
|
simplePlainQueue = new SpscLinkedArrayQueue<>(this.e);
|
|
} else {
|
|
simplePlainQueue = new SpscArrayQueue(i);
|
|
}
|
|
this.f = simplePlainQueue;
|
|
}
|
|
if (!simplePlainQueue.offer(call)) {
|
|
onError(new IllegalStateException("Scalar queue full?!"));
|
|
return true;
|
|
}
|
|
if (getAndIncrement() != 0) {
|
|
return false;
|
|
}
|
|
}
|
|
d();
|
|
return true;
|
|
} catch (Throwable th) {
|
|
Exceptions.b(th);
|
|
this.h.addThrowable(th);
|
|
c();
|
|
return true;
|
|
}
|
|
}
|
|
|
|
void a(U u, InnerObserver<T, U> innerObserver) {
|
|
if (get() == 0 && compareAndSet(0, 1)) {
|
|
this.a.onNext(u);
|
|
if (decrementAndGet() == 0) {
|
|
return;
|
|
}
|
|
} else {
|
|
SimpleQueue simpleQueue = innerObserver.d;
|
|
if (simpleQueue == null) {
|
|
simpleQueue = new SpscLinkedArrayQueue(this.e);
|
|
innerObserver.d = simpleQueue;
|
|
}
|
|
simpleQueue.offer(u);
|
|
if (getAndIncrement() != 0) {
|
|
return;
|
|
}
|
|
}
|
|
d();
|
|
}
|
|
|
|
boolean a() {
|
|
if (this.i) {
|
|
return true;
|
|
}
|
|
Throwable th = this.h.get();
|
|
if (this.c || th == null) {
|
|
return false;
|
|
}
|
|
b();
|
|
Throwable terminate = this.h.terminate();
|
|
if (terminate != ExceptionHelper.a) {
|
|
this.a.onError(terminate);
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
}
|