Uses of Interface io.reactivex.rxjava3.disposables.Disposable

Packages that use Disposable
Package	Description
io.reactivex.rxjava3.core	Base reactive classes: `Flowable`, `Observable`, `Single`, `Maybe` and `Completable`; base reactive consumers; other common base interfaces.
io.reactivex.rxjava3.disposables	Default implementations for `Disposable`-based resource management (`Disposable` container types) and utility classes to construct `Disposables` from callbacks and other types.
io.reactivex.rxjava3.flowables	Classes supporting the Flowable base reactive class: `ConnectableFlowable` and `GroupedFlowable`.
io.reactivex.rxjava3.internal.disposables
io.reactivex.rxjava3.internal.fuseable	Base interfaces and types for supporting operator-fusion.
io.reactivex.rxjava3.internal.jdk8
io.reactivex.rxjava3.internal.observers
io.reactivex.rxjava3.internal.operators.completable
io.reactivex.rxjava3.internal.operators.flowable
io.reactivex.rxjava3.internal.operators.maybe
io.reactivex.rxjava3.internal.operators.mixed
io.reactivex.rxjava3.internal.operators.observable
io.reactivex.rxjava3.internal.operators.single
io.reactivex.rxjava3.internal.schedulers
io.reactivex.rxjava3.internal.subscribers
io.reactivex.rxjava3.internal.subscriptions
io.reactivex.rxjava3.internal.util
io.reactivex.rxjava3.observables	Classes supporting the Observable base reactive class: `ConnectableObservable` and `GroupedObservable`.
io.reactivex.rxjava3.observers	Default wrappers and implementations for observer-based consumer classes and interfaces, including disposable and resource-tracking variants and the `TestObserver` that allows unit testing `Observable`-, `Single`-, `Maybe`- and `Completable`-based flows.
io.reactivex.rxjava3.operators	Classes and interfaces for writing advanced operators within and outside RxJava.
io.reactivex.rxjava3.schedulers	Contains notably the factory class of `Schedulers` providing methods for retrieving the standard scheduler instances, the `TestScheduler` for testing flows with scheduling in a controlled manner and the class `Timed` that can hold a value and a timestamp associated with it.
io.reactivex.rxjava3.subjects	Classes representing so-called hot sources, aka subjects, that implement a base reactive class and the respective consumer type at once to allow forms of multicasting events to multiple consumers as well as consuming another base reactive type of their kind.
io.reactivex.rxjava3.subscribers	Default wrappers and implementations for `Subscriber`-based consumer classes and interfaces, including disposable (`DisposableSubscriber`) and resource-tracking (`ResourceSubscriber`) variants and the `TestSubscriber` that allows unit testing `Flowable`-based flows.

Uses of Disposable in io.reactivex.rxjava3.core

Classes in io.reactivex.rxjava3.core that implement Disposable
Modifier and Type	Class	Description
`(package private) static class`	`Scheduler.DisposeTask`
`(package private) static class`	`Scheduler.PeriodicDirectTask`
`static class`	`Scheduler.Worker`	Represents an isolated, sequential worker of a parent Scheduler for executing `Runnable` tasks on an underlying task-execution scheme (such as custom Threads, event loop, `Executor` or Actor system).

Methods in io.reactivex.rxjava3.core with type parameters of type Disposable
Modifier and Type	Method	Description
`<S extends Scheduler & Disposable> S`	Scheduler.`when(@NonNull Function<Flowable<Flowable<Completable>>,Completable> combine)`	Allows the use of operators for controlling the timing around when actions scheduled on workers are actually done.

Methods in io.reactivex.rxjava3.core that return Disposable
Modifier and Type	Method	Description
`@NonNull Disposable`	Flowable.`forEach(@NonNull Consumer<? super @NonNull T> onNext)`	Subscribes to the current `Flowable` and receives notifications for each element.
`@NonNull Disposable`	Observable.`forEach(@NonNull Consumer<? super @NonNull T> onNext)`	Subscribes to the `ObservableSource` and calls a `Consumer` for each item of the current `Observable` on its emission thread.
`@NonNull Disposable`	Flowable.`forEachWhile(@NonNull Predicate<? super @NonNull T> onNext)`	Subscribes to the current `Flowable` and receives notifications for each element until the `onNext` Predicate returns `false`.
`@NonNull Disposable`	Flowable.`forEachWhile(@NonNull Predicate<? super @NonNull T> onNext, @NonNull Consumer<? super java.lang.Throwable> onError)`	Subscribes to the current `Flowable` and receives notifications for each element and error events until the `onNext` Predicate returns `false`.
`@NonNull Disposable`	Flowable.`forEachWhile(@NonNull Predicate<? super @NonNull T> onNext, @NonNull Consumer<? super java.lang.Throwable> onError, @NonNull Action onComplete)`	Subscribes to the current `Flowable` and receives notifications for each element and the terminal events until the `onNext` Predicate returns `false`.
`@NonNull Disposable`	Observable.`forEachWhile(@NonNull Predicate<? super @NonNull T> onNext)`	Subscribes to the `ObservableSource` and calls a `Predicate` for each item of the current `Observable`, on its emission thread, until the predicate returns `false`.
`@NonNull Disposable`	Observable.`forEachWhile(@NonNull Predicate<? super @NonNull T> onNext, @NonNull Consumer<? super java.lang.Throwable> onError)`	Subscribes to the `ObservableSource` and calls a `Predicate` for each item or a `Consumer` with the error of the current `Observable`, on their original emission threads, until the predicate returns `false`.
`@NonNull Disposable`	Observable.`forEachWhile(@NonNull Predicate<? super @NonNull T> onNext, @NonNull Consumer<? super java.lang.Throwable> onError, @NonNull Action onComplete)`	Subscribes to the `ObservableSource` and calls a `Predicate` for each item, a `Consumer` with the error or an `Action` upon completion of the current `Observable`, on their original emission threads, until the predicate returns `false`.
`@NonNull Disposable`	Scheduler.Worker.`schedule(@NonNull java.lang.Runnable run)`	Schedules a Runnable for execution without any time delay.
`abstract @NonNull Disposable`	Scheduler.Worker.`schedule(@NonNull java.lang.Runnable run, long delay, @NonNull java.util.concurrent.TimeUnit unit)`	Schedules an Runnable for execution at some point in the future specified by a time delay relative to the current time.
`@NonNull Disposable`	Scheduler.`scheduleDirect(@NonNull java.lang.Runnable run)`	Schedules the given task on this Scheduler without any time delay.
`@NonNull Disposable`	Scheduler.`scheduleDirect(@NonNull java.lang.Runnable run, long delay, @NonNull java.util.concurrent.TimeUnit unit)`	Schedules the execution of the given task with the given time delay.
`@NonNull Disposable`	Scheduler.Worker.`schedulePeriodically(@NonNull java.lang.Runnable run, long initialDelay, long period, @NonNull java.util.concurrent.TimeUnit unit)`	Schedules a periodic execution of the given task with the given initial time delay and repeat period.
`@NonNull Disposable`	Scheduler.`schedulePeriodicallyDirect(@NonNull java.lang.Runnable run, long initialDelay, long period, @NonNull java.util.concurrent.TimeUnit unit)`	Schedules a periodic execution of the given task with the given initial time delay and repeat period.
`@NonNull Disposable`	Completable.`subscribe()`	Subscribes to this `Completable` and returns a `Disposable` which can be used to dispose the subscription.
`@NonNull Disposable`	Completable.`subscribe(@NonNull Action onComplete)`	Subscribes to this `Completable` and calls the given `Action` when this `Completable` completes normally.
`@NonNull Disposable`	Completable.`subscribe(@NonNull Action onComplete, @NonNull Consumer<? super java.lang.Throwable> onError)`	Subscribes to this `Completable` and calls back either the `onError` or `onComplete` functions.
`@NonNull Disposable`	Completable.`subscribe(@NonNull Action onComplete, @NonNull Consumer<? super java.lang.Throwable> onError, @NonNull DisposableContainer container)`	Wraps the given onXXX callbacks into a `Disposable` `CompletableObserver`, adds it to the given `DisposableContainer` and ensures, that if the upstream terminates or this particular `Disposable` is disposed, the `CompletableObserver` is removed from the given composite.
`@NonNull Disposable`	Flowable.`subscribe()`	Subscribes to the current `Flowable` and ignores `onNext` and `onComplete` emissions.
`@NonNull Disposable`	Flowable.`subscribe(@NonNull Consumer<? super @NonNull T> onNext)`	Subscribes to the current `Flowable` and provides a callback to handle the items it emits.
`@NonNull Disposable`	Flowable.`subscribe(@NonNull Consumer<? super @NonNull T> onNext, @NonNull Consumer<? super java.lang.Throwable> onError)`	Subscribes to the current `Flowable` and provides callbacks to handle the items it emits and any error notification it issues.
`@NonNull Disposable`	Flowable.`subscribe(@NonNull Consumer<? super @NonNull T> onNext, @NonNull Consumer<? super java.lang.Throwable> onError, @NonNull Action onComplete)`	Subscribes to the current `Flowable` and provides callbacks to handle the items it emits and any error or completion notification it issues.
`@NonNull Disposable`	Flowable.`subscribe(@NonNull Consumer<? super @NonNull T> onNext, @NonNull Consumer<? super java.lang.Throwable> onError, @NonNull Action onComplete, @NonNull DisposableContainer container)`	Wraps the given onXXX callbacks into a `Disposable` `Subscriber`, adds it to the given `DisposableContainer` and ensures, that if the upstream terminates or this particular `Disposable` is disposed, the `Subscriber` is removed from the given container.
`@NonNull Disposable`	Maybe.`subscribe()`	Subscribes to a `Maybe` and ignores `onSuccess` and `onComplete` emissions.
`@NonNull Disposable`	Maybe.`subscribe(@NonNull Consumer<? super @NonNull T> onSuccess)`	Subscribes to a `Maybe` and provides a callback to handle the items it emits.
`@NonNull Disposable`	Maybe.`subscribe(@NonNull Consumer<? super @NonNull T> onSuccess, @NonNull Consumer<? super java.lang.Throwable> onError)`	Subscribes to a `Maybe` and provides callbacks to handle the items it emits and any error notification it issues.
`@NonNull Disposable`	Maybe.`subscribe(@NonNull Consumer<? super @NonNull T> onSuccess, @NonNull Consumer<? super java.lang.Throwable> onError, @NonNull Action onComplete)`	Subscribes to a `Maybe` and provides callbacks to handle the items it emits and any error or completion notification it issues.
`@NonNull Disposable`	Maybe.`subscribe(@NonNull Consumer<? super @NonNull T> onSuccess, @NonNull Consumer<? super java.lang.Throwable> onError, @NonNull Action onComplete, @NonNull DisposableContainer container)`	Wraps the given onXXX callbacks into a `Disposable` `MaybeObserver`, adds it to the given `DisposableContainer` and ensures, that if the upstream terminates or this particular `Disposable` is disposed, the `MaybeObserver` is removed from the given composite.
`@NonNull Disposable`	Observable.`subscribe()`	Subscribes to the current `Observable` and ignores `onNext` and `onComplete` emissions.
`@NonNull Disposable`	Observable.`subscribe(@NonNull Consumer<? super @NonNull T> onNext)`	Subscribes to the current `Observable` and provides a callback to handle the items it emits.
`@NonNull Disposable`	Observable.`subscribe(@NonNull Consumer<? super @NonNull T> onNext, @NonNull Consumer<? super java.lang.Throwable> onError)`	Subscribes to the current `Observable` and provides callbacks to handle the items it emits and any error notification it signals.
`@NonNull Disposable`	Observable.`subscribe(@NonNull Consumer<? super @NonNull T> onNext, @NonNull Consumer<? super java.lang.Throwable> onError, @NonNull Action onComplete)`	Subscribes to the current `Observable` and provides callbacks to handle the items it emits and any error or completion notification it signals.
`@NonNull Disposable`	Observable.`subscribe(@NonNull Consumer<? super @NonNull T> onNext, @NonNull Consumer<? super java.lang.Throwable> onError, @NonNull Action onComplete, @NonNull DisposableContainer container)`	Wraps the given onXXX callbacks into a `Disposable` `Observer`, adds it to the given `DisposableContainer` and ensures, that if the upstream terminates or this particular `Disposable` is disposed, the `Observer` is removed from the given container.
`@NonNull Disposable`	Single.`subscribe()`	Subscribes to a `Single` but ignore its emission or notification.
`@NonNull Disposable`	Single.`subscribe(@NonNull BiConsumer<? super @NonNull T,? super java.lang.Throwable> onCallback)`	Subscribes to a `Single` and provides a composite callback to handle the item it emits or any error notification it issues.
`@NonNull Disposable`	Single.`subscribe(@NonNull Consumer<? super @NonNull T> onSuccess)`	Subscribes to a `Single` and provides a callback to handle the item it emits.
`@NonNull Disposable`	Single.`subscribe(@NonNull Consumer<? super @NonNull T> onSuccess, @NonNull Consumer<? super java.lang.Throwable> onError)`	Subscribes to a `Single` and provides callbacks to handle the item it emits or any error notification it issues.
`@NonNull Disposable`	Single.`subscribe(@NonNull Consumer<? super @NonNull T> onSuccess, @NonNull Consumer<? super java.lang.Throwable> onError, @NonNull DisposableContainer container)`	Wraps the given onXXX callbacks into a `Disposable` `SingleObserver`, adds it to the given `DisposableContainer` and ensures, that if the upstream terminates or this particular `Disposable` is disposed, the `SingleObserver` is removed from the given container.

Methods in io.reactivex.rxjava3.core with parameters of type Disposable
Modifier and Type	Method	Description
`void`	CompletableObserver.`onSubscribe(@NonNull Disposable d)`	Called once by the `Completable` to set a `Disposable` on this instance which then can be used to cancel the subscription at any time.
`void`	MaybeObserver.`onSubscribe(@NonNull Disposable d)`	Provides the `MaybeObserver` with the means of cancelling (disposing) the connection (channel) with the `Maybe` in both synchronous (from within `onSubscribe(Disposable)` itself) and asynchronous manner.
`void`	Observer.`onSubscribe(@NonNull Disposable d)`	Provides the `Observer` with the means of cancelling (disposing) the connection (channel) with the `Observable` in both synchronous (from within `Observer.onNext(Object)`) and asynchronous manner.
`void`	SingleObserver.`onSubscribe(@NonNull Disposable d)`	Provides the `SingleObserver` with the means of cancelling (disposing) the connection (channel) with the Single in both synchronous (from within `onSubscribe(Disposable)` itself) and asynchronous manner.
`void`	CompletableEmitter.`setDisposable(@Nullable Disposable d)`	Sets a Disposable on this emitter; any previous `Disposable` or `Cancellable` will be disposed/cancelled.
`void`	FlowableEmitter.`setDisposable(@Nullable Disposable d)`	Sets a Disposable on this emitter; any previous `Disposable` or `Cancellable` will be disposed/cancelled.
`void`	MaybeEmitter.`setDisposable(@Nullable Disposable d)`	Sets a `Disposable` on this emitter; any previous `Disposable` or `Cancellable` will be disposed/cancelled.
`void`	ObservableEmitter.`setDisposable(@Nullable Disposable d)`	Sets a `Disposable` on this emitter; any previous `Disposable` or `Cancellable` will be disposed/cancelled.
`void`	SingleEmitter.`setDisposable(@Nullable Disposable d)`	Sets a `Disposable` on this emitter; any previous `Disposable` or `Cancellable` will be disposed/cancelled.

Method parameters in io.reactivex.rxjava3.core with type arguments of type Disposable
Modifier and Type	Method	Description
`@NonNull Completable`	Completable.`doOnLifecycle(@NonNull Consumer<? super Disposable> onSubscribe, @NonNull Action onDispose)`	Calls the appropriate `onXXX` method (shared between all `CompletableObserver`s) for the lifecycle events of the sequence (subscription, disposal).
`private @NonNull Completable`	Completable.`doOnLifecycle(Consumer<? super Disposable> onSubscribe, Consumer<? super java.lang.Throwable> onError, Action onComplete, Action onTerminate, Action onAfterTerminate, Action onDispose)`	Returns a `Completable` instance that calls the various callbacks upon the specific lifecycle events.
`@NonNull Maybe<T>`	Maybe.`doOnLifecycle(@NonNull Consumer<? super Disposable> onSubscribe, @NonNull Action onDispose)`	Calls the appropriate `onXXX` method (shared between all `MaybeObserver`s) for the lifecycle events of the sequence (subscription, disposal).
`@NonNull Observable<T>`	Observable.`doOnLifecycle(@NonNull Consumer<? super Disposable> onSubscribe, @NonNull Action onDispose)`	Calls the appropriate `onXXX` method (shared between all `Observer`s) for the lifecycle events of the sequence (subscription, disposal).
`@NonNull Single<T>`	Single.`doOnLifecycle(@NonNull Consumer<? super Disposable> onSubscribe, @NonNull Action onDispose)`	Calls the appropriate `onXXX` method (shared between all `SingleObserver`s) for the lifecycle events of the sequence (subscription, disposal).
`@NonNull Completable`	Completable.`doOnSubscribe(@NonNull Consumer<? super Disposable> onSubscribe)`	Returns a `Completable` instance that calls the given `onSubscribe` callback with the disposable that the downstream `CompletableObserver`s receive upon subscription.
`@NonNull Maybe<T>`	Maybe.`doOnSubscribe(@NonNull Consumer<? super Disposable> onSubscribe)`	Calls the shared `Consumer` with the `Disposable` sent through the `onSubscribe` for each `MaybeObserver` that subscribes to the current `Maybe`.
`@NonNull Observable<T>`	Observable.`doOnSubscribe(@NonNull Consumer<? super Disposable> onSubscribe)`	Returns an `Observable` so that it invokes the given `Consumer` when the current `Observable` is subscribed from its `Observer`s.
`@NonNull Single<T>`	Single.`doOnSubscribe(@NonNull Consumer<? super Disposable> onSubscribe)`	Calls the shared consumer with the `Disposable` sent through the `onSubscribe` for each `SingleObserver` that subscribes to the current `Single`.

Uses of Disposable in io.reactivex.rxjava3.disposables

Classes in io.reactivex.rxjava3.disposables that implement Disposable
Modifier and Type	Class	Description
`(package private) class`	`ActionDisposable`	A Disposable container that manages an `Action` instance.
`(package private) class`	`AutoCloseableDisposable`	A disposable container that manages an `AutoCloseable` instance.
`class`	`CompositeDisposable`	A disposable container that can hold onto multiple other `Disposable`s and offers O(1) time complexity for `CompositeDisposable.add(Disposable)`, `CompositeDisposable.remove(Disposable)` and `CompositeDisposable.delete(Disposable)` operations.
`(package private) class`	`FutureDisposable`	A Disposable container that cancels a `Future` instance.
`(package private) class`	`ReferenceDisposable<T>`	Base class for Disposable containers that manage some other type that has to be run when the container is disposed.
`(package private) class`	`RunnableDisposable`	A disposable container that manages a `Runnable` instance.
`class`	`SerialDisposable`	A Disposable container that allows atomically updating/replacing the contained Disposable with another Disposable, disposing the old one when updating plus handling the disposition when the container itself is disposed.
`(package private) class`	`SubscriptionDisposable`	A Disposable container that handles a `Subscription`.

Fields in io.reactivex.rxjava3.disposables with type parameters of type Disposable
Modifier and Type	Field	Description
`(package private) java.util.concurrent.atomic.AtomicReference<Disposable>`	SerialDisposable.`resource`
`(package private) OpenHashSet<Disposable>`	CompositeDisposable.`resources`

