Initial commit

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

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