Uses of Interface
io.reactivex.rxjava3.core.CompletableSource

Packages that use CompletableSource

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.fuseable	Base interfaces and types for supporting operator-fusion.
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.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 CompletableSource in io.reactivex.rxjava3.core

Classes in io.reactivex.rxjava3.core that implement CompletableSource

Modifier and Type	Class	Description
class	Completable	The Completable class represents a deferred computation without any value but only indication for completion or exception.

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

Modifier and Type	Method	Description
@NonNull CompletableSource	CompletableTransformer.apply(@NonNull Completable upstream)	Applies a function to the upstream Completable and returns a CompletableSource.

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

Modifier and Type	Method	Description
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.
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.
@NonNull Completable	Completable.concatWith(@NonNull CompletableSource other)	Concatenates this Completable with another CompletableSource.
@NonNull Flowable<T>	Flowable.concatWith(@NonNull CompletableSource other)	Returns a Flowable that emits items from this Flowable and when it completes normally, the other CompletableSource is subscribed to and the returned Flowable emits its terminal events.
@NonNull Observable<T>	Observable.concatWith(@NonNull CompletableSource other)	Returns an Observable that emits items from the current Observable and when it completes normally, the other CompletableSource is subscribed to and the returned Observable emits its terminal events.
@NonNull Single<T>	Single.delaySubscription(@NonNull CompletableSource subscriptionIndicator)	Delays the actual subscription to the current Single until the given other CompletableSource completes.
static <@NonNull T> @NonNull Flowable<T>	Flowable.fromCompletable(@NonNull CompletableSource completableSource)	Wraps a CompletableSource into a Flowable.
static <@NonNull T> @NonNull Maybe<T>	Maybe.fromCompletable(@NonNull CompletableSource completableSource)	Wraps a CompletableSource into a Maybe.
static <@NonNull T> @NonNull Observable<T>	Observable.fromCompletable(@NonNull CompletableSource completableSource)	Wraps a CompletableSource into an Observable.
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.
@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.
@NonNull Flowable<T>	Flowable.mergeWith(@NonNull CompletableSource other)	Relays the items of this Flowable and completes only when the other CompletableSource completes as well.
@NonNull Observable<T>	Observable.mergeWith(@NonNull CompletableSource other)	Relays the items of the current Observable and completes only when the other CompletableSource completes as well.
@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.
static @NonNull Single<java.lang.Boolean>	Completable.sequenceEqual(@NonNull CompletableSource source1, @NonNull CompletableSource source2)	Compares two CompletableSources and emits true via a Single if both complete.
@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 Flowable<T>	Flowable.startWith(@NonNull CompletableSource other)	Returns a Flowable which first runs the other CompletableSource then the current Flowable if the other completed normally.
@NonNull Flowable<T>	Maybe.startWith(@NonNull CompletableSource other)	Returns a Flowable which first runs the other CompletableSource then the current Maybe if the other completed normally.
@NonNull Observable<T>	Observable.startWith(@NonNull CompletableSource other)	Returns an Observable which first runs the other CompletableSource then the current Observable if the other completed normally.
@NonNull Flowable<T>	Single.startWith(@NonNull CompletableSource other)	Returns a Flowable which first runs the other CompletableSource then the current Single if the other completed normally.
@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 Single<T>	Single.takeUntil(@NonNull CompletableSource other)	Returns a Single that emits the item emitted by the current Single until a CompletableSource terminates.
@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, @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.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.
static @NonNull Completable	Completable.wrap(@NonNull CompletableSource source)	Wraps the given CompletableSource into a Completable if not already Completable.

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

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.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.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.
static @NonNull Completable	Completable.defer(@NonNull Supplier<? extends @NonNull CompletableSource> supplier)	Defers the subscription to a Completable instance returned by a supplier.
@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.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.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.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	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.
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.

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

Methods in io.reactivex.rxjava3.internal.fuseable that return CompletableSource

