Uses of Class
io.reactivex.rxjava3.core.Completable

Packages that use Completable

Package	Description
io.reactivex.rxjava3.core	Base reactive classes: Flowable, Observable, Single, Maybe and Completable; base reactive consumers; other common base interfaces.
io.reactivex.rxjava3.internal.jdk8
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.plugins	Contains the central plugin handler RxJavaPlugins class to hook into the lifecycle of the base reactive types and schedulers.
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.

Uses of Completable in io.reactivex.rxjava3.core

Methods in io.reactivex.rxjava3.core that return Completable

Modifier and Type	Method	Description
static @NonNull Completable	Completable.amb(@NonNull java.lang.Iterable<? extends CompletableSource> sources)	Returns a Completable which terminates as soon as one of the source Completables in the Iterable sequence terminates (normally or with an error) and disposes all other Completables.
static @NonNull Completable	Completable.ambArray(@NonNull CompletableSource... sources)	Returns a Completable which terminates as soon as one of the source Completables terminates (normally or with an error) and disposes all other Completables.
@NonNull Completable	Completable.ambWith(@NonNull CompletableSource other)	Returns a Completable that emits the a terminated event of either this Completable or the other CompletableSource, whichever fires first.
@NonNull Completable	Completable.andThen(@NonNull CompletableSource next)	Returns a Completable that first runs this Completable and then the other CompletableSource.
@NonNull Completable	Completable.cache()	Subscribes to this Completable only once, when the first CompletableObserver subscribes to the result Completable, caches its terminal event and relays/replays it to observers.
static @NonNull Completable	Completable.complete()	Returns a Completable instance that completes immediately when subscribed to.
@NonNull Completable	Completable.compose(@NonNull CompletableTransformer transformer)	Calls the given transformer function with this instance and returns the function's resulting CompletableSource wrapped with wrap(CompletableSource).
static @NonNull Completable	Completable.concat(@NonNull java.lang.Iterable<? extends CompletableSource> sources)	Returns a Completable which completes only when all sources complete, one after another.
static @NonNull Completable	Completable.concat(@NonNull org.reactivestreams.Publisher<? extends CompletableSource> sources)	Returns a Completable which completes only when all sources complete, one after another.
static @NonNull Completable	Completable.concat(@NonNull org.reactivestreams.Publisher<? extends CompletableSource> sources, int prefetch)	Returns a Completable which completes only when all sources complete, one after another.
static @NonNull Completable	Completable.concatArray(@NonNull CompletableSource... sources)	Returns a Completable which completes only when all sources complete, one after another.
static @NonNull Completable	Completable.concatArrayDelayError(@NonNull CompletableSource... sources)	Returns a Completable which completes only when all sources complete, one after another.
static @NonNull Completable	Completable.concatDelayError(@NonNull java.lang.Iterable<? extends CompletableSource> sources)	Returns a Completable which completes only when all sources complete, one after another.
static @NonNull Completable	Completable.concatDelayError(@NonNull org.reactivestreams.Publisher<? extends CompletableSource> sources)	Returns a Completable which completes only when all sources complete, one after another.
static @NonNull Completable	Completable.concatDelayError(@NonNull org.reactivestreams.Publisher<? extends CompletableSource> sources, int prefetch)	Returns a Completable which completes only when all sources complete, one after another.
@NonNull Completable	Flowable.concatMapCompletable(@NonNull Function<? super @NonNull T,? extends CompletableSource> mapper)	Maps the upstream items into CompletableSources and subscribes to them one after the other completes.
@NonNull Completable	Flowable.concatMapCompletable(@NonNull Function<? super @NonNull T,? extends CompletableSource> mapper, int prefetch)	Maps the upstream items into CompletableSources and subscribes to them one after the other completes.
@NonNull Completable	Maybe.concatMapCompletable(@NonNull Function<? super @NonNull T,? extends CompletableSource> mapper)	Returns a Completable that completes based on applying a specified function to the item emitted by the current Maybe, where that function returns a Completable.
@NonNull Completable	Observable.concatMapCompletable(@NonNull Function<? super @NonNull T,? extends CompletableSource> mapper)	Maps each element of the current Observable into CompletableSources, subscribes to them one at a time in order and waits until the upstream and all CompletableSources complete.
@NonNull Completable	Observable.concatMapCompletable(@NonNull Function<? super @NonNull T,? extends CompletableSource> mapper, int capacityHint)	Maps each element of the current Observable into CompletableSources, subscribes to them one at a time in order and waits until the upstream and all CompletableSources complete.
@NonNull Completable	Single.concatMapCompletable(@NonNull Function<? super @NonNull T,? extends CompletableSource> mapper)	Returns a Completable that completes based on applying a specified function to the item emitted by the current Single, where that function returns a CompletableSource.
@NonNull Completable	Flowable.concatMapCompletableDelayError(@NonNull Function<? super @NonNull T,? extends CompletableSource> mapper)	Maps the upstream items into CompletableSources and subscribes to them one after the other terminates, delaying all errors till both this Flowable and all inner CompletableSources terminate.
@NonNull Completable	Flowable.concatMapCompletableDelayError(@NonNull Function<? super @NonNull T,? extends CompletableSource> mapper, boolean tillTheEnd)	Maps the upstream items into CompletableSources and subscribes to them one after the other terminates, optionally delaying all errors till both this Flowable and all inner CompletableSources terminate.
@NonNull Completable	Flowable.concatMapCompletableDelayError(@NonNull Function<? super @NonNull T,? extends CompletableSource> mapper, boolean tillTheEnd, int prefetch)	Maps the upstream items into CompletableSources and subscribes to them one after the other terminates, optionally delaying all errors till both this Flowable and all inner CompletableSources terminate.
@NonNull Completable	Observable.concatMapCompletableDelayError(@NonNull Function<? super @NonNull T,? extends CompletableSource> mapper)	Maps the upstream items into CompletableSources and subscribes to them one after the other terminates, delaying all errors till both the current Observable and all inner CompletableSources terminate.
@NonNull Completable	Observable.concatMapCompletableDelayError(@NonNull Function<? super @NonNull T,? extends CompletableSource> mapper, boolean tillTheEnd)	Maps the upstream items into CompletableSources and subscribes to them one after the other terminates, optionally delaying all errors till both the current Observable and all inner CompletableSources terminate.
@NonNull Completable	Observable.concatMapCompletableDelayError(@NonNull Function<? super @NonNull T,? extends CompletableSource> mapper, boolean tillTheEnd, int bufferSize)	Maps the upstream items into CompletableSources and subscribes to them one after the other terminates, optionally delaying all errors till both the current Observable and all inner CompletableSources terminate.
@NonNull Completable	Completable.concatWith(@NonNull CompletableSource other)	Concatenates this Completable with another CompletableSource.
static @NonNull Completable	Completable.create(@NonNull CompletableOnSubscribe source)	Provides an API (via a cold Completable) 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 a Completable instance returned by a supplier.
@NonNull Completable	Completable.delay(long time, @NonNull java.util.concurrent.TimeUnit unit)	Returns a Completable which delays the emission of the completion event by the given time.
@NonNull Completable	Completable.delay(long time, @NonNull java.util.concurrent.TimeUnit unit, @NonNull Scheduler scheduler)	Returns a Completable which delays the emission of the completion event by the given time while running on the specified Scheduler.
@NonNull Completable	Completable.delay(long time, @NonNull java.util.concurrent.TimeUnit unit, @NonNull Scheduler scheduler, boolean delayError)	Returns a Completable which delays the emission of the completion event, and optionally the error as well, by the given time while running on the specified Scheduler.
@NonNull Completable	Completable.delaySubscription(long time, @NonNull java.util.concurrent.TimeUnit unit)	Returns a Completable that delays the subscription to the upstream by a given amount of time.
@NonNull Completable	Completable.delaySubscription(long time, @NonNull java.util.concurrent.TimeUnit unit, @NonNull Scheduler scheduler)	Returns a Completable that delays the subscription to the upstream by a given amount of time, both waiting and subscribing on a given Scheduler.
@NonNull Completable	Completable.doAfterTerminate(@NonNull Action onAfterTerminate)	Returns a Completable instance that calls the given onAfterTerminate Action after this Completable completes normally or with an exception.
@NonNull Completable	Completable.doFinally(@NonNull Action onFinally)	Calls the specified Action after this Completable signals onError or onComplete or gets disposed by the downstream.
@NonNull Completable	Completable.doOnComplete(@NonNull Action onComplete)	Returns a Completable which calls the given onComplete Action if this Completable completes.
@NonNull Completable	Completable.doOnDispose(@NonNull Action onDispose)	Calls the shared Action if a CompletableObserver subscribed to the current Completable disposes the common Disposable it received via onSubscribe.
@NonNull Completable	Completable.doOnError(@NonNull Consumer<? super java.lang.Throwable> onError)	Returns a Completable which calls the given onError Consumer if this Completable emits an error.
@NonNull Completable	Completable.doOnEvent(@NonNull Consumer<? super java.lang.Throwable> onEvent)	Returns a Completable which calls the given onEvent Consumer with the Throwable for an onError or null for an onComplete signal from this Completable before delivering the signal to the downstream.
@NonNull Completable	Completable.doOnLifecycle(@NonNull Consumer<? super Disposable> onSubscribe, @NonNull Action onDispose)	Calls the appropriate onXXX method (shared between all CompletableObservers) for the lifecycle events of the sequence (subscription, disposal).
private @NonNull Completable	Completable.doOnLifecycle(Consumer<? super Disposable> onSubscribe, Consumer<? super java.lang.Throwable> onError, Action onComplete, Action onTerminate, Action onAfterTerminate, Action onDispose)	Returns a Completable instance that calls the various callbacks upon the specific lifecycle events.
@NonNull Completable	Completable.doOnSubscribe(@NonNull Consumer<? super Disposable> onSubscribe)	Returns a Completable instance that calls the given onSubscribe callback with the disposable that the downstream CompletableObservers receive upon subscription.
@NonNull Completable	Completable.doOnTerminate(@NonNull Action onTerminate)	Returns a Completable instance that calls the given onTerminate Action just before this Completable completes normally or with an exception.
static @NonNull Completable	Completable.error(@NonNull Supplier<? extends @NonNull java.lang.Throwable> supplier)	Creates a Completable which calls the given error supplier for each subscriber and emits its returned Throwable.
static @NonNull Completable	Completable.error(@NonNull java.lang.Throwable throwable)	Creates a Completable instance that emits the given Throwable exception to subscribers.
@NonNull Completable	Flowable.flatMapCompletable(@NonNull Function<? super @NonNull T,? extends CompletableSource> mapper)	Maps each element of the upstream Flowable into CompletableSources, subscribes to them and waits until the upstream and all CompletableSources complete.
@NonNull Completable	Flowable.flatMapCompletable(@NonNull Function<? super @NonNull T,? extends CompletableSource> mapper, boolean delayErrors, int maxConcurrency)	Maps each element of the upstream Flowable into CompletableSources, subscribes to them and waits until the upstream and all CompletableSources complete, optionally delaying all errors.
@NonNull Completable	Maybe.flatMapCompletable(@NonNull Function<? super @NonNull T,? extends CompletableSource> mapper)	Returns a Completable that completes based on applying a specified function to the item emitted by the current Maybe, where that function returns a Completable.
@NonNull Completable	Observable.flatMapCompletable(@NonNull Function<? super @NonNull T,? extends CompletableSource> mapper)	Maps each element of the current Observable into CompletableSources, subscribes to them and waits until the upstream and all CompletableSources complete.
@NonNull Completable	Observable.flatMapCompletable(@NonNull Function<? super @NonNull T,? extends CompletableSource> mapper, boolean delayErrors)	Maps each element of the current Observable into CompletableSources, subscribes to them and waits until the upstream and all CompletableSources complete, optionally delaying all errors.
@NonNull Completable	Single.flatMapCompletable(@NonNull Function<? super @NonNull T,? extends CompletableSource> mapper)	Returns a Completable that completes based on applying a specified function to the item emitted by the current Single, where that function returns a CompletableSource.
static @NonNull Completable	Completable.fromAction(@NonNull Action action)	Returns a Completable instance that runs the given Action for each CompletableObserver and emits either an exception or simply completes.
static @NonNull Completable	Completable.fromCallable(@NonNull java.util.concurrent.Callable<?> callable)	Returns a Completable which when subscribed, executes the Callable function, ignores its normal result and emits onError or onComplete only.
static @NonNull Completable	Completable.fromCompletionStage(@NonNull java.util.concurrent.CompletionStage<?> stage)	Signals completion (or error) when the CompletionStage terminates.
static @NonNull Completable	Completable.fromFuture(@NonNull java.util.concurrent.Future<?> future)	Returns a Completable instance that reacts to the termination of the given Future in a blocking fashion.
static <@NonNull T> @NonNull Completable	Completable.fromMaybe(@NonNull MaybeSource<@NonNull T> maybe)	Returns a Completable instance that when subscribed to, subscribes to the MaybeSource instance and emits an onComplete event if the maybe emits onSuccess/onComplete or forwards any onError events.
static <@NonNull T> @NonNull Completable	Completable.fromObservable(@NonNull ObservableSource<@NonNull T> observable)	Returns a Completable instance that subscribes to the given ObservableSource, ignores all values and emits only the terminal event.
static <@NonNull T> @NonNull Completable	Completable.fromPublisher(@NonNull org.reactivestreams.Publisher<@NonNull T> publisher)	Returns a Completable instance that subscribes to the given Publisher, ignores all values and emits only the terminal event.
static @NonNull Completable	Completable.fromRunnable(@NonNull java.lang.Runnable run)	Returns a Completable instance that runs the given Runnable for each CompletableObserver and emits either its unchecked exception or simply completes.
static <@NonNull T> @NonNull Completable	Completable.fromSingle(@NonNull SingleSource<@NonNull T> single)	Returns a Completable instance that when subscribed to, subscribes to the SingleSource instance and emits a completion event if the single emits onSuccess or forwards any onError events.
static @NonNull Completable	Completable.fromSupplier(@NonNull Supplier<?> supplier)	Returns a Completable which when subscribed, executes the Supplier function, ignores its normal result and emits onError or onComplete only.
@NonNull Completable	Completable.hide()	Hides the identity of this Completable and its Disposable.
@NonNull Completable	Maybe.ignoreElement()	Returns a Completable that ignores the item emitted by the current Maybe and only calls onComplete or onError.
@NonNull Completable	Single.ignoreElement()	Returns a Completable that ignores the success value of this Single and signals onComplete instead.
@NonNull Completable	Flowable.ignoreElements()	Ignores all items emitted by the current Flowable and only calls onComplete or onError.
@NonNull Completable	Observable.ignoreElements()	Ignores all items emitted by the current Observable and only calls onComplete or onError.
@NonNull Completable	Completable.lift(@NonNull CompletableOperator onLift)	This method requires advanced knowledge about building operators, please consider other standard composition methods first; Returns a Completable which, when subscribed to, invokes the apply(CompletableObserver) method of the provided CompletableOperator for each individual downstream Completable and allows the insertion of a custom operator by accessing the downstream's CompletableObserver during this subscription phase and providing a new CompletableObserver, 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 java.lang.Iterable<? extends CompletableSource> sources)	Returns a Completable instance that subscribes to all sources at once and completes only when all source CompletableSources complete or one of them emits an error.
static @NonNull Completable	Completable.merge(@NonNull org.reactivestreams.Publisher<? extends CompletableSource> sources)	Returns a Completable instance that subscribes to all sources at once and completes only when all source CompletableSources complete or one of them emits an error.
static @NonNull Completable	Completable.merge(@NonNull org.reactivestreams.Publisher<? extends CompletableSource> sources, int maxConcurrency)	Returns a Completable instance that keeps subscriptions to a limited number of sources at once and completes only when all source CompletableSources complete or one of them emits an error.
private static @NonNull Completable	Completable.merge0(@NonNull org.reactivestreams.Publisher<? extends CompletableSource> sources, int maxConcurrency, boolean delayErrors)	Returns a Completable instance that keeps subscriptions to a limited number of CompletableSources at once and completes only when all source CompletableSources terminate in one way or another, combining any exceptions signaled by either the source Publisher or the inner CompletableSource instances.
static @NonNull Completable	Completable.mergeArray(@NonNull CompletableSource... sources)	Returns a Completable instance that subscribes to all sources at once and completes only when all source CompletableSources complete or one of them emits an error.
static @NonNull Completable	Completable.mergeArrayDelayError(@NonNull CompletableSource... sources)	Returns a Completable that subscribes to all CompletableSources in the source array and delays any error emitted by any of the inner CompletableSources until all of them terminate in a way or another.
static @NonNull Completable	Completable.mergeDelayError(@NonNull java.lang.Iterable<? extends CompletableSource> sources)	Returns a Completable that subscribes to all CompletableSources in the source sequence and delays any error emitted by any of the inner CompletableSources until all of them terminate in a way or another.
static @NonNull Completable	Completable.mergeDelayError(@NonNull org.reactivestreams.Publisher<? extends CompletableSource> sources)	Returns a Completable that subscribes to all CompletableSources in the source sequence and delays any error emitted by either the sources Publisher or any of the inner CompletableSources until all of them terminate in a way or another.
static @NonNull Completable	Completable.mergeDelayError(@NonNull org.reactivestreams.Publisher<? extends CompletableSource> sources, int maxConcurrency)	Returns a Completable that subscribes to a limited number of inner CompletableSources at once in the source sequence and delays any error emitted by either the sources Publisher or any of the inner CompletableSources until all of them terminate in a way or another.
@NonNull Completable	Completable.mergeWith(@NonNull CompletableSource other)	Returns a Completable which subscribes to this and the other CompletableSource and completes when both of them complete or one emits an error.
static @NonNull Completable	Completable.never()	Returns a Completable that never calls onError or onComplete.
@NonNull Completable	Completable.observeOn(@NonNull Scheduler scheduler)	Returns a Completable which emits the terminal events from the thread of the specified Scheduler.
@NonNull Completable	Completable.onErrorComplete()	Returns a Completable instance that if this Completable emits an error, it will emit an onComplete and swallow the upstream Throwable.
@NonNull Completable	Completable.onErrorComplete(@NonNull Predicate<? super java.lang.Throwable> predicate)	Returns a Completable instance that if this Completable emits an error and the Predicate returns true, it will emit an onComplete and swallow the Throwable.
@NonNull Completable	Completable.onErrorResumeNext(@NonNull Function<? super java.lang.Throwable,? extends CompletableSource> fallbackSupplier)	Returns a Completable instance that when encounters an error from this Completable, calls the specified mapper Function that returns a CompletableSource instance for it and resumes the execution with it.
@NonNull Completable	Completable.onErrorResumeWith(@NonNull CompletableSource fallback)	Resumes the flow with the given CompletableSource when the current Completable fails instead of signaling the error via onError.
@NonNull Completable	Completable.onTerminateDetach()	Nulls out references to the upstream producer and downstream CompletableObserver if the sequence is terminated or downstream calls dispose().
@NonNull Completable	Completable.repeat()	Returns a Completable that repeatedly subscribes to this Completable until disposed.
@NonNull Completable	Completable.repeat(long times)	Returns a Completable that subscribes repeatedly at most the given number of times to this Completable.
@NonNull Completable	Completable.repeatUntil(@NonNull BooleanSupplier stop)	Returns a Completable that repeatedly subscribes to this Completable so long as the given stop BooleanSupplier returns false.
@NonNull Completable	Completable.repeatWhen(@NonNull Function<? super Flowable<java.lang.Object>,? extends org.reactivestreams.Publisher<?>> handler)	Returns a Completable instance that repeats when the Publisher returned by the handler Function emits an item or completes when this Publisher emits an onComplete event.
@NonNull Completable	Completable.retry()	Returns a Completable that retries this Completable as long as it emits an onError event.
@NonNull Completable	Completable.retry(long times)	Returns a Completable that when this Completable emits an error, retries at most the given number of times before giving up and emitting the last error.
@NonNull Completable	Completable.retry(long times, @NonNull Predicate<? super java.lang.Throwable> predicate)	Returns a Completable that when this Completable emits an error, retries at most times or until the predicate returns false, whichever happens first and emitting the last error.
@NonNull Completable	Completable.retry(@NonNull BiPredicate<? super java.lang.Integer,? super java.lang.Throwable> predicate)	Returns a Completable that retries this Completable in case of an error as long as the predicate returns true.
@NonNull Completable	Completable.retry(@NonNull Predicate<? super java.lang.Throwable> predicate)	Returns a Completable that when this Completable emits an error, calls the given predicate with the latest Throwable to decide whether to resubscribe to the upstream or not.
@NonNull Completable	Completable.retryUntil(@NonNull BooleanSupplier stop)	Retries until the given stop function returns true.
@NonNull Completable	Completable.retryWhen(@NonNull Function<? super Flowable<java.lang.Throwable>,? extends org.reactivestreams.Publisher<?>> handler)	Returns a Completable which given a Publisher and when this Completable emits an error, delivers that error through a Flowable and the Publisher should signal a value indicating a retry in response or a terminal event indicating a termination.
@NonNull Completable	Completable.startWith(@NonNull CompletableSource other)	Returns a Completable which first runs the other CompletableSource then the current Completable if the other completed normally.
@NonNull Completable	Completable.subscribeOn(@NonNull Scheduler scheduler)	Returns a Completable which subscribes the downstream subscriber on the specified scheduler, making sure the subscription side-effects happen on that specific thread of the Scheduler.
@NonNull Completable	Flowable.switchMapCompletable(@NonNull Function<? super @NonNull T,? extends CompletableSource> mapper)	Maps the upstream values into CompletableSources, subscribes to the newer one while disposing the subscription to the previous CompletableSource, thus keeping at most one active CompletableSource running.
@NonNull Completable	Observable.switchMapCompletable(@NonNull Function<? super @NonNull T,? extends CompletableSource> mapper)	Maps the items of the current Observable into CompletableSources, subscribes to the newer one while disposing the subscription to the previous CompletableSource, thus keeping at most one active CompletableSource running.
@NonNull Completable	Flowable.switchMapCompletableDelayError(@NonNull Function<? super @NonNull T,? extends CompletableSource> mapper)	Maps the upstream values into CompletableSources, subscribes to the newer one while disposing the subscription to the previous CompletableSource, thus keeping at most one active CompletableSource running and delaying any main or inner errors until all of them terminate.
@NonNull Completable	Observable.switchMapCompletableDelayError(@NonNull Function<? super @NonNull T,? extends CompletableSource> mapper)	Maps the upstream values into CompletableSources, subscribes to the newer one while disposing the subscription to the previous CompletableSource, thus keeping at most one active CompletableSource running and delaying any main or inner errors until all of them terminate.
static @NonNull Completable	Completable.switchOnNext(@NonNull org.reactivestreams.Publisher<? extends CompletableSource> sources)	Switches between CompletableSources emitted by the source Publisher whenever a new CompletableSource is emitted, disposing the previously running CompletableSource, exposing the setup as a Completable sequence.
static @NonNull Completable	Completable.switchOnNextDelayError(@NonNull org.reactivestreams.Publisher<? extends CompletableSource> sources)	Switches between CompletableSources emitted by the source Publisher whenever a new CompletableSource is emitted, disposing the previously running CompletableSource, exposing the setup as a Completable sequence and delaying all errors from all of them until all terminate.
@NonNull Completable	Completable.takeUntil(@NonNull CompletableSource other)	Terminates the downstream if this or the other Completable terminates (wins the termination race) while disposing the connection to the losing source.
@NonNull Completable	Completable.timeout(long timeout, @NonNull java.util.concurrent.TimeUnit unit)	Returns a Completable that runs this Completable and emits a TimeoutException in case this Completable doesn't complete within the given time.
@NonNull Completable	Completable.timeout(long timeout, @NonNull java.util.concurrent.TimeUnit unit, @NonNull CompletableSource fallback)	Returns a Completable that runs this Completable and switches to the other CompletableSource in case this Completable doesn't complete within the given time.
@NonNull Completable	Completable.timeout(long timeout, @NonNull java.util.concurrent.TimeUnit unit, @NonNull Scheduler scheduler)	Returns a Completable that runs this Completable and emits a TimeoutException in case this Completable doesn't complete within the given time while "waiting" on the specified Scheduler.
@NonNull Completable	Completable.timeout(long timeout, @NonNull java.util.concurrent.TimeUnit unit, @NonNull Scheduler scheduler, @NonNull CompletableSource fallback)	Returns a Completable that runs this Completable and switches to the other CompletableSource in case this Completable doesn't complete within the given time while "waiting" on the specified Scheduler.
private @NonNull Completable	Completable.timeout0(long timeout, java.util.concurrent.TimeUnit unit, Scheduler scheduler, CompletableSource fallback)	Returns a Completable that runs this Completable and optionally switches to the other CompletableSource in case this Completable doesn't complete within the given time while "waiting" on the specified Scheduler.
static @NonNull Completable	Completable.timer(long delay, @NonNull java.util.concurrent.TimeUnit unit)	Returns a Completable instance that fires its onComplete event after the given delay elapsed.
static @NonNull Completable	Completable.timer(long delay, @NonNull java.util.concurrent.TimeUnit unit, @NonNull Scheduler scheduler)	Returns a Completable instance that fires its onComplete event after the given delay elapsed by using the supplied Scheduler.
static @NonNull Completable	Completable.unsafeCreate(@NonNull CompletableSource onSubscribe)	Constructs a Completable instance by wrapping the given source callback without any safeguards; you should manage the lifecycle and response to downstream disposal.
@NonNull Completable	Completable.unsubscribeOn(@NonNull Scheduler scheduler)	Returns a Completable which makes sure when an observer disposes the subscription, the dispose() method is called on the specified Scheduler.
static <@NonNull R> @NonNull Completable	Completable.using(@NonNull Supplier<@NonNull R> resourceSupplier, @NonNull Function<? super @NonNull R,? extends CompletableSource> sourceSupplier, @NonNull Consumer<? super @NonNull R> resourceCleanup)	Returns a Completable instance which manages a resource along with a custom CompletableSource instance while the subscription is active.
static <@NonNull R> @NonNull Completable	Completable.using(@NonNull Supplier<@NonNull R> resourceSupplier, @NonNull Function<? super @NonNull R,? extends CompletableSource> sourceSupplier, @NonNull Consumer<? super @NonNull R> resourceCleanup, boolean eager)	Returns a Completable instance which manages a resource along with a custom CompletableSource instance while the subscription is active and performs eager or lazy resource disposition.
static @NonNull Completable	Completable.wrap(@NonNull CompletableSource source)	Wraps the given CompletableSource into a Completable if not already Completable.