Methods in io.reactivex.rxjava3.disposables that return Disposable
Modifier and Type	Method	Description
`static @NonNull Disposable`	Disposable.`disposed()`	Returns a shared, disposed `Disposable` instance.
`static @NonNull Disposable`	Disposable.`empty()`	Returns a new, non-disposed `Disposable` instance.
`static @NonNull Disposable`	Disposable.`fromAction(@NonNull Action action)`	Construct a `Disposable` by wrapping a `Action` that is executed exactly once when the `Disposable` is disposed.
`static @NonNull Disposable`	Disposable.`fromAutoCloseable(@NonNull java.lang.AutoCloseable autoCloseable)`	Construct a `Disposable` by wrapping an `AutoCloseable` that is closed exactly once when the `Disposable` is disposed.
`static @NonNull Disposable`	Disposable.`fromFuture(@NonNull java.util.concurrent.Future<?> future)`	Construct a `Disposable` by wrapping a `Future` that is cancelled exactly once when the `Disposable` is disposed.
`static @NonNull Disposable`	Disposable.`fromFuture(@NonNull java.util.concurrent.Future<?> future, boolean allowInterrupt)`	Construct a `Disposable` by wrapping a `Future` that is cancelled exactly once when the `Disposable` is disposed.
`static @NonNull Disposable`	Disposable.`fromRunnable(@NonNull java.lang.Runnable run)`	Construct a `Disposable` by wrapping a `Runnable` that is executed exactly once when the `Disposable` is disposed.
`static @NonNull Disposable`	Disposable.`fromSubscription(@NonNull org.reactivestreams.Subscription subscription)`	Construct a `Disposable` by wrapping a `Subscription` that is cancelled exactly once when the `Disposable` is disposed.
`@Nullable Disposable`	SerialDisposable.`get()`	Returns the currently contained Disposable or null if this container is empty.

Methods in io.reactivex.rxjava3.disposables with parameters of type Disposable
Modifier and Type	Method	Description
`boolean`	CompositeDisposable.`add(@NonNull Disposable disposable)`	Adds a `Disposable` to this container or disposes it if the container has been disposed.
`boolean`	DisposableContainer.`add(Disposable d)`	Adds a disposable to this container or disposes it if the container has been disposed.
`boolean`	CompositeDisposable.`addAll(@NonNull Disposable... disposables)`	Atomically adds the given array of `Disposable`s to the container or disposes them all if the container has been disposed.
`boolean`	CompositeDisposable.`delete(@NonNull Disposable disposable)`	Removes (but does not dispose) the given `Disposable` if it is part of this container.
`boolean`	DisposableContainer.`delete(Disposable d)`	Removes but does not dispose the given disposable if it is part of this container.
`boolean`	CompositeDisposable.`remove(@NonNull Disposable disposable)`	Removes and disposes the given `Disposable` if it is part of this container.
`boolean`	DisposableContainer.`remove(Disposable d)`	Removes and disposes the given disposable if it is part of this container.
`boolean`	SerialDisposable.`replace(@Nullable Disposable next)`	Atomically: set the next disposable on this container but don't dispose the previous one (if any) or dispose next if the container has been disposed.
`boolean`	SerialDisposable.`set(@Nullable Disposable next)`	Atomically: set the next disposable on this container and dispose the previous one (if any) or dispose next if the container has been disposed.
`static @NonNull java.lang.AutoCloseable`	Disposable.`toAutoCloseable(@NonNull Disposable disposable)`	Construct an `AutoCloseable` by wrapping a `Disposable` that is disposed when the returned `AutoCloseable` is closed.

Method parameters in io.reactivex.rxjava3.disposables with type arguments of type Disposable
Modifier and Type	Method	Description
`(package private) void`	CompositeDisposable.`dispose(@Nullable OpenHashSet<Disposable> set)`	Dispose the contents of the `OpenHashSet` by suppressing non-fatal `Throwable`s till the end.

Constructors in io.reactivex.rxjava3.disposables with parameters of type Disposable
Constructor	Description
`CompositeDisposable(@NonNull Disposable... disposables)`	Creates a `CompositeDisposable` with the given array of initial `Disposable` elements.
`SerialDisposable(@Nullable Disposable initialDisposable)`	Constructs a SerialDisposable with the given initial Disposable instance.

Constructor parameters in io.reactivex.rxjava3.disposables with type arguments of type Disposable
Constructor	Description
`CompositeDisposable(@NonNull java.lang.Iterable<? extends Disposable> disposables)`	Creates a `CompositeDisposable` with the given `Iterable` sequence of initial `Disposable` elements.

Uses of Disposable in io.reactivex.rxjava3.flowables

Methods in io.reactivex.rxjava3.flowables that return Disposable
Modifier and Type	Method	Description
`@NonNull Disposable`	ConnectableFlowable.`connect()`	Instructs the `ConnectableFlowable` to begin emitting the items from its underlying `Flowable` to its `Subscriber`s.

Method parameters in io.reactivex.rxjava3.flowables with type arguments of type Disposable
Modifier and Type	Method	Description
`@NonNull Flowable<T>`	ConnectableFlowable.`autoConnect(int numberOfSubscribers, @NonNull Consumer<? super Disposable> connection)`	Returns a `Flowable` that automatically connects (at most once) to this `ConnectableFlowable` when the specified number of `Subscriber`s subscribe to it and calls the specified callback with the `Disposable` associated with the established connection.
`abstract void`	ConnectableFlowable.`connect(@NonNull Consumer<? super Disposable> connection)`	Instructs the `ConnectableFlowable` to begin emitting the items from its underlying `Flowable` to its `Subscriber`s.

Uses of Disposable in io.reactivex.rxjava3.internal.disposables

Classes in io.reactivex.rxjava3.internal.disposables that implement Disposable
Modifier and Type	Class	Description
`class`	`ArrayCompositeDisposable`	A composite disposable with a fixed number of slots.
`class`	`CancellableDisposable`	A disposable container that wraps a Cancellable instance.
`class`	`DisposableHelper`	Utility methods for working with Disposables atomically.
`class`	`EmptyDisposable`	Represents a stateless empty Disposable that reports being always empty and disposed.
`class`	`ListCompositeDisposable`	A disposable container that can hold onto multiple other disposables.
`class`	`SequentialDisposable`	A Disposable container that allows updating/replacing a Disposable atomically and with respect of disposing the container itself.

Fields in io.reactivex.rxjava3.internal.disposables with type parameters of type Disposable
Modifier and Type	Field	Description
`(package private) java.util.List<Disposable>`	ListCompositeDisposable.`resources`

Methods in io.reactivex.rxjava3.internal.disposables that return Disposable
Modifier and Type	Method	Description
`Disposable`	ArrayCompositeDisposable.`replaceResource(int index, Disposable resource)`	Replaces the resource at the specified index and returns the old resource.

Methods in io.reactivex.rxjava3.internal.disposables with parameters of type Disposable
Modifier and Type	Method	Description
`boolean`	ListCompositeDisposable.`add(Disposable d)`
`boolean`	ListCompositeDisposable.`addAll(Disposable... ds)`
`boolean`	ListCompositeDisposable.`delete(Disposable d)`
`static boolean`	DisposableHelper.`isDisposed(Disposable d)`	Checks if the given Disposable is the common `DisposableHelper.DISPOSED` enum value.
`boolean`	ListCompositeDisposable.`remove(Disposable d)`
`static boolean`	DisposableHelper.`replace(java.util.concurrent.atomic.AtomicReference<Disposable> field, Disposable d)`	Atomically replaces the Disposable in the field with the given new Disposable but does not dispose the old one.
`boolean`	SequentialDisposable.`replace(Disposable next)`	Atomically: set the next disposable on this container but don't dispose the previous one (if any) or dispose next if the container has been disposed.
`Disposable`	ArrayCompositeDisposable.`replaceResource(int index, Disposable resource)`	Replaces the resource at the specified index and returns the old resource.
`static boolean`	DisposableHelper.`set(java.util.concurrent.atomic.AtomicReference<Disposable> field, Disposable d)`	Atomically sets the field and disposes the old contents.
`static boolean`	DisposableHelper.`setOnce(java.util.concurrent.atomic.AtomicReference<Disposable> field, Disposable d)`	Atomically sets the field to the given non-null Disposable and returns true or returns false if the field is non-null.
`boolean`	ArrayCompositeDisposable.`setResource(int index, Disposable resource)`	Sets the resource at the specified index and disposes the old resource.
`static boolean`	DisposableHelper.`trySet(java.util.concurrent.atomic.AtomicReference<Disposable> field, Disposable d)`	Atomically tries to set the given Disposable on the field if it is null or disposes it if the field contains `DisposableHelper.DISPOSED`.
`boolean`	SequentialDisposable.`update(Disposable next)`	Atomically: set the next disposable on this container and dispose the previous one (if any) or dispose next if the container has been disposed.
`static boolean`	DisposableHelper.`validate(Disposable current, Disposable next)`	Verifies that current is null, next is not null, otherwise signals errors to the RxJavaPlugins and returns false.

Method parameters in io.reactivex.rxjava3.internal.disposables with type arguments of type Disposable
Modifier and Type	Method	Description
`static boolean`	DisposableHelper.`dispose(java.util.concurrent.atomic.AtomicReference<Disposable> field)`	Atomically disposes the Disposable in the field if not already disposed.
`(package private) void`	ListCompositeDisposable.`dispose(java.util.List<Disposable> set)`
`static boolean`	DisposableHelper.`replace(java.util.concurrent.atomic.AtomicReference<Disposable> field, Disposable d)`	Atomically replaces the Disposable in the field with the given new Disposable but does not dispose the old one.
`static boolean`	DisposableHelper.`set(java.util.concurrent.atomic.AtomicReference<Disposable> field, Disposable d)`	Atomically sets the field and disposes the old contents.
`static boolean`	DisposableHelper.`setOnce(java.util.concurrent.atomic.AtomicReference<Disposable> field, Disposable d)`	Atomically sets the field to the given non-null Disposable and returns true or returns false if the field is non-null.
`static boolean`	DisposableHelper.`trySet(java.util.concurrent.atomic.AtomicReference<Disposable> field, Disposable d)`	Atomically tries to set the given Disposable on the field if it is null or disposes it if the field contains `DisposableHelper.DISPOSED`.

Constructors in io.reactivex.rxjava3.internal.disposables with parameters of type Disposable
Constructor	Description
`ListCompositeDisposable(Disposable... resources)`
`SequentialDisposable(Disposable initial)`	Construct a SequentialDisposable with the initial Disposable provided.

Constructor parameters in io.reactivex.rxjava3.internal.disposables with type arguments of type Disposable
Constructor	Description
`ListCompositeDisposable(java.lang.Iterable<? extends Disposable> resources)`

Uses of Disposable in io.reactivex.rxjava3.internal.fuseable

Classes in io.reactivex.rxjava3.internal.fuseable that implement Disposable
Modifier and Type	Class	Description
`class`	`AbstractEmptyQueueFuseable<T>`	Represents an empty, async-only `QueueFuseable` instance.
`class`	`CancellableQueueFuseable<T>`	Represents an empty, async-only `QueueFuseable` instance that tracks and exposes a canceled/disposed state.

Uses of Disposable in io.reactivex.rxjava3.internal.jdk8

Classes in io.reactivex.rxjava3.internal.jdk8 that implement Disposable
Modifier and Type	Class	Description
`(package private) static class`	`CompletableFromCompletionStage.CompletionStageHandler<T>`
`(package private) static class`	`FlowableCollectWithCollectorSingle.CollectorSingleObserver<T,A,R>`
`(package private) static class`	`MaybeFlattenStreamAsObservable.FlattenStreamMultiObserver<T,R>`
`(package private) static class`	`MaybeFromCompletionStage.CompletionStageHandler<T>`
`(package private) static class`	`MaybeMapOptional.MapOptionalMaybeObserver<T,R>`
`(package private) static class`	`ObservableCollectWithCollector.CollectorObserver<T,A,R>`
`(package private) static class`	`ObservableCollectWithCollectorSingle.CollectorSingleObserver<T,A,R>`
`(package private) static class`	`ObservableFlatMapStream.FlatMapStreamObserver<T,R>`
`(package private) static class`	`ObservableFromCompletionStage.CompletionStageHandler<T>`
`(package private) static class`	`ObservableFromStream.StreamDisposable<T>`
`(package private) static class`	`ObservableMapOptional.MapOptionalObserver<T,R>`
`(package private) static class`	`SingleFromCompletionStage.CompletionStageHandler<T>`
`(package private) static class`	`SingleMapOptional.MapOptionalSingleObserver<T,R>`

Fields in io.reactivex.rxjava3.internal.jdk8 declared as Disposable
Modifier and Type	Field	Description
`(package private) Disposable`	MaybeFlattenStreamAsFlowable.FlattenStreamMultiObserver.`upstream`
`(package private) Disposable`	MaybeFlattenStreamAsObservable.FlattenStreamMultiObserver.`upstream`
`(package private) Disposable`	MaybeMapOptional.MapOptionalMaybeObserver.`upstream`
`(package private) Disposable`	ObservableCollectWithCollector.CollectorObserver.`upstream`
`(package private) Disposable`	ObservableCollectWithCollectorSingle.CollectorSingleObserver.`upstream`
`(package private) Disposable`	ObservableFlatMapStream.FlatMapStreamObserver.`upstream`
`(package private) Disposable`	SingleMapOptional.MapOptionalSingleObserver.`upstream`

Fields in io.reactivex.rxjava3.internal.jdk8 with type parameters of type Disposable
Modifier and Type	Field	Description
`(package private) java.util.concurrent.atomic.AtomicReference<Disposable>`	CompletionStageConsumer.`upstream`
`(package private) java.util.concurrent.atomic.AtomicReference<Disposable>`	ObservableStageObserver.`upstream`

Methods in io.reactivex.rxjava3.internal.jdk8 with parameters of type Disposable
Modifier and Type	Method	Description
`void`	CompletionStageConsumer.`onSubscribe(@NonNull Disposable d)`
`void`	MaybeFlattenStreamAsFlowable.FlattenStreamMultiObserver.`onSubscribe(@NonNull Disposable d)`
`void`	MaybeFlattenStreamAsObservable.FlattenStreamMultiObserver.`onSubscribe(@NonNull Disposable d)`
`void`	MaybeMapOptional.MapOptionalMaybeObserver.`onSubscribe(Disposable d)`
`void`	ObservableCollectWithCollector.CollectorObserver.`onSubscribe(@NonNull Disposable d)`
`void`	ObservableCollectWithCollectorSingle.CollectorSingleObserver.`onSubscribe(@NonNull Disposable d)`
`void`	ObservableFlatMapStream.FlatMapStreamObserver.`onSubscribe(@NonNull Disposable d)`
`void`	ObservableStageObserver.`onSubscribe(@NonNull Disposable d)`
`void`	SingleMapOptional.MapOptionalSingleObserver.`onSubscribe(Disposable d)`

Uses of Disposable in io.reactivex.rxjava3.internal.observers

Classes in io.reactivex.rxjava3.internal.observers that implement Disposable
Modifier and Type	Class	Description
`(package private) class`	`AbstractDisposableAutoRelease`	Wraps lambda callbacks and when the upstream terminates or the observer gets disposed, removes itself from a `CompositeDisposable`.
`class`	`BasicFuseableObserver<T,R>`	Base class for a fuseable intermediate observer.
`class`	`BasicIntQueueDisposable<T>`	An abstract QueueDisposable implementation, extending an AtomicInteger, that defaults all unnecessary Queue methods to throw UnsupportedOperationException.
`class`	`BasicQueueDisposable<T>`	An abstract QueueDisposable implementation that defaults all unnecessary Queue methods to throw UnsupportedOperationException.
`class`	`BiConsumerSingleObserver<T>`
`class`	`BlockingBaseObserver<T>`
`class`	`BlockingDisposableMultiObserver<T>`	Blocks until the upstream terminates and dispatches the outcome to the actual observer.
`class`	`BlockingFirstObserver<T>`	Blocks until the upstream signals its first value or completes.
`class`	`BlockingLastObserver<T>`	Blocks until the upstream signals its last value or completes.
`class`	`BlockingObserver<T>`
`class`	`CallbackCompletableObserver`
`class`	`ConsumerSingleObserver<T>`
`class`	`DeferredScalarDisposable<T>`	Represents a fuseable container for a single value.
`class`	`DeferredScalarObserver<T,R>`	A fuseable Observer that can generate 0 or 1 resulting value.
`class`	`DisposableAutoReleaseMultiObserver<T>`	Wraps lambda callbacks and when the upstream terminates or this (Single \| Maybe \| Completable) observer gets disposed, removes itself from a `CompositeDisposable`.
`class`	`DisposableAutoReleaseObserver<T>`	Wraps lambda callbacks and when the upstream terminates or this observer gets disposed, removes itself from a `CompositeDisposable`.
`class`	`DisposableLambdaObserver<T>`
`class`	`EmptyCompletableObserver`
`class`	`ForEachWhileObserver<T>`
`class`	`FutureMultiObserver<T>`	An Observer + Future that expects exactly one upstream value and provides it via the (blocking) Future API.
`class`	`FutureObserver<T>`	An Observer + Future that expects exactly one upstream value and provides it via the (blocking) Future API.
`class`	`InnerQueuedObserver<T>`	Subscriber that can fuse with the upstream and calls a support interface whenever an event is available.
`class`	`LambdaObserver<T>`

Fields in io.reactivex.rxjava3.internal.observers declared as Disposable
Modifier and Type	Field	Description
`protected Disposable`	BasicFuseableObserver.`upstream`	The upstream subscription.
`(package private) Disposable`	BlockingBaseObserver.`upstream`
`(package private) Disposable`	BlockingMultiObserver.`upstream`
`protected Disposable`	DeferredScalarObserver.`upstream`	The upstream disposable.
`(package private) Disposable`	DisposableLambdaObserver.`upstream`

Fields in io.reactivex.rxjava3.internal.observers with type parameters of type Disposable
Modifier and Type	Field	Description
`(package private) Consumer<? super Disposable>`	DisposableLambdaObserver.`onSubscribe`
`(package private) Consumer<? super Disposable>`	LambdaObserver.`onSubscribe`
`(package private) java.util.concurrent.atomic.AtomicReference<Disposable>`	ResumeSingleObserver.`parent`
`(package private) java.util.concurrent.atomic.AtomicReference<Disposable>`	FutureMultiObserver.`upstream`
`(package private) java.util.concurrent.atomic.AtomicReference<Disposable>`	FutureObserver.`upstream`

Methods in io.reactivex.rxjava3.internal.observers with parameters of type Disposable
Modifier and Type	Method	Description
`protected void`	QueueDrainObserver.`fastPathEmit(U value, boolean delayError, Disposable dispose)`
`protected void`	QueueDrainObserver.`fastPathOrderedEmit(U value, boolean delayError, Disposable disposable)`	Makes sure the fast-path emits in order.
`void`	AbstractDisposableAutoRelease.`onSubscribe(Disposable d)`
`void`	BasicFuseableObserver.`onSubscribe(Disposable d)`
`void`	BiConsumerSingleObserver.`onSubscribe(Disposable d)`
`void`	BlockingBaseObserver.`onSubscribe(Disposable d)`
`void`	BlockingDisposableMultiObserver.`onSubscribe(@NonNull Disposable d)`
`void`	BlockingMultiObserver.`onSubscribe(Disposable d)`
`void`	BlockingObserver.`onSubscribe(Disposable d)`
`void`	CallbackCompletableObserver.`onSubscribe(Disposable d)`
`void`	ConsumerSingleObserver.`onSubscribe(Disposable d)`
`void`	DeferredScalarObserver.`onSubscribe(Disposable d)`
`void`	DisposableLambdaObserver.`onSubscribe(Disposable d)`
`void`	EmptyCompletableObserver.`onSubscribe(Disposable d)`
`void`	ForEachWhileObserver.`onSubscribe(Disposable d)`
`void`	FutureMultiObserver.`onSubscribe(Disposable d)`
`void`	FutureObserver.`onSubscribe(Disposable d)`
`void`	InnerQueuedObserver.`onSubscribe(Disposable d)`
`void`	LambdaObserver.`onSubscribe(Disposable d)`
`void`	ResumeSingleObserver.`onSubscribe(Disposable d)`
`void`	SafeCompletableObserver.`onSubscribe(@NonNull Disposable d)`
`void`	SafeMaybeObserver.`onSubscribe(@NonNull Disposable d)`
`void`	SafeSingleObserver.`onSubscribe(@NonNull Disposable d)`

Constructor parameters in io.reactivex.rxjava3.internal.observers with type arguments of type Disposable
Constructor	Description
`DisposableLambdaObserver(Observer<? super T> actual, Consumer<? super Disposable> onSubscribe, Action onDispose)`
`ResumeSingleObserver(java.util.concurrent.atomic.AtomicReference<Disposable> parent, SingleObserver<? super T> downstream)`