Modifier and Type	Method	Description
@NonNull CompletableSource	HasUpstreamCompletableSource.source()	Returns the upstream source of this Completable.

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

Classes in io.reactivex.rxjava3.internal.jdk8 that implement CompletableSource

Modifier and Type	Class	Description
class	CompletableFromCompletionStage<T>	Wrap a CompletionStage and signal its outcome.

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

Classes in io.reactivex.rxjava3.internal.operators.completable that implement CompletableSource

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 CompletableSource

Modifier and Type	Field	Description
(package private) CompletableSource	CompletableAndThenCompletable.next
(package private) CompletableSource	CompletableAndThenCompletable.SourceObserver.next
(package private) CompletableSource	CompletableTakeUntilCompletable.other
(package private) CompletableSource	CompletableTimeout.other
(package private) CompletableSource	CompletableAndThenCompletable.source
(package private) CompletableSource	CompletableCache.source
(package private) CompletableSource	CompletableDelay.source
(package private) CompletableSource	CompletableDetach.source
(package private) CompletableSource	CompletableDisposeOn.source
(package private) CompletableSource	CompletableDoFinally.source
(package private) CompletableSource	CompletableDoOnEvent.source
(package private) CompletableSource	CompletableFromUnsafeSource.source
(package private) CompletableSource	CompletableHide.source
(package private) CompletableSource	CompletableLift.source
(package private) CompletableSource	CompletableObserveOn.source
(package private) CompletableSource	CompletableOnErrorComplete.source
(package private) CompletableSource	CompletableOnErrorReturn.source
(package private) CompletableSource	CompletablePeek.source
(package private) CompletableSource	CompletableResumeNext.source
(package private) CompletableSource	CompletableSubscribeOn.source
(package private) CompletableSource	CompletableSubscribeOn.SubscribeOnObserver.source
(package private) CompletableSource	CompletableTimeout.source
(package private) CompletableSource	CompletableToFlowable.source
(package private) CompletableSource	CompletableToObservable.source
(package private) CompletableSource	CompletableToSingle.source
private CompletableSource[]	CompletableAmb.sources
(package private) CompletableSource[]	CompletableConcatArray.ConcatInnerObserver.sources
(package private) CompletableSource[]	CompletableConcatArray.sources
(package private) CompletableSource[]	CompletableMergeArray.sources
(package private) CompletableSource[]	CompletableMergeArrayDelayError.sources

Fields in io.reactivex.rxjava3.internal.operators.completable with type parameters of type CompletableSource

Modifier and Type	Field	Description
(package private) Function<? super R,? extends CompletableSource>	CompletableUsing.completableFunction
(package private) Supplier<? extends CompletableSource>	CompletableDefer.completableSupplier
(package private) Function<? super java.lang.Throwable,? extends CompletableSource>	CompletableResumeNext.errorMapper
(package private) Function<? super java.lang.Throwable,? extends CompletableSource>	CompletableResumeNext.ResumeNextObserver.errorMapper
(package private) SimpleQueue<CompletableSource>	CompletableConcat.CompletableConcatSubscriber.queue
(package private) org.reactivestreams.Publisher<? extends CompletableSource>	CompletableMerge.source
(package private) org.reactivestreams.Publisher<? extends CompletableSource>	CompletableConcat.sources
(package private) java.util.Iterator<? extends CompletableSource>	CompletableConcatIterable.ConcatInnerObserver.sources
(package private) java.lang.Iterable<? extends CompletableSource>	CompletableConcatIterable.sources
(package private) java.lang.Iterable<? extends CompletableSource>	CompletableMergeDelayErrorIterable.sources
(package private) java.lang.Iterable<? extends CompletableSource>	CompletableMergeIterable.sources
private java.lang.Iterable<? extends CompletableSource>	CompletableAmb.sourcesIterable

Methods in io.reactivex.rxjava3.internal.operators.completable with parameters of type CompletableSource