Methods in io.reactivex.rxjava3.core with parameters of type Completable

Modifier and Type	Method	Description
R	CompletableConverter.apply(@NonNull Completable upstream)	Applies a function to the upstream Completable and returns a converted value of type R.
@NonNull CompletableSource	CompletableTransformer.apply(@NonNull Completable upstream)	Applies a function to the upstream Completable and returns a CompletableSource.

Method parameters in io.reactivex.rxjava3.core with type arguments of type Completable

Modifier and Type	Method	Description
<S extends Scheduler & Disposable> S	Scheduler.when(@NonNull Function<Flowable<Flowable<Completable>>,Completable> combine)	Allows the use of operators for controlling the timing around when actions scheduled on workers are actually done.
<S extends Scheduler & Disposable> S	Scheduler.when(@NonNull Function<Flowable<Flowable<Completable>>,Completable> combine)	Allows the use of operators for controlling the timing around when actions scheduled on workers are actually done.

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

Subclasses of Completable in io.reactivex.rxjava3.internal.jdk8

Modifier and Type	Class	Description
class	CompletableFromCompletionStage<T>	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.completable

Modifier and Type	Class	Description
class	CompletableAmb
class	CompletableAndThenCompletable
class	CompletableCache	Consume the upstream source exactly once and cache its terminal event.
class	CompletableConcat
class	CompletableConcatArray
class	CompletableConcatIterable
class	CompletableCreate
class	CompletableDefer
class	CompletableDelay
class	CompletableDetach	Breaks the references between the upstream and downstream when the Completable terminates.
class	CompletableDisposeOn
class	CompletableDoFinally	Execute an action after an onError, onComplete or a dispose event.
class	CompletableDoOnEvent
class	CompletableEmpty
class	CompletableError
class	CompletableErrorSupplier
class	CompletableFromAction
class	CompletableFromCallable
class	CompletableFromObservable<T>
class	CompletableFromPublisher<T>
class	CompletableFromRunnable
class	CompletableFromSingle<T>
class	CompletableFromSupplier	Call a Supplier for each incoming CompletableObserver and signal completion or the thrown exception.
class	CompletableFromUnsafeSource
class	CompletableHide	Hides the identity of the upstream Completable and its Disposable sent through onSubscribe.
class	CompletableLift
class	CompletableMerge
class	CompletableMergeArray
class	CompletableMergeArrayDelayError
class	CompletableMergeDelayErrorIterable
class	CompletableMergeIterable
class	CompletableNever
class	CompletableObserveOn
class	CompletableOnErrorComplete
class	CompletablePeek
class	CompletableResumeNext
class	CompletableSubscribeOn
class	CompletableTakeUntilCompletable	Terminates the sequence if either the main or the other Completable terminate.
class	CompletableTimeout
class	CompletableTimer	Signals an onComplete event after the specified delay.
class	CompletableUsing<R>

