Initial commit

sources/io/reactivex/internal/operators/observable/ObservableMergeWithCompletable.java

@@ -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);
+            }
+        }
+    }
+}