Modifier and Type	Method	Description
void	CompletableConcat.CompletableConcatSubscriber.onNext(CompletableSource t)
void	CompletableMerge.CompletableMergeSubscriber.onNext(CompletableSource t)

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

Constructor	Description
CompletableAmb(CompletableSource[] sources, java.lang.Iterable<? extends CompletableSource> sourcesIterable)
CompletableAndThenCompletable(CompletableSource source, CompletableSource next)
CompletableCache(CompletableSource source)
CompletableConcatArray(CompletableSource[] sources)
CompletableDelay(CompletableSource source, long delay, java.util.concurrent.TimeUnit unit, Scheduler scheduler, boolean delayError)
CompletableDetach(CompletableSource source)
CompletableDisposeOn(CompletableSource source, Scheduler scheduler)
CompletableDoFinally(CompletableSource source, Action onFinally)
CompletableDoOnEvent(CompletableSource source, Consumer<? super java.lang.Throwable> onEvent)
CompletableFromUnsafeSource(CompletableSource source)
CompletableHide(CompletableSource source)
CompletableLift(CompletableSource source, CompletableOperator onLift)
CompletableMergeArray(CompletableSource[] sources)
CompletableMergeArrayDelayError(CompletableSource[] sources)
CompletableObserveOn(CompletableSource source, Scheduler scheduler)
CompletableOnErrorComplete(CompletableSource source, Predicate<? super java.lang.Throwable> predicate)
CompletableOnErrorReturn(CompletableSource source, Function<? super java.lang.Throwable,? extends T> valueSupplier)
CompletablePeek(CompletableSource source, Consumer<? super Disposable> onSubscribe, Consumer<? super java.lang.Throwable> onError, Action onComplete, Action onTerminate, Action onAfterTerminate, Action onDispose)
CompletableResumeNext(CompletableSource source, Function<? super java.lang.Throwable,? extends CompletableSource> errorMapper)
CompletableSubscribeOn(CompletableSource source, Scheduler scheduler)
CompletableTakeUntilCompletable(Completable source, CompletableSource other)
CompletableTimeout(CompletableSource source, long timeout, java.util.concurrent.TimeUnit unit, Scheduler scheduler, CompletableSource other)
CompletableToFlowable(CompletableSource source)
CompletableToObservable(CompletableSource source)
CompletableToSingle(CompletableSource source, Supplier<? extends T> completionValueSupplier, T completionValue)
ConcatInnerObserver(CompletableObserver actual, CompletableSource[] sources)
SourceObserver(CompletableObserver actualObserver, CompletableSource next)
SubscribeOnObserver(CompletableObserver actual, CompletableSource source)

Constructor parameters in io.reactivex.rxjava3.internal.operators.completable with type arguments of type CompletableSource

Constructor	Description
CompletableAmb(CompletableSource[] sources, java.lang.Iterable<? extends CompletableSource> sourcesIterable)
CompletableConcat(org.reactivestreams.Publisher<? extends CompletableSource> sources, int prefetch)
CompletableConcatIterable(java.lang.Iterable<? extends CompletableSource> sources)
CompletableDefer(Supplier<? extends CompletableSource> completableSupplier)
CompletableMerge(org.reactivestreams.Publisher<? extends CompletableSource> source, int maxConcurrency, boolean delayErrors)
CompletableMergeDelayErrorIterable(java.lang.Iterable<? extends CompletableSource> sources)
CompletableMergeIterable(java.lang.Iterable<? extends CompletableSource> sources)
CompletableResumeNext(CompletableSource source, Function<? super java.lang.Throwable,? extends CompletableSource> errorMapper)
CompletableUsing(Supplier<R> resourceSupplier, Function<? super R,? extends CompletableSource> completableFunction, Consumer<? super R> disposer, boolean eager)
ConcatInnerObserver(CompletableObserver actual, java.util.Iterator<? extends CompletableSource> sources)
ResumeNextObserver(CompletableObserver observer, Function<? super java.lang.Throwable,? extends CompletableSource> errorMapper)

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