Uses of Disposable in io.reactivex.rxjava3.internal.operators.completable

Classes in io.reactivex.rxjava3.internal.operators.completable that implement Disposable
Modifier and Type	Class	Description
`(package private) static class`	`CompletableAndThenCompletable.SourceObserver`
`(package private) class`	`CompletableCache.InnerCompletableCache`
`(package private) static class`	`CompletableConcat.CompletableConcatSubscriber`
`(package private) static class`	`CompletableCreate.Emitter`
`(package private) static class`	`CompletableDelay.Delay`
`(package private) static class`	`CompletableDetach.DetachCompletableObserver`
`(package private) static class`	`CompletableDisposeOn.DisposeOnObserver`
`(package private) static class`	`CompletableDoFinally.DoFinallyObserver`
`(package private) static class`	`CompletableFromPublisher.FromPublisherSubscriber<T>`
`(package private) static class`	`CompletableHide.HideCompletableObserver`
`(package private) static class`	`CompletableMerge.CompletableMergeSubscriber`
`(package private) class`	`CompletableMerge.CompletableMergeSubscriber.MergeInnerObserver`
`(package private) static class`	`CompletableMergeArray.InnerCompletableObserver`
`(package private) static class`	`CompletableMergeArrayDelayError.TryTerminateAndReportDisposable`
`(package private) static class`	`CompletableMergeIterable.MergeCompletableObserver`
`(package private) static class`	`CompletableObserveOn.ObserveOnCompletableObserver`
`(package private) static class`	`CompletableOnErrorReturn.OnErrorReturnMaybeObserver<T>`
`(package private) class`	`CompletablePeek.CompletableObserverImplementation`
`(package private) static class`	`CompletableResumeNext.ResumeNextObserver`
`(package private) static class`	`CompletableSubscribeOn.SubscribeOnObserver`
`(package private) static class`	`CompletableTakeUntilCompletable.TakeUntilMainObserver`
`(package private) static class`	`CompletableTimer.TimerDisposable`
`(package private) static class`	`CompletableUsing.UsingObserver<R>`

Fields in io.reactivex.rxjava3.internal.operators.completable declared as Disposable
Modifier and Type	Field	Description
`(package private) Disposable`	CompletableAmb.Amb.`upstream`
`(package private) Disposable`	CompletableDetach.DetachCompletableObserver.`upstream`
`(package private) Disposable`	CompletableDisposeOn.DisposeOnObserver.`upstream`
`(package private) Disposable`	CompletableDoFinally.DoFinallyObserver.`upstream`
`(package private) Disposable`	CompletableHide.HideCompletableObserver.`upstream`
`(package private) Disposable`	CompletableOnErrorReturn.OnErrorReturnMaybeObserver.`upstream`
`(package private) Disposable`	CompletablePeek.CompletableObserverImplementation.`upstream`
`(package private) Disposable`	CompletableUsing.UsingObserver.`upstream`

Fields in io.reactivex.rxjava3.internal.operators.completable with type parameters of type Disposable
Modifier and Type	Field	Description
`(package private) Consumer<? super Disposable>`	CompletablePeek.`onSubscribe`
`(package private) java.util.concurrent.atomic.AtomicReference<Disposable>`	CompletableAndThenCompletable.NextObserver.`parent`

Methods in io.reactivex.rxjava3.internal.operators.completable with parameters of type Disposable
Modifier and Type	Method	Description
`void`	CompletableAmb.Amb.`onSubscribe(Disposable d)`
`void`	CompletableAndThenCompletable.NextObserver.`onSubscribe(Disposable d)`
`void`	CompletableAndThenCompletable.SourceObserver.`onSubscribe(Disposable d)`
`void`	CompletableCache.`onSubscribe(Disposable d)`
`void`	CompletableConcat.CompletableConcatSubscriber.ConcatInnerObserver.`onSubscribe(Disposable d)`
`void`	CompletableConcatArray.ConcatInnerObserver.`onSubscribe(Disposable d)`
`void`	CompletableConcatIterable.ConcatInnerObserver.`onSubscribe(Disposable d)`
`void`	CompletableDelay.Delay.`onSubscribe(Disposable d)`
`void`	CompletableDetach.DetachCompletableObserver.`onSubscribe(Disposable d)`
`void`	CompletableDisposeOn.DisposeOnObserver.`onSubscribe(Disposable d)`
`void`	CompletableDoFinally.DoFinallyObserver.`onSubscribe(Disposable d)`
`void`	CompletableDoOnEvent.DoOnEvent.`onSubscribe(Disposable d)`
`void`	CompletableFromObservable.CompletableFromObservableObserver.`onSubscribe(Disposable d)`
`void`	CompletableFromSingle.CompletableFromSingleObserver.`onSubscribe(Disposable d)`
`void`	CompletableHide.HideCompletableObserver.`onSubscribe(Disposable d)`
`void`	CompletableMerge.CompletableMergeSubscriber.MergeInnerObserver.`onSubscribe(Disposable d)`
`void`	CompletableMergeArray.InnerCompletableObserver.`onSubscribe(Disposable d)`
`void`	CompletableMergeArrayDelayError.MergeInnerCompletableObserver.`onSubscribe(Disposable d)`
`void`	CompletableMergeIterable.MergeCompletableObserver.`onSubscribe(Disposable d)`
`void`	CompletableObserveOn.ObserveOnCompletableObserver.`onSubscribe(Disposable d)`
`void`	CompletableOnErrorComplete.OnError.`onSubscribe(Disposable d)`
`void`	CompletableOnErrorReturn.OnErrorReturnMaybeObserver.`onSubscribe(Disposable d)`
`void`	CompletablePeek.CompletableObserverImplementation.`onSubscribe(Disposable d)`
`void`	CompletableResumeNext.ResumeNextObserver.`onSubscribe(Disposable d)`
`void`	CompletableSubscribeOn.SubscribeOnObserver.`onSubscribe(Disposable d)`
`void`	CompletableTakeUntilCompletable.TakeUntilMainObserver.`onSubscribe(Disposable d)`
`void`	CompletableTakeUntilCompletable.TakeUntilMainObserver.OtherObserver.`onSubscribe(Disposable d)`
`void`	CompletableTimeout.DisposeTask.DisposeObserver.`onSubscribe(Disposable d)`
`void`	CompletableTimeout.TimeOutObserver.`onSubscribe(Disposable d)`
`void`	CompletableToSingle.ToSingle.`onSubscribe(Disposable d)`
`void`	CompletableUsing.UsingObserver.`onSubscribe(Disposable d)`
`void`	CompletableCreate.Emitter.`setDisposable(Disposable d)`
`(package private) void`	CompletableTimer.TimerDisposable.`setFuture(Disposable d)`

Constructor parameters in io.reactivex.rxjava3.internal.operators.completable with type arguments of type Disposable
Constructor	Description
`CompletablePeek(CompletableSource source, Consumer<? super Disposable> onSubscribe, Consumer<? super java.lang.Throwable> onError, Action onComplete, Action onTerminate, Action onAfterTerminate, Action onDispose)`
`NextObserver(java.util.concurrent.atomic.AtomicReference<Disposable> parent, CompletableObserver downstream)`

Uses of Disposable in io.reactivex.rxjava3.internal.operators.flowable

Classes in io.reactivex.rxjava3.internal.operators.flowable that implement Disposable
Modifier and Type	Class	Description
`(package private) static class`	`BlockingFlowableIterable.BlockingFlowableIterator<T>`
`(package private) static class`	`BlockingFlowableLatest.LatestSubscriberIterator<T>`	Subscriber of source, iterator for output.
`(package private) static class`	`BlockingFlowableNext.NextSubscriber<T>`
`(package private) static class`	`FlowableAllSingle.AllSubscriber<T>`
`(package private) static class`	`FlowableAnySingle.AnySubscriber<T>`
`(package private) static class`	`FlowableBufferBoundary.BufferBoundarySubscriber.BufferOpenSubscriber<Open>`
`(package private) static class`	`FlowableBufferBoundary.BufferCloseSubscriber<T,C extends java.util.Collection<? super T>>`
`(package private) static class`	`FlowableBufferExactBoundary.BufferBoundarySubscriber<T,U extends java.util.Collection<? super T>,B>`
`(package private) static class`	`FlowableBufferExactBoundary.BufferExactBoundarySubscriber<T,U extends java.util.Collection<? super T>,B>`
`(package private) static class`	`FlowableBufferTimed.BufferExactBoundedSubscriber<T,U extends java.util.Collection<? super T>>`
`(package private) static class`	`FlowableBufferTimed.BufferExactUnboundedSubscriber<T,U extends java.util.Collection<? super T>>`
`(package private) static class`	`FlowableCollectSingle.CollectSubscriber<T,U>`
`(package private) static class`	`FlowableCountSingle.CountSubscriber`
`(package private) static class`	`FlowableDebounce.DebounceSubscriber.DebounceInnerSubscriber<T,U>`
`(package private) static class`	`FlowableDebounceTimed.DebounceEmitter<T>`
`(package private) static class`	`FlowableElementAtMaybe.ElementAtSubscriber<T>`
`(package private) static class`	`FlowableElementAtSingle.ElementAtSubscriber<T>`
`(package private) static class`	`FlowableFlatMap.InnerSubscriber<T,U>`
`(package private) class`	`FlowableFlatMapCompletable.FlatMapCompletableMainSubscriber.InnerConsumer`
`(package private) static class`	`FlowableFlatMapCompletableCompletable.FlatMapCompletableMainSubscriber<T>`
`(package private) class`	`FlowableFlatMapCompletableCompletable.FlatMapCompletableMainSubscriber.InnerObserver`
`(package private) class`	`FlowableFlatMapMaybe.FlatMapMaybeSubscriber.InnerObserver`
`(package private) class`	`FlowableFlatMapSingle.FlatMapSingleSubscriber.InnerObserver`
`static class`	`FlowableFromCompletable.FromCompletableObserver<T>`
`(package private) static class`	`FlowableGroupJoin.LeftRightEndSubscriber`
`(package private) static class`	`FlowableGroupJoin.LeftRightSubscriber`
`(package private) static class`	`FlowableIgnoreElementsCompletable.IgnoreElementsSubscriber<T>`
`(package private) static class`	`FlowableLastMaybe.LastSubscriber<T>`
`(package private) static class`	`FlowableLastSingle.LastSubscriber<T>`
`(package private) static class`	`FlowablePublish.PublishConnection<T>`
`(package private) static class`	`FlowableReduceMaybe.ReduceSubscriber<T>`
`(package private) static class`	`FlowableReduceSeedSingle.ReduceSeedObserver<T,R>`
`(package private) static class`	`FlowableReplay.InnerSubscription<T>`	A Subscription that manages the request and cancellation state of a child subscriber in thread-safe manner.
`(package private) static class`	`FlowableReplay.ReplaySubscriber<T>`
`(package private) static class`	`FlowableSequenceEqualSingle.EqualCoordinator<T>`
`(package private) static class`	`FlowableSingleMaybe.SingleElementSubscriber<T>`
`(package private) static class`	`FlowableSingleSingle.SingleElementSubscriber<T>`
`(package private) static class`	`FlowableTimeout.TimeoutConsumer`
`(package private) static class`	`FlowableToListSingle.ToListSubscriber<T,U extends java.util.Collection<? super T>>`
`(package private) static class`	`FlowableWindowBoundary.WindowBoundaryInnerSubscriber<T,B>`
`(package private) static class`	`FlowableWindowBoundarySelector.WindowBoundaryMainSubscriber.WindowEndSubscriberIntercept<T,V>`

Fields in io.reactivex.rxjava3.internal.operators.flowable declared as Disposable
Modifier and Type	Field	Description
`(package private) Disposable`	FlowableBufferExactBoundary.BufferExactBoundarySubscriber.`other`
`(package private) Disposable`	FlowableBufferTimed.BufferExactBoundedSubscriber.`timer`
`(package private) Disposable`	FlowableRefCount.RefConnection.`timer`
`(package private) Disposable`	FlowableFromCompletable.FromCompletableObserver.`upstream`
`(package private) Disposable`	FlowableFromObservable.SubscriberObserver.`upstream`

Fields in io.reactivex.rxjava3.internal.operators.flowable with type parameters of type Disposable
Modifier and Type	Field	Description
`(package private) Consumer<? super Disposable>`	FlowableAutoConnect.`connection`
`(package private) java.util.concurrent.atomic.AtomicReference<Disposable>`	FlowableDebounce.DebounceSubscriber.`debouncer`
`(package private) java.util.concurrent.atomic.AtomicReference<Disposable>`	FlowableConcatWithMaybe.ConcatWithSubscriber.`otherDisposable`
`(package private) java.util.concurrent.atomic.AtomicReference<Disposable>`	FlowableConcatWithSingle.ConcatWithSubscriber.`otherDisposable`
`(package private) java.util.concurrent.atomic.AtomicReference<Disposable>`	FlowableInterval.IntervalSubscriber.`resource`
`(package private) java.util.concurrent.atomic.AtomicReference<Disposable>`	FlowableIntervalRange.IntervalRangeSubscriber.`resource`
`(package private) java.util.concurrent.atomic.AtomicReference<Disposable>`	FlowableBufferTimed.BufferExactUnboundedSubscriber.`timer`

Methods in io.reactivex.rxjava3.internal.operators.flowable with parameters of type Disposable
Modifier and Type	Method	Description
`void`	FlowableRefCount.RefConnection.`accept(Disposable t)`
`void`	FlowableReplay.MulticastFlowable.DisposableConsumer.`accept(Disposable r)`
`(package private) void`	FlowableBufferBoundary.BufferBoundarySubscriber.`boundaryError(Disposable subscriber, java.lang.Throwable ex)`
`void`	FlowableConcatWithCompletable.ConcatWithSubscriber.`onSubscribe(Disposable d)`
`void`	FlowableConcatWithMaybe.ConcatWithSubscriber.`onSubscribe(Disposable d)`
`void`	FlowableConcatWithSingle.ConcatWithSubscriber.`onSubscribe(Disposable d)`
`void`	FlowableFlatMapCompletable.FlatMapCompletableMainSubscriber.InnerConsumer.`onSubscribe(Disposable d)`
`void`	FlowableFlatMapCompletableCompletable.FlatMapCompletableMainSubscriber.InnerObserver.`onSubscribe(Disposable d)`
`void`	FlowableFlatMapMaybe.FlatMapMaybeSubscriber.InnerObserver.`onSubscribe(Disposable d)`
`void`	FlowableFlatMapSingle.FlatMapSingleSubscriber.InnerObserver.`onSubscribe(Disposable d)`
`void`	FlowableFromCompletable.FromCompletableObserver.`onSubscribe(Disposable d)`
`void`	FlowableFromObservable.SubscriberObserver.`onSubscribe(Disposable d)`
`void`	FlowableMergeWithCompletable.MergeWithSubscriber.OtherObserver.`onSubscribe(Disposable d)`
`void`	FlowableMergeWithMaybe.MergeWithObserver.OtherObserver.`onSubscribe(Disposable d)`
`void`	FlowableMergeWithSingle.MergeWithObserver.OtherObserver.`onSubscribe(Disposable d)`
`void`	FlowableCreate.BaseEmitter.`setDisposable(Disposable d)`
`void`	FlowableCreate.SerializedEmitter.`setDisposable(Disposable d)`
`void`	FlowableDebounceTimed.DebounceEmitter.`setResource(Disposable d)`
`void`	FlowableInterval.IntervalSubscriber.`setResource(Disposable d)`
`void`	FlowableIntervalRange.IntervalRangeSubscriber.`setResource(Disposable d)`
`void`	FlowableTimer.TimerSubscriber.`setResource(Disposable d)`

Method parameters in io.reactivex.rxjava3.internal.operators.flowable with type arguments of type Disposable
Modifier and Type	Method	Description
`void`	FlowablePublish.`connect(Consumer<? super Disposable> connection)`
`void`	FlowableReplay.`connect(Consumer<? super Disposable> connection)`

Constructor parameters in io.reactivex.rxjava3.internal.operators.flowable with type arguments of type Disposable
Constructor	Description
`FlowableAutoConnect(ConnectableFlowable<? extends T> source, int numberOfSubscribers, Consumer<? super Disposable> connection)`

Uses of Disposable in io.reactivex.rxjava3.internal.operators.maybe

Classes in io.reactivex.rxjava3.internal.operators.maybe that implement Disposable
Modifier and Type	Class	Description
`(package private) static class`	`MaybeCache.CacheDisposable<T>`
`class`	`MaybeCallbackObserver<T>`	MaybeObserver that delegates the onSuccess, onError and onComplete method calls to callbacks.
`(package private) static class`	`MaybeContains.ContainsMaybeObserver`
`(package private) static class`	`MaybeCount.CountMaybeObserver`
`(package private) static class`	`MaybeCreate.Emitter<T>`
`(package private) static class`	`MaybeDelay.DelayMaybeObserver<T>`
`(package private) static class`	`MaybeDelayOtherPublisher.DelayMaybeObserver<T,U>`
`(package private) static class`	`MaybeDelaySubscriptionOtherPublisher.OtherSubscriber<T>`
`(package private) static class`	`MaybeDelayWithCompletable.OtherObserver<T>`
`(package private) static class`	`MaybeDematerialize.DematerializeObserver<T,R>`
`(package private) static class`	`MaybeDetach.DetachMaybeObserver<T>`
`(package private) static class`	`MaybeDoAfterSuccess.DoAfterObserver<T>`
`(package private) static class`	`MaybeDoFinally.DoFinallyObserver<T>`
`(package private) static class`	`MaybeDoOnEvent.DoOnEventMaybeObserver<T>`
`(package private) static class`	`MaybeDoOnLifecycle.MaybeLifecycleObserver<T>`
`(package private) static class`	`MaybeEqualSingle.EqualCoordinator<T>`
`(package private) static class`	`MaybeFilter.FilterMaybeObserver<T>`
`(package private) static class`	`MaybeFilterSingle.FilterMaybeObserver<T>`
`(package private) static class`	`MaybeFlatMapBiSelector.FlatMapBiMainObserver<T,U,R>`
`(package private) static class`	`MaybeFlatMapCompletable.FlatMapCompletableObserver<T>`
`(package private) static class`	`MaybeFlatMapIterableObservable.FlatMapIterableObserver<T,R>`
`(package private) static class`	`MaybeFlatMapNotification.FlatMapMaybeObserver<T,R>`
`(package private) static class`	`MaybeFlatMapSingle.FlatMapMaybeObserver<T,R>`
`(package private) static class`	`MaybeFlatten.FlatMapMaybeObserver<T,R>`
`(package private) static class`	`MaybeFromCompletable.FromCompletableObserver<T>`
`(package private) static class`	`MaybeFromSingle.FromSingleObserver<T>`
`(package private) static class`	`MaybeHide.HideMaybeObserver<T>`
`(package private) static class`	`MaybeIgnoreElement.IgnoreMaybeObserver<T>`
`(package private) static class`	`MaybeIgnoreElementCompletable.IgnoreMaybeObserver<T>`
`(package private) static class`	`MaybeIsEmpty.IsEmptyMaybeObserver<T>`
`(package private) static class`	`MaybeIsEmptySingle.IsEmptyMaybeObserver<T>`
`(package private) static class`	`MaybeMap.MapMaybeObserver<T,R>`
`(package private) static class`	`MaybeObserveOn.ObserveOnMaybeObserver<T>`
`static class`	`MaybeOnErrorComplete.OnErrorCompleteMultiObserver<T>`
`(package private) static class`	`MaybeOnErrorNext.OnErrorNextMaybeObserver<T>`
`(package private) static class`	`MaybeOnErrorReturn.OnErrorReturnMaybeObserver<T>`
`(package private) static class`	`MaybePeek.MaybePeekObserver<T>`
`(package private) static class`	`MaybeSubscribeOn.SubscribeOnMaybeObserver<T>`
`(package private) static class`	`MaybeSwitchIfEmpty.SwitchIfEmptyMaybeObserver<T>`
`(package private) static class`	`MaybeSwitchIfEmptySingle.SwitchIfEmptyMaybeObserver<T>`
`(package private) static class`	`MaybeTakeUntilMaybe.TakeUntilMainMaybeObserver<T,U>`
`(package private) static class`	`MaybeTakeUntilPublisher.TakeUntilMainMaybeObserver<T,U>`
`(package private) static class`	`MaybeTimeInterval.TimeIntervalMaybeObserver<T>`
`(package private) static class`	`MaybeTimeoutMaybe.TimeoutMainMaybeObserver<T,U>`
`(package private) static class`	`MaybeTimeoutPublisher.TimeoutMainMaybeObserver<T,U>`
`(package private) static class`	`MaybeTimer.TimerDisposable`
`(package private) static class`	`MaybeToObservable.MaybeToObservableObserver<T>`
`(package private) static class`	`MaybeToSingle.ToSingleMaybeSubscriber<T>`
`(package private) static class`	`MaybeUnsubscribeOn.UnsubscribeOnMaybeObserver<T>`
`(package private) static class`	`MaybeUsing.UsingObserver<T,D>`
`(package private) static class`	`MaybeZipArray.ZipCoordinator<T,R>`

