Initial commit

sources/io/reactivex/internal/disposables/ArrayCompositeDisposable.java

@@ -0,0 +1,60 @@
+package io.reactivex.internal.disposables;
+
+import io.reactivex.disposables.Disposable;
+import java.util.concurrent.atomic.AtomicReferenceArray;
+
+/* loaded from: classes2.dex */
+public final class ArrayCompositeDisposable extends AtomicReferenceArray<Disposable> implements Disposable {
+    private static final long serialVersionUID = 2746389416410565408L;
+
+    public ArrayCompositeDisposable(int i) {
+        super(i);
+    }
+
+    @Override // io.reactivex.disposables.Disposable
+    public void dispose() {
+        Disposable andSet;
+        if (get(0) != DisposableHelper.DISPOSED) {
+            int length = length();
+            for (int i = 0; i < length; i++) {
+                Disposable disposable = get(i);
+                DisposableHelper disposableHelper = DisposableHelper.DISPOSED;
+                if (disposable != disposableHelper && (andSet = getAndSet(i, disposableHelper)) != DisposableHelper.DISPOSED && andSet != null) {
+                    andSet.dispose();
+                }
+            }
+        }
+    }
+
+    public boolean isDisposed() {
+        return get(0) == DisposableHelper.DISPOSED;
+    }
+
+    public Disposable replaceResource(int i, Disposable disposable) {
+        Disposable disposable2;
+        do {
+            disposable2 = get(i);
+            if (disposable2 == DisposableHelper.DISPOSED) {
+                disposable.dispose();
+                return null;
+            }
+        } while (!compareAndSet(i, disposable2, disposable));
+        return disposable2;
+    }
+
+    public boolean setResource(int i, Disposable disposable) {
+        Disposable disposable2;
+        do {
+            disposable2 = get(i);
+            if (disposable2 == DisposableHelper.DISPOSED) {
+                disposable.dispose();
+                return false;
+            }
+        } while (!compareAndSet(i, disposable2, disposable));
+        if (disposable2 == null) {
+            return true;
+        }
+        disposable2.dispose();
+        return true;
+    }
+}

sources/io/reactivex/internal/disposables/CancellableDisposable.java

@@ -0,0 +1,34 @@
+package io.reactivex.internal.disposables;
+
+import io.reactivex.disposables.Disposable;
+import io.reactivex.exceptions.Exceptions;
+import io.reactivex.functions.Cancellable;
+import io.reactivex.plugins.RxJavaPlugins;
+import java.util.concurrent.atomic.AtomicReference;
+
+/* loaded from: classes2.dex */
+public final class CancellableDisposable extends AtomicReference<Cancellable> implements Disposable {
+    private static final long serialVersionUID = 5718521705281392066L;
+
+    public CancellableDisposable(Cancellable cancellable) {
+        super(cancellable);
+    }
+
+    @Override // io.reactivex.disposables.Disposable
+    public void dispose() {
+        Cancellable andSet;
+        if (get() == null || (andSet = getAndSet(null)) == null) {
+            return;
+        }
+        try {
+            andSet.cancel();
+        } catch (Exception e) {
+            Exceptions.b(e);
+            RxJavaPlugins.b(e);
+        }
+    }
+
+    public boolean isDisposed() {
+        return get() == null;
+    }
+}

sources/io/reactivex/internal/disposables/DisposableContainer.java

@@ -0,0 +1,12 @@
+package io.reactivex.internal.disposables;
+
+import io.reactivex.disposables.Disposable;
+
+/* loaded from: classes2.dex */
+public interface DisposableContainer {
+    boolean a(Disposable disposable);
+
+    boolean b(Disposable disposable);
+
+    boolean c(Disposable disposable);
+}

sources/io/reactivex/internal/disposables/DisposableHelper.java