Classes in io.reactivex.rxjava3.internal.operators.flowable that implement CompletableSource

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

Fields in io.reactivex.rxjava3.internal.operators.flowable declared as CompletableSource

Modifier and Type	Field	Description
(package private) CompletableSource	FlowableConcatWithCompletable.ConcatWithSubscriber.other
(package private) CompletableSource	FlowableConcatWithCompletable.other
(package private) CompletableSource	FlowableMergeWithCompletable.other
(package private) CompletableSource	FlowableFromCompletable.source

Fields in io.reactivex.rxjava3.internal.operators.flowable with type parameters of type CompletableSource

Modifier and Type	Field	Description
(package private) Function<? super T,? extends CompletableSource>	FlowableFlatMapCompletable.FlatMapCompletableMainSubscriber.mapper
(package private) Function<? super T,? extends CompletableSource>	FlowableFlatMapCompletable.mapper
(package private) Function<? super T,? extends CompletableSource>	FlowableFlatMapCompletableCompletable.FlatMapCompletableMainSubscriber.mapper
(package private) Function<? super T,? extends CompletableSource>	FlowableFlatMapCompletableCompletable.mapper

Methods in io.reactivex.rxjava3.internal.operators.flowable that return CompletableSource

Modifier and Type	Method	Description
CompletableSource	FlowableFromCompletable.source()

Constructors in io.reactivex.rxjava3.internal.operators.flowable with parameters of type CompletableSource

Constructor	Description
ConcatWithSubscriber(org.reactivestreams.Subscriber<? super T> actual, CompletableSource other)
FlowableConcatWithCompletable(Flowable<T> source, CompletableSource other)
FlowableFromCompletable(CompletableSource source)
FlowableMergeWithCompletable(Flowable<T> source, CompletableSource other)

Constructor parameters in io.reactivex.rxjava3.internal.operators.flowable with type arguments of type CompletableSource

Constructor	Description
FlatMapCompletableMainSubscriber(org.reactivestreams.Subscriber<? super T> subscriber, Function<? super T,? extends CompletableSource> mapper, boolean delayErrors, int maxConcurrency)
FlatMapCompletableMainSubscriber(CompletableObserver observer, Function<? super T,? extends CompletableSource> mapper, boolean delayErrors, int maxConcurrency)
FlowableFlatMapCompletable(Flowable<T> source, Function<? super T,? extends CompletableSource> mapper, boolean delayErrors, int maxConcurrency)
FlowableFlatMapCompletableCompletable(Flowable<T> source, Function<? super T,? extends CompletableSource> mapper, boolean delayErrors, int maxConcurrency)

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

Classes in io.reactivex.rxjava3.internal.operators.maybe that implement CompletableSource

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.

Fields in io.reactivex.rxjava3.internal.operators.maybe declared as CompletableSource

Modifier and Type	Field	Description
(package private) CompletableSource	MaybeDelayWithCompletable.other
(package private) CompletableSource	MaybeFromCompletable.source

Fields in io.reactivex.rxjava3.internal.operators.maybe with type parameters of type CompletableSource

Modifier and Type	Field	Description
(package private) Function<? super T,? extends CompletableSource>	MaybeFlatMapCompletable.FlatMapCompletableObserver.mapper
(package private) Function<? super T,? extends CompletableSource>	MaybeFlatMapCompletable.mapper

Methods in io.reactivex.rxjava3.internal.operators.maybe that return CompletableSource

Modifier and Type	Method	Description
CompletableSource	MaybeFromCompletable.source()

Constructors in io.reactivex.rxjava3.internal.operators.maybe with parameters of type CompletableSource

Constructor	Description
MaybeDelayWithCompletable(MaybeSource<T> source, CompletableSource other)
MaybeFromCompletable(CompletableSource source)

Constructor parameters in io.reactivex.rxjava3.internal.operators.maybe with type arguments of type CompletableSource

