datalore/jimu-decompiled
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Initial commit

Browse Source
This commit is contained in:
datalore
2025-05-13 19:24:51 +02:00
commit a950f49678
10604 changed files with 932663 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
sources/io/reactivex/internal/operators/observable/AbstractObservableWithUpstream.java Normal file
View File

@@ -0,0 +1,14 @@
package io.reactivex.internal.operators.observable;
import io.reactivex.Observable;
import io.reactivex.ObservableSource;
import io.reactivex.internal.fuseable.HasUpstreamObservableSource;
/* loaded from: classes2.dex */
abstract class AbstractObservableWithUpstream<T, U> extends Observable<U> implements HasUpstreamObservableSource<T> {
protected final ObservableSource<T> a;
AbstractObservableWithUpstream(ObservableSource<T> observableSource) {
this.a = observableSource;
}
}

131
sources/io/reactivex/internal/operators/observable/BlockingObservableIterable.java Normal file
View File

@@ -0,0 +1,131 @@
package io.reactivex.internal.operators.observable;
import io.reactivex.ObservableSource;
import io.reactivex.Observer;
import io.reactivex.disposables.Disposable;
import io.reactivex.internal.disposables.DisposableHelper;
import io.reactivex.internal.queue.SpscLinkedArrayQueue;
import io.reactivex.internal.util.BlockingHelper;
import io.reactivex.internal.util.ExceptionHelper;
import java.util.Iterator;
import java.util.NoSuchElementException;
import java.util.concurrent.atomic.AtomicReference;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/* loaded from: classes2.dex */
public final class BlockingObservableIterable<T> implements Iterable<T> {
final ObservableSource<? extends T> a;
final int b;
static final class BlockingObservableIterator<T> extends AtomicReference<Disposable> implements Observer<T>, Iterator<T>, Disposable {
final SpscLinkedArrayQueue<T> a;
final Lock b = new ReentrantLock();
final Condition c = this.b.newCondition();
volatile boolean d;
Throwable e;
BlockingObservableIterator(int i) {
this.a = new SpscLinkedArrayQueue<>(i);
}
void a() {
this.b.lock();
try {
this.c.signalAll();
} finally {
this.b.unlock();
}
}
@Override // io.reactivex.disposables.Disposable
public void dispose() {
DisposableHelper.dispose(this);
}
@Override // java.util.Iterator
public boolean hasNext() {
while (true) {
boolean z = this.d;
boolean isEmpty = this.a.isEmpty();
if (z) {
Throwable th = this.e;
if (th != null) {
throw ExceptionHelper.a(th);
}
if (isEmpty) {
return false;
}
}
if (!isEmpty) {
return true;
}
try {
BlockingHelper.a();
this.b.lock();
while (!this.d && this.a.isEmpty()) {
try {
this.c.await();
} finally {
}
}
this.b.unlock();
} catch (InterruptedException e) {
DisposableHelper.dispose(this);
a();
throw ExceptionHelper.a(e);
}
}
}
@Override // java.util.Iterator
public T next() {
if (hasNext()) {
return this.a.poll();
}
throw new NoSuchElementException();
}
@Override // io.reactivex.Observer
public void onComplete() {
this.d = true;
a();
}
@Override // io.reactivex.Observer
public void onError(Throwable th) {
this.e = th;
this.d = true;
a();
}
@Override // io.reactivex.Observer
public void onNext(T t) {
this.a.offer(t);
a();
}
@Override // io.reactivex.Observer
public void onSubscribe(Disposable disposable) {
DisposableHelper.setOnce(this, disposable);
}
@Override // java.util.Iterator
public void remove() {
throw new UnsupportedOperationException("remove");
}
}
public BlockingObservableIterable(ObservableSource<? extends T> observableSource, int i) {
this.a = observableSource;
this.b = i;
}
@Override // java.lang.Iterable
public Iterator<T> iterator() {
BlockingObservableIterator blockingObservableIterator = new BlockingObservableIterator(this.b);
this.a.subscribe(blockingObservableIterator);
return blockingObservableIterator;
}
}

94
sources/io/reactivex/internal/operators/observable/BlockingObservableLatest.java Normal file
View File

@@ -0,0 +1,94 @@
package io.reactivex.internal.operators.observable;
import io.reactivex.Notification;
import io.reactivex.Observable;
import io.reactivex.ObservableSource;
import io.reactivex.internal.util.BlockingHelper;
import io.reactivex.internal.util.ExceptionHelper;
import io.reactivex.observers.DisposableObserver;
import io.reactivex.plugins.RxJavaPlugins;
import java.util.Iterator;
import java.util.NoSuchElementException;
import java.util.concurrent.Semaphore;
import java.util.concurrent.atomic.AtomicReference;
/* loaded from: classes2.dex */
public final class BlockingObservableLatest<T> implements Iterable<T> {
final ObservableSource<T> a;
static final class BlockingObservableLatestIterator<T> extends DisposableObserver<Notification<T>> implements Iterator<T> {
Notification<T> b;
final Semaphore c = new Semaphore(0);
final AtomicReference<Notification<T>> d = new AtomicReference<>();
BlockingObservableLatestIterator() {
}
@Override // io.reactivex.Observer
/* renamed from: a, reason: merged with bridge method [inline-methods] */
public void onNext(Notification<T> notification) {
if (this.d.getAndSet(notification) == null) {
this.c.release();
}
}
@Override // java.util.Iterator
public boolean hasNext() {
Notification<T> notification = this.b;
if (notification != null && notification.d()) {
throw ExceptionHelper.a(this.b.a());
}
if (this.b == null) {
try {
BlockingHelper.a();
this.c.acquire();
Notification<T> andSet = this.d.getAndSet(null);
this.b = andSet;
if (andSet.d()) {
throw ExceptionHelper.a(andSet.a());
}
} catch (InterruptedException e) {
dispose();
this.b = Notification.a((Throwable) e);
throw ExceptionHelper.a(e);
}
}
return this.b.e();
}
@Override // java.util.Iterator
public T next() {
if (!hasNext()) {
throw new NoSuchElementException();
}
T b = this.b.b();
this.b = null;
return b;
}
@Override // io.reactivex.Observer
public void onComplete() {
}
@Override // io.reactivex.Observer
public void onError(Throwable th) {
RxJavaPlugins.b(th);
}
@Override // java.util.Iterator
public void remove() {
throw new UnsupportedOperationException("Read-only iterator.");
}
}
public BlockingObservableLatest(ObservableSource<T> observableSource) {
this.a = observableSource;
}
@Override // java.lang.Iterable
public Iterator<T> iterator() {
BlockingObservableLatestIterator blockingObservableLatestIterator = new BlockingObservableLatestIterator();
Observable.wrap(this.a).materialize().subscribe(blockingObservableLatestIterator);
return blockingObservableLatestIterator;
}
}

89
sources/io/reactivex/internal/operators/observable/BlockingObservableMostRecent.java Normal file
View File

@@ -0,0 +1,89 @@
package io.reactivex.internal.operators.observable;
import io.reactivex.ObservableSource;
import io.reactivex.internal.util.ExceptionHelper;
import io.reactivex.internal.util.NotificationLite;
import io.reactivex.observers.DefaultObserver;
import java.util.Iterator;
import java.util.NoSuchElementException;
/* loaded from: classes2.dex */
public final class BlockingObservableMostRecent<T> implements Iterable<T> {
final ObservableSource<T> a;
final T b;
static final class MostRecentObserver<T> extends DefaultObserver<T> {
volatile Object b;
final class Iterator implements java.util.Iterator<T> {
private Object a;
Iterator() {
}
@Override // java.util.Iterator
public boolean hasNext() {
this.a = MostRecentObserver.this.b;
return !NotificationLite.isComplete(this.a);
}
@Override // java.util.Iterator
public T next() {
try {
if (this.a == null) {
this.a = MostRecentObserver.this.b;
}
if (NotificationLite.isComplete(this.a)) {
throw new NoSuchElementException();
}
if (NotificationLite.isError(this.a)) {
throw ExceptionHelper.a(NotificationLite.getError(this.a));
}
return (T) NotificationLite.getValue(this.a);
} finally {
this.a = null;
}
}
@Override // java.util.Iterator
public void remove() {
throw new UnsupportedOperationException("Read only iterator");
}
}
MostRecentObserver(T t) {
this.b = NotificationLite.next(t);
}
public MostRecentObserver<T>.Iterator b() {
return new Iterator();
}
@Override // io.reactivex.Observer
public void onComplete() {
this.b = NotificationLite.complete();
}
@Override // io.reactivex.Observer
public void onError(Throwable th) {
this.b = NotificationLite.error(th);
}
@Override // io.reactivex.Observer
public void onNext(T t) {
this.b = NotificationLite.next(t);
}
}
public BlockingObservableMostRecent(ObservableSource<T> observableSource, T t) {
this.a = observableSource;
this.b = t;
}
@Override // java.lang.Iterable
public Iterator<T> iterator() {
MostRecentObserver mostRecentObserver = new MostRecentObserver(this.b);
this.a.subscribe(mostRecentObserver);
return mostRecentObserver.b();
}
}

138
sources/io/reactivex/internal/operators/observable/BlockingObservableNext.java Normal file
View File

@@ -0,0 +1,138 @@
package io.reactivex.internal.operators.observable;
import io.reactivex.Notification;
import io.reactivex.ObservableSource;
import io.reactivex.internal.util.BlockingHelper;
import io.reactivex.internal.util.ExceptionHelper;
import io.reactivex.observers.DisposableObserver;
import io.reactivex.plugins.RxJavaPlugins;
import java.util.Iterator;
import java.util.NoSuchElementException;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.atomic.AtomicInteger;
/* loaded from: classes2.dex */
public final class BlockingObservableNext<T> implements Iterable<T> {
final ObservableSource<T> a;
static final class NextIterator<T> implements Iterator<T> {
private final NextObserver<T> a;
private final ObservableSource<T> b;
private T c;
private boolean d = true;
private boolean e = true;
private Throwable f;
private boolean g;
NextIterator(ObservableSource<T> observableSource, NextObserver<T> nextObserver) {
this.b = observableSource;
this.a = nextObserver;
}
private boolean a() {
if (!this.g) {
this.g = true;
this.a.b();
new ObservableMaterialize(this.b).subscribe(this.a);
}
try {
Notification<T> c = this.a.c();
if (c.e()) {
this.e = false;
this.c = c.b();
return true;
}
this.d = false;
if (c.c()) {
return false;
}
this.f = c.a();
throw ExceptionHelper.a(this.f);
} catch (InterruptedException e) {
this.a.dispose();
this.f = e;
throw ExceptionHelper.a(e);
}
}
@Override // java.util.Iterator
public boolean hasNext() {
Throwable th = this.f;
if (th != null) {
throw ExceptionHelper.a(th);
}
if (this.d) {
return !this.e || a();
}
return false;
}
@Override // java.util.Iterator
public T next() {
Throwable th = this.f;
if (th != null) {
throw ExceptionHelper.a(th);
}
if (!hasNext()) {
throw new NoSuchElementException("No more elements");
}
this.e = true;
return this.c;
}
@Override // java.util.Iterator
public void remove() {
throw new UnsupportedOperationException("Read only iterator");
}
}
static final class NextObserver<T> extends DisposableObserver<Notification<T>> {
private final BlockingQueue<Notification<T>> b = new ArrayBlockingQueue(1);
final AtomicInteger c = new AtomicInteger();
NextObserver() {
}
@Override // io.reactivex.Observer
/* renamed from: a, reason: merged with bridge method [inline-methods] */
public void onNext(Notification<T> notification) {
if (this.c.getAndSet(0) == 1 || !notification.e()) {
while (!this.b.offer(notification)) {
Notification<T> poll = this.b.poll();
if (poll != null && !poll.e()) {
notification = poll;
}
}
}
}
void b() {
this.c.set(1);
}
public Notification<T> c() throws InterruptedException {
b();
BlockingHelper.a();
return this.b.take();
}
@Override // io.reactivex.Observer
public void onComplete() {
}
@Override // io.reactivex.Observer
public void onError(Throwable th) {
RxJavaPlugins.b(th);
}
}
public BlockingObservableNext(ObservableSource<T> observableSource) {
this.a = observableSource;
}
@Override // java.lang.Iterable
public Iterator<T> iterator() {
return new NextIterator(this.a, new NextObserver());
}
}

89
sources/io/reactivex/internal/operators/observable/ObservableAll.java Normal file
View File

@@ -0,0 +1,89 @@
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.Predicate;
import io.reactivex.internal.disposables.DisposableHelper;
import io.reactivex.plugins.RxJavaPlugins;
/* loaded from: classes2.dex */
public final class ObservableAll<T> extends AbstractObservableWithUpstream<T, Boolean> {
final Predicate<? super T> b;
static final class AllObserver<T> implements Observer<T>, Disposable {
final Observer<? super Boolean> a;
final Predicate<? super T> b;
Disposable c;
boolean d;
AllObserver(Observer<? super Boolean> observer, Predicate<? super T> predicate) {
this.a = observer;
this.b = predicate;
}
@Override // io.reactivex.disposables.Disposable
public void dispose() {
this.c.dispose();
}
@Override // io.reactivex.Observer
public void onComplete() {
if (this.d) {
return;
}
this.d = true;
this.a.onNext(true);
this.a.onComplete();
}
@Override // io.reactivex.Observer
public void onError(Throwable th) {
if (this.d) {
RxJavaPlugins.b(th);
} else {
this.d = true;
this.a.onError(th);
}
}
@Override // io.reactivex.Observer
public void onNext(T t) {
if (this.d) {
return;
}
try {
if (this.b.a(t)) {
return;
}
this.d = true;
this.c.dispose();
this.a.onNext(false);
this.a.onComplete();
} catch (Throwable th) {
Exceptions.b(th);
this.c.dispose();
onError(th);
}
}
@Override // io.reactivex.Observer
public void onSubscribe(Disposable disposable) {
if (DisposableHelper.validate(this.c, disposable)) {
this.c = disposable;
this.a.onSubscribe(this);
}
}
}
public ObservableAll(ObservableSource<T> observableSource, Predicate<? super T> predicate) {
super(observableSource);
this.b = predicate;
}
@Override // io.reactivex.Observable
protected void subscribeActual(Observer<? super Boolean> observer) {
this.a.subscribe(new AllObserver(observer, this.b));
}
}

97
sources/io/reactivex/internal/operators/observable/ObservableAllSingle.java Normal file
View File

@@ -0,0 +1,97 @@
package io.reactivex.internal.operators.observable;
import io.reactivex.Observable;
import io.reactivex.ObservableSource;
import io.reactivex.Observer;
import io.reactivex.Single;
import io.reactivex.SingleObserver;
import io.reactivex.disposables.Disposable;
import io.reactivex.exceptions.Exceptions;
import io.reactivex.functions.Predicate;
import io.reactivex.internal.disposables.DisposableHelper;
import io.reactivex.internal.fuseable.FuseToObservable;
import io.reactivex.plugins.RxJavaPlugins;
/* loaded from: classes2.dex */
public final class ObservableAllSingle<T> extends Single<Boolean> implements FuseToObservable<Boolean> {
final ObservableSource<T> a;
final Predicate<? super T> b;
static final class AllObserver<T> implements Observer<T>, Disposable {
final SingleObserver<? super Boolean> a;
final Predicate<? super T> b;
Disposable c;
boolean d;
AllObserver(SingleObserver<? super Boolean> singleObserver, Predicate<? super T> predicate) {
this.a = singleObserver;
this.b = predicate;
}
@Override // io.reactivex.disposables.Disposable
public void dispose() {
this.c.dispose();
}
@Override // io.reactivex.Observer
public void onComplete() {
if (this.d) {
return;
}
this.d = true;
this.a.onSuccess(true);
}
@Override // io.reactivex.Observer
public void onError(Throwable th) {
if (this.d) {
RxJavaPlugins.b(th);
} else {
this.d = true;
this.a.onError(th);
}
}
@Override // io.reactivex.Observer
public void onNext(T t) {
if (this.d) {
return;
}
try {
if (this.b.a(t)) {
return;
}
this.d = true;
this.c.dispose();
this.a.onSuccess(false);
} catch (Throwable th) {
Exceptions.b(th);
this.c.dispose();
onError(th);
}
}
@Override // io.reactivex.Observer
public void onSubscribe(Disposable disposable) {
if (DisposableHelper.validate(this.c, disposable)) {
this.c = disposable;
this.a.onSubscribe(this);
}
}
}
public ObservableAllSingle(ObservableSource<T> observableSource, Predicate<? super T> predicate) {
this.a = observableSource;
this.b = predicate;
}
@Override // io.reactivex.internal.fuseable.FuseToObservable
public Observable<Boolean> a() {
return RxJavaPlugins.a(new ObservableAll(this.a, this.b));
}
@Override // io.reactivex.Single
protected void b(SingleObserver<? super Boolean> singleObserver) {
this.a.subscribe(new AllObserver(singleObserver, this.b));
}
}

176
sources/io/reactivex/internal/operators/observable/ObservableAmb.java Normal file
View File

@@ -0,0 +1,176 @@
package io.reactivex.internal.operators.observable;
import io.reactivex.Observable;
import io.reactivex.ObservableSource;
import io.reactivex.Observer;
import io.reactivex.disposables.Disposable;
import io.reactivex.exceptions.Exceptions;
import io.reactivex.internal.disposables.DisposableHelper;
import io.reactivex.internal.disposables.EmptyDisposable;
import io.reactivex.plugins.RxJavaPlugins;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicReference;
/* loaded from: classes2.dex */
public final class ObservableAmb<T> extends Observable<T> {
final ObservableSource<? extends T>[] a;
final Iterable<? extends ObservableSource<? extends T>> b;
static final class AmbInnerObserver<T> extends AtomicReference<Disposable> implements Observer<T> {
final AmbCoordinator<T> a;
final int b;
final Observer<? super T> c;
boolean d;
AmbInnerObserver(AmbCoordinator<T> ambCoordinator, int i, Observer<? super T> observer) {
this.a = ambCoordinator;
this.b = i;
this.c = observer;
}
public void a() {
DisposableHelper.dispose(this);
}
@Override // io.reactivex.Observer
public void onComplete() {
if (this.d) {
this.c.onComplete();
} else if (this.a.a(this.b)) {
this.d = true;
this.c.onComplete();
}
}
@Override // io.reactivex.Observer
public void onError(Throwable th) {
if (this.d) {
this.c.onError(th);
} else if (!this.a.a(this.b)) {
RxJavaPlugins.b(th);
} else {
this.d = true;
this.c.onError(th);
}
}
@Override // io.reactivex.Observer
public void onNext(T t) {
if (this.d) {
this.c.onNext(t);
} else if (!this.a.a(this.b)) {
get().dispose();
} else {
this.d = true;
this.c.onNext(t);
}
}
@Override // io.reactivex.Observer
public void onSubscribe(Disposable disposable) {
DisposableHelper.setOnce(this, disposable);
}
}
public ObservableAmb(ObservableSource<? extends T>[] observableSourceArr, Iterable<? extends ObservableSource<? extends T>> iterable) {
this.a = observableSourceArr;
this.b = iterable;
}
@Override // io.reactivex.Observable
public void subscribeActual(Observer<? super T> observer) {
int length;
ObservableSource<? extends T>[] observableSourceArr = this.a;
if (observableSourceArr == null) {
observableSourceArr = new Observable[8];
try {
length = 0;
for (ObservableSource<? extends T> observableSource : this.b) {
if (observableSource == null) {
EmptyDisposable.error(new NullPointerException("One of the sources is null"), observer);
return;
}
if (length == observableSourceArr.length) {
ObservableSource<? extends T>[] observableSourceArr2 = new ObservableSource[(length >> 2) + length];
System.arraycopy(observableSourceArr, 0, observableSourceArr2, 0, length);
observableSourceArr = observableSourceArr2;
}
int i = length + 1;
observableSourceArr[length] = observableSource;
length = i;
}
} catch (Throwable th) {
Exceptions.b(th);
EmptyDisposable.error(th, observer);
return;
}
} else {
length = observableSourceArr.length;
}
if (length == 0) {
EmptyDisposable.complete(observer);
} else if (length == 1) {
observableSourceArr[0].subscribe(observer);
} else {
new AmbCoordinator(observer, length).a(observableSourceArr);
}
}
static final class AmbCoordinator<T> implements Disposable {
final Observer<? super T> a;
final AmbInnerObserver<T>[] b;
final AtomicInteger c = new AtomicInteger();
AmbCoordinator(Observer<? super T> observer, int i) {
this.a = observer;
this.b = new AmbInnerObserver[i];
}
public void a(ObservableSource<? extends T>[] observableSourceArr) {
AmbInnerObserver<T>[] ambInnerObserverArr = this.b;
int length = ambInnerObserverArr.length;
int i = 0;
while (i < length) {
int i2 = i + 1;
ambInnerObserverArr[i] = new AmbInnerObserver<>(this, i2, this.a);
i = i2;
}
this.c.lazySet(0);
this.a.onSubscribe(this);
for (int i3 = 0; i3 < length && this.c.get() == 0; i3++) {
observableSourceArr[i3].subscribe(ambInnerObserverArr[i3]);
}
}
@Override // io.reactivex.disposables.Disposable
public void dispose() {
if (this.c.get() != -1) {
this.c.lazySet(-1);
for (AmbInnerObserver<T> ambInnerObserver : this.b) {
ambInnerObserver.a();
}
}
}
public boolean a(int i) {
int i2 = this.c.get();
int i3 = 0;
if (i2 != 0) {
return i2 == i;
}
if (!this.c.compareAndSet(0, i)) {
return false;
}
AmbInnerObserver<T>[] ambInnerObserverArr = this.b;
int length = ambInnerObserverArr.length;
while (i3 < length) {
int i4 = i3 + 1;
if (i4 != i) {
ambInnerObserverArr[i3].a();
}
i3 = i4;
}
return true;
}
}
}

88
sources/io/reactivex/internal/operators/observable/ObservableAny.java Normal file
View File

@@ -0,0 +1,88 @@
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.Predicate;
import io.reactivex.internal.disposables.DisposableHelper;
import io.reactivex.plugins.RxJavaPlugins;
/* loaded from: classes2.dex */
public final class ObservableAny<T> extends AbstractObservableWithUpstream<T, Boolean> {
final Predicate<? super T> b;
static final class AnyObserver<T> implements Observer<T>, Disposable {
final Observer<? super Boolean> a;
final Predicate<? super T> b;
Disposable c;
boolean d;
AnyObserver(Observer<? super Boolean> observer, Predicate<? super T> predicate) {
this.a = observer;
this.b = predicate;
}
@Override // io.reactivex.disposables.Disposable
public void dispose() {
this.c.dispose();
}
@Override // io.reactivex.Observer
public void onComplete() {
if (this.d) {
return;
}
this.d = true;
this.a.onNext(false);
this.a.onComplete();
}
@Override // io.reactivex.Observer
public void onError(Throwable th) {
if (this.d) {
RxJavaPlugins.b(th);
} else {
this.d = true;
this.a.onError(th);
}
}
@Override // io.reactivex.Observer
public void onNext(T t) {
if (this.d) {
return;
}
try {
if (this.b.a(t)) {
this.d = true;
this.c.dispose();
this.a.onNext(true);
this.a.onComplete();
}
} catch (Throwable th) {
Exceptions.b(th);
this.c.dispose();
onError(th);
}
}
@Override // io.reactivex.Observer
public void onSubscribe(Disposable disposable) {
if (DisposableHelper.validate(this.c, disposable)) {
this.c = disposable;
this.a.onSubscribe(this);
}
}
}
public ObservableAny(ObservableSource<T> observableSource, Predicate<? super T> predicate) {
super(observableSource);
this.b = predicate;
}
@Override // io.reactivex.Observable
protected void subscribeActual(Observer<? super Boolean> observer) {
this.a.subscribe(new AnyObserver(observer, this.b));
}
}

96
sources/io/reactivex/internal/operators/observable/ObservableAnySingle.java Normal file
View File

@@ -0,0 +1,96 @@
package io.reactivex.internal.operators.observable;
import io.reactivex.Observable;
import io.reactivex.ObservableSource;
import io.reactivex.Observer;
import io.reactivex.Single;
import io.reactivex.SingleObserver;
import io.reactivex.disposables.Disposable;
import io.reactivex.exceptions.Exceptions;
import io.reactivex.functions.Predicate;
import io.reactivex.internal.disposables.DisposableHelper;
import io.reactivex.internal.fuseable.FuseToObservable;
import io.reactivex.plugins.RxJavaPlugins;
/* loaded from: classes2.dex */
public final class ObservableAnySingle<T> extends Single<Boolean> implements FuseToObservable<Boolean> {
final ObservableSource<T> a;
final Predicate<? super T> b;
static final class AnyObserver<T> implements Observer<T>, Disposable {
final SingleObserver<? super Boolean> a;
final Predicate<? super T> b;
Disposable c;
boolean d;
AnyObserver(SingleObserver<? super Boolean> singleObserver, Predicate<? super T> predicate) {
this.a = singleObserver;
this.b = predicate;
}
@Override // io.reactivex.disposables.Disposable
public void dispose() {
this.c.dispose();
}
@Override // io.reactivex.Observer
public void onComplete() {
if (this.d) {
return;
}
this.d = true;
this.a.onSuccess(false);
}
@Override // io.reactivex.Observer
public void onError(Throwable th) {
if (this.d) {
RxJavaPlugins.b(th);
} else {
this.d = true;
this.a.onError(th);
}
}
@Override // io.reactivex.Observer
public void onNext(T t) {
if (this.d) {
return;
}
try {
if (this.b.a(t)) {
this.d = true;
this.c.dispose();
this.a.onSuccess(true);
}
} catch (Throwable th) {
Exceptions.b(th);
this.c.dispose();
onError(th);
}
}
@Override // io.reactivex.Observer
public void onSubscribe(Disposable disposable) {
if (DisposableHelper.validate(this.c, disposable)) {
this.c = disposable;
this.a.onSubscribe(this);
}
}
}
public ObservableAnySingle(ObservableSource<T> observableSource, Predicate<? super T> predicate) {
this.a = observableSource;
this.b = predicate;
}
@Override // io.reactivex.internal.fuseable.FuseToObservable
public Observable<Boolean> a() {
return RxJavaPlugins.a(new ObservableAny(this.a, this.b));
}
@Override // io.reactivex.Single
protected void b(SingleObserver<? super Boolean> singleObserver) {
this.a.subscribe(new AnyObserver(singleObserver, this.b));
}
}

58
sources/io/reactivex/internal/operators/observable/ObservableBlockingSubscribe.java Normal file
View File

@@ -0,0 +1,58 @@
package io.reactivex.internal.operators.observable;
import io.reactivex.ObservableSource;
import io.reactivex.Observer;
import io.reactivex.functions.Action;
import io.reactivex.functions.Consumer;
import io.reactivex.internal.functions.Functions;
import io.reactivex.internal.functions.ObjectHelper;
import io.reactivex.internal.observers.BlockingObserver;
import io.reactivex.internal.observers.LambdaObserver;
import io.reactivex.internal.util.BlockingHelper;
import io.reactivex.internal.util.BlockingIgnoringReceiver;
import io.reactivex.internal.util.ExceptionHelper;
import io.reactivex.internal.util.NotificationLite;
import java.util.concurrent.LinkedBlockingQueue;
/* loaded from: classes2.dex */
public final class ObservableBlockingSubscribe {
public static <T> void a(ObservableSource<? extends T> observableSource, Observer<? super T> observer) {
LinkedBlockingQueue linkedBlockingQueue = new LinkedBlockingQueue();
BlockingObserver blockingObserver = new BlockingObserver(linkedBlockingQueue);
observer.onSubscribe(blockingObserver);
observableSource.subscribe(blockingObserver);
while (!blockingObserver.isDisposed()) {
Object poll = linkedBlockingQueue.poll();
if (poll == null) {
try {
poll = linkedBlockingQueue.take();
} catch (InterruptedException e) {
blockingObserver.dispose();
observer.onError(e);
return;
}
}
if (blockingObserver.isDisposed() || observableSource == BlockingObserver.TERMINATED || NotificationLite.acceptFull(poll, observer)) {
return;
}
}
}
public static <T> void a(ObservableSource<? extends T> observableSource) {
BlockingIgnoringReceiver blockingIgnoringReceiver = new BlockingIgnoringReceiver();
LambdaObserver lambdaObserver = new LambdaObserver(Functions.d(), blockingIgnoringReceiver, blockingIgnoringReceiver, Functions.d());
observableSource.subscribe(lambdaObserver);
BlockingHelper.a(blockingIgnoringReceiver, lambdaObserver);
Throwable th = blockingIgnoringReceiver.a;
if (th != null) {
throw ExceptionHelper.a(th);
}
}
public static <T> void a(ObservableSource<? extends T> observableSource, Consumer<? super T> consumer, Consumer<? super Throwable> consumer2, Action action) {
ObjectHelper.a(consumer, "onNext is null");
ObjectHelper.a(consumer2, "onError is null");
ObjectHelper.a(action, "onComplete is null");
a(observableSource, new LambdaObserver(consumer, consumer2, action, Functions.d()));
}
}

194
sources/io/reactivex/internal/operators/observable/ObservableBuffer.java Normal file
View File

@@ -0,0 +1,194 @@
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.internal.disposables.DisposableHelper;
import io.reactivex.internal.disposables.EmptyDisposable;
import io.reactivex.internal.functions.ObjectHelper;
import java.util.ArrayDeque;
import java.util.Collection;
import java.util.Iterator;
import java.util.concurrent.Callable;
import java.util.concurrent.atomic.AtomicBoolean;
/* loaded from: classes2.dex */
public final class ObservableBuffer<T, U extends Collection<? super T>> extends AbstractObservableWithUpstream<T, U> {
final int b;
final int c;
final Callable<U> d;
static final class BufferExactObserver<T, U extends Collection<? super T>> implements Observer<T>, Disposable {
final Observer<? super U> a;
final int b;
final Callable<U> c;
U d;
int e;
Disposable f;
BufferExactObserver(Observer<? super U> observer, int i, Callable<U> callable) {
this.a = observer;
this.b = i;
this.c = callable;
}
boolean a() {
try {
U call = this.c.call();
ObjectHelper.a(call, "Empty buffer supplied");
this.d = call;
return true;
} catch (Throwable th) {
Exceptions.b(th);
this.d = null;
Disposable disposable = this.f;
if (disposable == null) {
EmptyDisposable.error(th, this.a);
return false;
}
disposable.dispose();
this.a.onError(th);
return false;
}
}
@Override // io.reactivex.disposables.Disposable
public void dispose() {
this.f.dispose();
}
@Override // io.reactivex.Observer
public void onComplete() {
U u = this.d;
if (u != null) {
this.d = null;
if (!u.isEmpty()) {
this.a.onNext(u);
}
this.a.onComplete();
}
}
@Override // io.reactivex.Observer
public void onError(Throwable th) {
this.d = null;
this.a.onError(th);
}
@Override // io.reactivex.Observer
public void onNext(T t) {
U u = this.d;
if (u != null) {
u.add(t);
int i = this.e + 1;
this.e = i;
if (i >= this.b) {
this.a.onNext(u);
this.e = 0;
a();
}
}
}
@Override // io.reactivex.Observer
public void onSubscribe(Disposable disposable) {
if (DisposableHelper.validate(this.f, disposable)) {
this.f = disposable;
this.a.onSubscribe(this);
}
}
}
static final class BufferSkipObserver<T, U extends Collection<? super T>> extends AtomicBoolean implements Observer<T>, Disposable {
final Observer<? super U> a;
final int b;
final int c;
final Callable<U> d;
Disposable e;
final ArrayDeque<U> f = new ArrayDeque<>();
long g;
BufferSkipObserver(Observer<? super U> observer, int i, int i2, Callable<U> callable) {
this.a = observer;
this.b = i;
this.c = i2;
this.d = callable;
}
@Override // io.reactivex.disposables.Disposable
public void dispose() {
this.e.dispose();
}
@Override // io.reactivex.Observer
public void onComplete() {
while (!this.f.isEmpty()) {
this.a.onNext(this.f.poll());
}
this.a.onComplete();
}
@Override // io.reactivex.Observer
public void onError(Throwable th) {
this.f.clear();
this.a.onError(th);
}
@Override // io.reactivex.Observer
public void onNext(T t) {
long j = this.g;
this.g = 1 + j;
if (j % this.c == 0) {
try {
U call = this.d.call();
ObjectHelper.a(call, "The bufferSupplier returned a null collection. Null values are generally not allowed in 2.x operators and sources.");
this.f.offer(call);
} catch (Throwable th) {
this.f.clear();
this.e.dispose();
this.a.onError(th);
return;
}
}
Iterator<U> it = this.f.iterator();
while (it.hasNext()) {
U next = it.next();
next.add(t);
if (this.b <= next.size()) {
it.remove();
this.a.onNext(next);
}
}
}
@Override // io.reactivex.Observer
public void onSubscribe(Disposable disposable) {
if (DisposableHelper.validate(this.e, disposable)) {
this.e = disposable;
this.a.onSubscribe(this);
}
}
}
public ObservableBuffer(ObservableSource<T> observableSource, int i, int i2, Callable<U> callable) {
super(observableSource);
this.b = i;
this.c = i2;
this.d = callable;
}
@Override // io.reactivex.Observable
protected void subscribeActual(Observer<? super U> observer) {
int i = this.c;
int i2 = this.b;
if (i != i2) {
this.a.subscribe(new BufferSkipObserver(observer, i2, i, this.d));
return;
}
BufferExactObserver bufferExactObserver = new BufferExactObserver(observer, i2, this.d);
if (bufferExactObserver.a()) {
this.a.subscribe(bufferExactObserver);
}
}
}

315
sources/io/reactivex/internal/operators/observable/ObservableBufferBoundary.java Normal file
View File

@@ -0,0 +1,315 @@
package io.reactivex.internal.operators.observable;
import io.reactivex.Observable;
import io.reactivex.ObservableSource;
import io.reactivex.Observer;
import io.reactivex.disposables.CompositeDisposable;
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.queue.SpscLinkedArrayQueue;
import io.reactivex.internal.util.AtomicThrowable;
import io.reactivex.plugins.RxJavaPlugins;
import java.util.Collection;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.concurrent.Callable;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicReference;
/* loaded from: classes2.dex */
public final class ObservableBufferBoundary<T, U extends Collection<? super T>, Open, Close> extends AbstractObservableWithUpstream<T, U> {
final Callable<U> b;
final ObservableSource<? extends Open> c;
final Function<? super Open, ? extends ObservableSource<? extends Close>> d;
static final class BufferCloseObserver<T, C extends Collection<? super T>> extends AtomicReference<Disposable> implements Observer<Object>, Disposable {
final BufferBoundaryObserver<T, C, ?, ?> a;
final long b;
BufferCloseObserver(BufferBoundaryObserver<T, C, ?, ?> bufferBoundaryObserver, long j) {
this.a = bufferBoundaryObserver;
this.b = j;
}
@Override // io.reactivex.disposables.Disposable
public void dispose() {
DisposableHelper.dispose(this);
}
@Override // io.reactivex.Observer
public void onComplete() {
Disposable disposable = get();
DisposableHelper disposableHelper = DisposableHelper.DISPOSED;
if (disposable != disposableHelper) {
lazySet(disposableHelper);
this.a.a(this, this.b);
}
}
@Override // io.reactivex.Observer
public void onError(Throwable th) {
Disposable disposable = get();
DisposableHelper disposableHelper = DisposableHelper.DISPOSED;
if (disposable == disposableHelper) {
RxJavaPlugins.b(th);
} else {
lazySet(disposableHelper);
this.a.a(this, th);
}
}
@Override // io.reactivex.Observer
public void onNext(Object obj) {
Disposable disposable = get();
DisposableHelper disposableHelper = DisposableHelper.DISPOSED;
if (disposable != disposableHelper) {
lazySet(disposableHelper);
disposable.dispose();
this.a.a(this, this.b);
}
}
@Override // io.reactivex.Observer
public void onSubscribe(Disposable disposable) {
DisposableHelper.setOnce(this, disposable);
}
}
public ObservableBufferBoundary(ObservableSource<T> observableSource, ObservableSource<? extends Open> observableSource2, Function<? super Open, ? extends ObservableSource<? extends Close>> function, Callable<U> callable) {
super(observableSource);
this.c = observableSource2;
this.d = function;
this.b = callable;
}
@Override // io.reactivex.Observable
protected void subscribeActual(Observer<? super U> observer) {
BufferBoundaryObserver bufferBoundaryObserver = new BufferBoundaryObserver(observer, this.c, this.d, this.b);
observer.onSubscribe(bufferBoundaryObserver);
this.a.subscribe(bufferBoundaryObserver);
}
static final class BufferBoundaryObserver<T, C extends Collection<? super T>, Open, Close> extends AtomicInteger implements Observer<T>, Disposable {
final Observer<? super C> a;
final Callable<C> b;
final ObservableSource<? extends Open> c;
final Function<? super Open, ? extends ObservableSource<? extends Close>> d;
volatile boolean h;
volatile boolean j;
long k;
final SpscLinkedArrayQueue<C> i = new SpscLinkedArrayQueue<>(Observable.bufferSize());
final CompositeDisposable e = new CompositeDisposable();
final AtomicReference<Disposable> f = new AtomicReference<>();
Map<Long, C> l = new LinkedHashMap();
final AtomicThrowable g = new AtomicThrowable();
static final class BufferOpenObserver<Open> extends AtomicReference<Disposable> implements Observer<Open>, Disposable {
final BufferBoundaryObserver<?, ?, Open, ?> a;
BufferOpenObserver(BufferBoundaryObserver<?, ?, Open, ?> bufferBoundaryObserver) {
this.a = bufferBoundaryObserver;
}
@Override // io.reactivex.disposables.Disposable
public void dispose() {
DisposableHelper.dispose(this);
}
@Override // io.reactivex.Observer
public void onComplete() {
lazySet(DisposableHelper.DISPOSED);
this.a.a((BufferOpenObserver) this);
}
@Override // io.reactivex.Observer
public void onError(Throwable th) {
lazySet(DisposableHelper.DISPOSED);
this.a.a(this, th);
}
@Override // io.reactivex.Observer
public void onNext(Open open) {
this.a.a((BufferBoundaryObserver<?, ?, Open, ?>) open);
}
@Override // io.reactivex.Observer
public void onSubscribe(Disposable disposable) {
DisposableHelper.setOnce(this, disposable);
}
}
BufferBoundaryObserver(Observer<? super C> observer, ObservableSource<? extends Open> observableSource, Function<? super Open, ? extends ObservableSource<? extends Close>> function, Callable<C> callable) {
this.a = observer;
this.b = callable;
this.c = observableSource;
this.d = function;
}
void a(Open open) {
try {
C call = this.b.call();
ObjectHelper.a(call, "The bufferSupplier returned a null Collection");
C c = call;
ObservableSource<? extends Close> apply = this.d.apply(open);
ObjectHelper.a(apply, "The bufferClose returned a null ObservableSource");
ObservableSource<? extends Close> observableSource = apply;
long j = this.k;
this.k = 1 + j;
synchronized (this) {
Map<Long, C> map = this.l;
if (map == null) {
return;
}
map.put(Long.valueOf(j), c);
BufferCloseObserver bufferCloseObserver = new BufferCloseObserver(this, j);
this.e.b(bufferCloseObserver);
observableSource.subscribe(bufferCloseObserver);
}
} catch (Throwable th) {
Exceptions.b(th);
DisposableHelper.dispose(this.f);
onError(th);
}
}
@Override // io.reactivex.disposables.Disposable
public void dispose() {
if (DisposableHelper.dispose(this.f)) {
this.j = true;
this.e.dispose();
synchronized (this) {
this.l = null;
}
if (getAndIncrement() != 0) {
this.i.clear();
}
}
}
@Override // io.reactivex.Observer
public void onComplete() {
this.e.dispose();
synchronized (this) {
Map<Long, C> map = this.l;
if (map == null) {
return;
}
Iterator<C> it = map.values().iterator();
while (it.hasNext()) {
this.i.offer(it.next());
}
this.l = null;
this.h = true;
a();
}
}
@Override // io.reactivex.Observer
public void onError(Throwable th) {
if (!this.g.addThrowable(th)) {
RxJavaPlugins.b(th);
return;
}
this.e.dispose();
synchronized (this) {
this.l = null;
}
this.h = true;
a();
}
@Override // io.reactivex.Observer
public void onNext(T t) {
synchronized (this) {
Map<Long, C> map = this.l;
if (map == null) {
return;
}
Iterator<C> it = map.values().iterator();
while (it.hasNext()) {
it.next().add(t);
}
}
}
@Override // io.reactivex.Observer
public void onSubscribe(Disposable disposable) {
if (DisposableHelper.setOnce(this.f, disposable)) {
BufferOpenObserver bufferOpenObserver = new BufferOpenObserver(this);
this.e.b(bufferOpenObserver);
this.c.subscribe(bufferOpenObserver);
}
}
void a(BufferOpenObserver<Open> bufferOpenObserver) {
this.e.c(bufferOpenObserver);
if (this.e.c() == 0) {
DisposableHelper.dispose(this.f);
this.h = true;
a();
}
}
void a(BufferCloseObserver<T, C> bufferCloseObserver, long j) {
boolean z;
this.e.c(bufferCloseObserver);
if (this.e.c() == 0) {
DisposableHelper.dispose(this.f);
z = true;
} else {
z = false;
}
synchronized (this) {
if (this.l == null) {
return;
}
this.i.offer(this.l.remove(Long.valueOf(j)));
if (z) {
this.h = true;
}
a();
}
}
void a(Disposable disposable, Throwable th) {
DisposableHelper.dispose(this.f);
this.e.c(disposable);
onError(th);
}
void a() {
if (getAndIncrement() != 0) {
return;
}
Observer<? super C> observer = this.a;
SpscLinkedArrayQueue<C> spscLinkedArrayQueue = this.i;
int i = 1;
while (!this.j) {
boolean z = this.h;
if (z && this.g.get() != null) {
spscLinkedArrayQueue.clear();
observer.onError(this.g.terminate());
return;
}
C poll = spscLinkedArrayQueue.poll();
boolean z2 = poll == null;
if (z && z2) {
observer.onComplete();
return;
} else if (z2) {
i = addAndGet(-i);
if (i == 0) {
return;
}
} else {
observer.onNext(poll);
}
}
spscLinkedArrayQueue.clear();
}
}
}

217
sources/io/reactivex/internal/operators/observable/ObservableBufferBoundarySupplier.java Normal file
View File

@@ -0,0 +1,217 @@
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.internal.disposables.DisposableHelper;
import io.reactivex.internal.disposables.EmptyDisposable;
import io.reactivex.internal.functions.ObjectHelper;
import io.reactivex.internal.observers.QueueDrainObserver;
import io.reactivex.internal.queue.MpscLinkedQueue;
import io.reactivex.internal.util.QueueDrainHelper;
import io.reactivex.observers.DisposableObserver;
import io.reactivex.observers.SerializedObserver;
import io.reactivex.plugins.RxJavaPlugins;
import java.util.Collection;
import java.util.concurrent.Callable;
import java.util.concurrent.atomic.AtomicReference;
/* loaded from: classes2.dex */
public final class ObservableBufferBoundarySupplier<T, U extends Collection<? super T>, B> extends AbstractObservableWithUpstream<T, U> {
final Callable<? extends ObservableSource<B>> b;
final Callable<U> c;
static final class BufferBoundaryObserver<T, U extends Collection<? super T>, B> extends DisposableObserver<B> {
final BufferBoundarySupplierObserver<T, U, B> b;
boolean c;
BufferBoundaryObserver(BufferBoundarySupplierObserver<T, U, B> bufferBoundarySupplierObserver) {
this.b = bufferBoundarySupplierObserver;
}
@Override // io.reactivex.Observer
public void onComplete() {
if (this.c) {
return;
}
this.c = true;
this.b.j();
}
@Override // io.reactivex.Observer
public void onError(Throwable th) {
if (this.c) {
RxJavaPlugins.b(th);
} else {
this.c = true;
this.b.onError(th);
}
}
@Override // io.reactivex.Observer
public void onNext(B b) {
if (this.c) {
return;
}
this.c = true;
dispose();
this.b.j();
}
}
static final class BufferBoundarySupplierObserver<T, U extends Collection<? super T>, B> extends QueueDrainObserver<T, U, U> implements Observer<T>, Disposable {
final Callable<U> g;
final Callable<? extends ObservableSource<B>> h;
Disposable i;
final AtomicReference<Disposable> j;
U k;
BufferBoundarySupplierObserver(Observer<? super U> observer, Callable<U> callable, Callable<? extends ObservableSource<B>> callable2) {
super(observer, new MpscLinkedQueue());
this.j = new AtomicReference<>();
this.g = callable;
this.h = callable2;
}
/* JADX WARN: Multi-variable type inference failed */
@Override // io.reactivex.internal.observers.QueueDrainObserver, io.reactivex.internal.util.ObservableQueueDrain
public /* bridge */ /* synthetic */ void a(Observer observer, Object obj) {
a((Observer<? super Observer>) observer, (Observer) obj);
}
@Override // io.reactivex.disposables.Disposable
public void dispose() {
if (this.d) {
return;
}
this.d = true;
this.i.dispose();
f();
if (d()) {
this.c.clear();
}
}
void f() {
DisposableHelper.dispose(this.j);
}
void j() {
try {
U call = this.g.call();
ObjectHelper.a(call, "The buffer supplied is null");
U u = call;
try {
ObservableSource<B> call2 = this.h.call();
ObjectHelper.a(call2, "The boundary ObservableSource supplied is null");
ObservableSource<B> observableSource = call2;
BufferBoundaryObserver bufferBoundaryObserver = new BufferBoundaryObserver(this);
if (DisposableHelper.replace(this.j, bufferBoundaryObserver)) {
synchronized (this) {
U u2 = this.k;
if (u2 == null) {
return;
}
this.k = u;
observableSource.subscribe(bufferBoundaryObserver);
a(u2, false, this);
}
}
} catch (Throwable th) {
Exceptions.b(th);
this.d = true;
this.i.dispose();
this.b.onError(th);
}
} catch (Throwable th2) {
Exceptions.b(th2);
dispose();
this.b.onError(th2);
}
}
@Override // io.reactivex.Observer
public void onComplete() {
synchronized (this) {
U u = this.k;
if (u == null) {
return;
}
this.k = null;
this.c.offer(u);
this.e = true;
if (d()) {
QueueDrainHelper.a(this.c, this.b, false, this, this);
}
}
}
@Override // io.reactivex.Observer
public void onError(Throwable th) {
dispose();
this.b.onError(th);
}
@Override // io.reactivex.Observer
public void onNext(T t) {
synchronized (this) {
U u = this.k;
if (u == null) {
return;
}
u.add(t);
}
}
@Override // io.reactivex.Observer
public void onSubscribe(Disposable disposable) {
if (DisposableHelper.validate(this.i, disposable)) {
this.i = disposable;
Observer<? super V> observer = this.b;
try {
U call = this.g.call();
ObjectHelper.a(call, "The buffer supplied is null");
this.k = call;
try {
ObservableSource<B> call2 = this.h.call();
ObjectHelper.a(call2, "The boundary ObservableSource supplied is null");
ObservableSource<B> observableSource = call2;
BufferBoundaryObserver bufferBoundaryObserver = new BufferBoundaryObserver(this);
this.j.set(bufferBoundaryObserver);
observer.onSubscribe(this);
if (this.d) {
return;
}
observableSource.subscribe(bufferBoundaryObserver);
} catch (Throwable th) {
Exceptions.b(th);
this.d = true;
disposable.dispose();
EmptyDisposable.error(th, observer);
}
} catch (Throwable th2) {
Exceptions.b(th2);
this.d = true;
disposable.dispose();
EmptyDisposable.error(th2, observer);
}
}
}
public void a(Observer<? super U> observer, U u) {
this.b.onNext(u);
}
}
public ObservableBufferBoundarySupplier(ObservableSource<T> observableSource, Callable<? extends ObservableSource<B>> callable, Callable<U> callable2) {
super(observableSource);
this.b = callable;
this.c = callable2;
}
@Override // io.reactivex.Observable
protected void subscribeActual(Observer<? super U> observer) {
this.a.subscribe(new BufferBoundarySupplierObserver(new SerializedObserver(observer), this.c, this.b));
}
}

170
sources/io/reactivex/internal/operators/observable/ObservableBufferExactBoundary.java Normal file
View File

@@ -0,0 +1,170 @@
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.internal.disposables.DisposableHelper;
import io.reactivex.internal.disposables.EmptyDisposable;
import io.reactivex.internal.functions.ObjectHelper;
import io.reactivex.internal.observers.QueueDrainObserver;
import io.reactivex.internal.queue.MpscLinkedQueue;
import io.reactivex.internal.util.QueueDrainHelper;
import io.reactivex.observers.DisposableObserver;
import io.reactivex.observers.SerializedObserver;
import java.util.Collection;
import java.util.concurrent.Callable;
/* loaded from: classes2.dex */
public final class ObservableBufferExactBoundary<T, U extends Collection<? super T>, B> extends AbstractObservableWithUpstream<T, U> {
final ObservableSource<B> b;
final Callable<U> c;
static final class BufferBoundaryObserver<T, U extends Collection<? super T>, B> extends DisposableObserver<B> {
final BufferExactBoundaryObserver<T, U, B> b;
BufferBoundaryObserver(BufferExactBoundaryObserver<T, U, B> bufferExactBoundaryObserver) {
this.b = bufferExactBoundaryObserver;
}
@Override // io.reactivex.Observer
public void onComplete() {
this.b.onComplete();
}
@Override // io.reactivex.Observer
public void onError(Throwable th) {
this.b.onError(th);
}
@Override // io.reactivex.Observer
public void onNext(B b) {
this.b.f();
}
}
static final class BufferExactBoundaryObserver<T, U extends Collection<? super T>, B> extends QueueDrainObserver<T, U, U> implements Observer<T>, Disposable {
final Callable<U> g;
final ObservableSource<B> h;
Disposable i;
Disposable j;
U k;
BufferExactBoundaryObserver(Observer<? super U> observer, Callable<U> callable, ObservableSource<B> observableSource) {
super(observer, new MpscLinkedQueue());
this.g = callable;
this.h = observableSource;
}
/* JADX WARN: Multi-variable type inference failed */
@Override // io.reactivex.internal.observers.QueueDrainObserver, io.reactivex.internal.util.ObservableQueueDrain
public /* bridge */ /* synthetic */ void a(Observer observer, Object obj) {
a((Observer<? super Observer>) observer, (Observer) obj);
}
@Override // io.reactivex.disposables.Disposable
public void dispose() {
if (this.d) {
return;
}
this.d = true;
this.j.dispose();
this.i.dispose();
if (d()) {
this.c.clear();
}
}
void f() {
try {
U call = this.g.call();
ObjectHelper.a(call, "The buffer supplied is null");
U u = call;
synchronized (this) {
U u2 = this.k;
if (u2 == null) {
return;
}
this.k = u;
a(u2, false, this);
}
} catch (Throwable th) {
Exceptions.b(th);
dispose();
this.b.onError(th);
}
}
@Override // io.reactivex.Observer
public void onComplete() {
synchronized (this) {
U u = this.k;
if (u == null) {
return;
}
this.k = null;
this.c.offer(u);
this.e = true;
if (d()) {
QueueDrainHelper.a(this.c, this.b, false, this, this);
}
}
}
@Override // io.reactivex.Observer
public void onError(Throwable th) {
dispose();
this.b.onError(th);
}
@Override // io.reactivex.Observer
public void onNext(T t) {
synchronized (this) {
U u = this.k;
if (u == null) {
return;
}
u.add(t);
}
}
@Override // io.reactivex.Observer
public void onSubscribe(Disposable disposable) {
if (DisposableHelper.validate(this.i, disposable)) {
this.i = disposable;
try {
U call = this.g.call();
ObjectHelper.a(call, "The buffer supplied is null");
this.k = call;
BufferBoundaryObserver bufferBoundaryObserver = new BufferBoundaryObserver(this);
this.j = bufferBoundaryObserver;
this.b.onSubscribe(this);
if (this.d) {
return;
}
this.h.subscribe(bufferBoundaryObserver);
} catch (Throwable th) {
Exceptions.b(th);
this.d = true;
disposable.dispose();
EmptyDisposable.error(th, this.b);
}
}
}
public void a(Observer<? super U> observer, U u) {
this.b.onNext(u);
}
}
public ObservableBufferExactBoundary(ObservableSource<T> observableSource, ObservableSource<B> observableSource2, Callable<U> callable) {
super(observableSource);
this.b = observableSource2;
this.c = callable;
}
@Override // io.reactivex.Observable
protected void subscribeActual(Observer<? super U> observer) {
this.a.subscribe(new BufferExactBoundaryObserver(new SerializedObserver(observer), this.c, this.b));
}
}

496
sources/io/reactivex/internal/operators/observable/ObservableBufferTimed.java Normal file
View File

@@ -0,0 +1,496 @@
package io.reactivex.internal.operators.observable;
import io.reactivex.ObservableSource;
import io.reactivex.Observer;
import io.reactivex.Scheduler;
import io.reactivex.disposables.Disposable;
import io.reactivex.exceptions.Exceptions;
import io.reactivex.internal.disposables.DisposableHelper;
import io.reactivex.internal.disposables.EmptyDisposable;
import io.reactivex.internal.functions.ObjectHelper;
import io.reactivex.internal.observers.QueueDrainObserver;
import io.reactivex.internal.queue.MpscLinkedQueue;
import io.reactivex.internal.util.QueueDrainHelper;
import io.reactivex.observers.SerializedObserver;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicReference;
/* loaded from: classes2.dex */
public final class ObservableBufferTimed<T, U extends Collection<? super T>> extends AbstractObservableWithUpstream<T, U> {
final long b;
final long c;
final TimeUnit d;
final Scheduler e;
final Callable<U> f;
final int g;
final boolean h;
static final class BufferExactBoundedObserver<T, U extends Collection<? super T>> extends QueueDrainObserver<T, U, U> implements Runnable, Disposable {
final Callable<U> g;
final long h;
final TimeUnit i;
final int j;
final boolean k;
final Scheduler.Worker l;
U m;
Disposable n;
Disposable o;
long p;
long q;
BufferExactBoundedObserver(Observer<? super U> observer, Callable<U> callable, long j, TimeUnit timeUnit, int i, boolean z, Scheduler.Worker worker) {
super(observer, new MpscLinkedQueue());
this.g = callable;
this.h = j;
this.i = timeUnit;
this.j = i;
this.k = z;
this.l = worker;
}
/* JADX WARN: Multi-variable type inference failed */
@Override // io.reactivex.internal.observers.QueueDrainObserver, io.reactivex.internal.util.ObservableQueueDrain
public /* bridge */ /* synthetic */ void a(Observer observer, Object obj) {
a((Observer<? super Observer>) observer, (Observer) obj);
}
@Override // io.reactivex.disposables.Disposable
public void dispose() {
if (this.d) {
return;
}
this.d = true;
this.o.dispose();
this.l.dispose();
synchronized (this) {
this.m = null;
}
}
@Override // io.reactivex.Observer
public void onComplete() {
U u;
this.l.dispose();
synchronized (this) {
u = this.m;
this.m = null;
}
this.c.offer(u);
this.e = true;
if (d()) {
QueueDrainHelper.a(this.c, this.b, false, this, this);
}
}
@Override // io.reactivex.Observer
public void onError(Throwable th) {
synchronized (this) {
this.m = null;
}
this.b.onError(th);
this.l.dispose();
}
@Override // io.reactivex.Observer
public void onNext(T t) {
synchronized (this) {
U u = this.m;
if (u == null) {
return;
}
u.add(t);
if (u.size() < this.j) {
return;
}
this.m = null;
this.p++;
if (this.k) {
this.n.dispose();
}
b(u, false, this);
try {
U call = this.g.call();
ObjectHelper.a(call, "The buffer supplied is null");
U u2 = call;
synchronized (this) {
this.m = u2;
this.q++;
}
if (this.k) {
Scheduler.Worker worker = this.l;
long j = this.h;
this.n = worker.a(this, j, j, this.i);
}
} catch (Throwable th) {
Exceptions.b(th);
this.b.onError(th);
dispose();
}
}
}
@Override // io.reactivex.Observer
public void onSubscribe(Disposable disposable) {
if (DisposableHelper.validate(this.o, disposable)) {
this.o = disposable;
try {
U call = this.g.call();
ObjectHelper.a(call, "The buffer supplied is null");
this.m = call;
this.b.onSubscribe(this);
Scheduler.Worker worker = this.l;
long j = this.h;
this.n = worker.a(this, j, j, this.i);
} catch (Throwable th) {
Exceptions.b(th);
disposable.dispose();
EmptyDisposable.error(th, this.b);
this.l.dispose();
}
}
}
@Override // java.lang.Runnable
public void run() {
try {
U call = this.g.call();
ObjectHelper.a(call, "The bufferSupplier returned a null buffer");
U u = call;
synchronized (this) {
U u2 = this.m;
if (u2 != null && this.p == this.q) {
this.m = u;
b(u2, false, this);
}
}
} catch (Throwable th) {
Exceptions.b(th);
dispose();
this.b.onError(th);
}
}
/* JADX WARN: Multi-variable type inference failed */
public void a(Observer<? super U> observer, U u) {
observer.onNext(u);
}
}
static final class BufferExactUnboundedObserver<T, U extends Collection<? super T>> extends QueueDrainObserver<T, U, U> implements Runnable, Disposable {
final Callable<U> g;
final long h;
final TimeUnit i;
final Scheduler j;
Disposable k;
U l;
final AtomicReference<Disposable> m;
BufferExactUnboundedObserver(Observer<? super U> observer, Callable<U> callable, long j, TimeUnit timeUnit, Scheduler scheduler) {
super(observer, new MpscLinkedQueue());
this.m = new AtomicReference<>();
this.g = callable;
this.h = j;
this.i = timeUnit;
this.j = scheduler;
}
/* JADX WARN: Multi-variable type inference failed */
@Override // io.reactivex.internal.observers.QueueDrainObserver, io.reactivex.internal.util.ObservableQueueDrain
public /* bridge */ /* synthetic */ void a(Observer observer, Object obj) {
a((Observer<? super Observer>) observer, (Observer) obj);
}
@Override // io.reactivex.disposables.Disposable
public void dispose() {
DisposableHelper.dispose(this.m);
this.k.dispose();
}
@Override // io.reactivex.Observer
public void onComplete() {
U u;
synchronized (this) {
u = this.l;
this.l = null;
}
if (u != null) {
this.c.offer(u);
this.e = true;
if (d()) {
QueueDrainHelper.a(this.c, this.b, false, null, this);
}
}
DisposableHelper.dispose(this.m);
}
@Override // io.reactivex.Observer
public void onError(Throwable th) {
synchronized (this) {
this.l = null;
}
this.b.onError(th);
DisposableHelper.dispose(this.m);
}
@Override // io.reactivex.Observer
public void onNext(T t) {
synchronized (this) {
U u = this.l;
if (u == null) {
return;
}
u.add(t);
}
}
@Override // io.reactivex.Observer
public void onSubscribe(Disposable disposable) {
if (DisposableHelper.validate(this.k, disposable)) {
this.k = disposable;
try {
U call = this.g.call();
ObjectHelper.a(call, "The buffer supplied is null");
this.l = call;
this.b.onSubscribe(this);
if (this.d) {
return;
}
Scheduler scheduler = this.j;
long j = this.h;
Disposable a = scheduler.a(this, j, j, this.i);
if (this.m.compareAndSet(null, a)) {
return;
}
a.dispose();
} catch (Throwable th) {
Exceptions.b(th);
dispose();
EmptyDisposable.error(th, this.b);
}
}
}
@Override // java.lang.Runnable
public void run() {
U u;
try {
U call = this.g.call();
ObjectHelper.a(call, "The bufferSupplier returned a null buffer");
U u2 = call;
synchronized (this) {
u = this.l;
if (u != null) {
this.l = u2;
}
}
if (u == null) {
DisposableHelper.dispose(this.m);
} else {
a(u, false, this);
}
} catch (Throwable th) {
Exceptions.b(th);
this.b.onError(th);
dispose();
}
}
public void a(Observer<? super U> observer, U u) {
this.b.onNext(u);
}
}
static final class BufferSkipBoundedObserver<T, U extends Collection<? super T>> extends QueueDrainObserver<T, U, U> implements Runnable, Disposable {
final Callable<U> g;
final long h;
final long i;
final TimeUnit j;
final Scheduler.Worker k;
final List<U> l;
Disposable m;
final class RemoveFromBuffer implements Runnable {
private final U a;
RemoveFromBuffer(U u) {
this.a = u;
}
@Override // java.lang.Runnable
public void run() {
synchronized (BufferSkipBoundedObserver.this) {
BufferSkipBoundedObserver.this.l.remove(this.a);
}
BufferSkipBoundedObserver bufferSkipBoundedObserver = BufferSkipBoundedObserver.this;
bufferSkipBoundedObserver.b(this.a, false, bufferSkipBoundedObserver.k);
}
}
final class RemoveFromBufferEmit implements Runnable {
private final U a;
RemoveFromBufferEmit(U u) {
this.a = u;
}
@Override // java.lang.Runnable
public void run() {
synchronized (BufferSkipBoundedObserver.this) {
BufferSkipBoundedObserver.this.l.remove(this.a);
}
BufferSkipBoundedObserver bufferSkipBoundedObserver = BufferSkipBoundedObserver.this;
bufferSkipBoundedObserver.b(this.a, false, bufferSkipBoundedObserver.k);
}
}
BufferSkipBoundedObserver(Observer<? super U> observer, Callable<U> callable, long j, long j2, TimeUnit timeUnit, Scheduler.Worker worker) {
super(observer, new MpscLinkedQueue());
this.g = callable;
this.h = j;
this.i = j2;
this.j = timeUnit;
this.k = worker;
this.l = new LinkedList();
}
/* JADX WARN: Multi-variable type inference failed */
@Override // io.reactivex.internal.observers.QueueDrainObserver, io.reactivex.internal.util.ObservableQueueDrain
public /* bridge */ /* synthetic */ void a(Observer observer, Object obj) {
a((Observer<? super Observer>) observer, (Observer) obj);
}
@Override // io.reactivex.disposables.Disposable
public void dispose() {
if (this.d) {
return;
}
this.d = true;
f();
this.m.dispose();
this.k.dispose();
}
void f() {
synchronized (this) {
this.l.clear();
}
}
@Override // io.reactivex.Observer
public void onComplete() {
ArrayList arrayList;
synchronized (this) {
arrayList = new ArrayList(this.l);
this.l.clear();
}
Iterator it = arrayList.iterator();
while (it.hasNext()) {
this.c.offer((Collection) it.next());
}
this.e = true;
if (d()) {
QueueDrainHelper.a(this.c, this.b, false, this.k, this);
}
}
@Override // io.reactivex.Observer
public void onError(Throwable th) {
this.e = true;
f();
this.b.onError(th);
this.k.dispose();
}
@Override // io.reactivex.Observer
public void onNext(T t) {
synchronized (this) {
Iterator<U> it = this.l.iterator();
while (it.hasNext()) {
it.next().add(t);
}
}
}
@Override // io.reactivex.Observer
public void onSubscribe(Disposable disposable) {
if (DisposableHelper.validate(this.m, disposable)) {
this.m = disposable;
try {
U call = this.g.call();
ObjectHelper.a(call, "The buffer supplied is null");
U u = call;
this.l.add(u);
this.b.onSubscribe(this);
Scheduler.Worker worker = this.k;
long j = this.i;
worker.a(this, j, j, this.j);
this.k.a(new RemoveFromBufferEmit(u), this.h, this.j);
} catch (Throwable th) {
Exceptions.b(th);
disposable.dispose();
EmptyDisposable.error(th, this.b);
this.k.dispose();
}
}
}
@Override // java.lang.Runnable
public void run() {
if (this.d) {
return;
}
try {
U call = this.g.call();
ObjectHelper.a(call, "The bufferSupplier returned a null buffer");
U u = call;
synchronized (this) {
if (this.d) {
return;
}
this.l.add(u);
this.k.a(new RemoveFromBuffer(u), this.h, this.j);
}
} catch (Throwable th) {
Exceptions.b(th);
this.b.onError(th);
dispose();
}
}
/* JADX WARN: Multi-variable type inference failed */
public void a(Observer<? super U> observer, U u) {
observer.onNext(u);
}
}
public ObservableBufferTimed(ObservableSource<T> observableSource, long j, long j2, TimeUnit timeUnit, Scheduler scheduler, Callable<U> callable, int i, boolean z) {
super(observableSource);
this.b = j;
this.c = j2;
this.d = timeUnit;
this.e = scheduler;
this.f = callable;
this.g = i;
this.h = z;
}
@Override // io.reactivex.Observable
protected void subscribeActual(Observer<? super U> observer) {
if (this.b == this.c && this.g == Integer.MAX_VALUE) {
this.a.subscribe(new BufferExactUnboundedObserver(new SerializedObserver(observer), this.f, this.b, this.d, this.e));
return;
}
Scheduler.Worker a = this.e.a();
if (this.b == this.c) {
this.a.subscribe(new BufferExactBoundedObserver(new SerializedObserver(observer), this.f, this.b, this.d, this.g, this.h, a));
} else {
this.a.subscribe(new BufferSkipBoundedObserver(new SerializedObserver(observer), this.f, this.b, this.c, this.d, a));
}
}
}

226
sources/io/reactivex/internal/operators/observable/ObservableCache.java Normal file
View File

@@ -0,0 +1,226 @@
package io.reactivex.internal.operators.observable;
import io.reactivex.Observable;
import io.reactivex.Observer;
import io.reactivex.disposables.Disposable;
import io.reactivex.internal.disposables.SequentialDisposable;
import io.reactivex.internal.functions.ObjectHelper;
import io.reactivex.internal.util.LinkedArrayList;
import io.reactivex.internal.util.NotificationLite;
import io.reactivex.plugins.RxJavaPlugins;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicReference;
/* loaded from: classes2.dex */
public final class ObservableCache<T> extends AbstractObservableWithUpstream<T, T> {
final CacheState<T> b;
final AtomicBoolean c;
static final class CacheState<T> extends LinkedArrayList implements Observer<T> {
static final ReplayDisposable[] j = new ReplayDisposable[0];
static final ReplayDisposable[] k = new ReplayDisposable[0];
final Observable<? extends T> f;
final SequentialDisposable g;
final AtomicReference<ReplayDisposable<T>[]> h;
boolean i;
CacheState(Observable<? extends T> observable, int i) {
super(i);
this.f = observable;
this.h = new AtomicReference<>(j);
this.g = new SequentialDisposable();
}
public boolean a(ReplayDisposable<T> replayDisposable) {
ReplayDisposable<T>[] replayDisposableArr;
ReplayDisposable<T>[] replayDisposableArr2;
do {
replayDisposableArr = this.h.get();
if (replayDisposableArr == k) {
return false;
}
int length = replayDisposableArr.length;
replayDisposableArr2 = new ReplayDisposable[length + 1];
System.arraycopy(replayDisposableArr, 0, replayDisposableArr2, 0, length);
replayDisposableArr2[length] = replayDisposable;
} while (!this.h.compareAndSet(replayDisposableArr, replayDisposableArr2));
return true;
}
public void b(ReplayDisposable<T> replayDisposable) {
ReplayDisposable<T>[] replayDisposableArr;
ReplayDisposable<T>[] replayDisposableArr2;
do {
replayDisposableArr = this.h.get();
int length = replayDisposableArr.length;
if (length == 0) {
return;
}
int i = -1;
int i2 = 0;
while (true) {
if (i2 >= length) {
break;
}
if (replayDisposableArr[i2].equals(replayDisposable)) {
i = i2;
break;
}
i2++;
}
if (i < 0) {
return;
}
if (length == 1) {
replayDisposableArr2 = j;
} else {
ReplayDisposable<T>[] replayDisposableArr3 = new ReplayDisposable[length - 1];
System.arraycopy(replayDisposableArr, 0, replayDisposableArr3, 0, i);
System.arraycopy(replayDisposableArr, i + 1, replayDisposableArr3, i, (length - i) - 1);
replayDisposableArr2 = replayDisposableArr3;
}
} while (!this.h.compareAndSet(replayDisposableArr, replayDisposableArr2));
}
public void c() {
this.f.subscribe(this);
}
@Override // io.reactivex.Observer
public void onComplete() {
if (this.i) {
return;
}
this.i = true;
a(NotificationLite.complete());
this.g.dispose();
for (ReplayDisposable<T> replayDisposable : this.h.getAndSet(k)) {
replayDisposable.a();
}
}
@Override // io.reactivex.Observer
public void onError(Throwable th) {
if (this.i) {
return;
}
this.i = true;
a(NotificationLite.error(th));
this.g.dispose();
for (ReplayDisposable<T> replayDisposable : this.h.getAndSet(k)) {
replayDisposable.a();
}
}
@Override // io.reactivex.Observer
public void onNext(T t) {
if (this.i) {
return;
}
a(NotificationLite.next(t));
for (ReplayDisposable<T> replayDisposable : this.h.get()) {
replayDisposable.a();
}
}
@Override // io.reactivex.Observer
public void onSubscribe(Disposable disposable) {
this.g.update(disposable);
}
}
static final class ReplayDisposable<T> extends AtomicInteger implements Disposable {
final Observer<? super T> a;
final CacheState<T> b;
Object[] c;
int d;
int e;
volatile boolean f;
ReplayDisposable(Observer<? super T> observer, CacheState<T> cacheState) {
this.a = observer;
this.b = cacheState;
}
public void a() {
if (getAndIncrement() != 0) {
return;
}
Observer<? super T> observer = this.a;
int i = 1;
while (!this.f) {
int b = this.b.b();
if (b != 0) {
Object[] objArr = this.c;
if (objArr == null) {
objArr = this.b.a();
this.c = objArr;
}
int length = objArr.length - 1;
int i2 = this.e;
int i3 = this.d;
while (i2 < b) {
if (this.f) {
return;
}
if (i3 == length) {
objArr = (Object[]) objArr[length];
i3 = 0;
}
if (NotificationLite.accept(objArr[i3], observer)) {
return;
}
i3++;
i2++;
}
if (this.f) {
return;
}
this.e = i2;
this.d = i3;
this.c = objArr;
}
i = addAndGet(-i);
if (i == 0) {
return;
}
}
}
@Override // io.reactivex.disposables.Disposable
public void dispose() {
if (this.f) {
return;
}
this.f = true;
this.b.b(this);
}
}
private ObservableCache(Observable<T> observable, CacheState<T> cacheState) {
super(observable);
this.b = cacheState;
this.c = new AtomicBoolean();
}
public static <T> Observable<T> a(Observable<T> observable) {
return a(observable, 16);
}
@Override // io.reactivex.Observable
protected void subscribeActual(Observer<? super T> observer) {
ReplayDisposable<T> replayDisposable = new ReplayDisposable<>(observer, this.b);
observer.onSubscribe(replayDisposable);
this.b.a((ReplayDisposable) replayDisposable);
if (!this.c.get() && this.c.compareAndSet(false, true)) {
this.b.c();
}
replayDisposable.a();
}
public static <T> Observable<T> a(Observable<T> observable, int i) {
ObjectHelper.a(i, "capacityHint");
return RxJavaPlugins.a(new ObservableCache(observable, new CacheState(observable, i)));
}
}

94
sources/io/reactivex/internal/operators/observable/ObservableCollect.java Normal file
View File

@@ -0,0 +1,94 @@
package io.reactivex.internal.operators.observable;
import io.reactivex.ObservableSource;
import io.reactivex.Observer;
import io.reactivex.disposables.Disposable;
import io.reactivex.functions.BiConsumer;
import io.reactivex.internal.disposables.DisposableHelper;
import io.reactivex.internal.disposables.EmptyDisposable;
import io.reactivex.internal.functions.ObjectHelper;
import io.reactivex.plugins.RxJavaPlugins;
import java.util.concurrent.Callable;
/* loaded from: classes2.dex */
public final class ObservableCollect<T, U> extends AbstractObservableWithUpstream<T, U> {
final Callable<? extends U> b;
final BiConsumer<? super U, ? super T> c;
static final class CollectObserver<T, U> implements Observer<T>, Disposable {
final Observer<? super U> a;
final BiConsumer<? super U, ? super T> b;
final U c;
Disposable d;
boolean e;
CollectObserver(Observer<? super U> observer, U u, BiConsumer<? super U, ? super T> biConsumer) {
this.a = observer;
this.b = biConsumer;
this.c = u;
}
@Override // io.reactivex.disposables.Disposable
public void dispose() {
this.d.dispose();
}
@Override // io.reactivex.Observer
public void onComplete() {
if (this.e) {
return;
}
this.e = true;
this.a.onNext(this.c);
this.a.onComplete();
}
@Override // io.reactivex.Observer
public void onError(Throwable th) {
if (this.e) {
RxJavaPlugins.b(th);
} else {
this.e = true;
this.a.onError(th);
}
}
@Override // io.reactivex.Observer
public void onNext(T t) {
if (this.e) {
return;
}
try {
this.b.a(this.c, t);
} catch (Throwable th) {
this.d.dispose();
onError(th);
}
}
@Override // io.reactivex.Observer
public void onSubscribe(Disposable disposable) {
if (DisposableHelper.validate(this.d, disposable)) {
this.d = disposable;
this.a.onSubscribe(this);
}
}
}
public ObservableCollect(ObservableSource<T> observableSource, Callable<? extends U> callable, BiConsumer<? super U, ? super T> biConsumer) {
super(observableSource);
this.b = callable;
this.c = biConsumer;
}
@Override // io.reactivex.Observable
protected void subscribeActual(Observer<? super U> observer) {
try {
U call = this.b.call();
ObjectHelper.a(call, "The initialSupplier returned a null value");
this.a.subscribe(new CollectObserver(observer, call, this.c));
} catch (Throwable th) {
EmptyDisposable.error(th, observer);
}
}
}

103
sources/io/reactivex/internal/operators/observable/ObservableCollectSingle.java Normal file
View File

@@ -0,0 +1,103 @@
package io.reactivex.internal.operators.observable;
import io.reactivex.Observable;
import io.reactivex.ObservableSource;
import io.reactivex.Observer;
import io.reactivex.Single;
import io.reactivex.SingleObserver;
import io.reactivex.disposables.Disposable;
import io.reactivex.functions.BiConsumer;
import io.reactivex.internal.disposables.DisposableHelper;
import io.reactivex.internal.disposables.EmptyDisposable;
import io.reactivex.internal.functions.ObjectHelper;
import io.reactivex.internal.fuseable.FuseToObservable;
import io.reactivex.plugins.RxJavaPlugins;
import java.util.concurrent.Callable;
/* loaded from: classes2.dex */
public final class ObservableCollectSingle<T, U> extends Single<U> implements FuseToObservable<U> {
final ObservableSource<T> a;
final Callable<? extends U> b;
final BiConsumer<? super U, ? super T> c;
static final class CollectObserver<T, U> implements Observer<T>, Disposable {
final SingleObserver<? super U> a;
final BiConsumer<? super U, ? super T> b;
final U c;
Disposable d;
boolean e;
CollectObserver(SingleObserver<? super U> singleObserver, U u, BiConsumer<? super U, ? super T> biConsumer) {
this.a = singleObserver;
this.b = biConsumer;
this.c = u;
}
@Override // io.reactivex.disposables.Disposable
public void dispose() {
this.d.dispose();
}
@Override // io.reactivex.Observer
public void onComplete() {
if (this.e) {
return;
}
this.e = true;
this.a.onSuccess(this.c);
}
@Override // io.reactivex.Observer
public void onError(Throwable th) {
if (this.e) {
RxJavaPlugins.b(th);
} else {
this.e = true;
this.a.onError(th);
}
}
@Override // io.reactivex.Observer
public void onNext(T t) {
if (this.e) {
return;
}
try {
this.b.a(this.c, t);
} catch (Throwable th) {
this.d.dispose();
onError(th);
}
}
@Override // io.reactivex.Observer
public void onSubscribe(Disposable disposable) {
if (DisposableHelper.validate(this.d, disposable)) {
this.d = disposable;
this.a.onSubscribe(this);
}
}
}
public ObservableCollectSingle(ObservableSource<T> observableSource, Callable<? extends U> callable, BiConsumer<? super U, ? super T> biConsumer) {
this.a = observableSource;
this.b = callable;
this.c = biConsumer;
}
@Override // io.reactivex.internal.fuseable.FuseToObservable
public Observable<U> a() {
return RxJavaPlugins.a(new ObservableCollect(this.a, this.b, this.c));
}
@Override // io.reactivex.Single
protected void b(SingleObserver<? super U> singleObserver) {
try {
U call = this.b.call();
ObjectHelper.a(call, "The initialSupplier returned a null value");
this.a.subscribe(new CollectObserver(singleObserver, call, this.c));
} catch (Throwable th) {
EmptyDisposable.error(th, singleObserver);
}
}
}

342
sources/io/reactivex/internal/operators/observable/ObservableCombineLatest.java Normal file
View File

@@ -0,0 +1,342 @@
package io.reactivex.internal.operators.observable;
import io.reactivex.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.disposables.EmptyDisposable;
import io.reactivex.internal.functions.ObjectHelper;
import io.reactivex.internal.queue.SpscLinkedArrayQueue;
import io.reactivex.internal.util.AtomicThrowable;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicReference;
/* loaded from: classes2.dex */
public final class ObservableCombineLatest<T, R> extends Observable<R> {
final ObservableSource<? extends T>[] a;
final Iterable<? extends ObservableSource<? extends T>> b;
final Function<? super Object[], ? extends R> c;
final int d;
final boolean e;
static final class CombinerObserver<T, R> extends AtomicReference<Disposable> implements Observer<T> {
final LatestCoordinator<T, R> a;
final int b;
CombinerObserver(LatestCoordinator<T, R> latestCoordinator, int i) {
this.a = latestCoordinator;
this.b = i;
}
public void a() {
DisposableHelper.dispose(this);
}
@Override // io.reactivex.Observer
public void onComplete() {
this.a.a(this.b);
}
@Override // io.reactivex.Observer
public void onError(Throwable th) {
this.a.a(this.b, th);
}
@Override // io.reactivex.Observer
public void onNext(T t) {
this.a.a(this.b, (int) t);
}
@Override // io.reactivex.Observer
public void onSubscribe(Disposable disposable) {
DisposableHelper.setOnce(this, disposable);
}
}
public ObservableCombineLatest(ObservableSource<? extends T>[] observableSourceArr, Iterable<? extends ObservableSource<? extends T>> iterable, Function<? super Object[], ? extends R> function, int i, boolean z) {
this.a = observableSourceArr;
this.b = iterable;
this.c = function;
this.d = i;
this.e = z;
}
@Override // io.reactivex.Observable
public void subscribeActual(Observer<? super R> observer) {
int length;
ObservableSource<? extends T>[] observableSourceArr = this.a;
if (observableSourceArr == null) {
observableSourceArr = new Observable[8];
length = 0;
for (ObservableSource<? extends T> observableSource : this.b) {
if (length == observableSourceArr.length) {
ObservableSource<? extends T>[] observableSourceArr2 = new ObservableSource[(length >> 2) + length];
System.arraycopy(observableSourceArr, 0, observableSourceArr2, 0, length);
observableSourceArr = observableSourceArr2;
}
observableSourceArr[length] = observableSource;
length++;
}
} else {
length = observableSourceArr.length;
}
int i = length;
if (i == 0) {
EmptyDisposable.complete(observer);
} else {
new LatestCoordinator(observer, this.c, i, this.d, this.e).a(observableSourceArr);
}
}
static final class LatestCoordinator<T, R> extends AtomicInteger implements Disposable {
final Observer<? super R> a;
final Function<? super Object[], ? extends R> b;
final CombinerObserver<T, R>[] c;
Object[] d;
final SpscLinkedArrayQueue<Object[]> e;
final boolean f;
volatile boolean g;
volatile boolean h;
final AtomicThrowable i = new AtomicThrowable();
int j;
int k;
LatestCoordinator(Observer<? super R> observer, Function<? super Object[], ? extends R> function, int i, int i2, boolean z) {
this.a = observer;
this.b = function;
this.f = z;
this.d = new Object[i];
CombinerObserver<T, R>[] combinerObserverArr = new CombinerObserver[i];
for (int i3 = 0; i3 < i; i3++) {
combinerObserverArr[i3] = new CombinerObserver<>(this, i3);
}
this.c = combinerObserverArr;
this.e = new SpscLinkedArrayQueue<>(i2);
}
public void a(ObservableSource<? extends T>[] observableSourceArr) {
CombinerObserver<T, R>[] combinerObserverArr = this.c;
int length = combinerObserverArr.length;
this.a.onSubscribe(this);
for (int i = 0; i < length && !this.h && !this.g; i++) {
observableSourceArr[i].subscribe(combinerObserverArr[i]);
}
}
void b() {
if (getAndIncrement() != 0) {
return;
}
SpscLinkedArrayQueue<Object[]> spscLinkedArrayQueue = this.e;
Observer<? super R> observer = this.a;
boolean z = this.f;
int i = 1;
while (!this.g) {
if (!z && this.i.get() != null) {
a();
a((SpscLinkedArrayQueue<?>) spscLinkedArrayQueue);
observer.onError(this.i.terminate());
return;
}
boolean z2 = this.h;
Object[] poll = spscLinkedArrayQueue.poll();
boolean z3 = poll == null;
if (z2 && z3) {
a((SpscLinkedArrayQueue<?>) spscLinkedArrayQueue);
Throwable terminate = this.i.terminate();
if (terminate == null) {
observer.onComplete();
return;
} else {
observer.onError(terminate);
return;
}
}
if (z3) {
i = addAndGet(-i);
if (i == 0) {
return;
}
} else {
try {
R apply = this.b.apply(poll);
ObjectHelper.a(apply, "The combiner returned a null value");
observer.onNext(apply);
} catch (Throwable th) {
Exceptions.b(th);
this.i.addThrowable(th);
a();
a((SpscLinkedArrayQueue<?>) spscLinkedArrayQueue);
observer.onError(this.i.terminate());
return;
}
}
}
a((SpscLinkedArrayQueue<?>) spscLinkedArrayQueue);
}
@Override // io.reactivex.disposables.Disposable
public void dispose() {
if (this.g) {
return;
}
this.g = true;
a();
if (getAndIncrement() == 0) {
a((SpscLinkedArrayQueue<?>) this.e);
}
}
void a() {
for (CombinerObserver<T, R> combinerObserver : this.c) {
combinerObserver.a();
}
}
void a(SpscLinkedArrayQueue<?> spscLinkedArrayQueue) {
synchronized (this) {
this.d = null;
}
spscLinkedArrayQueue.clear();
}
/* JADX WARN: Multi-variable type inference failed */
void a(int i, T t) {
boolean z;
synchronized (this) {
Object[] objArr = this.d;
if (objArr == null) {
return;
}
Object obj = objArr[i];
int i2 = this.j;
if (obj == null) {
i2++;
this.j = i2;
}
objArr[i] = t;
if (i2 == objArr.length) {
this.e.offer(objArr.clone());
z = true;
} else {
z = false;
}
if (z) {
b();
}
}
}
/* JADX WARN: Code restructure failed: missing block: B:17:0x0023, code lost:
if (r1 == r4.length) goto L18;
*/
/*
Code decompiled incorrectly, please refer to instructions dump.
To view partially-correct code enable 'Show inconsistent code' option in preferences
*/
void a(int r3, java.lang.Throwable r4) {
/*
r2 = this;
io.reactivex.internal.util.AtomicThrowable r0 = r2.i
boolean r0 = r0.addThrowable(r4)
if (r0 == 0) goto L36
boolean r4 = r2.f
r0 = 1
if (r4 == 0) goto L2c
monitor-enter(r2)
java.lang.Object[] r4 = r2.d // Catch: java.lang.Throwable -> L29
if (r4 != 0) goto L14
monitor-exit(r2) // Catch: java.lang.Throwable -> L29
return
L14:
r3 = r4[r3] // Catch: java.lang.Throwable -> L29
if (r3 != 0) goto L1a
r3 = 1
goto L1b
L1a:
r3 = 0
L1b:
if (r3 != 0) goto L25
int r1 = r2.k // Catch: java.lang.Throwable -> L29
int r1 = r1 + r0
r2.k = r1 // Catch: java.lang.Throwable -> L29
int r4 = r4.length // Catch: java.lang.Throwable -> L29
if (r1 != r4) goto L27
L25:
r2.h = r0 // Catch: java.lang.Throwable -> L29
L27:
monitor-exit(r2) // Catch: java.lang.Throwable -> L29
goto L2d
L29:
r3 = move-exception
monitor-exit(r2) // Catch: java.lang.Throwable -> L29
throw r3
L2c:
r3 = 1
L2d:
if (r3 == 0) goto L32
r2.a()
L32:
r2.b()
goto L39
L36:
io.reactivex.plugins.RxJavaPlugins.b(r4)
L39:
return
*/
throw new UnsupportedOperationException("Method not decompiled: io.reactivex.internal.operators.observable.ObservableCombineLatest.LatestCoordinator.a(int, java.lang.Throwable):void");
}
/* JADX WARN: Code restructure failed: missing block: B:13:0x0017, code lost:
if (r2 == r0.length) goto L14;
*/
/*
Code decompiled incorrectly, please refer to instructions dump.
To view partially-correct code enable 'Show inconsistent code' option in preferences
*/
void a(int r4) {
/*
r3 = this;
monitor-enter(r3)
java.lang.Object[] r0 = r3.d // Catch: java.lang.Throwable -> L25
if (r0 != 0) goto L7
monitor-exit(r3) // Catch: java.lang.Throwable -> L25
return
L7:
r4 = r0[r4] // Catch: java.lang.Throwable -> L25
r1 = 1
if (r4 != 0) goto Le
r4 = 1
goto Lf
Le:
r4 = 0
Lf:
if (r4 != 0) goto L19
int r2 = r3.k // Catch: java.lang.Throwable -> L25
int r2 = r2 + r1
r3.k = r2 // Catch: java.lang.Throwable -> L25
int r0 = r0.length // Catch: java.lang.Throwable -> L25
if (r2 != r0) goto L1b
L19:
r3.h = r1 // Catch: java.lang.Throwable -> L25
L1b:
monitor-exit(r3) // Catch: java.lang.Throwable -> L25
if (r4 == 0) goto L21
r3.a()
L21:
r3.b()
return
L25:
r4 = move-exception
monitor-exit(r3) // Catch: java.lang.Throwable -> L25
throw r4
*/
throw new UnsupportedOperationException("Method not decompiled: io.reactivex.internal.operators.observable.ObservableCombineLatest.LatestCoordinator.a(int):void");
}
}
}

424
sources/io/reactivex/internal/operators/observable/ObservableConcatMap.java Normal file
View File

@@ -0,0 +1,424 @@
package io.reactivex.internal.operators.observable;
import android.Manifest;
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.SimpleQueue;
import io.reactivex.internal.queue.SpscLinkedArrayQueue;
import io.reactivex.internal.util.AtomicThrowable;
import io.reactivex.internal.util.ErrorMode;
import io.reactivex.observers.SerializedObserver;
import io.reactivex.plugins.RxJavaPlugins;
import java.util.concurrent.Callable;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicReference;
/* loaded from: classes2.dex */
public final class ObservableConcatMap<T, U> extends AbstractObservableWithUpstream<T, U> {
final Function<? super T, ? extends ObservableSource<? extends U>> b;
final int c;
final ErrorMode d;
static final class ConcatMapDelayErrorObserver<T, R> extends AtomicInteger implements Observer<T>, Disposable {
final Observer<? super R> a;
final Function<? super T, ? extends ObservableSource<? extends R>> b;
final int c;
final AtomicThrowable d = new AtomicThrowable();
final DelayErrorInnerObserver<R> e;
final boolean f;
SimpleQueue<T> g;
Disposable h;
volatile boolean i;
volatile boolean j;
volatile boolean k;
int l;
static final class DelayErrorInnerObserver<R> extends AtomicReference<Disposable> implements Observer<R> {
final Observer<? super R> a;
final ConcatMapDelayErrorObserver<?, R> b;
DelayErrorInnerObserver(Observer<? super R> observer, ConcatMapDelayErrorObserver<?, R> concatMapDelayErrorObserver) {
this.a = observer;
this.b = concatMapDelayErrorObserver;
}
void a() {
DisposableHelper.dispose(this);
}
@Override // io.reactivex.Observer
public void onComplete() {
ConcatMapDelayErrorObserver<?, R> concatMapDelayErrorObserver = this.b;
concatMapDelayErrorObserver.i = false;
concatMapDelayErrorObserver.a();
}
@Override // io.reactivex.Observer
public void onError(Throwable th) {
ConcatMapDelayErrorObserver<?, R> concatMapDelayErrorObserver = this.b;
if (!concatMapDelayErrorObserver.d.addThrowable(th)) {
RxJavaPlugins.b(th);
return;
}
if (!concatMapDelayErrorObserver.f) {
concatMapDelayErrorObserver.h.dispose();
}
concatMapDelayErrorObserver.i = false;
concatMapDelayErrorObserver.a();
}
@Override // io.reactivex.Observer
public void onNext(R r) {
this.a.onNext(r);
}
@Override // io.reactivex.Observer
public void onSubscribe(Disposable disposable) {
DisposableHelper.replace(this, disposable);
}
}
ConcatMapDelayErrorObserver(Observer<? super R> observer, Function<? super T, ? extends ObservableSource<? extends R>> function, int i, boolean z) {
this.a = observer;
this.b = function;
this.c = i;
this.f = z;
this.e = new DelayErrorInnerObserver<>(observer, this);
}
void a() {
if (getAndIncrement() != 0) {
return;
}
Observer<? super R> observer = this.a;
SimpleQueue<T> simpleQueue = this.g;
AtomicThrowable atomicThrowable = this.d;
while (true) {
if (!this.i) {
if (this.k) {
simpleQueue.clear();
return;
}
if (!this.f && atomicThrowable.get() != null) {
simpleQueue.clear();
this.k = true;
observer.onError(atomicThrowable.terminate());
return;
}
boolean z = this.j;
try {
T poll = simpleQueue.poll();
boolean z2 = poll == null;
if (z && z2) {
this.k = true;
Throwable terminate = atomicThrowable.terminate();
if (terminate != null) {
observer.onError(terminate);
return;
} else {
observer.onComplete();
return;
}
}
if (!z2) {
try {
ObservableSource<? extends R> apply = this.b.apply(poll);
ObjectHelper.a(apply, "The mapper returned a null ObservableSource");
ObservableSource<? extends R> observableSource = apply;
if (observableSource instanceof Callable) {
try {
Manifest manifest = (Object) ((Callable) observableSource).call();
if (manifest != null && !this.k) {
observer.onNext(manifest);
}
} catch (Throwable th) {
Exceptions.b(th);
atomicThrowable.addThrowable(th);
}
} else {
this.i = true;
observableSource.subscribe(this.e);
}
} catch (Throwable th2) {
Exceptions.b(th2);
this.k = true;
this.h.dispose();
simpleQueue.clear();
atomicThrowable.addThrowable(th2);
observer.onError(atomicThrowable.terminate());
return;
}
}
} catch (Throwable th3) {
Exceptions.b(th3);
this.k = true;
this.h.dispose();
atomicThrowable.addThrowable(th3);
observer.onError(atomicThrowable.terminate());
return;
}
}
if (decrementAndGet() == 0) {
return;
}
}
}
@Override // io.reactivex.disposables.Disposable
public void dispose() {
this.k = true;
this.h.dispose();
this.e.a();
}
@Override // io.reactivex.Observer
public void onComplete() {
this.j = true;
a();
}
@Override // io.reactivex.Observer
public void onError(Throwable th) {
if (!this.d.addThrowable(th)) {
RxJavaPlugins.b(th);
} else {
this.j = true;
a();
}
}
@Override // io.reactivex.Observer
public void onNext(T t) {
if (this.l == 0) {
this.g.offer(t);
}
a();
}
@Override // io.reactivex.Observer
public void onSubscribe(Disposable disposable) {
if (DisposableHelper.validate(this.h, disposable)) {
this.h = disposable;
if (disposable instanceof QueueDisposable) {
QueueDisposable queueDisposable = (QueueDisposable) disposable;
int requestFusion = queueDisposable.requestFusion(3);
if (requestFusion == 1) {
this.l = requestFusion;
this.g = queueDisposable;
this.j = true;
this.a.onSubscribe(this);
a();
return;
}
if (requestFusion == 2) {
this.l = requestFusion;
this.g = queueDisposable;
this.a.onSubscribe(this);
return;
}
}
this.g = new SpscLinkedArrayQueue(this.c);
this.a.onSubscribe(this);
}
}
}
static final class SourceObserver<T, U> extends AtomicInteger implements Observer<T>, Disposable {
final Observer<? super U> a;
final Function<? super T, ? extends ObservableSource<? extends U>> b;
final InnerObserver<U> c;
final int d;
SimpleQueue<T> e;
Disposable f;
volatile boolean g;
volatile boolean h;
volatile boolean i;
int j;
static final class InnerObserver<U> extends AtomicReference<Disposable> implements Observer<U> {
final Observer<? super U> a;
final SourceObserver<?, ?> b;
InnerObserver(Observer<? super U> observer, SourceObserver<?, ?> sourceObserver) {
this.a = observer;
this.b = sourceObserver;
}
void a() {
DisposableHelper.dispose(this);
}
@Override // io.reactivex.Observer
public void onComplete() {
this.b.b();
}
@Override // io.reactivex.Observer
public void onError(Throwable th) {
this.b.dispose();
this.a.onError(th);
}
@Override // io.reactivex.Observer
public void onNext(U u) {
this.a.onNext(u);
}
@Override // io.reactivex.Observer
public void onSubscribe(Disposable disposable) {
DisposableHelper.set(this, disposable);
}
}
SourceObserver(Observer<? super U> observer, Function<? super T, ? extends ObservableSource<? extends U>> function, int i) {
this.a = observer;
this.b = function;
this.d = i;
this.c = new InnerObserver<>(observer, this);
}
void a() {
if (getAndIncrement() != 0) {
return;
}
while (!this.h) {
if (!this.g) {
boolean z = this.i;
try {
T poll = this.e.poll();
boolean z2 = poll == null;
if (z && z2) {
this.h = true;
this.a.onComplete();
return;
}
if (!z2) {
try {
ObservableSource<? extends U> apply = this.b.apply(poll);
ObjectHelper.a(apply, "The mapper returned a null ObservableSource");
ObservableSource<? extends U> observableSource = apply;
this.g = true;
observableSource.subscribe(this.c);
} catch (Throwable th) {
Exceptions.b(th);
dispose();
this.e.clear();
this.a.onError(th);
return;
}
}
} catch (Throwable th2) {
Exceptions.b(th2);
dispose();
this.e.clear();
this.a.onError(th2);
return;
}
}
if (decrementAndGet() == 0) {
return;
}
}
this.e.clear();
}
void b() {
this.g = false;
a();
}
@Override // io.reactivex.disposables.Disposable
public void dispose() {
this.h = true;
this.c.a();
this.f.dispose();
if (getAndIncrement() == 0) {
this.e.clear();
}
}
@Override // io.reactivex.Observer
public void onComplete() {
if (this.i) {
return;
}
this.i = true;
a();
}
@Override // io.reactivex.Observer
public void onError(Throwable th) {
if (this.i) {
RxJavaPlugins.b(th);
return;
}
this.i = true;
dispose();
this.a.onError(th);
}
@Override // io.reactivex.Observer
public void onNext(T t) {
if (this.i) {
return;
}
if (this.j == 0) {
this.e.offer(t);
}
a();
}
@Override // io.reactivex.Observer
public void onSubscribe(Disposable disposable) {
if (DisposableHelper.validate(this.f, disposable)) {
this.f = disposable;
if (disposable instanceof QueueDisposable) {
QueueDisposable queueDisposable = (QueueDisposable) disposable;
int requestFusion = queueDisposable.requestFusion(3);
if (requestFusion == 1) {
this.j = requestFusion;
this.e = queueDisposable;
this.i = true;
this.a.onSubscribe(this);
a();
return;
}
if (requestFusion == 2) {
this.j = requestFusion;
this.e = queueDisposable;
this.a.onSubscribe(this);
return;
}
}
this.e = new SpscLinkedArrayQueue(this.d);
this.a.onSubscribe(this);
}
}
}
public ObservableConcatMap(ObservableSource<T> observableSource, Function<? super T, ? extends ObservableSource<? extends U>> function, int i, ErrorMode errorMode) {
super(observableSource);
this.b = function;
this.d = errorMode;
this.c = Math.max(8, i);
}
@Override // io.reactivex.Observable
public void subscribeActual(Observer<? super U> observer) {
if (ObservableScalarXMap.a(this.a, observer, this.b)) {
return;
}
ErrorMode errorMode = this.d;
if (errorMode == ErrorMode.IMMEDIATE) {
this.a.subscribe(new SourceObserver(new SerializedObserver(observer), this.b, this.c));
} else {
this.a.subscribe(new ConcatMapDelayErrorObserver(observer, this.b, this.c, errorMode == ErrorMode.END));
}
}
}

288
sources/io/reactivex/internal/operators/observable/ObservableConcatMapEager.java Normal file
View File

@@ -0,0 +1,288 @@
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.SimpleQueue;
import io.reactivex.internal.observers.InnerQueuedObserver;
import io.reactivex.internal.observers.InnerQueuedObserverSupport;
import io.reactivex.internal.queue.SpscLinkedArrayQueue;
import io.reactivex.internal.util.AtomicThrowable;
import io.reactivex.internal.util.ErrorMode;
import io.reactivex.plugins.RxJavaPlugins;
import java.util.ArrayDeque;
import java.util.concurrent.atomic.AtomicInteger;
/* loaded from: classes2.dex */
public final class ObservableConcatMapEager<T, R> extends AbstractObservableWithUpstream<T, R> {
final Function<? super T, ? extends ObservableSource<? extends R>> b;
final ErrorMode c;
final int d;
final int e;
public ObservableConcatMapEager(ObservableSource<T> observableSource, Function<? super T, ? extends ObservableSource<? extends R>> function, ErrorMode errorMode, int i, int i2) {
super(observableSource);
this.b = function;
this.c = errorMode;
this.d = i;
this.e = i2;
}
@Override // io.reactivex.Observable
protected void subscribeActual(Observer<? super R> observer) {
this.a.subscribe(new ConcatMapEagerMainObserver(observer, this.b, this.d, this.e, this.c));
}
static final class ConcatMapEagerMainObserver<T, R> extends AtomicInteger implements Observer<T>, Disposable, InnerQueuedObserverSupport<R> {
final Observer<? super R> a;
final Function<? super T, ? extends ObservableSource<? extends R>> b;
final int c;
final int d;
final ErrorMode e;
final AtomicThrowable f = new AtomicThrowable();
final ArrayDeque<InnerQueuedObserver<R>> g = new ArrayDeque<>();
SimpleQueue<T> h;
Disposable i;
volatile boolean j;
int k;
volatile boolean l;
InnerQueuedObserver<R> m;
int n;
ConcatMapEagerMainObserver(Observer<? super R> observer, Function<? super T, ? extends ObservableSource<? extends R>> function, int i, int i2, ErrorMode errorMode) {
this.a = observer;
this.b = function;
this.c = i;
this.d = i2;
this.e = errorMode;
}
@Override // io.reactivex.internal.observers.InnerQueuedObserverSupport
public void a(InnerQueuedObserver<R> innerQueuedObserver, R r) {
innerQueuedObserver.queue().offer(r);
a();
}
void b() {
InnerQueuedObserver<R> innerQueuedObserver = this.m;
if (innerQueuedObserver != null) {
innerQueuedObserver.dispose();
}
while (true) {
InnerQueuedObserver<R> poll = this.g.poll();
if (poll == null) {
return;
} else {
poll.dispose();
}
}
}
@Override // io.reactivex.disposables.Disposable
public void dispose() {
this.l = true;
if (getAndIncrement() == 0) {
this.h.clear();
b();
}
}
@Override // io.reactivex.Observer
public void onComplete() {
this.j = true;
a();
}
@Override // io.reactivex.Observer
public void onError(Throwable th) {
if (!this.f.addThrowable(th)) {
RxJavaPlugins.b(th);
} else {
this.j = true;
a();
}
}
@Override // io.reactivex.Observer
public void onNext(T t) {
if (this.k == 0) {
this.h.offer(t);
}
a();
}
@Override // io.reactivex.Observer
public void onSubscribe(Disposable disposable) {
if (DisposableHelper.validate(this.i, disposable)) {
this.i = disposable;
if (disposable instanceof QueueDisposable) {
QueueDisposable queueDisposable = (QueueDisposable) disposable;
int requestFusion = queueDisposable.requestFusion(3);
if (requestFusion == 1) {
this.k = requestFusion;
this.h = queueDisposable;
this.j = true;
this.a.onSubscribe(this);
a();
return;
}
if (requestFusion == 2) {
this.k = requestFusion;
this.h = queueDisposable;
this.a.onSubscribe(this);
return;
}
}
this.h = new SpscLinkedArrayQueue(this.d);
this.a.onSubscribe(this);
}
}
@Override // io.reactivex.internal.observers.InnerQueuedObserverSupport
public void a(InnerQueuedObserver<R> innerQueuedObserver, Throwable th) {
if (this.f.addThrowable(th)) {
if (this.e == ErrorMode.IMMEDIATE) {
this.i.dispose();
}
innerQueuedObserver.setDone();
a();
return;
}
RxJavaPlugins.b(th);
}
@Override // io.reactivex.internal.observers.InnerQueuedObserverSupport
public void a(InnerQueuedObserver<R> innerQueuedObserver) {
innerQueuedObserver.setDone();
a();
}
@Override // io.reactivex.internal.observers.InnerQueuedObserverSupport
public void a() {
R poll;
boolean z;
if (getAndIncrement() != 0) {
return;
}
SimpleQueue<T> simpleQueue = this.h;
ArrayDeque<InnerQueuedObserver<R>> arrayDeque = this.g;
Observer<? super R> observer = this.a;
ErrorMode errorMode = this.e;
int i = 1;
while (true) {
int i2 = this.n;
while (i2 != this.c) {
if (this.l) {
simpleQueue.clear();
b();
return;
}
if (errorMode == ErrorMode.IMMEDIATE && this.f.get() != null) {
simpleQueue.clear();
b();
observer.onError(this.f.terminate());
return;
}
try {
T poll2 = simpleQueue.poll();
if (poll2 == null) {
break;
}
ObservableSource<? extends R> apply = this.b.apply(poll2);
ObjectHelper.a(apply, "The mapper returned a null ObservableSource");
ObservableSource<? extends R> observableSource = apply;
InnerQueuedObserver<R> innerQueuedObserver = new InnerQueuedObserver<>(this, this.d);
arrayDeque.offer(innerQueuedObserver);
observableSource.subscribe(innerQueuedObserver);
i2++;
} catch (Throwable th) {
Exceptions.b(th);
this.i.dispose();
simpleQueue.clear();
b();
this.f.addThrowable(th);
observer.onError(this.f.terminate());
return;
}
}
this.n = i2;
if (this.l) {
simpleQueue.clear();
b();
return;
}
if (errorMode == ErrorMode.IMMEDIATE && this.f.get() != null) {
simpleQueue.clear();
b();
observer.onError(this.f.terminate());
return;
}
InnerQueuedObserver<R> innerQueuedObserver2 = this.m;
if (innerQueuedObserver2 == null) {
if (errorMode == ErrorMode.BOUNDARY && this.f.get() != null) {
simpleQueue.clear();
b();
observer.onError(this.f.terminate());
return;
}
boolean z2 = this.j;
InnerQueuedObserver<R> poll3 = arrayDeque.poll();
boolean z3 = poll3 == null;
if (z2 && z3) {
if (this.f.get() != null) {
simpleQueue.clear();
b();
observer.onError(this.f.terminate());
return;
}
observer.onComplete();
return;
}
if (!z3) {
this.m = poll3;
}
innerQueuedObserver2 = poll3;
}
if (innerQueuedObserver2 != null) {
SimpleQueue<R> queue = innerQueuedObserver2.queue();
while (!this.l) {
boolean isDone = innerQueuedObserver2.isDone();
if (errorMode == ErrorMode.IMMEDIATE && this.f.get() != null) {
simpleQueue.clear();
b();
observer.onError(this.f.terminate());
return;
}
try {
poll = queue.poll();
z = poll == null;
} catch (Throwable th2) {
Exceptions.b(th2);
this.f.addThrowable(th2);
this.m = null;
this.n--;
}
if (isDone && z) {
this.m = null;
this.n--;
} else if (!z) {
observer.onNext(poll);
}
}
simpleQueue.clear();
b();
return;
}
i = addAndGet(-i);
if (i == 0) {
return;
}
}
}
}
}

71
sources/io/reactivex/internal/operators/observable/ObservableConcatWithCompletable.java Normal file
View File

@@ -0,0 +1,71 @@
package io.reactivex.internal.operators.observable;
import io.reactivex.CompletableObserver;
import io.reactivex.CompletableSource;
import io.reactivex.Observable;
import io.reactivex.Observer;
import io.reactivex.disposables.Disposable;
import io.reactivex.internal.disposables.DisposableHelper;
import java.util.concurrent.atomic.AtomicReference;
/* loaded from: classes2.dex */
public final class ObservableConcatWithCompletable<T> extends AbstractObservableWithUpstream<T, T> {
final CompletableSource b;
static final class ConcatWithObserver<T> extends AtomicReference<Disposable> implements Observer<T>, CompletableObserver, Disposable {
final Observer<? super T> a;
CompletableSource b;
boolean c;
ConcatWithObserver(Observer<? super T> observer, CompletableSource completableSource) {
this.a = observer;
this.b = completableSource;
}
@Override // io.reactivex.disposables.Disposable
public void dispose() {
DisposableHelper.dispose(this);
}
@Override // io.reactivex.Observer
public void onComplete() {
if (this.c) {
this.a.onComplete();
return;
}
this.c = true;
DisposableHelper.replace(this, null);
CompletableSource completableSource = this.b;
this.b = null;
completableSource.a(this);
}
@Override // io.reactivex.Observer
public void onError(Throwable th) {
this.a.onError(th);
}
@Override // io.reactivex.Observer
public void onNext(T t) {
this.a.onNext(t);
}
@Override // io.reactivex.Observer
public void onSubscribe(Disposable disposable) {
if (!DisposableHelper.setOnce(this, disposable) || this.c) {
return;
}
this.a.onSubscribe(this);
}
}
public ObservableConcatWithCompletable(Observable<T> observable, CompletableSource completableSource) {
super(observable);
this.b = completableSource;
}
@Override // io.reactivex.Observable
protected void subscribeActual(Observer<? super T> observer) {
this.a.subscribe(new ConcatWithObserver(observer, this.b));
}
}

77
sources/io/reactivex/internal/operators/observable/ObservableConcatWithMaybe.java Normal file
View File

@@ -0,0 +1,77 @@
package io.reactivex.internal.operators.observable;
import io.reactivex.MaybeObserver;
import io.reactivex.MaybeSource;
import io.reactivex.Observable;
import io.reactivex.Observer;
import io.reactivex.disposables.Disposable;
import io.reactivex.internal.disposables.DisposableHelper;
import java.util.concurrent.atomic.AtomicReference;
/* loaded from: classes2.dex */
public final class ObservableConcatWithMaybe<T> extends AbstractObservableWithUpstream<T, T> {
final MaybeSource<? extends T> b;
static final class ConcatWithObserver<T> extends AtomicReference<Disposable> implements Observer<T>, MaybeObserver<T>, Disposable {
final Observer<? super T> a;
MaybeSource<? extends T> b;
boolean c;
ConcatWithObserver(Observer<? super T> observer, MaybeSource<? extends T> maybeSource) {
this.a = observer;
this.b = maybeSource;
}
@Override // io.reactivex.disposables.Disposable
public void dispose() {
DisposableHelper.dispose(this);
}
@Override // io.reactivex.Observer
public void onComplete() {
if (this.c) {
this.a.onComplete();
return;
}
this.c = true;
DisposableHelper.replace(this, null);
MaybeSource<? extends T> maybeSource = this.b;
this.b = null;
maybeSource.a(this);
}
@Override // io.reactivex.Observer
public void onError(Throwable th) {
this.a.onError(th);
}
@Override // io.reactivex.Observer
public void onNext(T t) {
this.a.onNext(t);
}
@Override // io.reactivex.Observer
public void onSubscribe(Disposable disposable) {
if (!DisposableHelper.setOnce(this, disposable) || this.c) {
return;
}
this.a.onSubscribe(this);
}
@Override // io.reactivex.MaybeObserver
public void onSuccess(T t) {
this.a.onNext(t);
this.a.onComplete();
}
}
public ObservableConcatWithMaybe(Observable<T> observable, MaybeSource<? extends T> maybeSource) {
super(observable);
this.b = maybeSource;
}
@Override // io.reactivex.Observable
protected void subscribeActual(Observer<? super T> observer) {
this.a.subscribe(new ConcatWithObserver(observer, this.b));
}
}

73
sources/io/reactivex/internal/operators/observable/ObservableConcatWithSingle.java Normal file
View File

@@ -0,0 +1,73 @@
package io.reactivex.internal.operators.observable;
import io.reactivex.Observable;
import io.reactivex.Observer;
import io.reactivex.SingleObserver;
import io.reactivex.SingleSource;
import io.reactivex.disposables.Disposable;
import io.reactivex.internal.disposables.DisposableHelper;
import java.util.concurrent.atomic.AtomicReference;
/* loaded from: classes2.dex */
public final class ObservableConcatWithSingle<T> extends AbstractObservableWithUpstream<T, T> {
final SingleSource<? extends T> b;
static final class ConcatWithObserver<T> extends AtomicReference<Disposable> implements Observer<T>, SingleObserver<T>, Disposable {
final Observer<? super T> a;
SingleSource<? extends T> b;
boolean c;
ConcatWithObserver(Observer<? super T> observer, SingleSource<? extends T> singleSource) {
this.a = observer;
this.b = singleSource;
}
@Override // io.reactivex.disposables.Disposable
public void dispose() {
DisposableHelper.dispose(this);
}
@Override // io.reactivex.Observer
public void onComplete() {
this.c = true;
DisposableHelper.replace(this, null);
SingleSource<? extends T> singleSource = this.b;
this.b = null;
singleSource.a(this);
}
@Override // io.reactivex.Observer
public void onError(Throwable th) {
this.a.onError(th);
}
@Override // io.reactivex.Observer
public void onNext(T t) {
this.a.onNext(t);
}
@Override // io.reactivex.Observer
public void onSubscribe(Disposable disposable) {
if (!DisposableHelper.setOnce(this, disposable) || this.c) {
return;
}
this.a.onSubscribe(this);
}
@Override // io.reactivex.SingleObserver
public void onSuccess(T t) {
this.a.onNext(t);
this.a.onComplete();
}
}
public ObservableConcatWithSingle(Observable<T> observable, SingleSource<? extends T> singleSource) {
super(observable);
this.b = singleSource;
}
@Override // io.reactivex.Observable
protected void subscribeActual(Observer<? super T> observer) {
this.a.subscribe(new ConcatWithObserver(observer, this.b));
}
}

58
sources/io/reactivex/internal/operators/observable/ObservableCount.java Normal file
View File

@@ -0,0 +1,58 @@
package io.reactivex.internal.operators.observable;
import io.reactivex.ObservableSource;
import io.reactivex.Observer;
import io.reactivex.disposables.Disposable;
import io.reactivex.internal.disposables.DisposableHelper;
/* loaded from: classes2.dex */
public final class ObservableCount<T> extends AbstractObservableWithUpstream<T, Long> {
static final class CountObserver implements Observer<Object>, Disposable {
final Observer<? super Long> a;
Disposable b;
long c;
CountObserver(Observer<? super Long> observer) {
this.a = observer;
}
@Override // io.reactivex.disposables.Disposable
public void dispose() {
this.b.dispose();
}
@Override // io.reactivex.Observer
public void onComplete() {
this.a.onNext(Long.valueOf(this.c));
this.a.onComplete();
}
@Override // io.reactivex.Observer
public void onError(Throwable th) {
this.a.onError(th);
}
@Override // io.reactivex.Observer
public void onNext(Object obj) {
this.c++;
}
@Override // io.reactivex.Observer
public void onSubscribe(Disposable disposable) {
if (DisposableHelper.validate(this.b, disposable)) {
this.b = disposable;
this.a.onSubscribe(this);
}
}
}
public ObservableCount(ObservableSource<T> observableSource) {
super(observableSource);
}
@Override // io.reactivex.Observable
public void subscribeActual(Observer<? super Long> observer) {
this.a.subscribe(new CountObserver(observer));
}
}

71
sources/io/reactivex/internal/operators/observable/ObservableCountSingle.java Normal file
View File

@@ -0,0 +1,71 @@
package io.reactivex.internal.operators.observable;
import io.reactivex.Observable;
import io.reactivex.ObservableSource;
import io.reactivex.Observer;
import io.reactivex.Single;
import io.reactivex.SingleObserver;
import io.reactivex.disposables.Disposable;
import io.reactivex.internal.disposables.DisposableHelper;
import io.reactivex.internal.fuseable.FuseToObservable;
import io.reactivex.plugins.RxJavaPlugins;
/* loaded from: classes2.dex */
public final class ObservableCountSingle<T> extends Single<Long> implements FuseToObservable<Long> {
final ObservableSource<T> a;
static final class CountObserver implements Observer<Object>, Disposable {
final SingleObserver<? super Long> a;
Disposable b;
long c;
CountObserver(SingleObserver<? super Long> singleObserver) {
this.a = singleObserver;
}
@Override // io.reactivex.disposables.Disposable
public void dispose() {
this.b.dispose();
this.b = DisposableHelper.DISPOSED;
}
@Override // io.reactivex.Observer
public void onComplete() {
this.b = DisposableHelper.DISPOSED;
this.a.onSuccess(Long.valueOf(this.c));
}
@Override // io.reactivex.Observer
public void onError(Throwable th) {
this.b = DisposableHelper.DISPOSED;
this.a.onError(th);
}
@Override // io.reactivex.Observer
public void onNext(Object obj) {
this.c++;
}
@Override // io.reactivex.Observer
public void onSubscribe(Disposable disposable) {
if (DisposableHelper.validate(this.b, disposable)) {
this.b = disposable;
this.a.onSubscribe(this);
}
}
}
public ObservableCountSingle(ObservableSource<T> observableSource) {
this.a = observableSource;
}
@Override // io.reactivex.internal.fuseable.FuseToObservable
public Observable<Long> a() {
return RxJavaPlugins.a(new ObservableCount(this.a));
}
@Override // io.reactivex.Single
public void b(SingleObserver<? super Long> singleObserver) {
this.a.subscribe(new CountObserver(singleObserver));
}
}

103
sources/io/reactivex/internal/operators/observable/ObservableCreate.java Normal file
View File

@@ -0,0 +1,103 @@
package io.reactivex.internal.operators.observable;
import io.reactivex.Observable;
import io.reactivex.ObservableEmitter;
import io.reactivex.ObservableOnSubscribe;
import io.reactivex.Observer;
import io.reactivex.disposables.Disposable;
import io.reactivex.exceptions.Exceptions;
import io.reactivex.internal.disposables.DisposableHelper;
import io.reactivex.plugins.RxJavaPlugins;
import java.util.concurrent.atomic.AtomicReference;
/* loaded from: classes2.dex */
public final class ObservableCreate<T> extends Observable<T> {
final ObservableOnSubscribe<T> a;
public ObservableCreate(ObservableOnSubscribe<T> observableOnSubscribe) {
this.a = observableOnSubscribe;
}
@Override // io.reactivex.Observable
protected void subscribeActual(Observer<? super T> observer) {
CreateEmitter createEmitter = new CreateEmitter(observer);
observer.onSubscribe(createEmitter);
try {
this.a.subscribe(createEmitter);
} catch (Throwable th) {
Exceptions.b(th);
createEmitter.onError(th);
}
}
static final class CreateEmitter<T> extends AtomicReference<Disposable> implements ObservableEmitter<T>, Disposable {
final Observer<? super T> a;
CreateEmitter(Observer<? super T> observer) {
this.a = observer;
}
public boolean a(Throwable th) {
if (th == null) {
th = new NullPointerException("onError called with null. Null values are generally not allowed in 2.x operators and sources.");
}
if (a()) {
return false;
}
try {
this.a.onError(th);
dispose();
return true;
} catch (Throwable th2) {
dispose();
throw th2;
}
}
@Override // io.reactivex.disposables.Disposable
public void dispose() {
DisposableHelper.dispose(this);
}
@Override // io.reactivex.Emitter
public void onComplete() {
if (a()) {
return;
}
try {
this.a.onComplete();
} finally {
dispose();
}
}
@Override // io.reactivex.Emitter
public void onError(Throwable th) {
if (a(th)) {
return;
}
RxJavaPlugins.b(th);
}
@Override // io.reactivex.Emitter
public void onNext(T t) {
if (t == null) {
onError(new NullPointerException("onNext called with null. Null values are generally not allowed in 2.x operators and sources."));
} else {
if (a()) {
return;
}
this.a.onNext(t);
}
}
@Override // java.util.concurrent.atomic.AtomicReference
public String toString() {
return String.format("%s{%s}", CreateEmitter.class.getSimpleName(), super.toString());
}
public boolean a() {
return DisposableHelper.isDisposed(get());
}
}
}

158
sources/io/reactivex/internal/operators/observable/ObservableDebounce.java Normal file
View File

@@ -0,0 +1,158 @@
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.observers.DisposableObserver;
import io.reactivex.observers.SerializedObserver;
import io.reactivex.plugins.RxJavaPlugins;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicReference;
/* loaded from: classes2.dex */
public final class ObservableDebounce<T, U> extends AbstractObservableWithUpstream<T, T> {
final Function<? super T, ? extends ObservableSource<U>> b;
static final class DebounceObserver<T, U> implements Observer<T>, Disposable {
final Observer<? super T> a;
final Function<? super T, ? extends ObservableSource<U>> b;
Disposable c;
final AtomicReference<Disposable> d = new AtomicReference<>();
volatile long e;
boolean f;
static final class DebounceInnerObserver<T, U> extends DisposableObserver<U> {
final DebounceObserver<T, U> b;
final long c;
final T d;
boolean e;
final AtomicBoolean f = new AtomicBoolean();
DebounceInnerObserver(DebounceObserver<T, U> debounceObserver, long j, T t) {
this.b = debounceObserver;
this.c = j;
this.d = t;
}
void b() {
if (this.f.compareAndSet(false, true)) {
this.b.a(this.c, this.d);
}
}
@Override // io.reactivex.Observer
public void onComplete() {
if (this.e) {
return;
}
this.e = true;
b();
}
@Override // io.reactivex.Observer
public void onError(Throwable th) {
if (this.e) {
RxJavaPlugins.b(th);
} else {
this.e = true;
this.b.onError(th);
}
}
@Override // io.reactivex.Observer
public void onNext(U u) {
if (this.e) {
return;
}
this.e = true;
dispose();
b();
}
}
DebounceObserver(Observer<? super T> observer, Function<? super T, ? extends ObservableSource<U>> function) {
this.a = observer;
this.b = function;
}
void a(long j, T t) {
if (j == this.e) {
this.a.onNext(t);
}
}
@Override // io.reactivex.disposables.Disposable
public void dispose() {
this.c.dispose();
DisposableHelper.dispose(this.d);
}
@Override // io.reactivex.Observer
public void onComplete() {
if (this.f) {
return;
}
this.f = true;
Disposable disposable = this.d.get();
if (disposable != DisposableHelper.DISPOSED) {
((DebounceInnerObserver) disposable).b();
DisposableHelper.dispose(this.d);
this.a.onComplete();
}
}
@Override // io.reactivex.Observer
public void onError(Throwable th) {
DisposableHelper.dispose(this.d);
this.a.onError(th);
}
@Override // io.reactivex.Observer
public void onNext(T t) {
if (this.f) {
return;
}
long j = this.e + 1;
this.e = j;
Disposable disposable = this.d.get();
if (disposable != null) {
disposable.dispose();
}
try {
ObservableSource<U> apply = this.b.apply(t);
ObjectHelper.a(apply, "The ObservableSource supplied is null");
ObservableSource<U> observableSource = apply;
DebounceInnerObserver debounceInnerObserver = new DebounceInnerObserver(this, j, t);
if (this.d.compareAndSet(disposable, debounceInnerObserver)) {
observableSource.subscribe(debounceInnerObserver);
}
} catch (Throwable th) {
Exceptions.b(th);
dispose();
this.a.onError(th);
}
}
@Override // io.reactivex.Observer
public void onSubscribe(Disposable disposable) {
if (DisposableHelper.validate(this.c, disposable)) {
this.c = disposable;
this.a.onSubscribe(this);
}
}
}
public ObservableDebounce(ObservableSource<T> observableSource, Function<? super T, ? extends ObservableSource<U>> function) {
super(observableSource);
this.b = function;
}
@Override // io.reactivex.Observable
public void subscribeActual(Observer<? super T> observer) {
this.a.subscribe(new DebounceObserver(new SerializedObserver(observer), this.b));
}
}

148
sources/io/reactivex/internal/operators/observable/ObservableDebounceTimed.java Normal file
View File

@@ -0,0 +1,148 @@
package io.reactivex.internal.operators.observable;
import io.reactivex.ObservableSource;
import io.reactivex.Observer;
import io.reactivex.Scheduler;
import io.reactivex.disposables.Disposable;
import io.reactivex.internal.disposables.DisposableHelper;
import io.reactivex.observers.SerializedObserver;
import io.reactivex.plugins.RxJavaPlugins;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicReference;
/* loaded from: classes2.dex */
public final class ObservableDebounceTimed<T> extends AbstractObservableWithUpstream<T, T> {
final long b;
final TimeUnit c;
final Scheduler d;
static final class DebounceEmitter<T> extends AtomicReference<Disposable> implements Runnable, Disposable {
final T a;
final long b;
final DebounceTimedObserver<T> c;
final AtomicBoolean d = new AtomicBoolean();
DebounceEmitter(T t, long j, DebounceTimedObserver<T> debounceTimedObserver) {
this.a = t;
this.b = j;
this.c = debounceTimedObserver;
}
public void a(Disposable disposable) {
DisposableHelper.replace(this, disposable);
}
@Override // io.reactivex.disposables.Disposable
public void dispose() {
DisposableHelper.dispose(this);
}
@Override // java.lang.Runnable
public void run() {
if (this.d.compareAndSet(false, true)) {
this.c.a(this.b, this.a, this);
}
}
}
static final class DebounceTimedObserver<T> implements Observer<T>, Disposable {
final Observer<? super T> a;
final long b;
final TimeUnit c;
final Scheduler.Worker d;
Disposable e;
Disposable f;
volatile long g;
boolean h;
DebounceTimedObserver(Observer<? super T> observer, long j, TimeUnit timeUnit, Scheduler.Worker worker) {
this.a = observer;
this.b = j;
this.c = timeUnit;
this.d = worker;
}
void a(long j, T t, DebounceEmitter<T> debounceEmitter) {
if (j == this.g) {
this.a.onNext(t);
debounceEmitter.dispose();
}
}
@Override // io.reactivex.disposables.Disposable
public void dispose() {
this.e.dispose();
this.d.dispose();
}
@Override // io.reactivex.Observer
public void onComplete() {
if (this.h) {
return;
}
this.h = true;
Disposable disposable = this.f;
if (disposable != null) {
disposable.dispose();
}
DebounceEmitter debounceEmitter = (DebounceEmitter) disposable;
if (debounceEmitter != null) {
debounceEmitter.run();
}
this.a.onComplete();
this.d.dispose();
}
@Override // io.reactivex.Observer
public void onError(Throwable th) {
if (this.h) {
RxJavaPlugins.b(th);
return;
}
Disposable disposable = this.f;
if (disposable != null) {
disposable.dispose();
}
this.h = true;
this.a.onError(th);
this.d.dispose();
}
@Override // io.reactivex.Observer
public void onNext(T t) {
if (this.h) {
return;
}
long j = this.g + 1;
this.g = j;
Disposable disposable = this.f;
if (disposable != null) {
disposable.dispose();
}
DebounceEmitter debounceEmitter = new DebounceEmitter(t, j, this);
this.f = debounceEmitter;
debounceEmitter.a(this.d.a(debounceEmitter, this.b, this.c));
}
@Override // io.reactivex.Observer
public void onSubscribe(Disposable disposable) {
if (DisposableHelper.validate(this.e, disposable)) {
this.e = disposable;
this.a.onSubscribe(this);
}
}
}
public ObservableDebounceTimed(ObservableSource<T> observableSource, long j, TimeUnit timeUnit, Scheduler scheduler) {
super(observableSource);
this.b = j;
this.c = timeUnit;
this.d = scheduler;
}
@Override // io.reactivex.Observable
public void subscribeActual(Observer<? super T> observer) {
this.a.subscribe(new DebounceTimedObserver(new SerializedObserver(observer), this.b, this.c, this.d.a()));
}
}

30
sources/io/reactivex/internal/operators/observable/ObservableDefer.java Normal file
View File

@@ -0,0 +1,30 @@
package io.reactivex.internal.operators.observable;
import io.reactivex.Observable;
import io.reactivex.ObservableSource;
import io.reactivex.Observer;
import io.reactivex.exceptions.Exceptions;
import io.reactivex.internal.disposables.EmptyDisposable;
import io.reactivex.internal.functions.ObjectHelper;
import java.util.concurrent.Callable;
/* loaded from: classes2.dex */
public final class ObservableDefer<T> extends Observable<T> {
final Callable<? extends ObservableSource<? extends T>> a;
public ObservableDefer(Callable<? extends ObservableSource<? extends T>> callable) {
this.a = callable;
}
@Override // io.reactivex.Observable
public void subscribeActual(Observer<? super T> observer) {
try {
ObservableSource<? extends T> call = this.a.call();
ObjectHelper.a(call, "null ObservableSource supplied");
call.subscribe(observer);
} catch (Throwable th) {
Exceptions.b(th);
EmptyDisposable.error(th, observer);
}
}
}

120
sources/io/reactivex/internal/operators/observable/ObservableDelay.java Normal file
View File

@@ -0,0 +1,120 @@
package io.reactivex.internal.operators.observable;
import io.reactivex.ObservableSource;
import io.reactivex.Observer;
import io.reactivex.Scheduler;
import io.reactivex.disposables.Disposable;
import io.reactivex.internal.disposables.DisposableHelper;
import io.reactivex.observers.SerializedObserver;
import java.util.concurrent.TimeUnit;
/* loaded from: classes2.dex */
public final class ObservableDelay<T> extends AbstractObservableWithUpstream<T, T> {
final long b;
final TimeUnit c;
final Scheduler d;
final boolean e;
static final class DelayObserver<T> implements Observer<T>, Disposable {
final Observer<? super T> a;
final long b;
final TimeUnit c;
final Scheduler.Worker d;
final boolean e;
Disposable f;
final class OnComplete implements Runnable {
OnComplete() {
}
@Override // java.lang.Runnable
public void run() {
try {
DelayObserver.this.a.onComplete();
} finally {
DelayObserver.this.d.dispose();
}
}
}
final class OnError implements Runnable {
private final Throwable a;
OnError(Throwable th) {
this.a = th;
}
@Override // java.lang.Runnable
public void run() {
try {
DelayObserver.this.a.onError(this.a);
} finally {
DelayObserver.this.d.dispose();
}
}
}
final class OnNext implements Runnable {
private final T a;
OnNext(T t) {
this.a = t;
}
@Override // java.lang.Runnable
public void run() {
DelayObserver.this.a.onNext(this.a);
}
}
DelayObserver(Observer<? super T> observer, long j, TimeUnit timeUnit, Scheduler.Worker worker, boolean z) {
this.a = observer;
this.b = j;
this.c = timeUnit;
this.d = worker;
this.e = z;
}
@Override // io.reactivex.disposables.Disposable
public void dispose() {
this.f.dispose();
this.d.dispose();
}
@Override // io.reactivex.Observer
public void onComplete() {
this.d.a(new OnComplete(), this.b, this.c);
}
@Override // io.reactivex.Observer
public void onError(Throwable th) {
this.d.a(new OnError(th), this.e ? this.b : 0L, this.c);
}
@Override // io.reactivex.Observer
public void onNext(T t) {
this.d.a(new OnNext(t), this.b, this.c);
}
@Override // io.reactivex.Observer
public void onSubscribe(Disposable disposable) {
if (DisposableHelper.validate(this.f, disposable)) {
this.f = disposable;
this.a.onSubscribe(this);
}
}
}
public ObservableDelay(ObservableSource<T> observableSource, long j, TimeUnit timeUnit, Scheduler scheduler, boolean z) {
super(observableSource);
this.b = j;
this.c = timeUnit;
this.d = scheduler;
this.e = z;
}
@Override // io.reactivex.Observable
public void subscribeActual(Observer<? super T> observer) {
this.a.subscribe(new DelayObserver(this.e ? observer : new SerializedObserver(observer), this.b, this.c, this.d.a(), this.e));
}
}

91
sources/io/reactivex/internal/operators/observable/ObservableDelaySubscriptionOther.java Normal file
View File

@@ -0,0 +1,91 @@
package io.reactivex.internal.operators.observable;
import io.reactivex.Observable;
import io.reactivex.ObservableSource;
import io.reactivex.Observer;
import io.reactivex.disposables.Disposable;
import io.reactivex.internal.disposables.SequentialDisposable;
import io.reactivex.plugins.RxJavaPlugins;
/* loaded from: classes2.dex */
public final class ObservableDelaySubscriptionOther<T, U> extends Observable<T> {
final ObservableSource<? extends T> a;
final ObservableSource<U> b;
final class DelayObserver implements Observer<U> {
final SequentialDisposable a;
final Observer<? super T> b;
boolean c;
final class OnComplete implements Observer<T> {
OnComplete() {
}
@Override // io.reactivex.Observer
public void onComplete() {
DelayObserver.this.b.onComplete();
}
@Override // io.reactivex.Observer
public void onError(Throwable th) {
DelayObserver.this.b.onError(th);
}
@Override // io.reactivex.Observer
public void onNext(T t) {
DelayObserver.this.b.onNext(t);
}
@Override // io.reactivex.Observer
public void onSubscribe(Disposable disposable) {
DelayObserver.this.a.update(disposable);
}
}
DelayObserver(SequentialDisposable sequentialDisposable, Observer<? super T> observer) {
this.a = sequentialDisposable;
this.b = observer;
}
@Override // io.reactivex.Observer
public void onComplete() {
if (this.c) {
return;
}
this.c = true;
ObservableDelaySubscriptionOther.this.a.subscribe(new OnComplete());
}
@Override // io.reactivex.Observer
public void onError(Throwable th) {
if (this.c) {
RxJavaPlugins.b(th);
} else {
this.c = true;
this.b.onError(th);
}
}
@Override // io.reactivex.Observer
public void onNext(U u) {
onComplete();
}
@Override // io.reactivex.Observer
public void onSubscribe(Disposable disposable) {
this.a.update(disposable);
}
}
public ObservableDelaySubscriptionOther(ObservableSource<? extends T> observableSource, ObservableSource<U> observableSource2) {
this.a = observableSource;
this.b = observableSource2;
}
@Override // io.reactivex.Observable
public void subscribeActual(Observer<? super T> observer) {
SequentialDisposable sequentialDisposable = new SequentialDisposable();
observer.onSubscribe(sequentialDisposable);
this.b.subscribe(new DelayObserver(sequentialDisposable, observer));
}
}

81
sources/io/reactivex/internal/operators/observable/ObservableDematerialize.java Normal file
View File

@@ -0,0 +1,81 @@
package io.reactivex.internal.operators.observable;
import io.reactivex.Notification;
import io.reactivex.ObservableSource;
import io.reactivex.Observer;
import io.reactivex.disposables.Disposable;
import io.reactivex.internal.disposables.DisposableHelper;
import io.reactivex.plugins.RxJavaPlugins;
/* loaded from: classes2.dex */
public final class ObservableDematerialize<T> extends AbstractObservableWithUpstream<Notification<T>, T> {
static final class DematerializeObserver<T> implements Observer<Notification<T>>, Disposable {
final Observer<? super T> a;
boolean b;
Disposable c;
DematerializeObserver(Observer<? super T> observer) {
this.a = observer;
}
@Override // io.reactivex.Observer
/* renamed from: a, reason: merged with bridge method [inline-methods] */
public void onNext(Notification<T> notification) {
if (this.b) {
if (notification.d()) {
RxJavaPlugins.b(notification.a());
}
} else if (notification.d()) {
this.c.dispose();
onError(notification.a());
} else if (!notification.c()) {
this.a.onNext(notification.b());
} else {
this.c.dispose();
onComplete();
}
}
@Override // io.reactivex.disposables.Disposable
public void dispose() {
this.c.dispose();
}
@Override // io.reactivex.Observer
public void onComplete() {
if (this.b) {
return;
}
this.b = true;
this.a.onComplete();
}
@Override // io.reactivex.Observer
public void onError(Throwable th) {
if (this.b) {
RxJavaPlugins.b(th);
} else {
this.b = true;
this.a.onError(th);
}
}
@Override // io.reactivex.Observer
public void onSubscribe(Disposable disposable) {
if (DisposableHelper.validate(this.c, disposable)) {
this.c = disposable;
this.a.onSubscribe(this);
}
}
}
public ObservableDematerialize(ObservableSource<Notification<T>> observableSource) {
super(observableSource);
}
@Override // io.reactivex.Observable
public void subscribeActual(Observer<? super T> observer) {
this.a.subscribe(new DematerializeObserver(observer));
}
}

66
sources/io/reactivex/internal/operators/observable/ObservableDetach.java Normal file
View File

@@ -0,0 +1,66 @@
package io.reactivex.internal.operators.observable;
import io.reactivex.ObservableSource;
import io.reactivex.Observer;
import io.reactivex.disposables.Disposable;
import io.reactivex.internal.disposables.DisposableHelper;
import io.reactivex.internal.util.EmptyComponent;
/* loaded from: classes2.dex */
public final class ObservableDetach<T> extends AbstractObservableWithUpstream<T, T> {
static final class DetachObserver<T> implements Observer<T>, Disposable {
Observer<? super T> a;
Disposable b;
DetachObserver(Observer<? super T> observer) {
this.a = observer;
}
@Override // io.reactivex.disposables.Disposable
public void dispose() {
Disposable disposable = this.b;
this.b = EmptyComponent.INSTANCE;
this.a = EmptyComponent.asObserver();
disposable.dispose();
}
@Override // io.reactivex.Observer
public void onComplete() {
Observer<? super T> observer = this.a;
this.b = EmptyComponent.INSTANCE;
this.a = EmptyComponent.asObserver();
observer.onComplete();
}
@Override // io.reactivex.Observer
public void onError(Throwable th) {
Observer<? super T> observer = this.a;
this.b = EmptyComponent.INSTANCE;
this.a = EmptyComponent.asObserver();
observer.onError(th);
}
@Override // io.reactivex.Observer
public void onNext(T t) {
this.a.onNext(t);
}
@Override // io.reactivex.Observer
public void onSubscribe(Disposable disposable) {
if (DisposableHelper.validate(this.b, disposable)) {
this.b = disposable;
this.a.onSubscribe(this);
}
}
}
public ObservableDetach(ObservableSource<T> observableSource) {
super(observableSource);
}
@Override // io.reactivex.Observable
protected void subscribeActual(Observer<? super T> observer) {
this.a.subscribe(new DetachObserver(observer));
}
}

116
sources/io/reactivex/internal/operators/observable/ObservableDistinct.java Normal file
View File

@@ -0,0 +1,116 @@
package io.reactivex.internal.operators.observable;
import io.reactivex.ObservableSource;
import io.reactivex.Observer;
import io.reactivex.exceptions.Exceptions;
import io.reactivex.functions.Function;
import io.reactivex.internal.disposables.EmptyDisposable;
import io.reactivex.internal.functions.ObjectHelper;
import io.reactivex.internal.observers.BasicFuseableObserver;
import io.reactivex.plugins.RxJavaPlugins;
import java.util.Collection;
import java.util.concurrent.Callable;
/* loaded from: classes2.dex */
public final class ObservableDistinct<T, K> extends AbstractObservableWithUpstream<T, T> {
final Function<? super T, K> b;
final Callable<? extends Collection<? super K>> c;
static final class DistinctObserver<T, K> extends BasicFuseableObserver<T, T> {
final Collection<? super K> f;
final Function<? super T, K> g;
DistinctObserver(Observer<? super T> observer, Function<? super T, K> function, Collection<? super K> collection) {
super(observer);
this.g = function;
this.f = collection;
}
@Override // io.reactivex.internal.observers.BasicFuseableObserver, io.reactivex.internal.fuseable.SimpleQueue
public void clear() {
this.f.clear();
super.clear();
}
@Override // io.reactivex.internal.observers.BasicFuseableObserver, io.reactivex.Observer
public void onComplete() {
if (this.d) {
return;
}
this.d = true;
this.f.clear();
this.a.onComplete();
}
@Override // io.reactivex.internal.observers.BasicFuseableObserver, io.reactivex.Observer
public void onError(Throwable th) {
if (this.d) {
RxJavaPlugins.b(th);
return;
}
this.d = true;
this.f.clear();
this.a.onError(th);
}
@Override // io.reactivex.Observer
public void onNext(T t) {
if (this.d) {
return;
}
if (this.e != 0) {
this.a.onNext(null);
return;
}
try {
K apply = this.g.apply(t);
ObjectHelper.a(apply, "The keySelector returned a null key");
if (this.f.add(apply)) {
this.a.onNext(t);
}
} catch (Throwable th) {
a(th);
}
}
@Override // io.reactivex.internal.fuseable.SimpleQueue
public T poll() throws Exception {
T poll;
Collection<? super K> collection;
K apply;
do {
poll = this.c.poll();
if (poll == null) {
break;
}
collection = this.f;
apply = this.g.apply(poll);
ObjectHelper.a(apply, "The keySelector returned a null key");
} while (!collection.add(apply));
return poll;
}
@Override // io.reactivex.internal.fuseable.QueueFuseable
public int requestFusion(int i) {
return a(i);
}
}
public ObservableDistinct(ObservableSource<T> observableSource, Function<? super T, K> function, Callable<? extends Collection<? super K>> callable) {
super(observableSource);
this.b = function;
this.c = callable;
}
@Override // io.reactivex.Observable
protected void subscribeActual(Observer<? super T> observer) {
try {
Collection<? super K> call = this.c.call();
ObjectHelper.a(call, "The collectionSupplier returned a null collection. Null values are generally not allowed in 2.x operators and sources.");
this.a.subscribe(new DistinctObserver(observer, this.b, call));
} catch (Throwable th) {
Exceptions.b(th);
EmptyDisposable.error(th, observer);
}
}
}

90
sources/io/reactivex/internal/operators/observable/ObservableDistinctUntilChanged.java Normal file
View File

@@ -0,0 +1,90 @@
package io.reactivex.internal.operators.observable;
import io.reactivex.ObservableSource;
import io.reactivex.Observer;
import io.reactivex.functions.BiPredicate;
import io.reactivex.functions.Function;
import io.reactivex.internal.observers.BasicFuseableObserver;
/* loaded from: classes2.dex */
public final class ObservableDistinctUntilChanged<T, K> extends AbstractObservableWithUpstream<T, T> {
final Function<? super T, K> b;
final BiPredicate<? super K, ? super K> c;
static final class DistinctUntilChangedObserver<T, K> extends BasicFuseableObserver<T, T> {
final Function<? super T, K> f;
final BiPredicate<? super K, ? super K> g;
K h;
boolean i;
DistinctUntilChangedObserver(Observer<? super T> observer, Function<? super T, K> function, BiPredicate<? super K, ? super K> biPredicate) {
super(observer);
this.f = function;
this.g = biPredicate;
}
@Override // io.reactivex.Observer
public void onNext(T t) {
if (this.d) {
return;
}
if (this.e != 0) {
this.a.onNext(t);
return;
}
try {
K apply = this.f.apply(t);
if (this.i) {
boolean a = this.g.a(this.h, apply);
this.h = apply;
if (a) {
return;
}
} else {
this.i = true;
this.h = apply;
}
this.a.onNext(t);
} catch (Throwable th) {
a(th);
}
}
@Override // io.reactivex.internal.fuseable.SimpleQueue
public T poll() throws Exception {
while (true) {
T poll = this.c.poll();
if (poll == null) {
return null;
}
K apply = this.f.apply(poll);
if (!this.i) {
this.i = true;
this.h = apply;
return poll;
}
if (!this.g.a(this.h, apply)) {
this.h = apply;
return poll;
}
this.h = apply;
}
}
@Override // io.reactivex.internal.fuseable.QueueFuseable
public int requestFusion(int i) {
return a(i);
}
}
public ObservableDistinctUntilChanged(ObservableSource<T> observableSource, Function<? super T, K> function, BiPredicate<? super K, ? super K> biPredicate) {
super(observableSource);
this.b = function;
this.c = biPredicate;
}
@Override // io.reactivex.Observable
protected void subscribeActual(Observer<? super T> observer) {
this.a.subscribe(new DistinctUntilChangedObserver(observer, this.b, this.c));
}
}

56
sources/io/reactivex/internal/operators/observable/ObservableDoAfterNext.java Normal file
View File

@@ -0,0 +1,56 @@
package io.reactivex.internal.operators.observable;
import io.reactivex.ObservableSource;
import io.reactivex.Observer;
import io.reactivex.functions.Consumer;
import io.reactivex.internal.observers.BasicFuseableObserver;
/* loaded from: classes2.dex */
public final class ObservableDoAfterNext<T> extends AbstractObservableWithUpstream<T, T> {
final Consumer<? super T> b;
static final class DoAfterObserver<T> extends BasicFuseableObserver<T, T> {
final Consumer<? super T> f;
DoAfterObserver(Observer<? super T> observer, Consumer<? super T> consumer) {
super(observer);
this.f = consumer;
}
@Override // io.reactivex.Observer
public void onNext(T t) {
this.a.onNext(t);
if (this.e == 0) {
try {
this.f.accept(t);
} catch (Throwable th) {
a(th);
}
}
}
@Override // io.reactivex.internal.fuseable.SimpleQueue
public T poll() throws Exception {
T poll = this.c.poll();
if (poll != null) {
this.f.accept(poll);
}
return poll;
}
@Override // io.reactivex.internal.fuseable.QueueFuseable
public int requestFusion(int i) {
return a(i);
}
}
public ObservableDoAfterNext(ObservableSource<T> observableSource, Consumer<? super T> consumer) {
super(observableSource);
this.b = consumer;
}
@Override // io.reactivex.Observable
protected void subscribeActual(Observer<? super T> observer) {
this.a.subscribe(new DoAfterObserver(observer, this.b));
}
}

116
sources/io/reactivex/internal/operators/observable/ObservableDoFinally.java Normal file
View File

@@ -0,0 +1,116 @@
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.Action;
import io.reactivex.internal.disposables.DisposableHelper;
import io.reactivex.internal.fuseable.QueueDisposable;
import io.reactivex.internal.observers.BasicIntQueueDisposable;
import io.reactivex.plugins.RxJavaPlugins;
/* loaded from: classes2.dex */
public final class ObservableDoFinally<T> extends AbstractObservableWithUpstream<T, T> {
final Action b;
static final class DoFinallyObserver<T> extends BasicIntQueueDisposable<T> implements Observer<T> {
final Observer<? super T> a;
final Action b;
Disposable c;
QueueDisposable<T> d;
boolean e;
DoFinallyObserver(Observer<? super T> observer, Action action) {
this.a = observer;
this.b = action;
}
void a() {
if (compareAndSet(0, 1)) {
try {
this.b.run();
} catch (Throwable th) {
Exceptions.b(th);
RxJavaPlugins.b(th);
}
}
}
@Override // io.reactivex.internal.fuseable.SimpleQueue
public void clear() {
this.d.clear();
}
@Override // io.reactivex.disposables.Disposable
public void dispose() {
this.c.dispose();
a();
}
@Override // io.reactivex.internal.fuseable.SimpleQueue
public boolean isEmpty() {
return this.d.isEmpty();
}
@Override // io.reactivex.Observer
public void onComplete() {
this.a.onComplete();
a();
}
@Override // io.reactivex.Observer
public void onError(Throwable th) {
this.a.onError(th);
a();
}
@Override // io.reactivex.Observer
public void onNext(T t) {
this.a.onNext(t);
}
@Override // io.reactivex.Observer
public void onSubscribe(Disposable disposable) {
if (DisposableHelper.validate(this.c, disposable)) {
this.c = disposable;
if (disposable instanceof QueueDisposable) {
this.d = (QueueDisposable) disposable;
}
this.a.onSubscribe(this);
}
}
@Override // io.reactivex.internal.fuseable.SimpleQueue
public T poll() throws Exception {
T poll = this.d.poll();
if (poll == null && this.e) {
a();
}
return poll;
}
@Override // io.reactivex.internal.fuseable.QueueFuseable
public int requestFusion(int i) {
QueueDisposable<T> queueDisposable = this.d;
if (queueDisposable == null || (i & 4) != 0) {
return 0;
}
int requestFusion = queueDisposable.requestFusion(i);
if (requestFusion != 0) {
this.e = requestFusion == 1;
}
return requestFusion;
}
}
public ObservableDoFinally(ObservableSource<T> observableSource, Action action) {
super(observableSource);
this.b = action;
}
@Override // io.reactivex.Observable
protected void subscribeActual(Observer<? super T> observer) {
this.a.subscribe(new DoFinallyObserver(observer, this.b));
}
}

121
sources/io/reactivex/internal/operators/observable/ObservableDoOnEach.java Normal file
View File

@@ -0,0 +1,121 @@
package io.reactivex.internal.operators.observable;
import io.reactivex.ObservableSource;
import io.reactivex.Observer;
import io.reactivex.disposables.Disposable;
import io.reactivex.exceptions.CompositeException;
import io.reactivex.exceptions.Exceptions;
import io.reactivex.functions.Action;
import io.reactivex.functions.Consumer;
import io.reactivex.internal.disposables.DisposableHelper;
import io.reactivex.plugins.RxJavaPlugins;
/* loaded from: classes2.dex */
public final class ObservableDoOnEach<T> extends AbstractObservableWithUpstream<T, T> {
final Consumer<? super T> b;
final Consumer<? super Throwable> c;
final Action d;
final Action e;
static final class DoOnEachObserver<T> implements Observer<T>, Disposable {
final Observer<? super T> a;
final Consumer<? super T> b;
final Consumer<? super Throwable> c;
final Action d;
final Action e;
Disposable f;
boolean g;
DoOnEachObserver(Observer<? super T> observer, Consumer<? super T> consumer, Consumer<? super Throwable> consumer2, Action action, Action action2) {
this.a = observer;
this.b = consumer;
this.c = consumer2;
this.d = action;
this.e = action2;
}
@Override // io.reactivex.disposables.Disposable
public void dispose() {
this.f.dispose();
}
@Override // io.reactivex.Observer
public void onComplete() {
if (this.g) {
return;
}
try {
this.d.run();
this.g = true;
this.a.onComplete();
try {
this.e.run();
} catch (Throwable th) {
Exceptions.b(th);
RxJavaPlugins.b(th);
}
} catch (Throwable th2) {
Exceptions.b(th2);
onError(th2);
}
}
@Override // io.reactivex.Observer
public void onError(Throwable th) {
if (this.g) {
RxJavaPlugins.b(th);
return;
}
this.g = true;
try {
this.c.accept(th);
} catch (Throwable th2) {
Exceptions.b(th2);
th = new CompositeException(th, th2);
}
this.a.onError(th);
try {
this.e.run();
} catch (Throwable th3) {
Exceptions.b(th3);
RxJavaPlugins.b(th3);
}
}
@Override // io.reactivex.Observer
public void onNext(T t) {
if (this.g) {
return;
}
try {
this.b.accept(t);
this.a.onNext(t);
} catch (Throwable th) {
Exceptions.b(th);
this.f.dispose();
onError(th);
}
}
@Override // io.reactivex.Observer
public void onSubscribe(Disposable disposable) {
if (DisposableHelper.validate(this.f, disposable)) {
this.f = disposable;
this.a.onSubscribe(this);
}
}
}
public ObservableDoOnEach(ObservableSource<T> observableSource, Consumer<? super T> consumer, Consumer<? super Throwable> consumer2, Action action, Action action2) {
super(observableSource);
this.b = consumer;
this.c = consumer2;
this.d = action;
this.e = action2;
}
@Override // io.reactivex.Observable
public void subscribeActual(Observer<? super T> observer) {
this.a.subscribe(new DoOnEachObserver(observer, this.b, this.c, this.d, this.e));
}
}

25
sources/io/reactivex/internal/operators/observable/ObservableDoOnLifecycle.java Normal file
View File

@@ -0,0 +1,25 @@
package io.reactivex.internal.operators.observable;
import io.reactivex.Observable;
import io.reactivex.Observer;
import io.reactivex.disposables.Disposable;
import io.reactivex.functions.Action;
import io.reactivex.functions.Consumer;
import io.reactivex.internal.observers.DisposableLambdaObserver;
/* loaded from: classes2.dex */
public final class ObservableDoOnLifecycle<T> extends AbstractObservableWithUpstream<T, T> {
private final Consumer<? super Disposable> b;
private final Action c;
public ObservableDoOnLifecycle(Observable<T> observable, Consumer<? super Disposable> consumer, Action action) {
super(observable);
this.b = consumer;
this.c = action;
}
@Override // io.reactivex.Observable
protected void subscribeActual(Observer<? super T> observer) {
this.a.subscribe(new DisposableLambdaObserver(observer, this.b, this.c));
}
}

100
sources/io/reactivex/internal/operators/observable/ObservableElementAt.java Normal file
View File

@@ -0,0 +1,100 @@
package io.reactivex.internal.operators.observable;
import io.reactivex.ObservableSource;
import io.reactivex.Observer;
import io.reactivex.disposables.Disposable;
import io.reactivex.internal.disposables.DisposableHelper;
import io.reactivex.plugins.RxJavaPlugins;
import java.util.NoSuchElementException;
/* loaded from: classes2.dex */
public final class ObservableElementAt<T> extends AbstractObservableWithUpstream<T, T> {
final long b;
final T c;
final boolean d;
static final class ElementAtObserver<T> implements Observer<T>, Disposable {
final Observer<? super T> a;
final long b;
final T c;
final boolean d;
Disposable e;
long f;
boolean g;
ElementAtObserver(Observer<? super T> observer, long j, T t, boolean z) {
this.a = observer;
this.b = j;
this.c = t;
this.d = z;
}
@Override // io.reactivex.disposables.Disposable
public void dispose() {
this.e.dispose();
}
@Override // io.reactivex.Observer
public void onComplete() {
if (this.g) {
return;
}
this.g = true;
T t = this.c;
if (t == null && this.d) {
this.a.onError(new NoSuchElementException());
return;
}
if (t != null) {
this.a.onNext(t);
}
this.a.onComplete();
}
@Override // io.reactivex.Observer
public void onError(Throwable th) {
if (this.g) {
RxJavaPlugins.b(th);
} else {
this.g = true;
this.a.onError(th);
}
}
@Override // io.reactivex.Observer
public void onNext(T t) {
if (this.g) {
return;
}
long j = this.f;
if (j != this.b) {
this.f = j + 1;
return;
}
this.g = true;
this.e.dispose();
this.a.onNext(t);
this.a.onComplete();
}
@Override // io.reactivex.Observer
public void onSubscribe(Disposable disposable) {
if (DisposableHelper.validate(this.e, disposable)) {
this.e = disposable;
this.a.onSubscribe(this);
}
}
}
public ObservableElementAt(ObservableSource<T> observableSource, long j, T t, boolean z) {
super(observableSource);
this.b = j;
this.c = t;
this.d = z;
}
@Override // io.reactivex.Observable
public void subscribeActual(Observer<? super T> observer) {
this.a.subscribe(new ElementAtObserver(observer, this.b, this.c, this.d));
}
}

92
sources/io/reactivex/internal/operators/observable/ObservableElementAtMaybe.java Normal file
View File

@@ -0,0 +1,92 @@
package io.reactivex.internal.operators.observable;
import io.reactivex.Maybe;
import io.reactivex.MaybeObserver;
import io.reactivex.Observable;
import io.reactivex.ObservableSource;
import io.reactivex.Observer;
import io.reactivex.disposables.Disposable;
import io.reactivex.internal.disposables.DisposableHelper;
import io.reactivex.internal.fuseable.FuseToObservable;
import io.reactivex.plugins.RxJavaPlugins;
/* loaded from: classes2.dex */
public final class ObservableElementAtMaybe<T> extends Maybe<T> implements FuseToObservable<T> {
final ObservableSource<T> a;
final long b;
static final class ElementAtObserver<T> implements Observer<T>, Disposable {
final MaybeObserver<? super T> a;
final long b;
Disposable c;
long d;
boolean e;
ElementAtObserver(MaybeObserver<? super T> maybeObserver, long j) {
this.a = maybeObserver;
this.b = j;
}
@Override // io.reactivex.disposables.Disposable
public void dispose() {
this.c.dispose();
}
@Override // io.reactivex.Observer
public void onComplete() {
if (this.e) {
return;
}
this.e = true;
this.a.onComplete();
}
@Override // io.reactivex.Observer
public void onError(Throwable th) {
if (this.e) {
RxJavaPlugins.b(th);
} else {
this.e = true;
this.a.onError(th);
}
}
@Override // io.reactivex.Observer
public void onNext(T t) {
if (this.e) {
return;
}
long j = this.d;
if (j != this.b) {
this.d = j + 1;
return;
}
this.e = true;
this.c.dispose();
this.a.onSuccess(t);
}
@Override // io.reactivex.Observer
public void onSubscribe(Disposable disposable) {
if (DisposableHelper.validate(this.c, disposable)) {
this.c = disposable;
this.a.onSubscribe(this);
}
}
}
public ObservableElementAtMaybe(ObservableSource<T> observableSource, long j) {
this.a = observableSource;
this.b = j;
}
@Override // io.reactivex.internal.fuseable.FuseToObservable
public Observable<T> a() {
return RxJavaPlugins.a(new ObservableElementAt(this.a, this.b, null, false));
}
@Override // io.reactivex.Maybe
public void b(MaybeObserver<? super T> maybeObserver) {
this.a.subscribe(new ElementAtObserver(maybeObserver, this.b));
}
}

102
sources/io/reactivex/internal/operators/observable/ObservableElementAtSingle.java Normal file
View File

@@ -0,0 +1,102 @@
package io.reactivex.internal.operators.observable;
import io.reactivex.Observable;
import io.reactivex.ObservableSource;
import io.reactivex.Observer;
import io.reactivex.Single;
import io.reactivex.SingleObserver;
import io.reactivex.disposables.Disposable;
import io.reactivex.internal.disposables.DisposableHelper;
import io.reactivex.internal.fuseable.FuseToObservable;
import io.reactivex.plugins.RxJavaPlugins;
import java.util.NoSuchElementException;
/* loaded from: classes2.dex */
public final class ObservableElementAtSingle<T> extends Single<T> implements FuseToObservable<T> {
final ObservableSource<T> a;
final long b;
final T c;
static final class ElementAtObserver<T> implements Observer<T>, Disposable {
final SingleObserver<? super T> a;
final long b;
final T c;
Disposable d;
long e;
boolean f;
ElementAtObserver(SingleObserver<? super T> singleObserver, long j, T t) {
this.a = singleObserver;
this.b = j;
this.c = t;
}
@Override // io.reactivex.disposables.Disposable
public void dispose() {
this.d.dispose();
}
@Override // io.reactivex.Observer
public void onComplete() {
if (this.f) {
return;
}
this.f = true;
T t = this.c;
if (t != null) {
this.a.onSuccess(t);
} else {
this.a.onError(new NoSuchElementException());
}
}
@Override // io.reactivex.Observer
public void onError(Throwable th) {
if (this.f) {
RxJavaPlugins.b(th);
} else {
this.f = true;
this.a.onError(th);
}
}
@Override // io.reactivex.Observer
public void onNext(T t) {
if (this.f) {
return;
}
long j = this.e;
if (j != this.b) {
this.e = j + 1;
return;
}
this.f = true;
this.d.dispose();
this.a.onSuccess(t);
}
@Override // io.reactivex.Observer
public void onSubscribe(Disposable disposable) {
if (DisposableHelper.validate(this.d, disposable)) {
this.d = disposable;
this.a.onSubscribe(this);
}
}
}
public ObservableElementAtSingle(ObservableSource<T> observableSource, long j, T t) {
this.a = observableSource;
this.b = j;
this.c = t;
}
@Override // io.reactivex.internal.fuseable.FuseToObservable
public Observable<T> a() {
return RxJavaPlugins.a(new ObservableElementAt(this.a, this.b, this.c, true));
}
@Override // io.reactivex.Single
public void b(SingleObserver<? super T> singleObserver) {
this.a.subscribe(new ElementAtObserver(singleObserver, this.b, this.c));
}
}

24
sources/io/reactivex/internal/operators/observable/ObservableEmpty.java Normal file
View File

@@ -0,0 +1,24 @@
package io.reactivex.internal.operators.observable;
import io.reactivex.Observable;
import io.reactivex.Observer;
import io.reactivex.internal.disposables.EmptyDisposable;
import io.reactivex.internal.fuseable.ScalarCallable;
/* loaded from: classes2.dex */
public final class ObservableEmpty extends Observable<Object> implements ScalarCallable<Object> {
public static final Observable<Object> a = new ObservableEmpty();
private ObservableEmpty() {
}
@Override // io.reactivex.internal.fuseable.ScalarCallable, java.util.concurrent.Callable
public Object call() {
return null;
}
@Override // io.reactivex.Observable
protected void subscribeActual(Observer<? super Object> observer) {
EmptyDisposable.complete(observer);
}
}

30
sources/io/reactivex/internal/operators/observable/ObservableError.java Normal file
View File

@@ -0,0 +1,30 @@
package io.reactivex.internal.operators.observable;
import io.reactivex.Observable;
import io.reactivex.Observer;
import io.reactivex.exceptions.Exceptions;
import io.reactivex.internal.disposables.EmptyDisposable;
import io.reactivex.internal.functions.ObjectHelper;
import java.util.concurrent.Callable;
/* loaded from: classes2.dex */
public final class ObservableError<T> extends Observable<T> {
final Callable<? extends Throwable> a;
public ObservableError(Callable<? extends Throwable> callable) {
this.a = callable;
}
@Override // io.reactivex.Observable
public void subscribeActual(Observer<? super T> observer) {
try {
Throwable call = this.a.call();
ObjectHelper.a(call, "Callable returned null throwable. Null values are generally not allowed in 2.x operators and sources.");
th = call;
} catch (Throwable th) {
th = th;
Exceptions.b(th);
}
EmptyDisposable.error(th, observer);
}
}

62
sources/io/reactivex/internal/operators/observable/ObservableFilter.java Normal file
View File

@@ -0,0 +1,62 @@
package io.reactivex.internal.operators.observable;
import io.reactivex.ObservableSource;
import io.reactivex.Observer;
import io.reactivex.functions.Predicate;
import io.reactivex.internal.observers.BasicFuseableObserver;
/* loaded from: classes2.dex */
public final class ObservableFilter<T> extends AbstractObservableWithUpstream<T, T> {
final Predicate<? super T> b;
static final class FilterObserver<T> extends BasicFuseableObserver<T, T> {
final Predicate<? super T> f;
FilterObserver(Observer<? super T> observer, Predicate<? super T> predicate) {
super(observer);
this.f = predicate;
}
@Override // io.reactivex.Observer
public void onNext(T t) {
if (this.e != 0) {
this.a.onNext(null);
return;
}
try {
if (this.f.a(t)) {
this.a.onNext(t);
}
} catch (Throwable th) {
a(th);
}
}
@Override // io.reactivex.internal.fuseable.SimpleQueue
public T poll() throws Exception {
T poll;
do {
poll = this.c.poll();
if (poll == null) {
break;
}
} while (!this.f.a(poll));
return poll;
}
@Override // io.reactivex.internal.fuseable.QueueFuseable
public int requestFusion(int i) {
return a(i);
}
}
public ObservableFilter(ObservableSource<T> observableSource, Predicate<? super T> predicate) {
super(observableSource);
this.b = predicate;
}
@Override // io.reactivex.Observable
public void subscribeActual(Observer<? super T> observer) {
this.a.subscribe(new FilterObserver(observer, this.b));
}
}

524
sources/io/reactivex/internal/operators/observable/ObservableFlatMap.java Normal file
View File

@@ -0,0 +1,524 @@
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;
}
}
}

169
sources/io/reactivex/internal/operators/observable/ObservableFlatMapCompletable.java Normal file
View File

@@ -0,0 +1,169 @@
package io.reactivex.internal.operators.observable;
import io.reactivex.CompletableObserver;
import io.reactivex.CompletableSource;
import io.reactivex.ObservableSource;
import io.reactivex.Observer;
import io.reactivex.disposables.CompositeDisposable;
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.observers.BasicIntQueueDisposable;
import io.reactivex.internal.util.AtomicThrowable;
import io.reactivex.plugins.RxJavaPlugins;
import java.util.concurrent.atomic.AtomicReference;
/* loaded from: classes2.dex */
public final class ObservableFlatMapCompletable<T> extends AbstractObservableWithUpstream<T, T> {
final Function<? super T, ? extends CompletableSource> b;
final boolean c;
public ObservableFlatMapCompletable(ObservableSource<T> observableSource, Function<? super T, ? extends CompletableSource> function, boolean z) {
super(observableSource);
this.b = function;
this.c = z;
}
@Override // io.reactivex.Observable
protected void subscribeActual(Observer<? super T> observer) {
this.a.subscribe(new FlatMapCompletableMainObserver(observer, this.b, this.c));
}
static final class FlatMapCompletableMainObserver<T> extends BasicIntQueueDisposable<T> implements Observer<T> {
final Observer<? super T> a;
final Function<? super T, ? extends CompletableSource> c;
final boolean d;
Disposable f;
volatile boolean g;
final AtomicThrowable b = new AtomicThrowable();
final CompositeDisposable e = new CompositeDisposable();
final class InnerObserver extends AtomicReference<Disposable> implements CompletableObserver, Disposable {
InnerObserver() {
}
@Override // io.reactivex.disposables.Disposable
public void dispose() {
DisposableHelper.dispose(this);
}
@Override // io.reactivex.CompletableObserver, io.reactivex.MaybeObserver
public void onComplete() {
FlatMapCompletableMainObserver.this.a(this);
}
@Override // io.reactivex.CompletableObserver
public void onError(Throwable th) {
FlatMapCompletableMainObserver.this.a(this, th);
}
@Override // io.reactivex.CompletableObserver
public void onSubscribe(Disposable disposable) {
DisposableHelper.setOnce(this, disposable);
}
}
FlatMapCompletableMainObserver(Observer<? super T> observer, Function<? super T, ? extends CompletableSource> function, boolean z) {
this.a = observer;
this.c = function;
this.d = z;
lazySet(1);
}
void a(FlatMapCompletableMainObserver<T>.InnerObserver innerObserver) {
this.e.c(innerObserver);
onComplete();
}
@Override // io.reactivex.internal.fuseable.SimpleQueue
public void clear() {
}
@Override // io.reactivex.disposables.Disposable
public void dispose() {
this.g = true;
this.f.dispose();
this.e.dispose();
}
@Override // io.reactivex.internal.fuseable.SimpleQueue
public boolean isEmpty() {
return true;
}
@Override // io.reactivex.Observer
public void onComplete() {
if (decrementAndGet() == 0) {
Throwable terminate = this.b.terminate();
if (terminate != null) {
this.a.onError(terminate);
} else {
this.a.onComplete();
}
}
}
@Override // io.reactivex.Observer
public void onError(Throwable th) {
if (!this.b.addThrowable(th)) {
RxJavaPlugins.b(th);
return;
}
if (this.d) {
if (decrementAndGet() == 0) {
this.a.onError(this.b.terminate());
return;
}
return;
}
dispose();
if (getAndSet(0) > 0) {
this.a.onError(this.b.terminate());
}
}
@Override // io.reactivex.Observer
public void onNext(T t) {
try {
CompletableSource apply = this.c.apply(t);
ObjectHelper.a(apply, "The mapper returned a null CompletableSource");
CompletableSource completableSource = apply;
getAndIncrement();
InnerObserver innerObserver = new InnerObserver();
if (this.g || !this.e.b(innerObserver)) {
return;
}
completableSource.a(innerObserver);
} catch (Throwable th) {
Exceptions.b(th);
this.f.dispose();
onError(th);
}
}
@Override // io.reactivex.Observer
public void onSubscribe(Disposable disposable) {
if (DisposableHelper.validate(this.f, disposable)) {
this.f = disposable;
this.a.onSubscribe(this);
}
}
@Override // io.reactivex.internal.fuseable.SimpleQueue
public T poll() throws Exception {
return null;
}
@Override // io.reactivex.internal.fuseable.QueueFuseable
public int requestFusion(int i) {
return i & 2;
}
void a(FlatMapCompletableMainObserver<T>.InnerObserver innerObserver, Throwable th) {
this.e.c(innerObserver);
onError(th);
}
}
}

159
sources/io/reactivex/internal/operators/observable/ObservableFlatMapCompletableCompletable.java Normal file
View File

@@ -0,0 +1,159 @@
package io.reactivex.internal.operators.observable;
import io.reactivex.Completable;
import io.reactivex.CompletableObserver;
import io.reactivex.CompletableSource;
import io.reactivex.Observable;
import io.reactivex.ObservableSource;
import io.reactivex.Observer;
import io.reactivex.disposables.CompositeDisposable;
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.FuseToObservable;
import io.reactivex.internal.util.AtomicThrowable;
import io.reactivex.plugins.RxJavaPlugins;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicReference;
/* loaded from: classes2.dex */
public final class ObservableFlatMapCompletableCompletable<T> extends Completable implements FuseToObservable<T> {
final ObservableSource<T> a;
final Function<? super T, ? extends CompletableSource> b;
final boolean c;
public ObservableFlatMapCompletableCompletable(ObservableSource<T> observableSource, Function<? super T, ? extends CompletableSource> function, boolean z) {
this.a = observableSource;
this.b = function;
this.c = z;
}
@Override // io.reactivex.internal.fuseable.FuseToObservable
public Observable<T> a() {
return RxJavaPlugins.a(new ObservableFlatMapCompletable(this.a, this.b, this.c));
}
@Override // io.reactivex.Completable
protected void b(CompletableObserver completableObserver) {
this.a.subscribe(new FlatMapCompletableMainObserver(completableObserver, this.b, this.c));
}
static final class FlatMapCompletableMainObserver<T> extends AtomicInteger implements Disposable, Observer<T> {
final CompletableObserver a;
final Function<? super T, ? extends CompletableSource> c;
final boolean d;
Disposable f;
volatile boolean g;
final AtomicThrowable b = new AtomicThrowable();
final CompositeDisposable e = new CompositeDisposable();
final class InnerObserver extends AtomicReference<Disposable> implements CompletableObserver, Disposable {
InnerObserver() {
}
@Override // io.reactivex.disposables.Disposable
public void dispose() {
DisposableHelper.dispose(this);
}
@Override // io.reactivex.CompletableObserver, io.reactivex.MaybeObserver
public void onComplete() {
FlatMapCompletableMainObserver.this.a(this);
}
@Override // io.reactivex.CompletableObserver
public void onError(Throwable th) {
FlatMapCompletableMainObserver.this.a(this, th);
}
@Override // io.reactivex.CompletableObserver
public void onSubscribe(Disposable disposable) {
DisposableHelper.setOnce(this, disposable);
}
}
FlatMapCompletableMainObserver(CompletableObserver completableObserver, Function<? super T, ? extends CompletableSource> function, boolean z) {
this.a = completableObserver;
this.c = function;
this.d = z;
lazySet(1);
}
void a(FlatMapCompletableMainObserver<T>.InnerObserver innerObserver) {
this.e.c(innerObserver);
onComplete();
}
@Override // io.reactivex.disposables.Disposable
public void dispose() {
this.g = true;
this.f.dispose();
this.e.dispose();
}
@Override // io.reactivex.Observer
public void onComplete() {
if (decrementAndGet() == 0) {
Throwable terminate = this.b.terminate();
if (terminate != null) {
this.a.onError(terminate);
} else {
this.a.onComplete();
}
}
}
@Override // io.reactivex.Observer
public void onError(Throwable th) {
if (!this.b.addThrowable(th)) {
RxJavaPlugins.b(th);
return;
}
if (this.d) {
if (decrementAndGet() == 0) {
this.a.onError(this.b.terminate());
return;
}
return;
}
dispose();
if (getAndSet(0) > 0) {
this.a.onError(this.b.terminate());
}
}
@Override // io.reactivex.Observer
public void onNext(T t) {
try {
CompletableSource apply = this.c.apply(t);
ObjectHelper.a(apply, "The mapper returned a null CompletableSource");
CompletableSource completableSource = apply;
getAndIncrement();
InnerObserver innerObserver = new InnerObserver();
if (this.g || !this.e.b(innerObserver)) {
return;
}
completableSource.a(innerObserver);
} catch (Throwable th) {
Exceptions.b(th);
this.f.dispose();
onError(th);
}
}
@Override // io.reactivex.Observer
public void onSubscribe(Disposable disposable) {
if (DisposableHelper.validate(this.f, disposable)) {
this.f = disposable;
this.a.onSubscribe(this);
}
}
void a(FlatMapCompletableMainObserver<T>.InnerObserver innerObserver, Throwable th) {
this.e.c(innerObserver);
onError(th);
}
}
}

276
sources/io/reactivex/internal/operators/observable/ObservableFlatMapMaybe.java Normal file
View File

@@ -0,0 +1,276 @@
package io.reactivex.internal.operators.observable;
import android.Manifest;
import io.reactivex.MaybeObserver;
import io.reactivex.MaybeSource;
import io.reactivex.Observable;
import io.reactivex.ObservableSource;
import io.reactivex.Observer;
import io.reactivex.disposables.CompositeDisposable;
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.queue.SpscLinkedArrayQueue;
import io.reactivex.internal.util.AtomicThrowable;
import io.reactivex.plugins.RxJavaPlugins;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicReference;
/* loaded from: classes2.dex */
public final class ObservableFlatMapMaybe<T, R> extends AbstractObservableWithUpstream<T, R> {
final Function<? super T, ? extends MaybeSource<? extends R>> b;
final boolean c;
public ObservableFlatMapMaybe(ObservableSource<T> observableSource, Function<? super T, ? extends MaybeSource<? extends R>> function, boolean z) {
super(observableSource);
this.b = function;
this.c = z;
}
@Override // io.reactivex.Observable
protected void subscribeActual(Observer<? super R> observer) {
this.a.subscribe(new FlatMapMaybeObserver(observer, this.b, this.c));
}
static final class FlatMapMaybeObserver<T, R> extends AtomicInteger implements Observer<T>, Disposable {
final Observer<? super R> a;
final boolean b;
final Function<? super T, ? extends MaybeSource<? extends R>> f;
Disposable h;
volatile boolean i;
final CompositeDisposable c = new CompositeDisposable();
final AtomicThrowable e = new AtomicThrowable();
final AtomicInteger d = new AtomicInteger(1);
final AtomicReference<SpscLinkedArrayQueue<R>> g = new AtomicReference<>();
final class InnerObserver extends AtomicReference<Disposable> implements MaybeObserver<R>, Disposable {
InnerObserver() {
}
@Override // io.reactivex.disposables.Disposable
public void dispose() {
DisposableHelper.dispose(this);
}
@Override // io.reactivex.MaybeObserver
public void onComplete() {
FlatMapMaybeObserver.this.a(this);
}
@Override // io.reactivex.MaybeObserver
public void onError(Throwable th) {
FlatMapMaybeObserver.this.a(this, th);
}
@Override // io.reactivex.MaybeObserver
public void onSubscribe(Disposable disposable) {
DisposableHelper.setOnce(this, disposable);
}
@Override // io.reactivex.MaybeObserver
public void onSuccess(R r) {
FlatMapMaybeObserver.this.a((FlatMapMaybeObserver<T, InnerObserver>.InnerObserver) this, (InnerObserver) r);
}
}
FlatMapMaybeObserver(Observer<? super R> observer, Function<? super T, ? extends MaybeSource<? extends R>> function, boolean z) {
this.a = observer;
this.f = function;
this.b = z;
}
void a(FlatMapMaybeObserver<T, R>.InnerObserver innerObserver, R r) {
this.c.c(innerObserver);
if (get() == 0) {
if (compareAndSet(0, 1)) {
this.a.onNext(r);
boolean z = this.d.decrementAndGet() == 0;
SpscLinkedArrayQueue<R> spscLinkedArrayQueue = this.g.get();
if (!z || (spscLinkedArrayQueue != null && !spscLinkedArrayQueue.isEmpty())) {
if (decrementAndGet() == 0) {
return;
}
c();
} else {
Throwable terminate = this.e.terminate();
if (terminate != null) {
this.a.onError(terminate);
return;
} else {
this.a.onComplete();
return;
}
}
}
}
SpscLinkedArrayQueue<R> d = d();
synchronized (d) {
d.offer(r);
}
this.d.decrementAndGet();
if (getAndIncrement() != 0) {
return;
}
c();
}
void b() {
if (getAndIncrement() == 0) {
c();
}
}
void c() {
Observer<? super R> observer = this.a;
AtomicInteger atomicInteger = this.d;
AtomicReference<SpscLinkedArrayQueue<R>> atomicReference = this.g;
int i = 1;
while (!this.i) {
if (!this.b && this.e.get() != null) {
Throwable terminate = this.e.terminate();
a();
observer.onError(terminate);
return;
}
boolean z = atomicInteger.get() == 0;
SpscLinkedArrayQueue<R> spscLinkedArrayQueue = atomicReference.get();
Manifest poll = spscLinkedArrayQueue != null ? spscLinkedArrayQueue.poll() : null;
boolean z2 = poll == null;
if (z && z2) {
Throwable terminate2 = this.e.terminate();
if (terminate2 != null) {
observer.onError(terminate2);
return;
} else {
observer.onComplete();
return;
}
}
if (z2) {
i = addAndGet(-i);
if (i == 0) {
return;
}
} else {
observer.onNext(poll);
}
}
a();
}
SpscLinkedArrayQueue<R> d() {
SpscLinkedArrayQueue<R> spscLinkedArrayQueue;
do {
SpscLinkedArrayQueue<R> spscLinkedArrayQueue2 = this.g.get();
if (spscLinkedArrayQueue2 != null) {
return spscLinkedArrayQueue2;
}
spscLinkedArrayQueue = new SpscLinkedArrayQueue<>(Observable.bufferSize());
} while (!this.g.compareAndSet(null, spscLinkedArrayQueue));
return spscLinkedArrayQueue;
}
@Override // io.reactivex.disposables.Disposable
public void dispose() {
this.i = true;
this.h.dispose();
this.c.dispose();
}
@Override // io.reactivex.Observer
public void onComplete() {
this.d.decrementAndGet();
b();
}
@Override // io.reactivex.Observer
public void onError(Throwable th) {
this.d.decrementAndGet();
if (!this.e.addThrowable(th)) {
RxJavaPlugins.b(th);
return;
}
if (!this.b) {
this.c.dispose();
}
b();
}
@Override // io.reactivex.Observer
public void onNext(T t) {
try {
MaybeSource<? extends R> apply = this.f.apply(t);
ObjectHelper.a(apply, "The mapper returned a null MaybeSource");
MaybeSource<? extends R> maybeSource = apply;
this.d.getAndIncrement();
InnerObserver innerObserver = new InnerObserver();
if (this.i || !this.c.b(innerObserver)) {
return;
}
maybeSource.a(innerObserver);
} catch (Throwable th) {
Exceptions.b(th);
this.h.dispose();
onError(th);
}
}
@Override // io.reactivex.Observer
public void onSubscribe(Disposable disposable) {
if (DisposableHelper.validate(this.h, disposable)) {
this.h = disposable;
this.a.onSubscribe(this);
}
}
void a(FlatMapMaybeObserver<T, R>.InnerObserver innerObserver, Throwable th) {
this.c.c(innerObserver);
if (this.e.addThrowable(th)) {
if (!this.b) {
this.h.dispose();
this.c.dispose();
}
this.d.decrementAndGet();
b();
return;
}
RxJavaPlugins.b(th);
}
void a(FlatMapMaybeObserver<T, R>.InnerObserver innerObserver) {
this.c.c(innerObserver);
if (get() == 0) {
if (compareAndSet(0, 1)) {
boolean z = this.d.decrementAndGet() == 0;
SpscLinkedArrayQueue<R> spscLinkedArrayQueue = this.g.get();
if (z && (spscLinkedArrayQueue == null || spscLinkedArrayQueue.isEmpty())) {
Throwable terminate = this.e.terminate();
if (terminate != null) {
this.a.onError(terminate);
return;
} else {
this.a.onComplete();
return;
}
}
if (decrementAndGet() == 0) {
return;
}
c();
return;
}
}
this.d.decrementAndGet();
b();
}
void a() {
SpscLinkedArrayQueue<R> spscLinkedArrayQueue = this.g.get();
if (spscLinkedArrayQueue != null) {
spscLinkedArrayQueue.clear();
}
}
}
}

244
sources/io/reactivex/internal/operators/observable/ObservableFlatMapSingle.java Normal file
View File

@@ -0,0 +1,244 @@
package io.reactivex.internal.operators.observable;
import android.Manifest;
import io.reactivex.Observable;
import io.reactivex.ObservableSource;
import io.reactivex.Observer;
import io.reactivex.SingleObserver;
import io.reactivex.SingleSource;
import io.reactivex.disposables.CompositeDisposable;
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.queue.SpscLinkedArrayQueue;
import io.reactivex.internal.util.AtomicThrowable;
import io.reactivex.plugins.RxJavaPlugins;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicReference;
/* loaded from: classes2.dex */
public final class ObservableFlatMapSingle<T, R> extends AbstractObservableWithUpstream<T, R> {
final Function<? super T, ? extends SingleSource<? extends R>> b;
final boolean c;
public ObservableFlatMapSingle(ObservableSource<T> observableSource, Function<? super T, ? extends SingleSource<? extends R>> function, boolean z) {
super(observableSource);
this.b = function;
this.c = z;
}
@Override // io.reactivex.Observable
protected void subscribeActual(Observer<? super R> observer) {
this.a.subscribe(new FlatMapSingleObserver(observer, this.b, this.c));
}
static final class FlatMapSingleObserver<T, R> extends AtomicInteger implements Observer<T>, Disposable {
final Observer<? super R> a;
final boolean b;
final Function<? super T, ? extends SingleSource<? extends R>> f;
Disposable h;
volatile boolean i;
final CompositeDisposable c = new CompositeDisposable();
final AtomicThrowable e = new AtomicThrowable();
final AtomicInteger d = new AtomicInteger(1);
final AtomicReference<SpscLinkedArrayQueue<R>> g = new AtomicReference<>();
final class InnerObserver extends AtomicReference<Disposable> implements SingleObserver<R>, Disposable {
InnerObserver() {
}
@Override // io.reactivex.disposables.Disposable
public void dispose() {
DisposableHelper.dispose(this);
}
@Override // io.reactivex.SingleObserver
public void onError(Throwable th) {
FlatMapSingleObserver.this.a(this, th);
}
@Override // io.reactivex.SingleObserver
public void onSubscribe(Disposable disposable) {
DisposableHelper.setOnce(this, disposable);
}
@Override // io.reactivex.SingleObserver
public void onSuccess(R r) {
FlatMapSingleObserver.this.a((FlatMapSingleObserver<T, InnerObserver>.InnerObserver) this, (InnerObserver) r);
}
}
FlatMapSingleObserver(Observer<? super R> observer, Function<? super T, ? extends SingleSource<? extends R>> function, boolean z) {
this.a = observer;
this.f = function;
this.b = z;
}
void a(FlatMapSingleObserver<T, R>.InnerObserver innerObserver, R r) {
this.c.c(innerObserver);
if (get() == 0) {
if (compareAndSet(0, 1)) {
this.a.onNext(r);
boolean z = this.d.decrementAndGet() == 0;
SpscLinkedArrayQueue<R> spscLinkedArrayQueue = this.g.get();
if (!z || (spscLinkedArrayQueue != null && !spscLinkedArrayQueue.isEmpty())) {
if (decrementAndGet() == 0) {
return;
}
c();
} else {
Throwable terminate = this.e.terminate();
if (terminate != null) {
this.a.onError(terminate);
return;
} else {
this.a.onComplete();
return;
}
}
}
}
SpscLinkedArrayQueue<R> d = d();
synchronized (d) {
d.offer(r);
}
this.d.decrementAndGet();
if (getAndIncrement() != 0) {
return;
}
c();
}
void b() {
if (getAndIncrement() == 0) {
c();
}
}
void c() {
Observer<? super R> observer = this.a;
AtomicInteger atomicInteger = this.d;
AtomicReference<SpscLinkedArrayQueue<R>> atomicReference = this.g;
int i = 1;
while (!this.i) {
if (!this.b && this.e.get() != null) {
Throwable terminate = this.e.terminate();
a();
observer.onError(terminate);
return;
}
boolean z = atomicInteger.get() == 0;
SpscLinkedArrayQueue<R> spscLinkedArrayQueue = atomicReference.get();
Manifest poll = spscLinkedArrayQueue != null ? spscLinkedArrayQueue.poll() : null;
boolean z2 = poll == null;
if (z && z2) {
Throwable terminate2 = this.e.terminate();
if (terminate2 != null) {
observer.onError(terminate2);
return;
} else {
observer.onComplete();
return;
}
}
if (z2) {
i = addAndGet(-i);
if (i == 0) {
return;
}
} else {
observer.onNext(poll);
}
}
a();
}
SpscLinkedArrayQueue<R> d() {
SpscLinkedArrayQueue<R> spscLinkedArrayQueue;
do {
SpscLinkedArrayQueue<R> spscLinkedArrayQueue2 = this.g.get();
if (spscLinkedArrayQueue2 != null) {
return spscLinkedArrayQueue2;
}
spscLinkedArrayQueue = new SpscLinkedArrayQueue<>(Observable.bufferSize());
} while (!this.g.compareAndSet(null, spscLinkedArrayQueue));
return spscLinkedArrayQueue;
}
@Override // io.reactivex.disposables.Disposable
public void dispose() {
this.i = true;
this.h.dispose();
this.c.dispose();
}
@Override // io.reactivex.Observer
public void onComplete() {
this.d.decrementAndGet();
b();
}
@Override // io.reactivex.Observer
public void onError(Throwable th) {
this.d.decrementAndGet();
if (!this.e.addThrowable(th)) {
RxJavaPlugins.b(th);
return;
}
if (!this.b) {
this.c.dispose();
}
b();
}
@Override // io.reactivex.Observer
public void onNext(T t) {
try {
SingleSource<? extends R> apply = this.f.apply(t);
ObjectHelper.a(apply, "The mapper returned a null SingleSource");
SingleSource<? extends R> singleSource = apply;
this.d.getAndIncrement();
InnerObserver innerObserver = new InnerObserver();
if (this.i || !this.c.b(innerObserver)) {
return;
}
singleSource.a(innerObserver);
} catch (Throwable th) {
Exceptions.b(th);
this.h.dispose();
onError(th);
}
}
@Override // io.reactivex.Observer
public void onSubscribe(Disposable disposable) {
if (DisposableHelper.validate(this.h, disposable)) {
this.h = disposable;
this.a.onSubscribe(this);
}
}
void a(FlatMapSingleObserver<T, R>.InnerObserver innerObserver, Throwable th) {
this.c.c(innerObserver);
if (this.e.addThrowable(th)) {
if (!this.b) {
this.h.dispose();
this.c.dispose();
}
this.d.decrementAndGet();
b();
return;
}
RxJavaPlugins.b(th);
}
void a() {
SpscLinkedArrayQueue<R> spscLinkedArrayQueue = this.g.get();
if (spscLinkedArrayQueue != null) {
spscLinkedArrayQueue.clear();
}
}
}
}

105
sources/io/reactivex/internal/operators/observable/ObservableFlattenIterable.java Normal file
View File

@@ -0,0 +1,105 @@
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.plugins.RxJavaPlugins;
/* loaded from: classes2.dex */
public final class ObservableFlattenIterable<T, R> extends AbstractObservableWithUpstream<T, R> {
final Function<? super T, ? extends Iterable<? extends R>> b;
static final class FlattenIterableObserver<T, R> implements Observer<T>, Disposable {
final Observer<? super R> a;
final Function<? super T, ? extends Iterable<? extends R>> b;
Disposable c;
FlattenIterableObserver(Observer<? super R> observer, Function<? super T, ? extends Iterable<? extends R>> function) {
this.a = observer;
this.b = function;
}
@Override // io.reactivex.disposables.Disposable
public void dispose() {
this.c.dispose();
this.c = DisposableHelper.DISPOSED;
}
@Override // io.reactivex.Observer
public void onComplete() {
Disposable disposable = this.c;
DisposableHelper disposableHelper = DisposableHelper.DISPOSED;
if (disposable == disposableHelper) {
return;
}
this.c = disposableHelper;
this.a.onComplete();
}
@Override // io.reactivex.Observer
public void onError(Throwable th) {
Disposable disposable = this.c;
DisposableHelper disposableHelper = DisposableHelper.DISPOSED;
if (disposable == disposableHelper) {
RxJavaPlugins.b(th);
} else {
this.c = disposableHelper;
this.a.onError(th);
}
}
@Override // io.reactivex.Observer
public void onNext(T t) {
if (this.c == DisposableHelper.DISPOSED) {
return;
}
try {
Observer<? super R> observer = this.a;
for (R r : this.b.apply(t)) {
try {
try {
ObjectHelper.a(r, "The iterator returned a null value");
observer.onNext(r);
} catch (Throwable th) {
Exceptions.b(th);
this.c.dispose();
onError(th);
return;
}
} catch (Throwable th2) {
Exceptions.b(th2);
this.c.dispose();
onError(th2);
return;
}
}
} catch (Throwable th3) {
Exceptions.b(th3);
this.c.dispose();
onError(th3);
}
}
@Override // io.reactivex.Observer
public void onSubscribe(Disposable disposable) {
if (DisposableHelper.validate(this.c, disposable)) {
this.c = disposable;
this.a.onSubscribe(this);
}
}
}
public ObservableFlattenIterable(ObservableSource<T> observableSource, Function<? super T, ? extends Iterable<? extends R>> function) {
super(observableSource);
this.b = function;
}
@Override // io.reactivex.Observable
protected void subscribeActual(Observer<? super R> observer) {
this.a.subscribe(new FlattenIterableObserver(observer, this.b));
}
}

96
sources/io/reactivex/internal/operators/observable/ObservableFromArray.java Normal file
View File

@@ -0,0 +1,96 @@
package io.reactivex.internal.operators.observable;
import io.reactivex.Observable;
import io.reactivex.Observer;
import io.reactivex.internal.functions.ObjectHelper;
import io.reactivex.internal.observers.BasicQueueDisposable;
/* loaded from: classes2.dex */
public final class ObservableFromArray<T> extends Observable<T> {
final T[] a;
static final class FromArrayDisposable<T> extends BasicQueueDisposable<T> {
final Observer<? super T> a;
final T[] b;
int c;
boolean d;
volatile boolean e;
FromArrayDisposable(Observer<? super T> observer, T[] tArr) {
this.a = observer;
this.b = tArr;
}
public boolean a() {
return this.e;
}
void b() {
T[] tArr = this.b;
int length = tArr.length;
for (int i = 0; i < length && !a(); i++) {
T t = tArr[i];
if (t == null) {
this.a.onError(new NullPointerException("The " + i + "th element is null"));
return;
}
this.a.onNext(t);
}
if (a()) {
return;
}
this.a.onComplete();
}
@Override // io.reactivex.internal.fuseable.SimpleQueue
public void clear() {
this.c = this.b.length;
}
@Override // io.reactivex.disposables.Disposable
public void dispose() {
this.e = true;
}
@Override // io.reactivex.internal.fuseable.SimpleQueue
public boolean isEmpty() {
return this.c == this.b.length;
}
@Override // io.reactivex.internal.fuseable.SimpleQueue
public T poll() {
int i = this.c;
T[] tArr = this.b;
if (i == tArr.length) {
return null;
}
this.c = i + 1;
T t = tArr[i];
ObjectHelper.a((Object) t, "The array element is null");
return t;
}
@Override // io.reactivex.internal.fuseable.QueueFuseable
public int requestFusion(int i) {
if ((i & 1) == 0) {
return 0;
}
this.d = true;
return 1;
}
}
public ObservableFromArray(T[] tArr) {
this.a = tArr;
}
@Override // io.reactivex.Observable
public void subscribeActual(Observer<? super T> observer) {
FromArrayDisposable fromArrayDisposable = new FromArrayDisposable(observer, this.a);
observer.onSubscribe(fromArrayDisposable);
if (fromArrayDisposable.d) {
return;
}
fromArrayDisposable.b();
}
}

46
sources/io/reactivex/internal/operators/observable/ObservableFromCallable.java Normal file
View File

@@ -0,0 +1,46 @@
package io.reactivex.internal.operators.observable;
import io.reactivex.Observable;
import io.reactivex.Observer;
import io.reactivex.exceptions.Exceptions;
import io.reactivex.internal.functions.ObjectHelper;
import io.reactivex.internal.observers.DeferredScalarDisposable;
import io.reactivex.plugins.RxJavaPlugins;
import java.util.concurrent.Callable;
/* loaded from: classes2.dex */
public final class ObservableFromCallable<T> extends Observable<T> implements Callable<T> {
final Callable<? extends T> a;
public ObservableFromCallable(Callable<? extends T> callable) {
this.a = callable;
}
@Override // java.util.concurrent.Callable
public T call() throws Exception {
T call = this.a.call();
ObjectHelper.a((Object) call, "The callable returned a null value");
return call;
}
@Override // io.reactivex.Observable
public void subscribeActual(Observer<? super T> observer) {
DeferredScalarDisposable deferredScalarDisposable = new DeferredScalarDisposable(observer);
observer.onSubscribe(deferredScalarDisposable);
if (deferredScalarDisposable.isDisposed()) {
return;
}
try {
T call = this.a.call();
ObjectHelper.a((Object) call, "Callable returned null");
deferredScalarDisposable.complete(call);
} catch (Throwable th) {
Exceptions.b(th);
if (deferredScalarDisposable.isDisposed()) {
RxJavaPlugins.b(th);
} else {
observer.onError(th);
}
}
}
}

42
sources/io/reactivex/internal/operators/observable/ObservableFromFuture.java Normal file
View File

@@ -0,0 +1,42 @@
package io.reactivex.internal.operators.observable;
import io.reactivex.Observable;
import io.reactivex.Observer;
import io.reactivex.exceptions.Exceptions;
import io.reactivex.internal.functions.ObjectHelper;
import io.reactivex.internal.observers.DeferredScalarDisposable;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
/* loaded from: classes2.dex */
public final class ObservableFromFuture<T> extends Observable<T> {
final Future<? extends T> a;
final long b;
final TimeUnit c;
public ObservableFromFuture(Future<? extends T> future, long j, TimeUnit timeUnit) {
this.a = future;
this.b = j;
this.c = timeUnit;
}
@Override // io.reactivex.Observable
public void subscribeActual(Observer<? super T> observer) {
DeferredScalarDisposable deferredScalarDisposable = new DeferredScalarDisposable(observer);
observer.onSubscribe(deferredScalarDisposable);
if (deferredScalarDisposable.isDisposed()) {
return;
}
try {
T t = this.c != null ? this.a.get(this.b, this.c) : this.a.get();
ObjectHelper.a((Object) t, "Future returned null");
deferredScalarDisposable.complete(t);
} catch (Throwable th) {
Exceptions.b(th);
if (deferredScalarDisposable.isDisposed()) {
return;
}
observer.onError(th);
}
}
}

131
sources/io/reactivex/internal/operators/observable/ObservableFromIterable.java Normal file
View File

@@ -0,0 +1,131 @@
package io.reactivex.internal.operators.observable;
import io.reactivex.Observable;
import io.reactivex.Observer;
import io.reactivex.exceptions.Exceptions;
import io.reactivex.internal.disposables.EmptyDisposable;
import io.reactivex.internal.functions.ObjectHelper;
import io.reactivex.internal.observers.BasicQueueDisposable;
import java.util.Iterator;
/* loaded from: classes2.dex */
public final class ObservableFromIterable<T> extends Observable<T> {
final Iterable<? extends T> a;
static final class FromIterableDisposable<T> extends BasicQueueDisposable<T> {
final Observer<? super T> a;
final Iterator<? extends T> b;
volatile boolean c;
boolean d;
boolean e;
boolean f;
FromIterableDisposable(Observer<? super T> observer, Iterator<? extends T> it) {
this.a = observer;
this.b = it;
}
public boolean a() {
return this.c;
}
void b() {
while (!a()) {
try {
T next = this.b.next();
ObjectHelper.a((Object) next, "The iterator returned a null value");
this.a.onNext(next);
if (a()) {
return;
}
try {
if (!this.b.hasNext()) {
if (a()) {
return;
}
this.a.onComplete();
return;
}
} catch (Throwable th) {
Exceptions.b(th);
this.a.onError(th);
return;
}
} catch (Throwable th2) {
Exceptions.b(th2);
this.a.onError(th2);
return;
}
}
}
@Override // io.reactivex.internal.fuseable.SimpleQueue
public void clear() {
this.e = true;
}
@Override // io.reactivex.disposables.Disposable
public void dispose() {
this.c = true;
}
@Override // io.reactivex.internal.fuseable.SimpleQueue
public boolean isEmpty() {
return this.e;
}
@Override // io.reactivex.internal.fuseable.SimpleQueue
public T poll() {
if (this.e) {
return null;
}
if (!this.f) {
this.f = true;
} else if (!this.b.hasNext()) {
this.e = true;
return null;
}
T next = this.b.next();
ObjectHelper.a((Object) next, "The iterator returned a null value");
return next;
}
@Override // io.reactivex.internal.fuseable.QueueFuseable
public int requestFusion(int i) {
if ((i & 1) == 0) {
return 0;
}
this.d = true;
return 1;
}
}
public ObservableFromIterable(Iterable<? extends T> iterable) {
this.a = iterable;
}
@Override // io.reactivex.Observable
public void subscribeActual(Observer<? super T> observer) {
try {
Iterator<? extends T> it = this.a.iterator();
try {
if (!it.hasNext()) {
EmptyDisposable.complete(observer);
return;
}
FromIterableDisposable fromIterableDisposable = new FromIterableDisposable(observer, it);
observer.onSubscribe(fromIterableDisposable);
if (fromIterableDisposable.d) {
return;
}
fromIterableDisposable.b();
} catch (Throwable th) {
Exceptions.b(th);
EmptyDisposable.error(th, observer);
}
} catch (Throwable th2) {
Exceptions.b(th2);
EmptyDisposable.error(th2, observer);
}
}
}

62
sources/io/reactivex/internal/operators/observable/ObservableFromPublisher.java Normal file
View File

@@ -0,0 +1,62 @@
package io.reactivex.internal.operators.observable;
import io.reactivex.FlowableSubscriber;
import io.reactivex.Observable;
import io.reactivex.Observer;
import io.reactivex.disposables.Disposable;
import io.reactivex.internal.subscriptions.SubscriptionHelper;
import org.reactivestreams.Publisher;
import org.reactivestreams.Subscription;
/* loaded from: classes2.dex */
public final class ObservableFromPublisher<T> extends Observable<T> {
final Publisher<? extends T> a;
static final class PublisherSubscriber<T> implements FlowableSubscriber<T>, Disposable {
final Observer<? super T> a;
Subscription b;
PublisherSubscriber(Observer<? super T> observer) {
this.a = observer;
}
@Override // io.reactivex.disposables.Disposable
public void dispose() {
this.b.cancel();
this.b = SubscriptionHelper.CANCELLED;
}
@Override // org.reactivestreams.Subscriber
public void onComplete() {
this.a.onComplete();
}
@Override // org.reactivestreams.Subscriber
public void onError(Throwable th) {
this.a.onError(th);
}
@Override // org.reactivestreams.Subscriber
public void onNext(T t) {
this.a.onNext(t);
}
@Override // org.reactivestreams.Subscriber
public void onSubscribe(Subscription subscription) {
if (SubscriptionHelper.validate(this.b, subscription)) {
this.b = subscription;
this.a.onSubscribe(this);
subscription.request(Long.MAX_VALUE);
}
}
}
public ObservableFromPublisher(Publisher<? extends T> publisher) {
this.a = publisher;
}
@Override // io.reactivex.Observable
protected void subscribeActual(Observer<? super T> observer) {
this.a.a(new PublisherSubscriber(observer));
}
}

19
sources/io/reactivex/internal/operators/observable/ObservableFromUnsafeSource.java Normal file
View File

@@ -0,0 +1,19 @@
package io.reactivex.internal.operators.observable;
import io.reactivex.Observable;
import io.reactivex.ObservableSource;
import io.reactivex.Observer;
/* loaded from: classes2.dex */
public final class ObservableFromUnsafeSource<T> extends Observable<T> {
final ObservableSource<T> a;
public ObservableFromUnsafeSource(ObservableSource<T> observableSource) {
this.a = observableSource;
}
@Override // io.reactivex.Observable
protected void subscribeActual(Observer<? super T> observer) {
this.a.subscribe(observer);
}
}

110
sources/io/reactivex/internal/operators/observable/ObservableGenerate.java Normal file
View File

@@ -0,0 +1,110 @@
package io.reactivex.internal.operators.observable;
import io.reactivex.Emitter;
import io.reactivex.Observable;
import io.reactivex.Observer;
import io.reactivex.disposables.Disposable;
import io.reactivex.exceptions.Exceptions;
import io.reactivex.functions.BiFunction;
import io.reactivex.functions.Consumer;
import io.reactivex.internal.disposables.EmptyDisposable;
import io.reactivex.plugins.RxJavaPlugins;
import java.util.concurrent.Callable;
/* loaded from: classes2.dex */
public final class ObservableGenerate<T, S> extends Observable<T> {
final Callable<S> a;
final BiFunction<S, Emitter<T>, S> b;
final Consumer<? super S> c;
public ObservableGenerate(Callable<S> callable, BiFunction<S, Emitter<T>, S> biFunction, Consumer<? super S> consumer) {
this.a = callable;
this.b = biFunction;
this.c = consumer;
}
@Override // io.reactivex.Observable
public void subscribeActual(Observer<? super T> observer) {
try {
GeneratorDisposable generatorDisposable = new GeneratorDisposable(observer, this.b, this.c, this.a.call());
observer.onSubscribe(generatorDisposable);
generatorDisposable.a();
} catch (Throwable th) {
Exceptions.b(th);
EmptyDisposable.error(th, observer);
}
}
static final class GeneratorDisposable<T, S> implements Emitter<T>, Disposable {
final Observer<? super T> a;
final BiFunction<S, ? super Emitter<T>, S> b;
final Consumer<? super S> c;
S d;
volatile boolean e;
boolean f;
GeneratorDisposable(Observer<? super T> observer, BiFunction<S, ? super Emitter<T>, S> biFunction, Consumer<? super S> consumer, S s) {
this.a = observer;
this.b = biFunction;
this.c = consumer;
this.d = s;
}
public void a() {
S s = this.d;
if (this.e) {
this.d = null;
a(s);
return;
}
BiFunction<S, ? super Emitter<T>, S> biFunction = this.b;
while (!this.e) {
try {
s = biFunction.apply(s, this);
if (this.f) {
this.e = true;
this.d = null;
a(s);
return;
}
} catch (Throwable th) {
Exceptions.b(th);
this.d = null;
this.e = true;
onError(th);
a(s);
return;
}
}
this.d = null;
a(s);
}
@Override // io.reactivex.disposables.Disposable
public void dispose() {
this.e = true;
}
@Override // io.reactivex.Emitter
public void onError(Throwable th) {
if (this.f) {
RxJavaPlugins.b(th);
return;
}
if (th == null) {
th = new NullPointerException("onError called with null. Null values are generally not allowed in 2.x operators and sources.");
}
this.f = true;
this.a.onError(th);
}
private void a(S s) {
try {
this.c.accept(s);
} catch (Throwable th) {
Exceptions.b(th);
RxJavaPlugins.b(th);
}
}
}
}

304
sources/io/reactivex/internal/operators/observable/ObservableGroupBy.java Normal file
View File

@@ -0,0 +1,304 @@
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.disposables.EmptyDisposable;
import io.reactivex.internal.functions.ObjectHelper;
import io.reactivex.internal.queue.SpscLinkedArrayQueue;
import io.reactivex.observables.GroupedObservable;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicReference;
/* loaded from: classes2.dex */
public final class ObservableGroupBy<T, K, V> extends AbstractObservableWithUpstream<T, GroupedObservable<K, V>> {
final Function<? super T, ? extends K> b;
final Function<? super T, ? extends V> c;
final int d;
final boolean e;
public static final class GroupByObserver<T, K, V> extends AtomicInteger implements Observer<T>, Disposable {
static final Object NULL_KEY = new Object();
private static final long serialVersionUID = -3688291656102519502L;
final int bufferSize;
final boolean delayError;
final Observer<? super GroupedObservable<K, V>> downstream;
final Function<? super T, ? extends K> keySelector;
Disposable upstream;
final Function<? super T, ? extends V> valueSelector;
final AtomicBoolean cancelled = new AtomicBoolean();
final Map<Object, GroupedUnicast<K, V>> groups = new ConcurrentHashMap();
public GroupByObserver(Observer<? super GroupedObservable<K, V>> observer, Function<? super T, ? extends K> function, Function<? super T, ? extends V> function2, int i, boolean z) {
this.downstream = observer;
this.keySelector = function;
this.valueSelector = function2;
this.bufferSize = i;
this.delayError = z;
lazySet(1);
}
public void cancel(K k) {
if (k == null) {
k = (K) NULL_KEY;
}
this.groups.remove(k);
if (decrementAndGet() == 0) {
this.upstream.dispose();
}
}
@Override // io.reactivex.disposables.Disposable
public void dispose() {
if (this.cancelled.compareAndSet(false, true) && decrementAndGet() == 0) {
this.upstream.dispose();
}
}
public boolean isDisposed() {
return this.cancelled.get();
}
@Override // io.reactivex.Observer
public void onComplete() {
ArrayList arrayList = new ArrayList(this.groups.values());
this.groups.clear();
Iterator it = arrayList.iterator();
while (it.hasNext()) {
((GroupedUnicast) it.next()).onComplete();
}
this.downstream.onComplete();
}
@Override // io.reactivex.Observer
public void onError(Throwable th) {
ArrayList arrayList = new ArrayList(this.groups.values());
this.groups.clear();
Iterator it = arrayList.iterator();
while (it.hasNext()) {
((GroupedUnicast) it.next()).onError(th);
}
this.downstream.onError(th);
}
@Override // io.reactivex.Observer
public void onNext(T t) {
try {
K apply = this.keySelector.apply(t);
Object obj = apply != null ? apply : NULL_KEY;
GroupedUnicast<K, V> groupedUnicast = this.groups.get(obj);
if (groupedUnicast == null) {
if (this.cancelled.get()) {
return;
}
groupedUnicast = GroupedUnicast.a(apply, this.bufferSize, this, this.delayError);
this.groups.put(obj, groupedUnicast);
getAndIncrement();
this.downstream.onNext(groupedUnicast);
}
try {
V apply2 = this.valueSelector.apply(t);
ObjectHelper.a(apply2, "The value supplied is null");
groupedUnicast.onNext(apply2);
} catch (Throwable th) {
Exceptions.b(th);
this.upstream.dispose();
onError(th);
}
} catch (Throwable th2) {
Exceptions.b(th2);
this.upstream.dispose();
onError(th2);
}
}
@Override // io.reactivex.Observer
public void onSubscribe(Disposable disposable) {
if (DisposableHelper.validate(this.upstream, disposable)) {
this.upstream = disposable;
this.downstream.onSubscribe(this);
}
}
}
static final class GroupedUnicast<K, T> extends GroupedObservable<K, T> {
final State<T, K> a;
protected GroupedUnicast(K k, State<T, K> state) {
super(k);
this.a = state;
}
public static <T, K> GroupedUnicast<K, T> a(K k, int i, GroupByObserver<?, K, T> groupByObserver, boolean z) {
return new GroupedUnicast<>(k, new State(i, groupByObserver, k, z));
}
public void onComplete() {
this.a.b();
}
public void onError(Throwable th) {
this.a.a(th);
}
public void onNext(T t) {
this.a.a((State<T, K>) t);
}
@Override // io.reactivex.Observable
protected void subscribeActual(Observer<? super T> observer) {
this.a.subscribe(observer);
}
}
public ObservableGroupBy(ObservableSource<T> observableSource, Function<? super T, ? extends K> function, Function<? super T, ? extends V> function2, int i, boolean z) {
super(observableSource);
this.b = function;
this.c = function2;
this.d = i;
this.e = z;
}
@Override // io.reactivex.Observable
public void subscribeActual(Observer<? super GroupedObservable<K, V>> observer) {
this.a.subscribe(new GroupByObserver(observer, this.b, this.c, this.d, this.e));
}
static final class State<T, K> extends AtomicInteger implements Disposable, ObservableSource<T> {
final K a;
final SpscLinkedArrayQueue<T> b;
final GroupByObserver<?, K, T> c;
final boolean d;
volatile boolean e;
Throwable f;
final AtomicBoolean g = new AtomicBoolean();
final AtomicBoolean h = new AtomicBoolean();
final AtomicReference<Observer<? super T>> i = new AtomicReference<>();
State(int i, GroupByObserver<?, K, T> groupByObserver, K k, boolean z) {
this.b = new SpscLinkedArrayQueue<>(i);
this.c = groupByObserver;
this.a = k;
this.d = z;
}
public void a(T t) {
this.b.offer(t);
a();
}
public void b() {
this.e = true;
a();
}
@Override // io.reactivex.disposables.Disposable
public void dispose() {
if (this.g.compareAndSet(false, true) && getAndIncrement() == 0) {
this.i.lazySet(null);
this.c.cancel(this.a);
}
}
@Override // io.reactivex.ObservableSource
public void subscribe(Observer<? super T> observer) {
if (!this.h.compareAndSet(false, true)) {
EmptyDisposable.error(new IllegalStateException("Only one Observer allowed!"), observer);
return;
}
observer.onSubscribe(this);
this.i.lazySet(observer);
if (this.g.get()) {
this.i.lazySet(null);
} else {
a();
}
}
public void a(Throwable th) {
this.f = th;
this.e = true;
a();
}
void a() {
if (getAndIncrement() != 0) {
return;
}
SpscLinkedArrayQueue<T> spscLinkedArrayQueue = this.b;
boolean z = this.d;
Observer<? super T> observer = this.i.get();
int i = 1;
while (true) {
if (observer != null) {
while (true) {
boolean z2 = this.e;
T poll = spscLinkedArrayQueue.poll();
boolean z3 = poll == null;
if (a(z2, z3, observer, z)) {
return;
}
if (z3) {
break;
} else {
observer.onNext(poll);
}
}
}
i = addAndGet(-i);
if (i == 0) {
return;
}
if (observer == null) {
observer = this.i.get();
}
}
}
boolean a(boolean z, boolean z2, Observer<? super T> observer, boolean z3) {
if (this.g.get()) {
this.b.clear();
this.c.cancel(this.a);
this.i.lazySet(null);
return true;
}
if (!z) {
return false;
}
if (z3) {
if (!z2) {
return false;
}
Throwable th = this.f;
this.i.lazySet(null);
if (th != null) {
observer.onError(th);
} else {
observer.onComplete();
}
return true;
}
Throwable th2 = this.f;
if (th2 != null) {
this.b.clear();
this.i.lazySet(null);
observer.onError(th2);
return true;
}
if (!z2) {
return false;
}
this.i.lazySet(null);
observer.onComplete();
return true;
}
}
}

351
sources/io/reactivex/internal/operators/observable/ObservableGroupJoin.java Normal file
View File

@@ -0,0 +1,351 @@
package io.reactivex.internal.operators.observable;
import io.reactivex.Observable;
import io.reactivex.ObservableSource;
import io.reactivex.Observer;
import io.reactivex.disposables.CompositeDisposable;
import io.reactivex.disposables.Disposable;
import io.reactivex.exceptions.Exceptions;
import io.reactivex.functions.BiFunction;
import io.reactivex.functions.Function;
import io.reactivex.internal.disposables.DisposableHelper;
import io.reactivex.internal.functions.ObjectHelper;
import io.reactivex.internal.queue.SpscLinkedArrayQueue;
import io.reactivex.internal.util.ExceptionHelper;
import io.reactivex.plugins.RxJavaPlugins;
import io.reactivex.subjects.UnicastSubject;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicReference;
/* loaded from: classes2.dex */
public final class ObservableGroupJoin<TLeft, TRight, TLeftEnd, TRightEnd, R> extends AbstractObservableWithUpstream<TLeft, R> {
final ObservableSource<? extends TRight> b;
final Function<? super TLeft, ? extends ObservableSource<TLeftEnd>> c;
final Function<? super TRight, ? extends ObservableSource<TRightEnd>> d;
final BiFunction<? super TLeft, ? super Observable<TRight>, ? extends R> e;
static final class GroupJoinDisposable<TLeft, TRight, TLeftEnd, TRightEnd, R> extends AtomicInteger implements Disposable, JoinSupport {
static final Integer n = 1;
static final Integer o = 2;
static final Integer p = 3;
static final Integer q = 4;
final Observer<? super R> a;
final Function<? super TLeft, ? extends ObservableSource<TLeftEnd>> g;
final Function<? super TRight, ? extends ObservableSource<TRightEnd>> h;
final BiFunction<? super TLeft, ? super Observable<TRight>, ? extends R> i;
int k;
int l;
volatile boolean m;
final CompositeDisposable c = new CompositeDisposable();
final SpscLinkedArrayQueue<Object> b = new SpscLinkedArrayQueue<>(Observable.bufferSize());
final Map<Integer, UnicastSubject<TRight>> d = new LinkedHashMap();
final Map<Integer, TRight> e = new LinkedHashMap();
final AtomicReference<Throwable> f = new AtomicReference<>();
final AtomicInteger j = new AtomicInteger(2);
GroupJoinDisposable(Observer<? super R> observer, Function<? super TLeft, ? extends ObservableSource<TLeftEnd>> function, Function<? super TRight, ? extends ObservableSource<TRightEnd>> function2, BiFunction<? super TLeft, ? super Observable<TRight>, ? extends R> biFunction) {
this.a = observer;
this.g = function;
this.h = function2;
this.i = biFunction;
}
void a() {
this.c.dispose();
}
void b() {
if (getAndIncrement() != 0) {
return;
}
SpscLinkedArrayQueue<?> spscLinkedArrayQueue = this.b;
Observer<? super R> observer = this.a;
int i = 1;
while (!this.m) {
if (this.f.get() != null) {
spscLinkedArrayQueue.clear();
a();
a(observer);
return;
}
boolean z = this.j.get() == 0;
Integer num = (Integer) spscLinkedArrayQueue.poll();
boolean z2 = num == null;
if (z && z2) {
Iterator<UnicastSubject<TRight>> it = this.d.values().iterator();
while (it.hasNext()) {
it.next().onComplete();
}
this.d.clear();
this.e.clear();
this.c.dispose();
observer.onComplete();
return;
}
if (z2) {
i = addAndGet(-i);
if (i == 0) {
return;
}
} else {
Object poll = spscLinkedArrayQueue.poll();
if (num == n) {
UnicastSubject d = UnicastSubject.d();
int i2 = this.k;
this.k = i2 + 1;
this.d.put(Integer.valueOf(i2), d);
try {
ObservableSource apply = this.g.apply(poll);
ObjectHelper.a(apply, "The leftEnd returned a null ObservableSource");
ObservableSource observableSource = apply;
LeftRightEndObserver leftRightEndObserver = new LeftRightEndObserver(this, true, i2);
this.c.b(leftRightEndObserver);
observableSource.subscribe(leftRightEndObserver);
if (this.f.get() != null) {
spscLinkedArrayQueue.clear();
a();
a(observer);
return;
}
try {
R apply2 = this.i.apply(poll, d);
ObjectHelper.a(apply2, "The resultSelector returned a null value");
observer.onNext(apply2);
Iterator<TRight> it2 = this.e.values().iterator();
while (it2.hasNext()) {
d.onNext(it2.next());
}
} catch (Throwable th) {
a(th, observer, spscLinkedArrayQueue);
return;
}
} catch (Throwable th2) {
a(th2, observer, spscLinkedArrayQueue);
return;
}
} else if (num == o) {
int i3 = this.l;
this.l = i3 + 1;
this.e.put(Integer.valueOf(i3), poll);
try {
ObservableSource apply3 = this.h.apply(poll);
ObjectHelper.a(apply3, "The rightEnd returned a null ObservableSource");
ObservableSource observableSource2 = apply3;
LeftRightEndObserver leftRightEndObserver2 = new LeftRightEndObserver(this, false, i3);
this.c.b(leftRightEndObserver2);
observableSource2.subscribe(leftRightEndObserver2);
if (this.f.get() != null) {
spscLinkedArrayQueue.clear();
a();
a(observer);
return;
} else {
Iterator<UnicastSubject<TRight>> it3 = this.d.values().iterator();
while (it3.hasNext()) {
it3.next().onNext(poll);
}
}
} catch (Throwable th3) {
a(th3, observer, spscLinkedArrayQueue);
return;
}
} else if (num == p) {
LeftRightEndObserver leftRightEndObserver3 = (LeftRightEndObserver) poll;
UnicastSubject<TRight> remove = this.d.remove(Integer.valueOf(leftRightEndObserver3.c));
this.c.a(leftRightEndObserver3);
if (remove != null) {
remove.onComplete();
}
} else if (num == q) {
LeftRightEndObserver leftRightEndObserver4 = (LeftRightEndObserver) poll;
this.e.remove(Integer.valueOf(leftRightEndObserver4.c));
this.c.a(leftRightEndObserver4);
}
}
}
spscLinkedArrayQueue.clear();
}
@Override // io.reactivex.disposables.Disposable
public void dispose() {
if (this.m) {
return;
}
this.m = true;
a();
if (getAndIncrement() == 0) {
this.b.clear();
}
}
void a(Observer<?> observer) {
Throwable a = ExceptionHelper.a(this.f);
Iterator<UnicastSubject<TRight>> it = this.d.values().iterator();
while (it.hasNext()) {
it.next().onError(a);
}
this.d.clear();
this.e.clear();
observer.onError(a);
}
void a(Throwable th, Observer<?> observer, SpscLinkedArrayQueue<?> spscLinkedArrayQueue) {
Exceptions.b(th);
ExceptionHelper.a(this.f, th);
spscLinkedArrayQueue.clear();
a();
a(observer);
}
@Override // io.reactivex.internal.operators.observable.ObservableGroupJoin.JoinSupport
public void a(LeftRightObserver leftRightObserver) {
this.c.c(leftRightObserver);
this.j.decrementAndGet();
b();
}
@Override // io.reactivex.internal.operators.observable.ObservableGroupJoin.JoinSupport
public void a(boolean z, Object obj) {
synchronized (this) {
this.b.a(z ? n : o, (Integer) obj);
}
b();
}
@Override // io.reactivex.internal.operators.observable.ObservableGroupJoin.JoinSupport
public void a(boolean z, LeftRightEndObserver leftRightEndObserver) {
synchronized (this) {
this.b.a(z ? p : q, (Integer) leftRightEndObserver);
}
b();
}
@Override // io.reactivex.internal.operators.observable.ObservableGroupJoin.JoinSupport
public void a(Throwable th) {
if (ExceptionHelper.a(this.f, th)) {
b();
} else {
RxJavaPlugins.b(th);
}
}
@Override // io.reactivex.internal.operators.observable.ObservableGroupJoin.JoinSupport
public void b(Throwable th) {
if (ExceptionHelper.a(this.f, th)) {
this.j.decrementAndGet();
b();
} else {
RxJavaPlugins.b(th);
}
}
}
interface JoinSupport {
void a(LeftRightObserver leftRightObserver);
void a(Throwable th);
void a(boolean z, LeftRightEndObserver leftRightEndObserver);
void a(boolean z, Object obj);
void b(Throwable th);
}
static final class LeftRightEndObserver extends AtomicReference<Disposable> implements Observer<Object>, Disposable {
final JoinSupport a;
final boolean b;
final int c;
LeftRightEndObserver(JoinSupport joinSupport, boolean z, int i) {
this.a = joinSupport;
this.b = z;
this.c = i;
}
@Override // io.reactivex.disposables.Disposable
public void dispose() {
DisposableHelper.dispose(this);
}
@Override // io.reactivex.Observer
public void onComplete() {
this.a.a(this.b, this);
}
@Override // io.reactivex.Observer
public void onError(Throwable th) {
this.a.a(th);
}
@Override // io.reactivex.Observer
public void onNext(Object obj) {
if (DisposableHelper.dispose(this)) {
this.a.a(this.b, this);
}
}
@Override // io.reactivex.Observer
public void onSubscribe(Disposable disposable) {
DisposableHelper.setOnce(this, disposable);
}
}
static final class LeftRightObserver extends AtomicReference<Disposable> implements Observer<Object>, Disposable {
final JoinSupport a;
final boolean b;
LeftRightObserver(JoinSupport joinSupport, boolean z) {
this.a = joinSupport;
this.b = z;
}
@Override // io.reactivex.disposables.Disposable
public void dispose() {
DisposableHelper.dispose(this);
}
@Override // io.reactivex.Observer
public void onComplete() {
this.a.a(this);
}
@Override // io.reactivex.Observer
public void onError(Throwable th) {
this.a.b(th);
}
@Override // io.reactivex.Observer
public void onNext(Object obj) {
this.a.a(this.b, obj);
}
@Override // io.reactivex.Observer
public void onSubscribe(Disposable disposable) {
DisposableHelper.setOnce(this, disposable);
}
}
public ObservableGroupJoin(ObservableSource<TLeft> observableSource, ObservableSource<? extends TRight> observableSource2, Function<? super TLeft, ? extends ObservableSource<TLeftEnd>> function, Function<? super TRight, ? extends ObservableSource<TRightEnd>> function2, BiFunction<? super TLeft, ? super Observable<TRight>, ? extends R> biFunction) {
super(observableSource);
this.b = observableSource2;
this.c = function;
this.d = function2;
this.e = biFunction;
}
@Override // io.reactivex.Observable
protected void subscribeActual(Observer<? super R> observer) {
GroupJoinDisposable groupJoinDisposable = new GroupJoinDisposable(observer, this.c, this.d, this.e);
observer.onSubscribe(groupJoinDisposable);
LeftRightObserver leftRightObserver = new LeftRightObserver(groupJoinDisposable, true);
groupJoinDisposable.c.b(leftRightObserver);
LeftRightObserver leftRightObserver2 = new LeftRightObserver(groupJoinDisposable, false);
groupJoinDisposable.c.b(leftRightObserver2);
this.a.subscribe(leftRightObserver);
this.b.subscribe(leftRightObserver2);
}
}

56
sources/io/reactivex/internal/operators/observable/ObservableHide.java Normal file
View File

@@ -0,0 +1,56 @@
package io.reactivex.internal.operators.observable;
import io.reactivex.ObservableSource;
import io.reactivex.Observer;
import io.reactivex.disposables.Disposable;
import io.reactivex.internal.disposables.DisposableHelper;
/* loaded from: classes2.dex */
public final class ObservableHide<T> extends AbstractObservableWithUpstream<T, T> {
static final class HideDisposable<T> implements Observer<T>, Disposable {
final Observer<? super T> a;
Disposable b;
HideDisposable(Observer<? super T> observer) {
this.a = observer;
}
@Override // io.reactivex.disposables.Disposable
public void dispose() {
this.b.dispose();
}
@Override // io.reactivex.Observer
public void onComplete() {
this.a.onComplete();
}
@Override // io.reactivex.Observer
public void onError(Throwable th) {
this.a.onError(th);
}
@Override // io.reactivex.Observer
public void onNext(T t) {
this.a.onNext(t);
}
@Override // io.reactivex.Observer
public void onSubscribe(Disposable disposable) {
if (DisposableHelper.validate(this.b, disposable)) {
this.b = disposable;
this.a.onSubscribe(this);
}
}
}
public ObservableHide(ObservableSource<T> observableSource) {
super(observableSource);
}
@Override // io.reactivex.Observable
protected void subscribeActual(Observer<? super T> observer) {
this.a.subscribe(new HideDisposable(observer));
}
}

52
sources/io/reactivex/internal/operators/observable/ObservableIgnoreElements.java Normal file
View File

@@ -0,0 +1,52 @@
package io.reactivex.internal.operators.observable;
import io.reactivex.ObservableSource;
import io.reactivex.Observer;
import io.reactivex.disposables.Disposable;
/* loaded from: classes2.dex */
public final class ObservableIgnoreElements<T> extends AbstractObservableWithUpstream<T, T> {
static final class IgnoreObservable<T> implements Observer<T>, Disposable {
final Observer<? super T> a;
Disposable b;
IgnoreObservable(Observer<? super T> observer) {
this.a = observer;
}
@Override // io.reactivex.disposables.Disposable
public void dispose() {
this.b.dispose();
}
@Override // io.reactivex.Observer
public void onComplete() {
this.a.onComplete();
}
@Override // io.reactivex.Observer
public void onError(Throwable th) {
this.a.onError(th);
}
@Override // io.reactivex.Observer
public void onNext(T t) {
}
@Override // io.reactivex.Observer
public void onSubscribe(Disposable disposable) {
this.b = disposable;
this.a.onSubscribe(this);
}
}
public ObservableIgnoreElements(ObservableSource<T> observableSource) {
super(observableSource);
}
@Override // io.reactivex.Observable
public void subscribeActual(Observer<? super T> observer) {
this.a.subscribe(new IgnoreObservable(observer));
}
}

63
sources/io/reactivex/internal/operators/observable/ObservableIgnoreElementsCompletable.java Normal file
View File

@@ -0,0 +1,63 @@
package io.reactivex.internal.operators.observable;
import io.reactivex.Completable;
import io.reactivex.CompletableObserver;
import io.reactivex.Observable;
import io.reactivex.ObservableSource;
import io.reactivex.Observer;
import io.reactivex.disposables.Disposable;
import io.reactivex.internal.fuseable.FuseToObservable;
import io.reactivex.plugins.RxJavaPlugins;
/* loaded from: classes2.dex */
public final class ObservableIgnoreElementsCompletable<T> extends Completable implements FuseToObservable<T> {
final ObservableSource<T> a;
static final class IgnoreObservable<T> implements Observer<T>, Disposable {
final CompletableObserver a;
Disposable b;
IgnoreObservable(CompletableObserver completableObserver) {
this.a = completableObserver;
}
@Override // io.reactivex.disposables.Disposable
public void dispose() {
this.b.dispose();
}
@Override // io.reactivex.Observer
public void onComplete() {
this.a.onComplete();
}
@Override // io.reactivex.Observer
public void onError(Throwable th) {
this.a.onError(th);
}
@Override // io.reactivex.Observer
public void onNext(T t) {
}
@Override // io.reactivex.Observer
public void onSubscribe(Disposable disposable) {
this.b = disposable;
this.a.onSubscribe(this);
}
}
public ObservableIgnoreElementsCompletable(ObservableSource<T> observableSource) {
this.a = observableSource;
}
@Override // io.reactivex.internal.fuseable.FuseToObservable
public Observable<T> a() {
return RxJavaPlugins.a(new ObservableIgnoreElements(this.a));
}
@Override // io.reactivex.Completable
public void b(CompletableObserver completableObserver) {
this.a.subscribe(new IgnoreObservable(completableObserver));
}
}

338
sources/io/reactivex/internal/operators/observable/ObservableInternalHelper.java Normal file
View File

@@ -0,0 +1,338 @@
package io.reactivex.internal.operators.observable;
import io.reactivex.Emitter;
import io.reactivex.Observable;
import io.reactivex.ObservableSource;
import io.reactivex.Observer;
import io.reactivex.Scheduler;
import io.reactivex.functions.Action;
import io.reactivex.functions.BiConsumer;
import io.reactivex.functions.BiFunction;
import io.reactivex.functions.Consumer;
import io.reactivex.functions.Function;
import io.reactivex.internal.functions.Functions;
import io.reactivex.internal.functions.ObjectHelper;
import io.reactivex.observables.ConnectableObservable;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.TimeUnit;
/* loaded from: classes2.dex */
public final class ObservableInternalHelper {
static final class BufferedReplayCallable<T> implements Callable<ConnectableObservable<T>> {
private final Observable<T> a;
private final int b;
BufferedReplayCallable(Observable<T> observable, int i) {
this.a = observable;
this.b = i;
}
@Override // java.util.concurrent.Callable
public ConnectableObservable<T> call() {
return this.a.replay(this.b);
}
}
static final class BufferedTimedReplayCallable<T> implements Callable<ConnectableObservable<T>> {
private final Observable<T> a;
private final int b;
private final long c;
private final TimeUnit d;
private final Scheduler e;
BufferedTimedReplayCallable(Observable<T> observable, int i, long j, TimeUnit timeUnit, Scheduler scheduler) {
this.a = observable;
this.b = i;
this.c = j;
this.d = timeUnit;
this.e = scheduler;
}
@Override // java.util.concurrent.Callable
public ConnectableObservable<T> call() {
return this.a.replay(this.b, this.c, this.d, this.e);
}
}
static final class FlatMapIntoIterable<T, U> implements Function<T, ObservableSource<U>> {
private final Function<? super T, ? extends Iterable<? extends U>> a;
FlatMapIntoIterable(Function<? super T, ? extends Iterable<? extends U>> function) {
this.a = function;
}
/* JADX WARN: Multi-variable type inference failed */
@Override // io.reactivex.functions.Function
public /* bridge */ /* synthetic */ Object apply(Object obj) throws Exception {
return apply((FlatMapIntoIterable<T, U>) obj);
}
@Override // io.reactivex.functions.Function
public ObservableSource<U> apply(T t) throws Exception {
Iterable<? extends U> apply = this.a.apply(t);
ObjectHelper.a(apply, "The mapper returned a null Iterable");
return new ObservableFromIterable(apply);
}
}
static final class FlatMapWithCombinerInner<U, R, T> implements Function<U, R> {
private final BiFunction<? super T, ? super U, ? extends R> a;
private final T b;
FlatMapWithCombinerInner(BiFunction<? super T, ? super U, ? extends R> biFunction, T t) {
this.a = biFunction;
this.b = t;
}
@Override // io.reactivex.functions.Function
public R apply(U u) throws Exception {
return this.a.apply(this.b, u);
}
}
static final class FlatMapWithCombinerOuter<T, R, U> implements Function<T, ObservableSource<R>> {
private final BiFunction<? super T, ? super U, ? extends R> a;
private final Function<? super T, ? extends ObservableSource<? extends U>> b;
FlatMapWithCombinerOuter(BiFunction<? super T, ? super U, ? extends R> biFunction, Function<? super T, ? extends ObservableSource<? extends U>> function) {
this.a = biFunction;
this.b = function;
}
/* JADX WARN: Multi-variable type inference failed */
@Override // io.reactivex.functions.Function
public /* bridge */ /* synthetic */ Object apply(Object obj) throws Exception {
return apply((FlatMapWithCombinerOuter<T, R, U>) obj);
}
@Override // io.reactivex.functions.Function
public ObservableSource<R> apply(T t) throws Exception {
ObservableSource<? extends U> apply = this.b.apply(t);
ObjectHelper.a(apply, "The mapper returned a null ObservableSource");
return new ObservableMap(apply, new FlatMapWithCombinerInner(this.a, t));
}
}
static final class ItemDelayFunction<T, U> implements Function<T, ObservableSource<T>> {
final Function<? super T, ? extends ObservableSource<U>> a;
ItemDelayFunction(Function<? super T, ? extends ObservableSource<U>> function) {
this.a = function;
}
/* JADX WARN: Multi-variable type inference failed */
@Override // io.reactivex.functions.Function
public /* bridge */ /* synthetic */ Object apply(Object obj) throws Exception {
return apply((ItemDelayFunction<T, U>) obj);
}
@Override // io.reactivex.functions.Function
public ObservableSource<T> apply(T t) throws Exception {
ObservableSource<U> apply = this.a.apply(t);
ObjectHelper.a(apply, "The itemDelay returned a null ObservableSource");
return new ObservableTake(apply, 1L).map(Functions.c(t)).defaultIfEmpty(t);
}
}
static final class ObserverOnComplete<T> implements Action {
final Observer<T> a;
ObserverOnComplete(Observer<T> observer) {
this.a = observer;
}
@Override // io.reactivex.functions.Action
public void run() throws Exception {
this.a.onComplete();
}
}
static final class ObserverOnError<T> implements Consumer<Throwable> {
final Observer<T> a;
ObserverOnError(Observer<T> observer) {
this.a = observer;
}
@Override // io.reactivex.functions.Consumer
/* renamed from: a, reason: merged with bridge method [inline-methods] */
public void accept(Throwable th) throws Exception {
this.a.onError(th);
}
}
static final class ObserverOnNext<T> implements Consumer<T> {
final Observer<T> a;
ObserverOnNext(Observer<T> observer) {
this.a = observer;
}
@Override // io.reactivex.functions.Consumer
public void accept(T t) throws Exception {
this.a.onNext(t);
}
}
static final class ReplayCallable<T> implements Callable<ConnectableObservable<T>> {
private final Observable<T> a;
ReplayCallable(Observable<T> observable) {
this.a = observable;
}
@Override // java.util.concurrent.Callable
public ConnectableObservable<T> call() {
return this.a.replay();
}
}
static final class ReplayFunction<T, R> implements Function<Observable<T>, ObservableSource<R>> {
private final Function<? super Observable<T>, ? extends ObservableSource<R>> a;
private final Scheduler b;
ReplayFunction(Function<? super Observable<T>, ? extends ObservableSource<R>> function, Scheduler scheduler) {
this.a = function;
this.b = scheduler;
}
@Override // io.reactivex.functions.Function
/* renamed from: a, reason: merged with bridge method [inline-methods] */
public ObservableSource<R> apply(Observable<T> observable) throws Exception {
ObservableSource<R> apply = this.a.apply(observable);
ObjectHelper.a(apply, "The selector returned a null ObservableSource");
return Observable.wrap(apply).observeOn(this.b);
}
}
static final class SimpleBiGenerator<T, S> implements BiFunction<S, Emitter<T>, S> {
final BiConsumer<S, Emitter<T>> a;
SimpleBiGenerator(BiConsumer<S, Emitter<T>> biConsumer) {
this.a = biConsumer;
}
public S a(S s, Emitter<T> emitter) throws Exception {
this.a.a(s, emitter);
return s;
}
/* JADX WARN: Multi-variable type inference failed */
@Override // io.reactivex.functions.BiFunction
public /* bridge */ /* synthetic */ Object apply(Object obj, Object obj2) throws Exception {
a(obj, (Emitter) obj2);
return obj;
}
}
static final class SimpleGenerator<T, S> implements BiFunction<S, Emitter<T>, S> {
final Consumer<Emitter<T>> a;
SimpleGenerator(Consumer<Emitter<T>> consumer) {
this.a = consumer;
}
public S a(S s, Emitter<T> emitter) throws Exception {
this.a.accept(emitter);
return s;
}
/* JADX WARN: Multi-variable type inference failed */
@Override // io.reactivex.functions.BiFunction
public /* bridge */ /* synthetic */ Object apply(Object obj, Object obj2) throws Exception {
a(obj, (Emitter) obj2);
return obj;
}
}
static final class TimedReplayCallable<T> implements Callable<ConnectableObservable<T>> {
private final Observable<T> a;
private final long b;
private final TimeUnit c;
private final Scheduler d;
TimedReplayCallable(Observable<T> observable, long j, TimeUnit timeUnit, Scheduler scheduler) {
this.a = observable;
this.b = j;
this.c = timeUnit;
this.d = scheduler;
}
@Override // java.util.concurrent.Callable
public ConnectableObservable<T> call() {
return this.a.replay(this.b, this.c, this.d);
}
}
static final class ZipIterableFunction<T, R> implements Function<List<ObservableSource<? extends T>>, ObservableSource<? extends R>> {
private final Function<? super Object[], ? extends R> a;
ZipIterableFunction(Function<? super Object[], ? extends R> function) {
this.a = function;
}
@Override // io.reactivex.functions.Function
/* renamed from: a, reason: merged with bridge method [inline-methods] */
public ObservableSource<? extends R> apply(List<ObservableSource<? extends T>> list) {
return Observable.zipIterable(list, this.a, false, Observable.bufferSize());
}
}
public static <T, S> BiFunction<S, Emitter<T>, S> a(Consumer<Emitter<T>> consumer) {
return new SimpleGenerator(consumer);
}
public static <T, U> Function<T, ObservableSource<T>> b(Function<? super T, ? extends ObservableSource<U>> function) {
return new ItemDelayFunction(function);
}
public static <T> Consumer<T> c(Observer<T> observer) {
return new ObserverOnNext(observer);
}
public static <T, S> BiFunction<S, Emitter<T>, S> a(BiConsumer<S, Emitter<T>> biConsumer) {
return new SimpleBiGenerator(biConsumer);
}
public static <T> Consumer<Throwable> b(Observer<T> observer) {
return new ObserverOnError(observer);
}
public static <T, R> Function<List<ObservableSource<? extends T>>, ObservableSource<? extends R>> c(Function<? super Object[], ? extends R> function) {
return new ZipIterableFunction(function);
}
public static <T> Action a(Observer<T> observer) {
return new ObserverOnComplete(observer);
}
public static <T, U, R> Function<T, ObservableSource<R>> a(Function<? super T, ? extends ObservableSource<? extends U>> function, BiFunction<? super T, ? super U, ? extends R> biFunction) {
return new FlatMapWithCombinerOuter(biFunction, function);
}
public static <T, U> Function<T, ObservableSource<U>> a(Function<? super T, ? extends Iterable<? extends U>> function) {
return new FlatMapIntoIterable(function);
}
public static <T> Callable<ConnectableObservable<T>> a(Observable<T> observable) {
return new ReplayCallable(observable);
}
public static <T> Callable<ConnectableObservable<T>> a(Observable<T> observable, int i) {
return new BufferedReplayCallable(observable, i);
}
public static <T> Callable<ConnectableObservable<T>> a(Observable<T> observable, int i, long j, TimeUnit timeUnit, Scheduler scheduler) {
return new BufferedTimedReplayCallable(observable, i, j, timeUnit, scheduler);
}
public static <T> Callable<ConnectableObservable<T>> a(Observable<T> observable, long j, TimeUnit timeUnit, Scheduler scheduler) {
return new TimedReplayCallable(observable, j, timeUnit, scheduler);
}
public static <T, R> Function<Observable<T>, ObservableSource<R>> a(Function<? super Observable<T>, ? extends ObservableSource<R>> function, Scheduler scheduler) {
return new ReplayFunction(function, scheduler);
}
}

67
sources/io/reactivex/internal/operators/observable/ObservableInterval.java Normal file
View File

@@ -0,0 +1,67 @@
package io.reactivex.internal.operators.observable;
import io.reactivex.Observable;
import io.reactivex.Observer;
import io.reactivex.Scheduler;
import io.reactivex.disposables.Disposable;
import io.reactivex.internal.disposables.DisposableHelper;
import io.reactivex.internal.schedulers.TrampolineScheduler;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicReference;
/* loaded from: classes2.dex */
public final class ObservableInterval extends Observable<Long> {
final Scheduler a;
final long b;
final long c;
final TimeUnit d;
static final class IntervalObserver extends AtomicReference<Disposable> implements Disposable, Runnable {
final Observer<? super Long> a;
long b;
IntervalObserver(Observer<? super Long> observer) {
this.a = observer;
}
public void a(Disposable disposable) {
DisposableHelper.setOnce(this, disposable);
}
@Override // io.reactivex.disposables.Disposable
public void dispose() {
DisposableHelper.dispose(this);
}
@Override // java.lang.Runnable
public void run() {
if (get() != DisposableHelper.DISPOSED) {
Observer<? super Long> observer = this.a;
long j = this.b;
this.b = 1 + j;
observer.onNext(Long.valueOf(j));
}
}
}
public ObservableInterval(long j, long j2, TimeUnit timeUnit, Scheduler scheduler) {
this.b = j;
this.c = j2;
this.d = timeUnit;
this.a = scheduler;
}
@Override // io.reactivex.Observable
public void subscribeActual(Observer<? super Long> observer) {
IntervalObserver intervalObserver = new IntervalObserver(observer);
observer.onSubscribe(intervalObserver);
Scheduler scheduler = this.a;
if (!(scheduler instanceof TrampolineScheduler)) {
intervalObserver.a(scheduler.a(intervalObserver, this.b, this.c, this.d));
return;
}
Scheduler.Worker a = scheduler.a();
intervalObserver.a(a);
a.a(intervalObserver, this.b, this.c, this.d);
}
}

83
sources/io/reactivex/internal/operators/observable/ObservableIntervalRange.java Normal file
View File

@@ -0,0 +1,83 @@
package io.reactivex.internal.operators.observable;
import io.reactivex.Observable;
import io.reactivex.Observer;
import io.reactivex.Scheduler;
import io.reactivex.disposables.Disposable;
import io.reactivex.internal.disposables.DisposableHelper;
import io.reactivex.internal.schedulers.TrampolineScheduler;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicReference;
/* loaded from: classes2.dex */
public final class ObservableIntervalRange extends Observable<Long> {
final Scheduler a;
final long b;
final long c;
final long d;
final long e;
final TimeUnit f;
static final class IntervalRangeObserver extends AtomicReference<Disposable> implements Disposable, Runnable {
final Observer<? super Long> a;
final long b;
long c;
IntervalRangeObserver(Observer<? super Long> observer, long j, long j2) {
this.a = observer;
this.c = j;
this.b = j2;
}
public boolean a() {
return get() == DisposableHelper.DISPOSED;
}
@Override // io.reactivex.disposables.Disposable
public void dispose() {
DisposableHelper.dispose(this);
}
@Override // java.lang.Runnable
public void run() {
if (a()) {
return;
}
long j = this.c;
this.a.onNext(Long.valueOf(j));
if (j != this.b) {
this.c = j + 1;
} else {
DisposableHelper.dispose(this);
this.a.onComplete();
}
}
public void a(Disposable disposable) {
DisposableHelper.setOnce(this, disposable);
}
}
public ObservableIntervalRange(long j, long j2, long j3, long j4, TimeUnit timeUnit, Scheduler scheduler) {
this.d = j3;
this.e = j4;
this.f = timeUnit;
this.a = scheduler;
this.b = j;
this.c = j2;
}
@Override // io.reactivex.Observable
public void subscribeActual(Observer<? super Long> observer) {
IntervalRangeObserver intervalRangeObserver = new IntervalRangeObserver(observer, this.b, this.c);
observer.onSubscribe(intervalRangeObserver);
Scheduler scheduler = this.a;
if (!(scheduler instanceof TrampolineScheduler)) {
intervalRangeObserver.a(scheduler.a(intervalRangeObserver, this.d, this.e, this.f));
return;
}
Scheduler.Worker a = scheduler.a();
intervalRangeObserver.a(a);
a.a(intervalRangeObserver, this.d, this.e, this.f);
}
}

257
sources/io/reactivex/internal/operators/observable/ObservableJoin.java Normal file
View File

@@ -0,0 +1,257 @@
package io.reactivex.internal.operators.observable;
import io.reactivex.Observable;
import io.reactivex.ObservableSource;
import io.reactivex.Observer;
import io.reactivex.disposables.CompositeDisposable;
import io.reactivex.disposables.Disposable;
import io.reactivex.exceptions.Exceptions;
import io.reactivex.functions.BiFunction;
import io.reactivex.functions.Function;
import io.reactivex.internal.functions.ObjectHelper;
import io.reactivex.internal.operators.observable.ObservableGroupJoin;
import io.reactivex.internal.queue.SpscLinkedArrayQueue;
import io.reactivex.internal.util.ExceptionHelper;
import io.reactivex.plugins.RxJavaPlugins;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicReference;
/* loaded from: classes2.dex */
public final class ObservableJoin<TLeft, TRight, TLeftEnd, TRightEnd, R> extends AbstractObservableWithUpstream<TLeft, R> {
final ObservableSource<? extends TRight> b;
final Function<? super TLeft, ? extends ObservableSource<TLeftEnd>> c;
final Function<? super TRight, ? extends ObservableSource<TRightEnd>> d;
final BiFunction<? super TLeft, ? super TRight, ? extends R> e;
static final class JoinDisposable<TLeft, TRight, TLeftEnd, TRightEnd, R> extends AtomicInteger implements Disposable, ObservableGroupJoin.JoinSupport {
static final Integer n = 1;
static final Integer o = 2;
static final Integer p = 3;
static final Integer q = 4;
final Observer<? super R> a;
final Function<? super TLeft, ? extends ObservableSource<TLeftEnd>> g;
final Function<? super TRight, ? extends ObservableSource<TRightEnd>> h;
final BiFunction<? super TLeft, ? super TRight, ? extends R> i;
int k;
int l;
volatile boolean m;
final CompositeDisposable c = new CompositeDisposable();
final SpscLinkedArrayQueue<Object> b = new SpscLinkedArrayQueue<>(Observable.bufferSize());
final Map<Integer, TLeft> d = new LinkedHashMap();
final Map<Integer, TRight> e = new LinkedHashMap();
final AtomicReference<Throwable> f = new AtomicReference<>();
final AtomicInteger j = new AtomicInteger(2);
JoinDisposable(Observer<? super R> observer, Function<? super TLeft, ? extends ObservableSource<TLeftEnd>> function, Function<? super TRight, ? extends ObservableSource<TRightEnd>> function2, BiFunction<? super TLeft, ? super TRight, ? extends R> biFunction) {
this.a = observer;
this.g = function;
this.h = function2;
this.i = biFunction;
}
void a() {
this.c.dispose();
}
void b() {
if (getAndIncrement() != 0) {
return;
}
SpscLinkedArrayQueue<?> spscLinkedArrayQueue = this.b;
Observer<? super R> observer = this.a;
int i = 1;
while (!this.m) {
if (this.f.get() != null) {
spscLinkedArrayQueue.clear();
a();
a(observer);
return;
}
boolean z = this.j.get() == 0;
Integer num = (Integer) spscLinkedArrayQueue.poll();
boolean z2 = num == null;
if (z && z2) {
this.d.clear();
this.e.clear();
this.c.dispose();
observer.onComplete();
return;
}
if (z2) {
i = addAndGet(-i);
if (i == 0) {
return;
}
} else {
Object poll = spscLinkedArrayQueue.poll();
if (num == n) {
int i2 = this.k;
this.k = i2 + 1;
this.d.put(Integer.valueOf(i2), poll);
try {
ObservableSource apply = this.g.apply(poll);
ObjectHelper.a(apply, "The leftEnd returned a null ObservableSource");
ObservableSource observableSource = apply;
ObservableGroupJoin.LeftRightEndObserver leftRightEndObserver = new ObservableGroupJoin.LeftRightEndObserver(this, true, i2);
this.c.b(leftRightEndObserver);
observableSource.subscribe(leftRightEndObserver);
if (this.f.get() != null) {
spscLinkedArrayQueue.clear();
a();
a(observer);
return;
}
Iterator<TRight> it = this.e.values().iterator();
while (it.hasNext()) {
try {
R apply2 = this.i.apply(poll, it.next());
ObjectHelper.a(apply2, "The resultSelector returned a null value");
observer.onNext(apply2);
} catch (Throwable th) {
a(th, observer, spscLinkedArrayQueue);
return;
}
}
} catch (Throwable th2) {
a(th2, observer, spscLinkedArrayQueue);
return;
}
} else if (num == o) {
int i3 = this.l;
this.l = i3 + 1;
this.e.put(Integer.valueOf(i3), poll);
try {
ObservableSource apply3 = this.h.apply(poll);
ObjectHelper.a(apply3, "The rightEnd returned a null ObservableSource");
ObservableSource observableSource2 = apply3;
ObservableGroupJoin.LeftRightEndObserver leftRightEndObserver2 = new ObservableGroupJoin.LeftRightEndObserver(this, false, i3);
this.c.b(leftRightEndObserver2);
observableSource2.subscribe(leftRightEndObserver2);
if (this.f.get() != null) {
spscLinkedArrayQueue.clear();
a();
a(observer);
return;
}
Iterator<TLeft> it2 = this.d.values().iterator();
while (it2.hasNext()) {
try {
R apply4 = this.i.apply(it2.next(), poll);
ObjectHelper.a(apply4, "The resultSelector returned a null value");
observer.onNext(apply4);
} catch (Throwable th3) {
a(th3, observer, spscLinkedArrayQueue);
return;
}
}
} catch (Throwable th4) {
a(th4, observer, spscLinkedArrayQueue);
return;
}
} else if (num == p) {
ObservableGroupJoin.LeftRightEndObserver leftRightEndObserver3 = (ObservableGroupJoin.LeftRightEndObserver) poll;
this.d.remove(Integer.valueOf(leftRightEndObserver3.c));
this.c.a(leftRightEndObserver3);
} else {
ObservableGroupJoin.LeftRightEndObserver leftRightEndObserver4 = (ObservableGroupJoin.LeftRightEndObserver) poll;
this.e.remove(Integer.valueOf(leftRightEndObserver4.c));
this.c.a(leftRightEndObserver4);
}
}
}
spscLinkedArrayQueue.clear();
}
@Override // io.reactivex.disposables.Disposable
public void dispose() {
if (this.m) {
return;
}
this.m = true;
a();
if (getAndIncrement() == 0) {
this.b.clear();
}
}
void a(Observer<?> observer) {
Throwable a = ExceptionHelper.a(this.f);
this.d.clear();
this.e.clear();
observer.onError(a);
}
void a(Throwable th, Observer<?> observer, SpscLinkedArrayQueue<?> spscLinkedArrayQueue) {
Exceptions.b(th);
ExceptionHelper.a(this.f, th);
spscLinkedArrayQueue.clear();
a();
a(observer);
}
@Override // io.reactivex.internal.operators.observable.ObservableGroupJoin.JoinSupport
public void a(ObservableGroupJoin.LeftRightObserver leftRightObserver) {
this.c.c(leftRightObserver);
this.j.decrementAndGet();
b();
}
@Override // io.reactivex.internal.operators.observable.ObservableGroupJoin.JoinSupport
public void a(boolean z, Object obj) {
synchronized (this) {
this.b.a(z ? n : o, (Integer) obj);
}
b();
}
@Override // io.reactivex.internal.operators.observable.ObservableGroupJoin.JoinSupport
public void a(boolean z, ObservableGroupJoin.LeftRightEndObserver leftRightEndObserver) {
synchronized (this) {
this.b.a(z ? p : q, (Integer) leftRightEndObserver);
}
b();
}
@Override // io.reactivex.internal.operators.observable.ObservableGroupJoin.JoinSupport
public void a(Throwable th) {
if (ExceptionHelper.a(this.f, th)) {
b();
} else {
RxJavaPlugins.b(th);
}
}
@Override // io.reactivex.internal.operators.observable.ObservableGroupJoin.JoinSupport
public void b(Throwable th) {
if (ExceptionHelper.a(this.f, th)) {
this.j.decrementAndGet();
b();
} else {
RxJavaPlugins.b(th);
}
}
}
public ObservableJoin(ObservableSource<TLeft> observableSource, ObservableSource<? extends TRight> observableSource2, Function<? super TLeft, ? extends ObservableSource<TLeftEnd>> function, Function<? super TRight, ? extends ObservableSource<TRightEnd>> function2, BiFunction<? super TLeft, ? super TRight, ? extends R> biFunction) {
super(observableSource);
this.b = observableSource2;
this.c = function;
this.d = function2;
this.e = biFunction;
}
@Override // io.reactivex.Observable
protected void subscribeActual(Observer<? super R> observer) {
JoinDisposable joinDisposable = new JoinDisposable(observer, this.c, this.d, this.e);
observer.onSubscribe(joinDisposable);
ObservableGroupJoin.LeftRightObserver leftRightObserver = new ObservableGroupJoin.LeftRightObserver(joinDisposable, true);
joinDisposable.c.b(leftRightObserver);
ObservableGroupJoin.LeftRightObserver leftRightObserver2 = new ObservableGroupJoin.LeftRightObserver(joinDisposable, false);
joinDisposable.c.b(leftRightObserver2);
this.a.subscribe(leftRightObserver);
this.b.subscribe(leftRightObserver2);
}
}

27
sources/io/reactivex/internal/operators/observable/ObservableJust.java Normal file
View File

@@ -0,0 +1,27 @@
package io.reactivex.internal.operators.observable;
import io.reactivex.Observable;
import io.reactivex.Observer;
import io.reactivex.internal.fuseable.ScalarCallable;
import io.reactivex.internal.operators.observable.ObservableScalarXMap;
/* loaded from: classes2.dex */
public final class ObservableJust<T> extends Observable<T> implements ScalarCallable<T> {
private final T a;
public ObservableJust(T t) {
this.a = t;
}
@Override // io.reactivex.internal.fuseable.ScalarCallable, java.util.concurrent.Callable
public T call() {
return this.a;
}
@Override // io.reactivex.Observable
protected void subscribeActual(Observer<? super T> observer) {
ObservableScalarXMap.ScalarDisposable scalarDisposable = new ObservableScalarXMap.ScalarDisposable(observer, this.a);
observer.onSubscribe(scalarDisposable);
scalarDisposable.run();
}
}

70
sources/io/reactivex/internal/operators/observable/ObservableLastMaybe.java Normal file
View File

@@ -0,0 +1,70 @@
package io.reactivex.internal.operators.observable;
import io.reactivex.Maybe;
import io.reactivex.MaybeObserver;
import io.reactivex.ObservableSource;
import io.reactivex.Observer;
import io.reactivex.disposables.Disposable;
import io.reactivex.internal.disposables.DisposableHelper;
/* loaded from: classes2.dex */
public final class ObservableLastMaybe<T> extends Maybe<T> {
final ObservableSource<T> a;
static final class LastObserver<T> implements Observer<T>, Disposable {
final MaybeObserver<? super T> a;
Disposable b;
T c;
LastObserver(MaybeObserver<? super T> maybeObserver) {
this.a = maybeObserver;
}
@Override // io.reactivex.disposables.Disposable
public void dispose() {
this.b.dispose();
this.b = DisposableHelper.DISPOSED;
}
@Override // io.reactivex.Observer
public void onComplete() {
this.b = DisposableHelper.DISPOSED;
T t = this.c;
if (t == null) {
this.a.onComplete();
} else {
this.c = null;
this.a.onSuccess(t);
}
}
@Override // io.reactivex.Observer
public void onError(Throwable th) {
this.b = DisposableHelper.DISPOSED;
this.c = null;
this.a.onError(th);
}
@Override // io.reactivex.Observer
public void onNext(T t) {
this.c = t;
}
@Override // io.reactivex.Observer
public void onSubscribe(Disposable disposable) {
if (DisposableHelper.validate(this.b, disposable)) {
this.b = disposable;
this.a.onSubscribe(this);
}
}
}
public ObservableLastMaybe(ObservableSource<T> observableSource) {
this.a = observableSource;
}
@Override // io.reactivex.Maybe
protected void b(MaybeObserver<? super T> maybeObserver) {
this.a.subscribe(new LastObserver(maybeObserver));
}
}

80
sources/io/reactivex/internal/operators/observable/ObservableLastSingle.java Normal file
View File

@@ -0,0 +1,80 @@
package io.reactivex.internal.operators.observable;
import io.reactivex.ObservableSource;
import io.reactivex.Observer;
import io.reactivex.Single;
import io.reactivex.SingleObserver;
import io.reactivex.disposables.Disposable;
import io.reactivex.internal.disposables.DisposableHelper;
import java.util.NoSuchElementException;
/* loaded from: classes2.dex */
public final class ObservableLastSingle<T> extends Single<T> {
final ObservableSource<T> a;
final T b;
static final class LastObserver<T> implements Observer<T>, Disposable {
final SingleObserver<? super T> a;
final T b;
Disposable c;
T d;
LastObserver(SingleObserver<? super T> singleObserver, T t) {
this.a = singleObserver;
this.b = t;
}
@Override // io.reactivex.disposables.Disposable
public void dispose() {
this.c.dispose();
this.c = DisposableHelper.DISPOSED;
}
@Override // io.reactivex.Observer
public void onComplete() {
this.c = DisposableHelper.DISPOSED;
T t = this.d;
if (t != null) {
this.d = null;
this.a.onSuccess(t);
return;
}
T t2 = this.b;
if (t2 != null) {
this.a.onSuccess(t2);
} else {
this.a.onError(new NoSuchElementException());
}
}
@Override // io.reactivex.Observer
public void onError(Throwable th) {
this.c = DisposableHelper.DISPOSED;
this.d = null;
this.a.onError(th);
}
@Override // io.reactivex.Observer
public void onNext(T t) {
this.d = t;
}
@Override // io.reactivex.Observer
public void onSubscribe(Disposable disposable) {
if (DisposableHelper.validate(this.c, disposable)) {
this.c = disposable;
this.a.onSubscribe(this);
}
}
}
public ObservableLastSingle(ObservableSource<T> observableSource, T t) {
this.a = observableSource;
this.b = t;
}
@Override // io.reactivex.Single
protected void b(SingleObserver<? super T> singleObserver) {
this.a.subscribe(new LastObserver(singleObserver, this.b));
}
}

35
sources/io/reactivex/internal/operators/observable/ObservableLift.java Normal file
View File

@@ -0,0 +1,35 @@
package io.reactivex.internal.operators.observable;
import io.reactivex.ObservableOperator;
import io.reactivex.ObservableSource;
import io.reactivex.Observer;
import io.reactivex.exceptions.Exceptions;
import io.reactivex.internal.functions.ObjectHelper;
import io.reactivex.plugins.RxJavaPlugins;
/* loaded from: classes2.dex */
public final class ObservableLift<R, T> extends AbstractObservableWithUpstream<T, R> {
final ObservableOperator<? extends R, ? super T> b;
public ObservableLift(ObservableSource<T> observableSource, ObservableOperator<? extends R, ? super T> observableOperator) {
super(observableSource);
this.b = observableOperator;
}
@Override // io.reactivex.Observable
public void subscribeActual(Observer<? super R> observer) {
try {
Observer<? super Object> a = this.b.a(observer);
ObjectHelper.a(a, "Operator " + this.b + " returned a null Observer");
this.a.subscribe(a);
} catch (NullPointerException e) {
throw e;
} catch (Throwable th) {
Exceptions.b(th);
RxJavaPlugins.b(th);
NullPointerException nullPointerException = new NullPointerException("Actually not, but can't throw other exceptions due to RS");
nullPointerException.initCause(th);
throw nullPointerException;
}
}
}

65
sources/io/reactivex/internal/operators/observable/ObservableMap.java Normal file
View File

@@ -0,0 +1,65 @@
package io.reactivex.internal.operators.observable;
import io.reactivex.ObservableSource;
import io.reactivex.Observer;
import io.reactivex.functions.Function;
import io.reactivex.internal.functions.ObjectHelper;
import io.reactivex.internal.observers.BasicFuseableObserver;
/* loaded from: classes2.dex */
public final class ObservableMap<T, U> extends AbstractObservableWithUpstream<T, U> {
final Function<? super T, ? extends U> b;
static final class MapObserver<T, U> extends BasicFuseableObserver<T, U> {
final Function<? super T, ? extends U> f;
MapObserver(Observer<? super U> observer, Function<? super T, ? extends U> function) {
super(observer);
this.f = function;
}
@Override // io.reactivex.Observer
public void onNext(T t) {
if (this.d) {
return;
}
if (this.e != 0) {
this.a.onNext(null);
return;
}
try {
U apply = this.f.apply(t);
ObjectHelper.a(apply, "The mapper function returned a null value.");
this.a.onNext(apply);
} catch (Throwable th) {
a(th);
}
}
@Override // io.reactivex.internal.fuseable.SimpleQueue
public U poll() throws Exception {
T poll = this.c.poll();
if (poll == null) {
return null;
}
U apply = this.f.apply(poll);
ObjectHelper.a(apply, "The mapper function returned a null value.");
return apply;
}
@Override // io.reactivex.internal.fuseable.QueueFuseable
public int requestFusion(int i) {
return a(i);
}
}
public ObservableMap(ObservableSource<T> observableSource, Function<? super T, ? extends U> function) {
super(observableSource);
this.b = function;
}
@Override // io.reactivex.Observable
public void subscribeActual(Observer<? super U> observer) {
this.a.subscribe(new MapObserver(observer, this.b));
}
}

96
sources/io/reactivex/internal/operators/observable/ObservableMapNotification.java Normal file
View File

@@ -0,0 +1,96 @@
package io.reactivex.internal.operators.observable;
import io.reactivex.ObservableSource;
import io.reactivex.Observer;
import io.reactivex.disposables.Disposable;
import io.reactivex.exceptions.CompositeException;
import io.reactivex.exceptions.Exceptions;
import io.reactivex.functions.Function;
import io.reactivex.internal.disposables.DisposableHelper;
import io.reactivex.internal.functions.ObjectHelper;
import java.util.concurrent.Callable;
/* loaded from: classes2.dex */
public final class ObservableMapNotification<T, R> extends AbstractObservableWithUpstream<T, ObservableSource<? extends R>> {
final Function<? super T, ? extends ObservableSource<? extends R>> b;
final Function<? super Throwable, ? extends ObservableSource<? extends R>> c;
final Callable<? extends ObservableSource<? extends R>> d;
static final class MapNotificationObserver<T, R> implements Observer<T>, Disposable {
final Observer<? super ObservableSource<? extends R>> a;
final Function<? super T, ? extends ObservableSource<? extends R>> b;
final Function<? super Throwable, ? extends ObservableSource<? extends R>> c;
final Callable<? extends ObservableSource<? extends R>> d;
Disposable e;
MapNotificationObserver(Observer<? super ObservableSource<? extends R>> observer, Function<? super T, ? extends ObservableSource<? extends R>> function, Function<? super Throwable, ? extends ObservableSource<? extends R>> function2, Callable<? extends ObservableSource<? extends R>> callable) {
this.a = observer;
this.b = function;
this.c = function2;
this.d = callable;
}
@Override // io.reactivex.disposables.Disposable
public void dispose() {
this.e.dispose();
}
@Override // io.reactivex.Observer
public void onComplete() {
try {
ObservableSource<? extends R> call = this.d.call();
ObjectHelper.a(call, "The onComplete ObservableSource returned is null");
this.a.onNext(call);
this.a.onComplete();
} catch (Throwable th) {
Exceptions.b(th);
this.a.onError(th);
}
}
@Override // io.reactivex.Observer
public void onError(Throwable th) {
try {
ObservableSource<? extends R> apply = this.c.apply(th);
ObjectHelper.a(apply, "The onError ObservableSource returned is null");
this.a.onNext(apply);
this.a.onComplete();
} catch (Throwable th2) {
Exceptions.b(th2);
this.a.onError(new CompositeException(th, th2));
}
}
@Override // io.reactivex.Observer
public void onNext(T t) {
try {
ObservableSource<? extends R> apply = this.b.apply(t);
ObjectHelper.a(apply, "The onNext ObservableSource returned is null");
this.a.onNext(apply);
} catch (Throwable th) {
Exceptions.b(th);
this.a.onError(th);
}
}
@Override // io.reactivex.Observer
public void onSubscribe(Disposable disposable) {
if (DisposableHelper.validate(this.e, disposable)) {
this.e = disposable;
this.a.onSubscribe(this);
}
}
}
public ObservableMapNotification(ObservableSource<T> observableSource, Function<? super T, ? extends ObservableSource<? extends R>> function, Function<? super Throwable, ? extends ObservableSource<? extends R>> function2, Callable<? extends ObservableSource<? extends R>> callable) {
super(observableSource);
this.b = function;
this.c = function2;
this.d = callable;
}
@Override // io.reactivex.Observable
public void subscribeActual(Observer<? super ObservableSource<? extends R>> observer) {
this.a.subscribe(new MapNotificationObserver(observer, this.b, this.c, this.d));
}
}

59
sources/io/reactivex/internal/operators/observable/ObservableMaterialize.java Normal file
View File

@@ -0,0 +1,59 @@
package io.reactivex.internal.operators.observable;
import io.reactivex.Notification;
import io.reactivex.ObservableSource;
import io.reactivex.Observer;
import io.reactivex.disposables.Disposable;
import io.reactivex.internal.disposables.DisposableHelper;
/* loaded from: classes2.dex */
public final class ObservableMaterialize<T> extends AbstractObservableWithUpstream<T, Notification<T>> {
static final class MaterializeObserver<T> implements Observer<T>, Disposable {
final Observer<? super Notification<T>> a;
Disposable b;
MaterializeObserver(Observer<? super Notification<T>> observer) {
this.a = observer;
}
@Override // io.reactivex.disposables.Disposable
public void dispose() {
this.b.dispose();
}
@Override // io.reactivex.Observer
public void onComplete() {
this.a.onNext(Notification.f());
this.a.onComplete();
}
@Override // io.reactivex.Observer
public void onError(Throwable th) {
this.a.onNext(Notification.a(th));
this.a.onComplete();
}
@Override // io.reactivex.Observer
public void onNext(T t) {
this.a.onNext(Notification.a(t));
}
@Override // io.reactivex.Observer
public void onSubscribe(Disposable disposable) {
if (DisposableHelper.validate(this.b, disposable)) {
this.b = disposable;
this.a.onSubscribe(this);
}
}
}
public ObservableMaterialize(ObservableSource<T> observableSource) {
super(observableSource);
}
@Override // io.reactivex.Observable
public void subscribeActual(Observer<? super Notification<T>> observer) {
this.a.subscribe(new MaterializeObserver(observer));
}
}

108
sources/io/reactivex/internal/operators/observable/ObservableMergeWithCompletable.java Normal file
View File

@@ -0,0 +1,108 @@
package io.reactivex.internal.operators.observable;
import io.reactivex.CompletableObserver;
import io.reactivex.CompletableSource;
import io.reactivex.Observable;
import io.reactivex.Observer;
import io.reactivex.disposables.Disposable;
import io.reactivex.internal.disposables.DisposableHelper;
import io.reactivex.internal.util.AtomicThrowable;
import io.reactivex.internal.util.HalfSerializer;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicReference;
/* loaded from: classes2.dex */
public final class ObservableMergeWithCompletable<T> extends AbstractObservableWithUpstream<T, T> {
final CompletableSource b;
public ObservableMergeWithCompletable(Observable<T> observable, CompletableSource completableSource) {
super(observable);
this.b = completableSource;
}
@Override // io.reactivex.Observable
protected void subscribeActual(Observer<? super T> observer) {
MergeWithObserver mergeWithObserver = new MergeWithObserver(observer);
observer.onSubscribe(mergeWithObserver);
this.a.subscribe(mergeWithObserver);
this.b.a(mergeWithObserver.c);
}
static final class MergeWithObserver<T> extends AtomicInteger implements Observer<T>, Disposable {
final Observer<? super T> a;
final AtomicReference<Disposable> b = new AtomicReference<>();
final OtherObserver c = new OtherObserver(this);
final AtomicThrowable d = new AtomicThrowable();
volatile boolean e;
volatile boolean f;
static final class OtherObserver extends AtomicReference<Disposable> implements CompletableObserver {
final MergeWithObserver<?> a;
OtherObserver(MergeWithObserver<?> mergeWithObserver) {
this.a = mergeWithObserver;
}
@Override // io.reactivex.CompletableObserver, io.reactivex.MaybeObserver
public void onComplete() {
this.a.a();
}
@Override // io.reactivex.CompletableObserver
public void onError(Throwable th) {
this.a.a(th);
}
@Override // io.reactivex.CompletableObserver
public void onSubscribe(Disposable disposable) {
DisposableHelper.setOnce(this, disposable);
}
}
MergeWithObserver(Observer<? super T> observer) {
this.a = observer;
}
void a(Throwable th) {
DisposableHelper.dispose(this.b);
HalfSerializer.a((Observer<?>) this.a, th, (AtomicInteger) this, this.d);
}
@Override // io.reactivex.disposables.Disposable
public void dispose() {
DisposableHelper.dispose(this.b);
DisposableHelper.dispose(this.c);
}
@Override // io.reactivex.Observer
public void onComplete() {
this.e = true;
if (this.f) {
HalfSerializer.a(this.a, this, this.d);
}
}
@Override // io.reactivex.Observer
public void onError(Throwable th) {
DisposableHelper.dispose(this.b);
HalfSerializer.a((Observer<?>) this.a, th, (AtomicInteger) this, this.d);
}
@Override // io.reactivex.Observer
public void onNext(T t) {
HalfSerializer.a(this.a, t, this, this.d);
}
@Override // io.reactivex.Observer
public void onSubscribe(Disposable disposable) {
DisposableHelper.setOnce(this.b, disposable);
}
void a() {
this.f = true;
if (this.e) {
HalfSerializer.a(this.a, this, this.d);
}
}
}
}

208
sources/io/reactivex/internal/operators/observable/ObservableMergeWithMaybe.java Normal file
View File

@@ -0,0 +1,208 @@
package io.reactivex.internal.operators.observable;
import android.Manifest;
import io.reactivex.MaybeObserver;
import io.reactivex.MaybeSource;
import io.reactivex.Observable;
import io.reactivex.Observer;
import io.reactivex.disposables.Disposable;
import io.reactivex.internal.disposables.DisposableHelper;
import io.reactivex.internal.fuseable.SimplePlainQueue;
import io.reactivex.internal.queue.SpscLinkedArrayQueue;
import io.reactivex.internal.util.AtomicThrowable;
import io.reactivex.plugins.RxJavaPlugins;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicReference;
/* loaded from: classes2.dex */
public final class ObservableMergeWithMaybe<T> extends AbstractObservableWithUpstream<T, T> {
final MaybeSource<? extends T> b;
public ObservableMergeWithMaybe(Observable<T> observable, MaybeSource<? extends T> maybeSource) {
super(observable);
this.b = maybeSource;
}
@Override // io.reactivex.Observable
protected void subscribeActual(Observer<? super T> observer) {
MergeWithObserver mergeWithObserver = new MergeWithObserver(observer);
observer.onSubscribe(mergeWithObserver);
this.a.subscribe(mergeWithObserver);
this.b.a(mergeWithObserver.c);
}
static final class MergeWithObserver<T> extends AtomicInteger implements Observer<T>, Disposable {
final Observer<? super T> a;
final AtomicReference<Disposable> b = new AtomicReference<>();
final OtherObserver<T> c = new OtherObserver<>(this);
final AtomicThrowable d = new AtomicThrowable();
volatile SimplePlainQueue<T> e;
T f;
volatile boolean g;
volatile boolean h;
volatile int i;
static final class OtherObserver<T> extends AtomicReference<Disposable> implements MaybeObserver<T> {
final MergeWithObserver<T> a;
OtherObserver(MergeWithObserver<T> mergeWithObserver) {
this.a = mergeWithObserver;
}
@Override // io.reactivex.MaybeObserver
public void onComplete() {
this.a.d();
}
@Override // io.reactivex.MaybeObserver
public void onError(Throwable th) {
this.a.a(th);
}
@Override // io.reactivex.MaybeObserver
public void onSubscribe(Disposable disposable) {
DisposableHelper.setOnce(this, disposable);
}
@Override // io.reactivex.MaybeObserver
public void onSuccess(T t) {
this.a.a((MergeWithObserver<T>) t);
}
}
MergeWithObserver(Observer<? super T> observer) {
this.a = observer;
}
void a(T t) {
if (compareAndSet(0, 1)) {
this.a.onNext(t);
this.i = 2;
} else {
this.f = t;
this.i = 1;
if (getAndIncrement() != 0) {
return;
}
}
b();
}
void b() {
Observer<? super T> observer = this.a;
int i = 1;
while (!this.g) {
if (this.d.get() != null) {
this.f = null;
this.e = null;
observer.onError(this.d.terminate());
return;
}
int i2 = this.i;
if (i2 == 1) {
T t = this.f;
this.f = null;
this.i = 2;
observer.onNext(t);
i2 = 2;
}
boolean z = this.h;
SimplePlainQueue<T> simplePlainQueue = this.e;
Manifest poll = simplePlainQueue != null ? simplePlainQueue.poll() : null;
boolean z2 = poll == null;
if (z && z2 && i2 == 2) {
this.e = null;
observer.onComplete();
return;
} else if (z2) {
i = addAndGet(-i);
if (i == 0) {
return;
}
} else {
observer.onNext(poll);
}
}
this.f = null;
this.e = null;
}
SimplePlainQueue<T> c() {
SimplePlainQueue<T> simplePlainQueue = this.e;
if (simplePlainQueue != null) {
return simplePlainQueue;
}
SpscLinkedArrayQueue spscLinkedArrayQueue = new SpscLinkedArrayQueue(Observable.bufferSize());
this.e = spscLinkedArrayQueue;
return spscLinkedArrayQueue;
}
void d() {
this.i = 2;
a();
}
@Override // io.reactivex.disposables.Disposable
public void dispose() {
this.g = true;
DisposableHelper.dispose(this.b);
DisposableHelper.dispose(this.c);
if (getAndIncrement() == 0) {
this.e = null;
this.f = null;
}
}
@Override // io.reactivex.Observer
public void onComplete() {
this.h = true;
a();
}
@Override // io.reactivex.Observer
public void onError(Throwable th) {
if (!this.d.addThrowable(th)) {
RxJavaPlugins.b(th);
} else {
DisposableHelper.dispose(this.b);
a();
}
}
@Override // io.reactivex.Observer
public void onNext(T t) {
if (compareAndSet(0, 1)) {
this.a.onNext(t);
if (decrementAndGet() == 0) {
return;
}
} else {
c().offer(t);
if (getAndIncrement() != 0) {
return;
}
}
b();
}
@Override // io.reactivex.Observer
public void onSubscribe(Disposable disposable) {
DisposableHelper.setOnce(this.b, disposable);
}
void a(Throwable th) {
if (this.d.addThrowable(th)) {
DisposableHelper.dispose(this.b);
a();
} else {
RxJavaPlugins.b(th);
}
}
void a() {
if (getAndIncrement() == 0) {
b();
}
}
}
}

198
sources/io/reactivex/internal/operators/observable/ObservableMergeWithSingle.java Normal file
View File

@@ -0,0 +1,198 @@
package io.reactivex.internal.operators.observable;
import android.Manifest;
import io.reactivex.Observable;
import io.reactivex.Observer;
import io.reactivex.SingleObserver;
import io.reactivex.SingleSource;
import io.reactivex.disposables.Disposable;
import io.reactivex.internal.disposables.DisposableHelper;
import io.reactivex.internal.fuseable.SimplePlainQueue;
import io.reactivex.internal.queue.SpscLinkedArrayQueue;
import io.reactivex.internal.util.AtomicThrowable;
import io.reactivex.plugins.RxJavaPlugins;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicReference;
/* loaded from: classes2.dex */
public final class ObservableMergeWithSingle<T> extends AbstractObservableWithUpstream<T, T> {
final SingleSource<? extends T> b;
public ObservableMergeWithSingle(Observable<T> observable, SingleSource<? extends T> singleSource) {
super(observable);
this.b = singleSource;
}
@Override // io.reactivex.Observable
protected void subscribeActual(Observer<? super T> observer) {
MergeWithObserver mergeWithObserver = new MergeWithObserver(observer);
observer.onSubscribe(mergeWithObserver);
this.a.subscribe(mergeWithObserver);
this.b.a(mergeWithObserver.c);
}
static final class MergeWithObserver<T> extends AtomicInteger implements Observer<T>, Disposable {
final Observer<? super T> a;
final AtomicReference<Disposable> b = new AtomicReference<>();
final OtherObserver<T> c = new OtherObserver<>(this);
final AtomicThrowable d = new AtomicThrowable();
volatile SimplePlainQueue<T> e;
T f;
volatile boolean g;
volatile boolean h;
volatile int i;
static final class OtherObserver<T> extends AtomicReference<Disposable> implements SingleObserver<T> {
final MergeWithObserver<T> a;
OtherObserver(MergeWithObserver<T> mergeWithObserver) {
this.a = mergeWithObserver;
}
@Override // io.reactivex.SingleObserver
public void onError(Throwable th) {
this.a.a(th);
}
@Override // io.reactivex.SingleObserver
public void onSubscribe(Disposable disposable) {
DisposableHelper.setOnce(this, disposable);
}
@Override // io.reactivex.SingleObserver
public void onSuccess(T t) {
this.a.a((MergeWithObserver<T>) t);
}
}
MergeWithObserver(Observer<? super T> observer) {
this.a = observer;
}
void a(T t) {
if (compareAndSet(0, 1)) {
this.a.onNext(t);
this.i = 2;
} else {
this.f = t;
this.i = 1;
if (getAndIncrement() != 0) {
return;
}
}
b();
}
void b() {
Observer<? super T> observer = this.a;
int i = 1;
while (!this.g) {
if (this.d.get() != null) {
this.f = null;
this.e = null;
observer.onError(this.d.terminate());
return;
}
int i2 = this.i;
if (i2 == 1) {
T t = this.f;
this.f = null;
this.i = 2;
observer.onNext(t);
i2 = 2;
}
boolean z = this.h;
SimplePlainQueue<T> simplePlainQueue = this.e;
Manifest poll = simplePlainQueue != null ? simplePlainQueue.poll() : null;
boolean z2 = poll == null;
if (z && z2 && i2 == 2) {
this.e = null;
observer.onComplete();
return;
} else if (z2) {
i = addAndGet(-i);
if (i == 0) {
return;
}
} else {
observer.onNext(poll);
}
}
this.f = null;
this.e = null;
}
SimplePlainQueue<T> c() {
SimplePlainQueue<T> simplePlainQueue = this.e;
if (simplePlainQueue != null) {
return simplePlainQueue;
}
SpscLinkedArrayQueue spscLinkedArrayQueue = new SpscLinkedArrayQueue(Observable.bufferSize());
this.e = spscLinkedArrayQueue;
return spscLinkedArrayQueue;
}
@Override // io.reactivex.disposables.Disposable
public void dispose() {
this.g = true;
DisposableHelper.dispose(this.b);
DisposableHelper.dispose(this.c);
if (getAndIncrement() == 0) {
this.e = null;
this.f = null;
}
}
@Override // io.reactivex.Observer
public void onComplete() {
this.h = true;
a();
}
@Override // io.reactivex.Observer
public void onError(Throwable th) {
if (!this.d.addThrowable(th)) {
RxJavaPlugins.b(th);
} else {
DisposableHelper.dispose(this.b);
a();
}
}
@Override // io.reactivex.Observer
public void onNext(T t) {
if (compareAndSet(0, 1)) {
this.a.onNext(t);
if (decrementAndGet() == 0) {
return;
}
} else {
c().offer(t);
if (getAndIncrement() != 0) {
return;
}
}
b();
}
@Override // io.reactivex.Observer
public void onSubscribe(Disposable disposable) {
DisposableHelper.setOnce(this.b, disposable);
}
void a(Throwable th) {
if (this.d.addThrowable(th)) {
DisposableHelper.dispose(this.b);
a();
} else {
RxJavaPlugins.b(th);
}
}
void a() {
if (getAndIncrement() == 0) {
b();
}
}
}
}

18
sources/io/reactivex/internal/operators/observable/ObservableNever.java Normal file
View File

@@ -0,0 +1,18 @@
package io.reactivex.internal.operators.observable;
import io.reactivex.Observable;
import io.reactivex.Observer;
import io.reactivex.internal.disposables.EmptyDisposable;
/* loaded from: classes2.dex */
public final class ObservableNever extends Observable<Object> {
public static final Observable<Object> a = new ObservableNever();
private ObservableNever() {
}
@Override // io.reactivex.Observable
protected void subscribeActual(Observer<? super Object> observer) {
observer.onSubscribe(EmptyDisposable.NEVER);
}
}

301
sources/io/reactivex/internal/operators/observable/ObservableObserveOn.java Normal file
View File

@@ -0,0 +1,301 @@
package io.reactivex.internal.operators.observable;
import io.reactivex.ObservableSource;
import io.reactivex.Observer;
import io.reactivex.Scheduler;
import io.reactivex.disposables.Disposable;
import io.reactivex.internal.disposables.DisposableHelper;
import io.reactivex.internal.fuseable.QueueDisposable;
import io.reactivex.internal.fuseable.SimpleQueue;
import io.reactivex.internal.observers.BasicIntQueueDisposable;
import io.reactivex.internal.queue.SpscLinkedArrayQueue;
import io.reactivex.internal.schedulers.TrampolineScheduler;
import io.reactivex.plugins.RxJavaPlugins;
/* loaded from: classes2.dex */
public final class ObservableObserveOn<T> extends AbstractObservableWithUpstream<T, T> {
final Scheduler b;
final boolean c;
final int d;
public ObservableObserveOn(ObservableSource<T> observableSource, Scheduler scheduler, boolean z, int i) {
super(observableSource);
this.b = scheduler;
this.c = z;
this.d = i;
}
@Override // io.reactivex.Observable
protected void subscribeActual(Observer<? super T> observer) {
Scheduler scheduler = this.b;
if (scheduler instanceof TrampolineScheduler) {
this.a.subscribe(observer);
} else {
this.a.subscribe(new ObserveOnObserver(observer, scheduler.a(), this.c, this.d));
}
}
static final class ObserveOnObserver<T> extends BasicIntQueueDisposable<T> implements Observer<T>, Runnable {
final Observer<? super T> a;
final Scheduler.Worker b;
final boolean c;
final int d;
SimpleQueue<T> e;
Disposable f;
Throwable g;
volatile boolean h;
volatile boolean i;
int j;
boolean k;
ObserveOnObserver(Observer<? super T> observer, Scheduler.Worker worker, boolean z, int i) {
this.a = observer;
this.b = worker;
this.c = z;
this.d = i;
}
void a() {
int i = 1;
while (!this.i) {
boolean z = this.h;
Throwable th = this.g;
if (!this.c && z && th != null) {
this.i = true;
this.a.onError(th);
this.b.dispose();
return;
}
this.a.onNext(null);
if (z) {
this.i = true;
Throwable th2 = this.g;
if (th2 != null) {
this.a.onError(th2);
} else {
this.a.onComplete();
}
this.b.dispose();
return;
}
i = addAndGet(-i);
if (i == 0) {
return;
}
}
}
/* JADX WARN: Code restructure failed: missing block: B:14:0x0027, code lost:
r3 = addAndGet(-r3);
*/
/* JADX WARN: Code restructure failed: missing block: B:15:0x002c, code lost:
if (r3 != 0) goto L27;
*/
/* JADX WARN: Code restructure failed: missing block: B:17:0x002e, code lost:
return;
*/
/*
Code decompiled incorrectly, please refer to instructions dump.
To view partially-correct code enable 'Show inconsistent code' option in preferences
*/
void b() {
/*
r7 = this;
io.reactivex.internal.fuseable.SimpleQueue<T> r0 = r7.e
io.reactivex.Observer<? super T> r1 = r7.a
r2 = 1
r3 = 1
L6:
boolean r4 = r7.h
boolean r5 = r0.isEmpty()
boolean r4 = r7.a(r4, r5, r1)
if (r4 == 0) goto L13
return
L13:
boolean r4 = r7.h
java.lang.Object r5 = r0.poll() // Catch: java.lang.Throwable -> L33
if (r5 != 0) goto L1d
r6 = 1
goto L1e
L1d:
r6 = 0
L1e:
boolean r4 = r7.a(r4, r6, r1)
if (r4 == 0) goto L25
return
L25:
if (r6 == 0) goto L2f
int r3 = -r3
int r3 = r7.addAndGet(r3)
if (r3 != 0) goto L6
return
L2f:
r1.onNext(r5)
goto L13
L33:
r3 = move-exception
io.reactivex.exceptions.Exceptions.b(r3)
r7.i = r2
io.reactivex.disposables.Disposable r2 = r7.f
r2.dispose()
r0.clear()
r1.onError(r3)
io.reactivex.Scheduler$Worker r0 = r7.b
r0.dispose()
return
*/
throw new UnsupportedOperationException("Method not decompiled: io.reactivex.internal.operators.observable.ObservableObserveOn.ObserveOnObserver.b():void");
}
void c() {
if (getAndIncrement() == 0) {
this.b.a(this);
}
}
@Override // io.reactivex.internal.fuseable.SimpleQueue
public void clear() {
this.e.clear();
}
@Override // io.reactivex.disposables.Disposable
public void dispose() {
if (this.i) {
return;
}
this.i = true;
this.f.dispose();
this.b.dispose();
if (getAndIncrement() == 0) {
this.e.clear();
}
}
@Override // io.reactivex.internal.fuseable.SimpleQueue
public boolean isEmpty() {
return this.e.isEmpty();
}
@Override // io.reactivex.Observer
public void onComplete() {
if (this.h) {
return;
}
this.h = true;
c();
}
@Override // io.reactivex.Observer
public void onError(Throwable th) {
if (this.h) {
RxJavaPlugins.b(th);
return;
}
this.g = th;
this.h = true;
c();
}
@Override // io.reactivex.Observer
public void onNext(T t) {
if (this.h) {
return;
}
if (this.j != 2) {
this.e.offer(t);
}
c();
}
@Override // io.reactivex.Observer
public void onSubscribe(Disposable disposable) {
if (DisposableHelper.validate(this.f, disposable)) {
this.f = disposable;
if (disposable instanceof QueueDisposable) {
QueueDisposable queueDisposable = (QueueDisposable) disposable;
int requestFusion = queueDisposable.requestFusion(7);
if (requestFusion == 1) {
this.j = requestFusion;
this.e = queueDisposable;
this.h = true;
this.a.onSubscribe(this);
c();
return;
}
if (requestFusion == 2) {
this.j = requestFusion;
this.e = queueDisposable;
this.a.onSubscribe(this);
return;
}
}
this.e = new SpscLinkedArrayQueue(this.d);
this.a.onSubscribe(this);
}
}
@Override // io.reactivex.internal.fuseable.SimpleQueue
public T poll() throws Exception {
return this.e.poll();
}
@Override // io.reactivex.internal.fuseable.QueueFuseable
public int requestFusion(int i) {
if ((i & 2) == 0) {
return 0;
}
this.k = true;
return 2;
}
@Override // java.lang.Runnable
public void run() {
if (this.k) {
a();
} else {
b();
}
}
boolean a(boolean z, boolean z2, Observer<? super T> observer) {
if (this.i) {
this.e.clear();
return true;
}
if (!z) {
return false;
}
Throwable th = this.g;
if (this.c) {
if (!z2) {
return false;
}
this.i = true;
if (th != null) {
observer.onError(th);
} else {
observer.onComplete();
}
this.b.dispose();
return true;
}
if (th != null) {
this.i = true;
this.e.clear();
observer.onError(th);
this.b.dispose();
return true;
}
if (!z2) {
return false;
}
this.i = true;
observer.onComplete();
this.b.dispose();
return true;
}
}
}

98
sources/io/reactivex/internal/operators/observable/ObservableOnErrorNext.java Normal file
View File

@@ -0,0 +1,98 @@
package io.reactivex.internal.operators.observable;
import io.reactivex.ObservableSource;
import io.reactivex.Observer;
import io.reactivex.disposables.Disposable;
import io.reactivex.exceptions.CompositeException;
import io.reactivex.exceptions.Exceptions;
import io.reactivex.functions.Function;
import io.reactivex.internal.disposables.SequentialDisposable;
import io.reactivex.plugins.RxJavaPlugins;
/* loaded from: classes2.dex */
public final class ObservableOnErrorNext<T> extends AbstractObservableWithUpstream<T, T> {
final Function<? super Throwable, ? extends ObservableSource<? extends T>> b;
final boolean c;
static final class OnErrorNextObserver<T> implements Observer<T> {
final Observer<? super T> a;
final Function<? super Throwable, ? extends ObservableSource<? extends T>> b;
final boolean c;
final SequentialDisposable d = new SequentialDisposable();
boolean e;
boolean f;
OnErrorNextObserver(Observer<? super T> observer, Function<? super Throwable, ? extends ObservableSource<? extends T>> function, boolean z) {
this.a = observer;
this.b = function;
this.c = z;
}
@Override // io.reactivex.Observer
public void onComplete() {
if (this.f) {
return;
}
this.f = true;
this.e = true;
this.a.onComplete();
}
@Override // io.reactivex.Observer
public void onError(Throwable th) {
if (this.e) {
if (this.f) {
RxJavaPlugins.b(th);
return;
} else {
this.a.onError(th);
return;
}
}
this.e = true;
if (this.c && !(th instanceof Exception)) {
this.a.onError(th);
return;
}
try {
ObservableSource<? extends T> apply = this.b.apply(th);
if (apply != null) {
apply.subscribe(this);
return;
}
NullPointerException nullPointerException = new NullPointerException("Observable is null");
nullPointerException.initCause(th);
this.a.onError(nullPointerException);
} catch (Throwable th2) {
Exceptions.b(th2);
this.a.onError(new CompositeException(th, th2));
}
}
@Override // io.reactivex.Observer
public void onNext(T t) {
if (this.f) {
return;
}
this.a.onNext(t);
}
@Override // io.reactivex.Observer
public void onSubscribe(Disposable disposable) {
this.d.replace(disposable);
}
}
public ObservableOnErrorNext(ObservableSource<T> observableSource, Function<? super Throwable, ? extends ObservableSource<? extends T>> function, boolean z) {
super(observableSource);
this.b = function;
this.c = z;
}
@Override // io.reactivex.Observable
public void subscribeActual(Observer<? super T> observer) {
OnErrorNextObserver onErrorNextObserver = new OnErrorNextObserver(observer, this.b, this.c);
observer.onSubscribe(onErrorNextObserver.d);
this.a.subscribe(onErrorNextObserver);
}
}

76
sources/io/reactivex/internal/operators/observable/ObservableOnErrorReturn.java Normal file
View File

@@ -0,0 +1,76 @@
package io.reactivex.internal.operators.observable;
import io.reactivex.ObservableSource;
import io.reactivex.Observer;
import io.reactivex.disposables.Disposable;
import io.reactivex.exceptions.CompositeException;
import io.reactivex.exceptions.Exceptions;
import io.reactivex.functions.Function;
import io.reactivex.internal.disposables.DisposableHelper;
/* loaded from: classes2.dex */
public final class ObservableOnErrorReturn<T> extends AbstractObservableWithUpstream<T, T> {
final Function<? super Throwable, ? extends T> b;
static final class OnErrorReturnObserver<T> implements Observer<T>, Disposable {
final Observer<? super T> a;
final Function<? super Throwable, ? extends T> b;
Disposable c;
OnErrorReturnObserver(Observer<? super T> observer, Function<? super Throwable, ? extends T> function) {
this.a = observer;
this.b = function;
}
@Override // io.reactivex.disposables.Disposable
public void dispose() {
this.c.dispose();
}
@Override // io.reactivex.Observer
public void onComplete() {
this.a.onComplete();
}
@Override // io.reactivex.Observer
public void onError(Throwable th) {
try {
T apply = this.b.apply(th);
if (apply != null) {
this.a.onNext(apply);
this.a.onComplete();
} else {
NullPointerException nullPointerException = new NullPointerException("The supplied value is null");
nullPointerException.initCause(th);
this.a.onError(nullPointerException);
}
} catch (Throwable th2) {
Exceptions.b(th2);
this.a.onError(new CompositeException(th, th2));
}
}
@Override // io.reactivex.Observer
public void onNext(T t) {
this.a.onNext(t);
}
@Override // io.reactivex.Observer
public void onSubscribe(Disposable disposable) {
if (DisposableHelper.validate(this.c, disposable)) {
this.c = disposable;
this.a.onSubscribe(this);
}
}
}
public ObservableOnErrorReturn(ObservableSource<T> observableSource, Function<? super Throwable, ? extends T> function) {
super(observableSource);
this.b = function;
}
@Override // io.reactivex.Observable
public void subscribeActual(Observer<? super T> observer) {
this.a.subscribe(new OnErrorReturnObserver(observer, this.b));
}
}

225
sources/io/reactivex/internal/operators/observable/ObservablePublish.java Normal file
View File

@@ -0,0 +1,225 @@
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.Consumer;
import io.reactivex.internal.disposables.DisposableHelper;
import io.reactivex.internal.fuseable.HasUpstreamObservableSource;
import io.reactivex.internal.util.ExceptionHelper;
import io.reactivex.observables.ConnectableObservable;
import io.reactivex.plugins.RxJavaPlugins;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicReference;
/* loaded from: classes2.dex */
public final class ObservablePublish<T> extends ConnectableObservable<T> implements HasUpstreamObservableSource<T> {
final ObservableSource<T> a;
final AtomicReference<PublishObserver<T>> b;
final ObservableSource<T> c;
static final class InnerDisposable<T> extends AtomicReference<Object> implements Disposable {
final Observer<? super T> a;
InnerDisposable(Observer<? super T> observer) {
this.a = observer;
}
void a(PublishObserver<T> publishObserver) {
if (compareAndSet(null, publishObserver)) {
return;
}
publishObserver.b(this);
}
@Override // io.reactivex.disposables.Disposable
public void dispose() {
Object andSet = getAndSet(this);
if (andSet == null || andSet == this) {
return;
}
((PublishObserver) andSet).b(this);
}
}
static final class PublishObserver<T> implements Observer<T>, Disposable {
static final InnerDisposable[] e = new InnerDisposable[0];
static final InnerDisposable[] f = new InnerDisposable[0];
final AtomicReference<PublishObserver<T>> a;
final AtomicReference<Disposable> d = new AtomicReference<>();
final AtomicReference<InnerDisposable<T>[]> b = new AtomicReference<>(e);
final AtomicBoolean c = new AtomicBoolean();
PublishObserver(AtomicReference<PublishObserver<T>> atomicReference) {
this.a = atomicReference;
}
public boolean a() {
return this.b.get() == f;
}
void b(InnerDisposable<T> innerDisposable) {
InnerDisposable<T>[] innerDisposableArr;
InnerDisposable<T>[] innerDisposableArr2;
do {
innerDisposableArr = this.b.get();
int length = innerDisposableArr.length;
if (length == 0) {
return;
}
int i = -1;
int i2 = 0;
while (true) {
if (i2 >= length) {
break;
}
if (innerDisposableArr[i2].equals(innerDisposable)) {
i = i2;
break;
}
i2++;
}
if (i < 0) {
return;
}
if (length == 1) {
innerDisposableArr2 = e;
} else {
InnerDisposable<T>[] innerDisposableArr3 = new InnerDisposable[length - 1];
System.arraycopy(innerDisposableArr, 0, innerDisposableArr3, 0, i);
System.arraycopy(innerDisposableArr, i + 1, innerDisposableArr3, i, (length - i) - 1);
innerDisposableArr2 = innerDisposableArr3;
}
} while (!this.b.compareAndSet(innerDisposableArr, innerDisposableArr2));
}
@Override // io.reactivex.disposables.Disposable
public void dispose() {
if (this.b.getAndSet(f) != f) {
this.a.compareAndSet(this, null);
DisposableHelper.dispose(this.d);
}
}
@Override // io.reactivex.Observer
public void onComplete() {
this.a.compareAndSet(this, null);
for (InnerDisposable<T> innerDisposable : this.b.getAndSet(f)) {
innerDisposable.a.onComplete();
}
}
@Override // io.reactivex.Observer
public void onError(Throwable th) {
this.a.compareAndSet(this, null);
InnerDisposable<T>[] andSet = this.b.getAndSet(f);
if (andSet.length == 0) {
RxJavaPlugins.b(th);
return;
}
for (InnerDisposable<T> innerDisposable : andSet) {
innerDisposable.a.onError(th);
}
}
@Override // io.reactivex.Observer
public void onNext(T t) {
for (InnerDisposable<T> innerDisposable : this.b.get()) {
innerDisposable.a.onNext(t);
}
}
@Override // io.reactivex.Observer
public void onSubscribe(Disposable disposable) {
DisposableHelper.setOnce(this.d, disposable);
}
boolean a(InnerDisposable<T> innerDisposable) {
InnerDisposable<T>[] innerDisposableArr;
InnerDisposable<T>[] innerDisposableArr2;
do {
innerDisposableArr = this.b.get();
if (innerDisposableArr == f) {
return false;
}
int length = innerDisposableArr.length;
innerDisposableArr2 = new InnerDisposable[length + 1];
System.arraycopy(innerDisposableArr, 0, innerDisposableArr2, 0, length);
innerDisposableArr2[length] = innerDisposable;
} while (!this.b.compareAndSet(innerDisposableArr, innerDisposableArr2));
return true;
}
}
static final class PublishSource<T> implements ObservableSource<T> {
private final AtomicReference<PublishObserver<T>> a;
PublishSource(AtomicReference<PublishObserver<T>> atomicReference) {
this.a = atomicReference;
}
@Override // io.reactivex.ObservableSource
public void subscribe(Observer<? super T> observer) {
InnerDisposable innerDisposable = new InnerDisposable(observer);
observer.onSubscribe(innerDisposable);
while (true) {
PublishObserver<T> publishObserver = this.a.get();
if (publishObserver == null || publishObserver.a()) {
PublishObserver<T> publishObserver2 = new PublishObserver<>(this.a);
if (this.a.compareAndSet(publishObserver, publishObserver2)) {
publishObserver = publishObserver2;
} else {
continue;
}
}
if (publishObserver.a(innerDisposable)) {
innerDisposable.a(publishObserver);
return;
}
}
}
}
private ObservablePublish(ObservableSource<T> observableSource, ObservableSource<T> observableSource2, AtomicReference<PublishObserver<T>> atomicReference) {
this.c = observableSource;
this.a = observableSource2;
this.b = atomicReference;
}
public static <T> ConnectableObservable<T> a(ObservableSource<T> observableSource) {
AtomicReference atomicReference = new AtomicReference();
return RxJavaPlugins.a((ConnectableObservable) new ObservablePublish(new PublishSource(atomicReference), observableSource, atomicReference));
}
@Override // io.reactivex.Observable
protected void subscribeActual(Observer<? super T> observer) {
this.c.subscribe(observer);
}
@Override // io.reactivex.observables.ConnectableObservable
public void a(Consumer<? super Disposable> consumer) {
PublishObserver<T> publishObserver;
while (true) {
publishObserver = this.b.get();
if (publishObserver != null && !publishObserver.a()) {
break;
}
PublishObserver<T> publishObserver2 = new PublishObserver<>(this.b);
if (this.b.compareAndSet(publishObserver, publishObserver2)) {
publishObserver = publishObserver2;
break;
}
}
boolean z = !publishObserver.c.get() && publishObserver.c.compareAndSet(false, true);
try {
consumer.accept(publishObserver);
if (z) {
this.a.subscribe(publishObserver);
}
} catch (Throwable th) {
Exceptions.b(th);
throw ExceptionHelper.a(th);
}
}
}

109
sources/io/reactivex/internal/operators/observable/ObservablePublishSelector.java Normal file
View File

@@ -0,0 +1,109 @@
package io.reactivex.internal.operators.observable;
import io.reactivex.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.disposables.EmptyDisposable;
import io.reactivex.internal.functions.ObjectHelper;
import io.reactivex.subjects.PublishSubject;
import java.util.concurrent.atomic.AtomicReference;
/* loaded from: classes2.dex */
public final class ObservablePublishSelector<T, R> extends AbstractObservableWithUpstream<T, R> {
final Function<? super Observable<T>, ? extends ObservableSource<R>> b;
static final class SourceObserver<T, R> implements Observer<T> {
final PublishSubject<T> a;
final AtomicReference<Disposable> b;
SourceObserver(PublishSubject<T> publishSubject, AtomicReference<Disposable> atomicReference) {
this.a = publishSubject;
this.b = atomicReference;
}
@Override // io.reactivex.Observer
public void onComplete() {
this.a.onComplete();
}
@Override // io.reactivex.Observer
public void onError(Throwable th) {
this.a.onError(th);
}
@Override // io.reactivex.Observer
public void onNext(T t) {
this.a.onNext(t);
}
@Override // io.reactivex.Observer
public void onSubscribe(Disposable disposable) {
DisposableHelper.setOnce(this.b, disposable);
}
}
static final class TargetObserver<T, R> extends AtomicReference<Disposable> implements Observer<R>, Disposable {
final Observer<? super R> a;
Disposable b;
TargetObserver(Observer<? super R> observer) {
this.a = observer;
}
@Override // io.reactivex.disposables.Disposable
public void dispose() {
this.b.dispose();
DisposableHelper.dispose(this);
}
@Override // io.reactivex.Observer
public void onComplete() {
DisposableHelper.dispose(this);
this.a.onComplete();
}
@Override // io.reactivex.Observer
public void onError(Throwable th) {
DisposableHelper.dispose(this);
this.a.onError(th);
}
@Override // io.reactivex.Observer
public void onNext(R r) {
this.a.onNext(r);
}
@Override // io.reactivex.Observer
public void onSubscribe(Disposable disposable) {
if (DisposableHelper.validate(this.b, disposable)) {
this.b = disposable;
this.a.onSubscribe(this);
}
}
}
public ObservablePublishSelector(ObservableSource<T> observableSource, Function<? super Observable<T>, ? extends ObservableSource<R>> function) {
super(observableSource);
this.b = function;
}
@Override // io.reactivex.Observable
protected void subscribeActual(Observer<? super R> observer) {
PublishSubject b = PublishSubject.b();
try {
ObservableSource<R> apply = this.b.apply(b);
ObjectHelper.a(apply, "The selector returned a null ObservableSource");
ObservableSource<R> observableSource = apply;
TargetObserver targetObserver = new TargetObserver(observer);
observableSource.subscribe(targetObserver);
this.a.subscribe(new SourceObserver(b, targetObserver));
} catch (Throwable th) {
Exceptions.b(th);
EmptyDisposable.error(th, observer);
}
}
}

87
sources/io/reactivex/internal/operators/observable/ObservableRange.java Normal file
View File

@@ -0,0 +1,87 @@
package io.reactivex.internal.operators.observable;
import io.reactivex.Observable;
import io.reactivex.Observer;
import io.reactivex.internal.observers.BasicIntQueueDisposable;
/* loaded from: classes2.dex */
public final class ObservableRange extends Observable<Integer> {
private final int a;
private final long b;
static final class RangeDisposable extends BasicIntQueueDisposable<Integer> {
final Observer<? super Integer> a;
final long b;
long c;
boolean d;
RangeDisposable(Observer<? super Integer> observer, long j, long j2) {
this.a = observer;
this.c = j;
this.b = j2;
}
@Override // io.reactivex.internal.fuseable.SimpleQueue
public void clear() {
this.c = this.b;
lazySet(1);
}
@Override // io.reactivex.disposables.Disposable
public void dispose() {
set(1);
}
@Override // io.reactivex.internal.fuseable.SimpleQueue
public boolean isEmpty() {
return this.c == this.b;
}
@Override // io.reactivex.internal.fuseable.QueueFuseable
public int requestFusion(int i) {
if ((i & 1) == 0) {
return 0;
}
this.d = true;
return 1;
}
void run() {
if (this.d) {
return;
}
Observer<? super Integer> observer = this.a;
long j = this.b;
for (long j2 = this.c; j2 != j && get() == 0; j2++) {
observer.onNext(Integer.valueOf((int) j2));
}
if (get() == 0) {
lazySet(1);
observer.onComplete();
}
}
@Override // io.reactivex.internal.fuseable.SimpleQueue
public Integer poll() throws Exception {
long j = this.c;
if (j != this.b) {
this.c = 1 + j;
return Integer.valueOf((int) j);
}
lazySet(1);
return null;
}
}
public ObservableRange(int i, int i2) {
this.a = i;
this.b = i + i2;
}
@Override // io.reactivex.Observable
protected void subscribeActual(Observer<? super Integer> observer) {
RangeDisposable rangeDisposable = new RangeDisposable(observer, this.a, this.b);
observer.onSubscribe(rangeDisposable);
rangeDisposable.run();
}
}

88
sources/io/reactivex/internal/operators/observable/ObservableRangeLong.java Normal file
View File

@@ -0,0 +1,88 @@
package io.reactivex.internal.operators.observable;
import io.reactivex.Observable;
import io.reactivex.Observer;
import io.reactivex.internal.observers.BasicIntQueueDisposable;
/* loaded from: classes2.dex */
public final class ObservableRangeLong extends Observable<Long> {
private final long a;
private final long b;
static final class RangeDisposable extends BasicIntQueueDisposable<Long> {
final Observer<? super Long> a;
final long b;
long c;
boolean d;
RangeDisposable(Observer<? super Long> observer, long j, long j2) {
this.a = observer;
this.c = j;
this.b = j2;
}
@Override // io.reactivex.internal.fuseable.SimpleQueue
public void clear() {
this.c = this.b;
lazySet(1);
}
@Override // io.reactivex.disposables.Disposable
public void dispose() {
set(1);
}
@Override // io.reactivex.internal.fuseable.SimpleQueue
public boolean isEmpty() {
return this.c == this.b;
}
@Override // io.reactivex.internal.fuseable.QueueFuseable
public int requestFusion(int i) {
if ((i & 1) == 0) {
return 0;
}
this.d = true;
return 1;
}
void run() {
if (this.d) {
return;
}
Observer<? super Long> observer = this.a;
long j = this.b;
for (long j2 = this.c; j2 != j && get() == 0; j2++) {
observer.onNext(Long.valueOf(j2));
}
if (get() == 0) {
lazySet(1);
observer.onComplete();
}
}
@Override // io.reactivex.internal.fuseable.SimpleQueue
public Long poll() throws Exception {
long j = this.c;
if (j != this.b) {
this.c = 1 + j;
return Long.valueOf(j);
}
lazySet(1);
return null;
}
}
public ObservableRangeLong(long j, long j2) {
this.a = j;
this.b = j2;
}
@Override // io.reactivex.Observable
protected void subscribeActual(Observer<? super Long> observer) {
long j = this.a;
RangeDisposable rangeDisposable = new RangeDisposable(observer, j, j + this.b);
observer.onSubscribe(rangeDisposable);
rangeDisposable.run();
}
}

101
sources/io/reactivex/internal/operators/observable/ObservableReduceMaybe.java Normal file
View File

@@ -0,0 +1,101 @@
package io.reactivex.internal.operators.observable;
import io.reactivex.Maybe;
import io.reactivex.MaybeObserver;
import io.reactivex.ObservableSource;
import io.reactivex.Observer;
import io.reactivex.disposables.Disposable;
import io.reactivex.exceptions.Exceptions;
import io.reactivex.functions.BiFunction;
import io.reactivex.internal.disposables.DisposableHelper;
import io.reactivex.internal.functions.ObjectHelper;
import io.reactivex.plugins.RxJavaPlugins;
/* loaded from: classes2.dex */
public final class ObservableReduceMaybe<T> extends Maybe<T> {
final ObservableSource<T> a;
final BiFunction<T, T, T> b;
static final class ReduceObserver<T> implements Observer<T>, Disposable {
final MaybeObserver<? super T> a;
final BiFunction<T, T, T> b;
boolean c;
T d;
Disposable e;
ReduceObserver(MaybeObserver<? super T> maybeObserver, BiFunction<T, T, T> biFunction) {
this.a = maybeObserver;
this.b = biFunction;
}
@Override // io.reactivex.disposables.Disposable
public void dispose() {
this.e.dispose();
}
@Override // io.reactivex.Observer
public void onComplete() {
if (this.c) {
return;
}
this.c = true;
T t = this.d;
this.d = null;
if (t != null) {
this.a.onSuccess(t);
} else {
this.a.onComplete();
}
}
@Override // io.reactivex.Observer
public void onError(Throwable th) {
if (this.c) {
RxJavaPlugins.b(th);
return;
}
this.c = true;
this.d = null;
this.a.onError(th);
}
@Override // io.reactivex.Observer
public void onNext(T t) {
if (this.c) {
return;
}
T t2 = this.d;
if (t2 == null) {
this.d = t;
return;
}
try {
T apply = this.b.apply(t2, t);
ObjectHelper.a((Object) apply, "The reducer returned a null value");
this.d = apply;
} catch (Throwable th) {
Exceptions.b(th);
this.e.dispose();
onError(th);
}
}
@Override // io.reactivex.Observer
public void onSubscribe(Disposable disposable) {
if (DisposableHelper.validate(this.e, disposable)) {
this.e = disposable;
this.a.onSubscribe(this);
}
}
}
public ObservableReduceMaybe(ObservableSource<T> observableSource, BiFunction<T, T, T> biFunction) {
this.a = observableSource;
this.b = biFunction;
}
@Override // io.reactivex.Maybe
protected void b(MaybeObserver<? super T> maybeObserver) {
this.a.subscribe(new ReduceObserver(maybeObserver, this.b));
}
}

91
sources/io/reactivex/internal/operators/observable/ObservableReduceSeedSingle.java Normal file
View File

@@ -0,0 +1,91 @@
package io.reactivex.internal.operators.observable;
import io.reactivex.ObservableSource;
import io.reactivex.Observer;
import io.reactivex.Single;
import io.reactivex.SingleObserver;
import io.reactivex.disposables.Disposable;
import io.reactivex.exceptions.Exceptions;
import io.reactivex.functions.BiFunction;
import io.reactivex.internal.disposables.DisposableHelper;
import io.reactivex.internal.functions.ObjectHelper;
import io.reactivex.plugins.RxJavaPlugins;
/* loaded from: classes2.dex */
public final class ObservableReduceSeedSingle<T, R> extends Single<R> {
final ObservableSource<T> a;
final R b;
final BiFunction<R, ? super T, R> c;
static final class ReduceSeedObserver<T, R> implements Observer<T>, Disposable {
final SingleObserver<? super R> a;
final BiFunction<R, ? super T, R> b;
R c;
Disposable d;
ReduceSeedObserver(SingleObserver<? super R> singleObserver, BiFunction<R, ? super T, R> biFunction, R r) {
this.a = singleObserver;
this.c = r;
this.b = biFunction;
}
@Override // io.reactivex.disposables.Disposable
public void dispose() {
this.d.dispose();
}
@Override // io.reactivex.Observer
public void onComplete() {
R r = this.c;
if (r != null) {
this.c = null;
this.a.onSuccess(r);
}
}
@Override // io.reactivex.Observer
public void onError(Throwable th) {
if (this.c == null) {
RxJavaPlugins.b(th);
} else {
this.c = null;
this.a.onError(th);
}
}
@Override // io.reactivex.Observer
public void onNext(T t) {
R r = this.c;
if (r != null) {
try {
R apply = this.b.apply(r, t);
ObjectHelper.a(apply, "The reducer returned a null value");
this.c = apply;
} catch (Throwable th) {
Exceptions.b(th);
this.d.dispose();
onError(th);
}
}
}
@Override // io.reactivex.Observer
public void onSubscribe(Disposable disposable) {
if (DisposableHelper.validate(this.d, disposable)) {
this.d = disposable;
this.a.onSubscribe(this);
}
}
}
public ObservableReduceSeedSingle(ObservableSource<T> observableSource, R r, BiFunction<R, ? super T, R> biFunction) {
this.a = observableSource;
this.b = r;
this.c = biFunction;
}
@Override // io.reactivex.Single
protected void b(SingleObserver<? super R> singleObserver) {
this.a.subscribe(new ReduceSeedObserver(singleObserver, this.c, this.b));
}
}

36
sources/io/reactivex/internal/operators/observable/ObservableReduceWithSingle.java Normal file
View File

@@ -0,0 +1,36 @@
package io.reactivex.internal.operators.observable;
import io.reactivex.ObservableSource;
import io.reactivex.Single;
import io.reactivex.SingleObserver;
import io.reactivex.exceptions.Exceptions;
import io.reactivex.functions.BiFunction;
import io.reactivex.internal.disposables.EmptyDisposable;
import io.reactivex.internal.functions.ObjectHelper;
import io.reactivex.internal.operators.observable.ObservableReduceSeedSingle;
import java.util.concurrent.Callable;
/* loaded from: classes2.dex */
public final class ObservableReduceWithSingle<T, R> extends Single<R> {
final ObservableSource<T> a;
final Callable<R> b;
final BiFunction<R, ? super T, R> c;
public ObservableReduceWithSingle(ObservableSource<T> observableSource, Callable<R> callable, BiFunction<R, ? super T, R> biFunction) {
this.a = observableSource;
this.b = callable;
this.c = biFunction;
}
@Override // io.reactivex.Single
protected void b(SingleObserver<? super R> singleObserver) {
try {
R call = this.b.call();
ObjectHelper.a(call, "The seedSupplier returned a null value");
this.a.subscribe(new ObservableReduceSeedSingle.ReduceSeedObserver(singleObserver, this.c, call));
} catch (Throwable th) {
Exceptions.b(th);
EmptyDisposable.error(th, singleObserver);
}
}
}

194
sources/io/reactivex/internal/operators/observable/ObservableRefCount.java Normal file
View File

@@ -0,0 +1,194 @@
package io.reactivex.internal.operators.observable;
import io.reactivex.Observable;
import io.reactivex.Observer;
import io.reactivex.Scheduler;
import io.reactivex.disposables.Disposable;
import io.reactivex.functions.Consumer;
import io.reactivex.internal.disposables.DisposableHelper;
import io.reactivex.internal.disposables.ResettableConnectable;
import io.reactivex.internal.disposables.SequentialDisposable;
import io.reactivex.observables.ConnectableObservable;
import io.reactivex.plugins.RxJavaPlugins;
import io.reactivex.schedulers.Schedulers;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicReference;
/* loaded from: classes2.dex */
public final class ObservableRefCount<T> extends Observable<T> {
final ConnectableObservable<T> a;
final int b;
final long c;
final TimeUnit d;
final Scheduler e;
RefConnection f;
static final class RefConnection extends AtomicReference<Disposable> implements Runnable, Consumer<Disposable> {
final ObservableRefCount<?> a;
Disposable b;
long c;
boolean d;
RefConnection(ObservableRefCount<?> observableRefCount) {
this.a = observableRefCount;
}
@Override // io.reactivex.functions.Consumer
/* renamed from: a, reason: merged with bridge method [inline-methods] */
public void accept(Disposable disposable) throws Exception {
DisposableHelper.replace(this, disposable);
}
@Override // java.lang.Runnable
public void run() {
this.a.c(this);
}
}
static final class RefCountObserver<T> extends AtomicBoolean implements Observer<T>, Disposable {
final Observer<? super T> a;
final ObservableRefCount<T> b;
final RefConnection c;
Disposable d;
RefCountObserver(Observer<? super T> observer, ObservableRefCount<T> observableRefCount, RefConnection refConnection) {
this.a = observer;
this.b = observableRefCount;
this.c = refConnection;
}
@Override // io.reactivex.disposables.Disposable
public void dispose() {
this.d.dispose();
if (compareAndSet(false, true)) {
this.b.a(this.c);
}
}
@Override // io.reactivex.Observer
public void onComplete() {
if (compareAndSet(false, true)) {
this.b.b(this.c);
this.a.onComplete();
}
}
@Override // io.reactivex.Observer
public void onError(Throwable th) {
if (!compareAndSet(false, true)) {
RxJavaPlugins.b(th);
} else {
this.b.b(this.c);
this.a.onError(th);
}
}
@Override // io.reactivex.Observer
public void onNext(T t) {
this.a.onNext(t);
}
@Override // io.reactivex.Observer
public void onSubscribe(Disposable disposable) {
if (DisposableHelper.validate(this.d, disposable)) {
this.d = disposable;
this.a.onSubscribe(this);
}
}
}
public ObservableRefCount(ConnectableObservable<T> connectableObservable) {
this(connectableObservable, 1, 0L, TimeUnit.NANOSECONDS, Schedulers.d());
}
void a(RefConnection refConnection) {
synchronized (this) {
if (this.f != null && this.f == refConnection) {
long j = refConnection.c - 1;
refConnection.c = j;
if (j == 0 && refConnection.d) {
if (this.c == 0) {
c(refConnection);
return;
}
SequentialDisposable sequentialDisposable = new SequentialDisposable();
refConnection.b = sequentialDisposable;
sequentialDisposable.replace(this.e.a(refConnection, this.c, this.d));
}
}
}
}
void b(RefConnection refConnection) {
synchronized (this) {
if (this.f != null && this.f == refConnection) {
this.f = null;
if (refConnection.b != null) {
refConnection.b.dispose();
}
}
long j = refConnection.c - 1;
refConnection.c = j;
if (j == 0) {
if (this.a instanceof Disposable) {
((Disposable) this.a).dispose();
} else if (this.a instanceof ResettableConnectable) {
((ResettableConnectable) this.a).a(refConnection.get());
}
}
}
}
void c(RefConnection refConnection) {
synchronized (this) {
if (refConnection.c == 0 && refConnection == this.f) {
this.f = null;
Disposable disposable = refConnection.get();
DisposableHelper.dispose(refConnection);
if (this.a instanceof Disposable) {
((Disposable) this.a).dispose();
} else if (this.a instanceof ResettableConnectable) {
((ResettableConnectable) this.a).a(disposable);
}
}
}
}
@Override // io.reactivex.Observable
protected void subscribeActual(Observer<? super T> observer) {
RefConnection refConnection;
boolean z;
synchronized (this) {
refConnection = this.f;
if (refConnection == null) {
refConnection = new RefConnection(this);
this.f = refConnection;
}
long j = refConnection.c;
if (j == 0 && refConnection.b != null) {
refConnection.b.dispose();
}
long j2 = j + 1;
refConnection.c = j2;
z = true;
if (refConnection.d || j2 != this.b) {
z = false;
} else {
refConnection.d = true;
}
}
this.a.subscribe(new RefCountObserver(observer, this, refConnection));
if (z) {
this.a.a(refConnection);
}
}
public ObservableRefCount(ConnectableObservable<T> connectableObservable, int i, long j, TimeUnit timeUnit, Scheduler scheduler) {
this.a = connectableObservable;
this.b = i;
this.c = j;
this.d = timeUnit;
this.e = scheduler;
}
}

81
sources/io/reactivex/internal/operators/observable/ObservableRepeat.java Normal file
View File

@@ -0,0 +1,81 @@
package io.reactivex.internal.operators.observable;
import io.reactivex.Observable;
import io.reactivex.ObservableSource;
import io.reactivex.Observer;
import io.reactivex.disposables.Disposable;
import io.reactivex.internal.disposables.SequentialDisposable;
import java.util.concurrent.atomic.AtomicInteger;
/* loaded from: classes2.dex */
public final class ObservableRepeat<T> extends AbstractObservableWithUpstream<T, T> {
final long b;
static final class RepeatObserver<T> extends AtomicInteger implements Observer<T> {
final Observer<? super T> a;
final SequentialDisposable b;
final ObservableSource<? extends T> c;
long d;
RepeatObserver(Observer<? super T> observer, long j, SequentialDisposable sequentialDisposable, ObservableSource<? extends T> observableSource) {
this.a = observer;
this.b = sequentialDisposable;
this.c = observableSource;
this.d = j;
}
void a() {
if (getAndIncrement() == 0) {
int i = 1;
while (!this.b.isDisposed()) {
this.c.subscribe(this);
i = addAndGet(-i);
if (i == 0) {
return;
}
}
}
}
@Override // io.reactivex.Observer
public void onComplete() {
long j = this.d;
if (j != Long.MAX_VALUE) {
this.d = j - 1;
}
if (j != 0) {
a();
} else {
this.a.onComplete();
}
}
@Override // io.reactivex.Observer
public void onError(Throwable th) {
this.a.onError(th);
}
@Override // io.reactivex.Observer
public void onNext(T t) {
this.a.onNext(t);
}
@Override // io.reactivex.Observer
public void onSubscribe(Disposable disposable) {
this.b.replace(disposable);
}
}
public ObservableRepeat(Observable<T> observable, long j) {
super(observable);
this.b = j;
}
@Override // io.reactivex.Observable
public void subscribeActual(Observer<? super T> observer) {
SequentialDisposable sequentialDisposable = new SequentialDisposable();
observer.onSubscribe(sequentialDisposable);
long j = this.b;
new RepeatObserver(observer, j != Long.MAX_VALUE ? j - 1 : Long.MAX_VALUE, sequentialDisposable, this.a).a();
}
}

80
sources/io/reactivex/internal/operators/observable/ObservableRepeatUntil.java Normal file
View File

@@ -0,0 +1,80 @@
package io.reactivex.internal.operators.observable;
import io.reactivex.Observable;
import io.reactivex.ObservableSource;
import io.reactivex.Observer;
import io.reactivex.disposables.Disposable;
import io.reactivex.exceptions.Exceptions;
import io.reactivex.functions.BooleanSupplier;
import io.reactivex.internal.disposables.SequentialDisposable;
import java.util.concurrent.atomic.AtomicInteger;
/* loaded from: classes2.dex */
public final class ObservableRepeatUntil<T> extends AbstractObservableWithUpstream<T, T> {
final BooleanSupplier b;
static final class RepeatUntilObserver<T> extends AtomicInteger implements Observer<T> {
final Observer<? super T> a;
final SequentialDisposable b;
final ObservableSource<? extends T> c;
final BooleanSupplier d;
RepeatUntilObserver(Observer<? super T> observer, BooleanSupplier booleanSupplier, SequentialDisposable sequentialDisposable, ObservableSource<? extends T> observableSource) {
this.a = observer;
this.b = sequentialDisposable;
this.c = observableSource;
this.d = booleanSupplier;
}
void a() {
if (getAndIncrement() == 0) {
int i = 1;
do {
this.c.subscribe(this);
i = addAndGet(-i);
} while (i != 0);
}
}
@Override // io.reactivex.Observer
public void onComplete() {
try {
if (this.d.a()) {
this.a.onComplete();
} else {
a();
}
} catch (Throwable th) {
Exceptions.b(th);
this.a.onError(th);
}
}
@Override // io.reactivex.Observer
public void onError(Throwable th) {
this.a.onError(th);
}
@Override // io.reactivex.Observer
public void onNext(T t) {
this.a.onNext(t);
}
@Override // io.reactivex.Observer
public void onSubscribe(Disposable disposable) {
this.b.replace(disposable);
}
}
public ObservableRepeatUntil(Observable<T> observable, BooleanSupplier booleanSupplier) {
super(observable);
this.b = booleanSupplier;
}
@Override // io.reactivex.Observable
public void subscribeActual(Observer<? super T> observer) {
SequentialDisposable sequentialDisposable = new SequentialDisposable();
observer.onSubscribe(sequentialDisposable);
new RepeatUntilObserver(observer, this.b, sequentialDisposable, this.a).a();
}
}

146
sources/io/reactivex/internal/operators/observable/ObservableRepeatWhen.java Normal file
View File

@@ -0,0 +1,146 @@
package io.reactivex.internal.operators.observable;
import io.reactivex.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.disposables.EmptyDisposable;
import io.reactivex.internal.functions.ObjectHelper;
import io.reactivex.internal.util.AtomicThrowable;
import io.reactivex.internal.util.HalfSerializer;
import io.reactivex.subjects.PublishSubject;
import io.reactivex.subjects.Subject;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicReference;
/* loaded from: classes2.dex */
public final class ObservableRepeatWhen<T> extends AbstractObservableWithUpstream<T, T> {
final Function<? super Observable<Object>, ? extends ObservableSource<?>> b;
public ObservableRepeatWhen(ObservableSource<T> observableSource, Function<? super Observable<Object>, ? extends ObservableSource<?>> function) {
super(observableSource);
this.b = function;
}
@Override // io.reactivex.Observable
protected void subscribeActual(Observer<? super T> observer) {
Subject<T> a = PublishSubject.b().a();
try {
ObservableSource<?> apply = this.b.apply(a);
ObjectHelper.a(apply, "The handler returned a null ObservableSource");
ObservableSource<?> observableSource = apply;
RepeatWhenObserver repeatWhenObserver = new RepeatWhenObserver(observer, a, this.a);
observer.onSubscribe(repeatWhenObserver);
observableSource.subscribe(repeatWhenObserver.e);
repeatWhenObserver.d();
} catch (Throwable th) {
Exceptions.b(th);
EmptyDisposable.error(th, observer);
}
}
static final class RepeatWhenObserver<T> extends AtomicInteger implements Observer<T>, Disposable {
final Observer<? super T> a;
final Subject<Object> d;
final ObservableSource<T> g;
volatile boolean h;
final AtomicInteger b = new AtomicInteger();
final AtomicThrowable c = new AtomicThrowable();
final RepeatWhenObserver<T>.InnerRepeatObserver e = new InnerRepeatObserver();
final AtomicReference<Disposable> f = new AtomicReference<>();
final class InnerRepeatObserver extends AtomicReference<Disposable> implements Observer<Object> {
InnerRepeatObserver() {
}
@Override // io.reactivex.Observer
public void onComplete() {
RepeatWhenObserver.this.a();
}
@Override // io.reactivex.Observer
public void onError(Throwable th) {
RepeatWhenObserver.this.a(th);
}
@Override // io.reactivex.Observer
public void onNext(Object obj) {
RepeatWhenObserver.this.b();
}
@Override // io.reactivex.Observer
public void onSubscribe(Disposable disposable) {
DisposableHelper.setOnce(this, disposable);
}
}
RepeatWhenObserver(Observer<? super T> observer, Subject<Object> subject, ObservableSource<T> observableSource) {
this.a = observer;
this.d = subject;
this.g = observableSource;
}
void a(Throwable th) {
DisposableHelper.dispose(this.f);
HalfSerializer.a((Observer<?>) this.a, th, (AtomicInteger) this, this.c);
}
void b() {
d();
}
public boolean c() {
return DisposableHelper.isDisposed(this.f.get());
}
void d() {
if (this.b.getAndIncrement() == 0) {
while (!c()) {
if (!this.h) {
this.h = true;
this.g.subscribe(this);
}
if (this.b.decrementAndGet() == 0) {
return;
}
}
}
}
@Override // io.reactivex.disposables.Disposable
public void dispose() {
DisposableHelper.dispose(this.f);
DisposableHelper.dispose(this.e);
}
@Override // io.reactivex.Observer
public void onComplete() {
this.h = false;
this.d.onNext(0);
}
@Override // io.reactivex.Observer
public void onError(Throwable th) {
DisposableHelper.dispose(this.e);
HalfSerializer.a((Observer<?>) this.a, th, (AtomicInteger) this, this.c);
}
@Override // io.reactivex.Observer
public void onNext(T t) {
HalfSerializer.a(this.a, t, this, this.c);
}
@Override // io.reactivex.Observer
public void onSubscribe(Disposable disposable) {
DisposableHelper.replace(this.f, disposable);
}
void a() {
DisposableHelper.dispose(this.f);
HalfSerializer.a(this.a, this, this.c);
}
}
}

728
sources/io/reactivex/internal/operators/observable/ObservableReplay.java Normal file
View File

@@ -0,0 +1,728 @@
package io.reactivex.internal.operators.observable;
import io.reactivex.Observable;
import io.reactivex.ObservableSource;
import io.reactivex.Observer;
import io.reactivex.Scheduler;
import io.reactivex.disposables.Disposable;
import io.reactivex.exceptions.Exceptions;
import io.reactivex.functions.Consumer;
import io.reactivex.functions.Function;
import io.reactivex.internal.disposables.DisposableHelper;
import io.reactivex.internal.disposables.EmptyDisposable;
import io.reactivex.internal.disposables.ResettableConnectable;
import io.reactivex.internal.functions.ObjectHelper;
import io.reactivex.internal.fuseable.HasUpstreamObservableSource;
import io.reactivex.internal.util.ExceptionHelper;
import io.reactivex.internal.util.NotificationLite;
import io.reactivex.observables.ConnectableObservable;
import io.reactivex.plugins.RxJavaPlugins;
import io.reactivex.schedulers.Timed;
import java.util.ArrayList;
import java.util.concurrent.Callable;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicReference;
/* loaded from: classes2.dex */
public final class ObservableReplay<T> extends ConnectableObservable<T> implements HasUpstreamObservableSource<T>, ResettableConnectable {
static final BufferSupplier e = new UnBoundedFactory();
final ObservableSource<T> a;
final AtomicReference<ReplayObserver<T>> b;
final BufferSupplier<T> c;
final ObservableSource<T> d;
static abstract class BoundedReplayBuffer<T> extends AtomicReference<Node> implements ReplayBuffer<T> {
Node a;
int b;
BoundedReplayBuffer() {
Node node = new Node(null);
this.a = node;
set(node);
}
Object a(Object obj) {
return obj;
}
final void a(Node node) {
this.a.set(node);
this.a = node;
this.b++;
}
Object b(Object obj) {
return obj;
}
final void b(Node node) {
set(node);
}
final void c() {
this.b--;
b(get().get());
}
final void d() {
Node node = get();
if (node.a != null) {
Node node2 = new Node(null);
node2.lazySet(node.get());
set(node2);
}
}
abstract void e();
void f() {
d();
}
@Override // io.reactivex.internal.operators.observable.ObservableReplay.ReplayBuffer
public final void next(T t) {
a(new Node(a(NotificationLite.next(t))));
e();
}
Node b() {
return get();
}
@Override // io.reactivex.internal.operators.observable.ObservableReplay.ReplayBuffer
public final void a(Throwable th) {
a(new Node(a(NotificationLite.error(th))));
f();
}
@Override // io.reactivex.internal.operators.observable.ObservableReplay.ReplayBuffer
public final void a() {
a(new Node(a(NotificationLite.complete())));
f();
}
@Override // io.reactivex.internal.operators.observable.ObservableReplay.ReplayBuffer
public final void a(InnerDisposable<T> innerDisposable) {
if (innerDisposable.getAndIncrement() != 0) {
return;
}
int i = 1;
do {
Node node = (Node) innerDisposable.a();
if (node == null) {
node = b();
innerDisposable.c = node;
}
while (!innerDisposable.b()) {
Node node2 = node.get();
if (node2 != null) {
if (NotificationLite.accept(b(node2.a), innerDisposable.b)) {
innerDisposable.c = null;
return;
}
node = node2;
} else {
innerDisposable.c = node;
i = innerDisposable.addAndGet(-i);
}
}
return;
} while (i != 0);
}
}
interface BufferSupplier<T> {
ReplayBuffer<T> call();
}
static final class DisposeConsumer<R> implements Consumer<Disposable> {
private final ObserverResourceWrapper<R> a;
DisposeConsumer(ObserverResourceWrapper<R> observerResourceWrapper) {
this.a = observerResourceWrapper;
}
@Override // io.reactivex.functions.Consumer
/* renamed from: a, reason: merged with bridge method [inline-methods] */
public void accept(Disposable disposable) {
this.a.setResource(disposable);
}
}
static final class InnerDisposable<T> extends AtomicInteger implements Disposable {
final ReplayObserver<T> a;
final Observer<? super T> b;
Object c;
volatile boolean d;
InnerDisposable(ReplayObserver<T> replayObserver, Observer<? super T> observer) {
this.a = replayObserver;
this.b = observer;
}
<U> U a() {
return (U) this.c;
}
public boolean b() {
return this.d;
}
@Override // io.reactivex.disposables.Disposable
public void dispose() {
if (this.d) {
return;
}
this.d = true;
this.a.b(this);
}
}
static final class MulticastReplay<R, U> extends Observable<R> {
private final Callable<? extends ConnectableObservable<U>> a;
private final Function<? super Observable<U>, ? extends ObservableSource<R>> b;
MulticastReplay(Callable<? extends ConnectableObservable<U>> callable, Function<? super Observable<U>, ? extends ObservableSource<R>> function) {
this.a = callable;
this.b = function;
}
@Override // io.reactivex.Observable
protected void subscribeActual(Observer<? super R> observer) {
try {
ConnectableObservable<U> call = this.a.call();
ObjectHelper.a(call, "The connectableFactory returned a null ConnectableObservable");
ConnectableObservable<U> connectableObservable = call;
ObservableSource<R> apply = this.b.apply(connectableObservable);
ObjectHelper.a(apply, "The selector returned a null ObservableSource");
ObservableSource<R> observableSource = apply;
ObserverResourceWrapper observerResourceWrapper = new ObserverResourceWrapper(observer);
observableSource.subscribe(observerResourceWrapper);
connectableObservable.a(new DisposeConsumer(observerResourceWrapper));
} catch (Throwable th) {
Exceptions.b(th);
EmptyDisposable.error(th, observer);
}
}
}
static final class Node extends AtomicReference<Node> {
final Object a;
Node(Object obj) {
this.a = obj;
}
}
static final class Replay<T> extends ConnectableObservable<T> {
private final ConnectableObservable<T> a;
private final Observable<T> b;
Replay(ConnectableObservable<T> connectableObservable, Observable<T> observable) {
this.a = connectableObservable;
this.b = observable;
}
@Override // io.reactivex.observables.ConnectableObservable
public void a(Consumer<? super Disposable> consumer) {
this.a.a(consumer);
}
@Override // io.reactivex.Observable
protected void subscribeActual(Observer<? super T> observer) {
this.b.subscribe(observer);
}
}
interface ReplayBuffer<T> {
void a();
void a(InnerDisposable<T> innerDisposable);
void a(Throwable th);
void next(T t);
}
static final class ReplayBufferSupplier<T> implements BufferSupplier<T> {
private final int a;
ReplayBufferSupplier(int i) {
this.a = i;
}
@Override // io.reactivex.internal.operators.observable.ObservableReplay.BufferSupplier
public ReplayBuffer<T> call() {
return new SizeBoundReplayBuffer(this.a);
}
}
static final class ReplayObserver<T> extends AtomicReference<Disposable> implements Observer<T>, Disposable {
static final InnerDisposable[] e = new InnerDisposable[0];
static final InnerDisposable[] f = new InnerDisposable[0];
final ReplayBuffer<T> a;
boolean b;
final AtomicReference<InnerDisposable[]> c = new AtomicReference<>(e);
final AtomicBoolean d = new AtomicBoolean();
ReplayObserver(ReplayBuffer<T> replayBuffer) {
this.a = replayBuffer;
}
public boolean a() {
return this.c.get() == f;
}
void b(InnerDisposable<T> innerDisposable) {
InnerDisposable[] innerDisposableArr;
InnerDisposable[] innerDisposableArr2;
do {
innerDisposableArr = this.c.get();
int length = innerDisposableArr.length;
if (length == 0) {
return;
}
int i = -1;
int i2 = 0;
while (true) {
if (i2 >= length) {
break;
}
if (innerDisposableArr[i2].equals(innerDisposable)) {
i = i2;
break;
}
i2++;
}
if (i < 0) {
return;
}
if (length == 1) {
innerDisposableArr2 = e;
} else {
InnerDisposable[] innerDisposableArr3 = new InnerDisposable[length - 1];
System.arraycopy(innerDisposableArr, 0, innerDisposableArr3, 0, i);
System.arraycopy(innerDisposableArr, i + 1, innerDisposableArr3, i, (length - i) - 1);
innerDisposableArr2 = innerDisposableArr3;
}
} while (!this.c.compareAndSet(innerDisposableArr, innerDisposableArr2));
}
void c() {
for (InnerDisposable<T> innerDisposable : this.c.getAndSet(f)) {
this.a.a(innerDisposable);
}
}
@Override // io.reactivex.disposables.Disposable
public void dispose() {
this.c.set(f);
DisposableHelper.dispose(this);
}
@Override // io.reactivex.Observer
public void onComplete() {
if (this.b) {
return;
}
this.b = true;
this.a.a();
c();
}
@Override // io.reactivex.Observer
public void onError(Throwable th) {
if (this.b) {
RxJavaPlugins.b(th);
return;
}
this.b = true;
this.a.a(th);
c();
}
@Override // io.reactivex.Observer
public void onNext(T t) {
if (this.b) {
return;
}
this.a.next(t);
b();
}
@Override // io.reactivex.Observer
public void onSubscribe(Disposable disposable) {
if (DisposableHelper.setOnce(this, disposable)) {
b();
}
}
boolean a(InnerDisposable<T> innerDisposable) {
InnerDisposable[] innerDisposableArr;
InnerDisposable[] innerDisposableArr2;
do {
innerDisposableArr = this.c.get();
if (innerDisposableArr == f) {
return false;
}
int length = innerDisposableArr.length;
innerDisposableArr2 = new InnerDisposable[length + 1];
System.arraycopy(innerDisposableArr, 0, innerDisposableArr2, 0, length);
innerDisposableArr2[length] = innerDisposable;
} while (!this.c.compareAndSet(innerDisposableArr, innerDisposableArr2));
return true;
}
void b() {
for (InnerDisposable<T> innerDisposable : this.c.get()) {
this.a.a(innerDisposable);
}
}
}
static final class ReplaySource<T> implements ObservableSource<T> {
private final AtomicReference<ReplayObserver<T>> a;
private final BufferSupplier<T> b;
ReplaySource(AtomicReference<ReplayObserver<T>> atomicReference, BufferSupplier<T> bufferSupplier) {
this.a = atomicReference;
this.b = bufferSupplier;
}
@Override // io.reactivex.ObservableSource
public void subscribe(Observer<? super T> observer) {
ReplayObserver<T> replayObserver;
while (true) {
replayObserver = this.a.get();
if (replayObserver != null) {
break;
}
ReplayObserver<T> replayObserver2 = new ReplayObserver<>(this.b.call());
if (this.a.compareAndSet(null, replayObserver2)) {
replayObserver = replayObserver2;
break;
}
}
InnerDisposable<T> innerDisposable = new InnerDisposable<>(replayObserver, observer);
observer.onSubscribe(innerDisposable);
replayObserver.a(innerDisposable);
if (innerDisposable.b()) {
replayObserver.b(innerDisposable);
} else {
replayObserver.a.a(innerDisposable);
}
}
}
static final class ScheduledReplaySupplier<T> implements BufferSupplier<T> {
private final int a;
private final long b;
private final TimeUnit c;
private final Scheduler d;
ScheduledReplaySupplier(int i, long j, TimeUnit timeUnit, Scheduler scheduler) {
this.a = i;
this.b = j;
this.c = timeUnit;
this.d = scheduler;
}
@Override // io.reactivex.internal.operators.observable.ObservableReplay.BufferSupplier
public ReplayBuffer<T> call() {
return new SizeAndTimeBoundReplayBuffer(this.a, this.b, this.c, this.d);
}
}
static final class SizeAndTimeBoundReplayBuffer<T> extends BoundedReplayBuffer<T> {
final Scheduler c;
final long d;
final TimeUnit e;
final int f;
SizeAndTimeBoundReplayBuffer(int i, long j, TimeUnit timeUnit, Scheduler scheduler) {
this.c = scheduler;
this.f = i;
this.d = j;
this.e = timeUnit;
}
@Override // io.reactivex.internal.operators.observable.ObservableReplay.BoundedReplayBuffer
Object a(Object obj) {
return new Timed(obj, this.c.a(this.e), this.e);
}
@Override // io.reactivex.internal.operators.observable.ObservableReplay.BoundedReplayBuffer
Object b(Object obj) {
return ((Timed) obj).b();
}
@Override // io.reactivex.internal.operators.observable.ObservableReplay.BoundedReplayBuffer
void e() {
Node node;
long a = this.c.a(this.e) - this.d;
Node node2 = get();
Node node3 = node2.get();
int i = 0;
while (true) {
Node node4 = node3;
node = node2;
node2 = node4;
if (node2 != null) {
int i2 = this.b;
if (i2 <= this.f) {
if (((Timed) node2.a).a() > a) {
break;
}
i++;
this.b--;
node3 = node2.get();
} else {
i++;
this.b = i2 - 1;
node3 = node2.get();
}
} else {
break;
}
}
if (i != 0) {
b(node);
}
}
/* JADX WARN: Code restructure failed: missing block: B:11:0x003e, code lost:
b(r3);
*/
/* JADX WARN: Code restructure failed: missing block: B:12:0x0041, code lost:
return;
*/
@Override // io.reactivex.internal.operators.observable.ObservableReplay.BoundedReplayBuffer
/*
Code decompiled incorrectly, please refer to instructions dump.
To view partially-correct code enable 'Show inconsistent code' option in preferences
*/
void f() {
/*
r10 = this;
io.reactivex.Scheduler r0 = r10.c
java.util.concurrent.TimeUnit r1 = r10.e
long r0 = r0.a(r1)
long r2 = r10.d
long r0 = r0 - r2
java.lang.Object r2 = r10.get()
io.reactivex.internal.operators.observable.ObservableReplay$Node r2 = (io.reactivex.internal.operators.observable.ObservableReplay.Node) r2
java.lang.Object r3 = r2.get()
io.reactivex.internal.operators.observable.ObservableReplay$Node r3 = (io.reactivex.internal.operators.observable.ObservableReplay.Node) r3
r4 = 0
L18:
r9 = r3
r3 = r2
r2 = r9
if (r2 == 0) goto L3c
int r5 = r10.b
r6 = 1
if (r5 <= r6) goto L3c
java.lang.Object r5 = r2.a
io.reactivex.schedulers.Timed r5 = (io.reactivex.schedulers.Timed) r5
long r7 = r5.a()
int r5 = (r7 > r0 ? 1 : (r7 == r0 ? 0 : -1))
if (r5 > 0) goto L3c
int r4 = r4 + 1
int r3 = r10.b
int r3 = r3 - r6
r10.b = r3
java.lang.Object r3 = r2.get()
io.reactivex.internal.operators.observable.ObservableReplay$Node r3 = (io.reactivex.internal.operators.observable.ObservableReplay.Node) r3
goto L18
L3c:
if (r4 == 0) goto L41
r10.b(r3)
L41:
return
*/
throw new UnsupportedOperationException("Method not decompiled: io.reactivex.internal.operators.observable.ObservableReplay.SizeAndTimeBoundReplayBuffer.f():void");
}
@Override // io.reactivex.internal.operators.observable.ObservableReplay.BoundedReplayBuffer
Node b() {
Node node;
long a = this.c.a(this.e) - this.d;
Node node2 = get();
Node node3 = node2.get();
while (true) {
Node node4 = node3;
node = node2;
node2 = node4;
if (node2 != null) {
Timed timed = (Timed) node2.a;
if (NotificationLite.isComplete(timed.b()) || NotificationLite.isError(timed.b()) || timed.a() > a) {
break;
}
node3 = node2.get();
} else {
break;
}
}
return node;
}
}
static final class SizeBoundReplayBuffer<T> extends BoundedReplayBuffer<T> {
final int c;
SizeBoundReplayBuffer(int i) {
this.c = i;
}
@Override // io.reactivex.internal.operators.observable.ObservableReplay.BoundedReplayBuffer
void e() {
if (this.b > this.c) {
c();
}
}
}
static final class UnBoundedFactory implements BufferSupplier<Object> {
UnBoundedFactory() {
}
@Override // io.reactivex.internal.operators.observable.ObservableReplay.BufferSupplier
public ReplayBuffer<Object> call() {
return new UnboundedReplayBuffer(16);
}
}
private ObservableReplay(ObservableSource<T> observableSource, ObservableSource<T> observableSource2, AtomicReference<ReplayObserver<T>> atomicReference, BufferSupplier<T> bufferSupplier) {
this.d = observableSource;
this.a = observableSource2;
this.b = atomicReference;
this.c = bufferSupplier;
}
public static <U, R> Observable<R> a(Callable<? extends ConnectableObservable<U>> callable, Function<? super Observable<U>, ? extends ObservableSource<R>> function) {
return RxJavaPlugins.a(new MulticastReplay(callable, function));
}
@Override // io.reactivex.Observable
protected void subscribeActual(Observer<? super T> observer) {
this.d.subscribe(observer);
}
static final class UnboundedReplayBuffer<T> extends ArrayList<Object> implements ReplayBuffer<T> {
volatile int a;
UnboundedReplayBuffer(int i) {
super(i);
}
@Override // io.reactivex.internal.operators.observable.ObservableReplay.ReplayBuffer
public void a(Throwable th) {
add(NotificationLite.error(th));
this.a++;
}
@Override // io.reactivex.internal.operators.observable.ObservableReplay.ReplayBuffer
public void next(T t) {
add(NotificationLite.next(t));
this.a++;
}
@Override // io.reactivex.internal.operators.observable.ObservableReplay.ReplayBuffer
public void a() {
add(NotificationLite.complete());
this.a++;
}
@Override // io.reactivex.internal.operators.observable.ObservableReplay.ReplayBuffer
public void a(InnerDisposable<T> innerDisposable) {
if (innerDisposable.getAndIncrement() != 0) {
return;
}
Observer<? super T> observer = innerDisposable.b;
int i = 1;
while (!innerDisposable.b()) {
int i2 = this.a;
Integer num = (Integer) innerDisposable.a();
int intValue = num != null ? num.intValue() : 0;
while (intValue < i2) {
if (NotificationLite.accept(get(intValue), observer) || innerDisposable.b()) {
return;
} else {
intValue++;
}
}
innerDisposable.c = Integer.valueOf(intValue);
i = innerDisposable.addAndGet(-i);
if (i == 0) {
return;
}
}
}
}
public static <T> ConnectableObservable<T> a(ConnectableObservable<T> connectableObservable, Scheduler scheduler) {
return RxJavaPlugins.a((ConnectableObservable) new Replay(connectableObservable, connectableObservable.observeOn(scheduler)));
}
public static <T> ConnectableObservable<T> a(ObservableSource<? extends T> observableSource) {
return a(observableSource, e);
}
public static <T> ConnectableObservable<T> a(ObservableSource<T> observableSource, int i) {
if (i == Integer.MAX_VALUE) {
return a(observableSource);
}
return a(observableSource, new ReplayBufferSupplier(i));
}
public static <T> ConnectableObservable<T> a(ObservableSource<T> observableSource, long j, TimeUnit timeUnit, Scheduler scheduler) {
return a(observableSource, j, timeUnit, scheduler, Integer.MAX_VALUE);
}
public static <T> ConnectableObservable<T> a(ObservableSource<T> observableSource, long j, TimeUnit timeUnit, Scheduler scheduler, int i) {
return a(observableSource, new ScheduledReplaySupplier(i, j, timeUnit, scheduler));
}
static <T> ConnectableObservable<T> a(ObservableSource<T> observableSource, BufferSupplier<T> bufferSupplier) {
AtomicReference atomicReference = new AtomicReference();
return RxJavaPlugins.a((ConnectableObservable) new ObservableReplay(new ReplaySource(atomicReference, bufferSupplier), observableSource, atomicReference, bufferSupplier));
}
@Override // io.reactivex.internal.disposables.ResettableConnectable
public void a(Disposable disposable) {
this.b.compareAndSet((ReplayObserver) disposable, null);
}
@Override // io.reactivex.observables.ConnectableObservable
public void a(Consumer<? super Disposable> consumer) {
ReplayObserver<T> replayObserver;
while (true) {
replayObserver = this.b.get();
if (replayObserver != null && !replayObserver.a()) {
break;
}
ReplayObserver<T> replayObserver2 = new ReplayObserver<>(this.c.call());
if (this.b.compareAndSet(replayObserver, replayObserver2)) {
replayObserver = replayObserver2;
break;
}
}
boolean z = !replayObserver.d.get() && replayObserver.d.compareAndSet(false, true);
try {
consumer.accept(replayObserver);
if (z) {
this.a.subscribe(replayObserver);
}
} catch (Throwable th) {
if (z) {
replayObserver.d.compareAndSet(true, false);
}
Exceptions.b(th);
throw ExceptionHelper.a(th);
}
}
}

88
sources/io/reactivex/internal/operators/observable/ObservableRetryBiPredicate.java Normal file
View File

@@ -0,0 +1,88 @@
package io.reactivex.internal.operators.observable;
import io.reactivex.Observable;
import io.reactivex.ObservableSource;
import io.reactivex.Observer;
import io.reactivex.disposables.Disposable;
import io.reactivex.exceptions.CompositeException;
import io.reactivex.exceptions.Exceptions;
import io.reactivex.functions.BiPredicate;
import io.reactivex.internal.disposables.SequentialDisposable;
import java.util.concurrent.atomic.AtomicInteger;
/* loaded from: classes2.dex */
public final class ObservableRetryBiPredicate<T> extends AbstractObservableWithUpstream<T, T> {
final BiPredicate<? super Integer, ? super Throwable> b;
static final class RetryBiObserver<T> extends AtomicInteger implements Observer<T> {
final Observer<? super T> a;
final SequentialDisposable b;
final ObservableSource<? extends T> c;
final BiPredicate<? super Integer, ? super Throwable> d;
int e;
RetryBiObserver(Observer<? super T> observer, BiPredicate<? super Integer, ? super Throwable> biPredicate, SequentialDisposable sequentialDisposable, ObservableSource<? extends T> observableSource) {
this.a = observer;
this.b = sequentialDisposable;
this.c = observableSource;
this.d = biPredicate;
}
void a() {
if (getAndIncrement() == 0) {
int i = 1;
while (!this.b.isDisposed()) {
this.c.subscribe(this);
i = addAndGet(-i);
if (i == 0) {
return;
}
}
}
}
@Override // io.reactivex.Observer
public void onComplete() {
this.a.onComplete();
}
@Override // io.reactivex.Observer
public void onError(Throwable th) {
try {
BiPredicate<? super Integer, ? super Throwable> biPredicate = this.d;
int i = this.e + 1;
this.e = i;
if (biPredicate.a(Integer.valueOf(i), th)) {
a();
} else {
this.a.onError(th);
}
} catch (Throwable th2) {
Exceptions.b(th2);
this.a.onError(new CompositeException(th, th2));
}
}
@Override // io.reactivex.Observer
public void onNext(T t) {
this.a.onNext(t);
}
@Override // io.reactivex.Observer
public void onSubscribe(Disposable disposable) {
this.b.update(disposable);
}
}
public ObservableRetryBiPredicate(Observable<T> observable, BiPredicate<? super Integer, ? super Throwable> biPredicate) {
super(observable);
this.b = biPredicate;
}
@Override // io.reactivex.Observable
public void subscribeActual(Observer<? super T> observer) {
SequentialDisposable sequentialDisposable = new SequentialDisposable();
observer.onSubscribe(sequentialDisposable);
new RetryBiObserver(observer, this.b, sequentialDisposable, this.a).a();
}
}

96
sources/io/reactivex/internal/operators/observable/ObservableRetryPredicate.java Normal file
View File

@@ -0,0 +1,96 @@
package io.reactivex.internal.operators.observable;
import io.reactivex.Observable;
import io.reactivex.ObservableSource;
import io.reactivex.Observer;
import io.reactivex.disposables.Disposable;
import io.reactivex.exceptions.CompositeException;
import io.reactivex.exceptions.Exceptions;
import io.reactivex.functions.Predicate;
import io.reactivex.internal.disposables.SequentialDisposable;
import java.util.concurrent.atomic.AtomicInteger;
/* loaded from: classes2.dex */
public final class ObservableRetryPredicate<T> extends AbstractObservableWithUpstream<T, T> {
final Predicate<? super Throwable> b;
final long c;
static final class RepeatObserver<T> extends AtomicInteger implements Observer<T> {
final Observer<? super T> a;
final SequentialDisposable b;
final ObservableSource<? extends T> c;
final Predicate<? super Throwable> d;
long e;
RepeatObserver(Observer<? super T> observer, long j, Predicate<? super Throwable> predicate, SequentialDisposable sequentialDisposable, ObservableSource<? extends T> observableSource) {
this.a = observer;
this.b = sequentialDisposable;
this.c = observableSource;
this.d = predicate;
this.e = j;
}
void a() {
if (getAndIncrement() == 0) {
int i = 1;
while (!this.b.isDisposed()) {
this.c.subscribe(this);
i = addAndGet(-i);
if (i == 0) {
return;
}
}
}
}
@Override // io.reactivex.Observer
public void onComplete() {
this.a.onComplete();
}
@Override // io.reactivex.Observer
public void onError(Throwable th) {
long j = this.e;
if (j != Long.MAX_VALUE) {
this.e = j - 1;
}
if (j == 0) {
this.a.onError(th);
return;
}
try {
if (this.d.a(th)) {
a();
} else {
this.a.onError(th);
}
} catch (Throwable th2) {
Exceptions.b(th2);
this.a.onError(new CompositeException(th, th2));
}
}
@Override // io.reactivex.Observer
public void onNext(T t) {
this.a.onNext(t);
}
@Override // io.reactivex.Observer
public void onSubscribe(Disposable disposable) {
this.b.update(disposable);
}
}
public ObservableRetryPredicate(Observable<T> observable, long j, Predicate<? super Throwable> predicate) {
super(observable);
this.b = predicate;
this.c = j;
}
@Override // io.reactivex.Observable
public void subscribeActual(Observer<? super T> observer) {
SequentialDisposable sequentialDisposable = new SequentialDisposable();
observer.onSubscribe(sequentialDisposable);
new RepeatObserver(observer, this.c, this.b, sequentialDisposable, this.a).a();
}
}

146
sources/io/reactivex/internal/operators/observable/ObservableRetryWhen.java Normal file
View File

@@ -0,0 +1,146 @@
package io.reactivex.internal.operators.observable;
import io.reactivex.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.disposables.EmptyDisposable;
import io.reactivex.internal.functions.ObjectHelper;
import io.reactivex.internal.util.AtomicThrowable;
import io.reactivex.internal.util.HalfSerializer;
import io.reactivex.subjects.PublishSubject;
import io.reactivex.subjects.Subject;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicReference;
/* loaded from: classes2.dex */
public final class ObservableRetryWhen<T> extends AbstractObservableWithUpstream<T, T> {
final Function<? super Observable<Throwable>, ? extends ObservableSource<?>> b;
public ObservableRetryWhen(ObservableSource<T> observableSource, Function<? super Observable<Throwable>, ? extends ObservableSource<?>> function) {
super(observableSource);
this.b = function;
}
@Override // io.reactivex.Observable
protected void subscribeActual(Observer<? super T> observer) {
Subject<T> a = PublishSubject.b().a();
try {
ObservableSource<?> apply = this.b.apply(a);
ObjectHelper.a(apply, "The handler returned a null ObservableSource");
ObservableSource<?> observableSource = apply;
RepeatWhenObserver repeatWhenObserver = new RepeatWhenObserver(observer, a, this.a);
observer.onSubscribe(repeatWhenObserver);
observableSource.subscribe(repeatWhenObserver.e);
repeatWhenObserver.d();
} catch (Throwable th) {
Exceptions.b(th);
EmptyDisposable.error(th, observer);
}
}
static final class RepeatWhenObserver<T> extends AtomicInteger implements Observer<T>, Disposable {
final Observer<? super T> a;
final Subject<Throwable> d;
final ObservableSource<T> g;
volatile boolean h;
final AtomicInteger b = new AtomicInteger();
final AtomicThrowable c = new AtomicThrowable();
final RepeatWhenObserver<T>.InnerRepeatObserver e = new InnerRepeatObserver();
final AtomicReference<Disposable> f = new AtomicReference<>();
final class InnerRepeatObserver extends AtomicReference<Disposable> implements Observer<Object> {
InnerRepeatObserver() {
}
@Override // io.reactivex.Observer
public void onComplete() {
RepeatWhenObserver.this.a();
}
@Override // io.reactivex.Observer
public void onError(Throwable th) {
RepeatWhenObserver.this.a(th);
}
@Override // io.reactivex.Observer
public void onNext(Object obj) {
RepeatWhenObserver.this.b();
}
@Override // io.reactivex.Observer
public void onSubscribe(Disposable disposable) {
DisposableHelper.setOnce(this, disposable);
}
}
RepeatWhenObserver(Observer<? super T> observer, Subject<Throwable> subject, ObservableSource<T> observableSource) {
this.a = observer;
this.d = subject;
this.g = observableSource;
}
void a(Throwable th) {
DisposableHelper.dispose(this.f);
HalfSerializer.a((Observer<?>) this.a, th, (AtomicInteger) this, this.c);
}
void b() {
d();
}
public boolean c() {
return DisposableHelper.isDisposed(this.f.get());
}
void d() {
if (this.b.getAndIncrement() == 0) {
while (!c()) {
if (!this.h) {
this.h = true;
this.g.subscribe(this);
}
if (this.b.decrementAndGet() == 0) {
return;
}
}
}
}
@Override // io.reactivex.disposables.Disposable
public void dispose() {
DisposableHelper.dispose(this.f);
DisposableHelper.dispose(this.e);
}
@Override // io.reactivex.Observer
public void onComplete() {
DisposableHelper.dispose(this.e);
HalfSerializer.a(this.a, this, this.c);
}
@Override // io.reactivex.Observer
public void onError(Throwable th) {
this.h = false;
this.d.onNext(th);
}
@Override // io.reactivex.Observer
public void onNext(T t) {
HalfSerializer.a(this.a, t, this, this.c);
}
@Override // io.reactivex.Observer
public void onSubscribe(Disposable disposable) {
DisposableHelper.replace(this.f, disposable);
}
void a() {
DisposableHelper.dispose(this.f);
HalfSerializer.a(this.a, this, this.c);
}
}
}

143
sources/io/reactivex/internal/operators/observable/ObservableSampleTimed.java Normal file
View File

@@ -0,0 +1,143 @@
package io.reactivex.internal.operators.observable;
import io.reactivex.ObservableSource;
import io.reactivex.Observer;
import io.reactivex.Scheduler;
import io.reactivex.disposables.Disposable;
import io.reactivex.internal.disposables.DisposableHelper;
import io.reactivex.observers.SerializedObserver;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicReference;
/* loaded from: classes2.dex */
public final class ObservableSampleTimed<T> extends AbstractObservableWithUpstream<T, T> {
final long b;
final TimeUnit c;
final Scheduler d;
final boolean e;
static final class SampleTimedEmitLast<T> extends SampleTimedObserver<T> {
final AtomicInteger g;
SampleTimedEmitLast(Observer<? super T> observer, long j, TimeUnit timeUnit, Scheduler scheduler) {
super(observer, j, timeUnit, scheduler);
this.g = new AtomicInteger(1);
}
@Override // io.reactivex.internal.operators.observable.ObservableSampleTimed.SampleTimedObserver
void b() {
c();
if (this.g.decrementAndGet() == 0) {
this.a.onComplete();
}
}
@Override // java.lang.Runnable
public void run() {
if (this.g.incrementAndGet() == 2) {
c();
if (this.g.decrementAndGet() == 0) {
this.a.onComplete();
}
}
}
}
static final class SampleTimedNoLast<T> extends SampleTimedObserver<T> {
SampleTimedNoLast(Observer<? super T> observer, long j, TimeUnit timeUnit, Scheduler scheduler) {
super(observer, j, timeUnit, scheduler);
}
@Override // io.reactivex.internal.operators.observable.ObservableSampleTimed.SampleTimedObserver
void b() {
this.a.onComplete();
}
@Override // java.lang.Runnable
public void run() {
c();
}
}
static abstract class SampleTimedObserver<T> extends AtomicReference<T> implements Observer<T>, Disposable, Runnable {
final Observer<? super T> a;
final long b;
final TimeUnit c;
final Scheduler d;
final AtomicReference<Disposable> e = new AtomicReference<>();
Disposable f;
SampleTimedObserver(Observer<? super T> observer, long j, TimeUnit timeUnit, Scheduler scheduler) {
this.a = observer;
this.b = j;
this.c = timeUnit;
this.d = scheduler;
}
void a() {
DisposableHelper.dispose(this.e);
}
abstract void b();
void c() {
T andSet = getAndSet(null);
if (andSet != null) {
this.a.onNext(andSet);
}
}
@Override // io.reactivex.disposables.Disposable
public void dispose() {
a();
this.f.dispose();
}
@Override // io.reactivex.Observer
public void onComplete() {
a();
b();
}
@Override // io.reactivex.Observer
public void onError(Throwable th) {
a();
this.a.onError(th);
}
@Override // io.reactivex.Observer
public void onNext(T t) {
lazySet(t);
}
@Override // io.reactivex.Observer
public void onSubscribe(Disposable disposable) {
if (DisposableHelper.validate(this.f, disposable)) {
this.f = disposable;
this.a.onSubscribe(this);
Scheduler scheduler = this.d;
long j = this.b;
DisposableHelper.replace(this.e, scheduler.a(this, j, j, this.c));
}
}
}
public ObservableSampleTimed(ObservableSource<T> observableSource, long j, TimeUnit timeUnit, Scheduler scheduler, boolean z) {
super(observableSource);
this.b = j;
this.c = timeUnit;
this.d = scheduler;
this.e = z;
}
@Override // io.reactivex.Observable
public void subscribeActual(Observer<? super T> observer) {
SerializedObserver serializedObserver = new SerializedObserver(observer);
if (this.e) {
this.a.subscribe(new SampleTimedEmitLast(serializedObserver, this.b, this.c, this.d));
} else {
this.a.subscribe(new SampleTimedNoLast(serializedObserver, this.b, this.c, this.d));
}
}
}

195
sources/io/reactivex/internal/operators/observable/ObservableSampleWithObservable.java Normal file
View File

@@ -0,0 +1,195 @@
package io.reactivex.internal.operators.observable;
import io.reactivex.ObservableSource;
import io.reactivex.Observer;
import io.reactivex.disposables.Disposable;
import io.reactivex.internal.disposables.DisposableHelper;
import io.reactivex.observers.SerializedObserver;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicReference;
/* loaded from: classes2.dex */
public final class ObservableSampleWithObservable<T> extends AbstractObservableWithUpstream<T, T> {
final ObservableSource<?> b;
final boolean c;
static final class SampleMainEmitLast<T> extends SampleMainObserver<T> {
final AtomicInteger e;
volatile boolean f;
SampleMainEmitLast(Observer<? super T> observer, ObservableSource<?> observableSource) {
super(observer, observableSource);
this.e = new AtomicInteger();
}
@Override // io.reactivex.internal.operators.observable.ObservableSampleWithObservable.SampleMainObserver
void b() {
this.f = true;
if (this.e.getAndIncrement() == 0) {
d();
this.a.onComplete();
}
}
@Override // io.reactivex.internal.operators.observable.ObservableSampleWithObservable.SampleMainObserver
void c() {
this.f = true;
if (this.e.getAndIncrement() == 0) {
d();
this.a.onComplete();
}
}
@Override // io.reactivex.internal.operators.observable.ObservableSampleWithObservable.SampleMainObserver
void e() {
if (this.e.getAndIncrement() == 0) {
do {
boolean z = this.f;
d();
if (z) {
this.a.onComplete();
return;
}
} while (this.e.decrementAndGet() != 0);
}
}
}
static final class SampleMainNoLast<T> extends SampleMainObserver<T> {
SampleMainNoLast(Observer<? super T> observer, ObservableSource<?> observableSource) {
super(observer, observableSource);
}
@Override // io.reactivex.internal.operators.observable.ObservableSampleWithObservable.SampleMainObserver
void b() {
this.a.onComplete();
}
@Override // io.reactivex.internal.operators.observable.ObservableSampleWithObservable.SampleMainObserver
void c() {
this.a.onComplete();
}
@Override // io.reactivex.internal.operators.observable.ObservableSampleWithObservable.SampleMainObserver
void e() {
d();
}
}
static abstract class SampleMainObserver<T> extends AtomicReference<T> implements Observer<T>, Disposable {
final Observer<? super T> a;
final ObservableSource<?> b;
final AtomicReference<Disposable> c = new AtomicReference<>();
Disposable d;
SampleMainObserver(Observer<? super T> observer, ObservableSource<?> observableSource) {
this.a = observer;
this.b = observableSource;
}
boolean a(Disposable disposable) {
return DisposableHelper.setOnce(this.c, disposable);
}
abstract void b();
abstract void c();
void d() {
T andSet = getAndSet(null);
if (andSet != null) {
this.a.onNext(andSet);
}
}
@Override // io.reactivex.disposables.Disposable
public void dispose() {
DisposableHelper.dispose(this.c);
this.d.dispose();
}
abstract void e();
@Override // io.reactivex.Observer
public void onComplete() {
DisposableHelper.dispose(this.c);
b();
}
@Override // io.reactivex.Observer
public void onError(Throwable th) {
DisposableHelper.dispose(this.c);
this.a.onError(th);
}
@Override // io.reactivex.Observer
public void onNext(T t) {
lazySet(t);
}
@Override // io.reactivex.Observer
public void onSubscribe(Disposable disposable) {
if (DisposableHelper.validate(this.d, disposable)) {
this.d = disposable;
this.a.onSubscribe(this);
if (this.c.get() == null) {
this.b.subscribe(new SamplerObserver(this));
}
}
}
public void a(Throwable th) {
this.d.dispose();
this.a.onError(th);
}
public void a() {
this.d.dispose();
c();
}
}
static final class SamplerObserver<T> implements Observer<Object> {
final SampleMainObserver<T> a;
SamplerObserver(SampleMainObserver<T> sampleMainObserver) {
this.a = sampleMainObserver;
}
@Override // io.reactivex.Observer
public void onComplete() {
this.a.a();
}
@Override // io.reactivex.Observer
public void onError(Throwable th) {
this.a.a(th);
}
@Override // io.reactivex.Observer
public void onNext(Object obj) {
this.a.e();
}
@Override // io.reactivex.Observer
public void onSubscribe(Disposable disposable) {
this.a.a(disposable);
}
}
public ObservableSampleWithObservable(ObservableSource<T> observableSource, ObservableSource<?> observableSource2, boolean z) {
super(observableSource);
this.b = observableSource2;
this.c = z;
}
@Override // io.reactivex.Observable
public void subscribeActual(Observer<? super T> observer) {
SerializedObserver serializedObserver = new SerializedObserver(observer);
if (this.c) {
this.a.subscribe(new SampleMainEmitLast(serializedObserver, this.b));
} else {
this.a.subscribe(new SampleMainNoLast(serializedObserver, this.b));
}
}
}

Some files were not shown because too many files have changed in this diff Show More