Fields in io.reactivex.rxjava3.internal.operators.maybe declared as Disposable
Modifier and Type	Field	Description
`(package private) Disposable`	MaybeUnsubscribeOn.UnsubscribeOnMaybeObserver.`ds`
`(package private) Disposable`	MaybeAmb.AmbMaybeObserver.`upstream`
`(package private) Disposable`	MaybeContains.ContainsMaybeObserver.`upstream`
`(package private) Disposable`	MaybeCount.CountMaybeObserver.`upstream`
`(package private) Disposable`	MaybeDelayOtherPublisher.DelayMaybeObserver.`upstream`
`(package private) Disposable`	MaybeDematerialize.DematerializeObserver.`upstream`
`(package private) Disposable`	MaybeDetach.DetachMaybeObserver.`upstream`
`(package private) Disposable`	MaybeDoAfterSuccess.DoAfterObserver.`upstream`
`(package private) Disposable`	MaybeDoFinally.DoFinallyObserver.`upstream`
`(package private) Disposable`	MaybeDoOnEvent.DoOnEventMaybeObserver.`upstream`
`(package private) Disposable`	MaybeDoOnLifecycle.MaybeLifecycleObserver.`upstream`
`(package private) Disposable`	MaybeFilter.FilterMaybeObserver.`upstream`
`(package private) Disposable`	MaybeFilterSingle.FilterMaybeObserver.`upstream`
`(package private) Disposable`	MaybeFlatMapIterableFlowable.FlatMapIterableObserver.`upstream`
`(package private) Disposable`	MaybeFlatMapIterableObservable.FlatMapIterableObserver.`upstream`
`(package private) Disposable`	MaybeFlatMapNotification.FlatMapMaybeObserver.`upstream`
`(package private) Disposable`	MaybeFlatten.FlatMapMaybeObserver.`upstream`
`(package private) Disposable`	MaybeFromCompletable.FromCompletableObserver.`upstream`
`(package private) Disposable`	MaybeFromSingle.FromSingleObserver.`upstream`
`(package private) Disposable`	MaybeHide.HideMaybeObserver.`upstream`
`(package private) Disposable`	MaybeIgnoreElement.IgnoreMaybeObserver.`upstream`
`(package private) Disposable`	MaybeIgnoreElementCompletable.IgnoreMaybeObserver.`upstream`
`(package private) Disposable`	MaybeIsEmpty.IsEmptyMaybeObserver.`upstream`
`(package private) Disposable`	MaybeIsEmptySingle.IsEmptyMaybeObserver.`upstream`
`(package private) Disposable`	MaybeMap.MapMaybeObserver.`upstream`
`(package private) Disposable`	MaybeOnErrorComplete.OnErrorCompleteMultiObserver.`upstream`
`(package private) Disposable`	MaybeOnErrorReturn.OnErrorReturnMaybeObserver.`upstream`
`(package private) Disposable`	MaybePeek.MaybePeekObserver.`upstream`
`(package private) Disposable`	MaybeTimeInterval.TimeIntervalMaybeObserver.`upstream`
`(package private) Disposable`	MaybeToFlowable.MaybeToFlowableSubscriber.`upstream`
`(package private) Disposable`	MaybeToObservable.MaybeToObservableObserver.`upstream`
`(package private) Disposable`	MaybeToSingle.ToSingleMaybeSubscriber.`upstream`
`(package private) Disposable`	MaybeUsing.UsingObserver.`upstream`

Fields in io.reactivex.rxjava3.internal.operators.maybe with type parameters of type Disposable
Modifier and Type	Field	Description
`(package private) Consumer<? super Disposable>`	MaybeDoOnLifecycle.MaybeLifecycleObserver.`onSubscribe`
`(package private) Consumer<? super Disposable>`	MaybeDoOnLifecycle.`onSubscribe`
`(package private) Consumer<? super Disposable>`	MaybePeek.`onSubscribeCall`
`(package private) java.util.concurrent.atomic.AtomicReference<Disposable>`	MaybeDelayWithCompletable.DelayWithMainObserver.`parent`
`(package private) java.util.concurrent.atomic.AtomicReference<Disposable>`	MaybeFlatMapSingle.FlatMapSingleObserver.`parent`
`(package private) java.util.concurrent.atomic.AtomicReference<Disposable>`	MaybeSwitchIfEmpty.SwitchIfEmptyMaybeObserver.OtherMaybeObserver.`parent`
`(package private) java.util.concurrent.atomic.AtomicReference<Disposable>`	MaybeSwitchIfEmptySingle.SwitchIfEmptyMaybeObserver.OtherSingleObserver.`parent`
`(package private) java.util.concurrent.atomic.AtomicReference<Disposable>`	MaybeOnErrorNext.OnErrorNextMaybeObserver.NextMaybeObserver.`upstream`

Methods in io.reactivex.rxjava3.internal.operators.maybe with parameters of type Disposable
Modifier and Type	Method	Description
`void`	MaybeAmb.AmbMaybeObserver.`onSubscribe(Disposable d)`
`void`	MaybeCache.`onSubscribe(Disposable d)`
`void`	MaybeCallbackObserver.`onSubscribe(Disposable d)`
`void`	MaybeConcatArray.ConcatMaybeObserver.`onSubscribe(Disposable d)`
`void`	MaybeConcatArrayDelayError.ConcatMaybeObserver.`onSubscribe(Disposable d)`
`void`	MaybeConcatIterable.ConcatMaybeObserver.`onSubscribe(Disposable d)`
`void`	MaybeContains.ContainsMaybeObserver.`onSubscribe(Disposable d)`
`void`	MaybeCount.CountMaybeObserver.`onSubscribe(Disposable d)`
`void`	MaybeDelay.DelayMaybeObserver.`onSubscribe(Disposable d)`
`void`	MaybeDelayOtherPublisher.DelayMaybeObserver.`onSubscribe(Disposable d)`
`void`	MaybeDelaySubscriptionOtherPublisher.DelayMaybeObserver.`onSubscribe(Disposable d)`
`void`	MaybeDelayWithCompletable.DelayWithMainObserver.`onSubscribe(Disposable d)`
`void`	MaybeDelayWithCompletable.OtherObserver.`onSubscribe(Disposable d)`
`void`	MaybeDematerialize.DematerializeObserver.`onSubscribe(Disposable d)`
`void`	MaybeDetach.DetachMaybeObserver.`onSubscribe(Disposable d)`
`void`	MaybeDoAfterSuccess.DoAfterObserver.`onSubscribe(Disposable d)`
`void`	MaybeDoFinally.DoFinallyObserver.`onSubscribe(Disposable d)`
`void`	MaybeDoOnEvent.DoOnEventMaybeObserver.`onSubscribe(Disposable d)`
`void`	MaybeDoOnLifecycle.MaybeLifecycleObserver.`onSubscribe(@NonNull Disposable d)`
`void`	MaybeDoOnTerminate.DoOnTerminate.`onSubscribe(Disposable d)`
`void`	MaybeEqualSingle.EqualObserver.`onSubscribe(Disposable d)`
`void`	MaybeFilter.FilterMaybeObserver.`onSubscribe(Disposable d)`
`void`	MaybeFilterSingle.FilterMaybeObserver.`onSubscribe(Disposable d)`
`void`	MaybeFlatMapBiSelector.FlatMapBiMainObserver.InnerObserver.`onSubscribe(Disposable d)`
`void`	MaybeFlatMapBiSelector.FlatMapBiMainObserver.`onSubscribe(Disposable d)`
`void`	MaybeFlatMapCompletable.FlatMapCompletableObserver.`onSubscribe(Disposable d)`
`void`	MaybeFlatMapIterableFlowable.FlatMapIterableObserver.`onSubscribe(Disposable d)`
`void`	MaybeFlatMapIterableObservable.FlatMapIterableObserver.`onSubscribe(Disposable d)`
`void`	MaybeFlatMapNotification.FlatMapMaybeObserver.InnerObserver.`onSubscribe(Disposable d)`
`void`	MaybeFlatMapNotification.FlatMapMaybeObserver.`onSubscribe(Disposable d)`
`void`	MaybeFlatMapSingle.FlatMapMaybeObserver.`onSubscribe(Disposable d)`
`void`	MaybeFlatMapSingle.FlatMapSingleObserver.`onSubscribe(Disposable d)`
`void`	MaybeFlatten.FlatMapMaybeObserver.InnerObserver.`onSubscribe(Disposable d)`
`void`	MaybeFlatten.FlatMapMaybeObserver.`onSubscribe(Disposable d)`
`void`	MaybeFromCompletable.FromCompletableObserver.`onSubscribe(Disposable d)`
`void`	MaybeFromSingle.FromSingleObserver.`onSubscribe(Disposable d)`
`void`	MaybeHide.HideMaybeObserver.`onSubscribe(Disposable d)`
`void`	MaybeIgnoreElement.IgnoreMaybeObserver.`onSubscribe(Disposable d)`
`void`	MaybeIgnoreElementCompletable.IgnoreMaybeObserver.`onSubscribe(Disposable d)`
`void`	MaybeIsEmpty.IsEmptyMaybeObserver.`onSubscribe(Disposable d)`
`void`	MaybeIsEmptySingle.IsEmptyMaybeObserver.`onSubscribe(Disposable d)`
`void`	MaybeMap.MapMaybeObserver.`onSubscribe(Disposable d)`
`void`	MaybeMergeArray.MergeMaybeObserver.`onSubscribe(Disposable d)`
`void`	MaybeObserveOn.ObserveOnMaybeObserver.`onSubscribe(Disposable d)`
`void`	MaybeOnErrorComplete.OnErrorCompleteMultiObserver.`onSubscribe(Disposable d)`
`void`	MaybeOnErrorNext.OnErrorNextMaybeObserver.NextMaybeObserver.`onSubscribe(Disposable d)`
`void`	MaybeOnErrorNext.OnErrorNextMaybeObserver.`onSubscribe(Disposable d)`
`void`	MaybeOnErrorReturn.OnErrorReturnMaybeObserver.`onSubscribe(Disposable d)`
`void`	MaybePeek.MaybePeekObserver.`onSubscribe(Disposable d)`
`void`	MaybeSubscribeOn.SubscribeOnMaybeObserver.`onSubscribe(Disposable d)`
`void`	MaybeSwitchIfEmpty.SwitchIfEmptyMaybeObserver.`onSubscribe(Disposable d)`
`void`	MaybeSwitchIfEmpty.SwitchIfEmptyMaybeObserver.OtherMaybeObserver.`onSubscribe(Disposable d)`
`void`	MaybeSwitchIfEmptySingle.SwitchIfEmptyMaybeObserver.`onSubscribe(Disposable d)`
`void`	MaybeSwitchIfEmptySingle.SwitchIfEmptyMaybeObserver.OtherSingleObserver.`onSubscribe(Disposable d)`
`void`	MaybeTakeUntilMaybe.TakeUntilMainMaybeObserver.`onSubscribe(Disposable d)`
`void`	MaybeTakeUntilMaybe.TakeUntilMainMaybeObserver.TakeUntilOtherMaybeObserver.`onSubscribe(Disposable d)`
`void`	MaybeTakeUntilPublisher.TakeUntilMainMaybeObserver.`onSubscribe(Disposable d)`
`void`	MaybeTimeInterval.TimeIntervalMaybeObserver.`onSubscribe(@NonNull Disposable d)`
`void`	MaybeTimeoutMaybe.TimeoutFallbackMaybeObserver.`onSubscribe(Disposable d)`
`void`	MaybeTimeoutMaybe.TimeoutMainMaybeObserver.`onSubscribe(Disposable d)`
`void`	MaybeTimeoutMaybe.TimeoutOtherMaybeObserver.`onSubscribe(Disposable d)`
`void`	MaybeTimeoutPublisher.TimeoutFallbackMaybeObserver.`onSubscribe(Disposable d)`
`void`	MaybeTimeoutPublisher.TimeoutMainMaybeObserver.`onSubscribe(Disposable d)`
`void`	MaybeToFlowable.MaybeToFlowableSubscriber.`onSubscribe(Disposable d)`
`void`	MaybeToObservable.MaybeToObservableObserver.`onSubscribe(Disposable d)`
`void`	MaybeToSingle.ToSingleMaybeSubscriber.`onSubscribe(Disposable d)`
`void`	MaybeUnsubscribeOn.UnsubscribeOnMaybeObserver.`onSubscribe(Disposable d)`
`void`	MaybeUsing.UsingObserver.`onSubscribe(Disposable d)`
`void`	MaybeZipArray.ZipMaybeObserver.`onSubscribe(Disposable d)`
`void`	MaybeCreate.Emitter.`setDisposable(Disposable d)`
`(package private) void`	MaybeTimer.TimerDisposable.`setFuture(Disposable d)`

Constructor parameters in io.reactivex.rxjava3.internal.operators.maybe with type arguments of type Disposable
Constructor	Description
`DelayWithMainObserver(java.util.concurrent.atomic.AtomicReference<Disposable> parent, MaybeObserver<? super T> downstream)`
`FlatMapSingleObserver(java.util.concurrent.atomic.AtomicReference<Disposable> parent, MaybeObserver<? super R> downstream)`
`MaybeDoOnLifecycle(Maybe<T> upstream, Consumer<? super Disposable> onSubscribe, Action onDispose)`
`MaybeLifecycleObserver(MaybeObserver<? super T> downstream, Consumer<? super Disposable> onSubscribe, Action onDispose)`
`MaybePeek(MaybeSource<T> source, Consumer<? super Disposable> onSubscribeCall, Consumer<? super T> onSuccessCall, Consumer<? super java.lang.Throwable> onErrorCall, Action onCompleteCall, Action onAfterTerminate, Action onDispose)`
`NextMaybeObserver(MaybeObserver<? super T> actual, java.util.concurrent.atomic.AtomicReference<Disposable> d)`
`OtherMaybeObserver(MaybeObserver<? super T> actual, java.util.concurrent.atomic.AtomicReference<Disposable> parent)`
`OtherSingleObserver(SingleObserver<? super T> actual, java.util.concurrent.atomic.AtomicReference<Disposable> parent)`

Uses of Disposable in io.reactivex.rxjava3.internal.operators.mixed

Classes in io.reactivex.rxjava3.internal.operators.mixed that implement Disposable
Modifier and Type	Class	Description
`(package private) static class`	`CompletableAndThenObservable.AndThenObservableObserver<R>`
`class`	`ConcatMapXMainObserver<T>`	Base class for implementing concatMapX main observers.
`(package private) static class`	`FlowableConcatMapCompletable.ConcatMapCompletableObserver<T>`
`(package private) static class`	`FlowableSwitchMapCompletable.SwitchMapCompletableObserver<T>`
`class`	`MaterializeSingleObserver<T>`	A consumer that implements the consumer types of Maybe, Single and Completable and turns their signals into Notifications for a SingleObserver.
`(package private) static class`	`MaybeFlatMapObservable.FlatMapObserver<T,R>`
`(package private) static class`	`ObservableConcatMapCompletable.ConcatMapCompletableObserver<T>`
`(package private) static class`	`ObservableConcatMapMaybe.ConcatMapMaybeMainObserver<T,R>`
`(package private) static class`	`ObservableConcatMapSingle.ConcatMapSingleMainObserver<T,R>`
`(package private) static class`	`ObservableSwitchMapCompletable.SwitchMapCompletableObserver<T>`
`(package private) static class`	`ObservableSwitchMapMaybe.SwitchMapMaybeMainObserver<T,R>`
`(package private) static class`	`ObservableSwitchMapSingle.SwitchMapSingleMainObserver<T,R>`
`(package private) static class`	`SingleFlatMapObservable.FlatMapObserver<T,R>`

Fields in io.reactivex.rxjava3.internal.operators.mixed declared as Disposable
Modifier and Type	Field	Description
`(package private) Disposable`	CompletableAndThenPublisher.AndThenPublisherSubscriber.`upstream`
`(package private) Disposable`	ConcatMapXMainObserver.`upstream`
`(package private) Disposable`	MaterializeSingleObserver.`upstream`
`(package private) Disposable`	MaybeFlatMapPublisher.FlatMapPublisherSubscriber.`upstream`
`(package private) Disposable`	ObservableSwitchMapCompletable.SwitchMapCompletableObserver.`upstream`
`(package private) Disposable`	ObservableSwitchMapMaybe.SwitchMapMaybeMainObserver.`upstream`
`(package private) Disposable`	ObservableSwitchMapSingle.SwitchMapSingleMainObserver.`upstream`

Methods in io.reactivex.rxjava3.internal.operators.mixed with parameters of type Disposable
Modifier and Type	Method	Description
`void`	CompletableAndThenObservable.AndThenObservableObserver.`onSubscribe(Disposable d)`
`void`	CompletableAndThenPublisher.AndThenPublisherSubscriber.`onSubscribe(Disposable d)`
`void`	ConcatMapXMainObserver.`onSubscribe(Disposable d)`
`void`	FlowableConcatMapCompletable.ConcatMapCompletableObserver.ConcatMapInnerObserver.`onSubscribe(Disposable d)`
`void`	FlowableConcatMapMaybe.ConcatMapMaybeSubscriber.ConcatMapMaybeObserver.`onSubscribe(Disposable d)`
`void`	FlowableConcatMapSingle.ConcatMapSingleSubscriber.ConcatMapSingleObserver.`onSubscribe(Disposable d)`
`void`	FlowableSwitchMapCompletable.SwitchMapCompletableObserver.SwitchMapInnerObserver.`onSubscribe(Disposable d)`
`void`	FlowableSwitchMapMaybe.SwitchMapMaybeSubscriber.SwitchMapMaybeObserver.`onSubscribe(Disposable d)`
`void`	FlowableSwitchMapSingle.SwitchMapSingleSubscriber.SwitchMapSingleObserver.`onSubscribe(Disposable d)`
`void`	MaterializeSingleObserver.`onSubscribe(Disposable d)`
`void`	MaybeFlatMapObservable.FlatMapObserver.`onSubscribe(Disposable d)`
`void`	MaybeFlatMapPublisher.FlatMapPublisherSubscriber.`onSubscribe(Disposable d)`
`void`	ObservableConcatMapCompletable.ConcatMapCompletableObserver.ConcatMapInnerObserver.`onSubscribe(Disposable d)`
`void`	ObservableConcatMapMaybe.ConcatMapMaybeMainObserver.ConcatMapMaybeObserver.`onSubscribe(Disposable d)`
`void`	ObservableConcatMapSingle.ConcatMapSingleMainObserver.ConcatMapSingleObserver.`onSubscribe(Disposable d)`
`void`	ObservableSwitchMapCompletable.SwitchMapCompletableObserver.`onSubscribe(Disposable d)`
`void`	ObservableSwitchMapCompletable.SwitchMapCompletableObserver.SwitchMapInnerObserver.`onSubscribe(Disposable d)`
`void`	ObservableSwitchMapMaybe.SwitchMapMaybeMainObserver.`onSubscribe(Disposable d)`
`void`	ObservableSwitchMapMaybe.SwitchMapMaybeMainObserver.SwitchMapMaybeObserver.`onSubscribe(Disposable d)`
`void`	ObservableSwitchMapSingle.SwitchMapSingleMainObserver.`onSubscribe(Disposable d)`
`void`	ObservableSwitchMapSingle.SwitchMapSingleMainObserver.SwitchMapSingleObserver.`onSubscribe(Disposable d)`
`void`	SingleFlatMapObservable.FlatMapObserver.`onSubscribe(Disposable d)`

