@NonNull Single<java.lang.Boolean> |
Flowable.all(@NonNull Predicate<? super @NonNull T> predicate) |
Returns a Single that emits a Boolean that indicates whether all of the items emitted by the current
Flowable satisfy a condition.
|
@NonNull Single<java.lang.Boolean> |
Observable.all(@NonNull Predicate<? super @NonNull T> predicate) |
Returns a Single that emits a Boolean that indicates whether all of the items emitted by the current
Observable satisfy a condition.
|
static <@NonNull T> @NonNull Single<T> |
Single.amb(@NonNull java.lang.Iterable<? extends SingleSource<? extends @NonNull T>> sources) |
Runs multiple SingleSource s and signals the events of the first one that signals (disposing
the rest).
|
static <@NonNull T> @NonNull Single<T> |
Single.ambArray(@NonNull SingleSource<? extends @NonNull T>... sources) |
Runs multiple SingleSource s and signals the events of the first one that signals (disposing
the rest).
|
@NonNull Single<T> |
Single.ambWith(@NonNull SingleSource<? extends @NonNull T> other) |
Signals the event of this or the other SingleSource whichever signals first.
|
<@NonNull T> @NonNull Single<T> |
Completable.andThen(@NonNull SingleSource<@NonNull T> next) |
Returns a Single which will subscribe to this Completable and once that is completed then
will subscribe to the next SingleSource .
|
@NonNull Single<java.lang.Boolean> |
Flowable.any(@NonNull Predicate<? super @NonNull T> predicate) |
Returns a Single that emits true if any item emitted by the current Flowable satisfies a
specified condition, otherwise false .
|
@NonNull Single<java.lang.Boolean> |
Observable.any(@NonNull Predicate<? super @NonNull T> predicate) |
Returns a Single that emits true if any item emitted by the current Observable satisfies a
specified condition, otherwise false .
|
@NonNull Single<T> |
Single.cache() |
Stores the success value or exception from the current Single and replays it to late SingleObserver s.
|
<@NonNull U> @NonNull Single<U> |
Single.cast(@NonNull java.lang.Class<? extends @NonNull U> clazz) |
Casts the success value of the current Single into the target type or signals a
ClassCastException if not compatible.
|
<@NonNull U> @NonNull Single<U> |
Flowable.collect(@NonNull Supplier<? extends @NonNull U> initialItemSupplier,
@NonNull BiConsumer<? super @NonNull U,? super @NonNull T> collector) |
Collects items emitted by the finite source Publisher into a single mutable data structure and returns
a Single that emits this structure.
|
<@NonNull R,@Nullable A> @NonNull Single<R> |
Flowable.collect(@NonNull java.util.stream.Collector<? super @NonNull T,@Nullable A,@NonNull R> collector) |
Collects the finite upstream's values into a container via a Stream Collector callback set and emits
it as the success result.
|
<@NonNull U> @NonNull Single<U> |
Observable.collect(@NonNull Supplier<? extends @NonNull U> initialItemSupplier,
@NonNull BiConsumer<? super @NonNull U,? super @NonNull T> collector) |
Collects items emitted by the finite source Observable into a single mutable data structure and returns
a Single that emits this structure.
|
<@NonNull R,@Nullable A> @NonNull Single<R> |
Observable.collect(@NonNull java.util.stream.Collector<? super @NonNull T,@Nullable A,@NonNull R> collector) |
Collects the finite upstream's values into a container via a Stream Collector callback set and emits
it as the success result as a Single .
|
<@NonNull U> @NonNull Single<U> |
Flowable.collectInto(@NonNull U initialItem,
@NonNull BiConsumer<? super @NonNull U,? super @NonNull T> collector) |
Collects items emitted by the finite source Publisher into a single mutable data structure and returns
a Single that emits this structure.
|
<@NonNull U> @NonNull Single<U> |
Observable.collectInto(@NonNull U initialItem,
@NonNull BiConsumer<? super @NonNull U,? super @NonNull T> collector) |
Collects items emitted by the finite source Observable into a single mutable data structure and returns
a Single that emits this structure.
|
<@NonNull R> @NonNull Single<R> |
Single.compose(@NonNull SingleTransformer<? super @NonNull T,? extends @NonNull R> transformer) |
|
<@NonNull R> @NonNull Single<R> |
Single.concatMap(@NonNull Function<? super @NonNull T,? extends SingleSource<? extends @NonNull R>> mapper) |
Returns a Single that is based on applying a specified function to the item emitted by the current Single ,
where that function returns a SingleSource .
|
@NonNull Single<java.lang.Boolean> |
Flowable.contains(@NonNull java.lang.Object item) |
Returns a Single that emits a Boolean that indicates whether the current Flowable emitted a
specified item.
|
@NonNull Single<java.lang.Boolean> |
Maybe.contains(@NonNull java.lang.Object item) |
Returns a Single that emits a Boolean that indicates whether the current Maybe emitted a
specified item.
|
@NonNull Single<java.lang.Boolean> |
Observable.contains(@NonNull java.lang.Object item) |
Returns a Single that emits a Boolean that indicates whether the current Observable emitted a
specified item.
|
@NonNull Single<java.lang.Boolean> |
Single.contains(@NonNull java.lang.Object item) |
Signals true if the current Single signals a success value that is Object.equals(Object) with the value
provided.
|
@NonNull Single<java.lang.Boolean> |
Single.contains(@NonNull java.lang.Object item,
@NonNull BiPredicate<java.lang.Object,java.lang.Object> comparer) |
Signals true if the current Single signals a success value that is equal with
the value provided by calling a BiPredicate .
|
@NonNull Single<java.lang.Long> |
Flowable.count() |
Returns a Single that counts the total number of items emitted by the current Flowable and emits
this count as a 64-bit Long .
|
@NonNull Single<java.lang.Long> |
Maybe.count() |
Returns a Single that counts the total number of items emitted (0 or 1) by the current Maybe and emits
this count as a 64-bit Long .
|
@NonNull Single<java.lang.Long> |
Observable.count() |
Returns a Single that counts the total number of items emitted by the current Observable and emits
this count as a 64-bit Long .
|
static <@NonNull T> @NonNull Single<T> |
Single.create(@NonNull SingleOnSubscribe<@NonNull T> source) |
Provides an API (via a cold Single ) that bridges the reactive world with the callback-style world.
|
@NonNull Single<T> |
Maybe.defaultIfEmpty(@NonNull T defaultItem) |
Returns a Single that emits the item emitted by the current Maybe or a specified default item
if the current Maybe is empty.
|
static <@NonNull T> @NonNull Single<T> |
Single.defer(@NonNull Supplier<? extends @NonNull SingleSource<? extends @NonNull T>> supplier) |
|
@NonNull Single<T> |
Single.delay(long time,
@NonNull java.util.concurrent.TimeUnit unit) |
Delays the emission of the success signal from the current Single by the specified amount.
|
@NonNull Single<T> |
Single.delay(long time,
@NonNull java.util.concurrent.TimeUnit unit,
boolean delayError) |
Delays the emission of the success or error signal from the current Single by the specified amount.
|
@NonNull Single<T> |
Single.delay(long time,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler) |
Delays the emission of the success signal from the current Single by the specified amount.
|
@NonNull Single<T> |
Single.delay(long time,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler,
boolean delayError) |
Delays the emission of the success or error signal from the current Single by the specified amount.
|
@NonNull Single<T> |
Single.delaySubscription(long time,
@NonNull java.util.concurrent.TimeUnit unit) |
Delays the actual subscription to the current Single until the given time delay elapsed.
|
@NonNull Single<T> |
Single.delaySubscription(long time,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler) |
Delays the actual subscription to the current Single until the given time delay elapsed.
|
@NonNull Single<T> |
Single.delaySubscription(@NonNull CompletableSource subscriptionIndicator) |
Delays the actual subscription to the current Single until the given other CompletableSource
completes.
|
<@NonNull U> @NonNull Single<T> |
Single.delaySubscription(@NonNull ObservableSource<@NonNull U> subscriptionIndicator) |
Delays the actual subscription to the current Single until the given other ObservableSource
signals its first value or completes.
|
<@NonNull U> @NonNull Single<T> |
Single.delaySubscription(@NonNull SingleSource<@NonNull U> subscriptionIndicator) |
Delays the actual subscription to the current Single until the given other SingleSource
signals success.
|
<@NonNull U> @NonNull Single<T> |
Single.delaySubscription(@NonNull org.reactivestreams.Publisher<@NonNull U> subscriptionIndicator) |
Delays the actual subscription to the current Single until the given other Publisher
signals its first value or completes.
|
@NonNull Single<T> |
Single.doAfterSuccess(@NonNull Consumer<? super @NonNull T> onAfterSuccess) |
Calls the specified consumer with the success item after this item has been emitted to the downstream.
|
@NonNull Single<T> |
Single.doAfterTerminate(@NonNull Action onAfterTerminate) |
Registers an Action to be called after this Single invokes either onSuccess or onError .
|
@NonNull Single<T> |
Single.doFinally(@NonNull Action onFinally) |
Calls the specified action after this Single signals onSuccess or onError or gets disposed by
the downstream.
|
@NonNull Single<T> |
Single.doOnDispose(@NonNull Action onDispose) |
|
@NonNull Single<T> |
Single.doOnError(@NonNull Consumer<? super java.lang.Throwable> onError) |
Calls the shared consumer with the error sent via onError for each
SingleObserver that subscribes to the current Single .
|
@NonNull Single<T> |
Single.doOnEvent(@NonNull BiConsumer<? super @NonNull T,? super java.lang.Throwable> onEvent) |
Calls the shared consumer with the error sent via onError or the value
via onSuccess for each SingleObserver that subscribes to the current Single .
|
@NonNull Single<T> |
Single.doOnLifecycle(@NonNull Consumer<? super Disposable> onSubscribe,
@NonNull Action onDispose) |
Calls the appropriate onXXX method (shared between all SingleObserver s) for the lifecycle events of
the sequence (subscription, disposal).
|
@NonNull Single<T> |
Single.doOnSubscribe(@NonNull Consumer<? super Disposable> onSubscribe) |
Calls the shared consumer with the Disposable sent through the onSubscribe for each
SingleObserver that subscribes to the current Single .
|
@NonNull Single<T> |
Single.doOnSuccess(@NonNull Consumer<? super @NonNull T> onSuccess) |
Calls the shared consumer with the success value sent via onSuccess for each
SingleObserver that subscribes to the current Single .
|
@NonNull Single<T> |
Single.doOnTerminate(@NonNull Action onTerminate) |
Returns a Single instance that calls the given onTerminate callback
just before this Single completes normally or with an exception.
|
@NonNull Single<T> |
Flowable.elementAt(long index,
@NonNull T defaultItem) |
Returns a Single that emits the item found at a specified index in a sequence of emissions from
this Flowable , or a default item if that index is out of range.
|
@NonNull Single<T> |
Observable.elementAt(long index,
@NonNull T defaultItem) |
Returns a Single that emits the item found at a specified index in a sequence of emissions from
the current Observable , or a default item if that index is out of range.
|
@NonNull Single<T> |
Flowable.elementAtOrError(long index) |
Returns a Single that emits the item found at a specified index in a sequence of emissions from
this Flowable or signals a NoSuchElementException if this Flowable has fewer elements than index.
|
@NonNull Single<T> |
Observable.elementAtOrError(long index) |
Returns a Single that emits the item found at a specified index in a sequence of emissions from the current Observable
or signals a NoSuchElementException if the current Observable signals fewer elements than index.
|
static <@NonNull T> @NonNull Single<T> |
Single.error(@NonNull Supplier<? extends @NonNull java.lang.Throwable> supplier) |
Signals a Throwable returned by the callback function for each individual SingleObserver .
|
static <@NonNull T> @NonNull Single<T> |
Single.error(@NonNull java.lang.Throwable throwable) |
Returns a Single that invokes a subscriber's onError method when the
subscriber subscribes to it.
|
@NonNull Single<T> |
Flowable.first(@NonNull T defaultItem) |
Returns a Single that emits only the very first item emitted by this Flowable , or a default
item if this Flowable completes without emitting anything.
|
@NonNull Single<T> |
Observable.first(@NonNull T defaultItem) |
Returns a Single that emits only the very first item emitted by the current Observable , or a default item
if the current Observable completes without emitting any items.
|
@NonNull Single<T> |
Flowable.firstOrError() |
Returns a Single that emits only the very first item emitted by this Flowable or
signals a NoSuchElementException if this Flowable is empty.
|
@NonNull Single<T> |
Observable.firstOrError() |
Returns a Single that emits only the very first item emitted by the current Observable or
signals a NoSuchElementException if the current Observable is empty.
|
<@NonNull R> @NonNull Single<R> |
Single.flatMap(@NonNull Function<? super @NonNull T,? extends SingleSource<? extends @NonNull R>> mapper) |
Returns a Single that is based on applying a specified function to the item emitted by the current Single ,
where that function returns a SingleSource .
|
<@NonNull R> @NonNull Single<R> |
Single.flatMap(@NonNull Function<? super @NonNull T,? extends SingleSource<? extends @NonNull R>> onSuccessMapper,
@NonNull Function<? super java.lang.Throwable,? extends SingleSource<? extends @NonNull R>> onErrorMapper) |
Maps the onSuccess or onError signals of the current Single into a SingleSource and emits that
SingleSource 's signals.
|
<@NonNull U,@NonNull R> @NonNull Single<R> |
Single.flatMap(@NonNull Function<? super @NonNull T,? extends SingleSource<? extends @NonNull U>> mapper,
@NonNull BiFunction<? super @NonNull T,? super @NonNull U,? extends @NonNull R> combiner) |
Returns a Single that emits the results of a specified function to the pair of values emitted by the
current Single and a specified mapped SingleSource .
|
static <@NonNull T> @NonNull Single<T> |
Single.fromCallable(@NonNull java.util.concurrent.Callable<? extends @NonNull T> callable) |
Returns a Single that invokes the given Callable for each incoming SingleObserver
and emits its value or exception to them.
|
static <@NonNull T> @NonNull Single<@NonNull T> |
Single.fromCompletionStage(@NonNull java.util.concurrent.CompletionStage<@NonNull T> stage) |
Signals the completion value or error of the given (hot) CompletionStage -based asynchronous calculation.
|
static <@NonNull T> @NonNull Single<T> |
Single.fromFuture(@NonNull java.util.concurrent.Future<? extends @NonNull T> future) |
Converts a Future into a Single and awaits its outcome in a blocking fashion.
|
static <@NonNull T> @NonNull Single<T> |
Single.fromFuture(@NonNull java.util.concurrent.Future<? extends @NonNull T> future,
long timeout,
@NonNull java.util.concurrent.TimeUnit unit) |
Converts a Future into a Single and awaits its outcome, or timeout, in a blocking fashion.
|
static <@NonNull T> @NonNull Single<T> |
Single.fromMaybe(@NonNull MaybeSource<@NonNull T> maybe) |
Returns a Single instance that when subscribed to, subscribes to the MaybeSource instance and
emits onSuccess as a single item, turns an onComplete into NoSuchElementException error signal or
forwards the onError signal.
|
static <@NonNull T> @NonNull Single<T> |
Single.fromMaybe(@NonNull MaybeSource<@NonNull T> maybe,
@NonNull T defaultItem) |
Returns a Single instance that when subscribed to, subscribes to the MaybeSource instance and
emits onSuccess as a single item, emits the defaultItem for an onComplete signal or
forwards the onError signal.
|
static <@NonNull T> @NonNull Single<T> |
Single.fromObservable(@NonNull ObservableSource<? extends @NonNull T> observable) |
Wraps a specific ObservableSource into a Single and signals its single element or error.
|
static <@NonNull T> @NonNull Single<T> |
Single.fromPublisher(@NonNull org.reactivestreams.Publisher<? extends @NonNull T> publisher) |
Wraps a specific Publisher into a Single and signals its single element or error.
|
static <@NonNull T> @NonNull Single<T> |
Single.fromSupplier(@NonNull Supplier<? extends @NonNull T> supplier) |
Returns a Single that invokes passed supplier and emits its result
for each individual SingleObserver that subscribes.
|
@NonNull Single<T> |
Single.hide() |
Hides the identity of the current Single , including the Disposable that is sent
to the downstream via onSubscribe() .
|
@NonNull Single<java.lang.Boolean> |
Flowable.isEmpty() |
Returns a Single that emits true if the current Flowable is empty, otherwise false .
|
@NonNull Single<java.lang.Boolean> |
Maybe.isEmpty() |
Returns a Single that emits true if the current Maybe is empty, otherwise false .
|
@NonNull Single<java.lang.Boolean> |
Observable.isEmpty() |
Returns a Single that emits true if the current Observable is empty, otherwise false .
|
static <@NonNull T> @NonNull Single<T> |
Single.just(@NonNull T item) |
Returns a Single that emits a specified item.
|
@NonNull Single<T> |
Flowable.last(@NonNull T defaultItem) |
Returns a Single that emits only the last item emitted by this Flowable , or a default item
if this Flowable completes without emitting any items.
|
@NonNull Single<T> |
Observable.last(@NonNull T defaultItem) |
Returns a Single that emits only the last item emitted by the current Observable , or a default item
if the current Observable completes without emitting any items.
|
@NonNull Single<T> |
Flowable.lastOrError() |
Returns a Single that emits only the last item emitted by this Flowable or signals
a NoSuchElementException if this Flowable is empty.
|
@NonNull Single<T> |
Observable.lastOrError() |
Returns a Single that emits only the last item emitted by the current Observable or
signals a NoSuchElementException if the current Observable is empty.
|
<@NonNull R> @NonNull Single<R> |
Single.lift(@NonNull SingleOperator<? extends @NonNull R,? super @NonNull T> lift) |
This method requires advanced knowledge about building operators, please consider
other standard composition methods first;
Returns a Single which, when subscribed to, invokes the apply(SingleObserver) method
of the provided SingleOperator for each individual downstream Single and allows the
insertion of a custom operator by accessing the downstream's SingleObserver during this subscription phase
and providing a new SingleObserver , containing the custom operator's intended business logic, that will be
used in the subscription process going further upstream.
|
<@NonNull R> @NonNull Single<R> |
Single.map(@NonNull Function<? super @NonNull T,? extends @NonNull R> mapper) |
Returns a Single that applies a specified function to the item emitted by the current Single and
emits the result of this function application.
|
<@NonNull T> @NonNull Single<Notification<T>> |
Completable.materialize() |
Maps the signal types of this Completable into a Notification of the same kind
and emits it as a single success value to downstream.
|
@NonNull Single<Notification<T>> |
Maybe.materialize() |
Maps the signal types of this Maybe into a Notification of the same kind
and emits it as a Single 's onSuccess value to downstream.
|
@NonNull Single<Notification<T>> |
Single.materialize() |
Maps the signal types of this Single into a Notification of the same kind
and emits it as a single success value to downstream.
|
static <@NonNull T> @NonNull Single<T> |
Single.merge(@NonNull SingleSource<? extends SingleSource<? extends @NonNull T>> source) |
Flattens a SingleSource that emits a SingleSingle into a single Single that emits the item
emitted by the nested SingleSource , without any transformation.
|
static <@NonNull T> @NonNull Single<T> |
Single.never() |
Returns a singleton instance of a never-signaling Single (only calls onSubscribe ).
|
@NonNull Single<T> |
Single.observeOn(@NonNull Scheduler scheduler) |
Signals the success item or the terminal signals of the current Single on the specified Scheduler ,
asynchronously.
|
@NonNull Single<T> |
Single.onErrorResumeNext(@NonNull Function<? super java.lang.Throwable,? extends SingleSource<? extends @NonNull T>> fallbackSupplier) |
Resumes the flow with a SingleSource returned for the failure Throwable of the current Single by a
function instead of signaling the error via onError .
|
@NonNull Single<T> |
Single.onErrorResumeWith(@NonNull SingleSource<? extends @NonNull T> fallback) |
Resumes the flow with the given SingleSource when the current Single fails instead of
signaling the error via onError .
|
@NonNull Single<T> |
Single.onErrorReturn(@NonNull Function<java.lang.Throwable,? extends @NonNull T> itemSupplier) |
Ends the flow with a success item returned by a function for the Throwable error signaled by the current
Single instead of signaling the error via onError .
|
@NonNull Single<T> |
Single.onErrorReturnItem(@NonNull T item) |
Signals the specified value as success in case the current Single signals an error.
|
@NonNull Single<T> |
Single.onTerminateDetach() |
Nulls out references to the upstream producer and downstream SingleObserver if
the sequence is terminated or downstream calls dispose() .
|
<@NonNull R> @NonNull Single<R> |
Flowable.reduce(@NonNull R seed,
@NonNull BiFunction<@NonNull R,? super @NonNull T,@NonNull R> reducer) |
Returns a Single that applies a specified accumulator function to the first item emitted by the current
Flowable and a specified seed value, then feeds the result of that function along with the second item
emitted by the current Flowable into the same function, and so on until all items have been emitted by the
current and finite Flowable , emitting the final result from the final call to your function as its sole item.
|
<@NonNull R> @NonNull Single<R> |
Observable.reduce(@NonNull R seed,
@NonNull BiFunction<@NonNull R,? super @NonNull T,@NonNull R> reducer) |
Returns a Single that applies a specified accumulator function to the first item emitted by the current
Observable and a specified seed value, then feeds the result of that function along with the second item
emitted by the current Observable into the same function, and so on until all items have been emitted by the
current and finite Observable , emitting the final result from the final call to your function as its sole item.
|
<@NonNull R> @NonNull Single<R> |
Flowable.reduceWith(@NonNull Supplier<@NonNull R> seedSupplier,
@NonNull BiFunction<@NonNull R,? super @NonNull T,@NonNull R> reducer) |
Returns a Single that applies a specified accumulator function to the first item emitted by the current
Flowable and a seed value derived from calling a specified seedSupplier , then feeds the result
of that function along with the second item emitted by the current Flowable into the same function, and so on until
all items have been emitted by the current and finite Flowable , emitting the final result from the final call to your
function as its sole item.
|
<@NonNull R> @NonNull Single<R> |
Observable.reduceWith(@NonNull Supplier<@NonNull R> seedSupplier,
@NonNull BiFunction<@NonNull R,? super @NonNull T,@NonNull R> reducer) |
Returns a Single that applies a specified accumulator function to the first item emitted by the current
Observable and a seed value derived from calling a specified seedSupplier , then feeds the result
of that function along with the second item emitted by the current Observable into the same function,
and so on until all items have been emitted by the current and finite Observable , emitting the final result
from the final call to your function as its sole item.
|
@NonNull Single<T> |
Single.retry() |
Repeatedly re-subscribes to the current Single indefinitely if it fails with an onError .
|
@NonNull Single<T> |
Single.retry(long times) |
Repeatedly re-subscribe at most the specified times to the current Single
if it fails with an onError .
|
@NonNull Single<T> |
Single.retry(long times,
@NonNull Predicate<? super java.lang.Throwable> predicate) |
Repeatedly re-subscribe at most times or until the predicate returns false , whichever happens first
if it fails with an onError .
|
@NonNull Single<T> |
Single.retry(@NonNull BiPredicate<? super java.lang.Integer,? super java.lang.Throwable> predicate) |
Re-subscribe to the current Single if the given predicate returns true when the Single fails
with an onError .
|
@NonNull Single<T> |
Single.retry(@NonNull Predicate<? super java.lang.Throwable> predicate) |
Re-subscribe to the current Single if the given predicate returns true when the Single fails
with an onError .
|
@NonNull Single<T> |
Single.retryUntil(@NonNull BooleanSupplier stop) |
Retries until the given stop function returns true .
|
@NonNull Single<T> |
Single.retryWhen(@NonNull Function<? super Flowable<java.lang.Throwable>,? extends org.reactivestreams.Publisher<?>> handler) |
Re-subscribes to the current Single if and when the Publisher returned by the handler
function signals a value.
|
static @NonNull Single<java.lang.Boolean> |
Completable.sequenceEqual(@NonNull CompletableSource source1,
@NonNull CompletableSource source2) |
|
static <@NonNull T> @NonNull Single<java.lang.Boolean> |
Flowable.sequenceEqual(@NonNull org.reactivestreams.Publisher<? extends @NonNull T> source1,
@NonNull org.reactivestreams.Publisher<? extends @NonNull T> source2) |
Returns a Single that emits a Boolean value that indicates whether two Publisher sequences are the
same by comparing the items emitted by each Publisher pairwise.
|
static <@NonNull T> @NonNull Single<java.lang.Boolean> |
Flowable.sequenceEqual(@NonNull org.reactivestreams.Publisher<? extends @NonNull T> source1,
@NonNull org.reactivestreams.Publisher<? extends @NonNull T> source2,
int bufferSize) |
Returns a Single that emits a Boolean value that indicates whether two Publisher sequences are the
same by comparing the items emitted by each Publisher pairwise.
|
static <@NonNull T> @NonNull Single<java.lang.Boolean> |
Flowable.sequenceEqual(@NonNull org.reactivestreams.Publisher<? extends @NonNull T> source1,
@NonNull org.reactivestreams.Publisher<? extends @NonNull T> source2,
@NonNull BiPredicate<? super @NonNull T,? super @NonNull T> isEqual) |
Returns a Single that emits a Boolean value that indicates whether two Publisher sequences are the
same by comparing the items emitted by each Publisher pairwise based on the results of a specified
equality function.
|
static <@NonNull T> @NonNull Single<java.lang.Boolean> |
Flowable.sequenceEqual(@NonNull org.reactivestreams.Publisher<? extends @NonNull T> source1,
@NonNull org.reactivestreams.Publisher<? extends @NonNull T> source2,
@NonNull BiPredicate<? super @NonNull T,? super @NonNull T> isEqual,
int bufferSize) |
Returns a Single that emits a Boolean value that indicates whether two Publisher sequences are the
same by comparing the items emitted by each Publisher pairwise based on the results of a specified
equality function.
|
static <@NonNull T> @NonNull Single<java.lang.Boolean> |
Maybe.sequenceEqual(@NonNull MaybeSource<? extends @NonNull T> source1,
@NonNull MaybeSource<? extends @NonNull T> source2) |
Returns a Single that emits a Boolean value that indicates whether two MaybeSource sequences are the
same by comparing the items emitted by each MaybeSource pairwise.
|
static <@NonNull T> @NonNull Single<java.lang.Boolean> |
Maybe.sequenceEqual(@NonNull MaybeSource<? extends @NonNull T> source1,
@NonNull MaybeSource<? extends @NonNull T> source2,
@NonNull BiPredicate<? super @NonNull T,? super @NonNull T> isEqual) |
Returns a Single that emits a Boolean value that indicates whether two MaybeSource s are the
same by comparing the items emitted by each MaybeSource pairwise based on the results of a specified
equality function.
|
static <@NonNull T> @NonNull Single<java.lang.Boolean> |
Observable.sequenceEqual(@NonNull ObservableSource<? extends @NonNull T> source1,
@NonNull ObservableSource<? extends @NonNull T> source2) |
Returns a Single that emits a Boolean value that indicates whether two ObservableSource sequences are the
same by comparing the items emitted by each ObservableSource pairwise.
|
static <@NonNull T> @NonNull Single<java.lang.Boolean> |
Observable.sequenceEqual(@NonNull ObservableSource<? extends @NonNull T> source1,
@NonNull ObservableSource<? extends @NonNull T> source2,
int bufferSize) |
Returns a Single that emits a Boolean value that indicates whether two ObservableSource sequences are the
same by comparing the items emitted by each ObservableSource pairwise.
|
static <@NonNull T> @NonNull Single<java.lang.Boolean> |
Observable.sequenceEqual(@NonNull ObservableSource<? extends @NonNull T> source1,
@NonNull ObservableSource<? extends @NonNull T> source2,
@NonNull BiPredicate<? super @NonNull T,? super @NonNull T> isEqual) |
Returns a Single that emits a Boolean value that indicates whether two ObservableSource sequences are the
same by comparing the items emitted by each ObservableSource pairwise based on the results of a specified
equality function.
|
static <@NonNull T> @NonNull Single<java.lang.Boolean> |
Observable.sequenceEqual(@NonNull ObservableSource<? extends @NonNull T> source1,
@NonNull ObservableSource<? extends @NonNull T> source2,
@NonNull BiPredicate<? super @NonNull T,? super @NonNull T> isEqual,
int bufferSize) |
Returns a Single that emits a Boolean value that indicates whether two ObservableSource sequences are the
same by comparing the items emitted by each ObservableSource pairwise based on the results of a specified
equality function.
|
static <@NonNull T> @NonNull Single<java.lang.Boolean> |
Single.sequenceEqual(@NonNull SingleSource<? extends @NonNull T> source1,
@NonNull SingleSource<? extends @NonNull T> source2) |
Compares two SingleSource s and emits true if they emit the same value (compared via Object.equals(Object) ).
|
@NonNull Single<T> |
Flowable.single(@NonNull T defaultItem) |
Returns a Single that emits the single item emitted by the current Flowable if it
emits only a single item, or a default item if the current Flowable emits no items.
|
@NonNull Single<T> |
Observable.single(@NonNull T defaultItem) |
Returns a Single that emits the single item emitted by the current Observable , if the current Observable
emits only a single item, or a default item if the current Observable emits no items.
|
@NonNull Single<T> |
Flowable.singleOrError() |
Returns a Single that emits the single item emitted by this Flowable , if this Flowable
emits only a single item, otherwise
if this Flowable completes without emitting any items a NoSuchElementException will be signaled and
if this Flowable emits more than one item, an IllegalArgumentException will be signaled.
|
@NonNull Single<T> |
Observable.singleOrError() |
Returns a Single that emits the single item emitted by the current Observable if it
emits only a single item, otherwise
if the current Observable completes without emitting any items or emits more than one item a
NoSuchElementException or IllegalArgumentException will be signaled respectively.
|
@NonNull Single<T> |
Single.subscribeOn(@NonNull Scheduler scheduler) |
|
@NonNull Single<T> |
Maybe.switchIfEmpty(@NonNull SingleSource<? extends @NonNull T> other) |
Returns a Single that emits the items emitted by the current Maybe or the item of an alternate
SingleSource if the current Maybe is empty.
|
@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 E> @NonNull Single<T> |
Single.takeUntil(@NonNull SingleSource<? extends @NonNull E> other) |
Returns a Single that emits the item emitted by the current Single until a second Single emits an item.
|
<@NonNull E> @NonNull Single<T> |
Single.takeUntil(@NonNull org.reactivestreams.Publisher<@NonNull E> other) |
Returns a Single that emits the item emitted by the current Single until a Publisher emits an item or completes.
|
@NonNull Single<Timed<T>> |
Single.timeInterval() |
Measures the time (in milliseconds) between the subscription and success item emission
of the current Single and signals it as a tuple ( Timed )
success value.
|
@NonNull Single<Timed<T>> |
Single.timeInterval(@NonNull Scheduler scheduler) |
Measures the time (in milliseconds) between the subscription and success item emission
of the current Single and signals it as a tuple ( Timed )
success value.
|
@NonNull Single<Timed<T>> |
Single.timeInterval(@NonNull java.util.concurrent.TimeUnit unit) |
Measures the time between the subscription and success item emission
of the current Single and signals it as a tuple ( Timed )
success value.
|
@NonNull Single<Timed<T>> |
Single.timeInterval(@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler) |
Measures the time between the subscription and success item emission
of the current Single and signals it as a tuple ( Timed )
success value.
|
@NonNull Single<T> |
Single.timeout(long timeout,
@NonNull java.util.concurrent.TimeUnit unit) |
Signals a TimeoutException if the current Single doesn't signal a success value within the
specified timeout window.
|
@NonNull Single<T> |
Single.timeout(long timeout,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler) |
Signals a TimeoutException if the current Single doesn't signal a success value within the
specified timeout window.
|
@NonNull Single<T> |
Single.timeout(long timeout,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler,
@NonNull SingleSource<? extends @NonNull T> fallback) |
Runs the current Single and if it doesn't signal within the specified timeout window, it is
disposed and the other SingleSource subscribed to.
|
@NonNull Single<T> |
Single.timeout(long timeout,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull SingleSource<? extends @NonNull T> fallback) |
Runs the current Single and if it doesn't signal within the specified timeout window, it is
disposed and the other SingleSource subscribed to.
|
private Single<T> |
Single.timeout0(long timeout,
java.util.concurrent.TimeUnit unit,
Scheduler scheduler,
SingleSource<? extends @NonNull T> fallback) |
|
static @NonNull Single<java.lang.Long> |
Single.timer(long delay,
@NonNull java.util.concurrent.TimeUnit unit) |
Signals success with 0L value after the given delay when a SingleObserver subscribes.
|
static @NonNull Single<java.lang.Long> |
Single.timer(long delay,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler) |
|
@NonNull Single<Timed<T>> |
Single.timestamp() |
Combines the success value from the current Single with the current time (in milliseconds) of
its reception, using the computation Scheduler as time source,
then signals them as a Timed instance.
|
@NonNull Single<Timed<T>> |
Single.timestamp(@NonNull Scheduler scheduler) |
Combines the success value from the current Single with the current time (in milliseconds) of
its reception, using the given Scheduler as time source,
then signals them as a Timed instance.
|
@NonNull Single<Timed<T>> |
Single.timestamp(@NonNull java.util.concurrent.TimeUnit unit) |
Combines the success value from the current Single with the current time of
its reception, using the computation Scheduler as time source,
then signals it as a Timed instance.
|
@NonNull Single<Timed<T>> |
Single.timestamp(@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler) |
Combines the success value from the current Single with the current time of
its reception, using the given Scheduler as time source,
then signals it as a Timed instance.
|
@NonNull Single<java.util.List<T>> |
Flowable.toList() |
Returns a Single that emits a single item, a list composed of all the items emitted by the
finite upstream source Publisher .
|
@NonNull Single<java.util.List<T>> |
Flowable.toList(int capacityHint) |
Returns a Single that emits a single item, a list composed of all the items emitted by the
finite source Publisher .
|
<@NonNull U extends java.util.Collection<? super @NonNull T>> @NonNull Single<U> |
Flowable.toList(@NonNull Supplier<@NonNull U> collectionSupplier) |
Returns a Single that emits a single item, a list composed of all the items emitted by the
finite source Publisher .
|
@NonNull Single<@NonNull java.util.List<T>> |
Observable.toList() |
Returns a Single that emits a single item, a List composed of all the items emitted by the
current and finite Observable .
|
@NonNull Single<@NonNull java.util.List<T>> |
Observable.toList(int capacityHint) |
Returns a Single that emits a single item, a List composed of all the items emitted by the
current and finite Observable .
|
<@NonNull U extends java.util.Collection<? super @NonNull T>> @NonNull Single<U> |
Observable.toList(@NonNull Supplier<@NonNull U> collectionSupplier) |
Returns a Single that emits a single item, a Collection (subclass) composed of all the items emitted by the
finite upstream Observable .
|
<@NonNull K> @NonNull Single<java.util.Map<K,T>> |
Flowable.toMap(@NonNull Function<? super @NonNull T,? extends @NonNull K> keySelector) |
Returns a Single that emits a single HashMap containing all items emitted by the finite source Publisher ,
mapped by the keys returned by a specified keySelector function.
|
<@NonNull K,@NonNull V> @NonNull Single<java.util.Map<K,V>> |
Flowable.toMap(@NonNull Function<? super @NonNull T,? extends @NonNull K> keySelector,
@NonNull Function<? super @NonNull T,? extends @NonNull V> valueSelector) |
Returns a Single that emits a single HashMap containing values corresponding to items emitted by the
finite source Publisher , mapped by the keys returned by a specified keySelector function.
|
<@NonNull K,@NonNull V> @NonNull Single<java.util.Map<K,V>> |
Flowable.toMap(@NonNull Function<? super @NonNull T,? extends @NonNull K> keySelector,
@NonNull Function<? super @NonNull T,? extends @NonNull V> valueSelector,
@NonNull Supplier<? extends java.util.Map<@NonNull K,@NonNull V>> mapSupplier) |
Returns a Single that emits a single Map , returned by a specified mapFactory function, that
contains keys and values extracted from the items emitted by the finite source Publisher .
|
<@NonNull K> @NonNull Single<@NonNull java.util.Map<K,T>> |
Observable.toMap(@NonNull Function<? super @NonNull T,? extends @NonNull K> keySelector) |
Returns a Single that emits a single HashMap containing all items emitted by the
current and finite Observable , mapped by the keys returned by a specified
keySelector function.
|
<@NonNull K,@NonNull V> @NonNull Single<java.util.Map<K,V>> |
Observable.toMap(@NonNull Function<? super @NonNull T,? extends @NonNull K> keySelector,
@NonNull Function<? super @NonNull T,? extends @NonNull V> valueSelector) |
Returns a Single that emits a single HashMap containing values corresponding to items emitted by the
current and finite Observable , mapped by the keys and values returned by the given selector functions.
|
<@NonNull K,@NonNull V> @NonNull Single<java.util.Map<K,V>> |
Observable.toMap(@NonNull Function<? super @NonNull T,? extends @NonNull K> keySelector,
@NonNull Function<? super @NonNull T,? extends @NonNull V> valueSelector,
@NonNull Supplier<? extends java.util.Map<@NonNull K,@NonNull V>> mapSupplier) |
Returns a Single that emits a single Map (subclass), returned by a specified mapFactory function, that
contains keys and values extracted from the items, via selector functions, emitted by the current and finite Observable .
|
<@NonNull K> @NonNull Single<java.util.Map<K,java.util.Collection<T>>> |
Flowable.toMultimap(@NonNull Function<? super @NonNull T,? extends @NonNull K> keySelector) |
Returns a Single that emits a single HashMap that contains an ArrayList of items emitted by the
finite source Publisher keyed by a specified keySelector function.
|
<@NonNull K,@NonNull V> @NonNull Single<java.util.Map<K,java.util.Collection<V>>> |
Flowable.toMultimap(@NonNull Function<? super @NonNull T,? extends @NonNull K> keySelector,
@NonNull Function<? super @NonNull T,? extends @NonNull V> valueSelector) |
Returns a Single that emits a single HashMap that contains an ArrayList of values extracted by a
specified valueSelector function from items emitted by the finite source Publisher , keyed by a
specified keySelector function.
|
<@NonNull K,@NonNull V> @NonNull Single<java.util.Map<K,java.util.Collection<V>>> |
Flowable.toMultimap(@NonNull Function<? super @NonNull T,? extends @NonNull K> keySelector,
@NonNull Function<? super @NonNull T,? extends @NonNull V> valueSelector,
@NonNull Supplier<? extends java.util.Map<@NonNull K,java.util.Collection<@NonNull V>>> mapSupplier,
@NonNull Function<? super @NonNull K,? extends java.util.Collection<? super @NonNull V>> collectionFactory) |
Returns a Single that emits a single Map , returned by a specified mapFactory function, that
contains a custom collection of values, extracted by a specified valueSelector function from
items emitted by the finite source Publisher , and keyed by the keySelector function.
|
<@NonNull K,@NonNull V> @NonNull Single<java.util.Map<K,java.util.Collection<V>>> |
Flowable.toMultimap(@NonNull Function<? super @NonNull T,? extends @NonNull K> keySelector,
@NonNull Function<? super @NonNull T,? extends @NonNull V> valueSelector,
@NonNull Supplier<java.util.Map<@NonNull K,java.util.Collection<@NonNull V>>> mapSupplier) |
Returns a Single that emits a single Map , returned by a specified mapFactory function, that
contains an ArrayList of values, extracted by a specified valueSelector function from items
emitted by the finite source Publisher and keyed by the keySelector function.
|
<@NonNull K> @NonNull Single<@NonNull java.util.Map<K,java.util.Collection<T>>> |
Observable.toMultimap(@NonNull Function<? super @NonNull T,? extends @NonNull K> keySelector) |
Returns a Single that emits a single HashMap that contains an ArrayList of items emitted by the
current and finite Observable keyed by a specified keySelector function.
|
<@NonNull K,@NonNull V> @NonNull Single<@NonNull java.util.Map<K,java.util.Collection<V>>> |
Observable.toMultimap(@NonNull Function<? super @NonNull T,? extends @NonNull K> keySelector,
@NonNull Function<? super @NonNull T,? extends @NonNull V> valueSelector,
@NonNull Supplier<? extends java.util.Map<@NonNull K,java.util.Collection<@NonNull V>>> mapSupplier,
@NonNull Function<? super @NonNull K,? extends java.util.Collection<? super @NonNull V>> collectionFactory) |
Returns a Single that emits a single Map (subclass), returned by a specified mapFactory function, that
contains a custom Collection of values, extracted by a specified valueSelector function from
items emitted by the current and finite Observable , and keyed by the keySelector function.
|
<@NonNull K,@NonNull V> @NonNull Single<@NonNull java.util.Map<K,java.util.Collection<V>>> |
Observable.toMultimap(@NonNull Function<? super @NonNull T,? extends @NonNull K> keySelector,
@NonNull Function<? super @NonNull T,? extends @NonNull V> valueSelector,
@NonNull Supplier<java.util.Map<@NonNull K,java.util.Collection<@NonNull V>>> mapSupplier) |
Returns a Single that emits a single Map (subclass), returned by a specified mapFactory function, that
contains an ArrayList of values, extracted by a specified valueSelector function from items
emitted by the current and finite Observable and keyed by the keySelector function.
|
<@NonNull K,@NonNull V> @NonNull Single<@NonNull java.util.Map<K,java.util.Collection<V>>> |
Observable.toMultimap(@NonNull Function<? super @NonNull T,? extends @NonNull K> keySelector,
Function<? super @NonNull T,? extends @NonNull V> valueSelector) |
Returns a Single that emits a single HashMap that contains an ArrayList of values extracted by a
specified valueSelector function from items emitted by the current and finite Observable ,
keyed by a specified keySelector function.
|
<@NonNull T> @NonNull Single<T> |
Completable.toSingle(@NonNull Supplier<? extends @NonNull T> completionValueSupplier) |
Converts this Completable into a Single which when this Completable completes normally,
calls the given Supplier and emits its returned value through onSuccess .
|
@NonNull Single<T> |
Maybe.toSingle() |
Converts this Maybe into a Single instance composing disposal
through and turning an empty Maybe into a signal of NoSuchElementException .
|
private static <T> @NonNull Single<T> |
Single.toSingle(@NonNull Flowable<T> source) |
|
<@NonNull T> @NonNull Single<T> |
Completable.toSingleDefault(@NonNull T completionValue) |
Converts this Completable into a Single which when this Completable completes normally,
emits the given value through onSuccess .
|
@NonNull Single<java.util.List<T>> |
Flowable.toSortedList() |
Returns a Single that emits a List that contains the items emitted by the finite source Publisher , in a
sorted order.
|
@NonNull Single<java.util.List<T>> |
Flowable.toSortedList(int capacityHint) |
Returns a Single that emits a List that contains the items emitted by the finite source Publisher , in a
sorted order.
|
@NonNull Single<java.util.List<T>> |
Flowable.toSortedList(@NonNull java.util.Comparator<? super @NonNull T> comparator) |
Returns a Single that emits a List that contains the items emitted by the finite source Publisher , in a
sorted order based on a specified comparison function.
|
@NonNull Single<java.util.List<T>> |
Flowable.toSortedList(@NonNull java.util.Comparator<? super @NonNull T> comparator,
int capacityHint) |
Returns a Single that emits a List that contains the items emitted by the finite source Publisher , in a
sorted order based on a specified comparison function.
|
@NonNull Single<@NonNull java.util.List<T>> |
Observable.toSortedList() |
Returns a Single that emits a List that contains the items emitted by the current and finite Observable , in a
sorted order.
|
@NonNull Single<@NonNull java.util.List<T>> |
Observable.toSortedList(int capacityHint) |
Returns a Single that emits a List that contains the items emitted by the current and finite Observable , in a
sorted order.
|
@NonNull Single<@NonNull java.util.List<T>> |
Observable.toSortedList(@NonNull java.util.Comparator<? super @NonNull T> comparator) |
Returns a Single that emits a List that contains the items emitted by the current and finite Observable , in a
sorted order based on a specified comparison function.
|
@NonNull Single<@NonNull java.util.List<T>> |
Observable.toSortedList(@NonNull java.util.Comparator<? super @NonNull T> comparator,
int capacityHint) |
Returns a Single that emits a List that contains the items emitted by the current and finite Observable , in a
sorted order based on a specified comparison function.
|
static <@NonNull T> @NonNull Single<T> |
Single.unsafeCreate(@NonNull SingleSource<@NonNull T> onSubscribe) |
Advanced use only: creates a Single instance without
any safeguards by using a callback that is called with a SingleObserver .
|
@NonNull Single<T> |
Single.unsubscribeOn(@NonNull Scheduler scheduler) |
|
static <@NonNull T,@NonNull U> @NonNull Single<T> |
Single.using(@NonNull Supplier<@NonNull U> resourceSupplier,
@NonNull Function<? super @NonNull U,? extends SingleSource<? extends @NonNull T>> sourceSupplier,
@NonNull Consumer<? super @NonNull U> resourceCleanup) |
Allows using and disposing a resource while running a SingleSource instance generated from
that resource (similar to a try-with-resources).
|
static <@NonNull T,@NonNull U> @NonNull Single<T> |
Single.using(@NonNull Supplier<@NonNull U> resourceSupplier,
@NonNull Function<? super @NonNull U,? extends SingleSource<? extends @NonNull T>> sourceSupplier,
@NonNull Consumer<? super @NonNull U> resourceCleanup,
boolean eager) |
Allows using and disposing a resource while running a SingleSource instance generated from
that resource (similar to a try-with-resources).
|
static <@NonNull T> @NonNull Single<T> |
Single.wrap(@NonNull SingleSource<@NonNull T> source) |
Wraps a SingleSource instance into a new Single instance if not already a Single
instance.
|
static <@NonNull T1,@NonNull T2,@NonNull T3,@NonNull T4,@NonNull T5,@NonNull T6,@NonNull T7,@NonNull T8,@NonNull T9,@NonNull R> @NonNull Single<R> |
Single.zip(@NonNull SingleSource<? extends @NonNull T1> source1,
@NonNull SingleSource<? extends @NonNull T2> source2,
@NonNull SingleSource<? extends @NonNull T3> source3,
@NonNull SingleSource<? extends @NonNull T4> source4,
@NonNull SingleSource<? extends @NonNull T5> source5,
@NonNull SingleSource<? extends @NonNull T6> source6,
@NonNull SingleSource<? extends @NonNull T7> source7,
@NonNull SingleSource<? extends @NonNull T8> source8,
@NonNull SingleSource<? extends @NonNull T9> source9,
@NonNull Function9<? super @NonNull T1,? super @NonNull T2,? super @NonNull T3,? super @NonNull T4,? super @NonNull T5,? super @NonNull T6,? super @NonNull T7,? super @NonNull T8,? super @NonNull T9,? extends @NonNull R> zipper) |
Returns a Single that emits the results of a specified combiner function applied to nine items
emitted by nine other SingleSource s.
|
static <@NonNull T1,@NonNull T2,@NonNull T3,@NonNull T4,@NonNull T5,@NonNull T6,@NonNull T7,@NonNull T8,@NonNull R> @NonNull Single<R> |
Single.zip(@NonNull SingleSource<? extends @NonNull T1> source1,
@NonNull SingleSource<? extends @NonNull T2> source2,
@NonNull SingleSource<? extends @NonNull T3> source3,
@NonNull SingleSource<? extends @NonNull T4> source4,
@NonNull SingleSource<? extends @NonNull T5> source5,
@NonNull SingleSource<? extends @NonNull T6> source6,
@NonNull SingleSource<? extends @NonNull T7> source7,
@NonNull SingleSource<? extends @NonNull T8> source8,
@NonNull Function8<? super @NonNull T1,? super @NonNull T2,? super @NonNull T3,? super @NonNull T4,? super @NonNull T5,? super @NonNull T6,? super @NonNull T7,? super @NonNull T8,? extends @NonNull R> zipper) |
Returns a Single that emits the results of a specified combiner function applied to eight items
emitted by eight other SingleSource s.
|
static <@NonNull T1,@NonNull T2,@NonNull T3,@NonNull T4,@NonNull T5,@NonNull T6,@NonNull T7,@NonNull R> @NonNull Single<R> |
Single.zip(@NonNull SingleSource<? extends @NonNull T1> source1,
@NonNull SingleSource<? extends @NonNull T2> source2,
@NonNull SingleSource<? extends @NonNull T3> source3,
@NonNull SingleSource<? extends @NonNull T4> source4,
@NonNull SingleSource<? extends @NonNull T5> source5,
@NonNull SingleSource<? extends @NonNull T6> source6,
@NonNull SingleSource<? extends @NonNull T7> source7,
@NonNull Function7<? super @NonNull T1,? super @NonNull T2,? super @NonNull T3,? super @NonNull T4,? super @NonNull T5,? super @NonNull T6,? super @NonNull T7,? extends @NonNull R> zipper) |
Returns a Single that emits the results of a specified combiner function applied to seven items
emitted by seven other SingleSource s.
|
static <@NonNull T1,@NonNull T2,@NonNull T3,@NonNull T4,@NonNull T5,@NonNull T6,@NonNull R> @NonNull Single<R> |
Single.zip(@NonNull SingleSource<? extends @NonNull T1> source1,
@NonNull SingleSource<? extends @NonNull T2> source2,
@NonNull SingleSource<? extends @NonNull T3> source3,
@NonNull SingleSource<? extends @NonNull T4> source4,
@NonNull SingleSource<? extends @NonNull T5> source5,
@NonNull SingleSource<? extends @NonNull T6> source6,
@NonNull Function6<? super @NonNull T1,? super @NonNull T2,? super @NonNull T3,? super @NonNull T4,? super @NonNull T5,? super @NonNull T6,? extends @NonNull R> zipper) |
Returns a Single that emits the results of a specified combiner function applied to six items
emitted by six other SingleSource s.
|
static <@NonNull T1,@NonNull T2,@NonNull T3,@NonNull T4,@NonNull T5,@NonNull R> @NonNull Single<R> |
Single.zip(@NonNull SingleSource<? extends @NonNull T1> source1,
@NonNull SingleSource<? extends @NonNull T2> source2,
@NonNull SingleSource<? extends @NonNull T3> source3,
@NonNull SingleSource<? extends @NonNull T4> source4,
@NonNull SingleSource<? extends @NonNull T5> source5,
@NonNull Function5<? super @NonNull T1,? super @NonNull T2,? super @NonNull T3,? super @NonNull T4,? super @NonNull T5,? extends @NonNull R> zipper) |
Returns a Single that emits the results of a specified combiner function applied to five items
emitted by five other SingleSource s.
|
static <@NonNull T1,@NonNull T2,@NonNull T3,@NonNull T4,@NonNull R> @NonNull Single<R> |
Single.zip(@NonNull SingleSource<? extends @NonNull T1> source1,
@NonNull SingleSource<? extends @NonNull T2> source2,
@NonNull SingleSource<? extends @NonNull T3> source3,
@NonNull SingleSource<? extends @NonNull T4> source4,
@NonNull Function4<? super @NonNull T1,? super @NonNull T2,? super @NonNull T3,? super @NonNull T4,? extends @NonNull R> zipper) |
Returns a Single that emits the results of a specified combiner function applied to four items
emitted by four other SingleSource s.
|
static <@NonNull T1,@NonNull T2,@NonNull T3,@NonNull R> @NonNull Single<R> |
Single.zip(@NonNull SingleSource<? extends @NonNull T1> source1,
@NonNull SingleSource<? extends @NonNull T2> source2,
@NonNull SingleSource<? extends @NonNull T3> source3,
@NonNull Function3<? super @NonNull T1,? super @NonNull T2,? super @NonNull T3,? extends @NonNull R> zipper) |
Returns a Single that emits the results of a specified combiner function applied to three items emitted
by three other SingleSource s.
|
static <@NonNull T1,@NonNull T2,@NonNull R> @NonNull Single<R> |
Single.zip(@NonNull SingleSource<? extends @NonNull T1> source1,
@NonNull SingleSource<? extends @NonNull T2> source2,
@NonNull BiFunction<? super @NonNull T1,? super @NonNull T2,? extends @NonNull R> zipper) |
Returns a Single that emits the results of a specified combiner function applied to two items emitted by
two other SingleSource s.
|
static <@NonNull T,@NonNull R> @NonNull Single<R> |
Single.zip(@NonNull java.lang.Iterable<? extends SingleSource<? extends @NonNull T>> sources,
@NonNull Function<? super java.lang.Object[],? extends @NonNull R> zipper) |
Waits until all SingleSource sources provided by the Iterable sequence signal a success
value and calls a zipper function with an array of these values to return a result
to be emitted to the downstream.
|
static <@NonNull T,@NonNull R> @NonNull Single<R> |
Single.zipArray(@NonNull Function<? super java.lang.Object[],? extends @NonNull R> zipper,
@NonNull SingleSource<? extends @NonNull T>... sources) |
Waits until all SingleSource sources provided via an array signal a success
value and calls a zipper function with an array of these values to return a result
to be emitted to downstream.
|
<@NonNull U,@NonNull R> @NonNull Single<R> |
Single.zipWith(@NonNull SingleSource<@NonNull U> other,
@NonNull BiFunction<? super @NonNull T,? super @NonNull U,? extends @NonNull R> zipper) |
Returns a Single that emits the result of applying a specified function to the pair of items emitted by
the current Single and another specified SingleSource .
|