Initial commit

sources/io/reactivex/internal/subscriptions/ArrayCompositeSubscription.java

@@ -0,0 +1,67 @@
+package io.reactivex.internal.subscriptions;
+
+import io.reactivex.disposables.Disposable;
+import java.util.concurrent.atomic.AtomicReferenceArray;
+import org.reactivestreams.Subscription;
+
+/* loaded from: classes2.dex */
+public final class ArrayCompositeSubscription extends AtomicReferenceArray<Subscription> implements Disposable {
+    private static final long serialVersionUID = 2746389416410565408L;
+
+    public ArrayCompositeSubscription(int i) {
+        super(i);
+    }
+
+    @Override // io.reactivex.disposables.Disposable
+    public void dispose() {
+        Subscription andSet;
+        if (get(0) != SubscriptionHelper.CANCELLED) {
+            int length = length();
+            for (int i = 0; i < length; i++) {
+                Subscription subscription = get(i);
+                SubscriptionHelper subscriptionHelper = SubscriptionHelper.CANCELLED;
+                if (subscription != subscriptionHelper && (andSet = getAndSet(i, subscriptionHelper)) != SubscriptionHelper.CANCELLED && andSet != null) {
+                    andSet.cancel();
+                }
+            }
+        }
+    }
+
+    public boolean isDisposed() {
+        return get(0) == SubscriptionHelper.CANCELLED;
+    }
+
+    public Subscription replaceResource(int i, Subscription subscription) {
+        Subscription subscription2;
+        do {
+            subscription2 = get(i);
+            if (subscription2 == SubscriptionHelper.CANCELLED) {
+                if (subscription == null) {
+                    return null;
+                }
+                subscription.cancel();
+                return null;
+            }
+        } while (!compareAndSet(i, subscription2, subscription));
+        return subscription2;
+    }
+
+    public boolean setResource(int i, Subscription subscription) {
+        Subscription subscription2;
+        do {
+            subscription2 = get(i);
+            if (subscription2 == SubscriptionHelper.CANCELLED) {
+                if (subscription == null) {
+                    return false;
+                }
+                subscription.cancel();
+                return false;
+            }
+        } while (!compareAndSet(i, subscription2, subscription));
+        if (subscription2 == null) {
+            return true;
+        }
+        subscription2.cancel();
+        return true;
+    }
+}

sources/io/reactivex/internal/subscriptions/AsyncSubscription.java

@@ -0,0 +1,56 @@
+package io.reactivex.internal.subscriptions;
+
+import io.reactivex.disposables.Disposable;
+import io.reactivex.internal.disposables.DisposableHelper;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.concurrent.atomic.AtomicReference;
+import org.reactivestreams.Subscription;
+
+/* loaded from: classes2.dex */
+public final class AsyncSubscription extends AtomicLong implements Subscription, Disposable {
+    private static final long serialVersionUID = 7028635084060361255L;
+    final AtomicReference<Subscription> actual;
+    final AtomicReference<Disposable> resource;
+
+    public AsyncSubscription() {
+        this.resource = new AtomicReference<>();
+        this.actual = new AtomicReference<>();
+    }
+
+    @Override // org.reactivestreams.Subscription
+    public void cancel() {
+        dispose();
+    }
+
+    @Override // io.reactivex.disposables.Disposable
+    public void dispose() {
+        SubscriptionHelper.cancel(this.actual);
+        DisposableHelper.dispose(this.resource);
+    }
+
+    public boolean isDisposed() {
+        return this.actual.get() == SubscriptionHelper.CANCELLED;
+    }
+
+    public boolean replaceResource(Disposable disposable) {
+        return DisposableHelper.replace(this.resource, disposable);
+    }
+
+    @Override // org.reactivestreams.Subscription
+    public void request(long j) {
+        SubscriptionHelper.deferredRequest(this.actual, this, j);
+    }
+
+    public boolean setResource(Disposable disposable) {
+        return DisposableHelper.set(this.resource, disposable);
+    }
+
+    public void setSubscription(Subscription subscription) {
+        SubscriptionHelper.deferredSetOnce(this.actual, this, subscription);
+    }
+
+    public AsyncSubscription(Disposable disposable) {
+        this();
+        this.resource.lazySet(disposable);
+    }
+}