Uses of Disposable in io.reactivex.rxjava3.internal.operators.observable

Classes in io.reactivex.rxjava3.internal.operators.observable that implement Disposable
Modifier and Type	Class	Description
`(package private) static class`	`BlockingObservableIterable.BlockingObservableIterator<T>`
`(package private) static class`	`BlockingObservableLatest.BlockingObservableLatestIterator<T>`
`(package private) static class`	`BlockingObservableNext.NextObserver<T>`
`(package private) static class`	`ObservableAll.AllObserver<T>`
`(package private) static class`	`ObservableAllSingle.AllObserver<T>`
`(package private) static class`	`ObservableAmb.AmbCoordinator<T>`
`(package private) static class`	`ObservableAny.AnyObserver<T>`
`(package private) static class`	`ObservableAnySingle.AnyObserver<T>`
`(package private) static class`	`ObservableBuffer.BufferExactObserver<T,U extends java.util.Collection<? super T>>`
`(package private) static class`	`ObservableBuffer.BufferSkipObserver<T,U extends java.util.Collection<? super T>>`
`(package private) static class`	`ObservableBufferBoundary.BufferBoundaryObserver<T,C extends java.util.Collection<? super T>,Open,Close>`
`(package private) static class`	`ObservableBufferBoundary.BufferBoundaryObserver.BufferOpenObserver<Open>`
`(package private) static class`	`ObservableBufferBoundary.BufferCloseObserver<T,C extends java.util.Collection<? super T>>`
`(package private) static class`	`ObservableBufferExactBoundary.BufferBoundaryObserver<T,U extends java.util.Collection<? super T>,B>`
`(package private) static class`	`ObservableBufferExactBoundary.BufferExactBoundaryObserver<T,U extends java.util.Collection<? super T>,B>`
`(package private) static class`	`ObservableBufferTimed.BufferExactBoundedObserver<T,U extends java.util.Collection<? super T>>`
`(package private) static class`	`ObservableBufferTimed.BufferExactUnboundedObserver<T,U extends java.util.Collection<? super T>>`
`(package private) static class`	`ObservableBufferTimed.BufferSkipBoundedObserver<T,U extends java.util.Collection<? super T>>`
`(package private) static class`	`ObservableCache.CacheDisposable<T>`	Hosts the downstream consumer and its current requested and replay states.
`(package private) static class`	`ObservableCollect.CollectObserver<T,U>`
`(package private) static class`	`ObservableCollectSingle.CollectObserver<T,U>`
`(package private) static class`	`ObservableCombineLatest.LatestCoordinator<T,R>`
`(package private) static class`	`ObservableConcatMap.ConcatMapDelayErrorObserver<T,R>`
`(package private) static class`	`ObservableConcatMap.SourceObserver<T,U>`
`(package private) static class`	`ObservableConcatMapEager.ConcatMapEagerMainObserver<T,R>`
`(package private) static class`	`ObservableConcatMapScheduler.ConcatMapDelayErrorObserver<T,R>`
`(package private) static class`	`ObservableConcatMapScheduler.ConcatMapObserver<T,U>`
`(package private) static class`	`ObservableConcatWithCompletable.ConcatWithObserver<T>`
`(package private) static class`	`ObservableConcatWithMaybe.ConcatWithObserver<T>`
`(package private) static class`	`ObservableConcatWithSingle.ConcatWithObserver<T>`
`(package private) static class`	`ObservableCount.CountObserver`
`(package private) static class`	`ObservableCountSingle.CountObserver`
`(package private) static class`	`ObservableCreate.CreateEmitter<T>`
`(package private) static class`	`ObservableDebounce.DebounceObserver<T,U>`
`(package private) static class`	`ObservableDebounce.DebounceObserver.DebounceInnerObserver<T,U>`
`(package private) static class`	`ObservableDebounceTimed.DebounceEmitter<T>`
`(package private) static class`	`ObservableDebounceTimed.DebounceTimedObserver<T>`
`(package private) static class`	`ObservableDelay.DelayObserver<T>`
`(package private) static class`	`ObservableDematerialize.DematerializeObserver<T,R>`
`(package private) static class`	`ObservableDetach.DetachObserver<T>`
`(package private) static class`	`ObservableDistinct.DistinctObserver<T,K>`
`(package private) static class`	`ObservableDistinctUntilChanged.DistinctUntilChangedObserver<T,K>`
`(package private) static class`	`ObservableDoAfterNext.DoAfterObserver<T>`
`(package private) static class`	`ObservableDoFinally.DoFinallyObserver<T>`
`(package private) static class`	`ObservableDoOnEach.DoOnEachObserver<T>`
`(package private) static class`	`ObservableElementAt.ElementAtObserver<T>`
`(package private) static class`	`ObservableElementAtMaybe.ElementAtObserver<T>`
`(package private) static class`	`ObservableElementAtSingle.ElementAtObserver<T>`
`(package private) static class`	`ObservableFilter.FilterObserver<T>`
`(package private) static class`	`ObservableFlatMap.MergeObserver<T,U>`
`(package private) static class`	`ObservableFlatMapCompletable.FlatMapCompletableMainObserver<T>`
`(package private) class`	`ObservableFlatMapCompletable.FlatMapCompletableMainObserver.InnerObserver`
`(package private) static class`	`ObservableFlatMapCompletableCompletable.FlatMapCompletableMainObserver<T>`
`(package private) class`	`ObservableFlatMapCompletableCompletable.FlatMapCompletableMainObserver.InnerObserver`
`(package private) static class`	`ObservableFlatMapMaybe.FlatMapMaybeObserver<T,R>`
`(package private) class`	`ObservableFlatMapMaybe.FlatMapMaybeObserver.InnerObserver`
`(package private) static class`	`ObservableFlatMapSingle.FlatMapSingleObserver<T,R>`
`(package private) class`	`ObservableFlatMapSingle.FlatMapSingleObserver.InnerObserver`
`(package private) static class`	`ObservableFlattenIterable.FlattenIterableObserver<T,R>`
`(package private) static class`	`ObservableFromArray.FromArrayDisposable<T>`
`static class`	`ObservableFromCompletable.FromCompletableObserver<T>`
`(package private) static class`	`ObservableFromIterable.FromIterableDisposable<T>`
`(package private) static class`	`ObservableFromPublisher.PublisherSubscriber<T>`
`(package private) static class`	`ObservableGenerate.GeneratorDisposable<T,S>`
`static class`	`ObservableGroupBy.GroupByObserver<T,K,V>`
`(package private) static class`	`ObservableGroupBy.State<T,K>`
`(package private) static class`	`ObservableGroupJoin.GroupJoinDisposable<TLeft,TRight,TLeftEnd,TRightEnd,R>`
`(package private) static class`	`ObservableGroupJoin.LeftRightEndObserver`
`(package private) static class`	`ObservableGroupJoin.LeftRightObserver`
`(package private) static class`	`ObservableHide.HideDisposable<T>`
`(package private) static class`	`ObservableIgnoreElements.IgnoreObservable<T>`
`(package private) static class`	`ObservableIgnoreElementsCompletable.IgnoreObservable<T>`
`(package private) static class`	`ObservableInterval.IntervalObserver`
`(package private) static class`	`ObservableIntervalRange.IntervalRangeObserver`
`(package private) static class`	`ObservableJoin.JoinDisposable<TLeft,TRight,TLeftEnd,TRightEnd,R>`
`(package private) static class`	`ObservableLastMaybe.LastObserver<T>`
`(package private) static class`	`ObservableLastSingle.LastObserver<T>`
`(package private) static class`	`ObservableMap.MapObserver<T,U>`
`(package private) static class`	`ObservableMapNotification.MapNotificationObserver<T,R>`
`(package private) static class`	`ObservableMaterialize.MaterializeObserver<T>`
`(package private) static class`	`ObservableMergeWithCompletable.MergeWithObserver<T>`
`(package private) static class`	`ObservableMergeWithMaybe.MergeWithObserver<T>`
`(package private) static class`	`ObservableMergeWithSingle.MergeWithObserver<T>`
`(package private) static class`	`ObservableObserveOn.ObserveOnObserver<T>`
`static class`	`ObservableOnErrorComplete.OnErrorCompleteObserver<T>`
`(package private) static class`	`ObservableOnErrorReturn.OnErrorReturnObserver<T>`
`(package private) static class`	`ObservablePublish.InnerDisposable<T>`	Intercepts the dispose signal from the downstream and removes itself from the connection's observers array at most once.
`(package private) static class`	`ObservablePublish.PublishConnection<T>`
`(package private) static class`	`ObservablePublishSelector.TargetObserver<R>`
`(package private) static class`	`ObservableRange.RangeDisposable`
`(package private) static class`	`ObservableRangeLong.RangeDisposable`
`(package private) static class`	`ObservableReduceMaybe.ReduceObserver<T>`
`(package private) static class`	`ObservableReduceSeedSingle.ReduceSeedObserver<T,R>`
`(package private) static class`	`ObservableRefCount.RefCountObserver<T>`
`(package private) static class`	`ObservableRepeatWhen.RepeatWhenObserver<T>`
`(package private) static class`	`ObservableReplay.InnerDisposable<T>`	A Disposable that manages the disposed state of a child Observer in thread-safe manner.
`(package private) static class`	`ObservableReplay.ReplayObserver<T>`
`(package private) static class`	`ObservableRetryWhen.RepeatWhenObserver<T>`
`(package private) static class`	`ObservableSampleTimed.SampleTimedEmitLast<T>`
`(package private) static class`	`ObservableSampleTimed.SampleTimedNoLast<T>`
`(package private) static class`	`ObservableSampleTimed.SampleTimedObserver<T>`
`(package private) static class`	`ObservableSampleWithObservable.SampleMainEmitLast<T>`
`(package private) static class`	`ObservableSampleWithObservable.SampleMainNoLast<T>`
`(package private) static class`	`ObservableSampleWithObservable.SampleMainObserver<T>`
`static class`	`ObservableScalarXMap.ScalarDisposable<T>`	Represents a Disposable that signals one onNext followed by an onComplete.
`(package private) static class`	`ObservableScan.ScanObserver<T>`
`(package private) static class`	`ObservableScanSeed.ScanSeedObserver<T,R>`
`(package private) static class`	`ObservableSequenceEqual.EqualCoordinator<T>`
`(package private) static class`	`ObservableSequenceEqualSingle.EqualCoordinator<T>`
`(package private) static class`	`ObservableSingleMaybe.SingleElementObserver<T>`
`(package private) static class`	`ObservableSingleSingle.SingleElementObserver<T>`
`(package private) static class`	`ObservableSkip.SkipObserver<T>`
`(package private) static class`	`ObservableSkipLast.SkipLastObserver<T>`
`(package private) static class`	`ObservableSkipLastTimed.SkipLastTimedObserver<T>`
`(package private) static class`	`ObservableSkipWhile.SkipWhileObserver<T>`
`(package private) static class`	`ObservableSubscribeOn.SubscribeOnObserver<T>`
`(package private) static class`	`ObservableSwitchMap.SwitchMapObserver<T,R>`
`(package private) static class`	`ObservableTake.TakeObserver<T>`
`(package private) static class`	`ObservableTakeLast.TakeLastObserver<T>`
`(package private) static class`	`ObservableTakeLastOne.TakeLastOneObserver<T>`
`(package private) static class`	`ObservableTakeLastTimed.TakeLastTimedObserver<T>`
`(package private) static class`	`ObservableTakeUntil.TakeUntilMainObserver<T,U>`
`(package private) static class`	`ObservableTakeUntilPredicate.TakeUntilPredicateObserver<T>`
`(package private) static class`	`ObservableTakeWhile.TakeWhileObserver<T>`
`(package private) static class`	`ObservableThrottleFirstTimed.DebounceTimedObserver<T>`
`(package private) static class`	`ObservableThrottleLatest.ThrottleLatestObserver<T>`
`(package private) static class`	`ObservableTimeInterval.TimeIntervalObserver<T>`
`(package private) static class`	`ObservableTimeout.TimeoutConsumer`
`(package private) static class`	`ObservableTimeout.TimeoutFallbackObserver<T>`
`(package private) static class`	`ObservableTimeout.TimeoutObserver<T>`
`(package private) static class`	`ObservableTimeoutTimed.TimeoutFallbackObserver<T>`
`(package private) static class`	`ObservableTimeoutTimed.TimeoutObserver<T>`
`(package private) static class`	`ObservableTimer.TimerObserver`
`(package private) static class`	`ObservableToList.ToListObserver<T,U extends java.util.Collection<? super T>>`
`(package private) static class`	`ObservableToListSingle.ToListObserver<T,U extends java.util.Collection<? super T>>`
`(package private) static class`	`ObservableUnsubscribeOn.UnsubscribeObserver<T>`
`(package private) static class`	`ObservableUsing.UsingObserver<T,D>`
`(package private) static class`	`ObservableWindow.WindowExactObserver<T>`
`(package private) static class`	`ObservableWindow.WindowSkipObserver<T>`
`(package private) static class`	`ObservableWindowBoundary.WindowBoundaryInnerObserver<T,B>`
`(package private) static class`	`ObservableWindowBoundary.WindowBoundaryMainObserver<T,B>`
`(package private) static class`	`ObservableWindowBoundarySelector.WindowBoundaryMainObserver<T,B,V>`
`(package private) static class`	`ObservableWindowBoundarySelector.WindowBoundaryMainObserver.WindowEndObserverIntercept<T,V>`
`(package private) static class`	`ObservableWindowTimed.AbstractWindowObserver<T>`
`(package private) static class`	`ObservableWindowTimed.WindowExactBoundedObserver<T>`
`(package private) static class`	`ObservableWindowTimed.WindowExactUnboundedObserver<T>`
`(package private) static class`	`ObservableWindowTimed.WindowSkipObserver<T>`
`(package private) static class`	`ObservableWithLatestFrom.WithLatestFromObserver<T,U,R>`
`(package private) static class`	`ObservableWithLatestFromMany.WithLatestFromObserver<T,R>`
`(package private) static class`	`ObservableZip.ZipCoordinator<T,R>`
`(package private) static class`	`ObservableZipIterable.ZipIterableObserver<T,U,V>`
`class`	`ObserverResourceWrapper<T>`

Fields in io.reactivex.rxjava3.internal.operators.observable declared as Disposable
Modifier and Type	Field	Description
`(package private) Disposable`	ObservableBufferExactBoundary.BufferExactBoundaryObserver.`other`
`(package private) Disposable`	ObservableBufferTimed.BufferExactBoundedObserver.`timer`
`(package private) Disposable`	ObservableRefCount.RefConnection.`timer`
`(package private) Disposable`	ObservableAll.AllObserver.`upstream`
`(package private) Disposable`	ObservableAllSingle.AllObserver.`upstream`
`(package private) Disposable`	ObservableAny.AnyObserver.`upstream`
`(package private) Disposable`	ObservableAnySingle.AnyObserver.`upstream`
`(package private) Disposable`	ObservableBuffer.BufferExactObserver.`upstream`
`(package private) Disposable`	ObservableBuffer.BufferSkipObserver.`upstream`
`(package private) Disposable`	ObservableBufferExactBoundary.BufferExactBoundaryObserver.`upstream`
`(package private) Disposable`	ObservableBufferTimed.BufferExactBoundedObserver.`upstream`
`(package private) Disposable`	ObservableBufferTimed.BufferExactUnboundedObserver.`upstream`
`(package private) Disposable`	ObservableBufferTimed.BufferSkipBoundedObserver.`upstream`
`(package private) Disposable`	ObservableCollect.CollectObserver.`upstream`
`(package private) Disposable`	ObservableCollectSingle.CollectObserver.`upstream`
`(package private) Disposable`	ObservableConcatMap.ConcatMapDelayErrorObserver.`upstream`
`(package private) Disposable`	ObservableConcatMap.SourceObserver.`upstream`
`(package private) Disposable`	ObservableConcatMapEager.ConcatMapEagerMainObserver.`upstream`
`(package private) Disposable`	ObservableConcatMapScheduler.ConcatMapDelayErrorObserver.`upstream`
`(package private) Disposable`	ObservableConcatMapScheduler.ConcatMapObserver.`upstream`
`(package private) Disposable`	ObservableCount.CountObserver.`upstream`
`(package private) Disposable`	ObservableCountSingle.CountObserver.`upstream`
`(package private) Disposable`	ObservableDebounce.DebounceObserver.`upstream`
`(package private) Disposable`	ObservableDebounceTimed.DebounceTimedObserver.`upstream`
`(package private) Disposable`	ObservableDelay.DelayObserver.`upstream`
`(package private) Disposable`	ObservableDematerialize.DematerializeObserver.`upstream`
`(package private) Disposable`	ObservableDetach.DetachObserver.`upstream`
`(package private) Disposable`	ObservableDoFinally.DoFinallyObserver.`upstream`
`(package private) Disposable`	ObservableDoOnEach.DoOnEachObserver.`upstream`
`(package private) Disposable`	ObservableElementAt.ElementAtObserver.`upstream`
`(package private) Disposable`	ObservableElementAtMaybe.ElementAtObserver.`upstream`
`(package private) Disposable`	ObservableElementAtSingle.ElementAtObserver.`upstream`
`(package private) Disposable`	ObservableFlatMap.MergeObserver.`upstream`
`(package private) Disposable`	ObservableFlatMapCompletable.FlatMapCompletableMainObserver.`upstream`
`(package private) Disposable`	ObservableFlatMapCompletableCompletable.FlatMapCompletableMainObserver.`upstream`
`(package private) Disposable`	ObservableFlatMapMaybe.FlatMapMaybeObserver.`upstream`
`(package private) Disposable`	ObservableFlatMapSingle.FlatMapSingleObserver.`upstream`
`(package private) Disposable`	ObservableFlattenIterable.FlattenIterableObserver.`upstream`
`(package private) Disposable`	ObservableFromCompletable.FromCompletableObserver.`upstream`
`(package private) Disposable`	ObservableGroupBy.GroupByObserver.`upstream`
`(package private) Disposable`	ObservableHide.HideDisposable.`upstream`
`(package private) Disposable`	ObservableIgnoreElements.IgnoreObservable.`upstream`
`(package private) Disposable`	ObservableIgnoreElementsCompletable.IgnoreObservable.`upstream`
`(package private) Disposable`	ObservableLastMaybe.LastObserver.`upstream`
`(package private) Disposable`	ObservableLastSingle.LastObserver.`upstream`
`(package private) Disposable`	ObservableMapNotification.MapNotificationObserver.`upstream`
`(package private) Disposable`	ObservableMaterialize.MaterializeObserver.`upstream`
`(package private) Disposable`	ObservableObserveOn.ObserveOnObserver.`upstream`
`(package private) Disposable`	ObservableOnErrorComplete.OnErrorCompleteObserver.`upstream`
`(package private) Disposable`	ObservableOnErrorReturn.OnErrorReturnObserver.`upstream`
`(package private) Disposable`	ObservablePublishSelector.TargetObserver.`upstream`
`(package private) Disposable`	ObservableReduceMaybe.ReduceObserver.`upstream`
`(package private) Disposable`	ObservableReduceSeedSingle.ReduceSeedObserver.`upstream`
`(package private) Disposable`	ObservableRefCount.RefCountObserver.`upstream`
`(package private) Disposable`	ObservableSampleTimed.SampleTimedObserver.`upstream`
`(package private) Disposable`	ObservableSampleWithObservable.SampleMainObserver.`upstream`
`(package private) Disposable`	ObservableScan.ScanObserver.`upstream`
`(package private) Disposable`	ObservableScanSeed.ScanSeedObserver.`upstream`
`(package private) Disposable`	ObservableSingleMaybe.SingleElementObserver.`upstream`
`(package private) Disposable`	ObservableSingleSingle.SingleElementObserver.`upstream`
`(package private) Disposable`	ObservableSkip.SkipObserver.`upstream`
`(package private) Disposable`	ObservableSkipLast.SkipLastObserver.`upstream`
`(package private) Disposable`	ObservableSkipLastTimed.SkipLastTimedObserver.`upstream`
`(package private) Disposable`	ObservableSkipUntil.SkipUntil.`upstream`
`(package private) Disposable`	ObservableSkipUntil.SkipUntilObserver.`upstream`
`(package private) Disposable`	ObservableSkipWhile.SkipWhileObserver.`upstream`
`(package private) Disposable`	ObservableSwitchMap.SwitchMapObserver.`upstream`
`(package private) Disposable`	ObservableTake.TakeObserver.`upstream`
`(package private) Disposable`	ObservableTakeLast.TakeLastObserver.`upstream`
`(package private) Disposable`	ObservableTakeLastOne.TakeLastOneObserver.`upstream`
`(package private) Disposable`	ObservableTakeLastTimed.TakeLastTimedObserver.`upstream`
`(package private) Disposable`	ObservableTakeUntilPredicate.TakeUntilPredicateObserver.`upstream`
`(package private) Disposable`	ObservableTakeWhile.TakeWhileObserver.`upstream`
`(package private) Disposable`	ObservableThrottleFirstTimed.DebounceTimedObserver.`upstream`
`(package private) Disposable`	ObservableThrottleLatest.ThrottleLatestObserver.`upstream`
`(package private) Disposable`	ObservableTimeInterval.TimeIntervalObserver.`upstream`
`(package private) Disposable`	ObservableToList.ToListObserver.`upstream`
`(package private) Disposable`	ObservableToListSingle.ToListObserver.`upstream`
`(package private) Disposable`	ObservableUnsubscribeOn.UnsubscribeObserver.`upstream`
`(package private) Disposable`	ObservableUsing.UsingObserver.`upstream`
`(package private) Disposable`	ObservableWindow.WindowExactObserver.`upstream`
`(package private) Disposable`	ObservableWindow.WindowSkipObserver.`upstream`
`(package private) Disposable`	ObservableWindowBoundarySelector.WindowBoundaryMainObserver.`upstream`
`(package private) Disposable`	ObservableWindowTimed.AbstractWindowObserver.`upstream`
`(package private) Disposable`	ObservableZipIterable.ZipIterableObserver.`upstream`