Fields in io.reactivex.rxjava3.internal.operators.completable declared as Completable

Modifier and Type	Field	Description
static Completable	CompletableEmpty.INSTANCE
static Completable	CompletableNever.INSTANCE
(package private) Completable	CompletableMaterialize.source
(package private) Completable	CompletableTakeUntilCompletable.source

Constructors in io.reactivex.rxjava3.internal.operators.completable with parameters of type Completable

Constructor	Description
CompletableMaterialize(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.flowable

Modifier and Type	Class	Description
class	FlowableFlatMapCompletableCompletable<T>	Maps a sequence of values into CompletableSources and awaits their termination.
class	FlowableIgnoreElementsCompletable<T>

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

Subclasses of Completable in io.reactivex.rxjava3.internal.operators.maybe

Modifier and Type	Class	Description
class	MaybeFlatMapCompletable<T>	Maps the success value of the source MaybeSource into a Completable.
class	MaybeIgnoreElementCompletable<T>	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.mixed

Modifier and Type	Class	Description
class	FlowableConcatMapCompletable<T>	Maps the upstream items into CompletableSources and subscribes to them one after the other completes or terminates (in error-delaying mode).
class	FlowableSwitchMapCompletable<T>	Maps the upstream values into CompletableSources, subscribes to the newer one while disposing the subscription to the previous CompletableSource, thus keeping at most one active CompletableSource running.
class	FlowableSwitchMapCompletablePublisher<T>	Switch between subsequent CompletableSources emitted by a Publisher.
class	ObservableConcatMapCompletable<T>	Maps the upstream items into CompletableSources and subscribes to them one after the other completes or terminates (in error-delaying mode).
class	ObservableSwitchMapCompletable<T>	Maps the upstream values into CompletableSources, subscribes to the newer one while disposing the subscription to the previous CompletableSource, thus keeping at most one active CompletableSource running.

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

Subclasses of Completable in io.reactivex.rxjava3.internal.operators.observable

Modifier and Type	Class	Description
class	ObservableFlatMapCompletableCompletable<T>	Maps a sequence of values into CompletableSources and awaits their termination.
class	ObservableIgnoreElementsCompletable<T>

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

Subclasses of Completable in io.reactivex.rxjava3.internal.operators.single

Modifier and Type	Class	Description
class	SingleFlatMapCompletable<T>	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.schedulers

Modifier and Type	Class	Description
(package private) class	SchedulerWhen.CreateWorkerFunction.WorkerCompletable

Fields in io.reactivex.rxjava3.internal.schedulers with type parameters of type Completable

Modifier and Type	Field	Description
private FlowableProcessor<Flowable<Completable>>	SchedulerWhen.workerProcessor

Methods in io.reactivex.rxjava3.internal.schedulers that return Completable

Modifier and Type	Method	Description
Completable	SchedulerWhen.CreateWorkerFunction.apply(SchedulerWhen.ScheduledAction action)

Constructor parameters in io.reactivex.rxjava3.internal.schedulers with type arguments of type Completable

Constructor	Description
SchedulerWhen(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 Completable

Modifier and Type	Field	Description
(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,? super CompletableObserver,? extends CompletableObserver>	RxJavaPlugins.onCompletableSubscribe

Methods in io.reactivex.rxjava3.plugins that return Completable

Modifier and Type	Method	Description
static @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 Completable

Modifier and Type	Method	Description
static @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,? super CompletableObserver,? extends CompletableObserver>	RxJavaPlugins.getOnCompletableSubscribe()	Returns the current hook function.

Methods in io.reactivex.rxjava3.plugins with parameters of type Completable

Modifier and Type	Method	Description
static @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 Completable

Modifier and Type	Method	Description
static 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,? super CompletableObserver,? extends CompletableObserver> onCompletableSubscribe)	Sets the specific hook function.

Uses of Completable in io.reactivex.rxjava3.subjects

Subclasses of Completable in io.reactivex.rxjava3.subjects

Modifier and Type	Class	Description
class	CompletableSubject	Represents a hot Completable-like source and consumer of events similar to Subjects.