@@ -0,0 +1,113 @@
+package io.reactivex.internal.disposables;
+
+import io.reactivex.disposables.Disposable;
+import io.reactivex.exceptions.ProtocolViolationException;
+import io.reactivex.internal.functions.ObjectHelper;
+import io.reactivex.plugins.RxJavaPlugins;
+import java.util.concurrent.atomic.AtomicReference;
+
+/* loaded from: classes2.dex */
+public enum DisposableHelper implements Disposable {
+    DISPOSED;
+
+    public static boolean dispose(AtomicReference<Disposable> atomicReference) {
+        Disposable andSet;
+        Disposable disposable = atomicReference.get();
+        DisposableHelper disposableHelper = DISPOSED;
+        if (disposable == disposableHelper || (andSet = atomicReference.getAndSet(disposableHelper)) == disposableHelper) {
+            return false;
+        }
+        if (andSet == null) {
+            return true;
+        }
+        andSet.dispose();
+        return true;
+    }
+
+    public static boolean isDisposed(Disposable disposable) {
+        return disposable == DISPOSED;
+    }
+
+    public static boolean replace(AtomicReference<Disposable> atomicReference, Disposable disposable) {
+        Disposable disposable2;
+        do {
+            disposable2 = atomicReference.get();
+            if (disposable2 == DISPOSED) {
+                if (disposable == null) {
+                    return false;
+                }
+                disposable.dispose();
+                return false;
+            }
+        } while (!atomicReference.compareAndSet(disposable2, disposable));
+        return true;
+    }
+
+    public static void reportDisposableSet() {
+        RxJavaPlugins.b(new ProtocolViolationException("Disposable already set!"));
+    }
+
+    public static boolean set(AtomicReference<Disposable> atomicReference, Disposable disposable) {
+        Disposable disposable2;
+        do {
+            disposable2 = atomicReference.get();
+            if (disposable2 == DISPOSED) {
+                if (disposable == null) {
+                    return false;
+                }
+                disposable.dispose();
+                return false;
+            }
+        } while (!atomicReference.compareAndSet(disposable2, disposable));
+        if (disposable2 == null) {
+            return true;
+        }
+        disposable2.dispose();
+        return true;
+    }
+
+    public static boolean setOnce(AtomicReference<Disposable> atomicReference, Disposable disposable) {
+        ObjectHelper.a(disposable, "d is null");
+        if (atomicReference.compareAndSet(null, disposable)) {
+            return true;
+        }
+        disposable.dispose();
+        if (atomicReference.get() == DISPOSED) {
+            return false;
+        }
+        reportDisposableSet();
+        return false;
+    }
+
+    public static boolean trySet(AtomicReference<Disposable> atomicReference, Disposable disposable) {
+        if (atomicReference.compareAndSet(null, disposable)) {
+            return true;
+        }
+        if (atomicReference.get() != DISPOSED) {
+            return false;
+        }
+        disposable.dispose();
+        return false;
+    }
+
+    public static boolean validate(Disposable disposable, Disposable disposable2) {
+        if (disposable2 == null) {
+            RxJavaPlugins.b(new NullPointerException("next is null"));
+            return false;
+        }
+        if (disposable == null) {
+            return true;
+        }
+        disposable2.dispose();
+        reportDisposableSet();
+        return false;
+    }
+
+    @Override // io.reactivex.disposables.Disposable
+    public void dispose() {
+    }
+
+    public boolean isDisposed() {
+        return true;
+    }
+}

sources/io/reactivex/internal/disposables/EmptyDisposable.java

@@ -0,0 +1,84 @@
+package io.reactivex.internal.disposables;
+
+import io.reactivex.CompletableObserver;
+import io.reactivex.MaybeObserver;
+import io.reactivex.Observer;
+import io.reactivex.SingleObserver;
+import io.reactivex.internal.fuseable.QueueDisposable;
+
+/* loaded from: classes2.dex */
+public enum EmptyDisposable implements QueueDisposable<Object> {
+    INSTANCE,
+    NEVER;
+
+    public static void complete(Observer<?> observer) {
+        observer.onSubscribe(INSTANCE);
+        observer.onComplete();
+    }
+
+    public static void error(Throwable th, Observer<?> observer) {
+        observer.onSubscribe(INSTANCE);
+        observer.onError(th);
+    }
+
+    @Override // io.reactivex.internal.fuseable.SimpleQueue
+    public void clear() {
+    }
+
+    @Override // io.reactivex.disposables.Disposable
+    public void dispose() {
+    }
+
+    public boolean isDisposed() {
+        return this == INSTANCE;
+    }
+
+    @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() throws Exception {
+        return null;
+    }
+
+    @Override // io.reactivex.internal.fuseable.QueueFuseable
+    public int requestFusion(int i) {
+        return i & 2;
+    }
+
+    public boolean offer(Object obj, Object obj2) {
+        throw new UnsupportedOperationException("Should not be called!");
+    }
+
+    public static void complete(MaybeObserver<?> maybeObserver) {
+        maybeObserver.onSubscribe(INSTANCE);
+        maybeObserver.onComplete();
+    }
+
+    public static void error(Throwable th, CompletableObserver completableObserver) {
+        completableObserver.onSubscribe(INSTANCE);
+        completableObserver.onError(th);
+    }
+
+    public static void complete(CompletableObserver completableObserver) {
+        completableObserver.onSubscribe(INSTANCE);
+        completableObserver.onComplete();
+    }
+
+    public static void error(Throwable th, SingleObserver<?> singleObserver) {
+        singleObserver.onSubscribe(INSTANCE);
+        singleObserver.onError(th);
+    }
+
+    public static void error(Throwable th, MaybeObserver<?> maybeObserver) {
+        maybeObserver.onSubscribe(INSTANCE);
+        maybeObserver.onError(th);
+    }
+}

