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.
final @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.
final @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.
final @NonNull Completable	Completable.concatWith(@NonNull CompletableSource other)	Concatenates this Completable with another CompletableSource.
final @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.
final @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.
final @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.
final @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.
final @NonNull Flowable<T>	Flowable.mergeWith(@NonNull CompletableSource other)	Relays the items of this Flowable and completes only when the other CompletableSource completes as well.
final @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.
final @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<Boolean>	Completable.sequenceEqual(@NonNull CompletableSource source1, @NonNull CompletableSource source2)	Compares two CompletableSources and emits true via a Single if both complete.
final @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.
final @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.
final @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.
final @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.
final @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.
final @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.
final @NonNull Single<T>	Single.takeUntil(@NonNull CompletableSource other)	Returns a Single that emits the item emitted by the current Single until a CompletableSource terminates.
final @NonNull Completable	Completable.timeout(long timeout, @NonNull 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.
final @NonNull Completable	Completable.timeout(long timeout, @NonNull 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, 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 Iterable<@NonNull ? 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 Iterable<@NonNull ? 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<@NonNull ? 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<@NonNull ? extends CompletableSource> sources, int prefetch)	Returns a Completable which completes only when all sources complete, one after another.
static @NonNull Completable	Completable.concatDelayError(@NonNull Iterable<@NonNull ? 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<@NonNull ? 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<@NonNull ? extends CompletableSource> sources, int prefetch)	Returns a Completable 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 into CompletableSources 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 into CompletableSources and subscribes to them one after the other completes.
final @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.
final @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.
final @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.
final @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.
final @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.
final @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.
final @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.
final @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.
final @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.
final @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.
final @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.
final @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.
final @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.
final @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.
final @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.
final @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 Iterable<@NonNull ? 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<@NonNull ? 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<@NonNull ? 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<@NonNull ? 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 Iterable<@NonNull ? 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<@NonNull ? 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<@NonNull ? 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.
final @NonNull Completable	Completable.onErrorResumeNext(@NonNull Function<? super 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.
final @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.
final @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.
final @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.
final @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<@NonNull ? 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<@NonNull ? 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
final 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
final class	CompletableAmb
final class	CompletableAndThenCompletable
final class	CompletableCache	Consume the upstream source exactly once and cache its terminal event.
final class	CompletableConcat
final class	CompletableConcatArray
final class	CompletableConcatIterable
final class	CompletableCreate
final class	CompletableDefer
final class	CompletableDelay
final class	CompletableDetach	Breaks the references between the upstream and downstream when the Completable terminates.
final class	CompletableDisposeOn
final class	CompletableDoFinally	Execute an action after an onError, onComplete or a dispose event.
final class	CompletableDoOnEvent
final class	CompletableEmpty
final class	CompletableError
final class	CompletableErrorSupplier
final class	CompletableFromAction
final class	CompletableFromCallable
final class	CompletableFromObservable<T>
final class	CompletableFromPublisher<T>
final class	CompletableFromRunnable
final class	CompletableFromSingle<T>
final class	CompletableFromSupplier	Call a Supplier for each incoming CompletableObserver and signal completion or the thrown exception.
final class	CompletableFromUnsafeSource
final class	CompletableHide	Hides the identity of the upstream Completable and its Disposable sent through onSubscribe.
final class	CompletableLift
final class	CompletableMerge
final class	CompletableMergeArray
final class	CompletableMergeArrayDelayError
final class	CompletableMergeDelayErrorIterable
final class	CompletableMergeIterable
final class	CompletableNever
final class	CompletableObserveOn
final class	CompletableOnErrorComplete
final class	CompletablePeek
final class	CompletableResumeNext
final class	CompletableSubscribeOn
final class	CompletableTakeUntilCompletable	Terminates the sequence if either the main or the other Completable terminate.
final class	CompletableTimeout
final class	CompletableTimer	Signals an onComplete event after the specified delay.
final class	CompletableUsing<R>

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

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

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

Modifier and Type	Field	Description
(package private) final Function<? super R,? extends CompletableSource>	CompletableUsing.completableFunction
(package private) final Supplier<? extends CompletableSource>	CompletableDefer.completableSupplier
(package private) final Function<? super Throwable,? extends CompletableSource>	CompletableResumeNext.errorMapper
(package private) final Function<? super Throwable,? extends CompletableSource>	CompletableResumeNext.ResumeNextObserver.errorMapper
(package private) SimpleQueue<CompletableSource>	CompletableConcat.CompletableConcatSubscriber.queue
(package private) final org.reactivestreams.Publisher<? extends CompletableSource>	CompletableMerge.source
(package private) final org.reactivestreams.Publisher<? extends CompletableSource>	CompletableConcat.sources
(package private) final Iterator<? extends CompletableSource>	CompletableConcatIterable.ConcatInnerObserver.sources
(package private) final Iterable<? extends CompletableSource>	CompletableConcatIterable.sources
(package private) final Iterable<? extends CompletableSource>	CompletableMergeDelayErrorIterable.sources
(package private) final Iterable<? extends CompletableSource>	CompletableMergeIterable.sources
private final 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

Modifier	Constructor	Description
	CompletableAmb(CompletableSource[] sources, Iterable<? extends CompletableSource> sourcesIterable)
	CompletableAndThenCompletable(CompletableSource source, CompletableSource next)
	CompletableCache(CompletableSource source)
	CompletableConcatArray(CompletableSource[] sources)
	CompletableDelay(CompletableSource source, long delay, TimeUnit unit, Scheduler scheduler, boolean delayError)
	CompletableDetach(CompletableSource source)
	CompletableDisposeOn(CompletableSource source, Scheduler scheduler)
	CompletableDoFinally(CompletableSource source, Action onFinally)
	CompletableDoOnEvent(CompletableSource source, Consumer<? super 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 Throwable> predicate)
	CompletableOnErrorReturn(CompletableSource source, Function<? super Throwable,? extends T> valueSupplier)
	CompletablePeek(CompletableSource source, Consumer<? super Disposable> onSubscribe, Consumer<? super Throwable> onError, Action onComplete, Action onTerminate, Action onAfterTerminate, Action onDispose)
	CompletableResumeNext(CompletableSource source, Function<? super Throwable,? extends CompletableSource> errorMapper)
	CompletableSubscribeOn(CompletableSource source, Scheduler scheduler)
	CompletableTakeUntilCompletable(Completable source, CompletableSource other)
	CompletableTimeout(CompletableSource source, long timeout, TimeUnit unit, Scheduler scheduler, CompletableSource other)
	CompletableToFlowable(CompletableSource source)
	CompletableToObservable(CompletableSource source)
	CompletableToSingle(CompletableSource source, Supplier<? extends T> completionValueSupplier, T completionValue)
(package private)	ConcatInnerObserver(CompletableObserver actual, CompletableSource[] sources)
(package private)	SourceObserver(CompletableObserver actualObserver, CompletableSource next)
(package private)	SubscribeOnObserver(CompletableObserver actual, CompletableSource source)

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

Modifier	Constructor	Description
	CompletableAmb(CompletableSource[] sources, Iterable<? extends CompletableSource> sourcesIterable)
	CompletableConcat(org.reactivestreams.Publisher<? extends CompletableSource> sources, int prefetch)
	CompletableConcatIterable(Iterable<? extends CompletableSource> sources)
	CompletableDefer(Supplier<? extends CompletableSource> completableSupplier)
	CompletableMerge(org.reactivestreams.Publisher<? extends CompletableSource> source, int maxConcurrency, boolean delayErrors)
	CompletableMergeDelayErrorIterable(Iterable<? extends CompletableSource> sources)
	CompletableMergeIterable(Iterable<? extends CompletableSource> sources)
	CompletableResumeNext(CompletableSource source, Function<? super Throwable,? extends CompletableSource> errorMapper)
	CompletableUsing(Supplier<R> resourceSupplier, Function<? super R,? extends CompletableSource> completableFunction, Consumer<? super R> disposer, boolean eager)
(package private)	ConcatInnerObserver(CompletableObserver actual, Iterator<? extends CompletableSource> sources)
(package private)	ResumeNextObserver(CompletableObserver observer, Function<? super 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
final class	FlowableFlatMapCompletableCompletable<T>	Maps a sequence of values into CompletableSources and awaits their termination.
final 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) final CompletableSource	FlowableConcatWithCompletable.other
(package private) final CompletableSource	FlowableMergeWithCompletable.other
(package private) final CompletableSource	FlowableFromCompletable.source

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

Modifier and Type	Field	Description
(package private) final Function<? super T,? extends CompletableSource>	FlowableFlatMapCompletable.FlatMapCompletableMainSubscriber.mapper
(package private) final Function<? super T,? extends CompletableSource>	FlowableFlatMapCompletable.mapper
(package private) final Function<? super T,? extends CompletableSource>	FlowableFlatMapCompletableCompletable.FlatMapCompletableMainSubscriber.mapper
(package private) final 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

Modifier	Constructor	Description
(package private)	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

Modifier	Constructor	Description
(package private)	FlatMapCompletableMainSubscriber(org.reactivestreams.Subscriber<? super T> subscriber, Function<? super T,? extends CompletableSource> mapper, boolean delayErrors, int maxConcurrency)
(package private)	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
final class	MaybeFlatMapCompletable<T>	Maps the success value of the source MaybeSource into a Completable.
final 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) final CompletableSource	MaybeDelayWithCompletable.other
(package private) final CompletableSource	MaybeFromCompletable.source

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

Modifier and Type	Field	Description
(package private) final Function<? super T,? extends CompletableSource>	MaybeFlatMapCompletable.FlatMapCompletableObserver.mapper
(package private) final 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

Modifier	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

Modifier	Constructor	Description
(package private)	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
final class	FlowableConcatMapCompletable<T>	Maps the upstream items into CompletableSources and subscribes to them one after the other completes or terminates (in error-delaying mode).
final 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.
final class	FlowableSwitchMapCompletablePublisher<T>	Switch between subsequent CompletableSources emitted by a Publisher.
final class	ObservableConcatMapCompletable<T>	Maps the upstream items into CompletableSources and subscribes to them one after the other completes or terminates (in error-delaying mode).
final 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) final CompletableSource	CompletableAndThenObservable.source
(package private) final CompletableSource	CompletableAndThenPublisher.source

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

