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