sources/io/reactivex/internal/disposables/ListCompositeDisposable.java

@@ -0,0 +1,105 @@
+package io.reactivex.internal.disposables;
+
+import io.reactivex.disposables.Disposable;
+import io.reactivex.exceptions.CompositeException;
+import io.reactivex.exceptions.Exceptions;
+import io.reactivex.internal.functions.ObjectHelper;
+import io.reactivex.internal.util.ExceptionHelper;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+
+/* loaded from: classes2.dex */
+public final class ListCompositeDisposable implements Disposable, DisposableContainer {
+    List<Disposable> a;
+    volatile boolean b;
+
+    @Override // io.reactivex.internal.disposables.DisposableContainer
+    public boolean a(Disposable disposable) {
+        if (!c(disposable)) {
+            return false;
+        }
+        disposable.dispose();
+        return true;
+    }
+
+    @Override // io.reactivex.internal.disposables.DisposableContainer
+    public boolean b(Disposable disposable) {
+        ObjectHelper.a(disposable, "d is null");
+        if (!this.b) {
+            synchronized (this) {
+                if (!this.b) {
+                    List list = this.a;
+                    if (list == null) {
+                        list = new LinkedList();
+                        this.a = list;
+                    }
+                    list.add(disposable);
+                    return true;
+                }
+            }
+        }
+        disposable.dispose();
+        return false;
+    }
+
+    @Override // io.reactivex.internal.disposables.DisposableContainer
+    public boolean c(Disposable disposable) {
+        ObjectHelper.a(disposable, "Disposable item is null");
+        if (this.b) {
+            return false;
+        }
+        synchronized (this) {
+            if (this.b) {
+                return false;
+            }
+            List<Disposable> list = this.a;
+            if (list != null && list.remove(disposable)) {
+                return true;
+            }
+            return false;
+        }
+    }
+
+    @Override // io.reactivex.disposables.Disposable
+    public void dispose() {
+        if (this.b) {
+            return;
+        }
+        synchronized (this) {
+            if (this.b) {
+                return;
+            }
+            this.b = true;
+            List<Disposable> list = this.a;
+            this.a = null;
+            a(list);
+        }
+    }
+
+    void a(List<Disposable> list) {
+        if (list == null) {
+            return;
+        }
+        ArrayList arrayList = null;
+        Iterator<Disposable> it = list.iterator();
+        while (it.hasNext()) {
+            try {
+                it.next().dispose();
+            } catch (Throwable th) {
+                Exceptions.b(th);
+                if (arrayList == null) {
+                    arrayList = new ArrayList();
+                }
+                arrayList.add(th);
+            }
+        }
+        if (arrayList != null) {
+            if (arrayList.size() == 1) {
+                throw ExceptionHelper.a((Throwable) arrayList.get(0));
+            }
+            throw new CompositeException(arrayList);
+        }
+    }
+}

sources/io/reactivex/internal/disposables/ResettableConnectable.java

@@ -0,0 +1,8 @@
+package io.reactivex.internal.disposables;
+
+import io.reactivex.disposables.Disposable;
+
+/* loaded from: classes2.dex */
+public interface ResettableConnectable {
+    void a(Disposable disposable);
+}

sources/io/reactivex/internal/disposables/SequentialDisposable.java

@@ -0,0 +1,33 @@
+package io.reactivex.internal.disposables;
+
+import io.reactivex.disposables.Disposable;
+import java.util.concurrent.atomic.AtomicReference;
+
+/* loaded from: classes2.dex */
+public final class SequentialDisposable extends AtomicReference<Disposable> implements Disposable {
+    private static final long serialVersionUID = -754898800686245608L;
+
+    public SequentialDisposable() {
+    }
+
+    @Override // io.reactivex.disposables.Disposable
+    public void dispose() {
+        DisposableHelper.dispose(this);
+    }
+
+    public boolean isDisposed() {
+        return DisposableHelper.isDisposed(get());
+    }
+
+    public boolean replace(Disposable disposable) {
+        return DisposableHelper.replace(this, disposable);
+    }
+
+    public boolean update(Disposable disposable) {
+        return DisposableHelper.set(this, disposable);
+    }
+
+    public SequentialDisposable(Disposable disposable) {
+        lazySet(disposable);
+    }
+}