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
andCompletable
; base reactive consumers; other common base interfaces.io.reactivex.rxjava3.disposables Default implementations forDisposable
-based resource management (Disposable
container types) and utility classes to constructDisposables
from callbacks and other types.io.reactivex.rxjava3.flowables Classes supporting the Flowable base reactive class:ConnectableFlowable
andGroupedFlowable
.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
andGroupedObservable
.io.reactivex.rxjava3.observers Default wrappers and implementations for observer-based consumer classes and interfaces, including disposable and resource-tracking variants and theTestObserver
that allows unit testingObservable
-,Single
-,Maybe
- andCompletable
-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 ofSchedulers
providing methods for retrieving the standard scheduler instances, theTestScheduler
for testing flows with scheduling in a controlled manner and the classTimed
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 forSubscriber
-based consumer classes and interfaces, including disposable (DisposableSubscriber
) and resource-tracking (ResourceSubscriber
) variants and theTestSubscriber
that allows unit testingFlowable
-based flows. -
-
Uses of Disposable in io.reactivex.rxjava3.core
Classes in io.reactivex.rxjava3.core that implement Disposable Modifier and Type Class Description (package private) static class
Scheduler.DisposeTask
(package private) static class
Scheduler.PeriodicDirectTask
static class
Scheduler.Worker
Represents an isolated, sequential worker of a parent Scheduler for executingRunnable
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>
SScheduler. when(@NonNull Function<Flowable<Flowable<Completable>>,Completable> combine)
Allows the use of operators for controlling the timing around when actions scheduled on workers are actually done.Methods in io.reactivex.rxjava3.core that return Disposable Modifier and Type Method Description @NonNull Disposable
Flowable. forEach(@NonNull Consumer<? super @NonNull T> onNext)
Subscribes to the currentFlowable
and receives notifications for each element.@NonNull Disposable
Observable. forEach(@NonNull Consumer<? super @NonNull T> onNext)
Subscribes to theObservableSource
and calls aConsumer
for each item of the currentObservable
on its emission thread.@NonNull Disposable
Flowable. forEachWhile(@NonNull Predicate<? super @NonNull T> onNext)
Subscribes to the currentFlowable
and receives notifications for each element until theonNext
Predicate returnsfalse
.@NonNull Disposable
Flowable. forEachWhile(@NonNull Predicate<? super @NonNull T> onNext, @NonNull Consumer<? super java.lang.Throwable> onError)
Subscribes to the currentFlowable
and receives notifications for each element and error events until theonNext
Predicate returnsfalse
.@NonNull Disposable
Flowable. forEachWhile(@NonNull Predicate<? super @NonNull T> onNext, @NonNull Consumer<? super java.lang.Throwable> onError, @NonNull Action onComplete)
Subscribes to the currentFlowable
and receives notifications for each element and the terminal events until theonNext
Predicate returnsfalse
.@NonNull Disposable
Observable. forEachWhile(@NonNull Predicate<? super @NonNull T> onNext)
Subscribes to theObservableSource
and calls aPredicate
for each item of the currentObservable
, on its emission thread, until the predicate returnsfalse
.@NonNull Disposable
Observable. forEachWhile(@NonNull Predicate<? super @NonNull T> onNext, @NonNull Consumer<? super java.lang.Throwable> onError)
Subscribes to theObservableSource
and calls aPredicate
for each item or aConsumer
with the error of the currentObservable
, on their original emission threads, until the predicate returnsfalse
.@NonNull Disposable
Observable. forEachWhile(@NonNull Predicate<? super @NonNull T> onNext, @NonNull Consumer<? super java.lang.Throwable> onError, @NonNull Action onComplete)
Subscribes to theObservableSource
and calls aPredicate
for each item, aConsumer
with the error or anAction
upon completion of the currentObservable
, on their original emission threads, until the predicate returnsfalse
.@NonNull Disposable
Scheduler.Worker. schedule(@NonNull java.lang.Runnable run)
Schedules a Runnable for execution without any time delay.abstract @NonNull Disposable
Scheduler.Worker. schedule(@NonNull java.lang.Runnable run, long delay, @NonNull java.util.concurrent.TimeUnit unit)
Schedules an Runnable for execution at some point in the future specified by a time delay relative to the current time.@NonNull Disposable
Scheduler. scheduleDirect(@NonNull java.lang.Runnable run)
Schedules the given task on this Scheduler without any time delay.@NonNull Disposable
Scheduler. scheduleDirect(@NonNull java.lang.Runnable run, long delay, @NonNull java.util.concurrent.TimeUnit unit)
Schedules the execution of the given task with the given time delay.@NonNull Disposable
Scheduler.Worker. schedulePeriodically(@NonNull java.lang.Runnable run, long initialDelay, long period, @NonNull java.util.concurrent.TimeUnit unit)
Schedules a periodic execution of the given task with the given initial time delay and repeat period.@NonNull Disposable
Scheduler. schedulePeriodicallyDirect(@NonNull java.lang.Runnable run, long initialDelay, long period, @NonNull java.util.concurrent.TimeUnit unit)
Schedules a periodic execution of the given task with the given initial time delay and repeat period.@NonNull Disposable
Completable. subscribe()
Subscribes to thisCompletable
and returns aDisposable
which can be used to dispose the subscription.@NonNull Disposable
Completable. subscribe(@NonNull Action onComplete)
@NonNull Disposable
Completable. subscribe(@NonNull Action onComplete, @NonNull Consumer<? super java.lang.Throwable> onError)
Subscribes to thisCompletable
and calls back either theonError
oronComplete
functions.@NonNull Disposable
Completable. subscribe(@NonNull Action onComplete, @NonNull Consumer<? super java.lang.Throwable> onError, @NonNull DisposableContainer container)
Wraps the given onXXX callbacks into aDisposable
CompletableObserver
, adds it to the givenDisposableContainer
and ensures, that if the upstream terminates or this particularDisposable
is disposed, theCompletableObserver
is removed from the given composite.@NonNull Disposable
Flowable. subscribe()
Subscribes to the currentFlowable
and ignoresonNext
andonComplete
emissions.@NonNull Disposable
Flowable. subscribe(@NonNull Consumer<? super @NonNull T> onNext)
Subscribes to the currentFlowable
and provides a callback to handle the items it emits.@NonNull Disposable
Flowable. subscribe(@NonNull Consumer<? super @NonNull T> onNext, @NonNull Consumer<? super java.lang.Throwable> onError)
Subscribes to the currentFlowable
and provides callbacks to handle the items it emits and any error notification it issues.@NonNull Disposable
Flowable. subscribe(@NonNull Consumer<? super @NonNull T> onNext, @NonNull Consumer<? super java.lang.Throwable> onError, @NonNull Action onComplete)
Subscribes to the currentFlowable
and provides callbacks to handle the items it emits and any error or completion notification it issues.@NonNull Disposable
Flowable. subscribe(@NonNull Consumer<? super @NonNull T> onNext, @NonNull Consumer<? super java.lang.Throwable> onError, @NonNull Action onComplete, @NonNull DisposableContainer container)
Wraps the given onXXX callbacks into aDisposable
Subscriber
, adds it to the givenDisposableContainer
and ensures, that if the upstream terminates or this particularDisposable
is disposed, theSubscriber
is removed from the given container.@NonNull Disposable
Maybe. subscribe()
Subscribes to aMaybe
and ignoresonSuccess
andonComplete
emissions.@NonNull Disposable
Maybe. subscribe(@NonNull Consumer<? super @NonNull T> onSuccess)
Subscribes to aMaybe
and provides a callback to handle the items it emits.@NonNull Disposable
Maybe. subscribe(@NonNull Consumer<? super @NonNull T> onSuccess, @NonNull Consumer<? super java.lang.Throwable> onError)
Subscribes to aMaybe
and provides callbacks to handle the items it emits and any error notification it issues.@NonNull Disposable
Maybe. subscribe(@NonNull Consumer<? super @NonNull T> onSuccess, @NonNull Consumer<? super java.lang.Throwable> onError, @NonNull Action onComplete)
Subscribes to aMaybe
and provides callbacks to handle the items it emits and any error or completion notification it issues.@NonNull Disposable
Maybe. subscribe(@NonNull Consumer<? super @NonNull T> onSuccess, @NonNull Consumer<? super java.lang.Throwable> onError, @NonNull Action onComplete, @NonNull DisposableContainer container)
Wraps the given onXXX callbacks into aDisposable
MaybeObserver
, adds it to the givenDisposableContainer
and ensures, that if the upstream terminates or this particularDisposable
is disposed, theMaybeObserver
is removed from the given composite.@NonNull Disposable
Observable. subscribe()
Subscribes to the currentObservable
and ignoresonNext
andonComplete
emissions.@NonNull Disposable
Observable. subscribe(@NonNull Consumer<? super @NonNull T> onNext)
Subscribes to the currentObservable
and provides a callback to handle the items it emits.@NonNull Disposable
Observable. subscribe(@NonNull Consumer<? super @NonNull T> onNext, @NonNull Consumer<? super java.lang.Throwable> onError)
Subscribes to the currentObservable
and provides callbacks to handle the items it emits and any error notification it signals.@NonNull Disposable
Observable. subscribe(@NonNull Consumer<? super @NonNull T> onNext, @NonNull Consumer<? super java.lang.Throwable> onError, @NonNull Action onComplete)
Subscribes to the currentObservable
and provides callbacks to handle the items it emits and any error or completion notification it signals.@NonNull Disposable
Observable. subscribe(@NonNull Consumer<? super @NonNull T> onNext, @NonNull Consumer<? super java.lang.Throwable> onError, @NonNull Action onComplete, @NonNull DisposableContainer container)
Wraps the given onXXX callbacks into aDisposable
Observer
, adds it to the givenDisposableContainer
and ensures, that if the upstream terminates or this particularDisposable
is disposed, theObserver
is removed from the given container.@NonNull Disposable
Single. subscribe()
Subscribes to aSingle
but ignore its emission or notification.@NonNull Disposable
Single. subscribe(@NonNull BiConsumer<? super @NonNull T,? super java.lang.Throwable> onCallback)
Subscribes to aSingle
and provides a composite callback to handle the item it emits or any error notification it issues.@NonNull Disposable
Single. subscribe(@NonNull Consumer<? super @NonNull T> onSuccess)
Subscribes to aSingle
and provides a callback to handle the item it emits.@NonNull Disposable
Single. subscribe(@NonNull Consumer<? super @NonNull T> onSuccess, @NonNull Consumer<? super java.lang.Throwable> onError)
Subscribes to aSingle
and provides callbacks to handle the item it emits or any error notification it issues.@NonNull Disposable
Single. subscribe(@NonNull Consumer<? super @NonNull T> onSuccess, @NonNull Consumer<? super java.lang.Throwable> onError, @NonNull DisposableContainer container)
Wraps the given onXXX callbacks into aDisposable
SingleObserver
, adds it to the givenDisposableContainer
and ensures, that if the upstream terminates or this particularDisposable
is disposed, theSingleObserver
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 theCompletable
to set aDisposable
on this instance which then can be used to cancel the subscription at any time.void
MaybeObserver. onSubscribe(@NonNull Disposable d)
Provides theMaybeObserver
with the means of cancelling (disposing) the connection (channel) with theMaybe
in both synchronous (from withinonSubscribe(Disposable)
itself) and asynchronous manner.void
Observer. onSubscribe(@NonNull Disposable d)
Provides theObserver
with the means of cancelling (disposing) the connection (channel) with theObservable
in both synchronous (from withinObserver.onNext(Object)
) and asynchronous manner.void
SingleObserver. onSubscribe(@NonNull Disposable d)
Provides theSingleObserver
with the means of cancelling (disposing) the connection (channel) with the Single in both synchronous (from withinonSubscribe(Disposable)
itself) and asynchronous manner.void
CompletableEmitter. setDisposable(@Nullable Disposable d)
Sets a Disposable on this emitter; any previousDisposable
orCancellable
will be disposed/cancelled.void
FlowableEmitter. setDisposable(@Nullable Disposable d)
Sets a Disposable on this emitter; any previousDisposable
orCancellable
will be disposed/cancelled.void
MaybeEmitter. setDisposable(@Nullable Disposable d)
Sets aDisposable
on this emitter; any previousDisposable
orCancellable
will be disposed/cancelled.void
ObservableEmitter. setDisposable(@Nullable Disposable d)
Sets aDisposable
on this emitter; any previousDisposable
orCancellable
will be disposed/cancelled.void
SingleEmitter. setDisposable(@Nullable Disposable d)
Sets aDisposable
on this emitter; any previousDisposable
orCancellable
will be disposed/cancelled.Method parameters in io.reactivex.rxjava3.core with type arguments of type Disposable Modifier and Type Method Description @NonNull Completable
Completable. doOnLifecycle(@NonNull Consumer<? super Disposable> onSubscribe, @NonNull Action onDispose)
Calls the appropriateonXXX
method (shared between allCompletableObserver
s) for the lifecycle events of the sequence (subscription, disposal).private @NonNull Completable
Completable. doOnLifecycle(Consumer<? super Disposable> onSubscribe, Consumer<? super java.lang.Throwable> onError, Action onComplete, Action onTerminate, Action onAfterTerminate, Action onDispose)
Returns aCompletable
instance that calls the various callbacks upon the specific lifecycle events.@NonNull Maybe<T>
Maybe. doOnLifecycle(@NonNull Consumer<? super Disposable> onSubscribe, @NonNull Action onDispose)
Calls the appropriateonXXX
method (shared between allMaybeObserver
s) for the lifecycle events of the sequence (subscription, disposal).@NonNull Observable<T>
Observable. doOnLifecycle(@NonNull Consumer<? super Disposable> onSubscribe, @NonNull Action onDispose)
Calls the appropriateonXXX
method (shared between allObserver
s) for the lifecycle events of the sequence (subscription, disposal).@NonNull Single<T>
Single. doOnLifecycle(@NonNull Consumer<? super Disposable> onSubscribe, @NonNull Action onDispose)
Calls the appropriateonXXX
method (shared between allSingleObserver
s) for the lifecycle events of the sequence (subscription, disposal).@NonNull Completable
Completable. doOnSubscribe(@NonNull Consumer<? super Disposable> onSubscribe)
Returns aCompletable
instance that calls the givenonSubscribe
callback with the disposable that the downstreamCompletableObserver
s receive upon subscription.@NonNull Maybe<T>
Maybe. doOnSubscribe(@NonNull Consumer<? super Disposable> onSubscribe)
Calls the sharedConsumer
with theDisposable
sent through theonSubscribe
for eachMaybeObserver
that subscribes to the currentMaybe
.@NonNull Observable<T>
Observable. doOnSubscribe(@NonNull Consumer<? super Disposable> onSubscribe)
@NonNull Single<T>
Single. doOnSubscribe(@NonNull Consumer<? super Disposable> onSubscribe)
Calls the shared consumer with theDisposable
sent through theonSubscribe
for eachSingleObserver
that subscribes to the currentSingle
. -
Uses of Disposable in io.reactivex.rxjava3.disposables
Classes in io.reactivex.rxjava3.disposables that implement Disposable Modifier and Type Class Description (package private) class
ActionDisposable
A Disposable container that manages anAction
instance.(package private) class
AutoCloseableDisposable
A disposable container that manages anAutoCloseable
instance.class
CompositeDisposable
A disposable container that can hold onto multiple otherDisposable
s and offers O(1) time complexity forCompositeDisposable.add(Disposable)
,CompositeDisposable.remove(Disposable)
andCompositeDisposable.delete(Disposable)
operations.(package private) class
FutureDisposable
A Disposable container that cancels aFuture
instance.(package private) class
ReferenceDisposable<T>
Base class for Disposable containers that manage some other type that has to be run when the container is disposed.(package private) class
RunnableDisposable
A disposable container that manages aRunnable
instance.class
SerialDisposable
A Disposable container that allows atomically updating/replacing the contained Disposable with another Disposable, disposing the old one when updating plus handling the disposition when the container itself is disposed.(package private) class
SubscriptionDisposable
A Disposable container that handles aSubscription
.Fields in io.reactivex.rxjava3.disposables with type parameters of type Disposable Modifier and Type Field Description (package private) java.util.concurrent.atomic.AtomicReference<Disposable>
SerialDisposable. resource
(package private) OpenHashSet<Disposable>
CompositeDisposable. resources
Methods in io.reactivex.rxjava3.disposables that return Disposable Modifier and Type Method Description static @NonNull Disposable
Disposable. disposed()
Returns a shared, disposedDisposable
instance.static @NonNull Disposable
Disposable. empty()
Returns a new, non-disposedDisposable
instance.static @NonNull Disposable
Disposable. fromAction(@NonNull Action action)
Construct aDisposable
by wrapping aAction
that is executed exactly once when theDisposable
is disposed.static @NonNull Disposable
Disposable. fromAutoCloseable(@NonNull java.lang.AutoCloseable autoCloseable)
Construct aDisposable
by wrapping anAutoCloseable
that is closed exactly once when theDisposable
is disposed.static @NonNull Disposable
Disposable. fromFuture(@NonNull java.util.concurrent.Future<?> future)
Construct aDisposable
by wrapping aFuture
that is cancelled exactly once when theDisposable
is disposed.static @NonNull Disposable
Disposable. fromFuture(@NonNull java.util.concurrent.Future<?> future, boolean allowInterrupt)
Construct aDisposable
by wrapping aFuture
that is cancelled exactly once when theDisposable
is disposed.static @NonNull Disposable
Disposable. fromRunnable(@NonNull java.lang.Runnable run)
Construct aDisposable
by wrapping aRunnable
that is executed exactly once when theDisposable
is disposed.static @NonNull Disposable
Disposable. fromSubscription(@NonNull org.reactivestreams.Subscription subscription)
Construct aDisposable
by wrapping aSubscription
that is cancelled exactly once when theDisposable
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 aDisposable
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 ofDisposable
s to the container or disposes them all if the container has been disposed.boolean
CompositeDisposable. delete(@NonNull Disposable disposable)
Removes (but does not dispose) the givenDisposable
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 givenDisposable
if it is part of this container.boolean
DisposableContainer. remove(Disposable d)
Removes and disposes the given disposable if it is part of this container.boolean
SerialDisposable. replace(@Nullable Disposable next)
Atomically: set the next disposable on this container but don't dispose the previous one (if any) or dispose next if the container has been disposed.boolean
SerialDisposable. set(@Nullable Disposable next)
Atomically: set the next disposable on this container and dispose the previous one (if any) or dispose next if the container has been disposed.static @NonNull java.lang.AutoCloseable
Disposable. toAutoCloseable(@NonNull Disposable disposable)
Construct anAutoCloseable
by wrapping aDisposable
that is disposed when the returnedAutoCloseable
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 theOpenHashSet
by suppressing non-fatalThrowable
s till the end.Constructors in io.reactivex.rxjava3.disposables with parameters of type Disposable Constructor Description CompositeDisposable(@NonNull Disposable... disposables)
Creates aCompositeDisposable
with the given array of initialDisposable
elements.SerialDisposable(@Nullable Disposable initialDisposable)
Constructs a SerialDisposable with the given initial Disposable instance.Constructor parameters in io.reactivex.rxjava3.disposables with type arguments of type Disposable Constructor Description CompositeDisposable(@NonNull java.lang.Iterable<? extends Disposable> disposables)
-
Uses of Disposable in io.reactivex.rxjava3.flowables
Methods in io.reactivex.rxjava3.flowables that return Disposable Modifier and Type Method Description @NonNull Disposable
ConnectableFlowable. connect()
Instructs theConnectableFlowable
to begin emitting the items from its underlyingFlowable
to itsSubscriber
s.Method parameters in io.reactivex.rxjava3.flowables with type arguments of type Disposable Modifier and Type Method Description @NonNull Flowable<T>
ConnectableFlowable. autoConnect(int numberOfSubscribers, @NonNull Consumer<? super Disposable> connection)
Returns aFlowable
that automatically connects (at most once) to thisConnectableFlowable
when the specified number ofSubscriber
s subscribe to it and calls the specified callback with theDisposable
associated with the established connection.abstract void
ConnectableFlowable. connect(@NonNull Consumer<? super Disposable> connection)
Instructs theConnectableFlowable
to begin emitting the items from its underlyingFlowable
to itsSubscriber
s. -
Uses of Disposable in io.reactivex.rxjava3.internal.disposables
Classes in io.reactivex.rxjava3.internal.disposables that implement Disposable Modifier and Type Class Description class
ArrayCompositeDisposable
A composite disposable with a fixed number of slots.class
CancellableDisposable
A disposable container that wraps a Cancellable instance.class
DisposableHelper
Utility methods for working with Disposables atomically.class
EmptyDisposable
Represents a stateless empty Disposable that reports being always empty and disposed.class
ListCompositeDisposable
A disposable container that can hold onto multiple other disposables.class
SequentialDisposable
A Disposable container that allows updating/replacing a Disposable atomically and with respect of disposing the container itself.Fields in io.reactivex.rxjava3.internal.disposables with type parameters of type Disposable Modifier and Type Field Description (package private) java.util.List<Disposable>
ListCompositeDisposable. resources
Methods in io.reactivex.rxjava3.internal.disposables that return Disposable Modifier and Type Method Description Disposable
ArrayCompositeDisposable. replaceResource(int index, Disposable resource)
Replaces the resource at the specified index and returns the old resource.Methods in io.reactivex.rxjava3.internal.disposables with parameters of type Disposable Modifier and Type Method Description boolean
ListCompositeDisposable. add(Disposable d)
boolean
ListCompositeDisposable. addAll(Disposable... ds)
boolean
ListCompositeDisposable. delete(Disposable d)
static boolean
DisposableHelper. isDisposed(Disposable d)
Checks if the given Disposable is the commonDisposableHelper.DISPOSED
enum value.boolean
ListCompositeDisposable. remove(Disposable d)
static boolean
DisposableHelper. replace(java.util.concurrent.atomic.AtomicReference<Disposable> field, Disposable d)
Atomically replaces the Disposable in the field with the given new Disposable but does not dispose the old one.boolean
SequentialDisposable. replace(Disposable next)
Atomically: set the next disposable on this container but don't dispose the previous one (if any) or dispose next if the container has been disposed.Disposable
ArrayCompositeDisposable. replaceResource(int index, Disposable resource)
Replaces the resource at the specified index and returns the old resource.static boolean
DisposableHelper. set(java.util.concurrent.atomic.AtomicReference<Disposable> field, Disposable d)
Atomically sets the field and disposes the old contents.static boolean
DisposableHelper. setOnce(java.util.concurrent.atomic.AtomicReference<Disposable> field, Disposable d)
Atomically sets the field to the given non-null Disposable and returns true or returns false if the field is non-null.boolean
ArrayCompositeDisposable. setResource(int index, Disposable resource)
Sets the resource at the specified index and disposes the old resource.static boolean
DisposableHelper. trySet(java.util.concurrent.atomic.AtomicReference<Disposable> field, Disposable d)
Atomically tries to set the given Disposable on the field if it is null or disposes it if the field containsDisposableHelper.DISPOSED
.boolean
SequentialDisposable. update(Disposable next)
Atomically: set the next disposable on this container and dispose the previous one (if any) or dispose next if the container has been disposed.static boolean
DisposableHelper. validate(Disposable current, Disposable next)
Verifies that current is null, next is not null, otherwise signals errors to the RxJavaPlugins and returns false.Method parameters in io.reactivex.rxjava3.internal.disposables with type arguments of type Disposable Modifier and Type Method Description static boolean
DisposableHelper. dispose(java.util.concurrent.atomic.AtomicReference<Disposable> field)
Atomically disposes the Disposable in the field if not already disposed.(package private) void
ListCompositeDisposable. dispose(java.util.List<Disposable> set)
static boolean
DisposableHelper. replace(java.util.concurrent.atomic.AtomicReference<Disposable> field, Disposable d)
Atomically replaces the Disposable in the field with the given new Disposable but does not dispose the old one.static boolean
DisposableHelper. set(java.util.concurrent.atomic.AtomicReference<Disposable> field, Disposable d)
Atomically sets the field and disposes the old contents.static boolean
DisposableHelper. setOnce(java.util.concurrent.atomic.AtomicReference<Disposable> field, Disposable d)
Atomically sets the field to the given non-null Disposable and returns true or returns false if the field is non-null.static boolean
DisposableHelper. trySet(java.util.concurrent.atomic.AtomicReference<Disposable> field, Disposable d)
Atomically tries to set the given Disposable on the field if it is null or disposes it if the field containsDisposableHelper.DISPOSED
.Constructors in io.reactivex.rxjava3.internal.disposables with parameters of type Disposable Constructor Description ListCompositeDisposable(Disposable... resources)
SequentialDisposable(Disposable initial)
Construct a SequentialDisposable with the initial Disposable provided.Constructor parameters in io.reactivex.rxjava3.internal.disposables with type arguments of type Disposable Constructor Description ListCompositeDisposable(java.lang.Iterable<? extends Disposable> resources)
-
Uses of Disposable in io.reactivex.rxjava3.internal.fuseable
Classes in io.reactivex.rxjava3.internal.fuseable that implement Disposable Modifier and Type Class Description class
AbstractEmptyQueueFuseable<T>
Represents an empty, async-onlyQueueFuseable
instance.class
CancellableQueueFuseable<T>
Represents an empty, async-onlyQueueFuseable
instance that tracks and exposes a canceled/disposed state. -
Uses of Disposable in io.reactivex.rxjava3.internal.jdk8
Fields in io.reactivex.rxjava3.internal.jdk8 declared as Disposable Modifier and Type Field Description (package private) Disposable
MaybeFlattenStreamAsFlowable.FlattenStreamMultiObserver. upstream
(package private) Disposable
MaybeFlattenStreamAsObservable.FlattenStreamMultiObserver. upstream
(package private) Disposable
MaybeMapOptional.MapOptionalMaybeObserver. upstream
(package private) Disposable
ObservableCollectWithCollector.CollectorObserver. upstream
(package private) Disposable
ObservableCollectWithCollectorSingle.CollectorSingleObserver. upstream
(package private) Disposable
ObservableFlatMapStream.FlatMapStreamObserver. upstream
(package private) Disposable
SingleMapOptional.MapOptionalSingleObserver. upstream
Fields in io.reactivex.rxjava3.internal.jdk8 with type parameters of type Disposable Modifier and Type Field Description (package private) java.util.concurrent.atomic.AtomicReference<Disposable>
CompletionStageConsumer. upstream
(package private) java.util.concurrent.atomic.AtomicReference<Disposable>
ObservableStageObserver. upstream
Methods in io.reactivex.rxjava3.internal.jdk8 with parameters of type Disposable Modifier and Type Method Description void
CompletionStageConsumer. onSubscribe(@NonNull Disposable d)
void
MaybeFlattenStreamAsFlowable.FlattenStreamMultiObserver. onSubscribe(@NonNull Disposable d)
void
MaybeFlattenStreamAsObservable.FlattenStreamMultiObserver. onSubscribe(@NonNull Disposable d)
void
MaybeMapOptional.MapOptionalMaybeObserver. onSubscribe(Disposable d)
void
ObservableCollectWithCollector.CollectorObserver. onSubscribe(@NonNull Disposable d)
void
ObservableCollectWithCollectorSingle.CollectorSingleObserver. onSubscribe(@NonNull Disposable d)
void
ObservableFlatMapStream.FlatMapStreamObserver. onSubscribe(@NonNull Disposable d)
void
ObservableStageObserver. onSubscribe(@NonNull Disposable d)
void
SingleMapOptional.MapOptionalSingleObserver. onSubscribe(Disposable d)
-
Uses of Disposable in io.reactivex.rxjava3.internal.observers
Classes in io.reactivex.rxjava3.internal.observers that implement Disposable Modifier and Type Class Description (package private) class
AbstractDisposableAutoRelease
Wraps lambda callbacks and when the upstream terminates or the observer gets disposed, removes itself from aCompositeDisposable
.class
BasicFuseableObserver<T,R>
Base class for a fuseable intermediate observer.class
BasicIntQueueDisposable<T>
An abstract QueueDisposable implementation, extending an AtomicInteger, that defaults all unnecessary Queue methods to throw UnsupportedOperationException.class
BasicQueueDisposable<T>
An abstract QueueDisposable implementation that defaults all unnecessary Queue methods to throw UnsupportedOperationException.class
BiConsumerSingleObserver<T>
class
BlockingBaseObserver<T>
class
BlockingDisposableMultiObserver<T>
Blocks until the upstream terminates and dispatches the outcome to the actual observer.class
BlockingFirstObserver<T>
Blocks until the upstream signals its first value or completes.class
BlockingLastObserver<T>
Blocks until the upstream signals its last value or completes.class
BlockingObserver<T>
class
CallbackCompletableObserver
class
ConsumerSingleObserver<T>
class
DeferredScalarDisposable<T>
Represents a fuseable container for a single value.class
DeferredScalarObserver<T,R>
A fuseable Observer that can generate 0 or 1 resulting value.class
DisposableAutoReleaseMultiObserver<T>
Wraps lambda callbacks and when the upstream terminates or this (Single | Maybe | Completable) observer gets disposed, removes itself from aCompositeDisposable
.class
DisposableAutoReleaseObserver<T>
Wraps lambda callbacks and when the upstream terminates or this observer gets disposed, removes itself from aCompositeDisposable
.class
DisposableLambdaObserver<T>
class
EmptyCompletableObserver
class
ForEachWhileObserver<T>
class
FutureMultiObserver<T>
An Observer + Future that expects exactly one upstream value and provides it via the (blocking) Future API.class
FutureObserver<T>
An Observer + Future that expects exactly one upstream value and provides it via the (blocking) Future API.class
InnerQueuedObserver<T>
Subscriber that can fuse with the upstream and calls a support interface whenever an event is available.class
LambdaObserver<T>
Fields in io.reactivex.rxjava3.internal.observers declared as Disposable Modifier and Type Field Description protected Disposable
BasicFuseableObserver. upstream
The upstream subscription.(package private) Disposable
BlockingBaseObserver. upstream
(package private) Disposable
BlockingMultiObserver. upstream
protected Disposable
DeferredScalarObserver. upstream
The upstream disposable.(package private) Disposable
DisposableLambdaObserver. upstream
Fields in io.reactivex.rxjava3.internal.observers with type parameters of type Disposable Modifier and Type Field Description (package private) Consumer<? super Disposable>
DisposableLambdaObserver. onSubscribe
(package private) Consumer<? super Disposable>
LambdaObserver. onSubscribe
(package private) java.util.concurrent.atomic.AtomicReference<Disposable>
ResumeSingleObserver. parent
(package private) java.util.concurrent.atomic.AtomicReference<Disposable>
FutureMultiObserver. upstream
(package private) java.util.concurrent.atomic.AtomicReference<Disposable>
FutureObserver. upstream
Methods in io.reactivex.rxjava3.internal.observers with parameters of type Disposable Modifier and Type Method Description protected void
QueueDrainObserver. fastPathEmit(U value, boolean delayError, Disposable dispose)
protected void
QueueDrainObserver. fastPathOrderedEmit(U value, boolean delayError, Disposable disposable)
Makes sure the fast-path emits in order.void
AbstractDisposableAutoRelease. onSubscribe(Disposable d)
void
BasicFuseableObserver. onSubscribe(Disposable d)
void
BiConsumerSingleObserver. onSubscribe(Disposable d)
void
BlockingBaseObserver. onSubscribe(Disposable d)
void
BlockingDisposableMultiObserver. onSubscribe(@NonNull Disposable d)
void
BlockingMultiObserver. onSubscribe(Disposable d)
void
BlockingObserver. onSubscribe(Disposable d)
void
CallbackCompletableObserver. onSubscribe(Disposable d)
void
ConsumerSingleObserver. onSubscribe(Disposable d)
void
DeferredScalarObserver. onSubscribe(Disposable d)
void
DisposableLambdaObserver. onSubscribe(Disposable d)
void
EmptyCompletableObserver. onSubscribe(Disposable d)
void
ForEachWhileObserver. onSubscribe(Disposable d)
void
FutureMultiObserver. onSubscribe(Disposable d)
void
FutureObserver. onSubscribe(Disposable d)
void
InnerQueuedObserver. onSubscribe(Disposable d)
void
LambdaObserver. onSubscribe(Disposable d)
void
ResumeSingleObserver. onSubscribe(Disposable d)
void
SafeCompletableObserver. onSubscribe(@NonNull Disposable d)
void
SafeMaybeObserver. onSubscribe(@NonNull Disposable d)
void
SafeSingleObserver. onSubscribe(@NonNull Disposable d)
Constructor parameters in io.reactivex.rxjava3.internal.observers with type arguments of type Disposable Constructor Description DisposableLambdaObserver(Observer<? super T> actual, Consumer<? super Disposable> onSubscribe, Action onDispose)
ResumeSingleObserver(java.util.concurrent.atomic.AtomicReference<Disposable> parent, SingleObserver<? super T> downstream)
-
Uses of Disposable in io.reactivex.rxjava3.internal.operators.completable
Fields in io.reactivex.rxjava3.internal.operators.completable declared as Disposable Modifier and Type Field Description (package private) Disposable
CompletableAmb.Amb. upstream
(package private) Disposable
CompletableDetach.DetachCompletableObserver. upstream
(package private) Disposable
CompletableDisposeOn.DisposeOnObserver. upstream
(package private) Disposable
CompletableDoFinally.DoFinallyObserver. upstream
(package private) Disposable
CompletableHide.HideCompletableObserver. upstream
(package private) Disposable
CompletableOnErrorReturn.OnErrorReturnMaybeObserver. upstream
(package private) Disposable
CompletablePeek.CompletableObserverImplementation. upstream
(package private) Disposable
CompletableUsing.UsingObserver. upstream
Fields in io.reactivex.rxjava3.internal.operators.completable with type parameters of type Disposable Modifier and Type Field Description (package private) Consumer<? super Disposable>
CompletablePeek. onSubscribe
(package private) java.util.concurrent.atomic.AtomicReference<Disposable>
CompletableAndThenCompletable.NextObserver. parent
Methods in io.reactivex.rxjava3.internal.operators.completable with parameters of type Disposable Modifier and Type Method Description void
CompletableAmb.Amb. onSubscribe(Disposable d)
void
CompletableAndThenCompletable.NextObserver. onSubscribe(Disposable d)
void
CompletableAndThenCompletable.SourceObserver. onSubscribe(Disposable d)
void
CompletableCache. onSubscribe(Disposable d)
void
CompletableConcat.CompletableConcatSubscriber.ConcatInnerObserver. onSubscribe(Disposable d)
void
CompletableConcatArray.ConcatInnerObserver. onSubscribe(Disposable d)
void
CompletableConcatIterable.ConcatInnerObserver. onSubscribe(Disposable d)
void
CompletableDelay.Delay. onSubscribe(Disposable d)
void
CompletableDetach.DetachCompletableObserver. onSubscribe(Disposable d)
void
CompletableDisposeOn.DisposeOnObserver. onSubscribe(Disposable d)
void
CompletableDoFinally.DoFinallyObserver. onSubscribe(Disposable d)
void
CompletableDoOnEvent.DoOnEvent. onSubscribe(Disposable d)
void
CompletableFromObservable.CompletableFromObservableObserver. onSubscribe(Disposable d)
void
CompletableFromSingle.CompletableFromSingleObserver. onSubscribe(Disposable d)
void
CompletableHide.HideCompletableObserver. onSubscribe(Disposable d)
void
CompletableMerge.CompletableMergeSubscriber.MergeInnerObserver. onSubscribe(Disposable d)
void
CompletableMergeArray.InnerCompletableObserver. onSubscribe(Disposable d)
void
CompletableMergeArrayDelayError.MergeInnerCompletableObserver. onSubscribe(Disposable d)
void
CompletableMergeIterable.MergeCompletableObserver. onSubscribe(Disposable d)
void
CompletableObserveOn.ObserveOnCompletableObserver. onSubscribe(Disposable d)
void
CompletableOnErrorComplete.OnError. onSubscribe(Disposable d)
void
CompletableOnErrorReturn.OnErrorReturnMaybeObserver. onSubscribe(Disposable d)
void
CompletablePeek.CompletableObserverImplementation. onSubscribe(Disposable d)
void
CompletableResumeNext.ResumeNextObserver. onSubscribe(Disposable d)
void
CompletableSubscribeOn.SubscribeOnObserver. onSubscribe(Disposable d)
void
CompletableTakeUntilCompletable.TakeUntilMainObserver. onSubscribe(Disposable d)
void
CompletableTakeUntilCompletable.TakeUntilMainObserver.OtherObserver. onSubscribe(Disposable d)
void
CompletableTimeout.DisposeTask.DisposeObserver. onSubscribe(Disposable d)
void
CompletableTimeout.TimeOutObserver. onSubscribe(Disposable d)
void
CompletableToSingle.ToSingle. onSubscribe(Disposable d)
void
CompletableUsing.UsingObserver. onSubscribe(Disposable d)
void
CompletableCreate.Emitter. setDisposable(Disposable d)
(package private) void
CompletableTimer.TimerDisposable. setFuture(Disposable d)
Constructor parameters in io.reactivex.rxjava3.internal.operators.completable with type arguments of type Disposable Constructor Description CompletablePeek(CompletableSource source, Consumer<? super Disposable> onSubscribe, Consumer<? super java.lang.Throwable> onError, Action onComplete, Action onTerminate, Action onAfterTerminate, Action onDispose)
NextObserver(java.util.concurrent.atomic.AtomicReference<Disposable> parent, CompletableObserver downstream)
-
Uses of Disposable in io.reactivex.rxjava3.internal.operators.flowable
Fields in io.reactivex.rxjava3.internal.operators.flowable declared as Disposable Modifier and Type Field Description (package private) Disposable
FlowableBufferExactBoundary.BufferExactBoundarySubscriber. other
(package private) Disposable
FlowableBufferTimed.BufferExactBoundedSubscriber. timer
(package private) Disposable
FlowableRefCount.RefConnection. timer
(package private) Disposable
FlowableFromCompletable.FromCompletableObserver. upstream
(package private) Disposable
FlowableFromObservable.SubscriberObserver. upstream
Fields in io.reactivex.rxjava3.internal.operators.flowable with type parameters of type Disposable Modifier and Type Field Description (package private) Consumer<? super Disposable>
FlowableAutoConnect. connection
(package private) java.util.concurrent.atomic.AtomicReference<Disposable>
FlowableDebounce.DebounceSubscriber. debouncer
(package private) java.util.concurrent.atomic.AtomicReference<Disposable>
FlowableConcatWithMaybe.ConcatWithSubscriber. otherDisposable
(package private) java.util.concurrent.atomic.AtomicReference<Disposable>
FlowableConcatWithSingle.ConcatWithSubscriber. otherDisposable
(package private) java.util.concurrent.atomic.AtomicReference<Disposable>
FlowableInterval.IntervalSubscriber. resource
(package private) java.util.concurrent.atomic.AtomicReference<Disposable>
FlowableIntervalRange.IntervalRangeSubscriber. resource
(package private) java.util.concurrent.atomic.AtomicReference<Disposable>
FlowableBufferTimed.BufferExactUnboundedSubscriber. timer
Methods in io.reactivex.rxjava3.internal.operators.flowable with parameters of type Disposable Modifier and Type Method Description void
FlowableRefCount.RefConnection. accept(Disposable t)
void
FlowableReplay.MulticastFlowable.DisposableConsumer. accept(Disposable r)
(package private) void
FlowableBufferBoundary.BufferBoundarySubscriber. boundaryError(Disposable subscriber, java.lang.Throwable ex)
void
FlowableConcatWithCompletable.ConcatWithSubscriber. onSubscribe(Disposable d)
void
FlowableConcatWithMaybe.ConcatWithSubscriber. onSubscribe(Disposable d)
void
FlowableConcatWithSingle.ConcatWithSubscriber. onSubscribe(Disposable d)
void
FlowableFlatMapCompletable.FlatMapCompletableMainSubscriber.InnerConsumer. onSubscribe(Disposable d)
void
FlowableFlatMapCompletableCompletable.FlatMapCompletableMainSubscriber.InnerObserver. onSubscribe(Disposable d)
void
FlowableFlatMapMaybe.FlatMapMaybeSubscriber.InnerObserver. onSubscribe(Disposable d)
void
FlowableFlatMapSingle.FlatMapSingleSubscriber.InnerObserver. onSubscribe(Disposable d)
void
FlowableFromCompletable.FromCompletableObserver. onSubscribe(Disposable d)
void
FlowableFromObservable.SubscriberObserver. onSubscribe(Disposable d)
void
FlowableMergeWithCompletable.MergeWithSubscriber.OtherObserver. onSubscribe(Disposable d)
void
FlowableMergeWithMaybe.MergeWithObserver.OtherObserver. onSubscribe(Disposable d)
void
FlowableMergeWithSingle.MergeWithObserver.OtherObserver. onSubscribe(Disposable d)
void
FlowableCreate.BaseEmitter. setDisposable(Disposable d)
void
FlowableCreate.SerializedEmitter. setDisposable(Disposable d)
void
FlowableDebounceTimed.DebounceEmitter. setResource(Disposable d)
void
FlowableInterval.IntervalSubscriber. setResource(Disposable d)
void
FlowableIntervalRange.IntervalRangeSubscriber. setResource(Disposable d)
void
FlowableTimer.TimerSubscriber. setResource(Disposable d)
Method parameters in io.reactivex.rxjava3.internal.operators.flowable with type arguments of type Disposable Modifier and Type Method Description void
FlowablePublish. connect(Consumer<? super Disposable> connection)
void
FlowableReplay. connect(Consumer<? super Disposable> connection)
Constructor parameters in io.reactivex.rxjava3.internal.operators.flowable with type arguments of type Disposable Constructor Description FlowableAutoConnect(ConnectableFlowable<? extends T> source, int numberOfSubscribers, Consumer<? super Disposable> connection)
-
Uses of Disposable in io.reactivex.rxjava3.internal.operators.maybe
Fields in io.reactivex.rxjava3.internal.operators.maybe declared as Disposable Modifier and Type Field Description (package private) Disposable
MaybeUnsubscribeOn.UnsubscribeOnMaybeObserver. ds
(package private) Disposable
MaybeAmb.AmbMaybeObserver. upstream
(package private) Disposable
MaybeContains.ContainsMaybeObserver. upstream
(package private) Disposable
MaybeCount.CountMaybeObserver. upstream
(package private) Disposable
MaybeDelayOtherPublisher.DelayMaybeObserver. upstream
(package private) Disposable
MaybeDematerialize.DematerializeObserver. upstream
(package private) Disposable
MaybeDetach.DetachMaybeObserver. upstream
(package private) Disposable
MaybeDoAfterSuccess.DoAfterObserver. upstream
(package private) Disposable
MaybeDoFinally.DoFinallyObserver. upstream
(package private) Disposable
MaybeDoOnEvent.DoOnEventMaybeObserver. upstream
(package private) Disposable
MaybeDoOnLifecycle.MaybeLifecycleObserver. upstream
(package private) Disposable
MaybeFilter.FilterMaybeObserver. upstream
(package private) Disposable
MaybeFilterSingle.FilterMaybeObserver. upstream
(package private) Disposable
MaybeFlatMapIterableFlowable.FlatMapIterableObserver. upstream
(package private) Disposable
MaybeFlatMapIterableObservable.FlatMapIterableObserver. upstream
(package private) Disposable
MaybeFlatMapNotification.FlatMapMaybeObserver. upstream
(package private) Disposable
MaybeFlatten.FlatMapMaybeObserver. upstream
(package private) Disposable
MaybeFromCompletable.FromCompletableObserver. upstream
(package private) Disposable
MaybeFromSingle.FromSingleObserver. upstream
(package private) Disposable
MaybeHide.HideMaybeObserver. upstream
(package private) Disposable
MaybeIgnoreElement.IgnoreMaybeObserver. upstream
(package private) Disposable
MaybeIgnoreElementCompletable.IgnoreMaybeObserver. upstream
(package private) Disposable
MaybeIsEmpty.IsEmptyMaybeObserver. upstream
(package private) Disposable
MaybeIsEmptySingle.IsEmptyMaybeObserver. upstream
(package private) Disposable
MaybeMap.MapMaybeObserver. upstream
(package private) Disposable
MaybeOnErrorComplete.OnErrorCompleteMultiObserver. upstream
(package private) Disposable
MaybeOnErrorReturn.OnErrorReturnMaybeObserver. upstream
(package private) Disposable
MaybePeek.MaybePeekObserver. upstream
(package private) Disposable
MaybeTimeInterval.TimeIntervalMaybeObserver. upstream
(package private) Disposable
MaybeToFlowable.MaybeToFlowableSubscriber. upstream
(package private) Disposable
MaybeToObservable.MaybeToObservableObserver. upstream
(package private) Disposable
MaybeToSingle.ToSingleMaybeSubscriber. upstream
(package private) Disposable
MaybeUsing.UsingObserver. upstream
Fields in io.reactivex.rxjava3.internal.operators.maybe with type parameters of type Disposable Modifier and Type Field Description (package private) Consumer<? super Disposable>
MaybeDoOnLifecycle.MaybeLifecycleObserver. onSubscribe
(package private) Consumer<? super Disposable>
MaybeDoOnLifecycle. onSubscribe
(package private) Consumer<? super Disposable>
MaybePeek. onSubscribeCall
(package private) java.util.concurrent.atomic.AtomicReference<Disposable>
MaybeDelayWithCompletable.DelayWithMainObserver. parent
(package private) java.util.concurrent.atomic.AtomicReference<Disposable>
MaybeFlatMapSingle.FlatMapSingleObserver. parent
(package private) java.util.concurrent.atomic.AtomicReference<Disposable>
MaybeSwitchIfEmpty.SwitchIfEmptyMaybeObserver.OtherMaybeObserver. parent
(package private) java.util.concurrent.atomic.AtomicReference<Disposable>
MaybeSwitchIfEmptySingle.SwitchIfEmptyMaybeObserver.OtherSingleObserver. parent
(package private) java.util.concurrent.atomic.AtomicReference<Disposable>
MaybeOnErrorNext.OnErrorNextMaybeObserver.NextMaybeObserver. upstream
Methods in io.reactivex.rxjava3.internal.operators.maybe with parameters of type Disposable Modifier and Type Method Description void
MaybeAmb.AmbMaybeObserver. onSubscribe(Disposable d)
void
MaybeCache. onSubscribe(Disposable d)
void
MaybeCallbackObserver. onSubscribe(Disposable d)
void
MaybeConcatArray.ConcatMaybeObserver. onSubscribe(Disposable d)
void
MaybeConcatArrayDelayError.ConcatMaybeObserver. onSubscribe(Disposable d)
void
MaybeConcatIterable.ConcatMaybeObserver. onSubscribe(Disposable d)
void
MaybeContains.ContainsMaybeObserver. onSubscribe(Disposable d)
void
MaybeCount.CountMaybeObserver. onSubscribe(Disposable d)
void
MaybeDelay.DelayMaybeObserver. onSubscribe(Disposable d)
void
MaybeDelayOtherPublisher.DelayMaybeObserver. onSubscribe(Disposable d)
void
MaybeDelaySubscriptionOtherPublisher.DelayMaybeObserver. onSubscribe(Disposable d)
void
MaybeDelayWithCompletable.DelayWithMainObserver. onSubscribe(Disposable d)
void
MaybeDelayWithCompletable.OtherObserver. onSubscribe(Disposable d)
void
MaybeDematerialize.DematerializeObserver. onSubscribe(Disposable d)
void
MaybeDetach.DetachMaybeObserver. onSubscribe(Disposable d)
void
MaybeDoAfterSuccess.DoAfterObserver. onSubscribe(Disposable d)
void
MaybeDoFinally.DoFinallyObserver. onSubscribe(Disposable d)
void
MaybeDoOnEvent.DoOnEventMaybeObserver. onSubscribe(Disposable d)
void
MaybeDoOnLifecycle.MaybeLifecycleObserver. onSubscribe(@NonNull Disposable d)
void
MaybeDoOnTerminate.DoOnTerminate. onSubscribe(Disposable d)
void
MaybeEqualSingle.EqualObserver. onSubscribe(Disposable d)
void
MaybeFilter.FilterMaybeObserver. onSubscribe(Disposable d)
void
MaybeFilterSingle.FilterMaybeObserver. onSubscribe(Disposable d)
void
MaybeFlatMapBiSelector.FlatMapBiMainObserver.InnerObserver. onSubscribe(Disposable d)
void
MaybeFlatMapBiSelector.FlatMapBiMainObserver. onSubscribe(Disposable d)
void
MaybeFlatMapCompletable.FlatMapCompletableObserver. onSubscribe(Disposable d)
void
MaybeFlatMapIterableFlowable.FlatMapIterableObserver. onSubscribe(Disposable d)
void
MaybeFlatMapIterableObservable.FlatMapIterableObserver. onSubscribe(Disposable d)
void
MaybeFlatMapNotification.FlatMapMaybeObserver.InnerObserver. onSubscribe(Disposable d)
void
MaybeFlatMapNotification.FlatMapMaybeObserver. onSubscribe(Disposable d)
void
MaybeFlatMapSingle.FlatMapMaybeObserver. onSubscribe(Disposable d)
void
MaybeFlatMapSingle.FlatMapSingleObserver. onSubscribe(Disposable d)
void
MaybeFlatten.FlatMapMaybeObserver.InnerObserver. onSubscribe(Disposable d)
void
MaybeFlatten.FlatMapMaybeObserver. onSubscribe(Disposable d)
void
MaybeFromCompletable.FromCompletableObserver. onSubscribe(Disposable d)
void
MaybeFromSingle.FromSingleObserver. onSubscribe(Disposable d)
void
MaybeHide.HideMaybeObserver. onSubscribe(Disposable d)
void
MaybeIgnoreElement.IgnoreMaybeObserver. onSubscribe(Disposable d)
void
MaybeIgnoreElementCompletable.IgnoreMaybeObserver. onSubscribe(Disposable d)
void
MaybeIsEmpty.IsEmptyMaybeObserver. onSubscribe(Disposable d)
void
MaybeIsEmptySingle.IsEmptyMaybeObserver. onSubscribe(Disposable d)
void
MaybeMap.MapMaybeObserver. onSubscribe(Disposable d)
void
MaybeMergeArray.MergeMaybeObserver. onSubscribe(Disposable d)
void
MaybeObserveOn.ObserveOnMaybeObserver. onSubscribe(Disposable d)
void
MaybeOnErrorComplete.OnErrorCompleteMultiObserver. onSubscribe(Disposable d)
void
MaybeOnErrorNext.OnErrorNextMaybeObserver.NextMaybeObserver. onSubscribe(Disposable d)
void
MaybeOnErrorNext.OnErrorNextMaybeObserver. onSubscribe(Disposable d)
void
MaybeOnErrorReturn.OnErrorReturnMaybeObserver. onSubscribe(Disposable d)
void
MaybePeek.MaybePeekObserver. onSubscribe(Disposable d)
void
MaybeSubscribeOn.SubscribeOnMaybeObserver. onSubscribe(Disposable d)
void
MaybeSwitchIfEmpty.SwitchIfEmptyMaybeObserver. onSubscribe(Disposable d)
void
MaybeSwitchIfEmpty.SwitchIfEmptyMaybeObserver.OtherMaybeObserver. onSubscribe(Disposable d)
void
MaybeSwitchIfEmptySingle.SwitchIfEmptyMaybeObserver. onSubscribe(Disposable d)
void
MaybeSwitchIfEmptySingle.SwitchIfEmptyMaybeObserver.OtherSingleObserver. onSubscribe(Disposable d)
void
MaybeTakeUntilMaybe.TakeUntilMainMaybeObserver. onSubscribe(Disposable d)
void
MaybeTakeUntilMaybe.TakeUntilMainMaybeObserver.TakeUntilOtherMaybeObserver. onSubscribe(Disposable d)
void
MaybeTakeUntilPublisher.TakeUntilMainMaybeObserver. onSubscribe(Disposable d)
void
MaybeTimeInterval.TimeIntervalMaybeObserver. onSubscribe(@NonNull Disposable d)
void
MaybeTimeoutMaybe.TimeoutFallbackMaybeObserver. onSubscribe(Disposable d)
void
MaybeTimeoutMaybe.TimeoutMainMaybeObserver. onSubscribe(Disposable d)
void
MaybeTimeoutMaybe.TimeoutOtherMaybeObserver. onSubscribe(Disposable d)
void
MaybeTimeoutPublisher.TimeoutFallbackMaybeObserver. onSubscribe(Disposable d)
void
MaybeTimeoutPublisher.TimeoutMainMaybeObserver. onSubscribe(Disposable d)
void
MaybeToFlowable.MaybeToFlowableSubscriber. onSubscribe(Disposable d)
void
MaybeToObservable.MaybeToObservableObserver. onSubscribe(Disposable d)
void
MaybeToSingle.ToSingleMaybeSubscriber. onSubscribe(Disposable d)
void
MaybeUnsubscribeOn.UnsubscribeOnMaybeObserver. onSubscribe(Disposable d)
void
MaybeUsing.UsingObserver. onSubscribe(Disposable d)
void
MaybeZipArray.ZipMaybeObserver. onSubscribe(Disposable d)
void
MaybeCreate.Emitter. setDisposable(Disposable d)
(package private) void
MaybeTimer.TimerDisposable. setFuture(Disposable d)
Constructor parameters in io.reactivex.rxjava3.internal.operators.maybe with type arguments of type Disposable Constructor Description DelayWithMainObserver(java.util.concurrent.atomic.AtomicReference<Disposable> parent, MaybeObserver<? super T> downstream)
FlatMapSingleObserver(java.util.concurrent.atomic.AtomicReference<Disposable> parent, MaybeObserver<? super R> downstream)
MaybeDoOnLifecycle(Maybe<T> upstream, Consumer<? super Disposable> onSubscribe, Action onDispose)
MaybeLifecycleObserver(MaybeObserver<? super T> downstream, Consumer<? super Disposable> onSubscribe, Action onDispose)
MaybePeek(MaybeSource<T> source, Consumer<? super Disposable> onSubscribeCall, Consumer<? super T> onSuccessCall, Consumer<? super java.lang.Throwable> onErrorCall, Action onCompleteCall, Action onAfterTerminate, Action onDispose)
NextMaybeObserver(MaybeObserver<? super T> actual, java.util.concurrent.atomic.AtomicReference<Disposable> d)
OtherMaybeObserver(MaybeObserver<? super T> actual, java.util.concurrent.atomic.AtomicReference<Disposable> parent)
OtherSingleObserver(SingleObserver<? super T> actual, java.util.concurrent.atomic.AtomicReference<Disposable> parent)
-
Uses of Disposable in io.reactivex.rxjava3.internal.operators.mixed
Classes in io.reactivex.rxjava3.internal.operators.mixed that implement Disposable Modifier and Type Class Description (package private) static class
CompletableAndThenObservable.AndThenObservableObserver<R>
class
ConcatMapXMainObserver<T>
Base class for implementing concatMapX main observers.(package private) static class
FlowableConcatMapCompletable.ConcatMapCompletableObserver<T>
(package private) static class
FlowableSwitchMapCompletable.SwitchMapCompletableObserver<T>
class
MaterializeSingleObserver<T>
A consumer that implements the consumer types of Maybe, Single and Completable and turns their signals into Notifications for a SingleObserver.(package private) static class
MaybeFlatMapObservable.FlatMapObserver<T,R>
(package private) static class
ObservableConcatMapCompletable.ConcatMapCompletableObserver<T>
(package private) static class
ObservableConcatMapMaybe.ConcatMapMaybeMainObserver<T,R>
(package private) static class
ObservableConcatMapSingle.ConcatMapSingleMainObserver<T,R>
(package private) static class
ObservableSwitchMapCompletable.SwitchMapCompletableObserver<T>
(package private) static class
ObservableSwitchMapMaybe.SwitchMapMaybeMainObserver<T,R>
(package private) static class
ObservableSwitchMapSingle.SwitchMapSingleMainObserver<T,R>
(package private) static class
SingleFlatMapObservable.FlatMapObserver<T,R>
Fields in io.reactivex.rxjava3.internal.operators.mixed declared as Disposable Modifier and Type Field Description (package private) Disposable
CompletableAndThenPublisher.AndThenPublisherSubscriber. upstream
(package private) Disposable
ConcatMapXMainObserver. upstream
(package private) Disposable
MaterializeSingleObserver. upstream
(package private) Disposable
MaybeFlatMapPublisher.FlatMapPublisherSubscriber. upstream
(package private) Disposable
ObservableSwitchMapCompletable.SwitchMapCompletableObserver. upstream
(package private) Disposable
ObservableSwitchMapMaybe.SwitchMapMaybeMainObserver. upstream
(package private) Disposable
ObservableSwitchMapSingle.SwitchMapSingleMainObserver. upstream
Methods in io.reactivex.rxjava3.internal.operators.mixed with parameters of type Disposable Modifier and Type Method Description void
CompletableAndThenObservable.AndThenObservableObserver. onSubscribe(Disposable d)
void
CompletableAndThenPublisher.AndThenPublisherSubscriber. onSubscribe(Disposable d)
void
ConcatMapXMainObserver. onSubscribe(Disposable d)
void
FlowableConcatMapCompletable.ConcatMapCompletableObserver.ConcatMapInnerObserver. onSubscribe(Disposable d)
void
FlowableConcatMapMaybe.ConcatMapMaybeSubscriber.ConcatMapMaybeObserver. onSubscribe(Disposable d)
void
FlowableConcatMapSingle.ConcatMapSingleSubscriber.ConcatMapSingleObserver. onSubscribe(Disposable d)
void
FlowableSwitchMapCompletable.SwitchMapCompletableObserver.SwitchMapInnerObserver. onSubscribe(Disposable d)
void
FlowableSwitchMapMaybe.SwitchMapMaybeSubscriber.SwitchMapMaybeObserver. onSubscribe(Disposable d)
void
FlowableSwitchMapSingle.SwitchMapSingleSubscriber.SwitchMapSingleObserver. onSubscribe(Disposable d)
void
MaterializeSingleObserver. onSubscribe(Disposable d)
void
MaybeFlatMapObservable.FlatMapObserver. onSubscribe(Disposable d)
void
MaybeFlatMapPublisher.FlatMapPublisherSubscriber. onSubscribe(Disposable d)
void
ObservableConcatMapCompletable.ConcatMapCompletableObserver.ConcatMapInnerObserver. onSubscribe(Disposable d)
void
ObservableConcatMapMaybe.ConcatMapMaybeMainObserver.ConcatMapMaybeObserver. onSubscribe(Disposable d)
void
ObservableConcatMapSingle.ConcatMapSingleMainObserver.ConcatMapSingleObserver. onSubscribe(Disposable d)
void
ObservableSwitchMapCompletable.SwitchMapCompletableObserver. onSubscribe(Disposable d)
void
ObservableSwitchMapCompletable.SwitchMapCompletableObserver.SwitchMapInnerObserver. onSubscribe(Disposable d)
void
ObservableSwitchMapMaybe.SwitchMapMaybeMainObserver. onSubscribe(Disposable d)
void
ObservableSwitchMapMaybe.SwitchMapMaybeMainObserver.SwitchMapMaybeObserver. onSubscribe(Disposable d)
void
ObservableSwitchMapSingle.SwitchMapSingleMainObserver. onSubscribe(Disposable d)
void
ObservableSwitchMapSingle.SwitchMapSingleMainObserver.SwitchMapSingleObserver. onSubscribe(Disposable d)
void
SingleFlatMapObservable.FlatMapObserver. onSubscribe(Disposable d)
-
Uses of Disposable in io.reactivex.rxjava3.internal.operators.observable
Fields in io.reactivex.rxjava3.internal.operators.observable declared as Disposable Modifier and Type Field Description (package private) Disposable
ObservableBufferExactBoundary.BufferExactBoundaryObserver. other
(package private) Disposable
ObservableBufferTimed.BufferExactBoundedObserver. timer
(package private) Disposable
ObservableRefCount.RefConnection. timer
(package private) Disposable
ObservableAll.AllObserver. upstream
(package private) Disposable
ObservableAllSingle.AllObserver. upstream
(package private) Disposable
ObservableAny.AnyObserver. upstream
(package private) Disposable
ObservableAnySingle.AnyObserver. upstream
(package private) Disposable
ObservableBuffer.BufferExactObserver. upstream
(package private) Disposable
ObservableBuffer.BufferSkipObserver. upstream
(package private) Disposable
ObservableBufferExactBoundary.BufferExactBoundaryObserver. upstream
(package private) Disposable
ObservableBufferTimed.BufferExactBoundedObserver. upstream
(package private) Disposable
ObservableBufferTimed.BufferExactUnboundedObserver. upstream
(package private) Disposable
ObservableBufferTimed.BufferSkipBoundedObserver. upstream
(package private) Disposable
ObservableCollect.CollectObserver. upstream
(package private) Disposable
ObservableCollectSingle.CollectObserver. upstream
(package private) Disposable
ObservableConcatMap.ConcatMapDelayErrorObserver. upstream
(package private) Disposable
ObservableConcatMap.SourceObserver. upstream
(package private) Disposable
ObservableConcatMapEager.ConcatMapEagerMainObserver. upstream
(package private) Disposable
ObservableConcatMapScheduler.ConcatMapDelayErrorObserver. upstream
(package private) Disposable
ObservableConcatMapScheduler.ConcatMapObserver. upstream
(package private) Disposable
ObservableCount.CountObserver. upstream
(package private) Disposable
ObservableCountSingle.CountObserver. upstream
(package private) Disposable
ObservableDebounce.DebounceObserver. upstream
(package private) Disposable
ObservableDebounceTimed.DebounceTimedObserver. upstream
(package private) Disposable
ObservableDelay.DelayObserver. upstream
(package private) Disposable
ObservableDematerialize.DematerializeObserver. upstream
(package private) Disposable
ObservableDetach.DetachObserver. upstream
(package private) Disposable
ObservableDoFinally.DoFinallyObserver. upstream
(package private) Disposable
ObservableDoOnEach.DoOnEachObserver. upstream
(package private) Disposable
ObservableElementAt.ElementAtObserver. upstream
(package private) Disposable
ObservableElementAtMaybe.ElementAtObserver. upstream
(package private) Disposable
ObservableElementAtSingle.ElementAtObserver. upstream
(package private) Disposable
ObservableFlatMap.MergeObserver. upstream
(package private) Disposable
ObservableFlatMapCompletable.FlatMapCompletableMainObserver. upstream
(package private) Disposable
ObservableFlatMapCompletableCompletable.FlatMapCompletableMainObserver. upstream
(package private) Disposable
ObservableFlatMapMaybe.FlatMapMaybeObserver. upstream
(package private) Disposable
ObservableFlatMapSingle.FlatMapSingleObserver. upstream
(package private) Disposable
ObservableFlattenIterable.FlattenIterableObserver. upstream
(package private) Disposable
ObservableFromCompletable.FromCompletableObserver. upstream
(package private) Disposable
ObservableGroupBy.GroupByObserver. upstream
(package private) Disposable
ObservableHide.HideDisposable. upstream
(package private) Disposable
ObservableIgnoreElements.IgnoreObservable. upstream
(package private) Disposable
ObservableIgnoreElementsCompletable.IgnoreObservable. upstream
(package private) Disposable
ObservableLastMaybe.LastObserver. upstream
(package private) Disposable
ObservableLastSingle.LastObserver. upstream
(package private) Disposable
ObservableMapNotification.MapNotificationObserver. upstream
(package private) Disposable
ObservableMaterialize.MaterializeObserver. upstream
(package private) Disposable
ObservableObserveOn.ObserveOnObserver. upstream
(package private) Disposable
ObservableOnErrorComplete.OnErrorCompleteObserver. upstream
(package private) Disposable
ObservableOnErrorReturn.OnErrorReturnObserver. upstream
(package private) Disposable
ObservablePublishSelector.TargetObserver. upstream
(package private) Disposable
ObservableReduceMaybe.ReduceObserver. upstream
(package private) Disposable
ObservableReduceSeedSingle.ReduceSeedObserver. upstream
(package private) Disposable
ObservableRefCount.RefCountObserver. upstream
(package private) Disposable
ObservableSampleTimed.SampleTimedObserver. upstream
(package private) Disposable
ObservableSampleWithObservable.SampleMainObserver. upstream
(package private) Disposable
ObservableScan.ScanObserver. upstream
(package private) Disposable
ObservableScanSeed.ScanSeedObserver. upstream
(package private) Disposable
ObservableSingleMaybe.SingleElementObserver. upstream
(package private) Disposable
ObservableSingleSingle.SingleElementObserver. upstream
(package private) Disposable
ObservableSkip.SkipObserver. upstream
(package private) Disposable
ObservableSkipLast.SkipLastObserver. upstream
(package private) Disposable
ObservableSkipLastTimed.SkipLastTimedObserver. upstream
(package private) Disposable
ObservableSkipUntil.SkipUntil. upstream
(package private) Disposable
ObservableSkipUntil.SkipUntilObserver. upstream
(package private) Disposable
ObservableSkipWhile.SkipWhileObserver. upstream
(package private) Disposable
ObservableSwitchMap.SwitchMapObserver. upstream
(package private) Disposable
ObservableTake.TakeObserver. upstream
(package private) Disposable
ObservableTakeLast.TakeLastObserver. upstream
(package private) Disposable
ObservableTakeLastOne.TakeLastOneObserver. upstream
(package private) Disposable
ObservableTakeLastTimed.TakeLastTimedObserver. upstream
(package private) Disposable
ObservableTakeUntilPredicate.TakeUntilPredicateObserver. upstream
(package private) Disposable
ObservableTakeWhile.TakeWhileObserver. upstream
(package private) Disposable
ObservableThrottleFirstTimed.DebounceTimedObserver. upstream
(package private) Disposable
ObservableThrottleLatest.ThrottleLatestObserver. upstream
(package private) Disposable
ObservableTimeInterval.TimeIntervalObserver. upstream
(package private) Disposable
ObservableToList.ToListObserver. upstream
(package private) Disposable
ObservableToListSingle.ToListObserver. upstream
(package private) Disposable
ObservableUnsubscribeOn.UnsubscribeObserver. upstream
(package private) Disposable
ObservableUsing.UsingObserver. upstream
(package private) Disposable
ObservableWindow.WindowExactObserver. upstream
(package private) Disposable
ObservableWindow.WindowSkipObserver. upstream
(package private) Disposable
ObservableWindowBoundarySelector.WindowBoundaryMainObserver. upstream
(package private) Disposable
ObservableWindowTimed.AbstractWindowObserver. upstream
(package private) Disposable
ObservableZipIterable.ZipIterableObserver. upstream
Fields in io.reactivex.rxjava3.internal.operators.observable with type parameters of type Disposable Modifier and Type Field Description (package private) java.util.concurrent.atomic.AtomicReference<Disposable>
ObservableTimeoutTimed.FallbackObserver. arbiter
(package private) Consumer<? super Disposable>
ObservableAutoConnect. connection
(package private) java.util.concurrent.atomic.AtomicReference<Disposable>
ObservableDebounce.DebounceObserver. debouncer
(package private) java.util.concurrent.atomic.AtomicReference<Disposable>
ObservableMergeWithCompletable.MergeWithObserver. mainDisposable
(package private) java.util.concurrent.atomic.AtomicReference<Disposable>
ObservableMergeWithMaybe.MergeWithObserver. mainDisposable
(package private) java.util.concurrent.atomic.AtomicReference<Disposable>
ObservableMergeWithSingle.MergeWithObserver. mainDisposable
private Consumer<? super Disposable>
ObservableDoOnLifecycle. onSubscribe
(package private) java.util.concurrent.atomic.AtomicReference<Disposable>
ObservableSampleWithObservable.SampleMainObserver. other
(package private) java.util.concurrent.atomic.AtomicReference<Disposable>
ObservableWithLatestFrom.WithLatestFromObserver. other
(package private) java.util.concurrent.atomic.AtomicReference<Disposable>
ObservablePublishSelector.SourceObserver. target
(package private) java.util.concurrent.atomic.AtomicReference<Disposable>
ObservableBufferTimed.BufferExactUnboundedObserver. timer
(package private) java.util.concurrent.atomic.AtomicReference<Disposable>
ObservableSampleTimed.SampleTimedObserver. timer
(package private) java.util.concurrent.atomic.AtomicReference<Disposable>
ObservableBufferBoundary.BufferBoundaryObserver. upstream
(package private) java.util.concurrent.atomic.AtomicReference<Disposable>
ObservablePublish.PublishConnection. upstream
(package private) java.util.concurrent.atomic.AtomicReference<Disposable>
ObservableRepeatWhen.RepeatWhenObserver. upstream
(package private) java.util.concurrent.atomic.AtomicReference<Disposable>
ObservableRetryWhen.RepeatWhenObserver. upstream
(package private) java.util.concurrent.atomic.AtomicReference<Disposable>
ObservableSubscribeOn.SubscribeOnObserver. upstream
(package private) java.util.concurrent.atomic.AtomicReference<Disposable>
ObservableTakeUntil.TakeUntilMainObserver. upstream
(package private) java.util.concurrent.atomic.AtomicReference<Disposable>
ObservableTimeout.TimeoutFallbackObserver. upstream
(package private) java.util.concurrent.atomic.AtomicReference<Disposable>
ObservableTimeout.TimeoutObserver. upstream
(package private) java.util.concurrent.atomic.AtomicReference<Disposable>
ObservableTimeoutTimed.TimeoutFallbackObserver. upstream
(package private) java.util.concurrent.atomic.AtomicReference<Disposable>
ObservableTimeoutTimed.TimeoutObserver. upstream
(package private) java.util.concurrent.atomic.AtomicReference<Disposable>
ObservableWindowBoundary.WindowBoundaryMainObserver. upstream
(package private) java.util.concurrent.atomic.AtomicReference<Disposable>
ObservableWindowBoundarySelector.WindowBoundaryMainObserver.WindowEndObserverIntercept. upstream
(package private) java.util.concurrent.atomic.AtomicReference<Disposable>
ObservableWithLatestFrom.WithLatestFromObserver. upstream
(package private) java.util.concurrent.atomic.AtomicReference<Disposable>
ObservableWithLatestFromMany.WithLatestFromObserver. upstream
(package private) java.util.concurrent.atomic.AtomicReference<Disposable>
ObservableZip.ZipObserver. upstream
(package private) java.util.concurrent.atomic.AtomicReference<Disposable>
ObserverResourceWrapper. upstream
Methods in io.reactivex.rxjava3.internal.operators.observable with parameters of type Disposable Modifier and Type Method Description void
ObservableRefCount.RefConnection. accept(Disposable t)
void
ObservableReplay.DisposeConsumer. accept(Disposable r)
(package private) void
ObservableBufferBoundary.BufferBoundaryObserver. boundaryError(Disposable observer, java.lang.Throwable ex)
void
BlockingObservableIterable.BlockingObservableIterator. onSubscribe(Disposable d)
void
ObservableAll.AllObserver. onSubscribe(Disposable d)
void
ObservableAllSingle.AllObserver. onSubscribe(Disposable d)
void
ObservableAmb.AmbInnerObserver. onSubscribe(Disposable d)
void
ObservableAny.AnyObserver. onSubscribe(Disposable d)
void
ObservableAnySingle.AnyObserver. onSubscribe(Disposable d)
void
ObservableBuffer.BufferExactObserver. onSubscribe(Disposable d)
void
ObservableBuffer.BufferSkipObserver. onSubscribe(Disposable d)
void
ObservableBufferBoundary.BufferBoundaryObserver.BufferOpenObserver. onSubscribe(Disposable d)
void
ObservableBufferBoundary.BufferBoundaryObserver. onSubscribe(Disposable d)
void
ObservableBufferBoundary.BufferCloseObserver. onSubscribe(Disposable d)
void
ObservableBufferExactBoundary.BufferExactBoundaryObserver. onSubscribe(Disposable d)
void
ObservableBufferTimed.BufferExactBoundedObserver. onSubscribe(Disposable d)
void
ObservableBufferTimed.BufferExactUnboundedObserver. onSubscribe(Disposable d)
void
ObservableBufferTimed.BufferSkipBoundedObserver. onSubscribe(Disposable d)
void
ObservableCache. onSubscribe(Disposable d)
void
ObservableCollect.CollectObserver. onSubscribe(Disposable d)
void
ObservableCollectSingle.CollectObserver. onSubscribe(Disposable d)
void
ObservableCombineLatest.CombinerObserver. onSubscribe(Disposable d)
void
ObservableConcatMap.ConcatMapDelayErrorObserver.DelayErrorInnerObserver. onSubscribe(Disposable d)
void
ObservableConcatMap.ConcatMapDelayErrorObserver. onSubscribe(Disposable d)
void
ObservableConcatMap.SourceObserver.InnerObserver. onSubscribe(Disposable d)
void
ObservableConcatMap.SourceObserver. onSubscribe(Disposable d)
void
ObservableConcatMapEager.ConcatMapEagerMainObserver. onSubscribe(Disposable d)
void
ObservableConcatMapScheduler.ConcatMapDelayErrorObserver.DelayErrorInnerObserver. onSubscribe(Disposable d)
void
ObservableConcatMapScheduler.ConcatMapDelayErrorObserver. onSubscribe(Disposable d)
void
ObservableConcatMapScheduler.ConcatMapObserver.InnerObserver. onSubscribe(Disposable d)
void
ObservableConcatMapScheduler.ConcatMapObserver. onSubscribe(Disposable d)
void
ObservableConcatWithCompletable.ConcatWithObserver. onSubscribe(Disposable d)
void
ObservableConcatWithMaybe.ConcatWithObserver. onSubscribe(Disposable d)
void
ObservableConcatWithSingle.ConcatWithObserver. onSubscribe(Disposable d)
void
ObservableCount.CountObserver. onSubscribe(Disposable d)
void
ObservableCountSingle.CountObserver. onSubscribe(Disposable d)
void
ObservableDebounce.DebounceObserver. onSubscribe(Disposable d)
void
ObservableDebounceTimed.DebounceTimedObserver. onSubscribe(Disposable d)
void
ObservableDelay.DelayObserver. onSubscribe(Disposable d)
void
ObservableDelaySubscriptionOther.DelayObserver.OnComplete. onSubscribe(Disposable d)
void
ObservableDelaySubscriptionOther.DelayObserver. onSubscribe(Disposable d)
void
ObservableDematerialize.DematerializeObserver. onSubscribe(Disposable d)
void
ObservableDetach.DetachObserver. onSubscribe(Disposable d)
void
ObservableDoFinally.DoFinallyObserver. onSubscribe(Disposable d)
void
ObservableDoOnEach.DoOnEachObserver. onSubscribe(Disposable d)
void
ObservableElementAt.ElementAtObserver. onSubscribe(Disposable d)
void
ObservableElementAtMaybe.ElementAtObserver. onSubscribe(Disposable d)
void
ObservableElementAtSingle.ElementAtObserver. onSubscribe(Disposable d)
void
ObservableFlatMap.InnerObserver. onSubscribe(Disposable d)
void
ObservableFlatMap.MergeObserver. onSubscribe(Disposable d)
void
ObservableFlatMapCompletable.FlatMapCompletableMainObserver.InnerObserver. onSubscribe(Disposable d)
void
ObservableFlatMapCompletable.FlatMapCompletableMainObserver. onSubscribe(Disposable d)
void
ObservableFlatMapCompletableCompletable.FlatMapCompletableMainObserver.InnerObserver. onSubscribe(Disposable d)
void
ObservableFlatMapCompletableCompletable.FlatMapCompletableMainObserver. onSubscribe(Disposable d)
void
ObservableFlatMapMaybe.FlatMapMaybeObserver.InnerObserver. onSubscribe(Disposable d)
void
ObservableFlatMapMaybe.FlatMapMaybeObserver. onSubscribe(Disposable d)
void
ObservableFlatMapSingle.FlatMapSingleObserver.InnerObserver. onSubscribe(Disposable d)
void
ObservableFlatMapSingle.FlatMapSingleObserver. onSubscribe(Disposable d)
void
ObservableFlattenIterable.FlattenIterableObserver. onSubscribe(Disposable d)
void
ObservableFromCompletable.FromCompletableObserver. onSubscribe(Disposable d)
void
ObservableGroupBy.GroupByObserver. onSubscribe(Disposable d)
void
ObservableGroupJoin.LeftRightEndObserver. onSubscribe(Disposable d)
void
ObservableGroupJoin.LeftRightObserver. onSubscribe(Disposable d)
void
ObservableHide.HideDisposable. onSubscribe(Disposable d)
void
ObservableIgnoreElements.IgnoreObservable. onSubscribe(Disposable d)
void
ObservableIgnoreElementsCompletable.IgnoreObservable. onSubscribe(Disposable d)
void
ObservableLastMaybe.LastObserver. onSubscribe(Disposable d)
void
ObservableLastSingle.LastObserver. onSubscribe(Disposable d)
void
ObservableMapNotification.MapNotificationObserver. onSubscribe(Disposable d)
void
ObservableMaterialize.MaterializeObserver. onSubscribe(Disposable d)
void
ObservableMergeWithCompletable.MergeWithObserver. onSubscribe(Disposable d)
void
ObservableMergeWithCompletable.MergeWithObserver.OtherObserver. onSubscribe(Disposable d)
void
ObservableMergeWithMaybe.MergeWithObserver. onSubscribe(Disposable d)
void
ObservableMergeWithMaybe.MergeWithObserver.OtherObserver. onSubscribe(Disposable d)
void
ObservableMergeWithSingle.MergeWithObserver. onSubscribe(Disposable d)
void
ObservableMergeWithSingle.MergeWithObserver.OtherObserver. onSubscribe(Disposable d)
void
ObservableObserveOn.ObserveOnObserver. onSubscribe(Disposable d)
void
ObservableOnErrorComplete.OnErrorCompleteObserver. onSubscribe(Disposable d)
void
ObservableOnErrorNext.OnErrorNextObserver. onSubscribe(Disposable d)
void
ObservableOnErrorReturn.OnErrorReturnObserver. onSubscribe(Disposable d)
void
ObservablePublish.PublishConnection. onSubscribe(Disposable d)
void
ObservablePublishSelector.SourceObserver. onSubscribe(Disposable d)
void
ObservablePublishSelector.TargetObserver. onSubscribe(Disposable d)
void
ObservableReduceMaybe.ReduceObserver. onSubscribe(Disposable d)
void
ObservableReduceSeedSingle.ReduceSeedObserver. onSubscribe(Disposable d)
void
ObservableRefCount.RefCountObserver. onSubscribe(Disposable d)
void
ObservableRepeat.RepeatObserver. onSubscribe(Disposable d)
void
ObservableRepeatUntil.RepeatUntilObserver. onSubscribe(Disposable d)
void
ObservableRepeatWhen.RepeatWhenObserver.InnerRepeatObserver. onSubscribe(Disposable d)
void
ObservableRepeatWhen.RepeatWhenObserver. onSubscribe(Disposable d)
void
ObservableReplay.ReplayObserver. onSubscribe(Disposable p)
void
ObservableRetryBiPredicate.RetryBiObserver. onSubscribe(Disposable d)
void
ObservableRetryPredicate.RepeatObserver. onSubscribe(Disposable d)
void
ObservableRetryWhen.RepeatWhenObserver.InnerRepeatObserver. onSubscribe(Disposable d)
void
ObservableRetryWhen.RepeatWhenObserver. onSubscribe(Disposable d)
void
ObservableSampleTimed.SampleTimedObserver. onSubscribe(Disposable d)
void
ObservableSampleWithObservable.SampleMainObserver. onSubscribe(Disposable d)
void
ObservableSampleWithObservable.SamplerObserver. onSubscribe(Disposable d)
void
ObservableScan.ScanObserver. onSubscribe(Disposable d)
void
ObservableScanSeed.ScanSeedObserver. onSubscribe(Disposable d)
void
ObservableSequenceEqual.EqualObserver. onSubscribe(Disposable d)
void
ObservableSequenceEqualSingle.EqualObserver. onSubscribe(Disposable d)
void
ObservableSingleMaybe.SingleElementObserver. onSubscribe(Disposable d)
void
ObservableSingleSingle.SingleElementObserver. onSubscribe(Disposable d)
void
ObservableSkip.SkipObserver. onSubscribe(Disposable d)
void
ObservableSkipLast.SkipLastObserver. onSubscribe(Disposable d)
void
ObservableSkipLastTimed.SkipLastTimedObserver. onSubscribe(Disposable d)
void
ObservableSkipUntil.SkipUntil. onSubscribe(Disposable d)
void
ObservableSkipUntil.SkipUntilObserver. onSubscribe(Disposable d)
void
ObservableSkipWhile.SkipWhileObserver. onSubscribe(Disposable d)
void
ObservableSubscribeOn.SubscribeOnObserver. onSubscribe(Disposable d)
void
ObservableSwitchIfEmpty.SwitchIfEmptyObserver. onSubscribe(Disposable d)
void
ObservableSwitchMap.SwitchMapInnerObserver. onSubscribe(Disposable d)
void
ObservableSwitchMap.SwitchMapObserver. onSubscribe(Disposable d)
void
ObservableTake.TakeObserver. onSubscribe(Disposable d)
void
ObservableTakeLast.TakeLastObserver. onSubscribe(Disposable d)
void
ObservableTakeLastOne.TakeLastOneObserver. onSubscribe(Disposable d)
void
ObservableTakeLastTimed.TakeLastTimedObserver. onSubscribe(Disposable d)
void
ObservableTakeUntil.TakeUntilMainObserver. onSubscribe(Disposable d)
void
ObservableTakeUntil.TakeUntilMainObserver.OtherObserver. onSubscribe(Disposable d)
void
ObservableTakeUntilPredicate.TakeUntilPredicateObserver. onSubscribe(Disposable d)
void
ObservableTakeWhile.TakeWhileObserver. onSubscribe(Disposable d)
void
ObservableThrottleFirstTimed.DebounceTimedObserver. onSubscribe(Disposable d)
void
ObservableThrottleLatest.ThrottleLatestObserver. onSubscribe(Disposable d)
void
ObservableTimeInterval.TimeIntervalObserver. onSubscribe(Disposable d)
void
ObservableTimeout.TimeoutConsumer. onSubscribe(Disposable d)
void
ObservableTimeout.TimeoutFallbackObserver. onSubscribe(Disposable d)
void
ObservableTimeout.TimeoutObserver. onSubscribe(Disposable d)
void
ObservableTimeoutTimed.FallbackObserver. onSubscribe(Disposable d)
void
ObservableTimeoutTimed.TimeoutFallbackObserver. onSubscribe(Disposable d)
void
ObservableTimeoutTimed.TimeoutObserver. onSubscribe(Disposable d)
void
ObservableToList.ToListObserver. onSubscribe(Disposable d)
void
ObservableToListSingle.ToListObserver. onSubscribe(Disposable d)
void
ObservableUnsubscribeOn.UnsubscribeObserver. onSubscribe(Disposable d)
void
ObservableUsing.UsingObserver. onSubscribe(Disposable d)
void
ObservableWindow.WindowExactObserver. onSubscribe(Disposable d)
void
ObservableWindow.WindowSkipObserver. onSubscribe(Disposable d)
void
ObservableWindowBoundary.WindowBoundaryMainObserver. onSubscribe(Disposable d)
void
ObservableWindowBoundarySelector.WindowBoundaryMainObserver. onSubscribe(Disposable d)
void
ObservableWindowBoundarySelector.WindowBoundaryMainObserver.WindowEndObserverIntercept. onSubscribe(Disposable d)
void
ObservableWindowBoundarySelector.WindowBoundaryMainObserver.WindowStartObserver. onSubscribe(Disposable d)
void
ObservableWindowTimed.AbstractWindowObserver. onSubscribe(Disposable d)
void
ObservableWithLatestFrom.WithLatestFromObserver. onSubscribe(Disposable d)
void
ObservableWithLatestFrom.WithLatestFromOtherObserver. onSubscribe(Disposable d)
void
ObservableWithLatestFromMany.WithLatestFromObserver. onSubscribe(Disposable d)
void
ObservableWithLatestFromMany.WithLatestInnerObserver. onSubscribe(Disposable d)
void
ObservableZip.ZipObserver. onSubscribe(Disposable d)
void
ObservableZipIterable.ZipIterableObserver. onSubscribe(Disposable d)
void
ObserverResourceWrapper. onSubscribe(Disposable d)
void
ObservableCreate.CreateEmitter. setDisposable(Disposable d)
void
ObservableCreate.SerializedEmitter. setDisposable(Disposable d)
(package private) boolean
ObservableSequenceEqual.EqualCoordinator. setDisposable(Disposable d, int index)
(package private) boolean
ObservableSequenceEqualSingle.EqualCoordinator. setDisposable(Disposable d, int index)
(package private) void
ObservableSubscribeOn.SubscribeOnObserver. setDisposable(Disposable d)
(package private) boolean
ObservableSampleWithObservable.SampleMainObserver. setOther(Disposable o)
boolean
ObservableWithLatestFrom.WithLatestFromObserver. setOther(Disposable o)
void
ObservableDebounceTimed.DebounceEmitter. setResource(Disposable d)
void
ObservableInterval.IntervalObserver. setResource(Disposable d)
void
ObservableIntervalRange.IntervalRangeObserver. setResource(Disposable d)
void
ObservableTimer.TimerObserver. setResource(Disposable d)
void
ObserverResourceWrapper. setResource(Disposable resource)
Method parameters in io.reactivex.rxjava3.internal.operators.observable with type arguments of type Disposable Modifier and Type Method Description void
ObservablePublish. connect(Consumer<? super Disposable> connection)
void
ObservableReplay. connect(Consumer<? super Disposable> connection)
Constructor parameters in io.reactivex.rxjava3.internal.operators.observable with type arguments of type Disposable Constructor Description FallbackObserver(Observer<? super T> actual, java.util.concurrent.atomic.AtomicReference<Disposable> arbiter)
ObservableAutoConnect(ConnectableObservable<? extends T> source, int numberOfObservers, Consumer<? super Disposable> connection)
ObservableDoOnLifecycle(Observable<T> upstream, Consumer<? super Disposable> onSubscribe, Action onDispose)
SourceObserver(PublishSubject<T> subject, java.util.concurrent.atomic.AtomicReference<Disposable> target)
-
Uses of Disposable in io.reactivex.rxjava3.internal.operators.single
Fields in io.reactivex.rxjava3.internal.operators.single declared as Disposable Modifier and Type Field Description (package private) Disposable
SingleFlatMapPublisher.SingleFlatMapPublisherObserver. disposable
(package private) Disposable
SingleUnsubscribeOn.UnsubscribeOnSingleObserver. ds
(package private) Disposable
SingleAmb.AmbSingleObserver. upstream
(package private) Disposable
SingleDematerialize.DematerializeObserver. upstream
(package private) Disposable
SingleDetach.DetachSingleObserver. upstream
(package private) Disposable
SingleDoAfterSuccess.DoAfterObserver. upstream
(package private) Disposable
SingleDoAfterTerminate.DoAfterTerminateObserver. upstream
(package private) Disposable
SingleDoFinally.DoFinallyObserver. upstream
(package private) Disposable
SingleDoOnDispose.DoOnDisposeObserver. upstream
(package private) Disposable
SingleDoOnLifecycle.SingleLifecycleObserver. upstream
(package private) Disposable
SingleFlatMapIterableFlowable.FlatMapIterableObserver. upstream
(package private) Disposable
SingleFlatMapIterableObservable.FlatMapIterableObserver. upstream
(package private) Disposable
SingleFlatMapNotification.FlatMapSingleObserver. upstream
(package private) Disposable
SingleHide.HideSingleObserver. upstream
(package private) Disposable
SingleTimeInterval.TimeIntervalSingleObserver. upstream
(package private) Disposable
SingleToFlowable.SingleToFlowableObserver. upstream
(package private) Disposable
SingleToObservable.SingleToObservableObserver. upstream
(package private) Disposable
SingleUsing.UsingSingleObserver. upstream
Fields in io.reactivex.rxjava3.internal.operators.single with type parameters of type Disposable Modifier and Type Field Description (package private) Consumer<? super Disposable>
SingleDoOnLifecycle. onSubscribe
(package private) Consumer<? super Disposable>
SingleDoOnLifecycle.SingleLifecycleObserver. onSubscribe
(package private) Consumer<? super Disposable>
SingleDoOnSubscribe.DoOnSubscribeSingleObserver. onSubscribe
(package private) Consumer<? super Disposable>
SingleDoOnSubscribe. onSubscribe
(package private) java.util.concurrent.atomic.AtomicReference<Disposable>
SingleFlatMap.SingleFlatMapCallback.FlatMapSingleObserver. parent
(package private) java.util.concurrent.atomic.AtomicReference<Disposable>
SingleFlatMapMaybe.FlatMapMaybeObserver. parent
(package private) java.util.concurrent.atomic.AtomicReference<Disposable>
SingleTimeout.TimeoutMainObserver. task
Methods in io.reactivex.rxjava3.internal.operators.single with parameters of type Disposable Modifier and Type Method Description void
SingleAmb.AmbSingleObserver. onSubscribe(Disposable d)
void
SingleCache. onSubscribe(Disposable d)
void
SingleContains.ContainsSingleObserver. onSubscribe(Disposable d)
void
SingleDelay.Delay. onSubscribe(Disposable d)
void
SingleDelayWithCompletable.OtherObserver. onSubscribe(Disposable d)
void
SingleDelayWithObservable.OtherSubscriber. onSubscribe(Disposable d)
void
SingleDelayWithSingle.OtherObserver. onSubscribe(Disposable d)
void
SingleDematerialize.DematerializeObserver. onSubscribe(Disposable d)
void
SingleDetach.DetachSingleObserver. onSubscribe(Disposable d)
void
SingleDoAfterSuccess.DoAfterObserver. onSubscribe(Disposable d)
void
SingleDoAfterTerminate.DoAfterTerminateObserver. onSubscribe(Disposable d)
void
SingleDoFinally.DoFinallyObserver. onSubscribe(Disposable d)
void
SingleDoOnDispose.DoOnDisposeObserver. onSubscribe(Disposable d)
void
SingleDoOnError.DoOnError. onSubscribe(Disposable d)
void
SingleDoOnEvent.DoOnEvent. onSubscribe(Disposable d)
void
SingleDoOnLifecycle.SingleLifecycleObserver. onSubscribe(@NonNull Disposable d)
void
SingleDoOnSubscribe.DoOnSubscribeSingleObserver. onSubscribe(Disposable d)
void
SingleDoOnSuccess.DoOnSuccess. onSubscribe(Disposable d)
void
SingleDoOnTerminate.DoOnTerminate. onSubscribe(Disposable d)
void
SingleEquals.InnerObserver. onSubscribe(Disposable d)
void
SingleFlatMap.SingleFlatMapCallback.FlatMapSingleObserver. onSubscribe(Disposable d)
void
SingleFlatMap.SingleFlatMapCallback. onSubscribe(Disposable d)
void
SingleFlatMapBiSelector.FlatMapBiMainObserver.InnerObserver. onSubscribe(Disposable d)
void
SingleFlatMapBiSelector.FlatMapBiMainObserver. onSubscribe(Disposable d)
void
SingleFlatMapCompletable.FlatMapCompletableObserver. onSubscribe(Disposable d)
void
SingleFlatMapIterableFlowable.FlatMapIterableObserver. onSubscribe(Disposable d)
void
SingleFlatMapIterableObservable.FlatMapIterableObserver. onSubscribe(Disposable d)
void
SingleFlatMapMaybe.FlatMapMaybeObserver. onSubscribe(Disposable d)
void
SingleFlatMapMaybe.FlatMapSingleObserver. onSubscribe(Disposable d)
void
SingleFlatMapNotification.FlatMapSingleObserver.InnerObserver. onSubscribe(Disposable d)
void
SingleFlatMapNotification.FlatMapSingleObserver. onSubscribe(Disposable d)
void
SingleFlatMapPublisher.SingleFlatMapPublisherObserver. onSubscribe(Disposable d)
void
SingleHide.HideSingleObserver. onSubscribe(Disposable d)
void
SingleMap.MapSingleObserver. onSubscribe(Disposable d)
void
SingleObserveOn.ObserveOnSingleObserver. onSubscribe(Disposable d)
void
SingleOnErrorReturn.OnErrorReturn. onSubscribe(Disposable d)
void
SingleResumeNext.ResumeMainSingleObserver. onSubscribe(Disposable d)
void
SingleSubscribeOn.SubscribeOnObserver. onSubscribe(Disposable d)
void
SingleTakeUntil.TakeUntilMainObserver. onSubscribe(Disposable d)
void
SingleTimeInterval.TimeIntervalSingleObserver. onSubscribe(@NonNull Disposable d)
void
SingleTimeout.TimeoutMainObserver. onSubscribe(Disposable d)
void
SingleTimeout.TimeoutMainObserver.TimeoutFallbackObserver. onSubscribe(Disposable d)
void
SingleToFlowable.SingleToFlowableObserver. onSubscribe(Disposable d)
void
SingleToObservable.SingleToObservableObserver. onSubscribe(Disposable d)
void
SingleUnsubscribeOn.UnsubscribeOnSingleObserver. onSubscribe(Disposable d)
void
SingleUsing.UsingSingleObserver. onSubscribe(Disposable d)
void
SingleZipArray.ZipSingleObserver. onSubscribe(Disposable d)
void
SingleCreate.Emitter. setDisposable(Disposable d)
(package private) void
SingleTimer.TimerDisposable. setFuture(Disposable d)
Constructor parameters in io.reactivex.rxjava3.internal.operators.single with type arguments of type Disposable Constructor Description DoOnSubscribeSingleObserver(SingleObserver<? super T> actual, Consumer<? super Disposable> onSubscribe)
FlatMapMaybeObserver(java.util.concurrent.atomic.AtomicReference<Disposable> parent, MaybeObserver<? super R> downstream)
FlatMapSingleObserver(java.util.concurrent.atomic.AtomicReference<Disposable> parent, SingleObserver<? super R> downstream)
SingleDoOnLifecycle(Single<T> upstream, Consumer<? super Disposable> onSubscribe, Action onDispose)
SingleDoOnSubscribe(SingleSource<T> source, Consumer<? super Disposable> onSubscribe)
SingleLifecycleObserver(SingleObserver<? super T> downstream, Consumer<? super Disposable> onSubscribe, Action onDispose)
-
Uses of Disposable in io.reactivex.rxjava3.internal.schedulers
Classes in io.reactivex.rxjava3.internal.schedulers that implement Disposable Modifier and Type Class Description (package private) class
AbstractDirectTask
Base functionality for direct tasks that manage a runnable and cancellation/completion.(package private) static class
ComputationScheduler.EventLoopWorker
(package private) static class
ComputationScheduler.PoolWorker
(package private) static class
ExecutorScheduler.DelayedRunnable
static class
ExecutorScheduler.ExecutorWorker
(package private) static class
ExecutorScheduler.ExecutorWorker.BooleanRunnable
(package private) static class
ExecutorScheduler.ExecutorWorker.InterruptibleRunnable
Wrapper for aRunnable
with additional logic for handling interruption on a shared thread, similar to how Java Executors do it.(package private) static class
ImmediateThinScheduler.ImmediateThinWorker
(package private) class
InstantPeriodicTask
Wrapper for a regular task that gets immediately rescheduled when the task completed.(package private) static class
IoScheduler.EventLoopWorker
(package private) static class
IoScheduler.ThreadWorker
class
NewThreadWorker
Base class that manages a single-threaded ScheduledExecutorService as a worker but doesn't perform task-tracking operations.class
ScheduledDirectPeriodicTask
A Callable to be submitted to an ExecutorService that runs a Runnable action periodically and manages completion/cancellation.class
ScheduledDirectTask
A Callable to be submitted to an ExecutorService that runs a Runnable action and manages completion/cancellation.class
ScheduledRunnable
class
SchedulerWhen
Allows the use of operators for controlling the timing around when actions scheduled on workers are actually done.(package private) static class
SchedulerWhen.DelayedAction
(package private) static class
SchedulerWhen.ImmediateAction
(package private) static class
SchedulerWhen.QueueWorker
(package private) static class
SchedulerWhen.ScheduledAction
(package private) static class
SchedulerWhen.SubscribedDisposable
(package private) static class
SingleScheduler.ScheduledWorker
(package private) static class
TrampolineScheduler.TrampolineWorker
Fields in io.reactivex.rxjava3.internal.schedulers declared as Disposable Modifier and Type Field Description private Disposable
SchedulerWhen. disposable
(package private) static Disposable
ImmediateThinScheduler. DISPOSED
(package private) static Disposable
SchedulerWhen. DISPOSED
(package private) static Disposable
SchedulerWhen. SUBSCRIBED
(package private) Disposable
DisposeOnCancel. upstream
Methods in io.reactivex.rxjava3.internal.schedulers that return Disposable Modifier and Type Method Description protected Disposable
SchedulerWhen.DelayedAction. callActual(Scheduler.Worker actualWorker, CompletableObserver actionCompletable)
protected Disposable
SchedulerWhen.ImmediateAction. callActual(Scheduler.Worker actualWorker, CompletableObserver actionCompletable)
protected abstract Disposable
SchedulerWhen.ScheduledAction. callActual(Scheduler.Worker actualWorker, CompletableObserver actionCompletable)
(package private) Disposable
TrampolineScheduler.TrampolineWorker. enqueue(java.lang.Runnable action, long execTime)
@NonNull Disposable
ComputationScheduler.EventLoopWorker. schedule(@NonNull java.lang.Runnable action)
@NonNull Disposable
ComputationScheduler.EventLoopWorker. schedule(@NonNull java.lang.Runnable action, long delayTime, @NonNull java.util.concurrent.TimeUnit unit)
@NonNull Disposable
ExecutorScheduler.ExecutorWorker. schedule(@NonNull java.lang.Runnable run)
@NonNull Disposable
ExecutorScheduler.ExecutorWorker. schedule(@NonNull java.lang.Runnable run, long delay, @NonNull java.util.concurrent.TimeUnit unit)
@NonNull Disposable
ImmediateThinScheduler.ImmediateThinWorker. schedule(@NonNull java.lang.Runnable run)
@NonNull Disposable
ImmediateThinScheduler.ImmediateThinWorker. schedule(@NonNull java.lang.Runnable run, long delay, @NonNull java.util.concurrent.TimeUnit unit)
@NonNull Disposable
IoScheduler.EventLoopWorker. schedule(@NonNull java.lang.Runnable action, long delayTime, @NonNull java.util.concurrent.TimeUnit unit)
@NonNull Disposable
NewThreadWorker. schedule(@NonNull java.lang.Runnable run)
@NonNull Disposable
NewThreadWorker. schedule(@NonNull java.lang.Runnable action, long delayTime, @NonNull java.util.concurrent.TimeUnit unit)
@NonNull Disposable
SchedulerWhen.QueueWorker. schedule(@NonNull java.lang.Runnable action)
@NonNull Disposable
SchedulerWhen.QueueWorker. schedule(@NonNull java.lang.Runnable action, long delayTime, @NonNull java.util.concurrent.TimeUnit unit)
@NonNull Disposable
SingleScheduler.ScheduledWorker. schedule(@NonNull java.lang.Runnable run, long delay, @NonNull java.util.concurrent.TimeUnit unit)
@NonNull Disposable
TrampolineScheduler.TrampolineWorker. schedule(@NonNull java.lang.Runnable action)
@NonNull Disposable
TrampolineScheduler.TrampolineWorker. schedule(@NonNull java.lang.Runnable action, long delayTime, @NonNull java.util.concurrent.TimeUnit unit)
@NonNull Disposable
ComputationScheduler. scheduleDirect(@NonNull java.lang.Runnable run, long delay, java.util.concurrent.TimeUnit unit)
@NonNull Disposable
ExecutorScheduler. scheduleDirect(@NonNull java.lang.Runnable run)
@NonNull Disposable
ExecutorScheduler. scheduleDirect(@NonNull java.lang.Runnable run, long delay, java.util.concurrent.TimeUnit unit)
@NonNull Disposable
ImmediateThinScheduler. scheduleDirect(@NonNull java.lang.Runnable run)
@NonNull Disposable
ImmediateThinScheduler. scheduleDirect(@NonNull java.lang.Runnable run, long delay, java.util.concurrent.TimeUnit unit)
Disposable
NewThreadWorker. scheduleDirect(java.lang.Runnable run, long delayTime, java.util.concurrent.TimeUnit unit)
Schedules the given runnable on the underlying executor directly and returns its future wrapped into a Disposable.@NonNull Disposable
SingleScheduler. scheduleDirect(@NonNull java.lang.Runnable run, long delay, java.util.concurrent.TimeUnit unit)
@NonNull Disposable
TrampolineScheduler. scheduleDirect(@NonNull java.lang.Runnable run)
@NonNull Disposable
TrampolineScheduler. scheduleDirect(@NonNull java.lang.Runnable run, long delay, java.util.concurrent.TimeUnit unit)
@NonNull Disposable
ImmediateThinScheduler.ImmediateThinWorker. schedulePeriodically(@NonNull java.lang.Runnable run, long initialDelay, long period, java.util.concurrent.TimeUnit unit)
@NonNull Disposable
ComputationScheduler. schedulePeriodicallyDirect(@NonNull java.lang.Runnable run, long initialDelay, long period, java.util.concurrent.TimeUnit unit)
@NonNull Disposable
ExecutorScheduler. schedulePeriodicallyDirect(@NonNull java.lang.Runnable run, long initialDelay, long period, java.util.concurrent.TimeUnit unit)
@NonNull Disposable
ImmediateThinScheduler. schedulePeriodicallyDirect(@NonNull java.lang.Runnable run, long initialDelay, long period, java.util.concurrent.TimeUnit unit)
Disposable
NewThreadWorker. schedulePeriodicallyDirect(java.lang.Runnable run, long initialDelay, long period, java.util.concurrent.TimeUnit unit)
Schedules the given runnable periodically on the underlying executor directly and returns its future wrapped into a Disposable.@NonNull Disposable
SingleScheduler. schedulePeriodicallyDirect(@NonNull java.lang.Runnable run, long initialDelay, long period, java.util.concurrent.TimeUnit unit)
Constructors in io.reactivex.rxjava3.internal.schedulers with parameters of type Disposable Constructor Description DisposeOnCancel(Disposable d)
-
Uses of Disposable in io.reactivex.rxjava3.internal.subscribers
Classes in io.reactivex.rxjava3.internal.subscribers that implement Disposable Modifier and Type Class Description class
BoundedSubscriber<T>
class
DisposableAutoReleaseSubscriber<T>
Wraps lambda callbacks and when the upstream terminates or this subscriber gets disposed, removes itself from aCompositeDisposable
.class
ForEachWhileSubscriber<T>
class
LambdaSubscriber<T>
class
SubscriberResourceWrapper<T>
Methods in io.reactivex.rxjava3.internal.subscribers with parameters of type Disposable Modifier and Type Method Description protected void
QueueDrainSubscriber. fastPathEmitMax(U value, boolean delayError, Disposable dispose)
protected void
QueueDrainSubscriber. fastPathOrderedEmitMax(U value, boolean delayError, Disposable dispose)
void
SubscriberResourceWrapper. setResource(Disposable resource)
-
Uses of Disposable in io.reactivex.rxjava3.internal.subscriptions
Classes in io.reactivex.rxjava3.internal.subscriptions that implement Disposable Modifier and Type Class Description class
ArrayCompositeSubscription
A composite disposable with a fixed number of slots.class
AsyncSubscription
A subscription implementation that arbitrates exactly one other Subscription and can hold a single disposable resource.Fields in io.reactivex.rxjava3.internal.subscriptions with type parameters of type Disposable Modifier and Type Field Description (package private) java.util.concurrent.atomic.AtomicReference<Disposable>
AsyncSubscription. resource
Methods in io.reactivex.rxjava3.internal.subscriptions with parameters of type Disposable Modifier and Type Method Description boolean
AsyncSubscription. replaceResource(Disposable r)
Replaces the currently held resource with the given new one without disposing the old.boolean
AsyncSubscription. setResource(Disposable r)
Sets a new resource and disposes the currently held resource.Constructors in io.reactivex.rxjava3.internal.subscriptions with parameters of type Disposable Constructor Description AsyncSubscription(Disposable resource)
-
Uses of Disposable in io.reactivex.rxjava3.internal.util
Classes in io.reactivex.rxjava3.internal.util that implement Disposable Modifier and Type Class Description class
EmptyComponent
Singleton implementing many interfaces as empty.Fields in io.reactivex.rxjava3.internal.util declared as Disposable Modifier and Type Field Description Disposable
ConnectConsumer. disposable
(package private) Disposable
NotificationLite.DisposableNotification. upstream
Methods in io.reactivex.rxjava3.internal.util that return Disposable Modifier and Type Method Description static Disposable
NotificationLite. getDisposable(java.lang.Object o)
Methods in io.reactivex.rxjava3.internal.util with parameters of type Disposable Modifier and Type Method Description void
ConnectConsumer. accept(Disposable t)
static void
BlockingHelper. awaitForComplete(java.util.concurrent.CountDownLatch latch, Disposable subscription)
static <T,U>
booleanQueueDrainHelper. checkTerminated(boolean d, boolean empty, Observer<?> observer, boolean delayError, SimpleQueue<?> q, Disposable disposable, ObservableQueueDrain<T,U> qd)
static java.lang.Object
NotificationLite. disposable(Disposable d)
Converts a Disposable into a notification value.static <T,U>
voidQueueDrainHelper. drainLoop(SimplePlainQueue<T> q, Observer<? super U> a, boolean delayError, Disposable dispose, ObservableQueueDrain<T,U> qd)
static <T,U>
voidQueueDrainHelper. drainMaxLoop(SimplePlainQueue<T> q, org.reactivestreams.Subscriber<? super U> a, boolean delayError, Disposable dispose, QueueDrain<T,U> qd)
Drain the queue but give up with an error if there aren't enough requests.void
EmptyComponent. onSubscribe(Disposable d)
static boolean
EndConsumerHelper. setOnce(java.util.concurrent.atomic.AtomicReference<Disposable> upstream, Disposable next, java.lang.Class<?> observer)
Atomically updates the target upstream AtomicReference from null to the non-null next Disposable, otherwise disposes next and reports a ProtocolViolationException if the AtomicReference doesn't contain the shared disposed indicator.static boolean
EndConsumerHelper. validate(Disposable upstream, Disposable next, java.lang.Class<?> observer)
Ensures that the upstream Disposable is null and returns true, otherwise disposes the next Disposable and if the upstream is not the shared disposed instance, reports a ProtocolViolationException due to multiple subscribe attempts.Method parameters in io.reactivex.rxjava3.internal.util with type arguments of type Disposable Modifier and Type Method Description static boolean
EndConsumerHelper. setOnce(java.util.concurrent.atomic.AtomicReference<Disposable> upstream, Disposable next, java.lang.Class<?> observer)
Atomically updates the target upstream AtomicReference from null to the non-null next Disposable, otherwise disposes next and reports a ProtocolViolationException if the AtomicReference doesn't contain the shared disposed indicator.Constructors in io.reactivex.rxjava3.internal.util with parameters of type Disposable Constructor Description DisposableNotification(Disposable d)
-
Uses of Disposable in io.reactivex.rxjava3.observables
Methods in io.reactivex.rxjava3.observables that return Disposable Modifier and Type Method Description @NonNull Disposable
ConnectableObservable. connect()
Instructs theConnectableObservable
to begin emitting the items from its underlyingObservable
to itsObserver
s.Method parameters in io.reactivex.rxjava3.observables with type arguments of type Disposable Modifier and Type Method Description @NonNull Observable<T>
ConnectableObservable. autoConnect(int numberOfObservers, @NonNull Consumer<? super Disposable> connection)
Returns anObservable
that automatically connects (at most once) to thisConnectableObservable
when the specified number ofObserver
s subscribe to it and calls the specified callback with theDisposable
associated with the established connection.abstract void
ConnectableObservable. connect(@NonNull Consumer<? super Disposable> connection)
Instructs theConnectableObservable
to begin emitting the items from its underlyingObservable
to itsObserver
s. -
Uses of Disposable in io.reactivex.rxjava3.observers
Classes in io.reactivex.rxjava3.observers that implement Disposable Modifier and Type Class Description class
DisposableCompletableObserver
An abstractCompletableObserver
that allows asynchronous cancellation by implementing Disposable.class
DisposableMaybeObserver<T>
An abstractMaybeObserver
that allows asynchronous cancellation by implementingDisposable
.class
DisposableObserver<T>
An abstractObserver
that allows asynchronous cancellation by implementingDisposable
.class
DisposableSingleObserver<T>
An abstractSingleObserver
that allows asynchronous cancellation by implementingDisposable
.class
ResourceCompletableObserver
An abstractCompletableObserver
that allows asynchronous cancellation of its subscription and associated resources.class
ResourceMaybeObserver<T>
An abstractMaybeObserver
that allows asynchronous cancellation of its subscription and associated resources.class
ResourceObserver<T>
An abstractObserver
that allows asynchronous cancellation of its subscription and associated resources.class
ResourceSingleObserver<T>
An abstractSingleObserver
that allows asynchronous cancellation of its subscription and the associated resources.class
SafeObserver<T>
Wraps anotherObserver
and ensures allonXXX
methods conform the protocol (except the requirement for serialized access).class
SerializedObserver<T>
Serializes access to theObserver.onNext(Object)
,Observer.onError(Throwable)
andObserver.onComplete()
methods of anotherObserver
.class
TestObserver<T>
AnObserver
,MaybeObserver
,SingleObserver
andCompletableObserver
composite that can record events fromObservable
s,Maybe
s,Single
s andCompletable
s and allows making assertions about them.Fields in io.reactivex.rxjava3.observers declared as Disposable Modifier and Type Field Description private Disposable
DefaultObserver. upstream
(package private) Disposable
SafeObserver. upstream
The subscription.(package private) Disposable
SerializedObserver. upstream
Fields in io.reactivex.rxjava3.observers with type parameters of type Disposable Modifier and Type Field Description (package private) java.util.concurrent.atomic.AtomicReference<Disposable>
DisposableCompletableObserver. upstream
(package private) java.util.concurrent.atomic.AtomicReference<Disposable>
DisposableMaybeObserver. upstream
(package private) java.util.concurrent.atomic.AtomicReference<Disposable>
DisposableObserver. upstream
(package private) java.util.concurrent.atomic.AtomicReference<Disposable>
DisposableSingleObserver. upstream
private java.util.concurrent.atomic.AtomicReference<Disposable>
ResourceCompletableObserver. upstream
The active subscription.private java.util.concurrent.atomic.AtomicReference<Disposable>
ResourceMaybeObserver. upstream
The active subscription.private java.util.concurrent.atomic.AtomicReference<Disposable>
ResourceObserver. upstream
The active subscription.private java.util.concurrent.atomic.AtomicReference<Disposable>
ResourceSingleObserver. upstream
The active subscription.private java.util.concurrent.atomic.AtomicReference<Disposable>
TestObserver. upstream
Holds the current subscription if any.Methods in io.reactivex.rxjava3.observers with parameters of type Disposable Modifier and Type Method Description void
ResourceCompletableObserver. add(@NonNull Disposable resource)
Adds a resource to thisResourceCompletableObserver
.void
ResourceMaybeObserver. add(@NonNull Disposable resource)
Adds a resource to thisResourceMaybeObserver
.void
ResourceObserver. add(@NonNull Disposable resource)
Adds a resource to thisResourceObserver
.void
ResourceSingleObserver. add(@NonNull Disposable resource)
Adds a resource to thisResourceSingleObserver
.void
DefaultObserver. onSubscribe(@NonNull Disposable d)
void
DisposableCompletableObserver. onSubscribe(@NonNull Disposable d)
void
DisposableMaybeObserver. onSubscribe(@NonNull Disposable d)
void
DisposableObserver. onSubscribe(@NonNull Disposable d)
void
DisposableSingleObserver. onSubscribe(@NonNull Disposable d)
void
ResourceCompletableObserver. onSubscribe(@NonNull Disposable d)
void
ResourceMaybeObserver. onSubscribe(@NonNull Disposable d)
void
ResourceObserver. onSubscribe(Disposable d)
void
ResourceSingleObserver. onSubscribe(@NonNull Disposable d)
void
SafeObserver. onSubscribe(@NonNull Disposable d)
void
SerializedObserver. onSubscribe(@NonNull Disposable d)
void
TestObserver.EmptyObserver. onSubscribe(Disposable d)
void
TestObserver. onSubscribe(@NonNull Disposable d)
-
Uses of Disposable in io.reactivex.rxjava3.operators
Subinterfaces of Disposable in io.reactivex.rxjava3.operators Modifier and Type Interface Description interface
QueueDisposable<T>
An interface extendingSimpleQueue
andDisposable
and allows negotiating the fusion mode between subsequent operators of theObservable
base reactive type. -
Uses of Disposable in io.reactivex.rxjava3.schedulers
Classes in io.reactivex.rxjava3.schedulers that implement Disposable Modifier and Type Class Description (package private) class
TestScheduler.TestWorker
(package private) class
TestScheduler.TestWorker.QueueRemove
Methods in io.reactivex.rxjava3.schedulers that return Disposable Modifier and Type Method Description @NonNull Disposable
TestScheduler.TestWorker. schedule(@NonNull java.lang.Runnable run)
@NonNull Disposable
TestScheduler.TestWorker. schedule(@NonNull java.lang.Runnable run, long delayTime, @NonNull java.util.concurrent.TimeUnit unit)
-
Uses of Disposable in io.reactivex.rxjava3.subjects
Classes in io.reactivex.rxjava3.subjects that implement Disposable Modifier and Type Class Description (package private) static class
AsyncSubject.AsyncDisposable<T>
(package private) static class
BehaviorSubject.BehaviorDisposable<T>
(package private) static class
CompletableSubject.CompletableDisposable
(package private) static class
MaybeSubject.MaybeDisposable<T>
(package private) static class
PublishSubject.PublishDisposable<T>
Wraps the actual subscriber, tracks its requests and makes cancellation to remove itself from the current subscribers array.(package private) static class
ReplaySubject.ReplayDisposable<T>
(package private) static class
SingleSubject.SingleDisposable<T>
(package private) class
UnicastSubject.UnicastQueueDisposable
Methods in io.reactivex.rxjava3.subjects with parameters of type Disposable Modifier and Type Method Description void
AsyncSubject. onSubscribe(Disposable d)
void
BehaviorSubject. onSubscribe(Disposable d)
void
CompletableSubject. onSubscribe(Disposable d)
void
MaybeSubject. onSubscribe(Disposable d)
void
PublishSubject. onSubscribe(Disposable d)
void
ReplaySubject. onSubscribe(Disposable d)
void
SerializedSubject. onSubscribe(Disposable d)
void
SingleSubject. onSubscribe(@NonNull Disposable d)
void
UnicastSubject. onSubscribe(Disposable d)
-
Uses of Disposable in io.reactivex.rxjava3.subscribers
Classes in io.reactivex.rxjava3.subscribers that implement Disposable Modifier and Type Class Description class
DisposableSubscriber<T>
An abstract Subscriber that allows asynchronous, external cancellation by implementingDisposable
.class
ResourceSubscriber<T>
An abstract Subscriber that allows asynchronous cancellation of its subscription and associated resources.Methods in io.reactivex.rxjava3.subscribers with parameters of type Disposable Modifier and Type Method Description void
ResourceSubscriber. add(Disposable resource)
Adds a resource to thisResourceSubscriber
.
-