sources/io/reactivex/internal/subscriptions/BasicIntQueueSubscription.java

@@ -0,0 +1,18 @@
+package io.reactivex.internal.subscriptions;
+
+import io.reactivex.internal.fuseable.QueueSubscription;
+import java.util.concurrent.atomic.AtomicInteger;
+
+/* loaded from: classes2.dex */
+public abstract class BasicIntQueueSubscription<T> extends AtomicInteger implements QueueSubscription<T> {
+    private static final long serialVersionUID = -6671519529404341862L;
+
+    @Override // io.reactivex.internal.fuseable.SimpleQueue
+    public final boolean offer(T t) {
+        throw new UnsupportedOperationException("Should not be called!");
+    }
+
+    public final boolean offer(T t, T t2) {
+        throw new UnsupportedOperationException("Should not be called!");
+    }
+}

sources/io/reactivex/internal/subscriptions/BasicQueueSubscription.java

@@ -0,0 +1,18 @@
+package io.reactivex.internal.subscriptions;
+
+import io.reactivex.internal.fuseable.QueueSubscription;
+import java.util.concurrent.atomic.AtomicLong;
+
+/* loaded from: classes2.dex */
+public abstract class BasicQueueSubscription<T> extends AtomicLong implements QueueSubscription<T> {
+    private static final long serialVersionUID = -6671519529404341862L;
+
+    @Override // io.reactivex.internal.fuseable.SimpleQueue
+    public final boolean offer(T t) {
+        throw new UnsupportedOperationException("Should not be called!");
+    }
+
+    public final boolean offer(T t, T t2) {
+        throw new UnsupportedOperationException("Should not be called!");
+    }
+}

sources/io/reactivex/internal/subscriptions/BooleanSubscription.java

@@ -0,0 +1,28 @@
+package io.reactivex.internal.subscriptions;
+
+import java.util.concurrent.atomic.AtomicBoolean;
+import org.reactivestreams.Subscription;
+
+/* loaded from: classes2.dex */
+public final class BooleanSubscription extends AtomicBoolean implements Subscription {
+    private static final long serialVersionUID = -8127758972444290902L;
+
+    @Override // org.reactivestreams.Subscription
+    public void cancel() {
+        lazySet(true);
+    }
+
+    public boolean isCancelled() {
+        return get();
+    }
+
+    @Override // org.reactivestreams.Subscription
+    public void request(long j) {
+        SubscriptionHelper.validate(j);
+    }
+
+    @Override // java.util.concurrent.atomic.AtomicBoolean
+    public String toString() {
+        return "BooleanSubscription(cancelled=" + get() + ")";
+    }
+}

sources/io/reactivex/internal/subscriptions/DeferredScalarSubscription.java