Constructor	Description
FlatMapCompletableObserver(CompletableObserver actual, Function<? super T,? extends CompletableSource> mapper)
MaybeFlatMapCompletable(MaybeSource<T> source, Function<? super T,? extends CompletableSource> mapper)

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

Classes in io.reactivex.rxjava3.internal.operators.mixed that implement CompletableSource

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.

Fields in io.reactivex.rxjava3.internal.operators.mixed declared as CompletableSource

Modifier and Type	Field	Description
(package private) CompletableSource	CompletableAndThenObservable.source
(package private) CompletableSource	CompletableAndThenPublisher.source

Fields in io.reactivex.rxjava3.internal.operators.mixed with type parameters of type CompletableSource

Modifier and Type	Field	Description
(package private) Function<? super T,? extends CompletableSource>	FlowableConcatMapCompletable.ConcatMapCompletableObserver.mapper
(package private) Function<? super T,? extends CompletableSource>	FlowableConcatMapCompletable.mapper
(package private) Function<? super T,? extends CompletableSource>	FlowableSwitchMapCompletable.mapper
(package private) Function<? super T,? extends CompletableSource>	FlowableSwitchMapCompletable.SwitchMapCompletableObserver.mapper
(package private) Function<? super T,? extends CompletableSource>	FlowableSwitchMapCompletablePublisher.mapper
(package private) Function<? super T,? extends CompletableSource>	ObservableConcatMapCompletable.ConcatMapCompletableObserver.mapper
(package private) Function<? super T,? extends CompletableSource>	ObservableConcatMapCompletable.mapper
(package private) Function<? super T,? extends CompletableSource>	ObservableSwitchMapCompletable.mapper
(package private) Function<? super T,? extends CompletableSource>	ObservableSwitchMapCompletable.SwitchMapCompletableObserver.mapper

Method parameters in io.reactivex.rxjava3.internal.operators.mixed with type arguments of type CompletableSource

Modifier and Type	Method	Description
(package private) static <T> boolean	ScalarXMapZHelper.tryAsCompletable(java.lang.Object source, Function<? super T,? extends CompletableSource> mapper, CompletableObserver observer)	Try subscribing to a CompletableSource mapped from a scalar source (which implements Supplier).

Constructors in io.reactivex.rxjava3.internal.operators.mixed with parameters of type CompletableSource

Constructor	Description
CompletableAndThenObservable(CompletableSource source, ObservableSource<? extends R> other)
CompletableAndThenPublisher(CompletableSource source, org.reactivestreams.Publisher<? extends R> other)

Constructor parameters in io.reactivex.rxjava3.internal.operators.mixed with type arguments of type CompletableSource

Constructor	Description
ConcatMapCompletableObserver(CompletableObserver downstream, Function<? super T,? extends CompletableSource> mapper, ErrorMode errorMode, int prefetch)
ConcatMapCompletableObserver(CompletableObserver downstream, Function<? super T,? extends CompletableSource> mapper, ErrorMode errorMode, int prefetch)
FlowableConcatMapCompletable(Flowable<T> source, Function<? super T,? extends CompletableSource> mapper, ErrorMode errorMode, int prefetch)
FlowableSwitchMapCompletable(Flowable<T> source, Function<? super T,? extends CompletableSource> mapper, boolean delayErrors)
FlowableSwitchMapCompletablePublisher(org.reactivestreams.Publisher<T> source, Function<? super T,? extends CompletableSource> mapper, boolean delayErrors)
ObservableConcatMapCompletable(Observable<T> source, Function<? super T,? extends CompletableSource> mapper, ErrorMode errorMode, int prefetch)
ObservableSwitchMapCompletable(Observable<T> source, Function<? super T,? extends CompletableSource> mapper, boolean delayErrors)
SwitchMapCompletableObserver(CompletableObserver downstream, Function<? super T,? extends CompletableSource> mapper, boolean delayErrors)
SwitchMapCompletableObserver(CompletableObserver downstream, Function<? super T,? extends CompletableSource> mapper, boolean delayErrors)

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