Modifier and Type	Field	Description
(package private) final Function<? super T,? extends CompletableSource>	FlowableConcatMapCompletable.ConcatMapCompletableObserver.mapper
(package private) final Function<? super T,? extends CompletableSource>	FlowableConcatMapCompletable.mapper
(package private) final Function<? super T,? extends CompletableSource>	FlowableSwitchMapCompletable.mapper
(package private) final Function<? super T,? extends CompletableSource>	FlowableSwitchMapCompletable.SwitchMapCompletableObserver.mapper
(package private) final Function<? super T,? extends CompletableSource>	FlowableSwitchMapCompletablePublisher.mapper
(package private) final Function<? super T,? extends CompletableSource>	ObservableConcatMapCompletable.ConcatMapCompletableObserver.mapper
(package private) final Function<? super T,? extends CompletableSource>	ObservableConcatMapCompletable.mapper
(package private) final Function<? super T,? extends CompletableSource>	ObservableSwitchMapCompletable.mapper
(package private) final 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(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

Modifier	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

Modifier	Constructor	Description
(package private)	ConcatMapCompletableObserver(CompletableObserver downstream, Function<? super T,? extends CompletableSource> mapper, ErrorMode errorMode, int prefetch)
(package private)	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)
(package private)	SwitchMapCompletableObserver(CompletableObserver downstream, Function<? super T,? extends CompletableSource> mapper, boolean delayErrors)
(package private)	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
final class	ObservableFlatMapCompletableCompletable<T>	Maps a sequence of values into CompletableSources and awaits their termination.
final 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) final CompletableSource	ObservableConcatWithCompletable.other
(package private) final CompletableSource	ObservableMergeWithCompletable.other
(package private) final CompletableSource	ObservableFromCompletable.source

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

Modifier and Type	Field	Description
(package private) final Function<? super T,? extends CompletableSource>	ObservableFlatMapCompletable.FlatMapCompletableMainObserver.mapper
(package private) final Function<? super T,? extends CompletableSource>	ObservableFlatMapCompletable.mapper
(package private) final Function<? super T,? extends CompletableSource>	ObservableFlatMapCompletableCompletable.FlatMapCompletableMainObserver.mapper
(package private) final 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

Modifier	Constructor	Description
(package private)	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

Modifier	Constructor	Description
(package private)	FlatMapCompletableMainObserver(Observer<? super T> observer, Function<? super T,? extends CompletableSource> mapper, boolean delayErrors)
(package private)	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
final 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) final CompletableSource	SingleDelayWithCompletable.other

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

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

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

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

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

Modifier	Constructor	Description
(package private)	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) final 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
final class	CompletableSubject	Represents a hot Completable-like source and consumer of events similar to Subjects.