@@ -0,0 +1,127 @@
+package io.reactivex.internal.subscriptions;
+
+import org.reactivestreams.Subscriber;
+
+/* loaded from: classes2.dex */
+public class DeferredScalarSubscription<T> extends BasicIntQueueSubscription<T> {
+    static final int CANCELLED = 4;
+    static final int FUSED_CONSUMED = 32;
+    static final int FUSED_EMPTY = 8;
+    static final int FUSED_READY = 16;
+    static final int HAS_REQUEST_HAS_VALUE = 3;
+    static final int HAS_REQUEST_NO_VALUE = 2;
+    static final int NO_REQUEST_HAS_VALUE = 1;
+    static final int NO_REQUEST_NO_VALUE = 0;
+    private static final long serialVersionUID = -2151279923272604993L;
+    protected final Subscriber<? super T> downstream;
+    protected T value;
+
+    public DeferredScalarSubscription(Subscriber<? super T> subscriber) {
+        this.downstream = subscriber;
+    }
+
+    public void cancel() {
+        set(4);
+        this.value = null;
+    }
+
+    @Override // io.reactivex.internal.fuseable.SimpleQueue
+    public final void clear() {
+        lazySet(32);
+        this.value = null;
+    }
+
+    public final void complete(T t) {
+        int i = get();
+        while (i != 8) {
+            if ((i & (-3)) != 0) {
+                return;
+            }
+            if (i == 2) {
+                lazySet(3);
+                Subscriber<? super T> subscriber = this.downstream;
+                subscriber.onNext(t);
+                if (get() != 4) {
+                    subscriber.onComplete();
+                    return;
+                }
+                return;
+            }
+            this.value = t;
+            if (compareAndSet(0, 1)) {
+                return;
+            }
+            i = get();
+            if (i == 4) {
+                this.value = null;
+                return;
+            }
+        }
+        this.value = t;
+        lazySet(16);
+        Subscriber<? super T> subscriber2 = this.downstream;
+        subscriber2.onNext(t);
+        if (get() != 4) {
+            subscriber2.onComplete();
+        }
+    }
+
+    public final boolean isCancelled() {
+        return get() == 4;
+    }
+
+    @Override // io.reactivex.internal.fuseable.SimpleQueue
+    public final boolean isEmpty() {
+        return get() != 16;
+    }
+
+    @Override // io.reactivex.internal.fuseable.SimpleQueue
+    public final T poll() {
+        if (get() != 16) {
+            return null;
+        }
+        lazySet(32);
+        T t = this.value;
+        this.value = null;
+        return t;
+    }
+
+    @Override // org.reactivestreams.Subscription
+    public final void request(long j) {
+        T t;
+        if (SubscriptionHelper.validate(j)) {
+            do {
+                int i = get();
+                if ((i & (-2)) != 0) {
+                    return;
+                }
+                if (i == 1) {
+                    if (!compareAndSet(1, 3) || (t = this.value) == null) {
+                        return;
+                    }
+                    this.value = null;
+                    Subscriber<? super T> subscriber = this.downstream;
+                    subscriber.onNext(t);
+                    if (get() != 4) {
+                        subscriber.onComplete();
+                        return;
+                    }
+                    return;
+                }
+            } while (!compareAndSet(0, 2));
+        }
+    }
+
+    @Override // io.reactivex.internal.fuseable.QueueFuseable
+    public final int requestFusion(int i) {
+        if ((i & 2) == 0) {
+            return 0;
+        }
+        lazySet(8);
+        return 2;
+    }
+
+    public final boolean tryCancel() {
+        return getAndSet(4) != 4;
+    }
+}

sources/io/reactivex/internal/subscriptions/EmptySubscription.java

@@ -0,0 +1,61 @@
+package io.reactivex.internal.subscriptions;
+
+import io.reactivex.internal.fuseable.QueueSubscription;
+import org.reactivestreams.Subscriber;
+
+/* loaded from: classes2.dex */
+public enum EmptySubscription implements QueueSubscription<Object> {
+    INSTANCE;
+
+    public static void complete(Subscriber<?> subscriber) {
+        subscriber.onSubscribe(INSTANCE);
+        subscriber.onComplete();
+    }
+
+    public static void error(Throwable th, Subscriber<?> subscriber) {
+        subscriber.onSubscribe(INSTANCE);
+        subscriber.onError(th);
+    }
+
+    @Override // org.reactivestreams.Subscription
+    public void cancel() {
+    }
+
+    @Override // io.reactivex.internal.fuseable.SimpleQueue
+    public void clear() {
+    }
+
+    @Override // io.reactivex.internal.fuseable.SimpleQueue
+    public boolean isEmpty() {
+        return true;
+    }
+
+    @Override // io.reactivex.internal.fuseable.SimpleQueue
+    public boolean offer(Object obj) {
+        throw new UnsupportedOperationException("Should not be called!");
+    }
+
+    @Override // io.reactivex.internal.fuseable.SimpleQueue
+    public Object poll() {
+        return null;
+    }
+
+    @Override // org.reactivestreams.Subscription
+    public void request(long j) {
+        SubscriptionHelper.validate(j);
+    }
+
+    @Override // io.reactivex.internal.fuseable.QueueFuseable
+    public int requestFusion(int i) {
+        return i & 2;
+    }
+
+    @Override // java.lang.Enum
+    public String toString() {
+        return "EmptySubscription";
+    }
+
+    public boolean offer(Object obj, Object obj2) {
+        throw new UnsupportedOperationException("Should not be called!");
+    }
+}

sources/io/reactivex/internal/subscriptions/ScalarSubscription.java

