Uses of Class
io.reactivex.rxjava3.core.Completable
Packages that use Completable
Package
Description
Base reactive classes:
Flowable
, Observable
,
Single
, Maybe
and
Completable
; base reactive consumers;
other common base interfaces.Contains the central plugin handler
RxJavaPlugins
class to hook into the lifecycle of the base reactive types and schedulers.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.
-
Uses of Completable in io.reactivex.rxjava3.core
Methods in io.reactivex.rxjava3.core that return CompletableModifier and TypeMethodDescriptionstatic @NonNull Completable
Completable.amb
(@NonNull Iterable<@NonNull ? extends CompletableSource> sources) Returns aCompletable
which terminates as soon as one of the sourceCompletable
s in theIterable
sequence terminates (normally or with an error) and disposes all otherCompletable
s.static @NonNull Completable
Completable.ambArray
(@NonNull CompletableSource... sources) Returns aCompletable
which terminates as soon as one of the sourceCompletable
s terminates (normally or with an error) and disposes all otherCompletable
s.final @NonNull Completable
Completable.ambWith
(@NonNull CompletableSource other) Returns aCompletable
that emits the a terminated event of either thisCompletable
or the otherCompletableSource
, whichever fires first.final @NonNull Completable
Completable.andThen
(@NonNull CompletableSource next) final @NonNull Completable
Completable.cache()
Subscribes to thisCompletable
only once, when the firstCompletableObserver
subscribes to the resultCompletable
, caches its terminal event and relays/replays it to observers.static @NonNull Completable
Completable.complete()
Returns aCompletable
instance that completes immediately when subscribed to.final @NonNull Completable
Completable.compose
(@NonNull CompletableTransformer transformer) Calls the given transformer function with this instance and returns the function's resultingCompletableSource
wrapped withwrap(CompletableSource)
.static @NonNull Completable
Completable.concat
(@NonNull Iterable<@NonNull ? extends CompletableSource> sources) Returns aCompletable
which completes only when all sources complete, one after another.static @NonNull Completable
Completable.concat
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends CompletableSource> sources) Returns aCompletable
which completes only when all sources complete, one after another.static @NonNull Completable
Completable.concat
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends CompletableSource> sources, int prefetch) Returns aCompletable
which completes only when all sources complete, one after another.static @NonNull Completable
Completable.concatArray
(@NonNull CompletableSource... sources) Returns aCompletable
which completes only when all sources complete, one after another.static @NonNull Completable
Completable.concatArrayDelayError
(@NonNull CompletableSource... sources) Returns aCompletable
which completes only when all sources complete, one after another.static @NonNull Completable
Completable.concatDelayError
(@NonNull Iterable<@NonNull ? extends CompletableSource> sources) Returns aCompletable
which completes only when all sources complete, one after another.static @NonNull Completable
Completable.concatDelayError
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends CompletableSource> sources) Returns aCompletable
which completes only when all sources complete, one after another.static @NonNull Completable
Completable.concatDelayError
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends CompletableSource> sources, int prefetch) Returns aCompletable
which completes only when all sources complete, one after another.final @NonNull Completable
Flowable.concatMapCompletable
(@NonNull Function<? super @NonNull T, ? extends CompletableSource> mapper) Maps the upstream items intoCompletableSource
s and subscribes to them one after the other completes.final @NonNull Completable
Flowable.concatMapCompletable
(@NonNull Function<? super @NonNull T, ? extends CompletableSource> mapper, int prefetch) Maps the upstream items intoCompletableSource
s and subscribes to them one after the other completes.final @NonNull Completable
Maybe.concatMapCompletable
(@NonNull Function<? super @NonNull T, ? extends CompletableSource> mapper) Returns aCompletable
that completes based on applying a specified function to the item emitted by the currentMaybe
, where that function returns aCompletable
.final @NonNull Completable
Observable.concatMapCompletable
(@NonNull Function<? super @NonNull T, ? extends CompletableSource> mapper) Maps each element of the currentObservable
intoCompletableSource
s, subscribes to them one at a time in order and waits until the upstream and allCompletableSource
s complete.final @NonNull Completable
Observable.concatMapCompletable
(@NonNull Function<? super @NonNull T, ? extends CompletableSource> mapper, int capacityHint) Maps each element of the currentObservable
intoCompletableSource
s, subscribes to them one at a time in order and waits until the upstream and allCompletableSource
s complete.final @NonNull Completable
Single.concatMapCompletable
(@NonNull Function<? super @NonNull T, ? extends CompletableSource> mapper) Returns aCompletable
that completes based on applying a specified function to the item emitted by the currentSingle
, where that function returns aCompletableSource
.final @NonNull Completable
Flowable.concatMapCompletableDelayError
(@NonNull Function<? super @NonNull T, ? extends CompletableSource> mapper) Maps the upstream items intoCompletableSource
s and subscribes to them one after the other terminates, delaying all errors till both thisFlowable
and all innerCompletableSource
s terminate.final @NonNull Completable
Flowable.concatMapCompletableDelayError
(@NonNull Function<? super @NonNull T, ? extends CompletableSource> mapper, boolean tillTheEnd) Maps the upstream items intoCompletableSource
s and subscribes to them one after the other terminates, optionally delaying all errors till both thisFlowable
and all innerCompletableSource
s terminate.final @NonNull Completable
Flowable.concatMapCompletableDelayError
(@NonNull Function<? super @NonNull T, ? extends CompletableSource> mapper, boolean tillTheEnd, int prefetch) Maps the upstream items intoCompletableSource
s and subscribes to them one after the other terminates, optionally delaying all errors till both thisFlowable
and all innerCompletableSource
s terminate.final @NonNull Completable
Observable.concatMapCompletableDelayError
(@NonNull Function<? super @NonNull T, ? extends CompletableSource> mapper) Maps the upstream items intoCompletableSource
s and subscribes to them one after the other terminates, delaying all errors till both the currentObservable
and all innerCompletableSource
s terminate.final @NonNull Completable
Observable.concatMapCompletableDelayError
(@NonNull Function<? super @NonNull T, ? extends CompletableSource> mapper, boolean tillTheEnd) Maps the upstream items intoCompletableSource
s and subscribes to them one after the other terminates, optionally delaying all errors till both the currentObservable
and all innerCompletableSource
s terminate.final @NonNull Completable
Observable.concatMapCompletableDelayError
(@NonNull Function<? super @NonNull T, ? extends CompletableSource> mapper, boolean tillTheEnd, int bufferSize) Maps the upstream items intoCompletableSource
s and subscribes to them one after the other terminates, optionally delaying all errors till both the currentObservable
and all innerCompletableSource
s terminate.final @NonNull Completable
Completable.concatWith
(@NonNull CompletableSource other) Concatenates thisCompletable
with anotherCompletableSource
.static @NonNull Completable
Completable.create
(@NonNull CompletableOnSubscribe source) Provides an API (via a coldCompletable
) that bridges the reactive world with the callback-style world.static @NonNull Completable
Completable.defer
(@NonNull Supplier<? extends @NonNull CompletableSource> supplier) Defers the subscription to aCompletable
instance returned by a supplier.final @NonNull Completable
Returns aCompletable
which delays the emission of the completion event by the given time.final @NonNull Completable
Returns aCompletable
which delays the emission of the completion event by the given time while running on the specifiedScheduler
.final @NonNull Completable
Completable.delay
(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean delayError) Returns aCompletable
which delays the emission of the completion event, and optionally the error as well, by the given time while running on the specifiedScheduler
.final @NonNull Completable
Completable.delaySubscription
(long time, @NonNull TimeUnit unit) Returns aCompletable
that delays the subscription to the upstream by a given amount of time.final @NonNull Completable
Completable.delaySubscription
(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Returns aCompletable
that delays the subscription to the upstream by a given amount of time, both waiting and subscribing on a givenScheduler
.final @NonNull Completable
Completable.doAfterTerminate
(@NonNull Action onAfterTerminate) Returns aCompletable
instance that calls the givenonAfterTerminate
Action
after thisCompletable
completes normally or with an exception.final @NonNull Completable
Calls the specifiedAction
after thisCompletable
signalsonError
oronComplete
or gets disposed by the downstream.final @NonNull Completable
Completable.doOnComplete
(@NonNull Action onComplete) final @NonNull Completable
Completable.doOnDispose
(@NonNull Action onDispose) Calls the sharedAction
if aCompletableObserver
subscribed to the currentCompletable
disposes the commonDisposable
it received viaonSubscribe
.final @NonNull Completable
final @NonNull Completable
final @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 Throwable> onError, Action onComplete, Action onTerminate, Action onAfterTerminate, Action onDispose) Returns aCompletable
instance that calls the various callbacks upon the specific lifecycle events.final @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.final @NonNull Completable
Completable.doOnTerminate
(@NonNull Action onTerminate) Returns aCompletable
instance that calls the givenonTerminate
Action
just before thisCompletable
completes normally or with an exception.static @NonNull Completable
Creates aCompletable
which calls the given error supplier for each subscriber and emits its returnedThrowable
.static @NonNull Completable
Creates aCompletable
instance that emits the givenThrowable
exception to subscribers.final @NonNull Completable
Flowable.flatMapCompletable
(@NonNull Function<? super @NonNull T, ? extends CompletableSource> mapper) Maps each element of the upstreamFlowable
intoCompletableSource
s, subscribes to them and waits until the upstream and allCompletableSource
s complete.final @NonNull Completable
Flowable.flatMapCompletable
(@NonNull Function<? super @NonNull T, ? extends CompletableSource> mapper, boolean delayErrors, int maxConcurrency) Maps each element of the upstreamFlowable
intoCompletableSource
s, subscribes to them and waits until the upstream and allCompletableSource
s complete, optionally delaying all errors.final @NonNull Completable
Maybe.flatMapCompletable
(@NonNull Function<? super @NonNull T, ? extends CompletableSource> mapper) Returns aCompletable
that completes based on applying a specified function to the item emitted by the currentMaybe
, where that function returns aCompletable
.final @NonNull Completable
Observable.flatMapCompletable
(@NonNull Function<? super @NonNull T, ? extends CompletableSource> mapper) Maps each element of the currentObservable
intoCompletableSource
s, subscribes to them and waits until the upstream and allCompletableSource
s complete.final @NonNull Completable
Observable.flatMapCompletable
(@NonNull Function<? super @NonNull T, ? extends CompletableSource> mapper, boolean delayErrors) Maps each element of the currentObservable
intoCompletableSource
s, subscribes to them and waits until the upstream and allCompletableSource
s complete, optionally delaying all errors.final @NonNull Completable
Single.flatMapCompletable
(@NonNull Function<? super @NonNull T, ? extends CompletableSource> mapper) Returns aCompletable
that completes based on applying a specified function to the item emitted by the currentSingle
, where that function returns aCompletableSource
.static @NonNull Completable
Completable.fromAction
(@NonNull Action action) Returns aCompletable
instance that runs the givenAction
for eachCompletableObserver
and emits either an exception or simply completes.static @NonNull Completable
Completable.fromCallable
(@NonNull Callable<?> callable) Returns aCompletable
which when subscribed, executes theCallable
function, ignores its normal result and emitsonError
oronComplete
only.static @NonNull Completable
Completable.fromCompletionStage
(@NonNull CompletionStage<?> stage) Signals completion (or error) when theCompletionStage
terminates.static @NonNull Completable
Completable.fromFuture
(@NonNull Future<?> future) Returns aCompletable
instance that reacts to the termination of the givenFuture
in a blocking fashion.static <@NonNull T>
@NonNull CompletableCompletable.fromMaybe
(@NonNull MaybeSource<@NonNull T> maybe) Returns aCompletable
instance that when subscribed to, subscribes to theMaybeSource
instance and emits anonComplete
event if the maybe emitsonSuccess
/onComplete
or forwards anyonError
events.static <@NonNull T>
@NonNull CompletableCompletable.fromObservable
(@NonNull ObservableSource<@NonNull T> observable) Returns aCompletable
instance that subscribes to the givenObservableSource
, ignores all values and emits only the terminal event.static <@NonNull T>
@NonNull CompletableCompletable.fromPublisher
(@NonNull org.reactivestreams.Publisher<@NonNull T> publisher) Returns aCompletable
instance that subscribes to the givenPublisher
, ignores all values and emits only the terminal event.static @NonNull Completable
Completable.fromRunnable
(@NonNull Runnable run) Returns aCompletable
instance that runs the givenRunnable
for eachCompletableObserver
and emits either its unchecked exception or simply completes.static <@NonNull T>
@NonNull CompletableCompletable.fromSingle
(@NonNull SingleSource<@NonNull T> single) Returns aCompletable
instance that when subscribed to, subscribes to theSingleSource
instance and emits a completion event if the single emitsonSuccess
or forwards anyonError
events.static @NonNull Completable
Completable.fromSupplier
(@NonNull Supplier<?> supplier) Returns aCompletable
which when subscribed, executes theSupplier
function, ignores its normal result and emitsonError
oronComplete
only.final @NonNull Completable
Completable.hide()
Hides the identity of thisCompletable
and itsDisposable
.final @NonNull Completable
Maybe.ignoreElement()
Returns aCompletable
that ignores the item emitted by the currentMaybe
and only callsonComplete
oronError
.final @NonNull Completable
Single.ignoreElement()
final @NonNull Completable
Flowable.ignoreElements()
Ignores all items emitted by the currentFlowable
and only callsonComplete
oronError
.final @NonNull Completable
Observable.ignoreElements()
Ignores all items emitted by the currentObservable
and only callsonComplete
oronError
.final @NonNull Completable
Completable.lift
(@NonNull CompletableOperator onLift) This method requires advanced knowledge about building operators, please consider other standard composition methods first; Returns aCompletable
which, when subscribed to, invokes theapply(CompletableObserver)
method of the providedCompletableOperator
for each individual downstreamCompletable
and allows the insertion of a custom operator by accessing the downstream'sCompletableObserver
during this subscription phase and providing a newCompletableObserver
, containing the custom operator's intended business logic, that will be used in the subscription process going further upstream.static @NonNull Completable
Completable.merge
(@NonNull Iterable<@NonNull ? extends CompletableSource> sources) Returns aCompletable
instance that subscribes to all sources at once and completes only when all sourceCompletableSource
s complete or one of them emits an error.static @NonNull Completable
Completable.merge
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends CompletableSource> sources) Returns aCompletable
instance that subscribes to all sources at once and completes only when all sourceCompletableSource
s complete or one of them emits an error.static @NonNull Completable
Completable.merge
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends CompletableSource> sources, int maxConcurrency) Returns aCompletable
instance that keeps subscriptions to a limited number of sources at once and completes only when all sourceCompletableSource
s complete or one of them emits an error.private static @NonNull Completable
Completable.merge0
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends CompletableSource> sources, int maxConcurrency, boolean delayErrors) Returns aCompletable
instance that keeps subscriptions to a limited number ofCompletableSource
s at once and completes only when all sourceCompletableSource
s terminate in one way or another, combining any exceptions signaled by either the sourcePublisher
or the innerCompletableSource
instances.static @NonNull Completable
Completable.mergeArray
(@NonNull CompletableSource... sources) Returns aCompletable
instance that subscribes to all sources at once and completes only when all sourceCompletableSource
s complete or one of them emits an error.static @NonNull Completable
Completable.mergeArrayDelayError
(@NonNull CompletableSource... sources) Returns aCompletable
that subscribes to allCompletableSource
s in the source array and delays any error emitted by any of the innerCompletableSource
s until all of them terminate in a way or another.static @NonNull Completable
Completable.mergeDelayError
(@NonNull Iterable<@NonNull ? extends CompletableSource> sources) Returns aCompletable
that subscribes to allCompletableSource
s in the source sequence and delays any error emitted by any of the innerCompletableSource
s until all of them terminate in a way or another.static @NonNull Completable
Completable.mergeDelayError
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends CompletableSource> sources) Returns aCompletable
that subscribes to allCompletableSource
s in the source sequence and delays any error emitted by either the sourcesPublisher
or any of the innerCompletableSource
s until all of them terminate in a way or another.static @NonNull Completable
Completable.mergeDelayError
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends CompletableSource> sources, int maxConcurrency) Returns aCompletable
that subscribes to a limited number of innerCompletableSource
s at once in the source sequence and delays any error emitted by either the sourcesPublisher
or any of the innerCompletableSource
s until all of them terminate in a way or another.final @NonNull Completable
Completable.mergeWith
(@NonNull CompletableSource other) Returns aCompletable
which subscribes to this and the otherCompletableSource
and completes when both of them complete or one emits an error.static @NonNull Completable
Completable.never()
Returns aCompletable
that never callsonError
oronComplete
.final @NonNull Completable
Returns aCompletable
which emits the terminal events from the thread of the specifiedScheduler
.final @NonNull Completable
Completable.onErrorComplete()
Returns aCompletable
instance that if thisCompletable
emits an error, it will emit anonComplete
and swallow the upstreamThrowable
.final @NonNull Completable
Completable.onErrorComplete
(@NonNull Predicate<? super Throwable> predicate) final @NonNull Completable
Completable.onErrorResumeNext
(@NonNull Function<? super Throwable, ? extends CompletableSource> fallbackSupplier) Returns aCompletable
instance that when encounters an error from thisCompletable
, calls the specifiedmapper
Function
that returns aCompletableSource
instance for it and resumes the execution with it.final @NonNull Completable
Completable.onErrorResumeWith
(@NonNull CompletableSource fallback) Resumes the flow with the givenCompletableSource
when the currentCompletable
fails instead of signaling the error viaonError
.final @NonNull Completable
Completable.onTerminateDetach()
Nulls out references to the upstream producer and downstreamCompletableObserver
if the sequence is terminated or downstream callsdispose()
.final @NonNull Completable
Completable.repeat()
Returns aCompletable
that repeatedly subscribes to thisCompletable
until disposed.final @NonNull Completable
Completable.repeat
(long times) Returns aCompletable
that subscribes repeatedly at most the given number of times to thisCompletable
.final @NonNull Completable
Completable.repeatUntil
(@NonNull BooleanSupplier stop) Returns aCompletable
that repeatedly subscribes to thisCompletable
so long as the given stopBooleanSupplier
returnsfalse
.final @NonNull Completable
Completable.repeatWhen
(@NonNull Function<? super Flowable<Object>, @NonNull ? extends org.reactivestreams.Publisher<@NonNull ?>> handler) Returns aCompletable
instance that repeats when thePublisher
returned by the handlerFunction
emits an item or completes when thisPublisher
emits anonComplete
event.final @NonNull Completable
Completable.retry()
Returns aCompletable
that retries thisCompletable
as long as it emits anonError
event.final @NonNull Completable
Completable.retry
(long times) Returns aCompletable
that when thisCompletable
emits an error, retries at most the given number of times before giving up and emitting the last error.final @NonNull Completable
Returns aCompletable
that when thisCompletable
emits an error, retries at most times or until the predicate returnsfalse
, whichever happens first and emitting the last error.final @NonNull Completable
Completable.retry
(@NonNull BiPredicate<? super Integer, ? super Throwable> predicate) Returns aCompletable
that retries thisCompletable
in case of an error as long as thepredicate
returnstrue
.final @NonNull Completable
Returns aCompletable
that when thisCompletable
emits an error, calls the given predicate with the latestThrowable
to decide whether to resubscribe to the upstream or not.final @NonNull Completable
Completable.retryUntil
(@NonNull BooleanSupplier stop) Retries until the given stop function returnstrue
.final @NonNull Completable
Completable.retryWhen
(@NonNull Function<? super Flowable<Throwable>, @NonNull ? extends org.reactivestreams.Publisher<@NonNull ?>> handler) Returns aCompletable
which given aPublisher
and when thisCompletable
emits an error, delivers that error through aFlowable
and thePublisher
should signal a value indicating a retry in response or a terminal event indicating a termination.final @NonNull Completable
Completable.startWith
(@NonNull CompletableSource other) Returns aCompletable
which first runs the otherCompletableSource
then the currentCompletable
if the other completed normally.final @NonNull Completable
Completable.subscribeOn
(@NonNull Scheduler scheduler) Returns aCompletable
which subscribes the downstream subscriber on the specified scheduler, making sure the subscription side-effects happen on that specific thread of theScheduler
.final @NonNull Completable
Flowable.switchMapCompletable
(@NonNull Function<? super @NonNull T, ? extends CompletableSource> mapper) Maps the upstream values intoCompletableSource
s, subscribes to the newer one while disposing the subscription to the previousCompletableSource
, thus keeping at most one activeCompletableSource
running.final @NonNull Completable
Observable.switchMapCompletable
(@NonNull Function<? super @NonNull T, ? extends CompletableSource> mapper) Maps the items of the currentObservable
intoCompletableSource
s, subscribes to the newer one while disposing the subscription to the previousCompletableSource
, thus keeping at most one activeCompletableSource
running.final @NonNull Completable
Flowable.switchMapCompletableDelayError
(@NonNull Function<? super @NonNull T, ? extends CompletableSource> mapper) Maps the upstream values intoCompletableSource
s, subscribes to the newer one while disposing the subscription to the previousCompletableSource
, thus keeping at most one activeCompletableSource
running and delaying any main or inner errors until all of them terminate.final @NonNull Completable
Observable.switchMapCompletableDelayError
(@NonNull Function<? super @NonNull T, ? extends CompletableSource> mapper) Maps the upstream values intoCompletableSource
s, subscribes to the newer one while disposing the subscription to the previousCompletableSource
, thus keeping at most one activeCompletableSource
running and delaying any main or inner errors until all of them terminate.static @NonNull Completable
Completable.switchOnNext
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends CompletableSource> sources) Switches betweenCompletableSource
s emitted by the sourcePublisher
whenever a newCompletableSource
is emitted, disposing the previously runningCompletableSource
, exposing the setup as aCompletable
sequence.static @NonNull Completable
Completable.switchOnNextDelayError
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends CompletableSource> sources) Switches betweenCompletableSource
s emitted by the sourcePublisher
whenever a newCompletableSource
is emitted, disposing the previously runningCompletableSource
, exposing the setup as aCompletable
sequence and delaying all errors from all of them until all terminate.final @NonNull Completable
Completable.takeUntil
(@NonNull CompletableSource other) Terminates the downstream if this or the otherCompletable
terminates (wins the termination race) while disposing the connection to the losing source.final @NonNull Completable
Returns aCompletabl
e that runs thisCompletable
and emits aTimeoutException
in case thisCompletable
doesn't complete within the given time.final @NonNull Completable
Completable.timeout
(long timeout, @NonNull TimeUnit unit, @NonNull CompletableSource fallback) Returns aCompletable
that runs thisCompletable
and switches to the otherCompletableSource
in case thisCompletable
doesn't complete within the given time.final @NonNull Completable
Returns aCompletable
that runs thisCompletable
and emits aTimeoutException
in case thisCompletable
doesn't complete within the given time while "waiting" on the specifiedScheduler
.final @NonNull Completable
Completable.timeout
(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, @NonNull CompletableSource fallback) Returns aCompletable
that runs thisCompletable
and switches to the otherCompletableSource
in case thisCompletable
doesn't complete within the given time while "waiting" on the specifiedScheduler
.private @NonNull Completable
Completable.timeout0
(long timeout, TimeUnit unit, Scheduler scheduler, CompletableSource fallback) Returns aCompletable
that runs thisCompletable
and optionally switches to the otherCompletableSource
in case thisCompletable
doesn't complete within the given time while "waiting" on the specifiedScheduler
.static @NonNull Completable
Returns aCompletable
instance that fires itsonComplete
event after the given delay elapsed.static @NonNull Completable
Returns aCompletable
instance that fires itsonComplete
event after the given delay elapsed by using the suppliedScheduler
.static @NonNull Completable
Completable.unsafeCreate
(@NonNull CompletableSource onSubscribe) Constructs aCompletable
instance by wrapping the given source callback without any safeguards; you should manage the lifecycle and response to downstream disposal.final @NonNull Completable
Completable.unsubscribeOn
(@NonNull Scheduler scheduler) Returns aCompletable
which makes sure when an observer disposes the subscription, thedispose()
method is called on the specifiedScheduler
.static <@NonNull R>
@NonNull CompletableCompletable.using
(@NonNull Supplier<@NonNull R> resourceSupplier, @NonNull Function<? super @NonNull R, ? extends CompletableSource> sourceSupplier, @NonNull Consumer<? super @NonNull R> resourceCleanup) Returns aCompletable
instance which manages a resource along with a customCompletableSource
instance while the subscription is active.static <@NonNull R>
@NonNull CompletableCompletable.using
(@NonNull Supplier<@NonNull R> resourceSupplier, @NonNull Function<? super @NonNull R, ? extends CompletableSource> sourceSupplier, @NonNull Consumer<? super @NonNull R> resourceCleanup, boolean eager) Returns aCompletable
instance which manages a resource along with a customCompletableSource
instance while the subscription is active and performs eager or lazy resource disposition.static @NonNull Completable
Completable.wrap
(@NonNull CompletableSource source) Methods in io.reactivex.rxjava3.core with parameters of type CompletableModifier and TypeMethodDescriptionCompletableConverter.apply
(@NonNull Completable upstream) Applies a function to the upstream Completable and returns a converted value of typeR
.CompletableTransformer.apply
(@NonNull Completable upstream) Applies a function to the upstreamCompletable
and returns aCompletableSource
.Method parameters in io.reactivex.rxjava3.core with type arguments of type CompletableModifier and TypeMethodDescription<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.<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. -
Uses of Completable in io.reactivex.rxjava3.internal.jdk8
Subclasses of Completable in io.reactivex.rxjava3.internal.jdk8Modifier and TypeClassDescriptionfinal class
Wrap a CompletionStage and signal its outcome. -
Uses of Completable in io.reactivex.rxjava3.internal.operators.completable
Subclasses of Completable in io.reactivex.rxjava3.internal.operators.completableModifier and TypeClassDescriptionfinal class
final class
final class
Consume the upstream source exactly once and cache its terminal event.final class
final class
final class
final class
final class
final class
final class
Breaks the references between the upstream and downstream when the Completable terminates.final class
final class
Execute an action after an onError, onComplete or a dispose event.final class
final class
final class
final class
final class
final class
final class
final class
final class
final class
final class
Call a Supplier for each incoming CompletableObserver and signal completion or the thrown exception.final class
final class
Hides the identity of the upstream Completable and its Disposable sent through onSubscribe.final class
final class
final class
final class
final class
final class
final class
final class
final class
final class
final class
final class
final class
Terminates the sequence if either the main or the other Completable terminate.final class
final class
Signals anonComplete
event after the specified delay.final class
Fields in io.reactivex.rxjava3.internal.operators.completable declared as CompletableModifier and TypeFieldDescriptionstatic final Completable
CompletableEmpty.INSTANCE
static final Completable
CompletableNever.INSTANCE
(package private) final Completable
CompletableMaterialize.source
(package private) final Completable
CompletableTakeUntilCompletable.source
Constructors in io.reactivex.rxjava3.internal.operators.completable with parameters of type CompletableModifierConstructorDescriptionCompletableMaterialize
(Completable source) CompletableTakeUntilCompletable
(Completable source, CompletableSource other) -
Uses of Completable in io.reactivex.rxjava3.internal.operators.flowable
Subclasses of Completable in io.reactivex.rxjava3.internal.operators.flowableModifier and TypeClassDescriptionfinal class
Maps a sequence of values into CompletableSources and awaits their termination.final class
-
Uses of Completable in io.reactivex.rxjava3.internal.operators.maybe
Subclasses of Completable in io.reactivex.rxjava3.internal.operators.maybeModifier and TypeClassDescriptionfinal class
Maps the success value of the source MaybeSource into a Completable.final class
Turns an onSuccess into an onComplete, onError and onComplete is relayed as is. -
Uses of Completable in io.reactivex.rxjava3.internal.operators.mixed
Subclasses of Completable in io.reactivex.rxjava3.internal.operators.mixedModifier and TypeClassDescriptionfinal class
Maps the upstream items intoCompletableSource
s and subscribes to them one after the other completes or terminates (in error-delaying mode).final class
Maps the upstream values intoCompletableSource
s, subscribes to the newer one while disposing the subscription to the previousCompletableSource
, thus keeping at most one activeCompletableSource
running.final class
Switch between subsequentCompletableSource
s emitted by aPublisher
.final class
Maps the upstream items intoCompletableSource
s and subscribes to them one after the other completes or terminates (in error-delaying mode).final class
Maps the upstream values intoCompletableSource
s, subscribes to the newer one while disposing the subscription to the previousCompletableSource
, thus keeping at most one activeCompletableSource
running. -
Uses of Completable in io.reactivex.rxjava3.internal.operators.observable
Subclasses of Completable in io.reactivex.rxjava3.internal.operators.observableModifier and TypeClassDescriptionfinal class
Maps a sequence of values into CompletableSources and awaits their termination.final class
-
Uses of Completable in io.reactivex.rxjava3.internal.operators.single
Subclasses of Completable in io.reactivex.rxjava3.internal.operators.singleModifier and TypeClassDescriptionfinal class
Maps the success value of the source SingleSource into a Completable. -
Uses of Completable in io.reactivex.rxjava3.internal.schedulers
Subclasses of Completable in io.reactivex.rxjava3.internal.schedulersModifier and TypeClassDescription(package private) final class
Fields in io.reactivex.rxjava3.internal.schedulers with type parameters of type CompletableModifier and TypeFieldDescriptionprivate final FlowableProcessor
<Flowable<Completable>> SchedulerWhen.workerProcessor
Methods in io.reactivex.rxjava3.internal.schedulers that return CompletableModifier and TypeMethodDescriptionSchedulerWhen.CreateWorkerFunction.apply
(SchedulerWhen.ScheduledAction action) Constructor parameters in io.reactivex.rxjava3.internal.schedulers with type arguments of type CompletableModifierConstructorDescriptionSchedulerWhen
(Function<Flowable<Flowable<Completable>>, Completable> combine, Scheduler actualScheduler) SchedulerWhen
(Function<Flowable<Flowable<Completable>>, Completable> combine, Scheduler actualScheduler) -
Uses of Completable in io.reactivex.rxjava3.plugins
Fields in io.reactivex.rxjava3.plugins with type parameters of type CompletableModifier and TypeFieldDescription(package private) static @Nullable Function
<? super Completable, ? extends Completable> RxJavaPlugins.onCompletableAssembly
(package private) static @Nullable Function
<? super Completable, ? extends Completable> RxJavaPlugins.onCompletableAssembly
(package private) static @Nullable BiFunction
<? super Completable, @NonNull ? super CompletableObserver, @NonNull ? extends CompletableObserver> RxJavaPlugins.onCompletableSubscribe
Methods in io.reactivex.rxjava3.plugins that return CompletableModifier and TypeMethodDescriptionstatic @NonNull Completable
RxJavaPlugins.onAssembly
(@NonNull Completable source) Calls the associated hook function.Methods in io.reactivex.rxjava3.plugins that return types with arguments of type CompletableModifier and TypeMethodDescriptionstatic @Nullable Function
<? super Completable, ? extends Completable> RxJavaPlugins.getOnCompletableAssembly()
Returns the current hook function.static @Nullable Function
<? super Completable, ? extends Completable> RxJavaPlugins.getOnCompletableAssembly()
Returns the current hook function.static @Nullable BiFunction
<? super Completable, @NonNull ? super CompletableObserver, @NonNull ? extends CompletableObserver> RxJavaPlugins.getOnCompletableSubscribe()
Returns the current hook function.Methods in io.reactivex.rxjava3.plugins with parameters of type CompletableModifier and TypeMethodDescriptionstatic @NonNull Completable
RxJavaPlugins.onAssembly
(@NonNull Completable source) Calls the associated hook function.static @NonNull CompletableObserver
RxJavaPlugins.onSubscribe
(@NonNull Completable source, @NonNull CompletableObserver observer) Calls the associated hook function.Method parameters in io.reactivex.rxjava3.plugins with type arguments of type CompletableModifier and TypeMethodDescriptionstatic void
RxJavaPlugins.setOnCompletableAssembly
(@Nullable Function<? super Completable, ? extends Completable> onCompletableAssembly) Sets the specific hook function.static void
RxJavaPlugins.setOnCompletableAssembly
(@Nullable Function<? super Completable, ? extends Completable> onCompletableAssembly) Sets the specific hook function.static void
RxJavaPlugins.setOnCompletableSubscribe
(@Nullable BiFunction<? super Completable, @NonNull ? super CompletableObserver, @NonNull ? extends CompletableObserver> onCompletableSubscribe) Sets the specific hook function. -
Uses of Completable in io.reactivex.rxjava3.subjects
Subclasses of Completable in io.reactivex.rxjava3.subjectsModifier and TypeClassDescriptionfinal class
Represents a hot Completable-like source and consumer of events similar to Subjects.