Fields in io.reactivex.rxjava3.internal.operators.observable with type parameters of type Disposable
Modifier and Type	Field	Description
`(package private) java.util.concurrent.atomic.AtomicReference<Disposable>`	ObservableTimeoutTimed.FallbackObserver.`arbiter`
`(package private) Consumer<? super Disposable>`	ObservableAutoConnect.`connection`
`(package private) java.util.concurrent.atomic.AtomicReference<Disposable>`	ObservableDebounce.DebounceObserver.`debouncer`
`(package private) java.util.concurrent.atomic.AtomicReference<Disposable>`	ObservableMergeWithCompletable.MergeWithObserver.`mainDisposable`
`(package private) java.util.concurrent.atomic.AtomicReference<Disposable>`	ObservableMergeWithMaybe.MergeWithObserver.`mainDisposable`
`(package private) java.util.concurrent.atomic.AtomicReference<Disposable>`	ObservableMergeWithSingle.MergeWithObserver.`mainDisposable`
`private Consumer<? super Disposable>`	ObservableDoOnLifecycle.`onSubscribe`
`(package private) java.util.concurrent.atomic.AtomicReference<Disposable>`	ObservableSampleWithObservable.SampleMainObserver.`other`
`(package private) java.util.concurrent.atomic.AtomicReference<Disposable>`	ObservableWithLatestFrom.WithLatestFromObserver.`other`
`(package private) java.util.concurrent.atomic.AtomicReference<Disposable>`	ObservablePublishSelector.SourceObserver.`target`
`(package private) java.util.concurrent.atomic.AtomicReference<Disposable>`	ObservableBufferTimed.BufferExactUnboundedObserver.`timer`
`(package private) java.util.concurrent.atomic.AtomicReference<Disposable>`	ObservableSampleTimed.SampleTimedObserver.`timer`
`(package private) java.util.concurrent.atomic.AtomicReference<Disposable>`	ObservableBufferBoundary.BufferBoundaryObserver.`upstream`
`(package private) java.util.concurrent.atomic.AtomicReference<Disposable>`	ObservablePublish.PublishConnection.`upstream`
`(package private) java.util.concurrent.atomic.AtomicReference<Disposable>`	ObservableRepeatWhen.RepeatWhenObserver.`upstream`
`(package private) java.util.concurrent.atomic.AtomicReference<Disposable>`	ObservableRetryWhen.RepeatWhenObserver.`upstream`
`(package private) java.util.concurrent.atomic.AtomicReference<Disposable>`	ObservableSubscribeOn.SubscribeOnObserver.`upstream`
`(package private) java.util.concurrent.atomic.AtomicReference<Disposable>`	ObservableTakeUntil.TakeUntilMainObserver.`upstream`
`(package private) java.util.concurrent.atomic.AtomicReference<Disposable>`	ObservableTimeout.TimeoutFallbackObserver.`upstream`
`(package private) java.util.concurrent.atomic.AtomicReference<Disposable>`	ObservableTimeout.TimeoutObserver.`upstream`
`(package private) java.util.concurrent.atomic.AtomicReference<Disposable>`	ObservableTimeoutTimed.TimeoutFallbackObserver.`upstream`
`(package private) java.util.concurrent.atomic.AtomicReference<Disposable>`	ObservableTimeoutTimed.TimeoutObserver.`upstream`
`(package private) java.util.concurrent.atomic.AtomicReference<Disposable>`	ObservableWindowBoundary.WindowBoundaryMainObserver.`upstream`
`(package private) java.util.concurrent.atomic.AtomicReference<Disposable>`	ObservableWindowBoundarySelector.WindowBoundaryMainObserver.WindowEndObserverIntercept.`upstream`
`(package private) java.util.concurrent.atomic.AtomicReference<Disposable>`	ObservableWithLatestFrom.WithLatestFromObserver.`upstream`
`(package private) java.util.concurrent.atomic.AtomicReference<Disposable>`	ObservableWithLatestFromMany.WithLatestFromObserver.`upstream`
`(package private) java.util.concurrent.atomic.AtomicReference<Disposable>`	ObservableZip.ZipObserver.`upstream`
`(package private) java.util.concurrent.atomic.AtomicReference<Disposable>`	ObserverResourceWrapper.`upstream`

Methods in io.reactivex.rxjava3.internal.operators.observable with parameters of type Disposable
Modifier and Type	Method	Description
`void`	ObservableRefCount.RefConnection.`accept(Disposable t)`
`void`	ObservableReplay.DisposeConsumer.`accept(Disposable r)`
`(package private) void`	ObservableBufferBoundary.BufferBoundaryObserver.`boundaryError(Disposable observer, java.lang.Throwable ex)`
`void`	BlockingObservableIterable.BlockingObservableIterator.`onSubscribe(Disposable d)`
`void`	ObservableAll.AllObserver.`onSubscribe(Disposable d)`
`void`	ObservableAllSingle.AllObserver.`onSubscribe(Disposable d)`
`void`	ObservableAmb.AmbInnerObserver.`onSubscribe(Disposable d)`
`void`	ObservableAny.AnyObserver.`onSubscribe(Disposable d)`
`void`	ObservableAnySingle.AnyObserver.`onSubscribe(Disposable d)`
`void`	ObservableBuffer.BufferExactObserver.`onSubscribe(Disposable d)`
`void`	ObservableBuffer.BufferSkipObserver.`onSubscribe(Disposable d)`
`void`	ObservableBufferBoundary.BufferBoundaryObserver.BufferOpenObserver.`onSubscribe(Disposable d)`
`void`	ObservableBufferBoundary.BufferBoundaryObserver.`onSubscribe(Disposable d)`
`void`	ObservableBufferBoundary.BufferCloseObserver.`onSubscribe(Disposable d)`
`void`	ObservableBufferExactBoundary.BufferExactBoundaryObserver.`onSubscribe(Disposable d)`
`void`	ObservableBufferTimed.BufferExactBoundedObserver.`onSubscribe(Disposable d)`
`void`	ObservableBufferTimed.BufferExactUnboundedObserver.`onSubscribe(Disposable d)`
`void`	ObservableBufferTimed.BufferSkipBoundedObserver.`onSubscribe(Disposable d)`
`void`	ObservableCache.`onSubscribe(Disposable d)`
`void`	ObservableCollect.CollectObserver.`onSubscribe(Disposable d)`
`void`	ObservableCollectSingle.CollectObserver.`onSubscribe(Disposable d)`
`void`	ObservableCombineLatest.CombinerObserver.`onSubscribe(Disposable d)`
`void`	ObservableConcatMap.ConcatMapDelayErrorObserver.DelayErrorInnerObserver.`onSubscribe(Disposable d)`
`void`	ObservableConcatMap.ConcatMapDelayErrorObserver.`onSubscribe(Disposable d)`
`void`	ObservableConcatMap.SourceObserver.InnerObserver.`onSubscribe(Disposable d)`
`void`	ObservableConcatMap.SourceObserver.`onSubscribe(Disposable d)`
`void`	ObservableConcatMapEager.ConcatMapEagerMainObserver.`onSubscribe(Disposable d)`
`void`	ObservableConcatMapScheduler.ConcatMapDelayErrorObserver.DelayErrorInnerObserver.`onSubscribe(Disposable d)`
`void`	ObservableConcatMapScheduler.ConcatMapDelayErrorObserver.`onSubscribe(Disposable d)`
`void`	ObservableConcatMapScheduler.ConcatMapObserver.InnerObserver.`onSubscribe(Disposable d)`
`void`	ObservableConcatMapScheduler.ConcatMapObserver.`onSubscribe(Disposable d)`
`void`	ObservableConcatWithCompletable.ConcatWithObserver.`onSubscribe(Disposable d)`
`void`	ObservableConcatWithMaybe.ConcatWithObserver.`onSubscribe(Disposable d)`
`void`	ObservableConcatWithSingle.ConcatWithObserver.`onSubscribe(Disposable d)`
`void`	ObservableCount.CountObserver.`onSubscribe(Disposable d)`
`void`	ObservableCountSingle.CountObserver.`onSubscribe(Disposable d)`
`void`	ObservableDebounce.DebounceObserver.`onSubscribe(Disposable d)`
`void`	ObservableDebounceTimed.DebounceTimedObserver.`onSubscribe(Disposable d)`
`void`	ObservableDelay.DelayObserver.`onSubscribe(Disposable d)`
`void`	ObservableDelaySubscriptionOther.DelayObserver.OnComplete.`onSubscribe(Disposable d)`
`void`	ObservableDelaySubscriptionOther.DelayObserver.`onSubscribe(Disposable d)`
`void`	ObservableDematerialize.DematerializeObserver.`onSubscribe(Disposable d)`
`void`	ObservableDetach.DetachObserver.`onSubscribe(Disposable d)`
`void`	ObservableDoFinally.DoFinallyObserver.`onSubscribe(Disposable d)`
`void`	ObservableDoOnEach.DoOnEachObserver.`onSubscribe(Disposable d)`
`void`	ObservableElementAt.ElementAtObserver.`onSubscribe(Disposable d)`
`void`	ObservableElementAtMaybe.ElementAtObserver.`onSubscribe(Disposable d)`
`void`	ObservableElementAtSingle.ElementAtObserver.`onSubscribe(Disposable d)`
`void`	ObservableFlatMap.InnerObserver.`onSubscribe(Disposable d)`
`void`	ObservableFlatMap.MergeObserver.`onSubscribe(Disposable d)`
`void`	ObservableFlatMapCompletable.FlatMapCompletableMainObserver.InnerObserver.`onSubscribe(Disposable d)`
`void`	ObservableFlatMapCompletable.FlatMapCompletableMainObserver.`onSubscribe(Disposable d)`
`void`	ObservableFlatMapCompletableCompletable.FlatMapCompletableMainObserver.InnerObserver.`onSubscribe(Disposable d)`
`void`	ObservableFlatMapCompletableCompletable.FlatMapCompletableMainObserver.`onSubscribe(Disposable d)`
`void`	ObservableFlatMapMaybe.FlatMapMaybeObserver.InnerObserver.`onSubscribe(Disposable d)`
`void`	ObservableFlatMapMaybe.FlatMapMaybeObserver.`onSubscribe(Disposable d)`
`void`	ObservableFlatMapSingle.FlatMapSingleObserver.InnerObserver.`onSubscribe(Disposable d)`
`void`	ObservableFlatMapSingle.FlatMapSingleObserver.`onSubscribe(Disposable d)`
`void`	ObservableFlattenIterable.FlattenIterableObserver.`onSubscribe(Disposable d)`
`void`	ObservableFromCompletable.FromCompletableObserver.`onSubscribe(Disposable d)`
`void`	ObservableGroupBy.GroupByObserver.`onSubscribe(Disposable d)`
`void`	ObservableGroupJoin.LeftRightEndObserver.`onSubscribe(Disposable d)`
`void`	ObservableGroupJoin.LeftRightObserver.`onSubscribe(Disposable d)`
`void`	ObservableHide.HideDisposable.`onSubscribe(Disposable d)`
`void`	ObservableIgnoreElements.IgnoreObservable.`onSubscribe(Disposable d)`
`void`	ObservableIgnoreElementsCompletable.IgnoreObservable.`onSubscribe(Disposable d)`
`void`	ObservableLastMaybe.LastObserver.`onSubscribe(Disposable d)`
`void`	ObservableLastSingle.LastObserver.`onSubscribe(Disposable d)`
`void`	ObservableMapNotification.MapNotificationObserver.`onSubscribe(Disposable d)`
`void`	ObservableMaterialize.MaterializeObserver.`onSubscribe(Disposable d)`
`void`	ObservableMergeWithCompletable.MergeWithObserver.`onSubscribe(Disposable d)`
`void`	ObservableMergeWithCompletable.MergeWithObserver.OtherObserver.`onSubscribe(Disposable d)`
`void`	ObservableMergeWithMaybe.MergeWithObserver.`onSubscribe(Disposable d)`
`void`	ObservableMergeWithMaybe.MergeWithObserver.OtherObserver.`onSubscribe(Disposable d)`
`void`	ObservableMergeWithSingle.MergeWithObserver.`onSubscribe(Disposable d)`
`void`	ObservableMergeWithSingle.MergeWithObserver.OtherObserver.`onSubscribe(Disposable d)`
`void`	ObservableObserveOn.ObserveOnObserver.`onSubscribe(Disposable d)`
`void`	ObservableOnErrorComplete.OnErrorCompleteObserver.`onSubscribe(Disposable d)`
`void`	ObservableOnErrorNext.OnErrorNextObserver.`onSubscribe(Disposable d)`
`void`	ObservableOnErrorReturn.OnErrorReturnObserver.`onSubscribe(Disposable d)`
`void`	ObservablePublish.PublishConnection.`onSubscribe(Disposable d)`
`void`	ObservablePublishSelector.SourceObserver.`onSubscribe(Disposable d)`
`void`	ObservablePublishSelector.TargetObserver.`onSubscribe(Disposable d)`
`void`	ObservableReduceMaybe.ReduceObserver.`onSubscribe(Disposable d)`
`void`	ObservableReduceSeedSingle.ReduceSeedObserver.`onSubscribe(Disposable d)`
`void`	ObservableRefCount.RefCountObserver.`onSubscribe(Disposable d)`
`void`	ObservableRepeat.RepeatObserver.`onSubscribe(Disposable d)`
`void`	ObservableRepeatUntil.RepeatUntilObserver.`onSubscribe(Disposable d)`
`void`	ObservableRepeatWhen.RepeatWhenObserver.InnerRepeatObserver.`onSubscribe(Disposable d)`
`void`	ObservableRepeatWhen.RepeatWhenObserver.`onSubscribe(Disposable d)`
`void`	ObservableReplay.ReplayObserver.`onSubscribe(Disposable p)`
`void`	ObservableRetryBiPredicate.RetryBiObserver.`onSubscribe(Disposable d)`
`void`	ObservableRetryPredicate.RepeatObserver.`onSubscribe(Disposable d)`
`void`	ObservableRetryWhen.RepeatWhenObserver.InnerRepeatObserver.`onSubscribe(Disposable d)`
`void`	ObservableRetryWhen.RepeatWhenObserver.`onSubscribe(Disposable d)`
`void`	ObservableSampleTimed.SampleTimedObserver.`onSubscribe(Disposable d)`
`void`	ObservableSampleWithObservable.SampleMainObserver.`onSubscribe(Disposable d)`
`void`	ObservableSampleWithObservable.SamplerObserver.`onSubscribe(Disposable d)`
`void`	ObservableScan.ScanObserver.`onSubscribe(Disposable d)`
`void`	ObservableScanSeed.ScanSeedObserver.`onSubscribe(Disposable d)`
`void`	ObservableSequenceEqual.EqualObserver.`onSubscribe(Disposable d)`
`void`	ObservableSequenceEqualSingle.EqualObserver.`onSubscribe(Disposable d)`
`void`	ObservableSingleMaybe.SingleElementObserver.`onSubscribe(Disposable d)`
`void`	ObservableSingleSingle.SingleElementObserver.`onSubscribe(Disposable d)`
`void`	ObservableSkip.SkipObserver.`onSubscribe(Disposable d)`
`void`	ObservableSkipLast.SkipLastObserver.`onSubscribe(Disposable d)`
`void`	ObservableSkipLastTimed.SkipLastTimedObserver.`onSubscribe(Disposable d)`
`void`	ObservableSkipUntil.SkipUntil.`onSubscribe(Disposable d)`
`void`	ObservableSkipUntil.SkipUntilObserver.`onSubscribe(Disposable d)`
`void`	ObservableSkipWhile.SkipWhileObserver.`onSubscribe(Disposable d)`
`void`	ObservableSubscribeOn.SubscribeOnObserver.`onSubscribe(Disposable d)`
`void`	ObservableSwitchIfEmpty.SwitchIfEmptyObserver.`onSubscribe(Disposable d)`
`void`	ObservableSwitchMap.SwitchMapInnerObserver.`onSubscribe(Disposable d)`
`void`	ObservableSwitchMap.SwitchMapObserver.`onSubscribe(Disposable d)`
`void`	ObservableTake.TakeObserver.`onSubscribe(Disposable d)`
`void`	ObservableTakeLast.TakeLastObserver.`onSubscribe(Disposable d)`
`void`	ObservableTakeLastOne.TakeLastOneObserver.`onSubscribe(Disposable d)`
`void`	ObservableTakeLastTimed.TakeLastTimedObserver.`onSubscribe(Disposable d)`
`void`	ObservableTakeUntil.TakeUntilMainObserver.`onSubscribe(Disposable d)`
`void`	ObservableTakeUntil.TakeUntilMainObserver.OtherObserver.`onSubscribe(Disposable d)`
`void`	ObservableTakeUntilPredicate.TakeUntilPredicateObserver.`onSubscribe(Disposable d)`
`void`	ObservableTakeWhile.TakeWhileObserver.`onSubscribe(Disposable d)`
`void`	ObservableThrottleFirstTimed.DebounceTimedObserver.`onSubscribe(Disposable d)`
`void`	ObservableThrottleLatest.ThrottleLatestObserver.`onSubscribe(Disposable d)`
`void`	ObservableTimeInterval.TimeIntervalObserver.`onSubscribe(Disposable d)`
`void`	ObservableTimeout.TimeoutConsumer.`onSubscribe(Disposable d)`
`void`	ObservableTimeout.TimeoutFallbackObserver.`onSubscribe(Disposable d)`
`void`	ObservableTimeout.TimeoutObserver.`onSubscribe(Disposable d)`
`void`	ObservableTimeoutTimed.FallbackObserver.`onSubscribe(Disposable d)`
`void`	ObservableTimeoutTimed.TimeoutFallbackObserver.`onSubscribe(Disposable d)`
`void`	ObservableTimeoutTimed.TimeoutObserver.`onSubscribe(Disposable d)`
`void`	ObservableToList.ToListObserver.`onSubscribe(Disposable d)`
`void`	ObservableToListSingle.ToListObserver.`onSubscribe(Disposable d)`
`void`	ObservableUnsubscribeOn.UnsubscribeObserver.`onSubscribe(Disposable d)`
`void`	ObservableUsing.UsingObserver.`onSubscribe(Disposable d)`
`void`	ObservableWindow.WindowExactObserver.`onSubscribe(Disposable d)`
`void`	ObservableWindow.WindowSkipObserver.`onSubscribe(Disposable d)`
`void`	ObservableWindowBoundary.WindowBoundaryMainObserver.`onSubscribe(Disposable d)`
`void`	ObservableWindowBoundarySelector.WindowBoundaryMainObserver.`onSubscribe(Disposable d)`
`void`	ObservableWindowBoundarySelector.WindowBoundaryMainObserver.WindowEndObserverIntercept.`onSubscribe(Disposable d)`
`void`	ObservableWindowBoundarySelector.WindowBoundaryMainObserver.WindowStartObserver.`onSubscribe(Disposable d)`
`void`	ObservableWindowTimed.AbstractWindowObserver.`onSubscribe(Disposable d)`
`void`	ObservableWithLatestFrom.WithLatestFromObserver.`onSubscribe(Disposable d)`
`void`	ObservableWithLatestFrom.WithLatestFromOtherObserver.`onSubscribe(Disposable d)`
`void`	ObservableWithLatestFromMany.WithLatestFromObserver.`onSubscribe(Disposable d)`
`void`	ObservableWithLatestFromMany.WithLatestInnerObserver.`onSubscribe(Disposable d)`
`void`	ObservableZip.ZipObserver.`onSubscribe(Disposable d)`
`void`	ObservableZipIterable.ZipIterableObserver.`onSubscribe(Disposable d)`
`void`	ObserverResourceWrapper.`onSubscribe(Disposable d)`
`void`	ObservableCreate.CreateEmitter.`setDisposable(Disposable d)`
`void`	ObservableCreate.SerializedEmitter.`setDisposable(Disposable d)`
`(package private) boolean`	ObservableSequenceEqual.EqualCoordinator.`setDisposable(Disposable d, int index)`
`(package private) boolean`	ObservableSequenceEqualSingle.EqualCoordinator.`setDisposable(Disposable d, int index)`
`(package private) void`	ObservableSubscribeOn.SubscribeOnObserver.`setDisposable(Disposable d)`
`(package private) boolean`	ObservableSampleWithObservable.SampleMainObserver.`setOther(Disposable o)`
`boolean`	ObservableWithLatestFrom.WithLatestFromObserver.`setOther(Disposable o)`
`void`	ObservableDebounceTimed.DebounceEmitter.`setResource(Disposable d)`
`void`	ObservableInterval.IntervalObserver.`setResource(Disposable d)`
`void`	ObservableIntervalRange.IntervalRangeObserver.`setResource(Disposable d)`
`void`	ObservableTimer.TimerObserver.`setResource(Disposable d)`
`void`	ObserverResourceWrapper.`setResource(Disposable resource)`