@@ -0,0 +1,73 @@
+package io.reactivex.internal.subscriptions;
+
+import io.reactivex.internal.fuseable.QueueSubscription;
+import java.util.concurrent.atomic.AtomicInteger;
+import org.reactivestreams.Subscriber;
+
+/* loaded from: classes2.dex */
+public final class ScalarSubscription<T> extends AtomicInteger implements QueueSubscription<T> {
+    static final int CANCELLED = 2;
+    static final int NO_REQUEST = 0;
+    static final int REQUESTED = 1;
+    private static final long serialVersionUID = -3830916580126663321L;
+    final Subscriber<? super T> subscriber;
+    final T value;
+
+    public ScalarSubscription(Subscriber<? super T> subscriber, T t) {
+        this.subscriber = subscriber;
+        this.value = t;
+    }
+
+    @Override // org.reactivestreams.Subscription
+    public void cancel() {
+        lazySet(2);
+    }
+
+    @Override // io.reactivex.internal.fuseable.SimpleQueue
+    public void clear() {
+        lazySet(1);
+    }
+
+    public boolean isCancelled() {
+        return get() == 2;
+    }
+
+    @Override // io.reactivex.internal.fuseable.SimpleQueue
+    public boolean isEmpty() {
+        return get() != 0;
+    }
+
+    @Override // io.reactivex.internal.fuseable.SimpleQueue
+    public boolean offer(T t) {
+        throw new UnsupportedOperationException("Should not be called!");
+    }
+
+    @Override // io.reactivex.internal.fuseable.SimpleQueue
+    public T poll() {
+        if (get() != 0) {
+            return null;
+        }
+        lazySet(1);
+        return this.value;
+    }
+
+    @Override // org.reactivestreams.Subscription
+    public void request(long j) {
+        if (SubscriptionHelper.validate(j) && compareAndSet(0, 1)) {
+            Subscriber<? super T> subscriber = this.subscriber;
+            subscriber.onNext(this.value);
+            if (get() != 2) {
+                subscriber.onComplete();
+            }
+        }
+    }
+
+    @Override // io.reactivex.internal.fuseable.QueueFuseable
+    public int requestFusion(int i) {
+        return i & 1;
+    }
+
+    public boolean offer(T t, T t2) {
+        throw new UnsupportedOperationException("Should not be called!");
+    }
+}

sources/io/reactivex/internal/subscriptions/SubscriptionArbiter.java