Classes in io.reactivex.rxjava3.internal.operators.observable that implement CompletableSource

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

Fields in io.reactivex.rxjava3.internal.operators.observable declared as CompletableSource

Modifier and Type	Field	Description
(package private) CompletableSource	ObservableConcatWithCompletable.ConcatWithObserver.other
(package private) CompletableSource	ObservableConcatWithCompletable.other
(package private) CompletableSource	ObservableMergeWithCompletable.other
(package private) CompletableSource	ObservableFromCompletable.source

Fields in io.reactivex.rxjava3.internal.operators.observable with type parameters of type CompletableSource

Modifier and Type	Field	Description
(package private) Function<? super T,? extends CompletableSource>	ObservableFlatMapCompletable.FlatMapCompletableMainObserver.mapper
(package private) Function<? super T,? extends CompletableSource>	ObservableFlatMapCompletable.mapper
(package private) Function<? super T,? extends CompletableSource>	ObservableFlatMapCompletableCompletable.FlatMapCompletableMainObserver.mapper
(package private) Function<? super T,? extends CompletableSource>	ObservableFlatMapCompletableCompletable.mapper

Methods in io.reactivex.rxjava3.internal.operators.observable that return CompletableSource

Modifier and Type	Method	Description
CompletableSource	ObservableFromCompletable.source()

Constructors in io.reactivex.rxjava3.internal.operators.observable with parameters of type CompletableSource

Constructor	Description
ConcatWithObserver(Observer<? super T> actual, CompletableSource other)
ObservableConcatWithCompletable(Observable<T> source, CompletableSource other)
ObservableFromCompletable(CompletableSource source)
ObservableMergeWithCompletable(Observable<T> source, CompletableSource other)

Constructor parameters in io.reactivex.rxjava3.internal.operators.observable with type arguments of type CompletableSource

Constructor	Description
FlatMapCompletableMainObserver(Observer<? super T> observer, Function<? super T,? extends CompletableSource> mapper, boolean delayErrors)
FlatMapCompletableMainObserver(CompletableObserver observer, Function<? super T,? extends CompletableSource> mapper, boolean delayErrors)
ObservableFlatMapCompletable(ObservableSource<T> source, Function<? super T,? extends CompletableSource> mapper, boolean delayErrors)
ObservableFlatMapCompletableCompletable(ObservableSource<T> source, Function<? super T,? extends CompletableSource> mapper, boolean delayErrors)

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

Classes in io.reactivex.rxjava3.internal.operators.single that implement CompletableSource

Modifier and Type	Class	Description
class	SingleFlatMapCompletable<T>	Maps the success value of the source SingleSource into a Completable.

Fields in io.reactivex.rxjava3.internal.operators.single declared as CompletableSource

Modifier and Type	Field	Description
(package private) CompletableSource	SingleDelayWithCompletable.other

Fields in io.reactivex.rxjava3.internal.operators.single with type parameters of type CompletableSource

Modifier and Type	Field	Description
(package private) Function<? super T,? extends CompletableSource>	SingleFlatMapCompletable.FlatMapCompletableObserver.mapper
(package private) Function<? super T,? extends CompletableSource>	SingleFlatMapCompletable.mapper

Constructors in io.reactivex.rxjava3.internal.operators.single with parameters of type CompletableSource

Constructor	Description
SingleDelayWithCompletable(SingleSource<T> source, CompletableSource other)

Constructor parameters in io.reactivex.rxjava3.internal.operators.single with type arguments of type CompletableSource

Constructor	Description
FlatMapCompletableObserver(CompletableObserver actual, Function<? super T,? extends CompletableSource> mapper)
SingleFlatMapCompletable(SingleSource<T> source, Function<? super T,? extends CompletableSource> mapper)

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

Classes in io.reactivex.rxjava3.internal.schedulers that implement CompletableSource

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

Uses of CompletableSource in io.reactivex.rxjava3.subjects

Classes in io.reactivex.rxjava3.subjects that implement CompletableSource

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