Method parameters in io.reactivex.rxjava3.internal.operators.observable with type arguments of type Disposable
Modifier and Type	Method	Description
`void`	ObservablePublish.`connect(Consumer<? super Disposable> connection)`
`void`	ObservableReplay.`connect(Consumer<? super Disposable> connection)`

Constructor parameters in io.reactivex.rxjava3.internal.operators.observable with type arguments of type Disposable
Constructor	Description
`FallbackObserver(Observer<? super T> actual, java.util.concurrent.atomic.AtomicReference<Disposable> arbiter)`
`ObservableAutoConnect(ConnectableObservable<? extends T> source, int numberOfObservers, Consumer<? super Disposable> connection)`
`ObservableDoOnLifecycle(Observable<T> upstream, Consumer<? super Disposable> onSubscribe, Action onDispose)`
`SourceObserver(PublishSubject<T> subject, java.util.concurrent.atomic.AtomicReference<Disposable> target)`

Uses of Disposable in io.reactivex.rxjava3.internal.operators.single

Classes in io.reactivex.rxjava3.internal.operators.single that implement Disposable
Modifier and Type	Class	Description
`(package private) static class`	`SingleCache.CacheDisposable<T>`
`(package private) static class`	`SingleCreate.Emitter<T>`
`(package private) static class`	`SingleDelayWithCompletable.OtherObserver<T>`
`(package private) static class`	`SingleDelayWithObservable.OtherSubscriber<T,U>`
`(package private) static class`	`SingleDelayWithPublisher.OtherSubscriber<T,U>`
`(package private) static class`	`SingleDelayWithSingle.OtherObserver<T,U>`
`(package private) static class`	`SingleDematerialize.DematerializeObserver<T,R>`
`(package private) static class`	`SingleDetach.DetachSingleObserver<T>`
`(package private) static class`	`SingleDoAfterSuccess.DoAfterObserver<T>`
`(package private) static class`	`SingleDoAfterTerminate.DoAfterTerminateObserver<T>`
`(package private) static class`	`SingleDoFinally.DoFinallyObserver<T>`
`(package private) static class`	`SingleDoOnDispose.DoOnDisposeObserver<T>`
`(package private) static class`	`SingleDoOnLifecycle.SingleLifecycleObserver<T>`
`(package private) static class`	`SingleFlatMap.SingleFlatMapCallback<T,R>`
`(package private) static class`	`SingleFlatMapBiSelector.FlatMapBiMainObserver<T,U,R>`
`(package private) static class`	`SingleFlatMapCompletable.FlatMapCompletableObserver<T>`
`(package private) static class`	`SingleFlatMapIterableObservable.FlatMapIterableObserver<T,R>`
`(package private) static class`	`SingleFlatMapMaybe.FlatMapSingleObserver<T,R>`
`(package private) static class`	`SingleFlatMapNotification.FlatMapSingleObserver<T,R>`
`(package private) static class`	`SingleFromPublisher.ToSingleObserver<T>`
`(package private) static class`	`SingleHide.HideSingleObserver<T>`
`(package private) static class`	`SingleObserveOn.ObserveOnSingleObserver<T>`
`(package private) static class`	`SingleResumeNext.ResumeMainSingleObserver<T>`
`(package private) static class`	`SingleSubscribeOn.SubscribeOnObserver<T>`
`(package private) static class`	`SingleTakeUntil.TakeUntilMainObserver<T>`
`(package private) static class`	`SingleTimeInterval.TimeIntervalSingleObserver<T>`
`(package private) static class`	`SingleTimeout.TimeoutMainObserver<T>`
`(package private) static class`	`SingleTimer.TimerDisposable`
`(package private) static class`	`SingleToObservable.SingleToObservableObserver<T>`
`(package private) static class`	`SingleUnsubscribeOn.UnsubscribeOnSingleObserver<T>`
`(package private) static class`	`SingleUsing.UsingSingleObserver<T,U>`
`(package private) static class`	`SingleZipArray.ZipCoordinator<T,R>`

Fields in io.reactivex.rxjava3.internal.operators.single declared as Disposable
Modifier and Type	Field	Description
`(package private) Disposable`	SingleFlatMapPublisher.SingleFlatMapPublisherObserver.`disposable`
`(package private) Disposable`	SingleUnsubscribeOn.UnsubscribeOnSingleObserver.`ds`
`(package private) Disposable`	SingleAmb.AmbSingleObserver.`upstream`
`(package private) Disposable`	SingleDematerialize.DematerializeObserver.`upstream`
`(package private) Disposable`	SingleDetach.DetachSingleObserver.`upstream`
`(package private) Disposable`	SingleDoAfterSuccess.DoAfterObserver.`upstream`
`(package private) Disposable`	SingleDoAfterTerminate.DoAfterTerminateObserver.`upstream`
`(package private) Disposable`	SingleDoFinally.DoFinallyObserver.`upstream`
`(package private) Disposable`	SingleDoOnDispose.DoOnDisposeObserver.`upstream`
`(package private) Disposable`	SingleDoOnLifecycle.SingleLifecycleObserver.`upstream`
`(package private) Disposable`	SingleFlatMapIterableFlowable.FlatMapIterableObserver.`upstream`
`(package private) Disposable`	SingleFlatMapIterableObservable.FlatMapIterableObserver.`upstream`
`(package private) Disposable`	SingleFlatMapNotification.FlatMapSingleObserver.`upstream`
`(package private) Disposable`	SingleHide.HideSingleObserver.`upstream`
`(package private) Disposable`	SingleTimeInterval.TimeIntervalSingleObserver.`upstream`
`(package private) Disposable`	SingleToFlowable.SingleToFlowableObserver.`upstream`
`(package private) Disposable`	SingleToObservable.SingleToObservableObserver.`upstream`
`(package private) Disposable`	SingleUsing.UsingSingleObserver.`upstream`

Fields in io.reactivex.rxjava3.internal.operators.single with type parameters of type Disposable
Modifier and Type	Field	Description
`(package private) Consumer<? super Disposable>`	SingleDoOnLifecycle.`onSubscribe`
`(package private) Consumer<? super Disposable>`	SingleDoOnLifecycle.SingleLifecycleObserver.`onSubscribe`
`(package private) Consumer<? super Disposable>`	SingleDoOnSubscribe.DoOnSubscribeSingleObserver.`onSubscribe`
`(package private) Consumer<? super Disposable>`	SingleDoOnSubscribe.`onSubscribe`
`(package private) java.util.concurrent.atomic.AtomicReference<Disposable>`	SingleFlatMap.SingleFlatMapCallback.FlatMapSingleObserver.`parent`
`(package private) java.util.concurrent.atomic.AtomicReference<Disposable>`	SingleFlatMapMaybe.FlatMapMaybeObserver.`parent`
`(package private) java.util.concurrent.atomic.AtomicReference<Disposable>`	SingleTimeout.TimeoutMainObserver.`task`

Methods in io.reactivex.rxjava3.internal.operators.single with parameters of type Disposable
Modifier and Type	Method	Description
`void`	SingleAmb.AmbSingleObserver.`onSubscribe(Disposable d)`
`void`	SingleCache.`onSubscribe(Disposable d)`
`void`	SingleContains.ContainsSingleObserver.`onSubscribe(Disposable d)`
`void`	SingleDelay.Delay.`onSubscribe(Disposable d)`
`void`	SingleDelayWithCompletable.OtherObserver.`onSubscribe(Disposable d)`
`void`	SingleDelayWithObservable.OtherSubscriber.`onSubscribe(Disposable d)`
`void`	SingleDelayWithSingle.OtherObserver.`onSubscribe(Disposable d)`
`void`	SingleDematerialize.DematerializeObserver.`onSubscribe(Disposable d)`
`void`	SingleDetach.DetachSingleObserver.`onSubscribe(Disposable d)`
`void`	SingleDoAfterSuccess.DoAfterObserver.`onSubscribe(Disposable d)`
`void`	SingleDoAfterTerminate.DoAfterTerminateObserver.`onSubscribe(Disposable d)`
`void`	SingleDoFinally.DoFinallyObserver.`onSubscribe(Disposable d)`
`void`	SingleDoOnDispose.DoOnDisposeObserver.`onSubscribe(Disposable d)`
`void`	SingleDoOnError.DoOnError.`onSubscribe(Disposable d)`
`void`	SingleDoOnEvent.DoOnEvent.`onSubscribe(Disposable d)`
`void`	SingleDoOnLifecycle.SingleLifecycleObserver.`onSubscribe(@NonNull Disposable d)`
`void`	SingleDoOnSubscribe.DoOnSubscribeSingleObserver.`onSubscribe(Disposable d)`
`void`	SingleDoOnSuccess.DoOnSuccess.`onSubscribe(Disposable d)`
`void`	SingleDoOnTerminate.DoOnTerminate.`onSubscribe(Disposable d)`
`void`	SingleEquals.InnerObserver.`onSubscribe(Disposable d)`
`void`	SingleFlatMap.SingleFlatMapCallback.FlatMapSingleObserver.`onSubscribe(Disposable d)`
`void`	SingleFlatMap.SingleFlatMapCallback.`onSubscribe(Disposable d)`
`void`	SingleFlatMapBiSelector.FlatMapBiMainObserver.InnerObserver.`onSubscribe(Disposable d)`
`void`	SingleFlatMapBiSelector.FlatMapBiMainObserver.`onSubscribe(Disposable d)`
`void`	SingleFlatMapCompletable.FlatMapCompletableObserver.`onSubscribe(Disposable d)`
`void`	SingleFlatMapIterableFlowable.FlatMapIterableObserver.`onSubscribe(Disposable d)`
`void`	SingleFlatMapIterableObservable.FlatMapIterableObserver.`onSubscribe(Disposable d)`
`void`	SingleFlatMapMaybe.FlatMapMaybeObserver.`onSubscribe(Disposable d)`
`void`	SingleFlatMapMaybe.FlatMapSingleObserver.`onSubscribe(Disposable d)`
`void`	SingleFlatMapNotification.FlatMapSingleObserver.InnerObserver.`onSubscribe(Disposable d)`
`void`	SingleFlatMapNotification.FlatMapSingleObserver.`onSubscribe(Disposable d)`
`void`	SingleFlatMapPublisher.SingleFlatMapPublisherObserver.`onSubscribe(Disposable d)`
`void`	SingleHide.HideSingleObserver.`onSubscribe(Disposable d)`
`void`	SingleMap.MapSingleObserver.`onSubscribe(Disposable d)`
`void`	SingleObserveOn.ObserveOnSingleObserver.`onSubscribe(Disposable d)`
`void`	SingleOnErrorReturn.OnErrorReturn.`onSubscribe(Disposable d)`
`void`	SingleResumeNext.ResumeMainSingleObserver.`onSubscribe(Disposable d)`
`void`	SingleSubscribeOn.SubscribeOnObserver.`onSubscribe(Disposable d)`
`void`	SingleTakeUntil.TakeUntilMainObserver.`onSubscribe(Disposable d)`
`void`	SingleTimeInterval.TimeIntervalSingleObserver.`onSubscribe(@NonNull Disposable d)`
`void`	SingleTimeout.TimeoutMainObserver.`onSubscribe(Disposable d)`
`void`	SingleTimeout.TimeoutMainObserver.TimeoutFallbackObserver.`onSubscribe(Disposable d)`
`void`	SingleToFlowable.SingleToFlowableObserver.`onSubscribe(Disposable d)`
`void`	SingleToObservable.SingleToObservableObserver.`onSubscribe(Disposable d)`
`void`	SingleUnsubscribeOn.UnsubscribeOnSingleObserver.`onSubscribe(Disposable d)`
`void`	SingleUsing.UsingSingleObserver.`onSubscribe(Disposable d)`
`void`	SingleZipArray.ZipSingleObserver.`onSubscribe(Disposable d)`
`void`	SingleCreate.Emitter.`setDisposable(Disposable d)`
`(package private) void`	SingleTimer.TimerDisposable.`setFuture(Disposable d)`

Constructor parameters in io.reactivex.rxjava3.internal.operators.single with type arguments of type Disposable
Constructor	Description
`DoOnSubscribeSingleObserver(SingleObserver<? super T> actual, Consumer<? super Disposable> onSubscribe)`
`FlatMapMaybeObserver(java.util.concurrent.atomic.AtomicReference<Disposable> parent, MaybeObserver<? super R> downstream)`
`FlatMapSingleObserver(java.util.concurrent.atomic.AtomicReference<Disposable> parent, SingleObserver<? super R> downstream)`
`SingleDoOnLifecycle(Single<T> upstream, Consumer<? super Disposable> onSubscribe, Action onDispose)`
`SingleDoOnSubscribe(SingleSource<T> source, Consumer<? super Disposable> onSubscribe)`
`SingleLifecycleObserver(SingleObserver<? super T> downstream, Consumer<? super Disposable> onSubscribe, Action onDispose)`

Uses of Disposable in io.reactivex.rxjava3.internal.schedulers

Classes in io.reactivex.rxjava3.internal.schedulers that implement Disposable
Modifier and Type	Class	Description
`(package private) class`	`AbstractDirectTask`	Base functionality for direct tasks that manage a runnable and cancellation/completion.
`(package private) static class`	`ComputationScheduler.EventLoopWorker`
`(package private) static class`	`ComputationScheduler.PoolWorker`
`(package private) static class`	`ExecutorScheduler.DelayedRunnable`
`static class`	`ExecutorScheduler.ExecutorWorker`
`(package private) static class`	`ExecutorScheduler.ExecutorWorker.BooleanRunnable`
`(package private) static class`	`ExecutorScheduler.ExecutorWorker.InterruptibleRunnable`	Wrapper for a `Runnable` with additional logic for handling interruption on a shared thread, similar to how Java Executors do it.
`(package private) static class`	`ImmediateThinScheduler.ImmediateThinWorker`
`(package private) class`	`InstantPeriodicTask`	Wrapper for a regular task that gets immediately rescheduled when the task completed.
`(package private) static class`	`IoScheduler.EventLoopWorker`
`(package private) static class`	`IoScheduler.ThreadWorker`
`class`	`NewThreadWorker`	Base class that manages a single-threaded ScheduledExecutorService as a worker but doesn't perform task-tracking operations.
`class`	`ScheduledDirectPeriodicTask`	A Callable to be submitted to an ExecutorService that runs a Runnable action periodically and manages completion/cancellation.
`class`	`ScheduledDirectTask`	A Callable to be submitted to an ExecutorService that runs a Runnable action and manages completion/cancellation.
`class`	`ScheduledRunnable`
`class`	`SchedulerWhen`	Allows the use of operators for controlling the timing around when actions scheduled on workers are actually done.
`(package private) static class`	`SchedulerWhen.DelayedAction`
`(package private) static class`	`SchedulerWhen.ImmediateAction`
`(package private) static class`	`SchedulerWhen.QueueWorker`
`(package private) static class`	`SchedulerWhen.ScheduledAction`
`(package private) static class`	`SchedulerWhen.SubscribedDisposable`
`(package private) static class`	`SingleScheduler.ScheduledWorker`
`(package private) static class`	`TrampolineScheduler.TrampolineWorker`

Fields in io.reactivex.rxjava3.internal.schedulers declared as Disposable
Modifier and Type	Field	Description
`private Disposable`	SchedulerWhen.`disposable`
`(package private) static Disposable`	ImmediateThinScheduler.`DISPOSED`
`(package private) static Disposable`	SchedulerWhen.`DISPOSED`
`(package private) static Disposable`	SchedulerWhen.`SUBSCRIBED`
`(package private) Disposable`	DisposeOnCancel.`upstream`

