Initial commit

sources/io/reactivex/internal/operators/maybe/MaybeCallbackObserver.java

@@ -0,0 +1,78 @@
+package io.reactivex.internal.operators.maybe;
+
+import io.reactivex.MaybeObserver;
+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.internal.functions.Functions;
+import io.reactivex.observers.LambdaConsumerIntrospection;
+import io.reactivex.plugins.RxJavaPlugins;
+import java.util.concurrent.atomic.AtomicReference;
+
+/* loaded from: classes2.dex */
+public final class MaybeCallbackObserver<T> extends AtomicReference<Disposable> implements MaybeObserver<T>, Disposable, LambdaConsumerIntrospection {
+    private static final long serialVersionUID = -6076952298809384986L;
+    final Action onComplete;
+    final Consumer<? super Throwable> onError;
+    final Consumer<? super T> onSuccess;
+
+    public MaybeCallbackObserver(Consumer<? super T> consumer, Consumer<? super Throwable> consumer2, Action action) {
+        this.onSuccess = consumer;
+        this.onError = consumer2;
+        this.onComplete = action;
+    }
+
+    @Override // io.reactivex.disposables.Disposable
+    public void dispose() {
+        DisposableHelper.dispose(this);
+    }
+
+    public boolean hasCustomOnError() {
+        return this.onError != Functions.e;
+    }
+
+    public boolean isDisposed() {
+        return DisposableHelper.isDisposed(get());
+    }
+
+    @Override // io.reactivex.MaybeObserver
+    public void onComplete() {
+        lazySet(DisposableHelper.DISPOSED);
+        try {
+            this.onComplete.run();
+        } catch (Throwable th) {
+            Exceptions.b(th);
+            RxJavaPlugins.b(th);
+        }
+    }
+
+    @Override // io.reactivex.MaybeObserver
+    public void onError(Throwable th) {
+        lazySet(DisposableHelper.DISPOSED);
+        try {
+            this.onError.accept(th);
+        } catch (Throwable th2) {
+            Exceptions.b(th2);
+            RxJavaPlugins.b(new CompositeException(th, th2));
+        }
+    }
+
+    @Override // io.reactivex.MaybeObserver
+    public void onSubscribe(Disposable disposable) {
+        DisposableHelper.setOnce(this, disposable);
+    }
+
+    @Override // io.reactivex.MaybeObserver
+    public void onSuccess(T t) {
+        lazySet(DisposableHelper.DISPOSED);
+        try {
+            this.onSuccess.accept(t);
+        } catch (Throwable th) {
+            Exceptions.b(th);
+            RxJavaPlugins.b(th);
+        }
+    }
+}

sources/io/reactivex/internal/operators/maybe/MaybeToFlowable.java

@@ -0,0 +1,61 @@
+package io.reactivex.internal.operators.maybe;
+
+import io.reactivex.Flowable;
+import io.reactivex.MaybeObserver;
+import io.reactivex.MaybeSource;
+import io.reactivex.disposables.Disposable;
+import io.reactivex.internal.disposables.DisposableHelper;
+import io.reactivex.internal.fuseable.HasUpstreamMaybeSource;
+import io.reactivex.internal.subscriptions.DeferredScalarSubscription;
+import org.reactivestreams.Subscriber;
+
+/* loaded from: classes2.dex */
+public final class MaybeToFlowable<T> extends Flowable<T> implements HasUpstreamMaybeSource<T> {
+    final MaybeSource<T> b;
+
+    static final class MaybeToFlowableSubscriber<T> extends DeferredScalarSubscription<T> implements MaybeObserver<T> {
+        Disposable a;
+
+        MaybeToFlowableSubscriber(Subscriber<? super T> subscriber) {
+            super(subscriber);
+        }
+
+        @Override // io.reactivex.internal.subscriptions.DeferredScalarSubscription, org.reactivestreams.Subscription
+        public void cancel() {
+            super.cancel();
+            this.a.dispose();
+        }
+
+        @Override // io.reactivex.MaybeObserver
+        public void onComplete() {
+            this.downstream.onComplete();
+        }
+
+        @Override // io.reactivex.MaybeObserver
+        public void onError(Throwable th) {
+            this.downstream.onError(th);
+        }
+
+        @Override // io.reactivex.MaybeObserver
+        public void onSubscribe(Disposable disposable) {
+            if (DisposableHelper.validate(this.a, disposable)) {
+                this.a = disposable;
+                this.downstream.onSubscribe(this);
+            }
+        }
+
+        @Override // io.reactivex.MaybeObserver
+        public void onSuccess(T t) {
+            complete(t);
+        }
+    }
+
+    public MaybeToFlowable(MaybeSource<T> maybeSource) {
+        this.b = maybeSource;
+    }
+
+    @Override // io.reactivex.Flowable
+    protected void b(Subscriber<? super T> subscriber) {
+        this.b.a(new MaybeToFlowableSubscriber(subscriber));
+    }
+}

sources/io/reactivex/internal/operators/maybe/MaybeToObservable.java

@@ -0,0 +1,54 @@
+package io.reactivex.internal.operators.maybe;
+
+import io.reactivex.MaybeObserver;
+import io.reactivex.Observable;
+import io.reactivex.Observer;
+import io.reactivex.disposables.Disposable;
+import io.reactivex.internal.disposables.DisposableHelper;
+import io.reactivex.internal.fuseable.HasUpstreamMaybeSource;
+import io.reactivex.internal.observers.DeferredScalarDisposable;
+
+/* loaded from: classes2.dex */
+public final class MaybeToObservable<T> extends Observable<T> implements HasUpstreamMaybeSource<T> {
+
+    static final class MaybeToObservableObserver<T> extends DeferredScalarDisposable<T> implements MaybeObserver<T> {
+        Disposable a;
+
+        MaybeToObservableObserver(Observer<? super T> observer) {
+            super(observer);
+        }
+
+        @Override // io.reactivex.internal.observers.DeferredScalarDisposable, io.reactivex.disposables.Disposable
+        public void dispose() {
+            super.dispose();
+            this.a.dispose();
+        }
+
+        @Override // io.reactivex.MaybeObserver
+        public void onComplete() {
+            complete();
+        }
+
+        @Override // io.reactivex.MaybeObserver
+        public void onError(Throwable th) {
+            error(th);
+        }
+
+        @Override // io.reactivex.MaybeObserver
+        public void onSubscribe(Disposable disposable) {
+            if (DisposableHelper.validate(this.a, disposable)) {
+                this.a = disposable;
+                this.downstream.onSubscribe(this);
+            }
+        }
+
+        @Override // io.reactivex.MaybeObserver
+        public void onSuccess(T t) {
+            complete(t);
+        }
+    }
+
+    public static <T> MaybeObserver<T> a(Observer<? super T> observer) {
+        return new MaybeToObservableObserver(observer);
+    }
+}

sources/io/reactivex/internal/operators/maybe/MaybeToPublisher.java

@@ -0,0 +1,19 @@
+package io.reactivex.internal.operators.maybe;
+
+import io.reactivex.MaybeSource;
+import io.reactivex.functions.Function;
+import org.reactivestreams.Publisher;
+
+/* loaded from: classes2.dex */
+public enum MaybeToPublisher implements Function<MaybeSource<Object>, Publisher<Object>> {
+    INSTANCE;
+
+    public static <T> Function<MaybeSource<T>, Publisher<T>> instance() {
+        return INSTANCE;
+    }
+
+    @Override // io.reactivex.functions.Function
+    public Publisher<Object> apply(MaybeSource<Object> maybeSource) throws Exception {
+        return new MaybeToFlowable(maybeSource);
+    }
+}