@@ -0,0 +1,186 @@
+package io.reactivex.internal.subscriptions;
+
+import io.reactivex.internal.functions.ObjectHelper;
+import io.reactivex.internal.util.BackpressureHelper;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.concurrent.atomic.AtomicReference;
+import org.reactivestreams.Subscription;
+
+/* loaded from: classes2.dex */
+public class SubscriptionArbiter extends AtomicInteger implements Subscription {
+    private static final long serialVersionUID = -2189523197179400958L;
+    Subscription actual;
+    volatile boolean cancelled;
+    long requested;
+    protected boolean unbounded;
+    final AtomicReference<Subscription> missedSubscription = new AtomicReference<>();
+    final AtomicLong missedRequested = new AtomicLong();
+    final AtomicLong missedProduced = new AtomicLong();
+
+    @Override // org.reactivestreams.Subscription
+    public void cancel() {
+        if (this.cancelled) {
+            return;
+        }
+        this.cancelled = true;
+        drain();
+    }
+
+    final void drain() {
+        if (getAndIncrement() != 0) {
+            return;
+        }
+        drainLoop();
+    }
+
+    final void drainLoop() {
+        Subscription subscription = null;
+        long j = 0;
+        int i = 1;
+        do {
+            Subscription subscription2 = this.missedSubscription.get();
+            if (subscription2 != null) {
+                subscription2 = this.missedSubscription.getAndSet(null);
+            }
+            long j2 = this.missedRequested.get();
+            if (j2 != 0) {
+                j2 = this.missedRequested.getAndSet(0L);
+            }
+            long j3 = this.missedProduced.get();
+            if (j3 != 0) {
+                j3 = this.missedProduced.getAndSet(0L);
+            }
+            Subscription subscription3 = this.actual;
+            if (this.cancelled) {
+                if (subscription3 != null) {
+                    subscription3.cancel();
+                    this.actual = null;
+                }
+                if (subscription2 != null) {
+                    subscription2.cancel();
+                }
+            } else {
+                long j4 = this.requested;
+                if (j4 != Long.MAX_VALUE) {
+                    j4 = BackpressureHelper.a(j4, j2);
+                    if (j4 != Long.MAX_VALUE) {
+                        long j5 = j4 - j3;
+                        if (j5 < 0) {
+                            SubscriptionHelper.reportMoreProduced(j5);
+                            j5 = 0;
+                        }
+                        j4 = j5;
+                    }
+                    this.requested = j4;
+                }
+                if (subscription2 != null) {
+                    if (subscription3 != null) {
+                        subscription3.cancel();
+                    }
+                    this.actual = subscription2;
+                    if (j4 != 0) {
+                        j = BackpressureHelper.a(j, j4);
+                        subscription = subscription2;
+                    }
+                } else if (subscription3 != null && j2 != 0) {
+                    j = BackpressureHelper.a(j, j2);
+                    subscription = subscription3;
+                }
+            }
+            i = addAndGet(-i);
+        } while (i != 0);
+        if (j != 0) {
+            subscription.request(j);
+        }
+    }
+
+    public final boolean isCancelled() {
+        return this.cancelled;
+    }
+
+    public final boolean isUnbounded() {
+        return this.unbounded;
+    }
+
+    public final void produced(long j) {
+        if (this.unbounded) {
+            return;
+        }
+        if (get() != 0 || !compareAndSet(0, 1)) {
+            BackpressureHelper.a(this.missedProduced, j);
+            drain();
+            return;
+        }
+        long j2 = this.requested;
+        if (j2 != Long.MAX_VALUE) {
+            long j3 = j2 - j;
+            long j4 = 0;
+            if (j3 < 0) {
+                SubscriptionHelper.reportMoreProduced(j3);
+            } else {
+                j4 = j3;
+            }
+            this.requested = j4;
+        }
+        if (decrementAndGet() == 0) {
+            return;
+        }
+        drainLoop();
+    }
+
+    @Override // org.reactivestreams.Subscription
+    public final void request(long j) {
+        if (!SubscriptionHelper.validate(j) || this.unbounded) {
+            return;
+        }
+        if (get() != 0 || !compareAndSet(0, 1)) {
+            BackpressureHelper.a(this.missedRequested, j);
+            drain();
+            return;
+        }
+        long j2 = this.requested;
+        if (j2 != Long.MAX_VALUE) {
+            long a = BackpressureHelper.a(j2, j);
+            this.requested = a;
+            if (a == Long.MAX_VALUE) {
+                this.unbounded = true;
+            }
+        }
+        Subscription subscription = this.actual;
+        if (decrementAndGet() != 0) {
+            drainLoop();
+        }
+        if (subscription != null) {
+            subscription.request(j);
+        }
+    }
+
+    public final void setSubscription(Subscription subscription) {
+        if (this.cancelled) {
+            subscription.cancel();
+            return;
+        }
+        ObjectHelper.a(subscription, "s is null");
+        if (get() != 0 || !compareAndSet(0, 1)) {
+            Subscription andSet = this.missedSubscription.getAndSet(subscription);
+            if (andSet != null) {
+                andSet.cancel();
+            }
+            drain();
+            return;
+        }
+        Subscription subscription2 = this.actual;
+        if (subscription2 != null) {
+            subscription2.cancel();
+        }
+        this.actual = subscription;
+        long j = this.requested;
+        if (decrementAndGet() != 0) {
+            drainLoop();
+        }
+        if (j != 0) {
+            subscription.request(j);
+        }
+    }
+}

sources/io/reactivex/internal/subscriptions/SubscriptionHelper.java