Methods in io.reactivex.rxjava3.internal.schedulers that return Disposable
Modifier and Type	Method	Description
`protected Disposable`	SchedulerWhen.DelayedAction.`callActual(Scheduler.Worker actualWorker, CompletableObserver actionCompletable)`
`protected Disposable`	SchedulerWhen.ImmediateAction.`callActual(Scheduler.Worker actualWorker, CompletableObserver actionCompletable)`
`protected abstract Disposable`	SchedulerWhen.ScheduledAction.`callActual(Scheduler.Worker actualWorker, CompletableObserver actionCompletable)`
`(package private) Disposable`	TrampolineScheduler.TrampolineWorker.`enqueue(java.lang.Runnable action, long execTime)`
`@NonNull Disposable`	ComputationScheduler.EventLoopWorker.`schedule(@NonNull java.lang.Runnable action)`
`@NonNull Disposable`	ComputationScheduler.EventLoopWorker.`schedule(@NonNull java.lang.Runnable action, long delayTime, @NonNull java.util.concurrent.TimeUnit unit)`
`@NonNull Disposable`	ExecutorScheduler.ExecutorWorker.`schedule(@NonNull java.lang.Runnable run)`
`@NonNull Disposable`	ExecutorScheduler.ExecutorWorker.`schedule(@NonNull java.lang.Runnable run, long delay, @NonNull java.util.concurrent.TimeUnit unit)`
`@NonNull Disposable`	ImmediateThinScheduler.ImmediateThinWorker.`schedule(@NonNull java.lang.Runnable run)`
`@NonNull Disposable`	ImmediateThinScheduler.ImmediateThinWorker.`schedule(@NonNull java.lang.Runnable run, long delay, @NonNull java.util.concurrent.TimeUnit unit)`
`@NonNull Disposable`	IoScheduler.EventLoopWorker.`schedule(@NonNull java.lang.Runnable action, long delayTime, @NonNull java.util.concurrent.TimeUnit unit)`
`@NonNull Disposable`	NewThreadWorker.`schedule(@NonNull java.lang.Runnable run)`
`@NonNull Disposable`	NewThreadWorker.`schedule(@NonNull java.lang.Runnable action, long delayTime, @NonNull java.util.concurrent.TimeUnit unit)`
`@NonNull Disposable`	SchedulerWhen.QueueWorker.`schedule(@NonNull java.lang.Runnable action)`
`@NonNull Disposable`	SchedulerWhen.QueueWorker.`schedule(@NonNull java.lang.Runnable action, long delayTime, @NonNull java.util.concurrent.TimeUnit unit)`
`@NonNull Disposable`	SingleScheduler.ScheduledWorker.`schedule(@NonNull java.lang.Runnable run, long delay, @NonNull java.util.concurrent.TimeUnit unit)`
`@NonNull Disposable`	TrampolineScheduler.TrampolineWorker.`schedule(@NonNull java.lang.Runnable action)`
`@NonNull Disposable`	TrampolineScheduler.TrampolineWorker.`schedule(@NonNull java.lang.Runnable action, long delayTime, @NonNull java.util.concurrent.TimeUnit unit)`
`@NonNull Disposable`	ComputationScheduler.`scheduleDirect(@NonNull java.lang.Runnable run, long delay, java.util.concurrent.TimeUnit unit)`
`@NonNull Disposable`	ExecutorScheduler.`scheduleDirect(@NonNull java.lang.Runnable run)`
`@NonNull Disposable`	ExecutorScheduler.`scheduleDirect(@NonNull java.lang.Runnable run, long delay, java.util.concurrent.TimeUnit unit)`
`@NonNull Disposable`	ImmediateThinScheduler.`scheduleDirect(@NonNull java.lang.Runnable run)`
`@NonNull Disposable`	ImmediateThinScheduler.`scheduleDirect(@NonNull java.lang.Runnable run, long delay, java.util.concurrent.TimeUnit unit)`
`Disposable`	NewThreadWorker.`scheduleDirect(java.lang.Runnable run, long delayTime, java.util.concurrent.TimeUnit unit)`	Schedules the given runnable on the underlying executor directly and returns its future wrapped into a Disposable.
`@NonNull Disposable`	SingleScheduler.`scheduleDirect(@NonNull java.lang.Runnable run, long delay, java.util.concurrent.TimeUnit unit)`
`@NonNull Disposable`	TrampolineScheduler.`scheduleDirect(@NonNull java.lang.Runnable run)`
`@NonNull Disposable`	TrampolineScheduler.`scheduleDirect(@NonNull java.lang.Runnable run, long delay, java.util.concurrent.TimeUnit unit)`
`@NonNull Disposable`	ImmediateThinScheduler.ImmediateThinWorker.`schedulePeriodically(@NonNull java.lang.Runnable run, long initialDelay, long period, java.util.concurrent.TimeUnit unit)`
`@NonNull Disposable`	ComputationScheduler.`schedulePeriodicallyDirect(@NonNull java.lang.Runnable run, long initialDelay, long period, java.util.concurrent.TimeUnit unit)`
`@NonNull Disposable`	ExecutorScheduler.`schedulePeriodicallyDirect(@NonNull java.lang.Runnable run, long initialDelay, long period, java.util.concurrent.TimeUnit unit)`
`@NonNull Disposable`	ImmediateThinScheduler.`schedulePeriodicallyDirect(@NonNull java.lang.Runnable run, long initialDelay, long period, java.util.concurrent.TimeUnit unit)`
`Disposable`	NewThreadWorker.`schedulePeriodicallyDirect(java.lang.Runnable run, long initialDelay, long period, java.util.concurrent.TimeUnit unit)`	Schedules the given runnable periodically on the underlying executor directly and returns its future wrapped into a Disposable.
`@NonNull Disposable`	SingleScheduler.`schedulePeriodicallyDirect(@NonNull java.lang.Runnable run, long initialDelay, long period, java.util.concurrent.TimeUnit unit)`

Constructors in io.reactivex.rxjava3.internal.schedulers with parameters of type Disposable
Constructor	Description
`DisposeOnCancel(Disposable d)`

Uses of Disposable in io.reactivex.rxjava3.internal.subscribers

Classes in io.reactivex.rxjava3.internal.subscribers that implement Disposable
Modifier and Type	Class	Description
`class`	`BoundedSubscriber<T>`
`class`	`DisposableAutoReleaseSubscriber<T>`	Wraps lambda callbacks and when the upstream terminates or this subscriber gets disposed, removes itself from a `CompositeDisposable`.
`class`	`ForEachWhileSubscriber<T>`
`class`	`LambdaSubscriber<T>`
`class`	`SubscriberResourceWrapper<T>`

Methods in io.reactivex.rxjava3.internal.subscribers with parameters of type Disposable
Modifier and Type	Method	Description
`protected void`	QueueDrainSubscriber.`fastPathEmitMax(U value, boolean delayError, Disposable dispose)`
`protected void`	QueueDrainSubscriber.`fastPathOrderedEmitMax(U value, boolean delayError, Disposable dispose)`
`void`	SubscriberResourceWrapper.`setResource(Disposable resource)`

Uses of Disposable in io.reactivex.rxjava3.internal.subscriptions

Classes in io.reactivex.rxjava3.internal.subscriptions that implement Disposable
Modifier and Type	Class	Description
`class`	`ArrayCompositeSubscription`	A composite disposable with a fixed number of slots.
`class`	`AsyncSubscription`	A subscription implementation that arbitrates exactly one other Subscription and can hold a single disposable resource.

Fields in io.reactivex.rxjava3.internal.subscriptions with type parameters of type Disposable
Modifier and Type	Field	Description
`(package private) java.util.concurrent.atomic.AtomicReference<Disposable>`	AsyncSubscription.`resource`

Methods in io.reactivex.rxjava3.internal.subscriptions with parameters of type Disposable
Modifier and Type	Method	Description
`boolean`	AsyncSubscription.`replaceResource(Disposable r)`	Replaces the currently held resource with the given new one without disposing the old.
`boolean`	AsyncSubscription.`setResource(Disposable r)`	Sets a new resource and disposes the currently held resource.

Constructors in io.reactivex.rxjava3.internal.subscriptions with parameters of type Disposable
Constructor	Description
`AsyncSubscription(Disposable resource)`

Uses of Disposable in io.reactivex.rxjava3.internal.util

Classes in io.reactivex.rxjava3.internal.util that implement Disposable
Modifier and Type	Class	Description
`class`	`EmptyComponent`	Singleton implementing many interfaces as empty.

Fields in io.reactivex.rxjava3.internal.util declared as Disposable
Modifier and Type	Field	Description
`Disposable`	ConnectConsumer.`disposable`
`(package private) Disposable`	NotificationLite.DisposableNotification.`upstream`

Methods in io.reactivex.rxjava3.internal.util that return Disposable
Modifier and Type	Method	Description
`static Disposable`	NotificationLite.`getDisposable(java.lang.Object o)`

Methods in io.reactivex.rxjava3.internal.util with parameters of type Disposable
Modifier and Type	Method	Description
`void`	ConnectConsumer.`accept(Disposable t)`
`static void`	BlockingHelper.`awaitForComplete(java.util.concurrent.CountDownLatch latch, Disposable subscription)`
`static <T,U> boolean`	QueueDrainHelper.`checkTerminated(boolean d, boolean empty, Observer<?> observer, boolean delayError, SimpleQueue<?> q, Disposable disposable, ObservableQueueDrain<T,U> qd)`
`static java.lang.Object`	NotificationLite.`disposable(Disposable d)`	Converts a Disposable into a notification value.
`static <T,U> void`	QueueDrainHelper.`drainLoop(SimplePlainQueue<T> q, Observer<? super U> a, boolean delayError, Disposable dispose, ObservableQueueDrain<T,U> qd)`
`static <T,U> void`	QueueDrainHelper.`drainMaxLoop(SimplePlainQueue<T> q, org.reactivestreams.Subscriber<? super U> a, boolean delayError, Disposable dispose, QueueDrain<T,U> qd)`	Drain the queue but give up with an error if there aren't enough requests.
`void`	EmptyComponent.`onSubscribe(Disposable d)`
`static boolean`	EndConsumerHelper.`setOnce(java.util.concurrent.atomic.AtomicReference<Disposable> upstream, Disposable next, java.lang.Class<?> observer)`	Atomically updates the target upstream AtomicReference from null to the non-null next Disposable, otherwise disposes next and reports a ProtocolViolationException if the AtomicReference doesn't contain the shared disposed indicator.
`static boolean`	EndConsumerHelper.`validate(Disposable upstream, Disposable next, java.lang.Class<?> observer)`	Ensures that the upstream Disposable is null and returns true, otherwise disposes the next Disposable and if the upstream is not the shared disposed instance, reports a ProtocolViolationException due to multiple subscribe attempts.

Method parameters in io.reactivex.rxjava3.internal.util with type arguments of type Disposable
Modifier and Type	Method	Description
`static boolean`	EndConsumerHelper.`setOnce(java.util.concurrent.atomic.AtomicReference<Disposable> upstream, Disposable next, java.lang.Class<?> observer)`	Atomically updates the target upstream AtomicReference from null to the non-null next Disposable, otherwise disposes next and reports a ProtocolViolationException if the AtomicReference doesn't contain the shared disposed indicator.

Constructors in io.reactivex.rxjava3.internal.util with parameters of type Disposable
Constructor	Description
`DisposableNotification(Disposable d)`

Uses of Disposable in io.reactivex.rxjava3.observables

Methods in io.reactivex.rxjava3.observables that return Disposable
Modifier and Type	Method	Description
`@NonNull Disposable`	ConnectableObservable.`connect()`	Instructs the `ConnectableObservable` to begin emitting the items from its underlying `Observable` to its `Observer`s.

Method parameters in io.reactivex.rxjava3.observables with type arguments of type Disposable
Modifier and Type	Method	Description
`@NonNull Observable<T>`	ConnectableObservable.`autoConnect(int numberOfObservers, @NonNull Consumer<? super Disposable> connection)`	Returns an `Observable` that automatically connects (at most once) to this `ConnectableObservable` when the specified number of `Observer`s subscribe to it and calls the specified callback with the `Disposable` associated with the established connection.
`abstract void`	ConnectableObservable.`connect(@NonNull Consumer<? super Disposable> connection)`	Instructs the `ConnectableObservable` to begin emitting the items from its underlying `Observable` to its `Observer`s.

Uses of Disposable in io.reactivex.rxjava3.observers

Classes in io.reactivex.rxjava3.observers that implement Disposable
Modifier and Type	Class	Description
`class`	`DisposableCompletableObserver`	An abstract `CompletableObserver` that allows asynchronous cancellation by implementing Disposable.
`class`	`DisposableMaybeObserver<T>`	An abstract `MaybeObserver` that allows asynchronous cancellation by implementing `Disposable`.
`class`	`DisposableObserver<T>`	An abstract `Observer` that allows asynchronous cancellation by implementing `Disposable`.
`class`	`DisposableSingleObserver<T>`	An abstract `SingleObserver` that allows asynchronous cancellation by implementing `Disposable`.
`class`	`ResourceCompletableObserver`	An abstract `CompletableObserver` that allows asynchronous cancellation of its subscription and associated resources.
`class`	`ResourceMaybeObserver<T>`	An abstract `MaybeObserver` that allows asynchronous cancellation of its subscription and associated resources.
`class`	`ResourceObserver<T>`	An abstract `Observer` that allows asynchronous cancellation of its subscription and associated resources.
`class`	`ResourceSingleObserver<T>`	An abstract `SingleObserver` that allows asynchronous cancellation of its subscription and the associated resources.
`class`	`SafeObserver<T>`	Wraps another `Observer` and ensures all `onXXX` methods conform the protocol (except the requirement for serialized access).
`class`	`SerializedObserver<T>`	Serializes access to the `Observer.onNext(Object)`, `Observer.onError(Throwable)` and `Observer.onComplete()` methods of another `Observer`.
`class`	`TestObserver<T>`	An `Observer`, `MaybeObserver`, `SingleObserver` and `CompletableObserver` composite that can record events from `Observable`s, `Maybe`s, `Single`s and `Completable`s and allows making assertions about them.

Fields in io.reactivex.rxjava3.observers declared as Disposable
Modifier and Type	Field	Description
`private Disposable`	DefaultObserver.`upstream`
`(package private) Disposable`	SafeObserver.`upstream`	The subscription.
`(package private) Disposable`	SerializedObserver.`upstream`

Fields in io.reactivex.rxjava3.observers with type parameters of type Disposable
Modifier and Type	Field	Description
`(package private) java.util.concurrent.atomic.AtomicReference<Disposable>`	DisposableCompletableObserver.`upstream`
`(package private) java.util.concurrent.atomic.AtomicReference<Disposable>`	DisposableMaybeObserver.`upstream`
`(package private) java.util.concurrent.atomic.AtomicReference<Disposable>`	DisposableObserver.`upstream`
`(package private) java.util.concurrent.atomic.AtomicReference<Disposable>`	DisposableSingleObserver.`upstream`
`private java.util.concurrent.atomic.AtomicReference<Disposable>`	ResourceCompletableObserver.`upstream`	The active subscription.
`private java.util.concurrent.atomic.AtomicReference<Disposable>`	ResourceMaybeObserver.`upstream`	The active subscription.
`private java.util.concurrent.atomic.AtomicReference<Disposable>`	ResourceObserver.`upstream`	The active subscription.
`private java.util.concurrent.atomic.AtomicReference<Disposable>`	ResourceSingleObserver.`upstream`	The active subscription.
`private java.util.concurrent.atomic.AtomicReference<Disposable>`	TestObserver.`upstream`	Holds the current subscription if any.

Methods in io.reactivex.rxjava3.observers with parameters of type Disposable
Modifier and Type	Method	Description
`void`	ResourceCompletableObserver.`add(@NonNull Disposable resource)`	Adds a resource to this `ResourceCompletableObserver`.
`void`	ResourceMaybeObserver.`add(@NonNull Disposable resource)`	Adds a resource to this `ResourceMaybeObserver`.
`void`	ResourceObserver.`add(@NonNull Disposable resource)`	Adds a resource to this `ResourceObserver`.
`void`	ResourceSingleObserver.`add(@NonNull Disposable resource)`	Adds a resource to this `ResourceSingleObserver`.
`void`	DefaultObserver.`onSubscribe(@NonNull Disposable d)`
`void`	DisposableCompletableObserver.`onSubscribe(@NonNull Disposable d)`
`void`	DisposableMaybeObserver.`onSubscribe(@NonNull Disposable d)`
`void`	DisposableObserver.`onSubscribe(@NonNull Disposable d)`
`void`	DisposableSingleObserver.`onSubscribe(@NonNull Disposable d)`
`void`	ResourceCompletableObserver.`onSubscribe(@NonNull Disposable d)`
`void`	ResourceMaybeObserver.`onSubscribe(@NonNull Disposable d)`
`void`	ResourceObserver.`onSubscribe(Disposable d)`
`void`	ResourceSingleObserver.`onSubscribe(@NonNull Disposable d)`
`void`	SafeObserver.`onSubscribe(@NonNull Disposable d)`
`void`	SerializedObserver.`onSubscribe(@NonNull Disposable d)`
`void`	TestObserver.EmptyObserver.`onSubscribe(Disposable d)`
`void`	TestObserver.`onSubscribe(@NonNull Disposable d)`

Uses of Disposable in io.reactivex.rxjava3.operators

Subinterfaces of Disposable in io.reactivex.rxjava3.operators
Modifier and Type	Interface	Description
`interface`	`QueueDisposable<T>`	An interface extending `SimpleQueue` and `Disposable` and allows negotiating the fusion mode between subsequent operators of the `Observable` base reactive type.

Uses of Disposable in io.reactivex.rxjava3.schedulers

Classes in io.reactivex.rxjava3.schedulers that implement Disposable
Modifier and Type	Class	Description
`(package private) class`	`TestScheduler.TestWorker`
`(package private) class`	`TestScheduler.TestWorker.QueueRemove`

Methods in io.reactivex.rxjava3.schedulers that return Disposable
Modifier and Type	Method	Description
`@NonNull Disposable`	TestScheduler.TestWorker.`schedule(@NonNull java.lang.Runnable run)`
`@NonNull Disposable`	TestScheduler.TestWorker.`schedule(@NonNull java.lang.Runnable run, long delayTime, @NonNull java.util.concurrent.TimeUnit unit)`

Uses of Disposable in io.reactivex.rxjava3.subjects

Classes in io.reactivex.rxjava3.subjects that implement Disposable
Modifier and Type	Class	Description
`(package private) static class`	`AsyncSubject.AsyncDisposable<T>`
`(package private) static class`	`BehaviorSubject.BehaviorDisposable<T>`
`(package private) static class`	`CompletableSubject.CompletableDisposable`
`(package private) static class`	`MaybeSubject.MaybeDisposable<T>`
`(package private) static class`	`PublishSubject.PublishDisposable<T>`	Wraps the actual subscriber, tracks its requests and makes cancellation to remove itself from the current subscribers array.
`(package private) static class`	`ReplaySubject.ReplayDisposable<T>`
`(package private) static class`	`SingleSubject.SingleDisposable<T>`
`(package private) class`	`UnicastSubject.UnicastQueueDisposable`

Methods in io.reactivex.rxjava3.subjects with parameters of type Disposable
Modifier and Type	Method	Description
`void`	AsyncSubject.`onSubscribe(Disposable d)`
`void`	BehaviorSubject.`onSubscribe(Disposable d)`
`void`	CompletableSubject.`onSubscribe(Disposable d)`
`void`	MaybeSubject.`onSubscribe(Disposable d)`
`void`	PublishSubject.`onSubscribe(Disposable d)`
`void`	ReplaySubject.`onSubscribe(Disposable d)`
`void`	SerializedSubject.`onSubscribe(Disposable d)`
`void`	SingleSubject.`onSubscribe(@NonNull Disposable d)`
`void`	UnicastSubject.`onSubscribe(Disposable d)`

Uses of Disposable in io.reactivex.rxjava3.subscribers

Classes in io.reactivex.rxjava3.subscribers that implement Disposable
Modifier and Type	Class	Description
`class`	`DisposableSubscriber<T>`	An abstract Subscriber that allows asynchronous, external cancellation by implementing `Disposable`.
`class`	`ResourceSubscriber<T>`	An abstract Subscriber that allows asynchronous cancellation of its subscription and associated resources.

Methods in io.reactivex.rxjava3.subscribers with parameters of type Disposable
Modifier and Type	Method	Description
`void`	ResourceSubscriber.`add(Disposable resource)`	Adds a resource to this `ResourceSubscriber`.

Uses of Interfaceio.reactivex.rxjava3.disposables.Disposable

Uses of Disposable in io.reactivex.rxjava3.core

Uses of Disposable in io.reactivex.rxjava3.disposables

Uses of Disposable in io.reactivex.rxjava3.flowables

Uses of Disposable in io.reactivex.rxjava3.internal.disposables

Uses of Disposable in io.reactivex.rxjava3.internal.fuseable

Uses of Disposable in io.reactivex.rxjava3.internal.jdk8

Uses of Disposable in io.reactivex.rxjava3.internal.observers

Uses of Disposable in io.reactivex.rxjava3.internal.operators.completable

Uses of Disposable in io.reactivex.rxjava3.internal.operators.flowable

Uses of Disposable in io.reactivex.rxjava3.internal.operators.maybe

Uses of Disposable in io.reactivex.rxjava3.internal.operators.mixed

Uses of Disposable in io.reactivex.rxjava3.internal.operators.observable

Uses of Disposable in io.reactivex.rxjava3.internal.operators.single

Uses of Disposable in io.reactivex.rxjava3.internal.schedulers

Uses of Disposable in io.reactivex.rxjava3.internal.subscribers

Uses of Disposable in io.reactivex.rxjava3.internal.subscriptions

Uses of Disposable in io.reactivex.rxjava3.internal.util

Uses of Disposable in io.reactivex.rxjava3.observables

Uses of Disposable in io.reactivex.rxjava3.observers

Uses of Disposable in io.reactivex.rxjava3.operators

Uses of Disposable in io.reactivex.rxjava3.schedulers

Uses of Disposable in io.reactivex.rxjava3.subjects

Uses of Disposable in io.reactivex.rxjava3.subscribers

Uses of Interface
io.reactivex.rxjava3.disposables.Disposable