Initial commit

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

@@ -0,0 +1,77 @@
+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;
+
+/* loaded from: classes2.dex */
+public final class ObservableSkipWhile<T> extends AbstractObservableWithUpstream<T, T> {
+    final Predicate<? super T> b;
+
+    static final class SkipWhileObserver<T> implements Observer<T>, Disposable {
+        final Observer<? super T> a;
+        final Predicate<? super T> b;
+        Disposable c;
+        boolean d;
+
+        SkipWhileObserver(Observer<? super T> 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() {
+            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) {
+            if (this.d) {
+                this.a.onNext(t);
+                return;
+            }
+            try {
+                if (this.b.a(t)) {
+                    return;
+                }
+                this.d = true;
+                this.a.onNext(t);
+            } catch (Throwable th) {
+                Exceptions.b(th);
+                this.c.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 ObservableSkipWhile(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 SkipWhileObserver(observer, this.b));
+    }
+}