@@ -0,0 +1,154 @@
+package io.reactivex.internal.subscriptions;
+
+import io.reactivex.exceptions.ProtocolViolationException;
+import io.reactivex.internal.functions.ObjectHelper;
+import io.reactivex.internal.util.BackpressureHelper;
+import io.reactivex.plugins.RxJavaPlugins;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.concurrent.atomic.AtomicReference;
+import org.reactivestreams.Subscription;
+
+/* loaded from: classes2.dex */
+public enum SubscriptionHelper implements Subscription {
+    CANCELLED;
+
+    public static boolean cancel(AtomicReference<Subscription> atomicReference) {
+        Subscription andSet;
+        Subscription subscription = atomicReference.get();
+        SubscriptionHelper subscriptionHelper = CANCELLED;
+        if (subscription == subscriptionHelper || (andSet = atomicReference.getAndSet(subscriptionHelper)) == CANCELLED) {
+            return false;
+        }
+        if (andSet == null) {
+            return true;
+        }
+        andSet.cancel();
+        return true;
+    }
+
+    public static void deferredRequest(AtomicReference<Subscription> atomicReference, AtomicLong atomicLong, long j) {
+        Subscription subscription = atomicReference.get();
+        if (subscription != null) {
+            subscription.request(j);
+            return;
+        }
+        if (validate(j)) {
+            BackpressureHelper.a(atomicLong, j);
+            Subscription subscription2 = atomicReference.get();
+            if (subscription2 != null) {
+                long andSet = atomicLong.getAndSet(0L);
+                if (andSet != 0) {
+                    subscription2.request(andSet);
+                }
+            }
+        }
+    }
+
+    public static boolean deferredSetOnce(AtomicReference<Subscription> atomicReference, AtomicLong atomicLong, Subscription subscription) {
+        if (!setOnce(atomicReference, subscription)) {
+            return false;
+        }
+        long andSet = atomicLong.getAndSet(0L);
+        if (andSet == 0) {
+            return true;
+        }
+        subscription.request(andSet);
+        return true;
+    }
+
+    public static boolean isCancelled(Subscription subscription) {
+        return subscription == CANCELLED;
+    }
+
+    public static boolean replace(AtomicReference<Subscription> atomicReference, Subscription subscription) {
+        Subscription subscription2;
+        do {
+            subscription2 = atomicReference.get();
+            if (subscription2 == CANCELLED) {
+                if (subscription == null) {
+                    return false;
+                }
+                subscription.cancel();
+                return false;
+            }
+        } while (!atomicReference.compareAndSet(subscription2, subscription));
+        return true;
+    }
+
+    public static void reportMoreProduced(long j) {
+        RxJavaPlugins.b(new ProtocolViolationException("More produced than requested: " + j));
+    }
+
+    public static void reportSubscriptionSet() {
+        RxJavaPlugins.b(new ProtocolViolationException("Subscription already set!"));
+    }
+
+    public static boolean set(AtomicReference<Subscription> atomicReference, Subscription subscription) {
+        Subscription subscription2;
+        do {
+            subscription2 = atomicReference.get();
+            if (subscription2 == CANCELLED) {
+                if (subscription == null) {
+                    return false;
+                }
+                subscription.cancel();
+                return false;
+            }
+        } while (!atomicReference.compareAndSet(subscription2, subscription));
+        if (subscription2 == null) {
+            return true;
+        }
+        subscription2.cancel();
+        return true;
+    }
+
+    public static boolean setOnce(AtomicReference<Subscription> atomicReference, Subscription subscription) {
+        ObjectHelper.a(subscription, "s is null");
+        if (atomicReference.compareAndSet(null, subscription)) {
+            return true;
+        }
+        subscription.cancel();
+        if (atomicReference.get() == CANCELLED) {
+            return false;
+        }
+        reportSubscriptionSet();
+        return false;
+    }
+
+    public static boolean validate(Subscription subscription, Subscription subscription2) {
+        if (subscription2 == null) {
+            RxJavaPlugins.b(new NullPointerException("next is null"));
+            return false;
+        }
+        if (subscription == null) {
+            return true;
+        }
+        subscription2.cancel();
+        reportSubscriptionSet();
+        return false;
+    }
+
+    @Override // org.reactivestreams.Subscription
+    public void cancel() {
+    }
+
+    @Override // org.reactivestreams.Subscription
+    public void request(long j) {
+    }
+
+    public static boolean validate(long j) {
+        if (j > 0) {
+            return true;
+        }
+        RxJavaPlugins.b(new IllegalArgumentException("n > 0 required but it was " + j));
+        return false;
+    }
+
+    public static boolean setOnce(AtomicReference<Subscription> atomicReference, Subscription subscription, long j) {
+        if (!setOnce(atomicReference, subscription)) {
+            return false;
+        }
+        subscription.request(j);
+        return true;
+    }
+}