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 final class	Scheduler.DisposeTask
(package private) static final 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
final @NonNull Disposable	Flowable.forEach(@NonNull Consumer<? super @NonNull T> onNext)	Subscribes to the current Flowable and receives notifications for each element.
final @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.
final @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.
final @NonNull Disposable	Flowable.forEachWhile(@NonNull Predicate<? super @NonNull T> onNext, @NonNull Consumer<? super Throwable> onError)	Subscribes to the current Flowable and receives notifications for each element and error events until the onNext Predicate returns false.
final @NonNull Disposable	Flowable.forEachWhile(@NonNull Predicate<? super @NonNull T> onNext, @NonNull Consumer<? super 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.
final @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.
final @NonNull Disposable	Observable.forEachWhile(@NonNull Predicate<? super @NonNull T> onNext, @NonNull Consumer<? super 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.
final @NonNull Disposable	Observable.forEachWhile(@NonNull Predicate<? super @NonNull T> onNext, @NonNull Consumer<? super 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 Runnable run)	Schedules a Runnable for execution without any time delay.
abstract @NonNull Disposable	Scheduler.Worker.schedule(@NonNull Runnable run, long delay, @NonNull 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 Runnable run)	Schedules the given task on this Scheduler without any time delay.
@NonNull Disposable	Scheduler.scheduleDirect(@NonNull Runnable run, long delay, @NonNull TimeUnit unit)	Schedules the execution of the given task with the given time delay.
@NonNull Disposable	Scheduler.Worker.schedulePeriodically(@NonNull Runnable run, long initialDelay, long period, @NonNull TimeUnit unit)	Schedules a periodic execution of the given task with the given initial time delay and repeat period.
@NonNull Disposable	Scheduler.schedulePeriodicallyDirect(@NonNull Runnable run, long initialDelay, long period, @NonNull TimeUnit unit)	Schedules a periodic execution of the given task with the given initial time delay and repeat period.
final @NonNull Disposable	Completable.subscribe()	Subscribes to this Completable and returns a Disposable which can be used to dispose the subscription.
final @NonNull Disposable	Completable.subscribe(@NonNull Action onComplete)	Subscribes to this Completable and calls the given Action when this Completable completes normally.
final @NonNull Disposable	Completable.subscribe(@NonNull Action onComplete, @NonNull Consumer<? super Throwable> onError)	Subscribes to this Completable and calls back either the onError or onComplete functions.
final @NonNull Disposable	Completable.subscribe(@NonNull Action onComplete, @NonNull Consumer<? super 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.
final @NonNull Disposable	Flowable.subscribe()	Subscribes to the current Flowable and ignores onNext and onComplete emissions.
final @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.
final @NonNull Disposable	Flowable.subscribe(@NonNull Consumer<? super @NonNull T> onNext, @NonNull Consumer<? super Throwable> onError)	Subscribes to the current Flowable and provides callbacks to handle the items it emits and any error notification it issues.
final @NonNull Disposable	Flowable.subscribe(@NonNull Consumer<? super @NonNull T> onNext, @NonNull Consumer<? super 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.
final @NonNull Disposable	Flowable.subscribe(@NonNull Consumer<? super @NonNull T> onNext, @NonNull Consumer<? super 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.
final @NonNull Disposable	Maybe.subscribe()	Subscribes to a Maybe and ignores onSuccess and onComplete emissions.
final @NonNull Disposable	Maybe.subscribe(@NonNull Consumer<? super @NonNull T> onSuccess)	Subscribes to a Maybe and provides a callback to handle the items it emits.
final @NonNull Disposable	Maybe.subscribe(@NonNull Consumer<? super @NonNull T> onSuccess, @NonNull Consumer<? super Throwable> onError)	Subscribes to a Maybe and provides callbacks to handle the items it emits and any error notification it issues.
final @NonNull Disposable	Maybe.subscribe(@NonNull Consumer<? super @NonNull T> onSuccess, @NonNull Consumer<? super 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.
final @NonNull Disposable	Maybe.subscribe(@NonNull Consumer<? super @NonNull T> onSuccess, @NonNull Consumer<? super 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.
final @NonNull Disposable	Observable.subscribe()	Subscribes to the current Observable and ignores onNext and onComplete emissions.
final @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.
final @NonNull Disposable	Observable.subscribe(@NonNull Consumer<? super @NonNull T> onNext, @NonNull Consumer<? super Throwable> onError)	Subscribes to the current Observable and provides callbacks to handle the items it emits and any error notification it signals.
final @NonNull Disposable	Observable.subscribe(@NonNull Consumer<? super @NonNull T> onNext, @NonNull Consumer<? super 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.
final @NonNull Disposable	Observable.subscribe(@NonNull Consumer<? super @NonNull T> onNext, @NonNull Consumer<? super 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.
final @NonNull Disposable	Single.subscribe()	Subscribes to a Single but ignore its emission or notification.
final @NonNull Disposable	Single.subscribe(@NonNull BiConsumer<@Nullable ? super @NonNull T, @Nullable ? super Throwable> onCallback)	Subscribes to a Single and provides a composite callback to handle the item it emits or any error notification it issues.
final @NonNull Disposable	Single.subscribe(@NonNull Consumer<? super @NonNull T> onSuccess)	Subscribes to a Single and provides a callback to handle the item it emits.
final @NonNull Disposable	Single.subscribe(@NonNull Consumer<? super @NonNull T> onSuccess, @NonNull Consumer<? super Throwable> onError)	Subscribes to a Single and provides callbacks to handle the item it emits or any error notification it issues.
final @NonNull Disposable	Single.subscribe(@NonNull Consumer<? super @NonNull T> onSuccess, @NonNull Consumer<? super 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
final @NonNull Completable	Completable.doOnLifecycle(@NonNull Consumer<? super Disposable> onSubscribe, @NonNull Action onDispose)	Calls the appropriate onXXX method (shared between all CompletableObservers) for the lifecycle events of the sequence (subscription, disposal).
private @NonNull Completable	Completable.doOnLifecycle(Consumer<? super Disposable> onSubscribe, Consumer<? super Throwable> onError, Action onComplete, Action onTerminate, Action onAfterTerminate, Action onDispose)	Returns a Completable instance that calls the various callbacks upon the specific lifecycle events.
final @NonNull Maybe<T>	Maybe.doOnLifecycle(@NonNull Consumer<? super Disposable> onSubscribe, @NonNull Action onDispose)	Calls the appropriate onXXX method (shared between all MaybeObservers) for the lifecycle events of the sequence (subscription, disposal).
final @NonNull Observable<T>	Observable.doOnLifecycle(@NonNull Consumer<? super Disposable> onSubscribe, @NonNull Action onDispose)	Calls the appropriate onXXX method (shared between all Observers) for the lifecycle events of the sequence (subscription, disposal).
final @NonNull Single<T>	Single.doOnLifecycle(@NonNull Consumer<? super Disposable> onSubscribe, @NonNull Action onDispose)	Calls the appropriate onXXX method (shared between all SingleObservers) for the lifecycle events of the sequence (subscription, disposal).
final @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 CompletableObservers receive upon subscription.
final @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.
final @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 Observers.
final @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) final class	ActionDisposable	A Disposable container that manages an Action instance.
(package private) final class	AutoCloseableDisposable	A disposable container that manages an AutoCloseable instance.
final class	CompositeDisposable	A disposable container that can hold onto multiple other Disposables and offers O(1) time complexity for CompositeDisposable.add(Disposable), CompositeDisposable.remove(Disposable) and CompositeDisposable.delete(Disposable) operations.
(package private) final 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) final class	RunnableDisposable	A disposable container that manages a Runnable instance.
final 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) final 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) final 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 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 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 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 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 Disposables 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 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 Throwables till the end.

Constructors in io.reactivex.rxjava3.disposables with parameters of type Disposable

Modifier	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

Modifier	Constructor	Description
	CompositeDisposable(@NonNull 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
final @NonNull Disposable	ConnectableFlowable.connect()	Instructs the ConnectableFlowable to begin emitting the items from its underlying Flowable to its Subscribers.

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 Subscribers 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 Subscribers.

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

Classes in io.reactivex.rxjava3.internal.disposables that implement Disposable

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

Subclasses with type arguments of type Disposable in io.reactivex.rxjava3.internal.disposables

Modifier and Type	Class	Description
final class	ArrayCompositeDisposable	A composite disposable with a fixed number of slots.
final 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) 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(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(AtomicReference<Disposable> field, Disposable d)	Atomically sets the field and disposes the old contents.
static boolean	DisposableHelper.setOnce(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(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(AtomicReference<Disposable> field)	Atomically disposes the Disposable in the field if not already disposed.
(package private) void	ListCompositeDisposable.dispose(List<Disposable> set)
static boolean	DisposableHelper.replace(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(AtomicReference<Disposable> field, Disposable d)	Atomically sets the field and disposes the old contents.
static boolean	DisposableHelper.setOnce(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(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

Modifier	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

Modifier	Constructor	Description
	ListCompositeDisposable(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.
final 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 final class	CompletableFromCompletionStage.CompletionStageHandler<T>
(package private) static final class	FlowableCollectWithCollectorSingle.CollectorSingleObserver<T,A,R>
(package private) static final class	MaybeFlattenStreamAsObservable.FlattenStreamMultiObserver<T,R>
(package private) static final class	MaybeFromCompletionStage.CompletionStageHandler<T>
(package private) static final class	MaybeMapOptional.MapOptionalMaybeObserver<T,R>
(package private) static final class	ObservableCollectWithCollector.CollectorObserver<T,A,R>
(package private) static final class	ObservableCollectWithCollectorSingle.CollectorSingleObserver<T,A,R>
(package private) static final class	ObservableFlatMapStream.FlatMapStreamObserver<T,R>
(package private) static final class	ObservableFromCompletionStage.CompletionStageHandler<T>
(package private) static final class	ObservableFromStream.StreamDisposable<T>
(package private) static final class	ObservableMapOptional.MapOptionalObserver<T,R>
(package private) static final class	SingleFromCompletionStage.CompletionStageHandler<T>
(package private) static final 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) final AtomicReference<Disposable>	CompletionStageConsumer.upstream
(package private) final 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)
final 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.
final class	BiConsumerSingleObserver<T>
class	BlockingBaseObserver<T>
final class	BlockingDisposableMultiObserver<T>	Blocks until the upstream terminates and dispatches the outcome to the actual observer.
final class	BlockingFirstObserver<T>	Blocks until the upstream signals its first value or completes.
final class	BlockingLastObserver<T>	Blocks until the upstream signals its last value or completes.
final class	BlockingObserver<T>
final class	CallbackCompletableObserver
final 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.
final class	DisposableAutoReleaseMultiObserver<T>	Wraps lambda callbacks and when the upstream terminates or this (Single | Maybe | Completable) observer gets disposed, removes itself from a CompositeDisposable.
final class	DisposableAutoReleaseObserver<T>	Wraps lambda callbacks and when the upstream terminates or this observer gets disposed, removes itself from a CompositeDisposable.
final class	DisposableLambdaObserver<T>
final class	EmptyCompletableObserver
final class	ForEachWhileObserver<T>
final class	FutureMultiObserver<T>	An Observer + Future that expects exactly one upstream value and provides it via the (blocking) Future API.
final class	FutureObserver<T>	An Observer + Future that expects exactly one upstream value and provides it via the (blocking) Future API.
final class	InnerQueuedObserver<T>	Subscriber that can fuse with the upstream and calls a support interface whenever an event is available.
final class	LambdaObserver<T>

Subclasses with type arguments of type Disposable in io.reactivex.rxjava3.internal.observers

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.
final class	BiConsumerSingleObserver<T>
final class	BlockingObserver<T>
final class	CallbackCompletableObserver
final class	ConsumerSingleObserver<T>
final class	EmptyCompletableObserver
final class	ForEachWhileObserver<T>
final class	InnerQueuedObserver<T>	Subscriber that can fuse with the upstream and calls a support interface whenever an event is available.
final 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) final Consumer<? super Disposable>	DisposableLambdaObserver.onSubscribe
(package private) final Consumer<? super Disposable>	LambdaObserver.onSubscribe
(package private) final AtomicReference<Disposable>	ResumeSingleObserver.parent
(package private) final AtomicReference<Disposable>	FutureMultiObserver.upstream
(package private) final AtomicReference<Disposable>	FutureObserver.upstream

Methods in io.reactivex.rxjava3.internal.observers with parameters of type Disposable

Modifier and Type	Method	Description
protected final void	QueueDrainObserver.fastPathEmit(U value, boolean delayError, Disposable dispose)
protected final void	QueueDrainObserver.fastPathOrderedEmit(U value, boolean delayError, Disposable disposable)	Makes sure the fast-path emits in order.
final void	AbstractDisposableAutoRelease.onSubscribe(Disposable d)
final void	BasicFuseableObserver.onSubscribe(Disposable d)
void	BiConsumerSingleObserver.onSubscribe(Disposable d)
final 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

Modifier	Constructor	Description
	DisposableLambdaObserver(Observer<? super T> actual, Consumer<? super Disposable> onSubscribe, Action onDispose)
	ResumeSingleObserver(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 final class	CompletableAndThenCompletable.SourceObserver
(package private) final class	CompletableCache.InnerCompletableCache
(package private) static final class	CompletableConcat.CompletableConcatSubscriber
(package private) static final class	CompletableCreate.Emitter
(package private) static final class	CompletableDelay.Delay
(package private) static final class	CompletableDetach.DetachCompletableObserver
(package private) static final class	CompletableDisposeOn.DisposeOnObserver
(package private) static final class	CompletableDoFinally.DoFinallyObserver
(package private) static final class	CompletableFromPublisher.FromPublisherSubscriber<T>
(package private) static final class	CompletableHide.HideCompletableObserver
(package private) static final class	CompletableMerge.CompletableMergeSubscriber
(package private) final class	CompletableMerge.CompletableMergeSubscriber.MergeInnerObserver
(package private) static final class	CompletableMergeArray.InnerCompletableObserver
(package private) static final class	CompletableMergeArrayDelayError.TryTerminateAndReportDisposable
(package private) static final class	CompletableMergeIterable.MergeCompletableObserver
(package private) static final class	CompletableObserveOn.ObserveOnCompletableObserver
(package private) static final class	CompletableOnErrorReturn.OnErrorReturnMaybeObserver<T>
(package private) final class	CompletablePeek.CompletableObserverImplementation
(package private) static final class	CompletableResumeNext.ResumeNextObserver
(package private) static final class	CompletableSubscribeOn.SubscribeOnObserver
(package private) static final class	CompletableTakeUntilCompletable.TakeUntilMainObserver
(package private) static final class	CompletableTimer.TimerDisposable
(package private) static final class	CompletableUsing.UsingObserver<R>

Subclasses with type arguments of type Disposable in io.reactivex.rxjava3.internal.operators.completable

Modifier and Type	Class	Description
(package private) static final class	CompletableAndThenCompletable.SourceObserver
(package private) static final class	CompletableConcat.CompletableConcatSubscriber.ConcatInnerObserver
(package private) static final class	CompletableCreate.Emitter
(package private) static final class	CompletableDelay.Delay
(package private) final class	CompletableMerge.CompletableMergeSubscriber.MergeInnerObserver
(package private) static final class	CompletableObserveOn.ObserveOnCompletableObserver
(package private) static final class	CompletableResumeNext.ResumeNextObserver
(package private) static final class	CompletableSubscribeOn.SubscribeOnObserver
(package private) static final class	CompletableTakeUntilCompletable.TakeUntilMainObserver
(package private) static final class	CompletableTakeUntilCompletable.TakeUntilMainObserver.OtherObserver
(package private) static final class	CompletableTimer.TimerDisposable

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) final Consumer<? super Disposable>	CompletablePeek.onSubscribe
(package private) final 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

Modifier	Constructor	Description
	CompletablePeek(CompletableSource source, Consumer<? super Disposable> onSubscribe, Consumer<? super Throwable> onError, Action onComplete, Action onTerminate, Action onAfterTerminate, Action onDispose)
(package private)	NextObserver(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 final class	BlockingFlowableIterable.BlockingFlowableIterator<T>
(package private) static final class	BlockingFlowableLatest.LatestSubscriberIterator<T>	Subscriber of source, iterator for output.
(package private) static final class	BlockingFlowableNext.NextSubscriber<T>
(package private) static final class	FlowableAllSingle.AllSubscriber<T>
(package private) static final class	FlowableAnySingle.AnySubscriber<T>
(package private) static final class	FlowableBufferBoundary.BufferBoundarySubscriber.BufferOpenSubscriber<Open>
(package private) static final class	FlowableBufferBoundary.BufferCloseSubscriber<T, C extends Collection<? super T>>
(package private) static final class	FlowableBufferExactBoundary.BufferBoundarySubscriber<T, U extends Collection<? super T>, B>
(package private) static final class	FlowableBufferExactBoundary.BufferExactBoundarySubscriber<T, U extends Collection<? super T>, B>
(package private) static final class	FlowableBufferTimed.BufferExactBoundedSubscriber<T, U extends Collection<? super T>>
(package private) static final class	FlowableBufferTimed.BufferExactUnboundedSubscriber<T, U extends Collection<? super T>>
(package private) static final class	FlowableCollectSingle.CollectSubscriber<T,U>
(package private) static final class	FlowableCountSingle.CountSubscriber
(package private) static final class	FlowableDebounce.DebounceSubscriber.DebounceInnerSubscriber<T,U>
(package private) static final class	FlowableDebounceTimed.DebounceEmitter<T>
(package private) static final class	FlowableElementAtMaybe.ElementAtSubscriber<T>
(package private) static final class	FlowableElementAtSingle.ElementAtSubscriber<T>
(package private) static final class	FlowableFlatMap.InnerSubscriber<T,U>
(package private) final class	FlowableFlatMapCompletable.FlatMapCompletableMainSubscriber.InnerConsumer
(package private) static final class	FlowableFlatMapCompletableCompletable.FlatMapCompletableMainSubscriber<T>
(package private) final class	FlowableFlatMapCompletableCompletable.FlatMapCompletableMainSubscriber.InnerObserver
(package private) final class	FlowableFlatMapMaybe.FlatMapMaybeSubscriber.InnerObserver
(package private) final class	FlowableFlatMapSingle.FlatMapSingleSubscriber.InnerObserver
static final class	FlowableFromCompletable.FromCompletableObserver<T>
(package private) static final class	FlowableGroupJoin.LeftRightEndSubscriber
(package private) static final class	FlowableGroupJoin.LeftRightSubscriber
(package private) static final class	FlowableIgnoreElementsCompletable.IgnoreElementsSubscriber<T>
(package private) static final class	FlowableLastMaybe.LastSubscriber<T>
(package private) static final class	FlowableLastSingle.LastSubscriber<T>
(package private) static final class	FlowablePublish.PublishConnection<T>
(package private) static final class	FlowableReduceMaybe.ReduceSubscriber<T>
(package private) static final class	FlowableReduceSeedSingle.ReduceSeedObserver<T,R>
(package private) static final class	FlowableReplay.InnerSubscription<T>	A Subscription that manages the request and cancellation state of a child subscriber in thread-safe manner.
(package private) static final class	FlowableReplay.ReplaySubscriber<T>
(package private) static final class	FlowableSequenceEqualSingle.EqualCoordinator<T>
(package private) static final class	FlowableSingleMaybe.SingleElementSubscriber<T>
(package private) static final class	FlowableSingleSingle.SingleElementSubscriber<T>
(package private) static final class	FlowableTimeout.TimeoutConsumer
(package private) static final class	FlowableToListSingle.ToListSubscriber<T, U extends Collection<? super T>>
(package private) static final class	FlowableWindowBoundary.WindowBoundaryInnerSubscriber<T,B>
(package private) static final class	FlowableWindowBoundarySelector.WindowBoundaryMainSubscriber.WindowEndSubscriberIntercept<T,V>

Subclasses with type arguments of type Disposable in io.reactivex.rxjava3.internal.operators.flowable

Modifier and Type	Class	Description
(package private) static final class	FlowableConcatWithCompletable.ConcatWithSubscriber<T>
(package private) static final class	FlowableDebounceTimed.DebounceEmitter<T>
(package private) final class	FlowableFlatMapCompletable.FlatMapCompletableMainSubscriber.InnerConsumer
(package private) final class	FlowableFlatMapCompletableCompletable.FlatMapCompletableMainSubscriber.InnerObserver
(package private) final class	FlowableFlatMapMaybe.FlatMapMaybeSubscriber.InnerObserver
(package private) final class	FlowableFlatMapSingle.FlatMapSingleSubscriber.InnerObserver
(package private) static final class	FlowableMergeWithCompletable.MergeWithSubscriber.OtherObserver
(package private) static final class	FlowableMergeWithMaybe.MergeWithObserver.OtherObserver<T>
(package private) static final class	FlowableMergeWithSingle.MergeWithObserver.OtherObserver<T>
(package private) static final class	FlowableRefCount.RefConnection
(package private) static final class	FlowableTimer.TimerSubscriber

Classes in io.reactivex.rxjava3.internal.operators.flowable that implement interfaces with type arguments of type Disposable

Modifier and Type	Class	Description
(package private) static final class	FlowableRefCount.RefConnection
(package private) final class	FlowableReplay.MulticastFlowable.DisposableConsumer

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) final Consumer<? super Disposable>	FlowableAutoConnect.connection
(package private) final AtomicReference<Disposable>	FlowableDebounce.DebounceSubscriber.debouncer
(package private) final AtomicReference<Disposable>	FlowableConcatWithMaybe.ConcatWithSubscriber.otherDisposable
(package private) final AtomicReference<Disposable>	FlowableConcatWithSingle.ConcatWithSubscriber.otherDisposable
(package private) final AtomicReference<Disposable>	FlowableInterval.IntervalSubscriber.resource
(package private) final AtomicReference<Disposable>	FlowableIntervalRange.IntervalRangeSubscriber.resource
(package private) final 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, 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)
final 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

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

Subclasses with type arguments of type Disposable in io.reactivex.rxjava3.internal.operators.maybe

Modifier and Type	Class	Description
final class	MaybeCallbackObserver<T>	MaybeObserver that delegates the onSuccess, onError and onComplete method calls to callbacks.
(package private) static final class	MaybeCreate.Emitter<T>
(package private) static final class	MaybeDelay.DelayMaybeObserver<T>
(package private) static final class	MaybeDelaySubscriptionOtherPublisher.DelayMaybeObserver<T>
(package private) static final class	MaybeDelayWithCompletable.OtherObserver<T>
(package private) static final class	MaybeEqualSingle.EqualObserver<T>
(package private) static final class	MaybeFlatMapBiSelector.FlatMapBiMainObserver.InnerObserver<T,U,R>
(package private) static final class	MaybeFlatMapCompletable.FlatMapCompletableObserver<T>
(package private) static final class	MaybeFlatMapNotification.FlatMapMaybeObserver<T,R>
(package private) static final class	MaybeFlatMapSingle.FlatMapMaybeObserver<T,R>
(package private) static final class	MaybeFlatten.FlatMapMaybeObserver<T,R>
(package private) static final class	MaybeObserveOn.ObserveOnMaybeObserver<T>
(package private) static final class	MaybeOnErrorNext.OnErrorNextMaybeObserver<T>
(package private) static final class	MaybeSubscribeOn.SubscribeOnMaybeObserver<T>
(package private) static final class	MaybeSwitchIfEmpty.SwitchIfEmptyMaybeObserver<T>
(package private) static final class	MaybeSwitchIfEmptySingle.SwitchIfEmptyMaybeObserver<T>
(package private) static final class	MaybeTakeUntilMaybe.TakeUntilMainMaybeObserver<T,U>
(package private) static final class	MaybeTakeUntilMaybe.TakeUntilMainMaybeObserver.TakeUntilOtherMaybeObserver<U>
(package private) static final class	MaybeTakeUntilPublisher.TakeUntilMainMaybeObserver<T,U>
(package private) static final class	MaybeTimeoutMaybe.TimeoutFallbackMaybeObserver<T>
(package private) static final class	MaybeTimeoutMaybe.TimeoutMainMaybeObserver<T,U>
(package private) static final class	MaybeTimeoutMaybe.TimeoutOtherMaybeObserver<T,U>
(package private) static final class	MaybeTimeoutPublisher.TimeoutFallbackMaybeObserver<T>
(package private) static final class	MaybeTimeoutPublisher.TimeoutMainMaybeObserver<T,U>
(package private) static final class	MaybeTimer.TimerDisposable
(package private) static final class	MaybeUnsubscribeOn.UnsubscribeOnMaybeObserver<T>
(package private) static final class	MaybeZipArray.ZipMaybeObserver<T>

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) final Consumer<? super Disposable>	MaybeDoOnLifecycle.MaybeLifecycleObserver.onSubscribe
(package private) final Consumer<? super Disposable>	MaybeDoOnLifecycle.onSubscribe
(package private) final Consumer<? super Disposable>	MaybePeek.onSubscribeCall
(package private) final AtomicReference<Disposable>	MaybeDelayWithCompletable.DelayWithMainObserver.parent
(package private) final AtomicReference<Disposable>	MaybeFlatMapSingle.FlatMapSingleObserver.parent
(package private) final AtomicReference<Disposable>	MaybeSwitchIfEmpty.SwitchIfEmptyMaybeObserver.OtherMaybeObserver.parent
(package private) final AtomicReference<Disposable>	MaybeSwitchIfEmptySingle.SwitchIfEmptyMaybeObserver.OtherSingleObserver.parent
(package private) final 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

Modifier	Constructor	Description
(package private)	DelayWithMainObserver(AtomicReference<Disposable> parent, MaybeObserver<? super T> downstream)
(package private)	FlatMapSingleObserver(AtomicReference<Disposable> parent, MaybeObserver<? super R> downstream)
	MaybeDoOnLifecycle(Maybe<T> upstream, Consumer<? super Disposable> onSubscribe, Action onDispose)
(package private)	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 Throwable> onErrorCall, Action onCompleteCall, Action onAfterTerminate, Action onDispose)
(package private)	NextMaybeObserver(MaybeObserver<? super T> actual, AtomicReference<Disposable> d)
(package private)	OtherMaybeObserver(MaybeObserver<? super T> actual, AtomicReference<Disposable> parent)
(package private)	OtherSingleObserver(SingleObserver<? super T> actual, 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 final class	CompletableAndThenObservable.AndThenObservableObserver<R>
class	ConcatMapXMainObserver<T>	Base class for implementing concatMapX main observers.
(package private) static final class	FlowableConcatMapCompletable.ConcatMapCompletableObserver<T>
(package private) static final class	FlowableSwitchMapCompletable.SwitchMapCompletableObserver<T>
final 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 final class	MaybeFlatMapObservable.FlatMapObserver<T,R>
(package private) static final class	ObservableConcatMapCompletable.ConcatMapCompletableObserver<T>
(package private) static final class	ObservableConcatMapMaybe.ConcatMapMaybeMainObserver<T,R>
(package private) static final class	ObservableConcatMapSingle.ConcatMapSingleMainObserver<T,R>
(package private) static final class	ObservableSwitchMapCompletable.SwitchMapCompletableObserver<T>
(package private) static final class	ObservableSwitchMapMaybe.SwitchMapMaybeMainObserver<T,R>
(package private) static final class	ObservableSwitchMapSingle.SwitchMapSingleMainObserver<T,R>
(package private) static final class	SingleFlatMapObservable.FlatMapObserver<T,R>

Subclasses with type arguments of type Disposable in io.reactivex.rxjava3.internal.operators.mixed

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

Subclasses with type arguments of type Disposable in io.reactivex.rxjava3.internal.operators.observable

Modifier and Type	Class	Description
(package private) static final class	BlockingObservableIterable.BlockingObservableIterator<T>
(package private) static final class	ObservableAmb.AmbInnerObserver<T>
(package private) static final class	ObservableBufferBoundary.BufferBoundaryObserver.BufferOpenObserver<Open>
(package private) static final class	ObservableBufferBoundary.BufferCloseObserver<T, C extends Collection<? super T>>
(package private) static final class	ObservableCombineLatest.CombinerObserver<T,R>
(package private) static final class	ObservableConcatMap.ConcatMapDelayErrorObserver.DelayErrorInnerObserver<R>
(package private) static final class	ObservableConcatMap.SourceObserver.InnerObserver<U>
(package private) static final class	ObservableConcatMapScheduler.ConcatMapDelayErrorObserver.DelayErrorInnerObserver<R>
(package private) static final class	ObservableConcatMapScheduler.ConcatMapObserver.InnerObserver<U>
(package private) static final class	ObservableConcatWithCompletable.ConcatWithObserver<T>
(package private) static final class	ObservableConcatWithMaybe.ConcatWithObserver<T>
(package private) static final class	ObservableConcatWithSingle.ConcatWithObserver<T>
(package private) static final class	ObservableCreate.CreateEmitter<T>
(package private) static final class	ObservableDebounceTimed.DebounceEmitter<T>
(package private) static final class	ObservableFlatMap.InnerObserver<T,U>
(package private) final class	ObservableFlatMapCompletable.FlatMapCompletableMainObserver.InnerObserver
(package private) final class	ObservableFlatMapCompletableCompletable.FlatMapCompletableMainObserver.InnerObserver
(package private) final class	ObservableFlatMapMaybe.FlatMapMaybeObserver.InnerObserver
(package private) final class	ObservableFlatMapSingle.FlatMapSingleObserver.InnerObserver
(package private) static final class	ObservableGroupJoin.LeftRightEndObserver
(package private) static final class	ObservableGroupJoin.LeftRightObserver
(package private) static final class	ObservableInterval.IntervalObserver
(package private) static final class	ObservableIntervalRange.IntervalRangeObserver
(package private) static final class	ObservableMergeWithCompletable.MergeWithObserver.OtherObserver
(package private) static final class	ObservableMergeWithMaybe.MergeWithObserver.OtherObserver<T>
(package private) static final class	ObservableMergeWithSingle.MergeWithObserver.OtherObserver<T>
(package private) static final class	ObservablePublishSelector.TargetObserver<R>
(package private) static final class	ObservableRefCount.RefConnection
(package private) final class	ObservableRepeatWhen.RepeatWhenObserver.InnerRepeatObserver
(package private) static final class	ObservableReplay.ReplayObserver<T>
(package private) final class	ObservableRetryWhen.RepeatWhenObserver.InnerRepeatObserver
(package private) static final class	ObservableSubscribeOn.SubscribeOnObserver<T>
(package private) static final class	ObservableSwitchMap.SwitchMapInnerObserver<T,R>
(package private) final class	ObservableTakeUntil.TakeUntilMainObserver.OtherObserver
(package private) static final class	ObservableThrottleFirstTimed.DebounceTimedObserver<T>
(package private) static final class	ObservableTimeout.TimeoutConsumer
(package private) static final class	ObservableTimeout.TimeoutFallbackObserver<T>
(package private) static final class	ObservableTimeoutTimed.TimeoutFallbackObserver<T>
(package private) static final class	ObservableTimer.TimerObserver
(package private) static final class	ObservableWindowBoundarySelector.WindowBoundaryMainObserver.WindowStartObserver<B>
(package private) static final class	ObservableWithLatestFromMany.WithLatestInnerObserver
final class	ObserverResourceWrapper<T>

Classes in io.reactivex.rxjava3.internal.operators.observable that implement interfaces with type arguments of type Disposable

Modifier and Type	Class	Description
(package private) static final class	ObservableRefCount.RefConnection
(package private) static final class	ObservableReplay.DisposeConsumer<R>

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) final AtomicReference<Disposable>	ObservableTimeoutTimed.FallbackObserver.arbiter
(package private) final Consumer<? super Disposable>	ObservableAutoConnect.connection
(package private) final AtomicReference<Disposable>	ObservableDebounce.DebounceObserver.debouncer
(package private) final AtomicReference<Disposable>	ObservableMergeWithCompletable.MergeWithObserver.mainDisposable
(package private) final AtomicReference<Disposable>	ObservableMergeWithMaybe.MergeWithObserver.mainDisposable
(package private) final AtomicReference<Disposable>	ObservableMergeWithSingle.MergeWithObserver.mainDisposable
private final Consumer<? super Disposable>	ObservableDoOnLifecycle.onSubscribe
(package private) final AtomicReference<Disposable>	ObservableSampleWithObservable.SampleMainObserver.other
(package private) final AtomicReference<Disposable>	ObservableWithLatestFrom.WithLatestFromObserver.other
(package private) final AtomicReference<Disposable>	ObservablePublishSelector.SourceObserver.target
(package private) final AtomicReference<Disposable>	ObservableBufferTimed.BufferExactUnboundedObserver.timer
(package private) final AtomicReference<Disposable>	ObservableSampleTimed.SampleTimedObserver.timer
(package private) final AtomicReference<Disposable>	ObservableBufferBoundary.BufferBoundaryObserver.upstream
(package private) final AtomicReference<Disposable>	ObservablePublish.PublishConnection.upstream
(package private) final AtomicReference<Disposable>	ObservableRepeatWhen.RepeatWhenObserver.upstream
(package private) final AtomicReference<Disposable>	ObservableRetryWhen.RepeatWhenObserver.upstream
(package private) final AtomicReference<Disposable>	ObservableSubscribeOn.SubscribeOnObserver.upstream
(package private) final AtomicReference<Disposable>	ObservableTakeUntil.TakeUntilMainObserver.upstream
(package private) final AtomicReference<Disposable>	ObservableTimeout.TimeoutFallbackObserver.upstream
(package private) final AtomicReference<Disposable>	ObservableTimeout.TimeoutObserver.upstream
(package private) final AtomicReference<Disposable>	ObservableTimeoutTimed.TimeoutFallbackObserver.upstream
(package private) final AtomicReference<Disposable>	ObservableTimeoutTimed.TimeoutObserver.upstream
(package private) final AtomicReference<Disposable>	ObservableWindowBoundary.WindowBoundaryMainObserver.upstream
(package private) final AtomicReference<Disposable>	ObservableWindowBoundarySelector.WindowBoundaryMainObserver.WindowEndObserverIntercept.upstream
(package private) final AtomicReference<Disposable>	ObservableWithLatestFrom.WithLatestFromObserver.upstream
(package private) final AtomicReference<Disposable>	ObservableWithLatestFromMany.WithLatestFromObserver.upstream
(package private) final AtomicReference<Disposable>	ObservableZip.ZipObserver.upstream
(package private) final 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, 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)
final 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

Modifier	Constructor	Description
(package private)	FallbackObserver(Observer<? super T> actual, AtomicReference<Disposable> arbiter)
	ObservableAutoConnect(ConnectableObservable<? extends T> source, int numberOfObservers, Consumer<? super Disposable> connection)
	ObservableDoOnLifecycle(Observable<T> upstream, Consumer<? super Disposable> onSubscribe, Action onDispose)
(package private)	SourceObserver(PublishSubject<T> subject, 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 final class	SingleCache.CacheDisposable<T>
(package private) static final class	SingleCreate.Emitter<T>
(package private) static final class	SingleDelayWithCompletable.OtherObserver<T>
(package private) static final class	SingleDelayWithObservable.OtherSubscriber<T,U>
(package private) static final class	SingleDelayWithPublisher.OtherSubscriber<T,U>
(package private) static final class	SingleDelayWithSingle.OtherObserver<T,U>
(package private) static final class	SingleDematerialize.DematerializeObserver<T,R>
(package private) static final class	SingleDetach.DetachSingleObserver<T>
(package private) static final class	SingleDoAfterSuccess.DoAfterObserver<T>
(package private) static final class	SingleDoAfterTerminate.DoAfterTerminateObserver<T>
(package private) static final class	SingleDoFinally.DoFinallyObserver<T>
(package private) static final class	SingleDoOnDispose.DoOnDisposeObserver<T>
(package private) static final class	SingleDoOnLifecycle.SingleLifecycleObserver<T>
(package private) static final class	SingleFlatMap.SingleFlatMapCallback<T,R>
(package private) static final class	SingleFlatMapBiSelector.FlatMapBiMainObserver<T,U,R>
(package private) static final class	SingleFlatMapCompletable.FlatMapCompletableObserver<T>
(package private) static final class	SingleFlatMapIterableObservable.FlatMapIterableObserver<T,R>
(package private) static final class	SingleFlatMapMaybe.FlatMapSingleObserver<T,R>
(package private) static final class	SingleFlatMapNotification.FlatMapSingleObserver<T,R>
(package private) static final class	SingleFromPublisher.ToSingleObserver<T>
(package private) static final class	SingleHide.HideSingleObserver<T>
(package private) static final class	SingleObserveOn.ObserveOnSingleObserver<T>
(package private) static final class	SingleResumeNext.ResumeMainSingleObserver<T>
(package private) static final class	SingleSubscribeOn.SubscribeOnObserver<T>
(package private) static final class	SingleTakeUntil.TakeUntilMainObserver<T>
(package private) static final class	SingleTimeInterval.TimeIntervalSingleObserver<T>
(package private) static final class	SingleTimeout.TimeoutMainObserver<T>
(package private) static final class	SingleTimer.TimerDisposable
(package private) static final class	SingleToObservable.SingleToObservableObserver<T>
(package private) static final class	SingleUnsubscribeOn.UnsubscribeOnSingleObserver<T>
(package private) static final class	SingleUsing.UsingSingleObserver<T,U>
(package private) static final class	SingleZipArray.ZipCoordinator<T,R>

Subclasses with type arguments of type Disposable in io.reactivex.rxjava3.internal.operators.single

Modifier and Type	Class	Description
(package private) static final class	SingleCreate.Emitter<T>
(package private) static final class	SingleDelayWithCompletable.OtherObserver<T>
(package private) static final class	SingleDelayWithObservable.OtherSubscriber<T,U>
(package private) static final class	SingleDelayWithPublisher.OtherSubscriber<T,U>
(package private) static final class	SingleDelayWithSingle.OtherObserver<T,U>
(package private) static final class	SingleFlatMap.SingleFlatMapCallback<T,R>
(package private) static final class	SingleFlatMapBiSelector.FlatMapBiMainObserver.InnerObserver<T,U,R>
(package private) static final class	SingleFlatMapCompletable.FlatMapCompletableObserver<T>
(package private) static final class	SingleFlatMapMaybe.FlatMapSingleObserver<T,R>
(package private) static final class	SingleFlatMapNotification.FlatMapSingleObserver<T,R>
(package private) static final class	SingleObserveOn.ObserveOnSingleObserver<T>
(package private) static final class	SingleResumeNext.ResumeMainSingleObserver<T>
(package private) static final class	SingleSubscribeOn.SubscribeOnObserver<T>
(package private) static final class	SingleTakeUntil.TakeUntilMainObserver<T>
(package private) static final class	SingleTimeout.TimeoutMainObserver<T>
(package private) static final class	SingleTimeout.TimeoutMainObserver.TimeoutFallbackObserver<T>
(package private) static final class	SingleTimer.TimerDisposable
(package private) static final class	SingleUnsubscribeOn.UnsubscribeOnSingleObserver<T>
(package private) static final class	SingleZipArray.ZipSingleObserver<T>

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) final Consumer<? super Disposable>	SingleDoOnLifecycle.onSubscribe
(package private) final Consumer<? super Disposable>	SingleDoOnLifecycle.SingleLifecycleObserver.onSubscribe
(package private) final Consumer<? super Disposable>	SingleDoOnSubscribe.DoOnSubscribeSingleObserver.onSubscribe
(package private) final Consumer<? super Disposable>	SingleDoOnSubscribe.onSubscribe
(package private) final AtomicReference<Disposable>	SingleFlatMap.SingleFlatMapCallback.FlatMapSingleObserver.parent
(package private) final AtomicReference<Disposable>	SingleFlatMapMaybe.FlatMapMaybeObserver.parent
(package private) final 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

Modifier	Constructor	Description
(package private)	DoOnSubscribeSingleObserver(SingleObserver<? super T> actual, Consumer<? super Disposable> onSubscribe)
(package private)	FlatMapMaybeObserver(AtomicReference<Disposable> parent, MaybeObserver<? super R> downstream)
(package private)	FlatMapSingleObserver(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)
(package private)	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 final class	ComputationScheduler.EventLoopWorker
(package private) static final class	ComputationScheduler.PoolWorker
(package private) static final class	ExecutorScheduler.DelayedRunnable
static final class	ExecutorScheduler.ExecutorWorker
(package private) static final class	ExecutorScheduler.ExecutorWorker.BooleanRunnable
(package private) static final 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 final class	ImmediateThinScheduler.ImmediateThinWorker
(package private) final class	InstantPeriodicTask	Wrapper for a regular task that gets immediately rescheduled when the task completed.
(package private) static final class	IoScheduler.EventLoopWorker
(package private) static final class	IoScheduler.ThreadWorker
class	NewThreadWorker	Base class that manages a single-threaded ScheduledExecutorService as a worker but doesn't perform task-tracking operations.
final class	ScheduledDirectPeriodicTask	A Callable to be submitted to an ExecutorService that runs a Runnable action periodically and manages completion/cancellation.
final class	ScheduledDirectTask	A Callable to be submitted to an ExecutorService that runs a Runnable action and manages completion/cancellation.
final 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 final class	SchedulerWhen.QueueWorker
(package private) static class	SchedulerWhen.ScheduledAction
(package private) static final class	SchedulerWhen.SubscribedDisposable
(package private) static final class	SingleScheduler.ScheduledWorker
(package private) static final class	TrampolineScheduler.TrampolineWorker

Subclasses with type arguments of type Disposable in io.reactivex.rxjava3.internal.schedulers

Modifier and Type	Class	Description
(package private) static class	SchedulerWhen.ScheduledAction

Fields in io.reactivex.rxjava3.internal.schedulers declared as Disposable

Modifier and Type	Field	Description
private Disposable	SchedulerWhen.disposable
(package private) static final Disposable	ImmediateThinScheduler.DISPOSED
(package private) static final Disposable	SchedulerWhen.DISPOSED
(package private) static final Disposable	SchedulerWhen.SUBSCRIBED
(package private) final 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(Runnable action, long execTime)
@NonNull Disposable	ComputationScheduler.EventLoopWorker.schedule(@NonNull Runnable action)
@NonNull Disposable	ComputationScheduler.EventLoopWorker.schedule(@NonNull Runnable action, long delayTime, @NonNull TimeUnit unit)
@NonNull Disposable	ExecutorScheduler.ExecutorWorker.schedule(@NonNull Runnable run)
@NonNull Disposable	ExecutorScheduler.ExecutorWorker.schedule(@NonNull Runnable run, long delay, @NonNull TimeUnit unit)
@NonNull Disposable	ImmediateThinScheduler.ImmediateThinWorker.schedule(@NonNull Runnable run)
@NonNull Disposable	ImmediateThinScheduler.ImmediateThinWorker.schedule(@NonNull Runnable run, long delay, @NonNull TimeUnit unit)
@NonNull Disposable	IoScheduler.EventLoopWorker.schedule(@NonNull Runnable action, long delayTime, @NonNull TimeUnit unit)
@NonNull Disposable	NewThreadWorker.schedule(@NonNull Runnable run)
@NonNull Disposable	NewThreadWorker.schedule(@NonNull Runnable action, long delayTime, @NonNull TimeUnit unit)
@NonNull Disposable	SchedulerWhen.QueueWorker.schedule(@NonNull Runnable action)
@NonNull Disposable	SchedulerWhen.QueueWorker.schedule(@NonNull Runnable action, long delayTime, @NonNull TimeUnit unit)
@NonNull Disposable	SingleScheduler.ScheduledWorker.schedule(@NonNull Runnable run, long delay, @NonNull TimeUnit unit)
@NonNull Disposable	TrampolineScheduler.TrampolineWorker.schedule(@NonNull Runnable action)
@NonNull Disposable	TrampolineScheduler.TrampolineWorker.schedule(@NonNull Runnable action, long delayTime, @NonNull TimeUnit unit)
@NonNull Disposable	ComputationScheduler.scheduleDirect(@NonNull Runnable run, long delay, TimeUnit unit)
@NonNull Disposable	ExecutorScheduler.scheduleDirect(@NonNull Runnable run)
@NonNull Disposable	ExecutorScheduler.scheduleDirect(@NonNull Runnable run, long delay, TimeUnit unit)
@NonNull Disposable	ImmediateThinScheduler.scheduleDirect(@NonNull Runnable run)
@NonNull Disposable	ImmediateThinScheduler.scheduleDirect(@NonNull Runnable run, long delay, TimeUnit unit)
Disposable	NewThreadWorker.scheduleDirect(Runnable run, long delayTime, TimeUnit unit)	Schedules the given runnable on the underlying executor directly and returns its future wrapped into a Disposable.
@NonNull Disposable	SingleScheduler.scheduleDirect(@NonNull Runnable run, long delay, TimeUnit unit)
@NonNull Disposable	TrampolineScheduler.scheduleDirect(@NonNull Runnable run)
@NonNull Disposable	TrampolineScheduler.scheduleDirect(@NonNull Runnable run, long delay, TimeUnit unit)
@NonNull Disposable	ImmediateThinScheduler.ImmediateThinWorker.schedulePeriodically(@NonNull Runnable run, long initialDelay, long period, TimeUnit unit)
@NonNull Disposable	ComputationScheduler.schedulePeriodicallyDirect(@NonNull Runnable run, long initialDelay, long period, TimeUnit unit)
@NonNull Disposable	ExecutorScheduler.schedulePeriodicallyDirect(@NonNull Runnable run, long initialDelay, long period, TimeUnit unit)
@NonNull Disposable	ImmediateThinScheduler.schedulePeriodicallyDirect(@NonNull Runnable run, long initialDelay, long period, TimeUnit unit)
Disposable	NewThreadWorker.schedulePeriodicallyDirect(Runnable run, long initialDelay, long period, 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 Runnable run, long initialDelay, long period, TimeUnit unit)

Constructors in io.reactivex.rxjava3.internal.schedulers with parameters of type Disposable

Modifier	Constructor	Description
(package private)	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
final class	BoundedSubscriber<T>
final class	DisposableAutoReleaseSubscriber<T>	Wraps lambda callbacks and when the upstream terminates or this subscriber gets disposed, removes itself from a CompositeDisposable.
final class	ForEachWhileSubscriber<T>
final class	LambdaSubscriber<T>
final class	SubscriberResourceWrapper<T>

Subclasses with type arguments of type Disposable in io.reactivex.rxjava3.internal.subscribers

Modifier and Type	Class	Description
final class	SubscriberResourceWrapper<T>

Methods in io.reactivex.rxjava3.internal.subscribers with parameters of type Disposable

Modifier and Type	Method	Description
protected final void	QueueDrainSubscriber.fastPathEmitMax(U value, boolean delayError, Disposable dispose)
protected final 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
final class	ArrayCompositeSubscription	A composite disposable with a fixed number of slots.
final 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) final 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

Modifier	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
enum	EmptyComponent	Singleton implementing many interfaces as empty.

Classes in io.reactivex.rxjava3.internal.util that implement interfaces with type arguments of type Disposable

Modifier and Type	Class	Description
final class	ConnectConsumer	Store the Disposable received from the connection.

Fields in io.reactivex.rxjava3.internal.util declared as Disposable

Modifier and Type	Field	Description
Disposable	ConnectConsumer.disposable
(package private) final Disposable	NotificationLite.DisposableNotification.upstream

Methods in io.reactivex.rxjava3.internal.util that return Disposable

Modifier and Type	Method	Description
static Disposable	NotificationLite.getDisposable(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(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 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(AtomicReference<Disposable> upstream, Disposable next, 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, 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(AtomicReference<Disposable> upstream, Disposable next, 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

Modifier	Constructor	Description
(package private)	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
final @NonNull Disposable	ConnectableObservable.connect()	Instructs the ConnectableObservable to begin emitting the items from its underlying Observable to its Observers.

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 Observers 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 Observers.

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.
final class	SafeObserver<T>	Wraps another Observer and ensures all onXXX methods conform the protocol (except the requirement for serialized access).
final 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 Observables, Maybes, Singles and Completables 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) final AtomicReference<Disposable>	DisposableCompletableObserver.upstream
(package private) final AtomicReference<Disposable>	DisposableMaybeObserver.upstream
(package private) final AtomicReference<Disposable>	DisposableObserver.upstream
(package private) final AtomicReference<Disposable>	DisposableSingleObserver.upstream
private final AtomicReference<Disposable>	ResourceCompletableObserver.upstream	The active subscription.
private final AtomicReference<Disposable>	ResourceMaybeObserver.upstream	The active subscription.
private final AtomicReference<Disposable>	ResourceObserver.upstream	The active subscription.
private final AtomicReference<Disposable>	ResourceSingleObserver.upstream	The active subscription.
private final 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
final void	ResourceCompletableObserver.add(@NonNull Disposable resource)	Adds a resource to this ResourceCompletableObserver.
final void	ResourceMaybeObserver.add(@NonNull Disposable resource)	Adds a resource to this ResourceMaybeObserver.
final void	ResourceObserver.add(@NonNull Disposable resource)	Adds a resource to this ResourceObserver.
final void	ResourceSingleObserver.add(@NonNull Disposable resource)	Adds a resource to this ResourceSingleObserver.
final void	DefaultObserver.onSubscribe(@NonNull Disposable d)
final void	DisposableCompletableObserver.onSubscribe(@NonNull Disposable d)
final void	DisposableMaybeObserver.onSubscribe(@NonNull Disposable d)
final void	DisposableObserver.onSubscribe(@NonNull Disposable d)
final void	DisposableSingleObserver.onSubscribe(@NonNull Disposable d)
final void	ResourceCompletableObserver.onSubscribe(@NonNull Disposable d)
final void	ResourceMaybeObserver.onSubscribe(@NonNull Disposable d)
final void	ResourceObserver.onSubscribe(Disposable d)
final 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) final class	TestScheduler.TestWorker
(package private) final class	TestScheduler.TestWorker.QueueRemove

Methods in io.reactivex.rxjava3.schedulers that return Disposable

Modifier and Type	Method	Description
@NonNull Disposable	TestScheduler.TestWorker.schedule(@NonNull Runnable run)
@NonNull Disposable	TestScheduler.TestWorker.schedule(@NonNull Runnable run, long delayTime, @NonNull 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 final class	AsyncSubject.AsyncDisposable<T>
(package private) static final class	BehaviorSubject.BehaviorDisposable<T>
(package private) static final class	CompletableSubject.CompletableDisposable
(package private) static final class	MaybeSubject.MaybeDisposable<T>
(package private) static final 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 final class	ReplaySubject.ReplayDisposable<T>
(package private) static final class	SingleSubject.SingleDisposable<T>
(package private) final 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
final void	ResourceSubscriber.add(Disposable resource)	Adds a resource to this ResourceSubscriber.