Uses of Annotation Interface
io.reactivex.rxjava3.annotations.NonNull
Packages that use NonNull
Package
Description
Base reactive classes:
Flowable
, Observable
,
Single
, Maybe
and
Completable
; base reactive consumers;
other common base interfaces.Default implementations for
Disposable
-based resource management
(Disposable
container types) and utility classes to construct
Disposables
from callbacks and other types.Exception handling utilities (
Exceptions
),
composite exception container (CompositeException
) and
various lifecycle-related (UndeliverableException
)
and behavior-violation exception types (OnErrorNotImplementedException
,
MissingBackpressureException
).Classes supporting the Flowable base reactive class:
ConnectableFlowable
and
GroupedFlowable
.Functional interfaces of functions and actions of arity 0 to 9 and related
utility classes.
Base interfaces and types for supporting operator-fusion.
Classes supporting the Observable base reactive class:
ConnectableObservable
and
GroupedObservable
.Default wrappers and implementations for observer-based consumer classes and interfaces,
including disposable and resource-tracking variants and
the
TestObserver
that allows unit testing
Observable
-, Single
-,
Maybe
- and Completable
-based flows.Classes and interfaces for writing advanced operators within and outside RxJava.
Contains the base type
ParallelFlowable
,
a sub-DSL for working with Flowable
sequences in parallel.Contains the central plugin handler
RxJavaPlugins
class to hook into the lifecycle of the base reactive types and schedulers.Classes representing so-called hot backpressure-aware sources, aka processors,
that implement the
FlowableProcessor
class,
the Reactive Streams Processor
interface
to allow forms of multicasting events to one or more subscribers as well as consuming another
Reactive Streams Publisher
.Contains notably the factory class of
Schedulers
providing methods for
retrieving the standard scheduler instances, the TestScheduler
for testing flows
with scheduling in a controlled manner and the class Timed
that can hold
a value and a timestamp associated with it.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.
Default wrappers and implementations for
Subscriber
-based consumer classes and interfaces,
including disposable (DisposableSubscriber
) and resource-tracking
(ResourceSubscriber
)
variants and the TestSubscriber
that allows unit testing
Flowable
-based flows.-
Uses of NonNull in io.reactivex.rxjava3.core
Fields in io.reactivex.rxjava3.core with annotations of type NonNullModifier and TypeFieldDescriptionScheduler.DisposeTask.decoratedRun
Scheduler.Worker.PeriodicTask.decoratedRun
Scheduler.PeriodicDirectTask.run
(package private) final @NonNull SequentialDisposable
Scheduler.Worker.PeriodicTask.sd
(package private) final @NonNull Scheduler.Worker
Scheduler.DisposeTask.w
(package private) final @NonNull Scheduler.Worker
Scheduler.PeriodicDirectTask.worker
Methods in io.reactivex.rxjava3.core with annotations of type NonNullModifier and TypeMethodDescriptionstatic @NonNull Completable
Completable.amb
(@NonNull Iterable<@NonNull ? extends CompletableSource> sources) Returns aCompletable
which terminates as soon as one of the sourceCompletable
s in theIterable
sequence terminates (normally or with an error) and disposes all otherCompletable
s.Flowable.amb
(@NonNull Iterable<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources) Mirrors the onePublisher
in anIterable
of severalPublisher
s that first either emits an item or sends a termination notification.Runs multipleMaybeSource
s provided by anIterable
sequence and signals the events of the first one that signals (disposing the rest).static <@NonNull T>
@NonNull Observable<T> Observable.amb
(@NonNull Iterable<@NonNull ? extends ObservableSource<? extends @NonNull T>> sources) Mirrors the oneObservableSource
in anIterable
of severalObservableSource
s that first either emits an item or sends a termination notification.Runs multipleSingleSource
s and signals the events of the first one that signals (disposing the rest).static @NonNull Completable
Completable.ambArray
(@NonNull CompletableSource... sources) Returns aCompletable
which terminates as soon as one of the sourceCompletable
s terminates (normally or with an error) and disposes all otherCompletable
s.Mirrors the onePublisher
in an array of severalPublisher
s that first either emits an item or sends a termination notification.Maybe.ambArray
(@NonNull MaybeSource<? extends @NonNull T>... sources) Runs multipleMaybeSource
s and signals the events of the first one that signals (disposing the rest).static <@NonNull T>
@NonNull Observable<T> Observable.ambArray
(@NonNull ObservableSource<? extends @NonNull T>... sources) Mirrors the oneObservableSource
in an array of severalObservableSource
s that first either emits an item or sends a termination notification.Single.ambArray
(@NonNull SingleSource<? extends @NonNull T>... sources) Runs multipleSingleSource
s and signals the events of the first one that signals (disposing the rest).final @NonNull Completable
Completable.ambWith
(@NonNull CompletableSource other) Returns aCompletable
that emits the a terminated event of either thisCompletable
or the otherCompletableSource
, whichever fires first.Mirrors thePublisher
(current or provided) that first either emits an item or sends a termination notification.Maybe.ambWith
(@NonNull MaybeSource<? extends @NonNull T> other) Mirrors theMaybeSource
(current or provided) that first signals an event.final @NonNull Observable
<T> Observable.ambWith
(@NonNull ObservableSource<? extends @NonNull T> other) Mirrors the currentObservable
or the otherObservableSource
provided of which the first either emits an item or sends a termination notification.Single.ambWith
(@NonNull SingleSource<? extends @NonNull T> other) Signals the event of this or the otherSingleSource
whichever signals first.final @NonNull Completable
Completable.andThen
(@NonNull CompletableSource next) Completable.andThen
(@NonNull MaybeSource<@NonNull T> next) Returns aMaybe
which will subscribe to thisCompletable
and once that is completed then will subscribe to thenext
MaybeSource
.final <@NonNull T>
@NonNull Observable<T> Completable.andThen
(@NonNull ObservableSource<@NonNull T> next) Returns anObservable
which will subscribe to thisCompletable
and once that is completed then will subscribe to thenext
ObservableSource
.Completable.andThen
(@NonNull SingleSource<@NonNull T> next) Returns aSingle
which will subscribe to thisCompletable
and once that is completed then will subscribe to thenext
SingleSource
.Returns aFlowable
which will subscribe to thisCompletable
and once that is completed then will subscribe to thenext
Publisher
.Returns aSingle
that emitstrue
if any item emitted by the currentFlowable
satisfies a specified condition, otherwisefalse
.Returns aSingle
that emitstrue
if any item emitted by the currentObservable
satisfies a specified condition, otherwisefalse
.CompletableOperator.apply
(@NonNull CompletableObserver observer) Applies a function to the childCompletableObserver
and returns a new parentCompletableObserver
.CompletableTransformer.apply
(@NonNull Completable upstream) Applies a function to the upstreamCompletable
and returns aCompletableSource
.FlowableOperator.apply
(@NonNull org.reactivestreams.Subscriber<? super @NonNull Downstream> subscriber) Applies a function to the childSubscriber
and returns a new parentSubscriber
.@NonNull org.reactivestreams.Publisher
<Downstream> Applies a function to the upstreamFlowable
and returns aPublisher
with optionally different element type.Applies a function to the upstreamMaybe
and returns a converted value of typeR
.@NonNull MaybeObserver
<? super Upstream> MaybeOperator.apply
(@NonNull MaybeObserver<? super @NonNull Downstream> observer) Applies a function to the childMaybeObserver
and returns a new parentMaybeObserver
.Applies a function to the upstreamMaybe
and returns aMaybeSource
with optionally different element type.ObservableOperator.apply
(@NonNull Observer<? super @NonNull Downstream> observer) Applies a function to the childObserver
and returns a new parentObserver
.ObservableTransformer.apply
(@NonNull Observable<@NonNull Upstream> upstream) Applies a function to the upstreamObservable
and returns anObservableSource
with optionally different element type.@NonNull SingleObserver
<? super Upstream> SingleOperator.apply
(@NonNull SingleObserver<? super @NonNull Downstream> observer) Applies a function to the childSingleObserver
and returns a new parentSingleObserver
.Applies a function to the upstreamSingle
and returns aSingleSource
with optionally different element type.final T
Flowable.blockingFirst()
Returns the first item emitted by thisFlowable
, or throwsNoSuchElementException
if it emits no items.final T
Flowable.blockingFirst
(@NonNull T defaultItem) Returns the first item emitted by thisFlowable
, or a default value if it emits no items.final T
Observable.blockingFirst()
Returns the first item emitted by the currentObservable
, or throwsNoSuchElementException
if it emits no items.final T
Observable.blockingFirst
(@NonNull T defaultItem) Returns the first item emitted by the currentObservable
, or a default value if it emits no items.final T
Maybe.blockingGet
(@NonNull T defaultValue) Waits in a blocking fashion until the currentMaybe
signals a success value (which is returned), defaultValue if completed or an exception (which is propagated).final T
Single.blockingGet()
Waits in a blocking fashion until the currentSingle
signals a success value (which is returned) or an exception (which is propagated).Flowable.blockingIterable()
Converts thisFlowable
into anIterable
.Flowable.blockingIterable
(int bufferSize) Converts thisFlowable
into anIterable
.Observable.blockingIterable()
Exposes the currentObservable
as anIterable
which, when iterated, subscribes to the currentObservable
and blocks until the currentObservable
emits items or terminates.Observable.blockingIterable
(int capacityHint) Exposes the currentObservable
as anIterable
which, when iterated, subscribes to the currentObservable
and blocks until the currentObservable
emits items or terminates.final T
Flowable.blockingLast()
Returns the last item emitted by thisFlowable
, or throwsNoSuchElementException
if thisFlowable
emits no items.final T
Flowable.blockingLast
(@NonNull T defaultItem) Returns the last item emitted by thisFlowable
, or a default value if it emits no items.final T
Observable.blockingLast()
Returns the last item emitted by the currentObservable
, or throwsNoSuchElementException
if the currentObservable
emits no items.final T
Observable.blockingLast
(@NonNull T defaultItem) Returns the last item emitted by the currentObservable
, or a default value if it emits no items.Flowable.blockingLatest()
Returns anIterable
that returns the latest item emitted by thisFlowable
, waiting if necessary for one to become available.Observable.blockingLatest()
Returns anIterable
that returns the latest item emitted by the currentObservable
, waiting if necessary for one to become available.Flowable.blockingMostRecent
(@NonNull T initialItem) Returns anIterable
that always returns the item most recently emitted by thisFlowable
.Observable.blockingMostRecent
(@NonNull T initialItem) Returns anIterable
that always returns the item most recently emitted by the currentObservable
.Flowable.blockingNext()
Returns anIterable
that blocks until thisFlowable
emits another item, then returns that item.Observable.blockingNext()
Returns anIterable
that blocks until the currentObservable
emits another item, then returns that item.final T
Flowable.blockingSingle()
If thisFlowable
completes after emitting a single item, return that item, otherwise throw aNoSuchElementException
.final T
Flowable.blockingSingle
(@NonNull T defaultItem) If thisFlowable
completes after emitting a single item, return that item; if it emits more than one item, throw anIllegalArgumentException
; if it emits no items, return a default value.final T
Observable.blockingSingle()
If the currentObservable
completes after emitting a single item, return that item, otherwise throw aNoSuchElementException
.final T
Observable.blockingSingle
(@NonNull T defaultItem) If the currentObservable
completes after emitting a single item, return that item; if it emits more than one item, throw anIllegalArgumentException
; if it emits no items, return a default value.Flowable.blockingStream()
Creates a sequentialStream
to consume or process thisFlowable
in a blocking manner via the JavaStream
API.Flowable.blockingStream
(int prefetch) Creates a sequentialStream
to consume or process thisFlowable
in a blocking manner via the JavaStream
API.Observable.blockingStream()
Creates a sequentialStream
to consume or process the currentObservable
in a blocking manner via the JavaStream
API.Observable.blockingStream
(int capacityHint) Creates a sequentialStream
to consume or process the currentObservable
in a blocking manner via the JavaStream
API.Flowable.buffer
(int count) Returns aFlowable
that emits buffers of items it collects from the currentFlowable
.Flowable.buffer
(int count, int skip) Returns aFlowable
that emits buffers of items it collects from the currentFlowable
.Returns aFlowable
that emits buffers of items it collects from the currentFlowable
.Returns aFlowable
that emits buffers of items it collects from the currentFlowable
.Returns aFlowable
that emits buffers of items it collects from the currentFlowable
.Returns aFlowable
that emits buffers of items it collects from the currentFlowable
.Flowable.buffer
(long timespan, long timeskip, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, @NonNull Supplier<@NonNull U> bufferSupplier) Returns aFlowable
that emits buffers of items it collects from the currentFlowable
.Returns aFlowable
that emits buffers of items it collects from the currentFlowable
.Returns aFlowable
that emits buffers of items it collects from the currentFlowable
.Returns aFlowable
that emits buffers of items it collects from the currentFlowable
.Returns aFlowable
that emits buffers of items it collects from the currentFlowable
.Flowable.buffer
(long timespan, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, int count, @NonNull Supplier<@NonNull U> bufferSupplier, boolean restartTimerOnMaxSize) Returns aFlowable
that emits buffers of items it collects from the currentFlowable
.Flowable.buffer
(@NonNull org.reactivestreams.Publisher<? extends @NonNull TOpening> openingIndicator, @NonNull Function<? super @NonNull TOpening, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull TClosing>> closingIndicator) Returns aFlowable
that emits buffers of items it collects from the currentFlowable
.final <@NonNull TOpening,
@NonNull TClosing, @NonNull U extends Collection<? super @NonNull T>>
@NonNull Flowable<U> Flowable.buffer
(@NonNull org.reactivestreams.Publisher<? extends @NonNull TOpening> openingIndicator, @NonNull Function<? super @NonNull TOpening, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull TClosing>> closingIndicator, @NonNull Supplier<@NonNull U> bufferSupplier) Returns aFlowable
that emits buffers of items it collects from the currentFlowable
.Returns aFlowable
that emits non-overlapping buffered items from the currentFlowable
each time the specified boundaryPublisher
emits an item.Flowable.buffer
(@NonNull org.reactivestreams.Publisher<@NonNull B> boundaryIndicator, int initialCapacity) Returns aFlowable
that emits non-overlapping buffered items from the currentFlowable
each time the specified boundaryPublisher
emits an item.Flowable.buffer
(@NonNull org.reactivestreams.Publisher<@NonNull B> boundaryIndicator, @NonNull Supplier<@NonNull U> bufferSupplier) Returns aFlowable
that emits non-overlapping buffered items from the currentFlowable
each time the specified boundaryPublisher
emits an item.final @NonNull Observable
<@NonNull List<T>> Observable.buffer
(int count) Returns anObservable
that emits buffers of items it collects from the currentObservable
.final @NonNull Observable
<@NonNull List<T>> Observable.buffer
(int count, int skip) Returns anObservable
that emits buffers of items it collects from the currentObservable
.final <@NonNull U extends Collection<? super @NonNull T>>
@NonNull Observable<U> Returns anObservable
that emits buffers of items it collects from the currentObservable
.final <@NonNull U extends Collection<? super @NonNull T>>
@NonNull Observable<U> Returns anObservable
that emits buffers of items it collects from the currentObservable
.final @NonNull Observable
<@NonNull List<T>> Returns anObservable
that emits buffers of items it collects from the currentObservable
.final @NonNull Observable
<@NonNull List<T>> Observable.buffer
(long timespan, long timeskip, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Returns anObservable
that emits buffers of items it collects from the currentObservable
.final <@NonNull U extends Collection<? super @NonNull T>>
@NonNull Observable<U> Observable.buffer
(long timespan, long timeskip, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, @NonNull Supplier<@NonNull U> bufferSupplier) Returns anObservable
that emits buffers of items it collects from the currentObservable
.final @NonNull Observable
<@NonNull List<T>> Returns anObservable
that emits buffers of items it collects from the currentObservable
.final @NonNull Observable
<@NonNull List<T>> Returns anObservable
that emits buffers of items it collects from the currentObservable
.final @NonNull Observable
<@NonNull List<T>> Returns anObservable
that emits buffers of items it collects from the currentObservable
.final @NonNull Observable
<@NonNull List<T>> Returns anObservable
that emits buffers of items it collects from the currentObservable
.final <@NonNull U extends Collection<? super @NonNull T>>
@NonNull Observable<U> Observable.buffer
(long timespan, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, int count, @NonNull Supplier<@NonNull U> bufferSupplier, boolean restartTimerOnMaxSize) Returns anObservable
that emits buffers of items it collects from the currentObservable
.Observable.buffer
(@NonNull ObservableSource<? extends @NonNull TOpening> openingIndicator, @NonNull Function<? super @NonNull TOpening, ? extends ObservableSource<? extends @NonNull TClosing>> closingIndicator) Returns anObservable
that emits buffers of items it collects from the currentObservable
.final <@NonNull TOpening,
@NonNull TClosing, @NonNull U extends Collection<? super @NonNull T>>
@NonNull Observable<U> Observable.buffer
(@NonNull ObservableSource<? extends @NonNull TOpening> openingIndicator, @NonNull Function<? super @NonNull TOpening, ? extends ObservableSource<? extends @NonNull TClosing>> closingIndicator, @NonNull Supplier<@NonNull U> bufferSupplier) Returns anObservable
that emits buffers of items it collects from the currentObservable
.Observable.buffer
(@NonNull ObservableSource<@NonNull B> boundaryIndicator) Returns anObservable
that emits non-overlapping buffered items from the currentObservable
each time the specified boundaryObservableSource
emits an item.Observable.buffer
(@NonNull ObservableSource<@NonNull B> boundaryIndicator, int initialCapacity) Returns anObservable
that emits non-overlapping buffered items from the currentObservable
each time the specified boundaryObservableSource
emits an item.final <@NonNull B,
@NonNull U extends Collection<? super @NonNull T>>
@NonNull Observable<U> Observable.buffer
(@NonNull ObservableSource<@NonNull B> boundaryIndicator, @NonNull Supplier<@NonNull U> bufferSupplier) Returns anObservable
that emits non-overlapping buffered items from the currentObservable
each time the specified boundaryObservableSource
emits an item.final @NonNull Completable
Completable.cache()
Subscribes to thisCompletable
only once, when the firstCompletableObserver
subscribes to the resultCompletable
, caches its terminal event and relays/replays it to observers.Flowable.cache()
Returns aFlowable
that subscribes to thisPublisher
lazily, caches all of its events and replays them, in the same order as received, to all the downstream subscribers.Maybe.cache()
Returns aMaybe
that subscribes to thisMaybe
lazily, caches its event and replays it, to all the downstream subscribers.final @NonNull Observable
<T> Observable.cache()
Returns anObservable
that subscribes to the currentObservable
lazily, caches all of its events and replays them, in the same order as received, to all the downstream observers.Single.cache()
Stores the success value or exception from the currentSingle
and replays it to lateSingleObserver
s.Flowable.cacheWithInitialCapacity
(int initialCapacity) Returns aFlowable
that subscribes to thisPublisher
lazily, caches all of its events and replays them, in the same order as received, to all the downstream subscribers.final @NonNull Observable
<T> Observable.cacheWithInitialCapacity
(int initialCapacity) Returns anObservable
that subscribes to the currentObservable
lazily, caches all of its events and replays them, in the same order as received, to all the downstream observers.Returns aFlowable
that emits the upstream items while they can be cast viaClass.cast(Object)
until the upstream terminates, or until the upstream signals an item which can't be cast, resulting in aClassCastException
to be signaled to the downstream.Casts the success value of the currentMaybe
into the target type or signals aClassCastException
if not compatible.final <@NonNull U>
@NonNull Observable<U> Returns anObservable
that emits the upstream items while they can be cast viaClass.cast(Object)
until the upstream terminates, or until the upstream signals an item which can't be cast, resulting in aClassCastException
to be signaled to the downstream.Casts the success value of the currentSingle
into the target type or signals aClassCastException
if not compatible.Flowable.collect
(@NonNull Supplier<? extends @NonNull U> initialItemSupplier, @NonNull BiConsumer<? super @NonNull U, ? super @NonNull T> collector) Collects items emitted by the finite sourcePublisher
into a single mutable data structure and returns aSingle
that emits this structure.Observable.collect
(@NonNull Supplier<? extends @NonNull U> initialItemSupplier, @NonNull BiConsumer<? super @NonNull U, ? super @NonNull T> collector) Collects items emitted by the finite sourceObservable
into a single mutable data structure and returns aSingle
that emits this structure.Flowable.collectInto
(@NonNull U initialItem, @NonNull BiConsumer<? super @NonNull U, ? super @NonNull T> collector) Collects items emitted by the finite sourcePublisher
into a single mutable data structure and returns aSingle
that emits this structure.Observable.collectInto
(@NonNull U initialItem, @NonNull BiConsumer<? super @NonNull U, ? super @NonNull T> collector) Collects items emitted by the finite sourceObservable
into a single mutable data structure and returns aSingle
that emits this structure.Flowable.combineLatest
(@NonNull Iterable<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources, @NonNull Function<? super Object[], ? extends @NonNull R> combiner) Combines a collection of sourcePublisher
s by emitting an item that aggregates the latest values of each of the sourcePublisher
s each time an item is received from any of the sourcePublisher
s, where this aggregation is defined by a specified function.Flowable.combineLatest
(@NonNull Iterable<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources, @NonNull Function<? super Object[], ? extends @NonNull R> combiner, int bufferSize) Combines a collection of sourcePublisher
s by emitting an item that aggregates the latest values of each of the sourcePublisher
s each time an item is received from any of the sourcePublisher
s, where this aggregation is defined by a specified function.Flowable.combineLatest
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull BiFunction<? super @NonNull T1, ? super @NonNull T2, ? extends @NonNull R> combiner) Combines two sourcePublisher
s by emitting an item that aggregates the latest values of each of the sourcePublisher
s each time an item is received from either of the sourcePublisher
s, where this aggregation is defined by a specified function.Flowable.combineLatest
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull Function3<? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, ? extends @NonNull R> combiner) Combines three sourcePublisher
s by emitting an item that aggregates the latest values of each of the sourcePublisher
s each time an item is received from any of the sourcePublisher
s, where this aggregation is defined by a specified function.Flowable.combineLatest
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull Function4<? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, ? super @NonNull T4, ? extends @NonNull R> combiner) Combines four sourcePublisher
s by emitting an item that aggregates the latest values of each of the sourcePublisher
s each time an item is received from any of the sourcePublisher
s, where this aggregation is defined by a specified function.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull R>
@NonNull Flowable<R> Flowable.combineLatest
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull org.reactivestreams.Publisher<? extends @NonNull T5> source5, @NonNull Function5<? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, ? super @NonNull T4, ? super @NonNull T5, ? extends @NonNull R> combiner) Combines five sourcePublisher
s by emitting an item that aggregates the latest values of each of the sourcePublisher
s each time an item is received from any of the sourcePublisher
s, where this aggregation is defined by a specified function.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull R>
@NonNull Flowable<R> Flowable.combineLatest
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull org.reactivestreams.Publisher<? extends @NonNull T5> source5, @NonNull org.reactivestreams.Publisher<? 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> combiner) Combines six sourcePublisher
s by emitting an item that aggregates the latest values of each of the sourcePublisher
s each time an item is received from any of the sourcePublisher
s, where this aggregation is defined by a specified function.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull R>
@NonNull Flowable<R> Flowable.combineLatest
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull org.reactivestreams.Publisher<? extends @NonNull T5> source5, @NonNull org.reactivestreams.Publisher<? extends @NonNull T6> source6, @NonNull org.reactivestreams.Publisher<? 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> combiner) Combines seven sourcePublisher
s by emitting an item that aggregates the latest values of each of the sourcePublisher
s each time an item is received from any of the sourcePublisher
s, where this aggregation is defined by a specified function.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull R>
@NonNull Flowable<R> Flowable.combineLatest
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull org.reactivestreams.Publisher<? extends @NonNull T5> source5, @NonNull org.reactivestreams.Publisher<? extends @NonNull T6> source6, @NonNull org.reactivestreams.Publisher<? extends @NonNull T7> source7, @NonNull org.reactivestreams.Publisher<? 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> combiner) Combines eight sourcePublisher
s by emitting an item that aggregates the latest values of each of the sourcePublisher
s each time an item is received from any of the sourcePublisher
s, where this aggregation is defined by a specified function.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull T9, @NonNull R>
@NonNull Flowable<R> Flowable.combineLatest
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull org.reactivestreams.Publisher<? extends @NonNull T5> source5, @NonNull org.reactivestreams.Publisher<? extends @NonNull T6> source6, @NonNull org.reactivestreams.Publisher<? extends @NonNull T7> source7, @NonNull org.reactivestreams.Publisher<? extends @NonNull T8> source8, @NonNull org.reactivestreams.Publisher<? 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> combiner) Combines nine sourcePublisher
s by emitting an item that aggregates the latest values of each of the sourcePublisher
s each time an item is received from any of the sourcePublisher
s, where this aggregation is defined by a specified function.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull T9, @NonNull R>
@NonNull Observable<R> Observable.combineLatest
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull ObservableSource<? extends @NonNull T5> source5, @NonNull ObservableSource<? extends @NonNull T6> source6, @NonNull ObservableSource<? extends @NonNull T7> source7, @NonNull ObservableSource<? extends @NonNull T8> source8, @NonNull ObservableSource<? 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> combiner) Combines nine sourceObservableSource
s by emitting an item that aggregates the latest values of each of theObservableSource
s each time an item is received from any of theObservableSource
s, where this aggregation is defined by a specified function.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull R>
@NonNull Observable<R> Observable.combineLatest
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull ObservableSource<? extends @NonNull T5> source5, @NonNull ObservableSource<? extends @NonNull T6> source6, @NonNull ObservableSource<? extends @NonNull T7> source7, @NonNull ObservableSource<? 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> combiner) Combines eight sourceObservableSource
s by emitting an item that aggregates the latest values of each of theObservableSource
s each time an item is received from any of theObservableSource
s, where this aggregation is defined by a specified function.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull R>
@NonNull Observable<R> Observable.combineLatest
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull ObservableSource<? extends @NonNull T5> source5, @NonNull ObservableSource<? extends @NonNull T6> source6, @NonNull ObservableSource<? 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> combiner) Combines seven sourceObservableSource
s by emitting an item that aggregates the latest values of each of theObservableSource
s each time an item is received from any of theObservableSource
s, where this aggregation is defined by a specified function.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull R>
@NonNull Observable<R> Observable.combineLatest
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull ObservableSource<? extends @NonNull T5> source5, @NonNull ObservableSource<? 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> combiner) Combines six sourceObservableSource
s by emitting an item that aggregates the latest values of each of theObservableSource
s each time an item is received from any of theObservableSource
s, where this aggregation is defined by a specified function.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull R>
@NonNull Observable<R> Observable.combineLatest
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull ObservableSource<? extends @NonNull T5> source5, @NonNull Function5<? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, ? super @NonNull T4, ? super @NonNull T5, ? extends @NonNull R> combiner) Combines five sourceObservableSource
s by emitting an item that aggregates the latest values of each of theObservableSource
s each time an item is received from any of theObservableSource
s, where this aggregation is defined by a specified function.Observable.combineLatest
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull Function4<? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, ? super @NonNull T4, ? extends @NonNull R> combiner) Combines four sourceObservableSource
s by emitting an item that aggregates the latest values of each of theObservableSource
s each time an item is received from any of theObservableSource
s, where this aggregation is defined by a specified function.Observable.combineLatest
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull Function3<? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, ? extends @NonNull R> combiner) Combines three sourceObservableSource
s by emitting an item that aggregates the latest values of each of theObservableSource
s each time an item is received from any of theObservableSource
s, where this aggregation is defined by a specified function.static <@NonNull T1,
@NonNull T2, @NonNull R>
@NonNull Observable<R> Observable.combineLatest
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull BiFunction<? super @NonNull T1, ? super @NonNull T2, ? extends @NonNull R> combiner) Combines two sourceObservableSource
s by emitting an item that aggregates the latest values of each of theObservableSource
s each time an item is received from either of theObservableSource
s, where this aggregation is defined by a specified function.static <@NonNull T,
@NonNull R>
@NonNull Observable<R> Observable.combineLatest
(@NonNull Iterable<@NonNull ? extends ObservableSource<? extends @NonNull T>> sources, @NonNull Function<? super Object[], ? extends @NonNull R> combiner) Combines a collection of sourceObservableSource
s by emitting an item that aggregates the latest values of each of the returnedObservableSource
s each time an item is received from any of the returnedObservableSource
s, where this aggregation is defined by a specified function.static <@NonNull T,
@NonNull R>
@NonNull Observable<R> Observable.combineLatest
(@NonNull Iterable<@NonNull ? extends ObservableSource<? extends @NonNull T>> sources, @NonNull Function<? super Object[], ? extends @NonNull R> combiner, int bufferSize) Combines anIterable
of sourceObservableSource
s by emitting an item that aggregates the latest values of each of the returnedObservableSource
s each time an item is received from any of the returnedObservableSource
s, where this aggregation is defined by a specified function.Flowable.combineLatestArray
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T>[] sources, @NonNull Function<? super Object[], ? extends @NonNull R> combiner) Combines a collection of sourcePublisher
s by emitting an item that aggregates the latest values of each of the sourcePublisher
s each time an item is received from any of the sourcePublisher
s, where this aggregation is defined by a specified function.Flowable.combineLatestArray
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T>[] sources, @NonNull Function<? super Object[], ? extends @NonNull R> combiner, int bufferSize) Combines a collection of sourcePublisher
s by emitting an item that aggregates the latest values of each of the sourcePublisher
s each time an item is received from any of the sourcePublisher
s, where this aggregation is defined by a specified function.static <@NonNull T,
@NonNull R>
@NonNull Observable<R> Observable.combineLatestArray
(@NonNull ObservableSource<? extends @NonNull T>[] sources, @NonNull Function<? super Object[], ? extends @NonNull R> combiner) Combines an array of sourceObservableSource
s by emitting an item that aggregates the latest values of each of theObservableSource
s each time an item is received from any of the returnedObservableSource
s, where this aggregation is defined by a specified function.static <@NonNull T,
@NonNull R>
@NonNull Observable<R> Observable.combineLatestArray
(@NonNull ObservableSource<? extends @NonNull T>[] sources, @NonNull Function<? super Object[], ? extends @NonNull R> combiner, int bufferSize) Combines an array of sourceObservableSource
s by emitting an item that aggregates the latest values of each of theObservableSource
s each time an item is received from any of theObservableSource
s, where this aggregation is defined by a specified function.Flowable.combineLatestArrayDelayError
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T>[] sources, @NonNull Function<? super Object[], ? extends @NonNull R> combiner) Combines a collection of sourcePublisher
s by emitting an item that aggregates the latest values of each of the sourcePublisher
s each time an item is received from any of the sourcePublisher
s, where this aggregation is defined by a specified function.Flowable.combineLatestArrayDelayError
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T>[] sources, @NonNull Function<? super Object[], ? extends @NonNull R> combiner, int bufferSize) Combines a collection of sourcePublisher
s by emitting an item that aggregates the latest values of each of the sourcePublisher
s each time an item is received from any of the sourcePublisher
s, where this aggregation is defined by a specified function and delays any error from the sources until all sourcePublisher
s terminate.static <@NonNull T,
@NonNull R>
@NonNull Observable<R> Observable.combineLatestArrayDelayError
(@NonNull ObservableSource<? extends @NonNull T>[] sources, @NonNull Function<? super Object[], ? extends @NonNull R> combiner) Combines an array ofObservableSource
s by emitting an item that aggregates the latest values of each of theObservableSource
s each time an item is received from any of theObservableSource
s, where this aggregation is defined by a specified function.static <@NonNull T,
@NonNull R>
@NonNull Observable<R> Observable.combineLatestArrayDelayError
(@NonNull ObservableSource<? extends @NonNull T>[] sources, @NonNull Function<? super Object[], ? extends @NonNull R> combiner, int bufferSize) Combines an array ofObservableSource
s by emitting an item that aggregates the latest values of each of theObservableSource
s each time an item is received from any of theObservableSource
s, where this aggregation is defined by a specified function and delays any error from the sources until all sourceObservableSource
s terminate.Flowable.combineLatestDelayError
(@NonNull Iterable<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources, @NonNull Function<? super Object[], ? extends @NonNull R> combiner) Combines a collection of sourcePublisher
s by emitting an item that aggregates the latest values of each of the sourcePublisher
s each time an item is received from any of the sourcePublisher
s, where this aggregation is defined by a specified function and delays any error from the sources until all sourcePublisher
s terminate.Flowable.combineLatestDelayError
(@NonNull Iterable<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources, @NonNull Function<? super Object[], ? extends @NonNull R> combiner, int bufferSize) Combines a collection of sourcePublisher
s by emitting an item that aggregates the latest values of each of the sourcePublisher
s each time an item is received from any of the sourcePublisher
s, where this aggregation is defined by a specified function and delays any error from the sources until all sourcePublisher
s terminate.static <@NonNull T,
@NonNull R>
@NonNull Observable<R> Observable.combineLatestDelayError
(@NonNull Iterable<@NonNull ? extends ObservableSource<? extends @NonNull T>> sources, @NonNull Function<? super Object[], ? extends @NonNull R> combiner) Combines anIterable
ofObservableSource
s by emitting an item that aggregates the latest values of each of theObservableSource
s each time an item is received from any of theObservableSource
s, where this aggregation is defined by a specified function and delays any error from the sources until all sourceObservableSource
s terminate.static <@NonNull T,
@NonNull R>
@NonNull Observable<R> Observable.combineLatestDelayError
(@NonNull Iterable<@NonNull ? extends ObservableSource<? extends @NonNull T>> sources, @NonNull Function<? super Object[], ? extends @NonNull R> combiner, int bufferSize) Combines anIterable
ofObservableSource
s by emitting an item that aggregates the latest values of each of theObservableSource
s each time an item is received from any of theObservableSource
s, where this aggregation is defined by a specified function and delays any error from the sources until all sourceObservableSource
s terminate.static @NonNull Completable
Completable.complete()
Returns aCompletable
instance that completes immediately when subscribed to.final @NonNull Completable
Completable.compose
(@NonNull CompletableTransformer transformer) Calls the given transformer function with this instance and returns the function's resultingCompletableSource
wrapped withCompletable.wrap(CompletableSource)
.Transform the currentFlowable
by applying a particularFlowableTransformer
function to it.Transform aMaybe
by applying a particularMaybeTransformer
function to it.final <@NonNull R>
@NonNull Observable<R> Observable.compose
(@NonNull ObservableTransformer<? super @NonNull T, ? extends @NonNull R> composer) Transform the currentObservable
by applying a particularObservableTransformer
function to it.Transform aSingle
by applying a particularSingleTransformer
function to it.static @NonNull Completable
Completable.concat
(@NonNull Iterable<@NonNull ? extends CompletableSource> sources) Returns aCompletable
which completes only when all sources complete, one after another.static @NonNull Completable
Completable.concat
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends CompletableSource> sources) Returns aCompletable
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 aCompletable
which completes only when all sources complete, one after another.Flowable.concat
(@NonNull Iterable<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources) Concatenates elements of eachPublisher
provided via anIterable
sequence into a single sequence of elements without interleaving them.Flowable.concat
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source2) Returns aFlowable
that emits the items emitted by twoPublisher
s, one after the other, without interleaving them.Flowable.concat
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source3) Returns aFlowable
that emits the items emitted by threePublisher
s, one after the other, without interleaving them.Flowable.concat
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source4) Returns aFlowable
that emits the items emitted by fourPublisher
s, one after the other, without interleaving them.Flowable.concat
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources) Returns aFlowable
that emits the items emitted by each of thePublisher
s emitted by the sourcePublisher
, one after the other, without interleaving them.Flowable.concat
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources, int prefetch) Returns aFlowable
that emits the items emitted by each of thePublisher
s emitted by the sourcePublisher
, one after the other, without interleaving them.Maybe.concat
(@NonNull MaybeSource<? extends @NonNull T> source1, @NonNull MaybeSource<? extends @NonNull T> source2) Returns aFlowable
that emits the items emitted by twoMaybeSource
s, one after the other.Maybe.concat
(@NonNull MaybeSource<? extends @NonNull T> source1, @NonNull MaybeSource<? extends @NonNull T> source2, @NonNull MaybeSource<? extends @NonNull T> source3) Returns aFlowable
that emits the items emitted by threeMaybeSource
s, one after the other.Maybe.concat
(@NonNull MaybeSource<? extends @NonNull T> source1, @NonNull MaybeSource<? extends @NonNull T> source2, @NonNull MaybeSource<? extends @NonNull T> source3, @NonNull MaybeSource<? extends @NonNull T> source4) Returns aFlowable
that emits the items emitted by fourMaybeSource
s, one after the other.Concatenate the single values, in a non-overlapping fashion, of theMaybeSource
sources provided by anIterable
sequence as aFlowable
sequence.Maybe.concat
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources) Concatenate the single values, in a non-overlapping fashion, of theMaybeSource
sources provided by aPublisher
sequence as aFlowable
sequence.Maybe.concat
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources, int prefetch) Concatenate the single values, in a non-overlapping fashion, of theMaybeSource
sources provided by aPublisher
sequence as aFlowable
sequence.static <@NonNull T>
@NonNull Observable<T> Observable.concat
(@NonNull ObservableSource<? extends ObservableSource<? extends @NonNull T>> sources) Returns anObservable
that emits the items emitted by each of theObservableSource
s emitted by theObservableSource
, one after the other, without interleaving them.static <@NonNull T>
@NonNull Observable<T> Observable.concat
(@NonNull ObservableSource<? extends ObservableSource<? extends @NonNull T>> sources, int bufferSize) Returns anObservable
that emits the items emitted by each of theObservableSource
s emitted by the outerObservableSource
, one after the other, without interleaving them.static <@NonNull T>
@NonNull Observable<T> Observable.concat
(@NonNull ObservableSource<? extends @NonNull T> source1, @NonNull ObservableSource<? extends @NonNull T> source2, @NonNull ObservableSource<? extends @NonNull T> source3) Returns anObservable
that emits the items emitted by threeObservableSource
s, one after the other, without interleaving them.static <@NonNull T>
@NonNull Observable<T> Observable.concat
(@NonNull ObservableSource<? extends @NonNull T> source1, @NonNull ObservableSource<? extends @NonNull T> source2, @NonNull ObservableSource<? extends @NonNull T> source3, @NonNull ObservableSource<? extends @NonNull T> source4) Returns anObservable
that emits the items emitted by fourObservableSource
s, one after the other, without interleaving them.static <@NonNull T>
@NonNull Observable<T> Observable.concat
(@NonNull ObservableSource<? extends @NonNull T> source1, ObservableSource<? extends @NonNull T> source2) Returns anObservable
that emits the items emitted by twoObservableSource
s, one after the other, without interleaving them.static <@NonNull T>
@NonNull Observable<T> Observable.concat
(@NonNull Iterable<@NonNull ? extends ObservableSource<? extends @NonNull T>> sources) Concatenates elements of eachObservableSource
provided via anIterable
sequence into a single sequence of elements without interleaving them.static <@NonNull T>
@NonNull Observable<T> Single.concat
(@NonNull ObservableSource<? extends SingleSource<? extends @NonNull T>> sources) Concatenate the single values, in a non-overlapping fashion, of theSingleSource
s provided by anObservableSource
sequence.Single.concat
(@NonNull SingleSource<? extends @NonNull T> source1, @NonNull SingleSource<? extends @NonNull T> source2) Returns aFlowable
that emits the items emitted by twoSingleSource
s, one after the other.Single.concat
(@NonNull SingleSource<? extends @NonNull T> source1, @NonNull SingleSource<? extends @NonNull T> source2, @NonNull SingleSource<? extends @NonNull T> source3) Returns aFlowable
that emits the items emitted by threeSingleSource
s, one after the other.Single.concat
(@NonNull SingleSource<? extends @NonNull T> source1, @NonNull SingleSource<? extends @NonNull T> source2, @NonNull SingleSource<? extends @NonNull T> source3, @NonNull SingleSource<? extends @NonNull T> source4) Returns aFlowable
that emits the items emitted by fourSingleSource
s, one after the other.Concatenate the single values, in a non-overlapping fashion, of theSingleSource
s provided by anIterable
sequence.Single.concat
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends SingleSource<? extends @NonNull T>> sources) Concatenate the single values, in a non-overlapping fashion, of theSingleSource
s provided by aPublisher
sequence.Single.concat
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends SingleSource<? extends @NonNull T>> sources, int prefetch) Concatenate the single values, in a non-overlapping fashion, of theSingleSource
s provided by aPublisher
sequence and prefetched by the specified amount.static @NonNull Completable
Completable.concatArray
(@NonNull CompletableSource... sources) Returns aCompletable
which completes only when all sources complete, one after another.Flowable.concatArray
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T>... sources) Concatenates a variable number ofPublisher
sources.Maybe.concatArray
(@NonNull MaybeSource<? extends @NonNull T>... sources) Concatenate the single values, in a non-overlapping fashion, of theMaybeSource
sources in the array as aFlowable
sequence.static <@NonNull T>
@NonNull Observable<T> Observable.concatArray
(@NonNull ObservableSource<? extends @NonNull T>... sources) Concatenates a variable number ofObservableSource
sources.Single.concatArray
(@NonNull SingleSource<? extends @NonNull T>... sources) Concatenate the single values, in a non-overlapping fashion, of theSingleSource
s provided in an array.static @NonNull Completable
Completable.concatArrayDelayError
(@NonNull CompletableSource... sources) Returns aCompletable
which completes only when all sources complete, one after another.Flowable.concatArrayDelayError
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T>... sources) Concatenates a variable number ofPublisher
sources and delays errors from any of them till all terminate.Maybe.concatArrayDelayError
(@NonNull MaybeSource<? extends @NonNull T>... sources) Concatenates a variable number ofMaybeSource
sources and delays errors from any of them till all terminate as aFlowable
sequence.static <@NonNull T>
@NonNull Observable<T> Observable.concatArrayDelayError
(@NonNull ObservableSource<? extends @NonNull T>... sources) Concatenates a variable number ofObservableSource
sources and delays errors from any of them till all terminate.Single.concatArrayDelayError
(@NonNull SingleSource<? extends @NonNull T>... sources) Concatenate the single values, in a non-overlapping fashion, of theSingleSource
s provided in an array.Flowable.concatArrayEager
(int maxConcurrency, int prefetch, @NonNull org.reactivestreams.Publisher<? extends @NonNull T>... sources) Concatenates an array ofPublisher
s eagerly into a single stream of values.Flowable.concatArrayEager
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T>... sources) Concatenates an array ofPublisher
s eagerly into a single stream of values.Maybe.concatArrayEager
(@NonNull MaybeSource<? extends @NonNull T>... sources) Concatenates a sequence ofMaybeSource
eagerly into aFlowable
sequence.static <@NonNull T>
@NonNull Observable<T> Observable.concatArrayEager
(int maxConcurrency, int bufferSize, @NonNull ObservableSource<? extends @NonNull T>... sources) Concatenates an array ofObservableSource
s eagerly into a single stream of values.static <@NonNull T>
@NonNull Observable<T> Observable.concatArrayEager
(@NonNull ObservableSource<? extends @NonNull T>... sources) Concatenates an array ofObservableSource
s eagerly into a single stream of values.Single.concatArrayEager
(@NonNull SingleSource<? extends @NonNull T>... sources) Concatenates a sequence ofSingleSource
eagerly into a single stream of values.Flowable.concatArrayEagerDelayError
(int maxConcurrency, int prefetch, @NonNull org.reactivestreams.Publisher<? extends @NonNull T>... sources) Concatenates an array ofPublisher
s eagerly into a single stream of values and delaying any errors until all sources terminate.Flowable.concatArrayEagerDelayError
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T>... sources) Concatenates an array ofPublisher
s eagerly into a single stream of values and delaying any errors until all sources terminate.Maybe.concatArrayEagerDelayError
(@NonNull MaybeSource<? extends @NonNull T>... sources) Concatenates a sequence ofMaybeSource
eagerly into aFlowable
sequence.static <@NonNull T>
@NonNull Observable<T> Observable.concatArrayEagerDelayError
(int maxConcurrency, int bufferSize, @NonNull ObservableSource<? extends @NonNull T>... sources) Concatenates an array ofObservableSource
s eagerly into a single stream of values and delaying any errors until all sources terminate.static <@NonNull T>
@NonNull Observable<T> Observable.concatArrayEagerDelayError
(@NonNull ObservableSource<? extends @NonNull T>... sources) Concatenates an array ofObservableSource
s eagerly into a single stream of values and delaying any errors until all sources terminate.Single.concatArrayEagerDelayError
(@NonNull SingleSource<? extends @NonNull T>... sources) Concatenates a sequence ofSingleSource
eagerly into a single stream of values.static @NonNull Completable
Completable.concatDelayError
(@NonNull Iterable<@NonNull ? extends CompletableSource> sources) Returns aCompletable
which completes only when all sources complete, one after another.static @NonNull Completable
Completable.concatDelayError
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends CompletableSource> sources) Returns aCompletable
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 aCompletable
which completes only when all sources complete, one after another.Flowable.concatDelayError
(@NonNull Iterable<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources) Concatenates theIterable
sequence ofPublisher
s into a single sequence by subscribing to eachPublisher
, one after the other, one at a time and delays any errors till the all innerPublisher
s terminate.Flowable.concatDelayError
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources) Concatenates thePublisher
sequence ofPublisher
s into a single sequence by subscribing to each innerPublisher
, one after the other, one at a time and delays any errors till the all inner and the outerPublisher
s terminate.Flowable.concatDelayError
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources, int prefetch, boolean tillTheEnd) Concatenates thePublisher
sequence ofPublisher
s into a single sequence by subscribing to each innerPublisher
, one after the other, one at a time and delays any errors till the all inner and the outerPublisher
s terminate.Maybe.concatDelayError
(@NonNull Iterable<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources) Concatenates theIterable
sequence ofMaybeSource
s into a single sequence by subscribing to eachMaybeSource
, one after the other, one at a time and delays any errors till the all innerMaybeSource
s terminate as aFlowable
sequence.Maybe.concatDelayError
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources) Concatenates thePublisher
sequence ofMaybeSource
s into a single sequence by subscribing to each innerMaybeSource
, one after the other, one at a time and delays any errors till the all inner and the outerPublisher
terminate as aFlowable
sequence.Maybe.concatDelayError
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources, int prefetch) Concatenates thePublisher
sequence ofMaybeSource
s into a single sequence by subscribing to each innerMaybeSource
, one after the other, one at a time and delays any errors till the all inner and the outerPublisher
terminate as aFlowable
sequence.static <@NonNull T>
@NonNull Observable<T> Observable.concatDelayError
(@NonNull ObservableSource<? extends ObservableSource<? extends @NonNull T>> sources) Concatenates theObservableSource
sequence ofObservableSource
s into a singleObservable
sequence by subscribing to each innerObservableSource
, one after the other, one at a time and delays any errors till the all inner and the outerObservableSource
s terminate.static <@NonNull T>
@NonNull Observable<T> Observable.concatDelayError
(@NonNull ObservableSource<? extends ObservableSource<? extends @NonNull T>> sources, int bufferSize, boolean tillTheEnd) Concatenates theObservableSource
sequence ofObservableSource
s into a single sequence by subscribing to each innerObservableSource
, one after the other, one at a time and delays any errors till the all inner and the outerObservableSource
s terminate.static <@NonNull T>
@NonNull Observable<T> Observable.concatDelayError
(@NonNull Iterable<@NonNull ? extends ObservableSource<? extends @NonNull T>> sources) Concatenates theIterable
sequence ofObservableSource
s into a singleObservable
sequence by subscribing to eachObservableSource
, one after the other, one at a time and delays any errors till the all innerObservableSource
s terminate.Single.concatDelayError
(@NonNull Iterable<@NonNull ? extends SingleSource<? extends @NonNull T>> sources) Concatenates theIterable
sequence ofSingleSource
s into a single sequence by subscribing to eachSingleSource
, one after the other, one at a time and delays any errors till the all innerSingleSource
s terminate as aFlowable
sequence.Single.concatDelayError
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends SingleSource<? extends @NonNull T>> sources) Concatenates thePublisher
sequence ofSingleSource
s into a single sequence by subscribing to each innerSingleSource
, one after the other, one at a time and delays any errors till the all inner and the outerPublisher
terminate as aFlowable
sequence.Single.concatDelayError
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends SingleSource<? extends @NonNull T>> sources, int prefetch) Concatenates thePublisher
sequence ofSingleSource
s into a single sequence by subscribing to each innerSingleSource
, one after the other, one at a time and delays any errors till the all inner and the outerPublisher
terminate as aFlowable
sequence.Flowable.concatEager
(@NonNull Iterable<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources) Concatenates a sequence ofPublisher
s eagerly into a single stream of values.Flowable.concatEager
(@NonNull Iterable<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources, int maxConcurrency, int prefetch) Concatenates a sequence ofPublisher
s eagerly into a single stream of values and runs a limited number of inner sequences at once.Flowable.concatEager
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources) Concatenates aPublisher
sequence ofPublisher
s eagerly into a single stream of values.Flowable.concatEager
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources, int maxConcurrency, int prefetch) Concatenates aPublisher
sequence ofPublisher
s eagerly into a single stream of values and runs a limited number of inner sequences at once.Maybe.concatEager
(@NonNull Iterable<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources) Concatenates a sequence ofMaybeSource
s eagerly into aFlowable
sequence.Maybe.concatEager
(@NonNull Iterable<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources, int maxConcurrency) Concatenates a sequence ofMaybeSource
s eagerly into aFlowable
sequence and runs a limited number of the inner sequences at once.Maybe.concatEager
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources) Maybe.concatEager
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources, int maxConcurrency) Concatenates aPublisher
sequence ofMaybeSource
s eagerly into aFlowable
sequence, running at most the given number of innerMaybeSource
s at once.static <@NonNull T>
@NonNull Observable<T> Observable.concatEager
(@NonNull ObservableSource<? extends ObservableSource<? extends @NonNull T>> sources) Concatenates anObservableSource
sequence ofObservableSource
s eagerly into a single stream of values.static <@NonNull T>
@NonNull Observable<T> Observable.concatEager
(@NonNull ObservableSource<? extends ObservableSource<? extends @NonNull T>> sources, int maxConcurrency, int bufferSize) Concatenates anObservableSource
sequence ofObservableSource
s eagerly into a single stream of values and runs a limited number of inner sequences at once.static <@NonNull T>
@NonNull Observable<T> Observable.concatEager
(@NonNull Iterable<@NonNull ? extends ObservableSource<? extends @NonNull T>> sources) Concatenates a sequence ofObservableSource
s eagerly into a single stream of values.static <@NonNull T>
@NonNull Observable<T> Observable.concatEager
(@NonNull Iterable<@NonNull ? extends ObservableSource<? extends @NonNull T>> sources, int maxConcurrency, int bufferSize) Concatenates a sequence ofObservableSource
s eagerly into a single stream of values and runs a limited number of inner sequences at once.Single.concatEager
(@NonNull Iterable<@NonNull ? extends SingleSource<? extends @NonNull T>> sources) Concatenates anIterable
sequence ofSingleSource
s eagerly into a single stream of values.Single.concatEager
(@NonNull Iterable<@NonNull ? extends SingleSource<? extends @NonNull T>> sources, int maxConcurrency) Concatenates anIterable
sequence ofSingleSource
s eagerly into a single stream of values and runs a limited number of the inner sources at once.Single.concatEager
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends SingleSource<? extends @NonNull T>> sources) Concatenates aPublisher
sequence ofSingleSource
s eagerly into a single stream of values.Single.concatEager
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends SingleSource<? extends @NonNull T>> sources, int maxConcurrency) Concatenates aPublisher
sequence ofSingleSource
s eagerly into a single stream of values and runs a limited number of those innerSingleSource
s at once.Flowable.concatEagerDelayError
(@NonNull Iterable<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources) Concatenates a sequence ofPublisher
s eagerly into a single stream of values, delaying errors until all the inner sequences terminate.Flowable.concatEagerDelayError
(@NonNull Iterable<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources, int maxConcurrency, int prefetch) Concatenates a sequence ofPublisher
s eagerly into a single stream of values, delaying errors until all the inner sequences terminate and runs a limited number of inner sequences at once.Flowable.concatEagerDelayError
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources) Concatenates aPublisher
sequence ofPublisher
s eagerly into a single stream of values, delaying errors until all the inner and the outer sequences terminate.Flowable.concatEagerDelayError
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources, int maxConcurrency, int prefetch) Concatenates aPublisher
sequence ofPublisher
s eagerly into a single stream of values, delaying errors until all the inner and outer sequences terminate and runs a limited number of inner sequences at once.Maybe.concatEagerDelayError
(@NonNull Iterable<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources) Concatenates a sequence ofMaybeSource
s eagerly into aFlowable
sequence, delaying errors until all innerMaybeSource
s terminate.Maybe.concatEagerDelayError
(@NonNull Iterable<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources, int maxConcurrency) Concatenates a sequence ofMaybeSource
s eagerly into aFlowable
sequence, delaying errors until all innerMaybeSource
s terminate and runs a limited number of innerMaybeSource
s at once.Maybe.concatEagerDelayError
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources) Concatenates aPublisher
sequence ofMaybeSource
s eagerly into aFlowable
sequence, delaying errors until all the inner and the outer sequence terminate.Maybe.concatEagerDelayError
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources, int maxConcurrency) Concatenates aPublisher
sequence ofMaybeSource
s eagerly into aFlowable
sequence, delaying errors until all the inner and the outer sequence terminate and runs a limited number of the innerMaybeSource
s at once.static <@NonNull T>
@NonNull Observable<T> Observable.concatEagerDelayError
(@NonNull ObservableSource<? extends ObservableSource<? extends @NonNull T>> sources) Concatenates anObservableSource
sequence ofObservableSource
s eagerly into a single stream of values, delaying errors until all the inner and the outer sequence terminate.static <@NonNull T>
@NonNull Observable<T> Observable.concatEagerDelayError
(@NonNull ObservableSource<? extends ObservableSource<? extends @NonNull T>> sources, int maxConcurrency, int bufferSize) Concatenates anObservableSource
sequence ofObservableSource
s eagerly into a single stream of values, delaying errors until all the inner and the outer sequence terminate and runs a limited number of inner sequences at once.static <@NonNull T>
@NonNull Observable<T> Observable.concatEagerDelayError
(@NonNull Iterable<@NonNull ? extends ObservableSource<? extends @NonNull T>> sources) Concatenates a sequence ofObservableSource
s eagerly into a single stream of values, delaying errors until all the inner sequences terminate.static <@NonNull T>
@NonNull Observable<T> Observable.concatEagerDelayError
(@NonNull Iterable<@NonNull ? extends ObservableSource<? extends @NonNull T>> sources, int maxConcurrency, int bufferSize) Concatenates a sequence ofObservableSource
s eagerly into a single stream of values, delaying errors until all the inner sequences terminate and runs a limited number of inner sequences at once.Single.concatEagerDelayError
(@NonNull Iterable<@NonNull ? extends SingleSource<? extends @NonNull T>> sources) Concatenates anIterable
sequence ofSingleSource
s eagerly into a single stream of values, delaying errors until all the inner sources terminate.Single.concatEagerDelayError
(@NonNull Iterable<@NonNull ? extends SingleSource<? extends @NonNull T>> sources, int maxConcurrency) Concatenates anIterable
sequence ofSingleSource
s eagerly into a single stream of values, delaying errors until all the inner sources terminate.Single.concatEagerDelayError
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends SingleSource<? extends @NonNull T>> sources) Concatenates aPublisher
sequence ofSingleSource
s eagerly into a single stream of values, delaying errors until all the inner and the outer sequence terminate.Single.concatEagerDelayError
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends SingleSource<? extends @NonNull T>> sources, int maxConcurrency) Concatenates aPublisher
sequence ofSingleSource
s eagerly into a single stream of values, running at most the specified number of those innerSingleSource
s at once and delaying errors until all the inner and the outer sequence terminate.Flowable.concatMap
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper) Returns a newFlowable
that emits items resulting from applying a function that you supply to each item emitted by the currentFlowable
, where that function returns aPublisher
, and then emitting the items that result from concatenating those returnedPublisher
s.Flowable.concatMap
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper, int prefetch) Returns a newFlowable
that emits items resulting from applying a function that you supply to each item emitted by the currentFlowable
, where that function returns aPublisher
, and then emitting the items that result from concatenating those returnedPublisher
s.Flowable.concatMap
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper, int prefetch, @NonNull Scheduler scheduler) Returns a newFlowable
that emits items resulting from applying a function (on a designated scheduler) that you supply to each item emitted by the currentFlowable
, where that function returns aPublisher
, and then emitting the items that result from concatenating those returnedPublisher
s.Maybe.concatMap
(@NonNull Function<? super @NonNull T, ? extends MaybeSource<? extends @NonNull R>> mapper) Returns aMaybe
that is based on applying a specified function to the item emitted by the currentMaybe
, where that function returns aMaybeSource
.final <@NonNull R>
@NonNull Observable<R> Observable.concatMap
(@NonNull Function<? super @NonNull T, ? extends ObservableSource<? extends @NonNull R>> mapper) Returns a newObservable
that emits items resulting from applying a function that you supply to each item emitted by the currentObservable
, where that function returns anObservableSource
, and then emitting the items that result from concatenating those returnedObservableSource
s.final <@NonNull R>
@NonNull Observable<R> Observable.concatMap
(@NonNull Function<? super @NonNull T, ? extends ObservableSource<? extends @NonNull R>> mapper, int bufferSize) Returns a newObservable
that emits items resulting from applying a function that you supply to each item emitted by the currentObservable
, where that function returns anObservableSource
, and then emitting the items that result from concatenating those returnedObservableSource
s.final <@NonNull R>
@NonNull Observable<R> Observable.concatMap
(@NonNull Function<? super @NonNull T, ? extends ObservableSource<? extends @NonNull R>> mapper, int bufferSize, @NonNull Scheduler scheduler) Returns a newObservable
that emits items resulting from applying a function that you supply to each item emitted by the currentObservable
, where that function returns anObservableSource
, and then emitting the items that result from concatenating those returnedObservableSource
s.Single.concatMap
(@NonNull Function<? super @NonNull T, ? extends SingleSource<? extends @NonNull R>> mapper) Returns aSingle
that is based on applying a specified function to the item emitted by the currentSingle
, where that function returns aSingleSource
.final @NonNull Completable
Flowable.concatMapCompletable
(@NonNull Function<? super @NonNull T, ? extends CompletableSource> mapper) Maps the upstream items intoCompletableSource
s 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 intoCompletableSource
s and subscribes to them one after the other completes.final @NonNull Completable
Maybe.concatMapCompletable
(@NonNull Function<? super @NonNull T, ? extends CompletableSource> mapper) Returns aCompletable
that completes based on applying a specified function to the item emitted by the currentMaybe
, where that function returns aCompletable
.final @NonNull Completable
Observable.concatMapCompletable
(@NonNull Function<? super @NonNull T, ? extends CompletableSource> mapper) Maps each element of the currentObservable
intoCompletableSource
s, subscribes to them one at a time in order and waits until the upstream and allCompletableSource
s complete.final @NonNull Completable
Observable.concatMapCompletable
(@NonNull Function<? super @NonNull T, ? extends CompletableSource> mapper, int capacityHint) Maps each element of the currentObservable
intoCompletableSource
s, subscribes to them one at a time in order and waits until the upstream and allCompletableSource
s complete.final @NonNull Completable
Single.concatMapCompletable
(@NonNull Function<? super @NonNull T, ? extends CompletableSource> mapper) Returns aCompletable
that completes based on applying a specified function to the item emitted by the currentSingle
, where that function returns aCompletableSource
.final @NonNull Completable
Flowable.concatMapCompletableDelayError
(@NonNull Function<? super @NonNull T, ? extends CompletableSource> mapper) Maps the upstream items intoCompletableSource
s and subscribes to them one after the other terminates, delaying all errors till both thisFlowable
and all innerCompletableSource
s terminate.final @NonNull Completable
Flowable.concatMapCompletableDelayError
(@NonNull Function<? super @NonNull T, ? extends CompletableSource> mapper, boolean tillTheEnd) Maps the upstream items intoCompletableSource
s and subscribes to them one after the other terminates, optionally delaying all errors till both thisFlowable
and all innerCompletableSource
s terminate.final @NonNull Completable
Flowable.concatMapCompletableDelayError
(@NonNull Function<? super @NonNull T, ? extends CompletableSource> mapper, boolean tillTheEnd, int prefetch) Maps the upstream items intoCompletableSource
s and subscribes to them one after the other terminates, optionally delaying all errors till both thisFlowable
and all innerCompletableSource
s terminate.final @NonNull Completable
Observable.concatMapCompletableDelayError
(@NonNull Function<? super @NonNull T, ? extends CompletableSource> mapper) Maps the upstream items intoCompletableSource
s and subscribes to them one after the other terminates, delaying all errors till both the currentObservable
and all innerCompletableSource
s terminate.final @NonNull Completable
Observable.concatMapCompletableDelayError
(@NonNull Function<? super @NonNull T, ? extends CompletableSource> mapper, boolean tillTheEnd) Maps the upstream items intoCompletableSource
s and subscribes to them one after the other terminates, optionally delaying all errors till both the currentObservable
and all innerCompletableSource
s terminate.final @NonNull Completable
Observable.concatMapCompletableDelayError
(@NonNull Function<? super @NonNull T, ? extends CompletableSource> mapper, boolean tillTheEnd, int bufferSize) Maps the upstream items intoCompletableSource
s and subscribes to them one after the other terminates, optionally delaying all errors till both the currentObservable
and all innerCompletableSource
s terminate.Flowable.concatMapDelayError
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper) Maps each of the items into aPublisher
, subscribes to them one after the other, one at a time and emits their values in order while delaying any error from either this or any of the innerPublisher
s till all of them terminate.Flowable.concatMapDelayError
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper, boolean tillTheEnd, int prefetch) Maps each of the items into aPublisher
, subscribes to them one after the other, one at a time and emits their values in order while delaying any error from either this or any of the innerPublisher
s till all of them terminate.Flowable.concatMapDelayError
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper, boolean tillTheEnd, int prefetch, @NonNull Scheduler scheduler) Maps each of the upstream items into aPublisher
, subscribes to them one after the other, one at a time and emits their values in order while executing the mapper function on the designated scheduler, delaying any error from either this or any of the innerPublisher
s till all of them terminate.final <@NonNull R>
@NonNull Observable<R> Observable.concatMapDelayError
(@NonNull Function<? super @NonNull T, ? extends ObservableSource<? extends @NonNull R>> mapper) Maps each of the items into anObservableSource
, subscribes to them one after the other, one at a time and emits their values in order while delaying any error from either this or any of the innerObservableSource
s till all of them terminate.final <@NonNull R>
@NonNull Observable<R> Observable.concatMapDelayError
(@NonNull Function<? super @NonNull T, ? extends ObservableSource<? extends @NonNull R>> mapper, boolean tillTheEnd, int bufferSize) Maps each of the items into anObservableSource
, subscribes to them one after the other, one at a time and emits their values in order while delaying any error from either this or any of the innerObservableSource
s till all of them terminate.final <@NonNull R>
@NonNull Observable<R> Observable.concatMapDelayError
(@NonNull Function<? super @NonNull T, ? extends ObservableSource<? extends @NonNull R>> mapper, boolean tillTheEnd, int bufferSize, @NonNull Scheduler scheduler) Maps each of the items into anObservableSource
, subscribes to them one after the other, one at a time and emits their values in order while delaying any error from either this or any of the innerObservableSource
s till all of them terminate.Flowable.concatMapEager
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper) Maps a sequence of values intoPublisher
s and concatenates thesePublisher
s eagerly into a singlePublisher
.Flowable.concatMapEager
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper, int maxConcurrency, int prefetch) Maps a sequence of values intoPublisher
s and concatenates thesePublisher
s eagerly into a singlePublisher
.final <@NonNull R>
@NonNull Observable<R> Observable.concatMapEager
(@NonNull Function<? super @NonNull T, ? extends ObservableSource<? extends @NonNull R>> mapper) Maps a sequence of values intoObservableSource
s and concatenates theseObservableSource
s eagerly into a singleObservable
sequence.final <@NonNull R>
@NonNull Observable<R> Observable.concatMapEager
(@NonNull Function<? super @NonNull T, ? extends ObservableSource<? extends @NonNull R>> mapper, int maxConcurrency, int bufferSize) Maps a sequence of values intoObservableSource
s and concatenates theseObservableSource
s eagerly into a singleObservable
sequence.Flowable.concatMapEagerDelayError
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper, boolean tillTheEnd) Maps a sequence of values intoPublisher
s and concatenates thesePublisher
s eagerly into a singlePublisher
.Flowable.concatMapEagerDelayError
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper, boolean tillTheEnd, int maxConcurrency, int prefetch) Maps a sequence of values intoPublisher
s and concatenates thesePublisher
s eagerly into a singleFlowable
sequence.final <@NonNull R>
@NonNull Observable<R> Observable.concatMapEagerDelayError
(@NonNull Function<? super @NonNull T, ? extends ObservableSource<? extends @NonNull R>> mapper, boolean tillTheEnd) Maps a sequence of values intoObservableSource
s and concatenates theseObservableSource
s eagerly into a singleObservable
sequence.final <@NonNull R>
@NonNull Observable<R> Observable.concatMapEagerDelayError
(@NonNull Function<? super @NonNull T, ? extends ObservableSource<? extends @NonNull R>> mapper, boolean tillTheEnd, int maxConcurrency, int bufferSize) Maps a sequence of values intoObservableSource
s and concatenates theseObservableSource
s eagerly into a singleObservable
sequence.Flowable.concatMapIterable
(@NonNull Function<? super @NonNull T, @NonNull ? extends Iterable<? extends @NonNull U>> mapper) Returns aFlowable
that concatenate each item emitted by the currentFlowable
with the values in anIterable
corresponding to that item that is generated by a selector.Flowable.concatMapIterable
(@NonNull Function<? super @NonNull T, @NonNull ? extends Iterable<? extends @NonNull U>> mapper, int prefetch) Returns aFlowable
that concatenate each item emitted by the currentFlowable
with the values in anIterable
corresponding to that item that is generated by a selector.final <@NonNull U>
@NonNull Observable<U> Observable.concatMapIterable
(@NonNull Function<? super @NonNull T, @NonNull ? extends Iterable<? extends @NonNull U>> mapper) Returns anObservable
that concatenate each item emitted by the currentObservable
with the values in anIterable
corresponding to that item that is generated by a selector.Flowable.concatMapMaybe
(@NonNull Function<? super @NonNull T, ? extends MaybeSource<? extends @NonNull R>> mapper) Maps the upstream items intoMaybeSource
s and subscribes to them one after the other succeeds or completes, emits their success value if available or terminates immediately if either thisFlowable
or the current innerMaybeSource
fail.Flowable.concatMapMaybe
(@NonNull Function<? super @NonNull T, ? extends MaybeSource<? extends @NonNull R>> mapper, int prefetch) Maps the upstream items intoMaybeSource
s and subscribes to them one after the other succeeds or completes, emits their success value if available or terminates immediately if either thisFlowable
or the current innerMaybeSource
fail.final <@NonNull R>
@NonNull Observable<R> Observable.concatMapMaybe
(@NonNull Function<? super @NonNull T, ? extends MaybeSource<? extends @NonNull R>> mapper) Maps the upstream items intoMaybeSource
s and subscribes to them one after the other succeeds or completes, emits their success value if available or terminates immediately if either the currentObservable
or the current innerMaybeSource
fail.final <@NonNull R>
@NonNull Observable<R> Observable.concatMapMaybe
(@NonNull Function<? super @NonNull T, ? extends MaybeSource<? extends @NonNull R>> mapper, int bufferSize) Maps the upstream items intoMaybeSource
s and subscribes to them one after the other succeeds or completes, emits their success value if available or terminates immediately if either the currentObservable
or the current innerMaybeSource
fail.Single.concatMapMaybe
(@NonNull Function<? super @NonNull T, ? extends MaybeSource<? extends @NonNull R>> mapper) Returns aMaybe
that is based on applying a specified function to the item emitted by the currentSingle
, where that function returns aMaybeSource
.Flowable.concatMapMaybeDelayError
(@NonNull Function<? super @NonNull T, ? extends MaybeSource<? extends @NonNull R>> mapper) Maps the upstream items intoMaybeSource
s and subscribes to them one after the other terminates, emits their success value if available and delaying all errors till both thisFlowable
and all innerMaybeSource
s terminate.Flowable.concatMapMaybeDelayError
(@NonNull Function<? super @NonNull T, ? extends MaybeSource<? extends @NonNull R>> mapper, boolean tillTheEnd) Maps the upstream items intoMaybeSource
s and subscribes to them one after the other terminates, emits their success value if available and optionally delaying all errors till both thisFlowable
and all innerMaybeSource
s terminate.Flowable.concatMapMaybeDelayError
(@NonNull Function<? super @NonNull T, ? extends MaybeSource<? extends @NonNull R>> mapper, boolean tillTheEnd, int prefetch) Maps the upstream items intoMaybeSource
s and subscribes to them one after the other terminates, emits their success value if available and optionally delaying all errors till both thisFlowable
and all innerMaybeSource
s terminate.final <@NonNull R>
@NonNull Observable<R> Observable.concatMapMaybeDelayError
(@NonNull Function<? super @NonNull T, ? extends MaybeSource<? extends @NonNull R>> mapper) Maps the upstream items intoMaybeSource
s and subscribes to them one after the other terminates, emits their success value if available and delaying all errors till both the currentObservable
and all innerMaybeSource
s terminate.final <@NonNull R>
@NonNull Observable<R> Observable.concatMapMaybeDelayError
(@NonNull Function<? super @NonNull T, ? extends MaybeSource<? extends @NonNull R>> mapper, boolean tillTheEnd) Maps the upstream items intoMaybeSource
s and subscribes to them one after the other terminates, emits their success value if available and optionally delaying all errors till both the currentObservable
and all innerMaybeSource
s terminate.final <@NonNull R>
@NonNull Observable<R> Observable.concatMapMaybeDelayError
(@NonNull Function<? super @NonNull T, ? extends MaybeSource<? extends @NonNull R>> mapper, boolean tillTheEnd, int bufferSize) Maps the upstream items intoMaybeSource
s and subscribes to them one after the other terminates, emits their success value if available and optionally delaying all errors till both the currentObservable
and all innerMaybeSource
s terminate.Flowable.concatMapSingle
(@NonNull Function<? super @NonNull T, ? extends SingleSource<? extends @NonNull R>> mapper) Maps the upstream items intoSingleSource
s and subscribes to them one after the other succeeds, emits their success values or terminates immediately if either thisFlowable
or the current innerSingleSource
fail.Flowable.concatMapSingle
(@NonNull Function<? super @NonNull T, ? extends SingleSource<? extends @NonNull R>> mapper, int prefetch) Maps the upstream items intoSingleSource
s and subscribes to them one after the other succeeds, emits their success values or terminates immediately if either thisFlowable
or the current innerSingleSource
fail.Maybe.concatMapSingle
(@NonNull Function<? super @NonNull T, ? extends SingleSource<? extends @NonNull R>> mapper) Returns aMaybe
based on applying a specified function to the item emitted by the currentMaybe
, where that function returns aSingle
.final <@NonNull R>
@NonNull Observable<R> Observable.concatMapSingle
(@NonNull Function<? super @NonNull T, ? extends SingleSource<? extends @NonNull R>> mapper) Maps the upstream items intoSingleSource
s and subscribes to them one after the other succeeds, emits their success values or terminates immediately if either the currentObservable
or the current innerSingleSource
fail.final <@NonNull R>
@NonNull Observable<R> Observable.concatMapSingle
(@NonNull Function<? super @NonNull T, ? extends SingleSource<? extends @NonNull R>> mapper, int bufferSize) Maps the upstream items intoSingleSource
s and subscribes to them one after the other succeeds, emits their success values or terminates immediately if either the currentObservable
or the current innerSingleSource
fail.Flowable.concatMapSingleDelayError
(@NonNull Function<? super @NonNull T, ? extends SingleSource<? extends @NonNull R>> mapper) Maps the upstream items intoSingleSource
s and subscribes to them one after the other succeeds or fails, emits their success values and delays all errors till both thisFlowable
and all innerSingleSource
s terminate.Flowable.concatMapSingleDelayError
(@NonNull Function<? super @NonNull T, ? extends SingleSource<? extends @NonNull R>> mapper, boolean tillTheEnd) Maps the upstream items intoSingleSource
s and subscribes to them one after the other succeeds or fails, emits their success values and optionally delays all errors till both thisFlowable
and all innerSingleSource
s terminate.Flowable.concatMapSingleDelayError
(@NonNull Function<? super @NonNull T, ? extends SingleSource<? extends @NonNull R>> mapper, boolean tillTheEnd, int prefetch) Maps the upstream items intoSingleSource
s and subscribes to them one after the other succeeds or fails, emits their success values and optionally delays errors till both thisFlowable
and all innerSingleSource
s terminate.final <@NonNull R>
@NonNull Observable<R> Observable.concatMapSingleDelayError
(@NonNull Function<? super @NonNull T, ? extends SingleSource<? extends @NonNull R>> mapper) Maps the upstream items intoSingleSource
s and subscribes to them one after the other succeeds or fails, emits their success values and delays all errors till both the currentObservable
and all innerSingleSource
s terminate.final <@NonNull R>
@NonNull Observable<R> Observable.concatMapSingleDelayError
(@NonNull Function<? super @NonNull T, ? extends SingleSource<? extends @NonNull R>> mapper, boolean tillTheEnd) Maps the upstream items intoSingleSource
s and subscribes to them one after the other succeeds or fails, emits their success values and optionally delays all errors till both the currentObservable
and all innerSingleSource
s terminate.final <@NonNull R>
@NonNull Observable<R> Observable.concatMapSingleDelayError
(@NonNull Function<? super @NonNull T, ? extends SingleSource<? extends @NonNull R>> mapper, boolean tillTheEnd, int bufferSize) Maps the upstream items intoSingleSource
s and subscribes to them one after the other succeeds or fails, emits their success values and optionally delays errors till both the currentObservable
and all innerSingleSource
s terminate.Flowable.concatMapStream
(@NonNull Function<? super @NonNull T, @NonNull ? extends Stream<? extends @NonNull R>> mapper) Maps each upstream item into aStream
and emits theStream
's items to the downstream in a sequential fashion.Flowable.concatMapStream
(@NonNull Function<? super @NonNull T, @NonNull ? extends Stream<? extends @NonNull R>> mapper, int prefetch) Maps each upstream item into aStream
and emits theStream
's items to the downstream in a sequential fashion.final <@NonNull R>
@NonNull Observable<R> Observable.concatMapStream
(@NonNull Function<? super @NonNull T, @NonNull ? extends Stream<? extends @NonNull R>> mapper) Maps each upstream item into aStream
and emits theStream
's items to the downstream in a sequential fashion.final @NonNull Completable
Completable.concatWith
(@NonNull CompletableSource other) Concatenates thisCompletable
with anotherCompletableSource
.Flowable.concatWith
(@NonNull CompletableSource other) Returns aFlowable
that emits items from thisFlowable
and when it completes normally, the otherCompletableSource
is subscribed to and the returnedFlowable
emits its terminal events.Flowable.concatWith
(@NonNull MaybeSource<? extends @NonNull T> other) Returns aFlowable
that emits the items from thisFlowable
followed by the success item or terminal events of the otherMaybeSource
.Flowable.concatWith
(@NonNull SingleSource<? extends @NonNull T> other) Returns aFlowable
that emits the items from thisFlowable
followed by the success item or error event of the otherSingleSource
.Flowable.concatWith
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T> other) Returns aFlowable
that emits the items emitted from the currentFlowable
, then the next, one after the other, without interleaving them.Maybe.concatWith
(@NonNull MaybeSource<? extends @NonNull T> other) Returns aFlowable
that emits the items emitted from the currentMaybe
, then theother
MaybeSource
, one after the other, without interleaving them.final @NonNull Observable
<T> Observable.concatWith
(@NonNull CompletableSource other) Returns anObservable
that emits items from the currentObservable
and when it completes normally, the otherCompletableSource
is subscribed to and the returnedObservable
emits its terminal events.final @NonNull Observable
<T> Observable.concatWith
(@NonNull MaybeSource<? extends @NonNull T> other) Returns anObservable
that emits the items from the currentObservable
followed by the success item or terminal events of the otherMaybeSource
.final @NonNull Observable
<T> Observable.concatWith
(@NonNull ObservableSource<? extends @NonNull T> other) Returns anObservable
that first emits the items emitted from the currentObservable
, then items from theother
ObservableSource
without interleaving them.final @NonNull Observable
<T> Observable.concatWith
(@NonNull SingleSource<? extends @NonNull T> other) Returns anObservable
that emits the items from the currentObservable
followed by the success item or error event of theother
SingleSource
.Single.concatWith
(@NonNull SingleSource<? extends @NonNull T> other) Returns aFlowable
that emits the item emitted by the currentSingle
, then the item emitted by the specifiedSingleSource
.Signalstrue
if the currentSingle
signals a success value that isObject.equals(Object)
with the value provided.Signalstrue
if the currentSingle
signals a success value that is equal with the value provided by calling aBiPredicate
.Flowable.count()
Maybe.count()
Observable.count()
static @NonNull Completable
Completable.create
(@NonNull CompletableOnSubscribe source) Provides an API (via a coldCompletable
) that bridges the reactive world with the callback-style world.Flowable.create
(@NonNull FlowableOnSubscribe<@NonNull T> source, @NonNull BackpressureStrategy mode) Provides an API (via a coldFlowable
) that bridges the reactive world with the callback-style, generally non-backpressured world.Maybe.create
(@NonNull MaybeOnSubscribe<@NonNull T> onSubscribe) Provides an API (via a coldMaybe
) that bridges the reactive world with the callback-style world.static <@NonNull T>
@NonNull Observable<T> Observable.create
(@NonNull ObservableOnSubscribe<@NonNull T> source) Provides an API (via a coldObservable
) that bridges the reactive world with the callback-style world.Single.create
(@NonNull SingleOnSubscribe<@NonNull T> source) Provides an API (via a coldSingle
) that bridges the reactive world with the callback-style world.static <T> @NonNull Notification
<T> Notification.createOnComplete()
Returns the empty and stateless shared instance of a notification representing anonComplete
signal.static <T> @NonNull Notification
<T> Notification.createOnError
(@NonNull Throwable error) Constructs an onError notification containing the error.static <@NonNull T>
@NonNull Notification<T> Notification.createOnNext
(@NonNull T value) Constructs an onNext notification containing the given value.abstract @NonNull Scheduler.Worker
Scheduler.createWorker()
Retrieves or creates a newScheduler.Worker
that represents sequential execution of actions.Returns aFlowable
that mirrors the currentFlowable
, except that it drops items emitted by the currentFlowable
that are followed by newer items before a timeout value expires.Returns aFlowable
that mirrors the currentFlowable
, except that it drops items emitted by the currentFlowable
that are followed by newer items before a timeout value expires on a specifiedScheduler
.Flowable.debounce
(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, @NonNull Consumer<? super @NonNull T> onDropped) Returns aFlowable
that mirrors the currentFlowable
, except that it drops items emitted by the currentFlowable
that are followed by newer items before a timeout value expires on a specifiedScheduler
.Flowable.debounce
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<@NonNull U>> debounceIndicator) Returns aFlowable
that mirrors the currentFlowable
, except that it drops items emitted by the currentFlowable
that are followed by another item within a computed debounce duration.final @NonNull Observable
<T> Returns anObservable
that mirrors the currentObservable
, except that it drops items emitted by the currentObservable
that are followed by newer items before a timeout value expires.final @NonNull Observable
<T> Returns anObservable
that mirrors the currentObservable
, except that it drops items emitted by the currentObservable
that are followed by newer items before a timeout value expires on a specifiedScheduler
.final @NonNull Observable
<T> Observable.debounce
(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, @NonNull Consumer<? super @NonNull T> onDropped) Returns anObservable
that mirrors the currentObservable
, except that it drops items emitted by the currentObservable
that are followed by newer items before a timeout value expires on a specifiedScheduler
.final <@NonNull U>
@NonNull Observable<T> Observable.debounce
(@NonNull Function<? super @NonNull T, ? extends ObservableSource<@NonNull U>> debounceIndicator) Returns anObservable
that mirrors the currentObservable
, except that it drops items emitted by the currentObservable
that are followed by another item within a computed debounce duration denoted by an item emission or completion from a generated innerObservableSource
for that original item.Flowable.defaultIfEmpty
(@NonNull T defaultItem) Returns aFlowable
that emits the items emitted by the currentFlowable
or a specified default item if the currentFlowable
is empty.Maybe.defaultIfEmpty
(@NonNull T defaultItem) Returns aSingle
that emits the item emitted by the currentMaybe
or a specified default item if the currentMaybe
is empty.final @NonNull Observable
<T> Observable.defaultIfEmpty
(@NonNull T defaultItem) Returns anObservable
that emits the items emitted by the currentObservable
or a specified default item if the currentObservable
is empty.static @NonNull Completable
Completable.defer
(@NonNull Supplier<? extends @NonNull CompletableSource> supplier) Defers the subscription to aCompletable
instance returned by a supplier.Flowable.defer
(@NonNull Supplier<? extends @NonNull org.reactivestreams.Publisher<? extends @NonNull T>> supplier) Returns aFlowable
that calls aPublisher
factory to create aPublisher
for each newSubscriber
that subscribes.Calls aSupplier
for each individualMaybeObserver
to return the actualMaybeSource
source to be subscribed to.static <@NonNull T>
@NonNull Observable<T> Observable.defer
(@NonNull Supplier<? extends @NonNull ObservableSource<? extends @NonNull T>> supplier) Returns anObservable
that calls anObservableSource
factory to create anObservableSource
for each newObserver
that subscribes.Calls aSupplier
for each individualSingleObserver
to return the actualSingleSource
to be subscribed to.final @NonNull Completable
Returns aCompletable
which delays the emission of the completion event by the given time.final @NonNull Completable
Returns aCompletable
which delays the emission of the completion event by the given time while running on the specifiedScheduler
.final @NonNull Completable
Completable.delay
(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean delayError) Returns aCompletable
which delays the emission of the completion event, and optionally the error as well, by the given time while running on the specifiedScheduler
.Returns aFlowable
that emits the items emitted by the currentFlowable
shifted forward in time by a specified delay.Returns aFlowable
that emits the items emitted by the currentFlowable
shifted forward in time by a specified delay.Returns aFlowable
that emits the items emitted by the currentFlowable
shifted forward in time by a specified delay.Returns aFlowable
that emits the items emitted by the currentFlowable
shifted forward in time by a specified delay.Flowable.delay
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<@NonNull U>> itemDelayIndicator) Returns aFlowable
that delays the emissions of the currentFlowable
via anotherPublisher
on a per-item basis.Flowable.delay
(@NonNull org.reactivestreams.Publisher<@NonNull U> subscriptionIndicator, @NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<@NonNull V>> itemDelayIndicator) Returns aFlowable
that delays the subscription to and emissions from the currentFlowable
via anotherPublisher
on a per-item basis.Returns aMaybe
that signals the events emitted by the currentMaybe
shifted forward in time by a specified delay.Returns aMaybe
that signals the events emitted by the currentMaybe
shifted forward in time by a specified delay.Returns aMaybe
that signals the events emitted by the currentMaybe
shifted forward in time by a specified delay.Returns aMaybe
that signals the events emitted by the currentMaybe
shifted forward in time by a specified delay running on the specifiedScheduler
.Delays the emission of thisMaybe
until the givenPublisher
signals an item or completes.final @NonNull Observable
<T> Returns anObservable
that emits the items emitted by the currentObservable
shifted forward in time by a specified delay.final @NonNull Observable
<T> Returns anObservable
that emits the items emitted by the currentObservable
shifted forward in time by a specified delay.final @NonNull Observable
<T> Returns anObservable
that emits the items emitted by the currentObservable
shifted forward in time by a specified delay.final @NonNull Observable
<T> Observable.delay
(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean delayError) Returns anObservable
that emits the items emitted by the currentObservable
shifted forward in time by a specified delay.final <@NonNull U,
@NonNull V>
@NonNull Observable<T> Observable.delay
(@NonNull ObservableSource<@NonNull U> subscriptionIndicator, @NonNull Function<? super @NonNull T, ? extends ObservableSource<@NonNull V>> itemDelayIndicator) Returns anObservable
that delays the subscription to and emissions from the currentObservable
viaObservableSource
s for the subscription itself and on a per-item basis.final <@NonNull U>
@NonNull Observable<T> Observable.delay
(@NonNull Function<? super @NonNull T, ? extends ObservableSource<@NonNull U>> itemDelayIndicator) Returns anObservable
that delays the emissions of the currentObservable
via a per-item derivedObservableSource
's item emission or termination, on a per source item basis.Delays the emission of the success signal from the currentSingle
by the specified amount.Delays the emission of the success or error signal from the currentSingle
by the specified amount.Delays the emission of the success signal from the currentSingle
by the specified amount.Delays the emission of the success or error signal from the currentSingle
by the specified amount.final @NonNull Completable
Completable.delaySubscription
(long time, @NonNull TimeUnit unit) Returns aCompletable
that delays the subscription to the upstream by a given amount of time.final @NonNull Completable
Completable.delaySubscription
(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Returns aCompletable
that delays the subscription to the upstream by a given amount of time, both waiting and subscribing on a givenScheduler
.Flowable.delaySubscription
(long time, @NonNull TimeUnit unit) Returns aFlowable
that delays the subscription to the currentFlowable
by a given amount of time.Flowable.delaySubscription
(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Returns aFlowable
that delays the subscription to the currentFlowable
by a given amount of time, both waiting and subscribing on a givenScheduler
.Flowable.delaySubscription
(@NonNull org.reactivestreams.Publisher<@NonNull U> subscriptionIndicator) Returns aFlowable
that delays the subscription to thisPublisher
until the otherPublisher
emits an element or completes normally.Maybe.delaySubscription
(long time, @NonNull TimeUnit unit) Returns aMaybe
that delays the subscription to the currentMaybe
by a given amount of time.Maybe.delaySubscription
(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Returns aMaybe
that delays the subscription to the currentMaybe
by a given amount of time, both waiting and subscribing on a givenScheduler
.Maybe.delaySubscription
(@NonNull org.reactivestreams.Publisher<@NonNull U> subscriptionIndicator) Returns aMaybe
that delays the subscription to thisMaybe
until the otherPublisher
emits an element or completes normally.final @NonNull Observable
<T> Observable.delaySubscription
(long time, @NonNull TimeUnit unit) Returns anObservable
that delays the subscription to the currentObservable
by a given amount of time.final @NonNull Observable
<T> Observable.delaySubscription
(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Returns anObservable
that delays the subscription to the currentObservable
by a given amount of time, both waiting and subscribing on a givenScheduler
.final <@NonNull U>
@NonNull Observable<T> Observable.delaySubscription
(@NonNull ObservableSource<@NonNull U> subscriptionIndicator) Returns anObservable
that delays the subscription to the currentObservable
until the otherObservableSource
emits an element or completes normally.Single.delaySubscription
(long time, @NonNull TimeUnit unit) Delays the actual subscription to the currentSingle
until the given time delay elapsed.Single.delaySubscription
(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Delays the actual subscription to the currentSingle
until the given time delay elapsed.Single.delaySubscription
(@NonNull CompletableSource subscriptionIndicator) Delays the actual subscription to the currentSingle
until the given otherCompletableSource
completes.Single.delaySubscription
(@NonNull ObservableSource<@NonNull U> subscriptionIndicator) Delays the actual subscription to the currentSingle
until the given otherObservableSource
signals its first value or completes.Single.delaySubscription
(@NonNull SingleSource<@NonNull U> subscriptionIndicator) Delays the actual subscription to the currentSingle
until the given otherSingleSource
signals success.Single.delaySubscription
(@NonNull org.reactivestreams.Publisher<@NonNull U> subscriptionIndicator) Delays the actual subscription to the currentSingle
until the given otherPublisher
signals its first value or completes.Flowable.dematerialize
(@NonNull Function<@NonNull ? super @NonNull T, @NonNull Notification<@NonNull R>> selector) Returns aFlowable
that reverses the effect ofmaterialize
by transforming theNotification
objects extracted from the source items via a selector function into their respectiveSubscriber
signal types.Maybe.dematerialize
(@NonNull Function<? super @NonNull T, @NonNull Notification<@NonNull R>> selector) Maps theNotification
success value of the currentMaybe
back into normalonSuccess
,onError
oronComplete
signals.final <@NonNull R>
@NonNull Observable<R> Observable.dematerialize
(@NonNull Function<? super @NonNull T, Notification<@NonNull R>> selector) Returns anObservable
that reverses the effect ofmaterialize
by transforming theNotification
objects extracted from the source items via a selector function into their respectiveObserver
signal types.Single.dematerialize
(@NonNull Function<? super @NonNull T, @NonNull Notification<@NonNull R>> selector) Maps theNotification
success value of the currentSingle
back into normalonSuccess
,onError
oronComplete
signals as aMaybe
source.Flowable.distinct()
Returns aFlowable
that emits all items emitted by the currentFlowable
that are distinct based onObject.equals(Object)
comparison.Returns aFlowable
that emits all items emitted by the currentFlowable
that are distinct according to a key selector function and based onObject.equals(Object)
comparison of the objects returned by the key selector function.Flowable.distinct
(@NonNull Function<? super @NonNull T, @NonNull K> keySelector, @NonNull Supplier<? extends Collection<? super @NonNull K>> collectionSupplier) Returns aFlowable
that emits all items emitted by the currentFlowable
that are distinct according to a key selector function and based onObject.equals(Object)
comparison of the objects returned by the key selector function.final @NonNull Observable
<T> Observable.distinct()
Returns anObservable
that emits all items emitted by the currentObservable
that are distinct based onObject.equals(Object)
comparison.final <@NonNull K>
@NonNull Observable<T> Returns anObservable
that emits all items emitted by the currentObservable
that are distinct according to a key selector function and based onObject.equals(Object)
comparison of the objects returned by the key selector function.final <@NonNull K>
@NonNull Observable<T> Observable.distinct
(@NonNull Function<? super @NonNull T, @NonNull K> keySelector, @NonNull Supplier<? extends Collection<? super @NonNull K>> collectionSupplier) Returns anObservable
that emits all items emitted by the currentObservable
that are distinct according to a key selector function and based onObject.equals(Object)
comparison of the objects returned by the key selector function.Flowable.distinctUntilChanged()
Returns aFlowable
that emits all items emitted by the currentFlowable
that are distinct from their immediate predecessors based onObject.equals(Object)
comparison.Flowable.distinctUntilChanged
(@NonNull BiPredicate<? super @NonNull T, ? super @NonNull T> comparer) Returns aFlowable
that emits all items emitted by the currentFlowable
that are distinct from their immediate predecessors when compared with each other via the provided comparator function.Returns aFlowable
that emits all items emitted by the currentFlowable
that are distinct from their immediate predecessors, according to a key selector function and based onObject.equals(Object)
comparison of those objects returned by the key selector function.final @NonNull Observable
<T> Observable.distinctUntilChanged()
Returns anObservable
that emits all items emitted by the currentObservable
that are distinct from their immediate predecessors based onObject.equals(Object)
comparison.final @NonNull Observable
<T> Observable.distinctUntilChanged
(@NonNull BiPredicate<? super @NonNull T, ? super @NonNull T> comparer) Returns anObservable
that emits all items emitted by the currentObservable
that are distinct from their immediate predecessors when compared with each other via the provided comparator function.final <@NonNull K>
@NonNull Observable<T> Returns anObservable
that emits all items emitted by the currentObservable
that are distinct from their immediate predecessors, according to a key selector function and based onObject.equals(Object)
comparison of those objects returned by the key selector function.Flowable.doAfterNext
(@NonNull Consumer<? super @NonNull T> onAfterNext) Calls the specified consumer with the current item after this item has been emitted to the downstream.final @NonNull Observable
<T> Observable.doAfterNext
(@NonNull Consumer<? super @NonNull T> onAfterNext) Calls the specifiedConsumer
with the current item after this item has been emitted to the downstream.Maybe.doAfterSuccess
(@NonNull Consumer<? super @NonNull T> onAfterSuccess) Calls the specifiedConsumer
with the success item after this item has been emitted to the downstream.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.final @NonNull Completable
Completable.doAfterTerminate
(@NonNull Action onAfterTerminate) Returns aCompletable
instance that calls the givenonAfterTerminate
Action
after thisCompletable
completes normally or with an exception.Flowable.doAfterTerminate
(@NonNull Action onAfterTerminate) Maybe.doAfterTerminate
(@NonNull Action onAfterTerminate) final @NonNull Observable
<T> Observable.doAfterTerminate
(@NonNull Action onAfterTerminate) Single.doAfterTerminate
(@NonNull Action onAfterTerminate) final @NonNull Completable
Calls the specifiedAction
after thisCompletable
signalsonError
oronComplete
or gets disposed by the downstream.Calls the specified action after thisFlowable
signalsonError
oronComplete
or gets canceled by the downstream.Calls the specified action after thisMaybe
signalsonSuccess
,onError
oronComplete
or gets disposed by the downstream.final @NonNull Observable
<T> Calls the specified action after the currentObservable
signalsonError
oronCompleted
or gets disposed by the downstream.Calls the specified action after thisSingle
signalsonSuccess
oronError
or gets disposed by the downstream.Flowable.doOnCancel
(@NonNull Action onCancel) Calls the cancelAction
if the downstream cancels the sequence.final @NonNull Completable
Completable.doOnComplete
(@NonNull Action onComplete) Flowable.doOnComplete
(@NonNull Action onComplete) Maybe.doOnComplete
(@NonNull Action onComplete) final @NonNull Observable
<T> Observable.doOnComplete
(@NonNull Action onComplete) final @NonNull Completable
Completable.doOnDispose
(@NonNull Action onDispose) Calls the sharedAction
if aCompletableObserver
subscribed to the currentCompletable
disposes the commonDisposable
it received viaonSubscribe
.Maybe.doOnDispose
(@NonNull Action onDispose) Calls the sharedAction
if aMaybeObserver
subscribed to the currentMaybe
disposes the commonDisposable
it received viaonSubscribe
.final @NonNull Observable
<T> Observable.doOnDispose
(@NonNull Action onDispose) Calls the given sharedAction
if the downstream disposes the sequence.Single.doOnDispose
(@NonNull Action onDispose) Calls the sharedAction
if aSingleObserver
subscribed to the currentSingle
disposes the commonDisposable
it received viaonSubscribe
.Flowable.doOnEach
(@NonNull Consumer<? super @NonNull T> onNext, @NonNull Consumer<? super Throwable> onError, Action onComplete, Action onAfterTerminate) Calls the appropriate onXXX consumer (shared between all subscribers) whenever a signal with the same type passes through, before forwarding them to downstream.Invokes aConsumer
with aNotification
instances matching the signals emitted by the currentFlowable
before they are forwarded to the downstream.Calls the appropriate methods of the givenSubscriber
when the currentFlowable
signals events before forwarding it to the downstream.final @NonNull Observable
<T> Returns anObservable
that forwards the items and terminal events of the currentObservable
to itsObserver
s and to the given sharedObserver
instance.final @NonNull Observable
<T> Returns anObservable
that invokes aConsumer
with the appropriateNotification
object when the currentObservable
signals an item or terminates.private @NonNull Observable
<T> Observable.doOnEach
(@NonNull Consumer<? super @NonNull T> onNext, @NonNull Consumer<? super Throwable> onError, @NonNull Action onComplete, @NonNull Action onAfterTerminate) Calls the appropriateonXXX
consumer (shared between allObserver
s) whenever a signal with the same type passes through, before forwarding them to the downstream.final @NonNull Completable
Calls the sharedConsumer
with the error sent viaonError
for eachMaybeObserver
that subscribes to the currentMaybe
.final @NonNull Observable
<T> Calls the shared consumer with the error sent viaonError
for eachSingleObserver
that subscribes to the currentSingle
.final @NonNull Completable
Maybe.doOnEvent
(@NonNull BiConsumer<@Nullable ? super @NonNull T, @Nullable ? super Throwable> onEvent) Calls the givenonEvent
callback with the (success value,null
) for anonSuccess
, (null
, throwable) for anonError
or (null
,null
) for anonComplete
signal from thisMaybe
before delivering said signal to the downstream.Single.doOnEvent
(@NonNull BiConsumer<@Nullable ? super @NonNull T, @Nullable ? super Throwable> onEvent) Calls the shared consumer with the error sent viaonError
or the value viaonSuccess
for eachSingleObserver
that subscribes to the currentSingle
.final @NonNull Completable
Completable.doOnLifecycle
(@NonNull Consumer<? super Disposable> onSubscribe, @NonNull Action onDispose) Calls the appropriateonXXX
method (shared between allCompletableObserver
s) for the lifecycle events of the sequence (subscription, disposal).private @NonNull Completable
Completable.doOnLifecycle
(Consumer<? super Disposable> onSubscribe, Consumer<? super Throwable> onError, Action onComplete, Action onTerminate, Action onAfterTerminate, Action onDispose) Returns aCompletable
instance that calls the various callbacks upon the specific lifecycle events.Flowable.doOnLifecycle
(@NonNull Consumer<? super org.reactivestreams.Subscription> onSubscribe, @NonNull LongConsumer onRequest, @NonNull Action onCancel) Calls the appropriateonXXX
method (shared between allSubscriber
s) for the lifecycle events of the sequence (subscription, cancellation, requesting).Maybe.doOnLifecycle
(@NonNull Consumer<? super Disposable> onSubscribe, @NonNull Action onDispose) Calls the appropriateonXXX
method (shared between allMaybeObserver
s) for the lifecycle events of the sequence (subscription, disposal).final @NonNull Observable
<T> Observable.doOnLifecycle
(@NonNull Consumer<? super Disposable> onSubscribe, @NonNull Action onDispose) Calls the appropriateonXXX
method (shared between allObserver
s) for the lifecycle events of the sequence (subscription, disposal).Single.doOnLifecycle
(@NonNull Consumer<? super Disposable> onSubscribe, @NonNull Action onDispose) Calls the appropriateonXXX
method (shared between allSingleObserver
s) for the lifecycle events of the sequence (subscription, disposal).Calls the givenConsumer
with the value emitted by the currentFlowable
before forwarding it to the downstream.final @NonNull Observable
<T> Calls the givenConsumer
with the value emitted by the currentObservable
before forwarding it to the downstream.Flowable.doOnRequest
(@NonNull LongConsumer onRequest) Calls the givenLongConsumer
with the request amount from the downstream before forwarding it to the currentFlowable
.final @NonNull Completable
Completable.doOnSubscribe
(@NonNull Consumer<? super Disposable> onSubscribe) Returns aCompletable
instance that calls the givenonSubscribe
callback with the disposable that the downstreamCompletableObserver
s receive upon subscription.Flowable.doOnSubscribe
(@NonNull Consumer<? super org.reactivestreams.Subscription> onSubscribe) Calls the givenConsumer
with theSubscription
provided by the currentFlowable
upon subscription from the downstream before forwarding it to the subscriber'sonSubscribe
method.Maybe.doOnSubscribe
(@NonNull Consumer<? super Disposable> onSubscribe) Calls the sharedConsumer
with theDisposable
sent through theonSubscribe
for eachMaybeObserver
that subscribes to the currentMaybe
.final @NonNull Observable
<T> Observable.doOnSubscribe
(@NonNull Consumer<? super Disposable> onSubscribe) Single.doOnSubscribe
(@NonNull Consumer<? super Disposable> onSubscribe) Calls the shared consumer with theDisposable
sent through theonSubscribe
for eachSingleObserver
that subscribes to the currentSingle
.Maybe.doOnSuccess
(@NonNull Consumer<? super @NonNull T> onSuccess) Calls the sharedConsumer
with the success value sent viaonSuccess
for eachMaybeObserver
that subscribes to the currentMaybe
.Single.doOnSuccess
(@NonNull Consumer<? super @NonNull T> onSuccess) Calls the shared consumer with the success value sent viaonSuccess
for eachSingleObserver
that subscribes to the currentSingle
.final @NonNull Completable
Completable.doOnTerminate
(@NonNull Action onTerminate) Returns aCompletable
instance that calls the givenonTerminate
Action
just before thisCompletable
completes normally or with an exception.Flowable.doOnTerminate
(@NonNull Action onTerminate) Calls the givenAction
when the currentFlowable
completes normally or with an error before those signals are forwarded to the downstream.Maybe.doOnTerminate
(@NonNull Action onTerminate) Returns aMaybe
instance that calls the given onTerminate callback just before thisMaybe
completes normally or with an exception.final @NonNull Observable
<T> Observable.doOnTerminate
(@NonNull Action onTerminate) Returns anObservable
so that it invokes an action when the currentObservable
callsonComplete
oronError
.Single.doOnTerminate
(@NonNull Action onTerminate) Returns aSingle
instance that calls the givenonTerminate
callback just before thisSingle
completes normally or with an exception.Flowable.elementAt
(long index) Returns aMaybe
that emits the single item at a specified index in a sequence of emissions from thisFlowable
or completes if thisFlowable
sequence has fewer elements than index.Returns aSingle
that emits the item found at a specified index in a sequence of emissions from thisFlowable
, or a default item if that index is out of range.Observable.elementAt
(long index) Returns aMaybe
that emits the single item at a specified index in a sequence of emissions from the currentObservable
or completes if the currentObservable
signals fewer elements than index.Returns aSingle
that emits the item found at a specified index in a sequence of emissions from the currentObservable
, or a default item if that index is out of range.Flowable.elementAtOrError
(long index) Returns aSingle
that emits the item found at a specified index in a sequence of emissions from thisFlowable
or signals aNoSuchElementException
if thisFlowable
has fewer elements than index.Observable.elementAtOrError
(long index) Returns aSingle
that emits the item found at a specified index in a sequence of emissions from the currentObservable
or signals aNoSuchElementException
if the currentObservable
signals fewer elements than index.Flowable.empty()
Returns aFlowable
that emits no items to theSubscriber
and immediately invokes itsonComplete
method.Maybe.empty()
Returns a (singleton)Maybe
instance that callsonComplete
immediately.static <@NonNull T>
@NonNull Observable<T> Observable.empty()
Returns anObservable
that emits no items to theObserver
and immediately invokes itsonComplete
method.static @NonNull Completable
Creates aCompletable
which calls the given error supplier for each subscriber and emits its returnedThrowable
.static @NonNull Completable
Creates aCompletable
instance that emits the givenThrowable
exception to subscribers.Returns aFlowable
that invokes aSubscriber
'sonError
method when theSubscriber
subscribes to it.Returns aFlowable
that invokes aSubscriber
'sonError
method when theSubscriber
subscribes to it.Returns aMaybe
that invokes aMaybeObserver
'sonError
method when theMaybeObserver
subscribes to it.Returns aMaybe
that invokes a subscriber'sonError
method when the subscriber subscribes to it.static <@NonNull T>
@NonNull Observable<T> static <@NonNull T>
@NonNull Observable<T> Signals aThrowable
returned by the callback function for each individualSingleObserver
.Returns aSingle
that invokes a subscriber'sonError
method when the subscriber subscribes to it.Filters items emitted by the currentFlowable
by only emitting those that satisfy a specified predicate.Filters the success item of theMaybe
via a predicate function and emitting it if the predicate returnstrue
, completing otherwise.final @NonNull Observable
<T> Filters items emitted by the currentObservable
by only emitting those that satisfy a specifiedPredicate
.Filters the success item of theSingle
via a predicate function and emitting it if the predicate returnstrue
, completing otherwise.Returns aSingle
that emits only the very first item emitted by thisFlowable
, or a default item if thisFlowable
completes without emitting anything.Returns aSingle
that emits only the very first item emitted by the currentObservable
, or a default item if the currentObservable
completes without emitting any items.Flowable.firstElement()
Returns aMaybe
that emits only the very first item emitted by thisFlowable
or completes if thisFlowable
is empty.Observable.firstElement()
Returns aMaybe
that emits only the very first item emitted by the currentObservable
, or completes if the currentObservable
is empty.Flowable.firstOrError()
Returns aSingle
that emits only the very first item emitted by thisFlowable
or signals aNoSuchElementException
if thisFlowable
is empty.Observable.firstOrError()
Returns aSingle
that emits only the very first item emitted by the currentObservable
or signals aNoSuchElementException
if the currentObservable
is empty.final @NonNull CompletionStage
<T> Flowable.firstOrErrorStage()
Signals the first upstream item or aNoSuchElementException
if the upstream is empty via aCompletionStage
.final @NonNull CompletionStage
<T> Observable.firstOrErrorStage()
Signals the first upstream item or aNoSuchElementException
if the upstream is empty via aCompletionStage
.final @NonNull CompletionStage
<T> Flowable.firstStage
(@NonNull T defaultItem) Signals the first upstream item (or the default item if the upstream is empty) via aCompletionStage
.final @NonNull CompletionStage
<T> Observable.firstStage
(@NonNull T defaultItem) Signals the first upstream item (or the default item if the upstream is empty) via aCompletionStage
.Flowable.flatMap
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper) Returns aFlowable
that emits items based on applying a function that you supply to each item emitted by the currentFlowable
, where that function returns aPublisher
, and then merging those resultingPublisher
s and emitting the results of this merger.Flowable.flatMap
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper, boolean delayErrors) Returns aFlowable
that emits items based on applying a function that you supply to each item emitted by the currentFlowable
, where that function returns aPublisher
, and then merging those resultingPublisher
s and emitting the results of this merger.Flowable.flatMap
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper, boolean delayErrors, int maxConcurrency) Returns aFlowable
that emits items based on applying a function that you supply to each item emitted by the currentFlowable
, where that function returns aPublisher
, and then merging those resultingPublisher
s and emitting the results of this merger, while limiting the maximum number of concurrent subscriptions to thesePublisher
s.Flowable.flatMap
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper, boolean delayErrors, int maxConcurrency, int bufferSize) Returns aFlowable
that emits items based on applying a function that you supply to each item emitted by the currentFlowable
, where that function returns aPublisher
, and then merging those resultingPublisher
s and emitting the results of this merger, while limiting the maximum number of concurrent subscriptions to thesePublisher
s.Flowable.flatMap
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper, int maxConcurrency) Returns aFlowable
that emits items based on applying a function that you supply to each item emitted by the currentFlowable
, where that function returns aPublisher
, and then merging those resultingPublisher
s and emitting the results of this merger, while limiting the maximum number of concurrent subscriptions to thesePublisher
s.Flowable.flatMap
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> onNextMapper, @NonNull Function<? super Throwable, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> onErrorMapper, @NonNull Supplier<? extends org.reactivestreams.Publisher<? extends @NonNull R>> onCompleteSupplier) Returns aFlowable
that applies a function to each item emitted or notification raised by the currentFlowable
and then flattens thePublisher
s returned from these functions and emits the resulting items.Flowable.flatMap
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> onNextMapper, @NonNull Function<Throwable, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> onErrorMapper, @NonNull Supplier<? extends org.reactivestreams.Publisher<? extends @NonNull R>> onCompleteSupplier, int maxConcurrency) Returns aFlowable
that applies a function to each item emitted or notification raised by the currentFlowable
and then flattens thePublisher
s returned from these functions and emits the resulting items, while limiting the maximum number of concurrent subscriptions to thesePublisher
s.Flowable.flatMap
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull U>> mapper, @NonNull BiFunction<? super @NonNull T, ? super @NonNull U, ? extends @NonNull R> combiner) Returns aFlowable
that emits the results of a specified function to the pair of values emitted by the currentFlowable
and a specified collectionPublisher
.Flowable.flatMap
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull U>> mapper, @NonNull BiFunction<? super @NonNull T, ? super @NonNull U, ? extends @NonNull R> combiner, boolean delayErrors) Returns aFlowable
that emits the results of a specified function to the pair of values emitted by the currentFlowable
and a specified innerPublisher
.Flowable.flatMap
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull U>> mapper, @NonNull BiFunction<? super @NonNull T, ? super @NonNull U, ? extends @NonNull R> combiner, boolean delayErrors, int maxConcurrency) Returns aFlowable
that emits the results of a specified function to the pair of values emitted by the currentFlowable
and a specified collectionPublisher
, while limiting the maximum number of concurrent subscriptions to thesePublisher
s.Flowable.flatMap
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull U>> mapper, @NonNull BiFunction<? super @NonNull T, ? super @NonNull U, ? extends @NonNull R> combiner, boolean delayErrors, int maxConcurrency, int bufferSize) Returns aFlowable
that emits the results of a specified function to the pair of values emitted by the currentFlowable
and a specified collectionPublisher
, while limiting the maximum number of concurrent subscriptions to thesePublisher
s.Flowable.flatMap
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull U>> mapper, @NonNull BiFunction<? super @NonNull T, ? super @NonNull U, ? extends @NonNull R> combiner, int maxConcurrency) Returns aFlowable
that emits the results of a specified function to the pair of values emitted by the currentFlowable
and a specified collectionPublisher
, while limiting the maximum number of concurrent subscriptions to thesePublisher
s.Maybe.flatMap
(@NonNull Function<? super @NonNull T, ? extends MaybeSource<? extends @NonNull R>> mapper) Returns aMaybe
that is based on applying a specified function to the item emitted by the currentMaybe
, where that function returns aMaybeSource
.Maybe.flatMap
(@NonNull Function<? super @NonNull T, ? extends MaybeSource<? extends @NonNull R>> onSuccessMapper, @NonNull Function<? super Throwable, ? extends MaybeSource<? extends @NonNull R>> onErrorMapper, @NonNull Supplier<? extends MaybeSource<? extends @NonNull R>> onCompleteSupplier) Maps theonSuccess
,onError
oronComplete
signals of the currentMaybe
into aMaybeSource
and emits thatMaybeSource
's signals.Maybe.flatMap
(@NonNull Function<? super @NonNull T, ? extends MaybeSource<? extends @NonNull U>> mapper, @NonNull BiFunction<? super @NonNull T, ? super @NonNull U, ? extends @NonNull R> combiner) Returns aMaybe
that emits the results of a specified function to the pair of values emitted by the currentMaybe
and a specified mappedMaybeSource
.final <@NonNull R>
@NonNull Observable<R> Observable.flatMap
(@NonNull Function<? super @NonNull T, ? extends ObservableSource<? extends @NonNull R>> mapper) Returns anObservable
that emits items based on applying a function that you supply to each item emitted by the currentObservable
, where that function returns anObservableSource
, and then merging those returnedObservableSource
s and emitting the results of this merger.final <@NonNull R>
@NonNull Observable<R> Observable.flatMap
(@NonNull Function<? super @NonNull T, ? extends ObservableSource<? extends @NonNull R>> mapper, boolean delayErrors) Returns anObservable
that emits items based on applying a function that you supply to each item emitted by the currentObservable
, where that function returns anObservableSource
, and then merging those returnedObservableSource
s and emitting the results of this merger.final <@NonNull R>
@NonNull Observable<R> Observable.flatMap
(@NonNull Function<? super @NonNull T, ? extends ObservableSource<? extends @NonNull R>> mapper, boolean delayErrors, int maxConcurrency) Returns anObservable
that emits items based on applying a function that you supply to each item emitted by the currentObservable
, where that function returns anObservableSource
, and then merging those returnedObservableSource
s and emitting the results of this merger, while limiting the maximum number of concurrent subscriptions to theseObservableSource
s.final <@NonNull R>
@NonNull Observable<R> Observable.flatMap
(@NonNull Function<? super @NonNull T, ? extends ObservableSource<? extends @NonNull R>> mapper, boolean delayErrors, int maxConcurrency, int bufferSize) Returns anObservable
that emits items based on applying a function that you supply to each item emitted by the currentObservable
, where that function returns anObservableSource
, and then merging those returnedObservableSource
s and emitting the results of this merger, while limiting the maximum number of concurrent subscriptions to theseObservableSource
s.final <@NonNull R>
@NonNull Observable<R> Observable.flatMap
(@NonNull Function<? super @NonNull T, ? extends ObservableSource<? extends @NonNull R>> mapper, int maxConcurrency) Returns anObservable
that emits items based on applying a function that you supply to each item emitted by the currentObservable
, where that function returns anObservableSource
, and then merging those returnedObservableSource
s and emitting the results of this merger, while limiting the maximum number of concurrent subscriptions to theseObservableSource
s.final <@NonNull R>
@NonNull Observable<R> Observable.flatMap
(@NonNull Function<? super @NonNull T, ? extends ObservableSource<? extends @NonNull R>> onNextMapper, @NonNull Function<? super Throwable, ? extends ObservableSource<? extends @NonNull R>> onErrorMapper, @NonNull Supplier<? extends ObservableSource<? extends @NonNull R>> onCompleteSupplier) Returns anObservable
that applies a function to each item emitted or notification raised by the currentObservable
and then flattens theObservableSource
s returned from these functions and emits the resulting items.final <@NonNull R>
@NonNull Observable<R> Observable.flatMap
(@NonNull Function<? super @NonNull T, ? extends ObservableSource<? extends @NonNull R>> onNextMapper, @NonNull Function<Throwable, ? extends ObservableSource<? extends @NonNull R>> onErrorMapper, @NonNull Supplier<? extends ObservableSource<? extends @NonNull R>> onCompleteSupplier, int maxConcurrency) Returns anObservable
that applies a function to each item emitted or notification raised by the currentObservable
and then flattens theObservableSource
s returned from these functions and emits the resulting items, while limiting the maximum number of concurrent subscriptions to theseObservableSource
s.final <@NonNull U,
@NonNull R>
@NonNull Observable<R> Observable.flatMap
(@NonNull Function<? super @NonNull T, ? extends ObservableSource<? extends @NonNull U>> mapper, @NonNull BiFunction<? super @NonNull T, ? super @NonNull U, ? extends @NonNull R> combiner) Returns anObservable
that emits the results of a specified function to the pair of values emitted by the currentObservable
and the mapped innerObservableSource
.final <@NonNull U,
@NonNull R>
@NonNull Observable<R> Observable.flatMap
(@NonNull Function<? super @NonNull T, ? extends ObservableSource<? extends @NonNull U>> mapper, @NonNull BiFunction<? super @NonNull T, ? super @NonNull U, ? extends @NonNull R> combiner, boolean delayErrors) Returns anObservable
that emits the results of a specified function to the pair of values emitted by the currentObservable
and the mapped innerObservableSource
.final <@NonNull U,
@NonNull R>
@NonNull Observable<R> Observable.flatMap
(@NonNull Function<? super @NonNull T, ? extends ObservableSource<? extends @NonNull U>> mapper, @NonNull BiFunction<? super @NonNull T, ? super @NonNull U, ? extends @NonNull R> combiner, boolean delayErrors, int maxConcurrency) Returns anObservable
that emits the results of a specified function to the pair of values emitted by the currentObservable
and the mapped innerObservableSource
, while limiting the maximum number of concurrent subscriptions to theseObservableSource
s.final <@NonNull U,
@NonNull R>
@NonNull Observable<R> Observable.flatMap
(@NonNull Function<? super @NonNull T, ? extends ObservableSource<? extends @NonNull U>> mapper, @NonNull BiFunction<? super @NonNull T, ? super @NonNull U, ? extends @NonNull R> combiner, boolean delayErrors, int maxConcurrency, int bufferSize) Returns anObservable
that emits the results of a specified function to the pair of values emitted by the currentObservable
and the mapped innerObservableSource
, while limiting the maximum number of concurrent subscriptions to theseObservableSource
s.final <@NonNull U,
@NonNull R>
@NonNull Observable<R> Observable.flatMap
(@NonNull Function<? super @NonNull T, ? extends ObservableSource<? extends @NonNull U>> mapper, @NonNull BiFunction<? super @NonNull T, ? super @NonNull U, ? extends @NonNull R> combiner, int maxConcurrency) Returns anObservable
that emits the results of a specified function to the pair of values emitted by the currentObservable
and the mapped innerObservableSource
, while limiting the maximum number of concurrent subscriptions to theseObservableSource
s.Single.flatMap
(@NonNull Function<? super @NonNull T, ? extends SingleSource<? extends @NonNull R>> mapper) Returns aSingle
that is based on applying a specified function to the item emitted by the currentSingle
, where that function returns aSingleSource
.Single.flatMap
(@NonNull Function<? super @NonNull T, ? extends SingleSource<? extends @NonNull R>> onSuccessMapper, @NonNull Function<? super Throwable, ? extends SingleSource<? extends @NonNull R>> onErrorMapper) Maps theonSuccess
oronError
signals of the currentSingle
into aSingleSource
and emits thatSingleSource
's signals.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 aSingle
that emits the results of a specified function to the pair of values emitted by the currentSingle
and a specified mappedSingleSource
.final @NonNull Completable
Flowable.flatMapCompletable
(@NonNull Function<? super @NonNull T, ? extends CompletableSource> mapper) Maps each element of the upstreamFlowable
intoCompletableSource
s, subscribes to them and waits until the upstream and allCompletableSource
s complete.final @NonNull Completable
Flowable.flatMapCompletable
(@NonNull Function<? super @NonNull T, ? extends CompletableSource> mapper, boolean delayErrors, int maxConcurrency) Maps each element of the upstreamFlowable
intoCompletableSource
s, subscribes to them and waits until the upstream and allCompletableSource
s complete, optionally delaying all errors.final @NonNull Completable
Maybe.flatMapCompletable
(@NonNull Function<? super @NonNull T, ? extends CompletableSource> mapper) Returns aCompletable
that completes based on applying a specified function to the item emitted by the currentMaybe
, where that function returns aCompletable
.final @NonNull Completable
Observable.flatMapCompletable
(@NonNull Function<? super @NonNull T, ? extends CompletableSource> mapper) Maps each element of the currentObservable
intoCompletableSource
s, subscribes to them and waits until the upstream and allCompletableSource
s complete.final @NonNull Completable
Observable.flatMapCompletable
(@NonNull Function<? super @NonNull T, ? extends CompletableSource> mapper, boolean delayErrors) Maps each element of the currentObservable
intoCompletableSource
s, subscribes to them and waits until the upstream and allCompletableSource
s complete, optionally delaying all errors.final @NonNull Completable
Single.flatMapCompletable
(@NonNull Function<? super @NonNull T, ? extends CompletableSource> mapper) Returns aCompletable
that completes based on applying a specified function to the item emitted by the currentSingle
, where that function returns aCompletableSource
.Flowable.flatMapIterable
(@NonNull Function<? super @NonNull T, @NonNull ? extends Iterable<? extends @NonNull U>> mapper) Flowable.flatMapIterable
(@NonNull Function<? super @NonNull T, @NonNull ? extends Iterable<? extends @NonNull U>> mapper, int bufferSize) Flowable.flatMapIterable
(@NonNull Function<? super @NonNull T, @NonNull ? extends Iterable<? extends @NonNull U>> mapper, @NonNull BiFunction<? super @NonNull T, ? super @NonNull U, ? extends @NonNull V> combiner) MergesIterable
s generated by a mapperFunction
for each individual item emitted by the currentFlowable
into a singleFlowable
sequence where the resulting items will be the combination of the original item and each inner item of the respectiveIterable
as returned by theresultSelector
BiFunction
.Flowable.flatMapIterable
(@NonNull Function<? super @NonNull T, @NonNull ? extends Iterable<? extends @NonNull U>> mapper, @NonNull BiFunction<? super @NonNull T, ? super @NonNull U, ? extends @NonNull V> combiner, int prefetch) MergesIterable
s generated by a mapperFunction
for each individual item emitted by the currentFlowable
into a singleFlowable
sequence where the resulting items will be the combination of the original item and each inner item of the respectiveIterable
as returned by theresultSelector
BiFunction
.final <@NonNull U>
@NonNull Observable<U> Observable.flatMapIterable
(@NonNull Function<? super @NonNull T, @NonNull ? extends Iterable<? extends @NonNull U>> mapper) final <@NonNull U,
@NonNull V>
@NonNull Observable<V> Observable.flatMapIterable
(@NonNull Function<? super @NonNull T, @NonNull ? extends Iterable<? extends @NonNull U>> mapper, @NonNull BiFunction<? super @NonNull T, ? super @NonNull U, ? extends @NonNull V> combiner) MergesIterable
s generated by a mapperFunction
for each individual item emitted by the currentObservable
into a singleObservable
sequence where the resulting items will be the combination of the original item and each inner item of the respectiveIterable
as returned by theresultSelector
BiFunction
.Flowable.flatMapMaybe
(@NonNull Function<? super @NonNull T, ? extends MaybeSource<? extends @NonNull R>> mapper) Maps each element of the upstreamFlowable
intoMaybeSource
s, subscribes to all of them and merges theironSuccess
values, in no particular order, into a singleFlowable
sequence.Flowable.flatMapMaybe
(@NonNull Function<? super @NonNull T, ? extends MaybeSource<? extends @NonNull R>> mapper, boolean delayErrors, int maxConcurrency) Maps each element of the upstreamFlowable
intoMaybeSource
s, subscribes to at mostmaxConcurrency
MaybeSource
s at a time and merges theironSuccess
values, in no particular order, into a singleFlowable
sequence, optionally delaying all errors.final <@NonNull R>
@NonNull Observable<R> Observable.flatMapMaybe
(@NonNull Function<? super @NonNull T, ? extends MaybeSource<? extends @NonNull R>> mapper) Maps each element of the currentObservable
intoMaybeSource
s, subscribes to all of them and merges theironSuccess
values, in no particular order, into a singleObservable
sequence.final <@NonNull R>
@NonNull Observable<R> Observable.flatMapMaybe
(@NonNull Function<? super @NonNull T, ? extends MaybeSource<? extends @NonNull R>> mapper, boolean delayErrors) Maps each element of the currentObservable
intoMaybeSource
s, subscribes to them and merges theironSuccess
values, in no particular order, into a singleObservable
sequence, optionally delaying all errors.Single.flatMapMaybe
(@NonNull Function<? super @NonNull T, ? extends MaybeSource<? extends @NonNull R>> mapper) Returns aMaybe
that is based on applying a specified function to the item emitted by the currentSingle
, where that function returns aMaybeSource
.final <@NonNull R>
@NonNull Observable<R> Maybe.flatMapObservable
(@NonNull Function<? super @NonNull T, ? extends ObservableSource<? extends @NonNull R>> mapper) Returns anObservable
that is based on applying a specified function to the item emitted by the currentMaybe
, where that function returns anObservableSource
.final <@NonNull R>
@NonNull Observable<R> Single.flatMapObservable
(@NonNull Function<? super @NonNull T, ? extends ObservableSource<? extends @NonNull R>> mapper) Returns anObservable
that is based on applying a specified function to the item emitted by the currentSingle
, where that function returns anObservableSource
.Maybe.flatMapPublisher
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper) Returns aFlowable
that emits items based on applying a specified function to the item emitted by the currentMaybe
, where that function returns aPublisher
.Single.flatMapPublisher
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper) Returns aFlowable
that emits items based on applying a specified function to the item emitted by the currentSingle
, where that function returns aPublisher
.Flowable.flatMapSingle
(@NonNull Function<? super @NonNull T, ? extends SingleSource<? extends @NonNull R>> mapper) Maps each element of the upstreamFlowable
intoSingleSource
s, subscribes to all of them and merges theironSuccess
values, in no particular order, into a singleFlowable
sequence.Flowable.flatMapSingle
(@NonNull Function<? super @NonNull T, ? extends SingleSource<? extends @NonNull R>> mapper, boolean delayErrors, int maxConcurrency) Maps each element of the upstreamFlowable
intoSingleSource
s, subscribes to at mostmaxConcurrency
SingleSource
s at a time and merges theironSuccess
values, in no particular order, into a singleFlowable
sequence, optionally delaying all errors.Maybe.flatMapSingle
(@NonNull Function<? super @NonNull T, ? extends SingleSource<? extends @NonNull R>> mapper) Returns aMaybe
based on applying a specified function to the item emitted by the currentMaybe
, where that function returns aSingle
.final <@NonNull R>
@NonNull Observable<R> Observable.flatMapSingle
(@NonNull Function<? super @NonNull T, ? extends SingleSource<? extends @NonNull R>> mapper) Maps each element of the currentObservable
intoSingleSource
s, subscribes to all of them and merges theironSuccess
values, in no particular order, into a singleObservable
sequence.final <@NonNull R>
@NonNull Observable<R> Observable.flatMapSingle
(@NonNull Function<? super @NonNull T, ? extends SingleSource<? extends @NonNull R>> mapper, boolean delayErrors) Maps each element of the currentObservable
intoSingleSource
s, subscribes to them and merges theironSuccess
values, in no particular order, into a singleObservable
sequence, optionally delaying all errors.Flowable.flatMapStream
(@NonNull Function<? super @NonNull T, @NonNull ? extends Stream<? extends @NonNull R>> mapper) Maps each upstream item into aStream
and emits theStream
's items to the downstream in a sequential fashion.Flowable.flatMapStream
(@NonNull Function<? super @NonNull T, @NonNull ? extends Stream<? extends @NonNull R>> mapper, int prefetch) Maps each upstream item into aStream
and emits theStream
's items to the downstream in a sequential fashion.final <@NonNull R>
@NonNull Observable<R> Observable.flatMapStream
(@NonNull Function<? super @NonNull T, @NonNull ? extends Stream<? extends @NonNull R>> mapper) Maps each upstream item into aStream
and emits theStream
's items to the downstream in a sequential fashion.Maybe.flattenAsFlowable
(@NonNull Function<? super @NonNull T, @NonNull ? extends Iterable<? extends @NonNull U>> mapper) Single.flattenAsFlowable
(@NonNull Function<? super @NonNull T, @NonNull ? extends Iterable<? extends @NonNull U>> mapper) final <@NonNull U>
@NonNull Observable<U> Maybe.flattenAsObservable
(@NonNull Function<? super @NonNull T, @NonNull ? extends Iterable<? extends @NonNull U>> mapper) Maps the success value of the currentMaybe
into anIterable
and emits its items as anObservable
sequence.final <@NonNull U>
@NonNull Observable<U> Single.flattenAsObservable
(@NonNull Function<@NonNull ? super @NonNull T, @NonNull ? extends Iterable<? extends @NonNull U>> mapper) Maps the success value of the currentSingle
into anIterable
and emits its items as anObservable
sequence.Maybe.flattenStreamAsFlowable
(@NonNull Function<? super @NonNull T, @NonNull ? extends Stream<? extends @NonNull R>> mapper) Single.flattenStreamAsFlowable
(@NonNull Function<? super @NonNull T, @NonNull ? extends Stream<? extends @NonNull R>> mapper) final <@NonNull R>
@NonNull Observable<R> Maybe.flattenStreamAsObservable
(@NonNull Function<? super @NonNull T, @NonNull ? extends Stream<? extends @NonNull R>> mapper) Maps the upstream succecss value into a JavaStream
and emits its items to the downstream consumer as anObservable
.final <@NonNull R>
@NonNull Observable<R> Single.flattenStreamAsObservable
(@NonNull Function<? super @NonNull T, @NonNull ? extends Stream<? extends @NonNull R>> mapper) Maps the upstream succecss value into a JavaStream
and emits its items to the downstream consumer as anObservable
.final @NonNull Disposable
Subscribes to the currentFlowable
and receives notifications for each element.final @NonNull Disposable
Subscribes to theObservableSource
and calls aConsumer
for each item of the currentObservable
on its emission thread.final @NonNull Disposable
Flowable.forEachWhile
(@NonNull Predicate<? super @NonNull T> onNext) Subscribes to the currentFlowable
and receives notifications for each element until theonNext
Predicate returnsfalse
.final @NonNull Disposable
Flowable.forEachWhile
(@NonNull Predicate<? super @NonNull T> onNext, @NonNull Consumer<? super Throwable> onError) Subscribes to the currentFlowable
and receives notifications for each element and error events until theonNext
Predicate returnsfalse
.final @NonNull Disposable
Flowable.forEachWhile
(@NonNull Predicate<? super @NonNull T> onNext, @NonNull Consumer<? super Throwable> onError, @NonNull Action onComplete) Subscribes to the currentFlowable
and receives notifications for each element and the terminal events until theonNext
Predicate returnsfalse
.final @NonNull Disposable
Observable.forEachWhile
(@NonNull Predicate<? super @NonNull T> onNext) Subscribes to theObservableSource
and calls aPredicate
for each item of the currentObservable
, on its emission thread, until the predicate returnsfalse
.final @NonNull Disposable
Observable.forEachWhile
(@NonNull Predicate<? super @NonNull T> onNext, @NonNull Consumer<? super Throwable> onError) Subscribes to theObservableSource
and calls aPredicate
for each item or aConsumer
with the error of the currentObservable
, on their original emission threads, until the predicate returnsfalse
.final @NonNull Disposable
Observable.forEachWhile
(@NonNull Predicate<? super @NonNull T> onNext, @NonNull Consumer<? super Throwable> onError, @NonNull Action onComplete) Subscribes to theObservableSource
and calls aPredicate
for each item, aConsumer
with the error or anAction
upon completion of the currentObservable
, on their original emission threads, until the predicate returnsfalse
.static @NonNull Completable
Completable.fromAction
(@NonNull Action action) Returns aCompletable
instance that runs the givenAction
for eachCompletableObserver
and emits either an exception or simply completes.Flowable.fromAction
(@NonNull Action action) Returns aFlowable
instance that runs the givenAction
for eachSubscriber
and emits either its exception or simply completes.Maybe.fromAction
(@NonNull Action action) Returns aMaybe
instance that runs the givenAction
for eachMaybeObserver
and emits either its exception or simply completes.static <@NonNull T>
@NonNull Observable<T> Observable.fromAction
(@NonNull Action action) Converts an array into aPublisher
that emits the items in the array.static <@NonNull T>
@NonNull Observable<T> Converts an array into anObservableSource
that emits the items in the array.static @NonNull Completable
Completable.fromCallable
(@NonNull Callable<?> callable) Returns aCompletable
which when subscribed, executes theCallable
function, ignores its normal result and emitsonError
oronComplete
only.Flowable.fromCallable
(@NonNull Callable<? extends @NonNull T> callable) Returns aFlowable
that, when aSubscriber
subscribes to it, invokes a function you specify and then emits the value returned from that function.Maybe.fromCallable
(@NonNull Callable<? extends @Nullable T> callable) Returns aMaybe
that invokes the givenCallable
for each individualMaybeObserver
that subscribes and emits the resulting non-null
item viaonSuccess
while considering anull
result from theCallable
as indication for valueless completion viaonComplete
.static <@NonNull T>
@NonNull Observable<T> Observable.fromCallable
(@NonNull Callable<? extends @NonNull T> callable) Returns anObservable
that, when an observer subscribes to it, invokes a function you specify and then emits the value returned from that function.Single.fromCallable
(@NonNull Callable<? extends @NonNull T> callable) Returns aSingle
that invokes the givenCallable
for each incomingSingleObserver
and emits its value or exception to them.Flowable.fromCompletable
(@NonNull CompletableSource completableSource) Wraps aCompletableSource
into aFlowable
.Maybe.fromCompletable
(@NonNull CompletableSource completableSource) Wraps aCompletableSource
into aMaybe
.static <@NonNull T>
@NonNull Observable<T> Observable.fromCompletable
(@NonNull CompletableSource completableSource) Wraps aCompletableSource
into anObservable
.static @NonNull Completable
Completable.fromCompletionStage
(@NonNull CompletionStage<?> stage) Signals completion (or error) when theCompletionStage
terminates.Flowable.fromCompletionStage
(@NonNull CompletionStage<@NonNull T> stage) Signals the completion value or error of the given (hot)CompletionStage
-based asynchronous calculation.Maybe.fromCompletionStage
(@NonNull CompletionStage<@NonNull T> stage) Signals the completion value or error of the given (hot)CompletionStage
-based asynchronous calculation.static <@NonNull T>
@NonNull Observable<@NonNull T> Observable.fromCompletionStage
(@NonNull CompletionStage<@NonNull T> stage) Signals the completion value or error of the given (hot)CompletionStage
-based asynchronous calculation.Single.fromCompletionStage
(@NonNull CompletionStage<@NonNull T> stage) Signals the completion value or error of the given (hot)CompletionStage
-based asynchronous calculation.static @NonNull Completable
Completable.fromFuture
(@NonNull Future<?> future) Returns aCompletable
instance that reacts to the termination of the givenFuture
in a blocking fashion.Flowable.fromFuture
(@NonNull Future<? extends @NonNull T> future) Converts aFuture
into aPublisher
.Flowable.fromFuture
(@NonNull Future<? extends @NonNull T> future, long timeout, @NonNull TimeUnit unit) Maybe.fromFuture
(@NonNull Future<? extends @NonNull T> future) Maybe.fromFuture
(@NonNull Future<? extends @NonNull T> future, long timeout, @NonNull TimeUnit unit) static <@NonNull T>
@NonNull Observable<T> Observable.fromFuture
(@NonNull Future<? extends @NonNull T> future) Converts aFuture
into anObservable
.static <@NonNull T>
@NonNull Observable<T> Observable.fromFuture
(@NonNull Future<? extends @NonNull T> future, long timeout, @NonNull TimeUnit unit) Single.fromFuture
(@NonNull Future<? extends @NonNull T> future) Converts aFuture
into aSingle
and awaits its outcome in a blocking fashion.Single.fromFuture
(@NonNull Future<? extends @NonNull T> future, long timeout, @NonNull TimeUnit unit) Converts aFuture
into aSingle
and awaits its outcome, or timeout, in a blocking fashion.Flowable.fromIterable
(@NonNull Iterable<? extends @NonNull T> source) Converts anIterable
sequence into aPublisher
that emits the items in the sequence.static <@NonNull T>
@NonNull Observable<T> Observable.fromIterable
(@NonNull Iterable<? extends @NonNull T> source) Converts anIterable
sequence into anObservable
that emits the items in the sequence.static <@NonNull T>
@NonNull CompletableCompletable.fromMaybe
(@NonNull MaybeSource<@NonNull T> maybe) Returns aCompletable
instance that when subscribed to, subscribes to theMaybeSource
instance and emits anonComplete
event if the maybe emitsonSuccess
/onComplete
or forwards anyonError
events.Flowable.fromMaybe
(@NonNull MaybeSource<@NonNull T> maybe) Returns aFlowable
instance that when subscribed to, subscribes to theMaybeSource
instance and emitsonSuccess
as a single item or forwards anyonComplete
oronError
signal.static <@NonNull T>
@NonNull Observable<T> Observable.fromMaybe
(@NonNull MaybeSource<@NonNull T> maybe) Returns anObservable
instance that when subscribed to, subscribes to theMaybeSource
instance and emitsonSuccess
as a single item or forwards anyonComplete
oronError
signal.Single.fromMaybe
(@NonNull MaybeSource<@NonNull T> maybe) Returns aSingle
instance that when subscribed to, subscribes to theMaybeSource
instance and emitsonSuccess
as a single item, turns anonComplete
intoNoSuchElementException
error signal or forwards theonError
signal.Single.fromMaybe
(@NonNull MaybeSource<@NonNull T> maybe, @NonNull T defaultItem) Returns aSingle
instance that when subscribed to, subscribes to theMaybeSource
instance and emitsonSuccess
as a single item, emits thedefaultItem
for anonComplete
signal or forwards theonError
signal.static <@NonNull T>
@NonNull CompletableCompletable.fromObservable
(@NonNull ObservableSource<@NonNull T> observable) Returns aCompletable
instance that subscribes to the givenObservableSource
, ignores all values and emits only the terminal event.Flowable.fromObservable
(@NonNull ObservableSource<@NonNull T> source, @NonNull BackpressureStrategy strategy) Converts the givenObservableSource
into aFlowable
by applying the specified backpressure strategy.Maybe.fromObservable
(@NonNull ObservableSource<@NonNull T> source) Wraps anObservableSource
into aMaybe
and emits the very first item or completes if the source is empty.Single.fromObservable
(@NonNull ObservableSource<? extends @NonNull T> observable) Wraps a specificObservableSource
into aSingle
and signals its single element or error.Flowable.fromOptional
(@NonNull Optional<@NonNull T> optional) Converts the existing value of the provided optional into aFlowable.just(Object)
or an empty optional into anFlowable.empty()
Flowable
instance.Maybe.fromOptional
(@NonNull Optional<@NonNull T> optional) Converts the existing value of the provided optional into aMaybe.just(Object)
or an empty optional into anMaybe.empty()
Maybe
instance.static <@NonNull T>
@NonNull Observable<@NonNull T> Observable.fromOptional
(@NonNull Optional<@NonNull T> optional) Converts the existing value of the provided optional into aObservable.just(Object)
or an empty optional into anObservable.empty()
Observable
instance.static <@NonNull T>
@NonNull CompletableCompletable.fromPublisher
(@NonNull org.reactivestreams.Publisher<@NonNull T> publisher) Returns aCompletable
instance that subscribes to the givenPublisher
, ignores all values and emits only the terminal event.Flowable.fromPublisher
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T> publisher) Converts an arbitrary Reactive StreamsPublisher
into aFlowable
if not already aFlowable
.Maybe.fromPublisher
(@NonNull org.reactivestreams.Publisher<@NonNull T> source) Wraps aPublisher
into aMaybe
and emits the very first item or completes if the source is empty.static <@NonNull T>
@NonNull Observable<T> Observable.fromPublisher
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T> publisher) Converts an arbitrary Reactive StreamsPublisher
into anObservable
.Single.fromPublisher
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T> publisher) Wraps a specificPublisher
into aSingle
and signals its single element or error.static @NonNull Completable
Completable.fromRunnable
(@NonNull Runnable run) Returns aCompletable
instance that runs the givenRunnable
for eachCompletableObserver
and emits either its unchecked exception or simply completes.Flowable.fromRunnable
(@NonNull Runnable run) Returns aFlowable
instance that runs the givenRunnable
for eachSubscriber
and emits either its unchecked exception or simply completes.Maybe.fromRunnable
(@NonNull Runnable run) Returns aMaybe
instance that runs the givenRunnable
for eachMaybeObserver
and emits either its unchecked exception or simply completes.static <@NonNull T>
@NonNull Observable<T> Observable.fromRunnable
(@NonNull Runnable run) static <@NonNull T>
@NonNull CompletableCompletable.fromSingle
(@NonNull SingleSource<@NonNull T> single) Returns aCompletable
instance that when subscribed to, subscribes to theSingleSource
instance and emits a completion event if the single emitsonSuccess
or forwards anyonError
events.Flowable.fromSingle
(@NonNull SingleSource<@NonNull T> source) Returns aFlowable
instance that when subscribed to, subscribes to theSingleSource
instance and emitsonSuccess
as a single item or forwards theonError
signal.Maybe.fromSingle
(@NonNull SingleSource<@NonNull T> single) Wraps aSingleSource
into aMaybe
.static <@NonNull T>
@NonNull Observable<T> Observable.fromSingle
(@NonNull SingleSource<@NonNull T> source) Returns anObservable
instance that when subscribed to, subscribes to theSingleSource
instance and emitsonSuccess
as a single item or forwards theonError
signal.Flowable.fromStream
(@NonNull Stream<@NonNull T> stream) Converts aStream
into a finiteFlowable
and emits its items in the sequence.static <@NonNull T>
@NonNull Observable<@NonNull T> Observable.fromStream
(@NonNull Stream<@NonNull T> stream) Converts aStream
into a finiteObservable
and emits its items in the sequence.static @NonNull Completable
Completable.fromSupplier
(@NonNull Supplier<?> supplier) Returns aCompletable
which when subscribed, executes theSupplier
function, ignores its normal result and emitsonError
oronComplete
only.Flowable.fromSupplier
(@NonNull Supplier<? extends @NonNull T> supplier) Returns aFlowable
that, when aSubscriber
subscribes to it, invokes a supplier function you specify and then emits the value returned from that function.Maybe.fromSupplier
(@NonNull Supplier<? extends @Nullable T> supplier) Returns aMaybe
that invokes the givenSupplier
for each individualMaybeObserver
that subscribes and emits the resulting non-null
item viaonSuccess
while considering anull
result from theSupplier
as indication for valueless completion viaonComplete
.static <@NonNull T>
@NonNull Observable<T> Observable.fromSupplier
(@NonNull Supplier<? extends @NonNull T> supplier) Returns anObservable
that, when an observer subscribes to it, invokes a supplier function you specify and then emits the value returned from that function.Single.fromSupplier
(@NonNull Supplier<? extends @NonNull T> supplier) Returns aSingle
that invokes passed supplier and emits its result for each individualSingleObserver
that subscribes.Returns a cold, synchronous, stateless and backpressure-aware generator of values.Flowable.generate
(@NonNull Supplier<@NonNull S> initialState, @NonNull BiConsumer<@NonNull S, Emitter<@NonNull T>> generator) Returns a cold, synchronous, stateful and backpressure-aware generator of values.Flowable.generate
(@NonNull Supplier<@NonNull S> initialState, @NonNull BiConsumer<@NonNull S, Emitter<@NonNull T>> generator, @NonNull Consumer<? super @NonNull S> disposeState) Returns a cold, synchronous, stateful and backpressure-aware generator of values.Flowable.generate
(@NonNull Supplier<@NonNull S> initialState, @NonNull BiFunction<@NonNull S, @NonNull Emitter<@NonNull T>, @NonNull S> generator) Returns a cold, synchronous, stateful and backpressure-aware generator of values.Flowable.generate
(@NonNull Supplier<@NonNull S> initialState, @NonNull BiFunction<@NonNull S, @NonNull Emitter<@NonNull T>, @NonNull S> generator, @NonNull Consumer<? super @NonNull S> disposeState) Returns a cold, synchronous, stateful and backpressure-aware generator of values.static <@NonNull T>
@NonNull Observable<T> Returns a cold, synchronous and stateless generator of values.static <@NonNull T,
@NonNull S>
@NonNull Observable<T> Observable.generate
(@NonNull Supplier<@NonNull S> initialState, @NonNull BiConsumer<@NonNull S, Emitter<@NonNull T>> generator) Returns a cold, synchronous and stateful generator of values.static <@NonNull T,
@NonNull S>
@NonNull Observable<T> Observable.generate
(@NonNull Supplier<@NonNull S> initialState, @NonNull BiConsumer<@NonNull S, Emitter<@NonNull T>> generator, @NonNull Consumer<? super @NonNull S> disposeState) Returns a cold, synchronous and stateful generator of values.static <@NonNull T,
@NonNull S>
@NonNull Observable<T> Observable.generate
(@NonNull Supplier<@NonNull S> initialState, @NonNull BiFunction<@NonNull S, Emitter<@NonNull T>, @NonNull S> generator) Returns a cold, synchronous and stateful generator of values.static <@NonNull T,
@NonNull S>
@NonNull Observable<T> Observable.generate
(@NonNull Supplier<@NonNull S> initialState, @NonNull BiFunction<@NonNull S, Emitter<@NonNull T>, @NonNull S> generator, @NonNull Consumer<? super @NonNull S> disposeState) Returns a cold, synchronous and stateful generator of values.final <@NonNull K>
@NonNull Flowable<GroupedFlowable<K, T>> Groups the items emitted by the currentFlowable
according to a specified criterion, and emits these grouped items asGroupedFlowable
s.final <@NonNull K>
@NonNull Flowable<GroupedFlowable<K, T>> Flowable.groupBy
(@NonNull Function<? super @NonNull T, ? extends @NonNull K> keySelector, boolean delayError) Groups the items emitted by the currentFlowable
according to a specified criterion, and emits these grouped items asGroupedFlowable
s.final <@NonNull K,
@NonNull V>
@NonNull Flowable<GroupedFlowable<K, V>> Flowable.groupBy
(@NonNull Function<? super @NonNull T, ? extends @NonNull K> keySelector, @NonNull Function<? super @NonNull T, ? extends @NonNull V> valueSelector) Groups the items emitted by the currentFlowable
according to a specified criterion, and emits these grouped items asGroupedFlowable
s.final <@NonNull K,
@NonNull V>
@NonNull Flowable<GroupedFlowable<K, V>> Flowable.groupBy
(@NonNull Function<? super @NonNull T, ? extends @NonNull K> keySelector, @NonNull Function<? super @NonNull T, ? extends @NonNull V> valueSelector, boolean delayError) Groups the items emitted by the currentFlowable
according to a specified criterion, and emits these grouped items asGroupedFlowable
s.final <@NonNull K,
@NonNull V>
@NonNull Flowable<GroupedFlowable<K, V>> Flowable.groupBy
(@NonNull Function<? super @NonNull T, ? extends @NonNull K> keySelector, @NonNull Function<? super @NonNull T, ? extends @NonNull V> valueSelector, boolean delayError, int bufferSize) Groups the items emitted by the currentFlowable
according to a specified criterion, and emits these grouped items asGroupedFlowable
s.final <@NonNull K,
@NonNull V>
@NonNull Flowable<GroupedFlowable<K, V>> Flowable.groupBy
(@NonNull Function<? super @NonNull T, ? extends @NonNull K> keySelector, @NonNull Function<? super @NonNull T, ? extends @NonNull V> valueSelector, boolean delayError, int bufferSize, @NonNull Function<? super Consumer<Object>, ? extends Map<@NonNull K, Object>> evictingMapFactory) Groups the items emitted by the currentFlowable
according to a specified criterion, and emits these grouped items asGroupedFlowable
s.final <@NonNull K>
@NonNull Observable<GroupedObservable<K, T>> Groups the items emitted by the currentObservable
according to a specified criterion, and emits these grouped items asGroupedObservable
s.final <@NonNull K>
@NonNull Observable<GroupedObservable<K, T>> Observable.groupBy
(@NonNull Function<? super @NonNull T, ? extends @NonNull K> keySelector, boolean delayError) Groups the items emitted by the currentObservable
according to a specified criterion, and emits these grouped items asGroupedObservable
s.final <@NonNull K,
@NonNull V>
@NonNull Observable<GroupedObservable<K, V>> Observable.groupBy
(@NonNull Function<? super @NonNull T, ? extends @NonNull K> keySelector, @NonNull Function<? super @NonNull T, ? extends @NonNull V> valueSelector, boolean delayError) Groups the items emitted by the currentObservable
according to a specified criterion, and emits these grouped items asGroupedObservable
s.final <@NonNull K,
@NonNull V>
@NonNull Observable<GroupedObservable<K, V>> Observable.groupBy
(@NonNull Function<? super @NonNull T, ? extends @NonNull K> keySelector, @NonNull Function<? super @NonNull T, ? extends @NonNull V> valueSelector, boolean delayError, int bufferSize) Groups the items emitted by the currentObservable
according to a specified criterion, and emits these grouped items asGroupedObservable
s.final <@NonNull K,
@NonNull V>
@NonNull Observable<GroupedObservable<K, V>> Observable.groupBy
(@NonNull Function<? super @NonNull T, ? extends @NonNull K> keySelector, Function<? super @NonNull T, ? extends @NonNull V> valueSelector) Groups the items emitted by the currentObservable
according to a specified criterion, and emits these grouped items asGroupedObservable
s.Flowable.groupJoin
(@NonNull org.reactivestreams.Publisher<? extends @NonNull TRight> other, @NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<@NonNull TLeftEnd>> leftEnd, @NonNull Function<? super @NonNull TRight, @NonNull ? extends org.reactivestreams.Publisher<@NonNull TRightEnd>> rightEnd, @NonNull BiFunction<? super @NonNull T, ? super Flowable<@NonNull TRight>, ? extends @NonNull R> resultSelector) Returns aFlowable
that correlates twoPublisher
s when they overlap in time and groups the results.Observable.groupJoin
(@NonNull ObservableSource<? extends @NonNull TRight> other, @NonNull Function<? super @NonNull T, ? extends ObservableSource<@NonNull TLeftEnd>> leftEnd, @NonNull Function<? super @NonNull TRight, ? extends ObservableSource<@NonNull TRightEnd>> rightEnd, @NonNull BiFunction<? super @NonNull T, ? super Observable<@NonNull TRight>, ? extends @NonNull R> resultSelector) Returns anObservable
that correlates twoObservableSource
s when they overlap in time and groups the results.final @NonNull Completable
Completable.hide()
Hides the identity of thisCompletable
and itsDisposable
.Flowable.hide()
Hides the identity of thisFlowable
and itsSubscription
.Maybe.hide()
Hides the identity of thisMaybe
and itsDisposable
.final @NonNull Observable
<T> Observable.hide()
Hides the identity of the currentObservable
and itsDisposable
.Single.hide()
Hides the identity of the currentSingle
, including theDisposable
that is sent to the downstream viaonSubscribe()
.final @NonNull Completable
Maybe.ignoreElement()
Returns aCompletable
that ignores the item emitted by the currentMaybe
and only callsonComplete
oronError
.final @NonNull Completable
Single.ignoreElement()
final @NonNull Completable
Flowable.ignoreElements()
Ignores all items emitted by the currentFlowable
and only callsonComplete
oronError
.final @NonNull Completable
Observable.ignoreElements()
Ignores all items emitted by the currentObservable
and only callsonComplete
oronError
.Returns aFlowable
that emits a0L
after theinitialDelay
and ever-increasing numbers after eachperiod
of time thereafter.Flowable.interval
(long initialDelay, long period, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Returns aFlowable
that emits a0L
after theinitialDelay
and ever-increasing numbers after eachperiod
of time thereafter, on a specifiedScheduler
.Returns aFlowable
that emits a sequential number every specified interval of time.Returns aFlowable
that emits a sequential number every specified interval of time, on a specifiedScheduler
.static @NonNull Observable
<Long> Returns anObservable
that emits a0L
after theinitialDelay
and ever increasing numbers after eachperiod
of time thereafter.static @NonNull Observable
<Long> Observable.interval
(long initialDelay, long period, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Returns anObservable
that emits a0L
after theinitialDelay
and ever increasing numbers after eachperiod
of time thereafter, on a specifiedScheduler
.static @NonNull Observable
<Long> Returns anObservable
that emits a sequential number every specified interval of time.static @NonNull Observable
<Long> Returns anObservable
that emits a sequential number every specified interval of time, on a specifiedScheduler
.Flowable.intervalRange
(long start, long count, long initialDelay, long period, @NonNull TimeUnit unit) Signals a range of long values, the first after some initial delay and the rest periodically after.Flowable.intervalRange
(long start, long count, long initialDelay, long period, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Signals a range of long values, the first after some initial delay and the rest periodically after.static @NonNull Observable
<Long> Observable.intervalRange
(long start, long count, long initialDelay, long period, @NonNull TimeUnit unit) Signals a range of long values, the first after some initial delay and the rest periodically after.static @NonNull Observable
<Long> Observable.intervalRange
(long start, long count, long initialDelay, long period, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Signals a range of long values, the first after some initial delay and the rest periodically after.Flowable.isEmpty()
Maybe.isEmpty()
Observable.isEmpty()
Flowable.join
(@NonNull org.reactivestreams.Publisher<? extends @NonNull TRight> other, @NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<@NonNull TLeftEnd>> leftEnd, @NonNull Function<? super @NonNull TRight, @NonNull ? extends org.reactivestreams.Publisher<@NonNull TRightEnd>> rightEnd, @NonNull BiFunction<? super @NonNull T, ? super @NonNull TRight, ? extends @NonNull R> resultSelector) Correlates the items emitted by twoPublisher
s based on overlapping durations.Observable.join
(@NonNull ObservableSource<? extends @NonNull TRight> other, @NonNull Function<? super @NonNull T, ? extends ObservableSource<@NonNull TLeftEnd>> leftEnd, @NonNull Function<? super @NonNull TRight, ? extends ObservableSource<@NonNull TRightEnd>> rightEnd, @NonNull BiFunction<? super @NonNull T, ? super @NonNull TRight, ? extends @NonNull R> resultSelector) Correlates the items emitted by twoObservableSource
s based on overlapping durations.Returns aFlowable
that signals the given (constant reference) item and then completes.Converts two items into aPublisher
that emits those items.Converts three items into aPublisher
that emits those items.Converts four items into aPublisher
that emits those items.Flowable.just
(@NonNull T item1, @NonNull T item2, @NonNull T item3, @NonNull T item4, @NonNull T item5) Converts five items into aPublisher
that emits those items.Flowable.just
(@NonNull T item1, @NonNull T item2, @NonNull T item3, @NonNull T item4, @NonNull T item5, @NonNull T item6) Converts six items into aPublisher
that emits those items.Flowable.just
(@NonNull T item1, @NonNull T item2, @NonNull T item3, @NonNull T item4, @NonNull T item5, @NonNull T item6, @NonNull T item7) Converts seven items into aPublisher
that emits those items.Flowable.just
(@NonNull T item1, @NonNull T item2, @NonNull T item3, @NonNull T item4, @NonNull T item5, @NonNull T item6, @NonNull T item7, @NonNull T item8) Converts eight items into aPublisher
that emits those items.Flowable.just
(@NonNull T item1, @NonNull T item2, @NonNull T item3, @NonNull T item4, @NonNull T item5, @NonNull T item6, @NonNull T item7, @NonNull T item8, @NonNull T item9) Converts nine items into aPublisher
that emits those items.Flowable.just
(@NonNull T item1, @NonNull T item2, @NonNull T item3, @NonNull T item4, @NonNull T item5, @NonNull T item6, @NonNull T item7, @NonNull T item8, @NonNull T item9, @NonNull T item10) Converts ten items into aPublisher
that emits those items.Returns aMaybe
that emits a specified item.static <@NonNull T>
@NonNull Observable<T> Returns anObservable
that signals the given (constant reference) item and then completes.static <@NonNull T>
@NonNull Observable<T> Converts two items into anObservable
that emits those items.static <@NonNull T>
@NonNull Observable<T> Converts three items into anObservable
that emits those items.static <@NonNull T>
@NonNull Observable<T> Converts four items into anObservable
that emits those items.static <@NonNull T>
@NonNull Observable<T> Observable.just
(@NonNull T item1, @NonNull T item2, @NonNull T item3, @NonNull T item4, @NonNull T item5) Converts five items into anObservable
that emits those items.static <@NonNull T>
@NonNull Observable<T> Observable.just
(@NonNull T item1, @NonNull T item2, @NonNull T item3, @NonNull T item4, @NonNull T item5, @NonNull T item6) Converts six items into anObservable
that emits those items.static <@NonNull T>
@NonNull Observable<T> Observable.just
(@NonNull T item1, @NonNull T item2, @NonNull T item3, @NonNull T item4, @NonNull T item5, @NonNull T item6, @NonNull T item7) Converts seven items into anObservable
that emits those items.static <@NonNull T>
@NonNull Observable<T> Observable.just
(@NonNull T item1, @NonNull T item2, @NonNull T item3, @NonNull T item4, @NonNull T item5, @NonNull T item6, @NonNull T item7, @NonNull T item8) Converts eight items into anObservable
that emits those items.static <@NonNull T>
@NonNull Observable<T> Observable.just
(@NonNull T item1, @NonNull T item2, @NonNull T item3, @NonNull T item4, @NonNull T item5, @NonNull T item6, @NonNull T item7, @NonNull T item8, @NonNull T item9) Converts nine items into anObservable
that emits those items.static <@NonNull T>
@NonNull Observable<T> Observable.just
(@NonNull T item1, @NonNull T item2, @NonNull T item3, @NonNull T item4, @NonNull T item5, @NonNull T item6, @NonNull T item7, @NonNull T item8, @NonNull T item9, @NonNull T item10) Converts ten items into anObservable
that emits those items.Returns aSingle
that emits a specified item.Returns aSingle
that emits only the last item emitted by thisFlowable
, or a default item if thisFlowable
completes without emitting any items.Returns aSingle
that emits only the last item emitted by the currentObservable
, or a default item if the currentObservable
completes without emitting any items.Flowable.lastElement()
Returns aMaybe
that emits the last item emitted by thisFlowable
or completes if thisFlowable
is empty.Observable.lastElement()
Returns aMaybe
that emits the last item emitted by the currentObservable
or completes if the currentObservable
is empty.Flowable.lastOrError()
Returns aSingle
that emits only the last item emitted by thisFlowable
or signals aNoSuchElementException
if thisFlowable
is empty.Observable.lastOrError()
Returns aSingle
that emits only the last item emitted by the currentObservable
or signals aNoSuchElementException
if the currentObservable
is empty.final @NonNull CompletionStage
<T> Flowable.lastOrErrorStage()
Signals the last upstream item or aNoSuchElementException
if the upstream is empty via aCompletionStage
.final @NonNull CompletionStage
<T> Observable.lastOrErrorStage()
Signals the last upstream item or aNoSuchElementException
if the upstream is empty via aCompletionStage
.final @NonNull CompletionStage
<T> Signals the last upstream item (or the default item if the upstream is empty) via aCompletionStage
.final @NonNull CompletionStage
<T> Signals the last upstream item (or the default item if the upstream is empty) via aCompletionStage
.final @NonNull Completable
Completable.lift
(@NonNull CompletableOperator onLift) This method requires advanced knowledge about building operators, please consider other standard composition methods first; Returns aCompletable
which, when subscribed to, invokes theapply(CompletableObserver)
method of the providedCompletableOperator
for each individual downstreamCompletable
and allows the insertion of a custom operator by accessing the downstream'sCompletableObserver
during this subscription phase and providing a newCompletableObserver
, containing the custom operator's intended business logic, that will be used in the subscription process going further upstream.This method requires advanced knowledge about building operators, please consider other standard composition methods first; Returns aFlowable
which, when subscribed to, invokes theapply(Subscriber)
method of the providedFlowableOperator
for each individual downstreamSubscriber
and allows the insertion of a custom operator by accessing the downstream'sSubscriber
during this subscription phase and providing a newSubscriber
, containing the custom operator's intended business logic, that will be used in the subscription process going further upstream.This method requires advanced knowledge about building operators, please consider other standard composition methods first; Returns aMaybe
which, when subscribed to, invokes theapply(MaybeObserver)
method of the providedMaybeOperator
for each individual downstreamMaybe
and allows the insertion of a custom operator by accessing the downstream'sMaybeObserver
during this subscription phase and providing a newMaybeObserver
, containing the custom operator's intended business logic, that will be used in the subscription process going further upstream.final <@NonNull R>
@NonNull Observable<R> This method requires advanced knowledge about building operators, please consider other standard composition methods first; Returns anObservable
which, when subscribed to, invokes theapply(Observer)
method of the providedObservableOperator
for each individual downstreamObserver
and allows the insertion of a custom operator by accessing the downstream'sObserver
during this subscription phase and providing a newObserver
, containing the custom operator's intended business logic, that will be used in the subscription process going further upstream.This method requires advanced knowledge about building operators, please consider other standard composition methods first; Returns aSingle
which, when subscribed to, invokes theapply(SingleObserver)
method of the providedSingleOperator
for each individual downstreamSingle
and allows the insertion of a custom operator by accessing the downstream'sSingleObserver
during this subscription phase and providing a newSingleObserver
, containing the custom operator's intended business logic, that will be used in the subscription process going further upstream.Returns aFlowable
that applies a specified function to each item emitted by the currentFlowable
and emits the results of these function applications.Returns aMaybe
that applies a specified function to the item emitted by the currentMaybe
and emits the result of this function application.final <@NonNull R>
@NonNull Observable<R> Returns anObservable
that applies a specified function to each item emitted by the currentObservable
and emits the results of these function applications.Returns aSingle
that applies a specified function to the item emitted by the currentSingle
and emits the result of this function application.Flowable.mapOptional
(@NonNull Function<? super @NonNull T, @NonNull Optional<? extends @NonNull R>> mapper) Maps each upstream value into anOptional
and emits the contained item if not empty.Maybe.mapOptional
(@NonNull Function<? super @NonNull T, @NonNull Optional<? extends @NonNull R>> mapper) Maps the upstream success value into anOptional
and emits the contained item if not empty.final <@NonNull R>
@NonNull Observable<R> Observable.mapOptional
(@NonNull Function<? super @NonNull T, @NonNull Optional<? extends @NonNull R>> mapper) Maps each upstream value into anOptional
and emits the contained item if not empty.Single.mapOptional
(@NonNull Function<? super @NonNull T, @NonNull Optional<? extends @NonNull R>> mapper) final <@NonNull T>
@NonNull Single<Notification<T>> Completable.materialize()
Maps the signal types of thisCompletable
into aNotification
of the same kind and emits it as a single success value to downstream.final @NonNull Flowable
<Notification<T>> Flowable.materialize()
Returns aFlowable
that represents all of the emissions and notifications from the currentFlowable
into emissions marked with their original types withinNotification
objects.final @NonNull Single
<Notification<T>> Maybe.materialize()
Maps the signal types of thisMaybe
into aNotification
of the same kind and emits it as aSingle
'sonSuccess
value to downstream.final @NonNull Observable
<Notification<T>> Observable.materialize()
Returns anObservable
that represents all of the emissions and notifications from the currentObservable
into emissions marked with their original types withinNotification
objects.final @NonNull Single
<Notification<T>> Single.materialize()
Maps the signal types of thisSingle
into aNotification
of the same kind and emits it as a single success value to downstream.static @NonNull Completable
Completable.merge
(@NonNull Iterable<@NonNull ? extends CompletableSource> sources) Returns aCompletable
instance that subscribes to all sources at once and completes only when all sourceCompletableSource
s complete or one of them emits an error.static @NonNull Completable
Completable.merge
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends CompletableSource> sources) Returns aCompletable
instance that subscribes to all sources at once and completes only when all sourceCompletableSource
s complete or one of them emits an error.static @NonNull Completable
Completable.merge
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends CompletableSource> sources, int maxConcurrency) Returns aCompletable
instance that keeps subscriptions to a limited number of sources at once and completes only when all sourceCompletableSource
s complete or one of them emits an error.Flowable.merge
(@NonNull Iterable<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources) Flowable.merge
(@NonNull Iterable<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources, int maxConcurrency) Flattens anIterable
ofPublisher
s into onePublisher
, without any transformation, while limiting the number of concurrent subscriptions to thesePublisher
s.Flowable.merge
(@NonNull Iterable<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources, int maxConcurrency, int bufferSize) Flattens anIterable
ofPublisher
s into onePublisher
, without any transformation, while limiting the number of concurrent subscriptions to thesePublisher
s.Flowable.merge
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source2) Flattens twoPublisher
s into a singlePublisher
, without any transformation.Flowable.merge
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source3) Flattens threePublisher
s into a singlePublisher
, without any transformation.Flowable.merge
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source4) Flattens fourPublisher
s into a singlePublisher
, without any transformation.Flowable.merge
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources) Flattens aPublisher
that emitsPublisher
s into a singlePublisher
that emits the items emitted by thosPublisher
s , without any transformation.Flowable.merge
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources, int maxConcurrency) Flattens aPublisher
that emitsPublisher
s into a singlePublisher
that emits the items emitted by thosePublisher
s, without any transformation, while limiting the maximum number of concurrent subscriptions to thesePublisher
s.Maybe.merge
(@NonNull MaybeSource<? extends MaybeSource<? extends @NonNull T>> source) Flattens aMaybeSource
that emits aMaybeSource
into a singleMaybeSource
that emits the item emitted by the nestedMaybeSource
, without any transformation.Maybe.merge
(@NonNull MaybeSource<? extends @NonNull T> source1, @NonNull MaybeSource<? extends @NonNull T> source2) Flattens twoMaybeSource
s into a singleFlowable
, without any transformation.Maybe.merge
(@NonNull MaybeSource<? extends @NonNull T> source1, @NonNull MaybeSource<? extends @NonNull T> source2, @NonNull MaybeSource<? extends @NonNull T> source3) Flattens threeMaybeSource
s into a singleFlowable
, without any transformation.Maybe.merge
(@NonNull MaybeSource<? extends @NonNull T> source1, @NonNull MaybeSource<? extends @NonNull T> source2, @NonNull MaybeSource<? extends @NonNull T> source3, @NonNull MaybeSource<? extends @NonNull T> source4) Flattens fourMaybeSource
s into a singleFlowable
, without any transformation.Merges anIterable
sequence ofMaybeSource
instances into a singleFlowable
sequence, running allMaybeSource
s at once.Maybe.merge
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources) Merges aPublisher
sequence ofMaybeSource
instances into a singleFlowable
sequence, running allMaybeSource
s at once.Maybe.merge
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources, int maxConcurrency) Merges aPublisher
sequence ofMaybeSource
instances into a singleFlowable
sequence, running at most maxConcurrencyMaybeSource
s at once.static <@NonNull T>
@NonNull Observable<T> Observable.merge
(@NonNull ObservableSource<? extends ObservableSource<? extends @NonNull T>> sources) Flattens anObservableSource
that emitsObservableSource
s into a singleObservable
that emits the items emitted by thoseObservableSource
s, without any transformation.static <@NonNull T>
@NonNull Observable<T> Observable.merge
(@NonNull ObservableSource<? extends ObservableSource<? extends @NonNull T>> sources, int maxConcurrency) Flattens anObservableSource
that emitsObservableSource
s into a singleObservable
that emits the items emitted by thoseObservableSource
s, without any transformation, while limiting the maximum number of concurrent subscriptions to theseObservableSource
s.static <@NonNull T>
@NonNull Observable<T> Observable.merge
(@NonNull ObservableSource<? extends @NonNull T> source1, @NonNull ObservableSource<? extends @NonNull T> source2) Flattens twoObservableSource
s into a singleObservable
, without any transformation.static <@NonNull T>
@NonNull Observable<T> Observable.merge
(@NonNull ObservableSource<? extends @NonNull T> source1, @NonNull ObservableSource<? extends @NonNull T> source2, @NonNull ObservableSource<? extends @NonNull T> source3) Flattens threeObservableSource
s into a singleObservable
, without any transformation.static <@NonNull T>
@NonNull Observable<T> Observable.merge
(@NonNull ObservableSource<? extends @NonNull T> source1, @NonNull ObservableSource<? extends @NonNull T> source2, @NonNull ObservableSource<? extends @NonNull T> source3, @NonNull ObservableSource<? extends @NonNull T> source4) Flattens fourObservableSource
s into a singleObservable
, without any transformation.static <@NonNull T>
@NonNull Observable<T> Observable.merge
(@NonNull Iterable<@NonNull ? extends ObservableSource<? extends @NonNull T>> sources) static <@NonNull T>
@NonNull Observable<T> Observable.merge
(@NonNull Iterable<@NonNull ? extends ObservableSource<? extends @NonNull T>> sources, int maxConcurrency) Flattens anIterable
ofObservableSource
s into oneObservable
, without any transformation, while limiting the number of concurrent subscriptions to theseObservableSource
s.static <@NonNull T>
@NonNull Observable<T> Observable.merge
(@NonNull Iterable<@NonNull ? extends ObservableSource<? extends @NonNull T>> sources, int maxConcurrency, int bufferSize) Flattens anIterable
ofObservableSource
s into oneObservable
, without any transformation, while limiting the number of concurrent subscriptions to theseObservableSource
s.Single.merge
(@NonNull SingleSource<? extends SingleSource<? extends @NonNull T>> source) Flattens aSingleSource
that emits aSingleSingle
into a singleSingle
that emits the item emitted by the nestedSingleSource
, without any transformation.Single.merge
(@NonNull SingleSource<? extends @NonNull T> source1, @NonNull SingleSource<? extends @NonNull T> source2) Flattens twoSingleSource
s into oneFlowable
sequence, without any transformation.Single.merge
(@NonNull SingleSource<? extends @NonNull T> source1, @NonNull SingleSource<? extends @NonNull T> source2, @NonNull SingleSource<? extends @NonNull T> source3) Flattens threeSingleSource
s into oneFlowable
sequence, without any transformation.Single.merge
(@NonNull SingleSource<? extends @NonNull T> source1, @NonNull SingleSource<? extends @NonNull T> source2, @NonNull SingleSource<? extends @NonNull T> source3, @NonNull SingleSource<? extends @NonNull T> source4) Flattens fourSingleSource
s into oneFlowable
sequence, without any transformation.Merges anIterable
sequence ofSingleSource
instances into a singleFlowable
sequence, running allSingleSource
s at once.Single.merge
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends SingleSource<? extends @NonNull T>> sources) Merges a sequence ofSingleSource
instances emitted by aPublisher
into a singleFlowable
sequence, running allSingleSource
s at once.private static @NonNull Completable
Completable.merge0
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends CompletableSource> sources, int maxConcurrency, boolean delayErrors) Returns aCompletable
instance that keeps subscriptions to a limited number ofCompletableSource
s at once and completes only when all sourceCompletableSource
s terminate in one way or another, combining any exceptions signaled by either the sourcePublisher
or the innerCompletableSource
instances.static @NonNull Completable
Completable.mergeArray
(@NonNull CompletableSource... sources) Returns aCompletable
instance that subscribes to all sources at once and completes only when all sourceCompletableSource
s complete or one of them emits an error.Flowable.mergeArray
(int maxConcurrency, int bufferSize, @NonNull org.reactivestreams.Publisher<? extends @NonNull T>... sources) Flattens an array ofPublisher
s into onePublisher
, without any transformation, while limiting the number of concurrent subscriptions to thesePublisher
s.Flowable.mergeArray
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T>... sources) Flattens an array ofPublisher
s into onePublisher
, without any transformation.Maybe.mergeArray
(MaybeSource<? extends @NonNull T>... sources) Merges an array ofMaybeSource
instances into a singleFlowable
sequence, running allMaybeSource
s at once.static <@NonNull T>
@NonNull Observable<T> Observable.mergeArray
(int maxConcurrency, int bufferSize, @NonNull ObservableSource<? extends @NonNull T>... sources) Flattens an array ofObservableSource
s into oneObservable
, without any transformation, while limiting the number of concurrent subscriptions to theseObservableSource
s.static <@NonNull T>
@NonNull Observable<T> Observable.mergeArray
(@NonNull ObservableSource<? extends @NonNull T>... sources) Flattens an array ofObservableSource
s into oneObservable
, without any transformation.Single.mergeArray
(SingleSource<? extends @NonNull T>... sources) Merges an array ofSingleSource
instances into a singleFlowable
sequence, running allSingleSource
s at once.static @NonNull Completable
Completable.mergeArrayDelayError
(@NonNull CompletableSource... sources) Returns aCompletable
that subscribes to allCompletableSource
s in the source array and delays any error emitted by any of the innerCompletableSource
s until all of them terminate in a way or another.Flowable.mergeArrayDelayError
(int maxConcurrency, int bufferSize, @NonNull org.reactivestreams.Publisher<? extends @NonNull T>... sources) Flattens an array ofPublisher
s into onePublisher
, in a way that allows aSubscriber
to receive all successfully emitted items from each of the sourcePublisher
s without being interrupted by an error notification from one of them, while limiting the number of concurrent subscriptions to thesePublisher
s.Flowable.mergeArrayDelayError
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T>... sources) Flattens an array ofPublisher
s into oneFlowable
, in a way that allows aSubscriber
to receive all successfully emitted items from each of the sourcePublisher
s without being interrupted by an error notification from one of them.Maybe.mergeArrayDelayError
(@NonNull MaybeSource<? extends @NonNull T>... sources) Flattens an array ofMaybeSource
s into oneFlowable
, in a way that allows a subscriber to receive all successfully emitted items from each of the sourceMaybeSource
s without being interrupted by an error notification from one of them.static <@NonNull T>
@NonNull Observable<T> Observable.mergeArrayDelayError
(int maxConcurrency, int bufferSize, @NonNull ObservableSource<? extends @NonNull T>... sources) Flattens an array ofObservableSource
s into oneObservable
, in a way that allows anObserver
to receive all successfully emitted items from each of theObservableSource
s without being interrupted by an error notification from one of them, while limiting the number of concurrent subscriptions to theseObservableSource
s.static <@NonNull T>
@NonNull Observable<T> Observable.mergeArrayDelayError
(@NonNull ObservableSource<? extends @NonNull T>... sources) Flattens an array ofObservableSource
s into oneObservable
, in a way that allows anObserver
to receive all successfully emitted items from each of theObservableSource
s without being interrupted by an error notification from one of them.Single.mergeArrayDelayError
(@NonNull SingleSource<? extends @NonNull T>... sources) Flattens an array ofSingleSource
s into oneFlowable
, in a way that allows a subscriber to receive all successfully emitted items from each of the sourceSingleSource
s without being interrupted by an error notification from one of them.static @NonNull Completable
Completable.mergeDelayError
(@NonNull Iterable<@NonNull ? extends CompletableSource> sources) Returns aCompletable
that subscribes to allCompletableSource
s in the source sequence and delays any error emitted by any of the innerCompletableSource
s until all of them terminate in a way or another.static @NonNull Completable
Completable.mergeDelayError
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends CompletableSource> sources) Returns aCompletable
that subscribes to allCompletableSource
s in the source sequence and delays any error emitted by either the sourcesPublisher
or any of the innerCompletableSource
s 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 aCompletable
that subscribes to a limited number of innerCompletableSource
s at once in the source sequence and delays any error emitted by either the sourcesPublisher
or any of the innerCompletableSource
s until all of them terminate in a way or another.Flowable.mergeDelayError
(@NonNull Iterable<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources) Flattens anIterable
ofPublisher
s into onePublisher
, in a way that allows aSubscriber
to receive all successfully emitted items from each of the sourcePublisher
s without being interrupted by an error notification from one of them.Flowable.mergeDelayError
(@NonNull Iterable<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources, int maxConcurrency) Flattens anIterable
ofPublisher
s into onePublisher
, in a way that allows aSubscriber
to receive all successfully emitted items from each of the sourcePublisher
s without being interrupted by an error notification from one of them, while limiting the number of concurrent subscriptions to thesePublisher
s.Flowable.mergeDelayError
(@NonNull Iterable<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources, int maxConcurrency, int bufferSize) Flattens anIterable
ofPublisher
s into onePublisher
, in a way that allows aSubscriber
to receive all successfully emitted items from each of the sourcePublisher
s without being interrupted by an error notification from one of them, while limiting the number of concurrent subscriptions to thesePublisher
s.Flowable.mergeDelayError
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source2) Flattens twoPublisher
s into onePublisher
, in a way that allows aSubscriber
to receive all successfully emitted items from each of the sourcePublisher
s without being interrupted by an error notification from one of them.Flowable.mergeDelayError
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source3) Flattens threePublisher
s into onePublisher
, in a way that allows aSubscriber
to receive all successfully emitted items from all of the sourcePublisher
s without being interrupted by an error notification from one of them.Flowable.mergeDelayError
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source4) Flattens fourPublisher
s into onePublisher
, in a way that allows aSubscriber
to receive all successfully emitted items from all of the sourcePublisher
s without being interrupted by an error notification from one of them.Flowable.mergeDelayError
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources) Flattens aPublisher
that emitsPublisher
s into onePublisher
, in a way that allows aSubscriber
to receive all successfully emitted items from all of the sourcePublisher
s without being interrupted by an error notification from one of them.Flowable.mergeDelayError
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources, int maxConcurrency) Flattens aPublisher
that emitsPublisher
s into onePublisher
, in a way that allows aSubscriber
to receive all successfully emitted items from all of the sourcePublisher
s without being interrupted by an error notification from one of them, while limiting the number of concurrent subscriptions to thesePublisher
s.Maybe.mergeDelayError
(@NonNull MaybeSource<? extends @NonNull T> source1, @NonNull MaybeSource<? extends @NonNull T> source2) Flattens twoMaybeSource
s into oneFlowable
, in a way that allows a subscriber to receive all successfully emitted items from each of the sourceMaybeSource
s without being interrupted by an error notification from one of them.Maybe.mergeDelayError
(@NonNull MaybeSource<? extends @NonNull T> source1, @NonNull MaybeSource<? extends @NonNull T> source2, @NonNull MaybeSource<? extends @NonNull T> source3) Flattens threeMaybeSource
into oneFlowable
, in a way that allows a subscriber to receive all successfully emitted items from all of the sourceMaybeSource
s without being interrupted by an error notification from one of them.Maybe.mergeDelayError
(@NonNull MaybeSource<? extends @NonNull T> source1, @NonNull MaybeSource<? extends @NonNull T> source2, @NonNull MaybeSource<? extends @NonNull T> source3, @NonNull MaybeSource<? extends @NonNull T> source4) Flattens fourMaybeSource
s into oneFlowable
, in a way that allows a subscriber to receive all successfully emitted items from all of the sourceMaybeSource
s without being interrupted by an error notification from one of them.Maybe.mergeDelayError
(@NonNull Iterable<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources) Flattens anIterable
sequence ofMaybeSource
s into oneFlowable
, in a way that allows a subscriber to receive all successfully emitted items from each of the sourceMaybeSource
s without being interrupted by an error notification from one of them.Maybe.mergeDelayError
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources) Flattens aPublisher
that emitsMaybeSource
s into oneFlowable
, in a way that allows a subscriber to receive all successfully emitted items from all of the sourceMaybeSource
s without being interrupted by an error notification from one of them or even the mainPublisher
.Maybe.mergeDelayError
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources, int maxConcurrency) Flattens aPublisher
that emitsMaybeSource
s into oneFlowable
, in a way that allows a subscriber to receive all successfully emitted items from all of the sourceMaybeSource
s without being interrupted by an error notification from one of them or even the mainPublisher
as well as limiting the total number of activeMaybeSource
s.static <@NonNull T>
@NonNull Observable<T> Observable.mergeDelayError
(@NonNull ObservableSource<? extends ObservableSource<? extends @NonNull T>> sources) Flattens anObservableSource
that emitsObservableSource
s into oneObservable
, in a way that allows anObserver
to receive all successfully emitted items from all of the emittedObservableSource
s without being interrupted by an error notification from one of them.static <@NonNull T>
@NonNull Observable<T> Observable.mergeDelayError
(@NonNull ObservableSource<? extends ObservableSource<? extends @NonNull T>> sources, int maxConcurrency) Flattens anObservableSource
that emitsObservableSource
s into oneObservable
, in a way that allows anObserver
to receive all successfully emitted items from all of the emittedObservableSource
s without being interrupted by an error notification from one of them, while limiting the number of concurrent subscriptions to theseObservableSource
s.static <@NonNull T>
@NonNull Observable<T> Observable.mergeDelayError
(@NonNull ObservableSource<? extends @NonNull T> source1, @NonNull ObservableSource<? extends @NonNull T> source2) Flattens twoObservableSource
s into oneObservable
, in a way that allows anObserver
to receive all successfully emitted items from each of theObservableSource
s without being interrupted by an error notification from one of them.static <@NonNull T>
@NonNull Observable<T> Observable.mergeDelayError
(@NonNull ObservableSource<? extends @NonNull T> source1, @NonNull ObservableSource<? extends @NonNull T> source2, @NonNull ObservableSource<? extends @NonNull T> source3) Flattens threeObservableSource
s into oneObservable
, in a way that allows anObserver
to receive all successfully emitted items from all of theObservableSource
s without being interrupted by an error notification from one of them.static <@NonNull T>
@NonNull Observable<T> Observable.mergeDelayError
(@NonNull ObservableSource<? extends @NonNull T> source1, @NonNull ObservableSource<? extends @NonNull T> source2, @NonNull ObservableSource<? extends @NonNull T> source3, @NonNull ObservableSource<? extends @NonNull T> source4) Flattens fourObservableSource
s into oneObservable
, in a way that allows anObserver
to receive all successfully emitted items from all of theObservableSource
s without being interrupted by an error notification from one of them.static <@NonNull T>
@NonNull Observable<T> Observable.mergeDelayError
(@NonNull Iterable<@NonNull ? extends ObservableSource<? extends @NonNull T>> sources) Flattens anIterable
ofObservableSource
s into oneObservable
, in a way that allows anObserver
to receive all successfully emitted items from each of the returnedObservableSource
s without being interrupted by an error notification from one of them.static <@NonNull T>
@NonNull Observable<T> Observable.mergeDelayError
(@NonNull Iterable<@NonNull ? extends ObservableSource<? extends @NonNull T>> sources, int maxConcurrency) Flattens anIterable
ofObservableSource
s into oneObservable
, in a way that allows anObserver
to receive all successfully emitted items from each of the returnedObservableSource
s without being interrupted by an error notification from one of them, while limiting the number of concurrent subscriptions to theseObservableSource
s.static <@NonNull T>
@NonNull Observable<T> Observable.mergeDelayError
(@NonNull Iterable<@NonNull ? extends ObservableSource<? extends @NonNull T>> sources, int maxConcurrency, int bufferSize) Flattens anIterable
ofObservableSource
s into oneObservable
, in a way that allows anObserver
to receive all successfully emitted items from each of the returnedObservableSource
s without being interrupted by an error notification from one of them, while limiting the number of concurrent subscriptions to theseObservableSource
s.Single.mergeDelayError
(@NonNull SingleSource<? extends @NonNull T> source1, @NonNull SingleSource<? extends @NonNull T> source2) Flattens twoSingleSource
s into oneFlowable
, without any transformation, delaying any error(s) until all sources succeed or fail.Single.mergeDelayError
(@NonNull SingleSource<? extends @NonNull T> source1, @NonNull SingleSource<? extends @NonNull T> source2, @NonNull SingleSource<? extends @NonNull T> source3) Flattens twoSingleSource
s into oneFlowable
, without any transformation, delaying any error(s) until all sources succeed or fail.Single.mergeDelayError
(@NonNull SingleSource<? extends @NonNull T> source1, @NonNull SingleSource<? extends @NonNull T> source2, @NonNull SingleSource<? extends @NonNull T> source3, @NonNull SingleSource<? extends @NonNull T> source4) Flattens twoSingleSource
s into oneFlowable
, without any transformation, delaying any error(s) until all sources succeed or fail.Single.mergeDelayError
(@NonNull Iterable<@NonNull ? extends SingleSource<? extends @NonNull T>> sources) Merges anIterable
sequence ofSingleSource
instances into oneFlowable
sequence, running allSingleSource
s at once and delaying any error(s) until all sources succeed or fail.Single.mergeDelayError
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends SingleSource<? extends @NonNull T>> sources) Merges a sequence ofSingleSource
instances emitted by aPublisher
into aFlowable
sequence, running allSingleSource
s at once and delaying any error(s) until all sources succeed or fail.final @NonNull Completable
Completable.mergeWith
(@NonNull CompletableSource other) Returns aCompletable
which subscribes to this and the otherCompletableSource
and completes when both of them complete or one emits an error.Flowable.mergeWith
(@NonNull CompletableSource other) Relays the items of thisFlowable
and completes only when the otherCompletableSource
completes as well.Flowable.mergeWith
(@NonNull MaybeSource<? extends @NonNull T> other) Merges the sequence of items of thisFlowable
with the success value of the otherMaybeSource
or waits for both to complete normally if theMaybeSource
is empty.Flowable.mergeWith
(@NonNull SingleSource<? extends @NonNull T> other) Merges the sequence of items of thisFlowable
with the success value of the otherSingleSource
.Flattens this and anotherPublisher
into a singlePublisher
, without any transformation.Maybe.mergeWith
(@NonNull MaybeSource<? extends @NonNull T> other) final @NonNull Observable
<T> Observable.mergeWith
(@NonNull CompletableSource other) Relays the items of the currentObservable
and completes only when the otherCompletableSource
completes as well.final @NonNull Observable
<T> Observable.mergeWith
(@NonNull MaybeSource<? extends @NonNull T> other) Merges the sequence of items of the currentObservable
with the success value of the otherMaybeSource
or waits both to complete normally if theMaybeSource
is empty.final @NonNull Observable
<T> Observable.mergeWith
(@NonNull ObservableSource<? extends @NonNull T> other) Flattens the currentObservable
and anotherObservableSource
into a singleObservable
sequence, without any transformation.final @NonNull Observable
<T> Observable.mergeWith
(@NonNull SingleSource<? extends @NonNull T> other) Merges the sequence of items of the currentObservable
with the success value of the otherSingleSource
.Single.mergeWith
(@NonNull SingleSource<? extends @NonNull T> other) static @NonNull Completable
Completable.never()
Returns aCompletable
that never callsonError
oronComplete
.Flowable.never()
Returns aFlowable
that never sends any items or notifications to aSubscriber
.Maybe.never()
Returns aMaybe
that never sends any items or notifications to aMaybeObserver
.static <@NonNull T>
@NonNull Observable<T> Observable.never()
Returns anObservable
that never sends any items or notifications to anObserver
.Single.never()
Returns a singleton instance of a never-signalingSingle
(only callsonSubscribe
).final @NonNull Completable
Returns aCompletable
which emits the terminal events from the thread of the specifiedScheduler
.Signals the items and terminal signals of the currentFlowable
on the specifiedScheduler
, asynchronously with a bounded buffer ofFlowable.bufferSize()
slots.Signals the items and terminal signals of the currentFlowable
on the specifiedScheduler
, asynchronously with a bounded buffer and optionally delaysonError
notifications.Signals the items and terminal signals of the currentFlowable
on the specifiedScheduler
, asynchronously with a bounded buffer of configurable size and optionally delaysonError
notifications.Wraps aMaybe
to emit its item (or notify of its error) on a specifiedScheduler
, asynchronously.final @NonNull Observable
<T> Returns anObservable
to perform the currentObservable
's emissions and notifications on a specifiedScheduler
, asynchronously with an unbounded buffer withFlowable.bufferSize()
"island size".final @NonNull Observable
<T> Returns anObservable
to perform the currentObservable
's emissions and notifications on a specifiedScheduler
, asynchronously with an unbounded buffer withFlowable.bufferSize()
"island size" and optionally delaysonError
notifications.final @NonNull Observable
<T> Returns anObservable
to perform the currentObservable
's emissions and notifications on a specifiedScheduler
, asynchronously with an unbounded buffer of configurable "island size" and optionally delaysonError
notifications.Signals the success item or the terminal signals of the currentSingle
on the specifiedScheduler
, asynchronously.Filters the items emitted by the currentFlowable
, only emitting those of the specified type.Filters the items emitted by the currentMaybe
, only emitting its success value if that is an instance of the suppliedClass
.final <@NonNull U>
@NonNull Observable<U> Filters the items emitted by the currentObservable
, only emitting those of the specified type.Filters the items emitted by the currentSingle
, only emitting its success value if that is an instance of the suppliedClass
.Flowable.onBackpressureBuffer()
Buffers an unlimited number of items from the currentFlowable
and allows it to emit as fast it can while allowing the downstream to consume the items at its own place.Flowable.onBackpressureBuffer
(boolean delayError) Buffers an unlimited number of items from the currentFlowable
and allows it to emit as fast it can while allowing the downstream to consume the items at its own place, optionally delaying an error until all buffered items have been consumed.Flowable.onBackpressureBuffer
(int capacity) Buffers an limited number of items from the currentFlowable
and allows it to emit as fast it can while allowing the downstream to consume the items at its own place, however, the resultingFlowable
will signal aMissingBackpressureException
viaonError
as soon as the buffer's capacity is exceeded, dropping all undelivered items, and canceling the flow.Flowable.onBackpressureBuffer
(int capacity, boolean delayError) Buffers an limited number of items from the currentFlowable
and allows it to emit as fast it can while allowing the downstream to consume the items at its own place, however, the resultingFlowable
will signal aMissingBackpressureException
viaonError
as soon as the buffer's capacity is exceeded, dropping all undelivered items, and canceling the flow.Flowable.onBackpressureBuffer
(int capacity, boolean delayError, boolean unbounded) Buffers an optionally unlimited number of items from the currentFlowable
and allows it to emit as fast it can while allowing the downstream to consume the items at its own place.Flowable.onBackpressureBuffer
(int capacity, boolean delayError, boolean unbounded, @NonNull Action onOverflow) Buffers an optionally unlimited number of items from the currentFlowable
and allows it to emit as fast it can while allowing the downstream to consume the items at its own place.Flowable.onBackpressureBuffer
(int capacity, boolean delayError, boolean unbounded, @NonNull Action onOverflow, @NonNull Consumer<? super @NonNull T> onDropped) Buffers an optionally unlimited number of items from the currentFlowable
and allows it to emit as fast it can while allowing the downstream to consume the items at its own place.Flowable.onBackpressureBuffer
(int capacity, @NonNull Action onOverflow) Buffers an limited number of items from the currentFlowable
and allows it to emit as fast it can while allowing the downstream to consume the items at its own place, however, the resultingFlowable
will signal aMissingBackpressureException
viaonError
as soon as the buffer's capacity is exceeded, dropping all undelivered items, canceling the flow and calling theonOverflow
action.Flowable.onBackpressureBuffer
(long capacity, @Nullable Action onOverflow, @NonNull BackpressureOverflowStrategy overflowStrategy) Buffers an optionally unlimited number of items from the currentFlowable
and allows it to emit as fast it can while allowing the downstream to consume the items at its own place.Flowable.onBackpressureBuffer
(long capacity, @Nullable Action onOverflow, @NonNull BackpressureOverflowStrategy overflowStrategy, @NonNull Consumer<? super @NonNull T> onDropped) Buffers an optionally unlimited number of items from the currentFlowable
and allows it to emit as fast it can while allowing the downstream to consume the items at its own place.Flowable.onBackpressureDrop()
Drops items from the currentFlowable
if the downstream is not ready to receive new items (indicated by a lack ofSubscription.request(long)
calls from it).Flowable.onBackpressureDrop
(@NonNull Consumer<? super @NonNull T> onDrop) Drops items from the currentFlowable
if the downstream is not ready to receive new items (indicated by a lack ofSubscription.request(long)
calls from it) and calls the givenConsumer
with such dropped items.Flowable.onBackpressureLatest()
Drops all but the latest item emitted by the currentFlowable
if the downstream is not ready to receive new items (indicated by a lack ofSubscription.request(long)
calls from it) and emits this latest item when the downstream becomes ready.Flowable.onBackpressureLatest
(@NonNull Consumer<? super @NonNull T> onDropped) Drops all but the latest item emitted by the currentFlowable
if the downstream is not ready to receive new items (indicated by a lack ofSubscription.request(long)
calls from it) and emits this latest item when the downstream becomes ready.Flowable.onBackpressureReduce
(@NonNull BiFunction<@NonNull T, @NonNull T, @NonNull T> reducer) Reduces a sequence of two not emitted values via a function into a single value if the downstream is not ready to receive new items (indicated by a lack ofSubscription.request(long)
calls from it) and emits this latest item when the downstream becomes ready.Flowable.onBackpressureReduce
(@NonNull Supplier<@NonNull R> supplier, @NonNull BiFunction<@NonNull R, ? super @NonNull T, @NonNull R> reducer) Reduces upstream values into an aggregate value, provided by a supplier and combined via a reducer function, while the downstream is not ready to receive items, then emits this aggregate value when the downstream becomes ready.final @NonNull Completable
Completable.onErrorComplete()
Returns aCompletable
instance that if thisCompletable
emits an error, it will emit anonComplete
and swallow the upstreamThrowable
.final @NonNull Completable
Completable.onErrorComplete
(@NonNull Predicate<? super Throwable> predicate) Flowable.onErrorComplete()
Returns aFlowable
instance that if the currentFlowable
emits an error, it will emit anonComplete
and swallow the throwable.Flowable.onErrorComplete
(@NonNull Predicate<? super Throwable> predicate) Returns aFlowable
instance that if the currentFlowable
emits an error and the predicate returnstrue
, it will emit anonComplete
and swallow the throwable.Maybe.onErrorComplete()
Returns aMaybe
instance that if thisMaybe
emits an error, it will emit anonComplete
and swallow the throwable.Maybe.onErrorComplete
(@NonNull Predicate<? super Throwable> predicate) Returns aMaybe
instance that if thisMaybe
emits an error and the predicate returnstrue
, it will emit anonComplete
and swallow the throwable.final @NonNull Observable
<T> Observable.onErrorComplete()
Returns anObservable
instance that if the currentObservable
emits an error, it will emit anonComplete
and swallow the throwable.final @NonNull Observable
<T> Observable.onErrorComplete
(@NonNull Predicate<? super Throwable> predicate) Returns anObservable
instance that if the currentObservable
emits an error and the predicate returnstrue
, it will emit anonComplete
and swallow the throwable.Single.onErrorComplete()
Returns aMaybe
instance that if the currentSingle
emits an error, it will emit anonComplete
and swallow the throwable.Single.onErrorComplete
(@NonNull Predicate<? super Throwable> predicate) Returns aMaybe
instance that if thisSingle
emits an error and the predicate returnstrue
, it will emit anonComplete
and swallow the throwable.final @NonNull Completable
Completable.onErrorResumeNext
(@NonNull Function<? super Throwable, ? extends CompletableSource> fallbackSupplier) Returns aCompletable
instance that when encounters an error from thisCompletable
, calls the specifiedmapper
Function
that returns aCompletableSource
instance for it and resumes the execution with it.Flowable.onErrorResumeNext
(@NonNull Function<? super Throwable, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> fallbackSupplier) Resumes the flow with aPublisher
returned for the failureThrowable
of the currentFlowable
by a function instead of signaling the error viaonError
.Maybe.onErrorResumeNext
(@NonNull Function<? super Throwable, ? extends MaybeSource<? extends @NonNull T>> fallbackSupplier) Resumes the flow with aMaybeSource
returned for the failureThrowable
of the currentMaybe
by a function instead of signaling the error viaonError
.final @NonNull Observable
<T> Observable.onErrorResumeNext
(@NonNull Function<? super Throwable, ? extends ObservableSource<? extends @NonNull T>> fallbackSupplier) Resumes the flow with anObservableSource
returned for the failureThrowable
of the currentObservable
by a function instead of signaling the error viaonError
.Single.onErrorResumeNext
(@NonNull Function<? super Throwable, ? extends SingleSource<? extends @NonNull T>> fallbackSupplier) Resumes the flow with aSingleSource
returned for the failureThrowable
of the currentSingle
by a function instead of signaling the error viaonError
.final @NonNull Completable
Completable.onErrorResumeWith
(@NonNull CompletableSource fallback) Resumes the flow with the givenCompletableSource
when the currentCompletable
fails instead of signaling the error viaonError
.Flowable.onErrorResumeWith
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T> fallback) Resumes the flow with the givenPublisher
when the currentFlowable
fails instead of signaling the error viaonError
.Maybe.onErrorResumeWith
(@NonNull MaybeSource<? extends @NonNull T> fallback) Resumes the flow with the givenMaybeSource
when the currentMaybe
fails instead of signaling the error viaonError
.final @NonNull Observable
<T> Observable.onErrorResumeWith
(@NonNull ObservableSource<? extends @NonNull T> fallback) Resumes the flow with the givenObservableSource
when the currentObservable
fails instead of signaling the error viaonError
.Single.onErrorResumeWith
(@NonNull SingleSource<? extends @NonNull T> fallback) Resumes the flow with the givenSingleSource
when the currentSingle
fails instead of signaling the error viaonError
.Completable.onErrorReturn
(@NonNull Function<? super Throwable, ? extends @NonNull T> itemSupplier) Ends the flow with a success item returned by a function for theThrowable
error signaled by the currentCompletable
instead of signaling the error viaonError
.Ends the flow with a last item returned by a function for theThrowable
error signaled by the currentFlowable
instead of signaling the error viaonError
.Ends the flow with a success item returned by a function for theThrowable
error signaled by the currentMaybe
instead of signaling the error viaonError
.final @NonNull Observable
<T> Ends the flow with a last item returned by a function for theThrowable
error signaled by the currentObservable
instead of signaling the error viaonError
.Ends the flow with a success item returned by a function for theThrowable
error signaled by the currentSingle
instead of signaling the error viaonError
.Completable.onErrorReturnItem
(@NonNull T item) Ends the flow with the given success item when the currentCompletable
fails instead of signaling the error viaonError
.Flowable.onErrorReturnItem
(@NonNull T item) Ends the flow with the given last item when the currentFlowable
fails instead of signaling the error viaonError
.Maybe.onErrorReturnItem
(@NonNull T item) Ends the flow with the given success item when the currentMaybe
fails instead of signaling the error viaonError
.final @NonNull Observable
<T> Observable.onErrorReturnItem
(@NonNull T item) Ends the flow with the given last item when the currentObservable
fails instead of signaling the error viaonError
.Single.onErrorReturnItem
(@NonNull T item) Signals the specified value as success in case the currentSingle
signals an error.final @NonNull Completable
Completable.onTerminateDetach()
Nulls out references to the upstream producer and downstreamCompletableObserver
if the sequence is terminated or downstream callsdispose()
.Flowable.onTerminateDetach()
Nulls out references to the upstream producer and downstreamSubscriber
if the sequence is terminated or downstream cancels.Maybe.onTerminateDetach()
Nulls out references to the upstream producer and downstreamMaybeObserver
if the sequence is terminated or downstream callsdispose()
.final @NonNull Observable
<T> Observable.onTerminateDetach()
Nulls out references to the upstream producer and downstreamObserver
if the sequence is terminated or downstream callsdispose()
.Single.onTerminateDetach()
Nulls out references to the upstream producer and downstreamSingleObserver
if the sequence is terminated or downstream callsdispose()
.final @NonNull ParallelFlowable
<T> Flowable.parallel()
Parallelizes the flow by creating multiple 'rails' (equal to the number of CPUs) and dispatches the upstream items to them in a round-robin fashion.final @NonNull ParallelFlowable
<T> Flowable.parallel
(int parallelism) Parallelizes the flow by creating the specified number of 'rails' and dispatches the upstream items to them in a round-robin fashion.final @NonNull ParallelFlowable
<T> Flowable.parallel
(int parallelism, int prefetch) Parallelizes the flow by creating the specified number of 'rails' and dispatches the upstream items to them in a round-robin fashion and uses the defined per-'rail' prefetch amount.final @NonNull ConnectableFlowable
<T> Flowable.publish()
Returns aConnectableFlowable
, which is a variety ofPublisher
that waits until itsconnect
method is called before it begins emitting items to thoseSubscriber
s that have subscribed to it.final @NonNull ConnectableFlowable
<T> Flowable.publish
(int bufferSize) Returns aConnectableFlowable
, which is a variety ofPublisher
that waits until itsconnect
method is called before it begins emitting items to thoseSubscriber
s that have subscribed to it.Flowable.publish
(@NonNull Function<? super Flowable<@NonNull T>, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> selector, int prefetch) Returns aFlowable
that emits the results of invoking a specified selector on items emitted by aConnectableFlowable
that shares a single subscription to the underlying sequence.Flowable.publish
(@NonNull Function<? super Flowable<@NonNull T>, @NonNull ? extends org.reactivestreams.Publisher<@NonNull R>> selector) Returns aFlowable
that emits the results of invoking a specified selector on items emitted by aConnectableFlowable
that shares a single subscription to the underlying sequence.final @NonNull ConnectableObservable
<T> Observable.publish()
Returns aConnectableObservable
, which is a variety ofObservableSource
that waits until itsconnect
method is called before it begins emitting items to thoseObserver
s that have subscribed to it.final <@NonNull R>
@NonNull Observable<R> Observable.publish
(@NonNull Function<? super Observable<@NonNull T>, ? extends ObservableSource<@NonNull R>> selector) Returns anObservable
that emits the results of invoking a specified selector on items emitted by aConnectableObservable
that shares a single subscription to the currentObservable
sequence.Flowable.range
(int start, int count) Returns aFlowable
that emits a sequence ofInteger
s within a specified range.static @NonNull Observable
<Integer> Observable.range
(int start, int count) Returns anObservable
that emits a sequence ofInteger
s within a specified range.Flowable.rangeLong
(long start, long count) Returns aFlowable
that emits a sequence ofLong
s within a specified range.static @NonNull Observable
<Long> Observable.rangeLong
(long start, long count) Returns anObservable
that emits a sequence ofLong
s within a specified range.Flowable.rebatchRequests
(int n) Requestsn
initially from the upstream and then 75% ofn
subsequently after 75% ofn
values have been emitted to the downstream.Returns aMaybe
that applies a specified accumulator function to the first item emitted by the currentFlowable
, then feeds the result of that function along with the second item emitted by the currentFlowable
into the same function, and so on until all items have been emitted by the current and finiteFlowable
, and emits the final result from the final call to your function as its sole item.Flowable.reduce
(@NonNull R seed, @NonNull BiFunction<@NonNull R, ? super @NonNull T, @NonNull R> reducer) Returns aSingle
that applies a specified accumulator function to the first item emitted by the currentFlowable
and a specified seed value, then feeds the result of that function along with the second item emitted by the currentFlowable
into the same function, and so on until all items have been emitted by the current and finiteFlowable
, emitting the final result from the final call to your function as its sole item.Returns aMaybe
that applies a specified accumulator function to the first item emitted by the currentObservable
, then feeds the result of that function along with the second item emitted by the currentObservable
into the same function, and so on until all items have been emitted by the current and finiteObservable
, and emits the final result from the final call to your function as its sole item.Observable.reduce
(@NonNull R seed, @NonNull BiFunction<@NonNull R, ? super @NonNull T, @NonNull R> reducer) Returns aSingle
that applies a specified accumulator function to the first item emitted by the currentObservable
and a specified seed value, then feeds the result of that function along with the second item emitted by the currentObservable
into the same function, and so on until all items have been emitted by the current and finiteObservable
, emitting the final result from the final call to your function as its sole item.Flowable.reduceWith
(@NonNull Supplier<@NonNull R> seedSupplier, @NonNull BiFunction<@NonNull R, ? super @NonNull T, @NonNull R> reducer) Returns aSingle
that applies a specified accumulator function to the first item emitted by the currentFlowable
and a seed value derived from calling a specifiedseedSupplier
, then feeds the result of that function along with the second item emitted by the currentFlowable
into the same function, and so on until all items have been emitted by the current and finiteFlowable
, emitting the final result from the final call to your function as its sole item.Observable.reduceWith
(@NonNull Supplier<@NonNull R> seedSupplier, @NonNull BiFunction<@NonNull R, ? super @NonNull T, @NonNull R> reducer) Returns aSingle
that applies a specified accumulator function to the first item emitted by the currentObservable
and a seed value derived from calling a specifiedseedSupplier
, then feeds the result of that function along with the second item emitted by the currentObservable
into the same function, and so on until all items have been emitted by the current and finiteObservable
, emitting the final result from the final call to your function as its sole item.final @NonNull Completable
Completable.repeat()
Returns aCompletable
that repeatedly subscribes to thisCompletable
until disposed.final @NonNull Completable
Completable.repeat
(long times) Returns aCompletable
that subscribes repeatedly at most the given number of times to thisCompletable
.Flowable.repeat()
Returns aFlowable
that repeats the sequence of items emitted by the currentFlowable
indefinitely.Flowable.repeat
(long times) Returns aFlowable
that repeats the sequence of items emitted by the currentFlowable
at mostcount
times.Maybe.repeat()
Returns aFlowable
that repeats the sequence of items emitted by the currentMaybe
indefinitely.Maybe.repeat
(long times) Returns aFlowable
that repeats the sequence of items emitted by the currentMaybe
at mostcount
times.final @NonNull Observable
<T> Observable.repeat()
Returns anObservable
that repeats the sequence of items emitted by the currentObservable
indefinitely.final @NonNull Observable
<T> Observable.repeat
(long times) Returns anObservable
that repeats the sequence of items emitted by the currentObservable
at mostcount
times.Single.repeat()
Repeatedly re-subscribes to the currentSingle
and emits each success value as aFlowable
sequence.Single.repeat
(long times) Re-subscribes to the currentSingle
at most the given number of times and emits each success value as aFlowable
sequence.final @NonNull Completable
Completable.repeatUntil
(@NonNull BooleanSupplier stop) Returns aCompletable
that repeatedly subscribes to thisCompletable
so long as the given stopBooleanSupplier
returnsfalse
.Flowable.repeatUntil
(@NonNull BooleanSupplier stop) Returns aFlowable
that repeats the sequence of items emitted by the currentFlowable
until the provided stop function returnstrue
.Maybe.repeatUntil
(@NonNull BooleanSupplier stop) Returns aFlowable
that repeats the sequence of items emitted by the currentMaybe
until the provided stop function returnstrue
.final @NonNull Observable
<T> Observable.repeatUntil
(@NonNull BooleanSupplier stop) Returns anObservable
that repeats the sequence of items emitted by the currentObservable
until the provided stop function returnstrue
.Single.repeatUntil
(@NonNull BooleanSupplier stop) Re-subscribes to the currentSingle
until the givenBooleanSupplier
returnstrue
and emits the success items as aFlowable
sequence.final @NonNull Completable
Completable.repeatWhen
(@NonNull Function<? super Flowable<Object>, @NonNull ? extends org.reactivestreams.Publisher<@NonNull ?>> handler) Returns aCompletable
instance that repeats when thePublisher
returned by the handlerFunction
emits an item or completes when thisPublisher
emits anonComplete
event.Flowable.repeatWhen
(@NonNull Function<? super Flowable<Object>, @NonNull ? extends org.reactivestreams.Publisher<@NonNull ?>> handler) Returns aFlowable
that emits the same values as the currentFlowable
with the exception of anonComplete
.Maybe.repeatWhen
(@NonNull Function<? super Flowable<Object>, @NonNull ? extends org.reactivestreams.Publisher<@NonNull ?>> handler) Returns aFlowable
that emits the same values as the currentMaybe
with the exception of anonComplete
.final @NonNull Observable
<T> Observable.repeatWhen
(@NonNull Function<? super Observable<Object>, ? extends ObservableSource<?>> handler) Returns anObservable
that emits the same values as the currentObservable
with the exception of anonComplete
.Single.repeatWhen
(@NonNull Function<? super Flowable<Object>, @NonNull ? extends org.reactivestreams.Publisher<@NonNull ?>> handler) Re-subscribes to the currentSingle
if thePublisher
returned by the handler function signals a value in response to a value signaled through theFlowable
the handler receives.final @NonNull ConnectableFlowable
<T> Flowable.replay()
Returns aConnectableFlowable
that shares a single subscription to the underlyingPublisher
that will replay all of its items and notifications to any futureSubscriber
.final @NonNull ConnectableFlowable
<T> Flowable.replay
(int bufferSize) Returns aConnectableFlowable
that shares a single subscription to the currentFlowable
and replays at mostbufferSize
items to lateSubscriber
s.final @NonNull ConnectableFlowable
<T> Flowable.replay
(int bufferSize, boolean eagerTruncate) Returns aConnectableFlowable
that shares a single subscription to the currentFlowable
and replays at mostbufferSize
items to lateSubscriber
s.final @NonNull ConnectableFlowable
<T> Returns aConnectableFlowable
that shares a single subscription to the currentFlowable
and replays at mostbufferSize
items that were emitted during a specified time window.final @NonNull ConnectableFlowable
<T> Returns aConnectableFlowable
that shares a single subscription to the currentFlowable
and replays a maximum ofbufferSize
items that are emitted within a specified time window to lateSubscriber
s.final @NonNull ConnectableFlowable
<T> Flowable.replay
(int bufferSize, long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean eagerTruncate) Returns aConnectableFlowable
that shares a single subscription to the currentFlowable
and replays a maximum ofbufferSize
items that are emitted within a specified time window to lateSubscriber
s.final @NonNull ConnectableFlowable
<T> Returns aConnectableFlowable
that shares a single subscription to the currentFlowable
and replays all items emitted by it within a specified time window to lateSubscriber
s.final @NonNull ConnectableFlowable
<T> Returns aConnectableFlowable
that shares a single subscription to the currentFlowable
and replays all items emitted by it within a specified time window to lateSubscriber
s.final @NonNull ConnectableFlowable
<T> Flowable.replay
(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean eagerTruncate) Returns aConnectableFlowable
that shares a single subscription to the currentFlowable
and replays all items emitted by it within a specified time window to lateSubscriber
s.Flowable.replay
(@NonNull Function<? super Flowable<@NonNull T>, @NonNull ? extends org.reactivestreams.Publisher<@NonNull R>> selector) Returns aFlowable
that emits items that are the results of invoking a specified selector on the items emitted by aConnectableFlowable
that shares a single subscription to the currentFlowable
.Flowable.replay
(@NonNull Function<? super Flowable<@NonNull T>, @NonNull ? extends org.reactivestreams.Publisher<@NonNull R>> selector, int bufferSize) Returns aFlowable
that emits items that are the results of invoking a specified selector on items emitted by aConnectableFlowable
that shares a single subscription to the currentFlowable
, replayingbufferSize
notifications.Flowable.replay
(@NonNull Function<? super Flowable<@NonNull T>, @NonNull ? extends org.reactivestreams.Publisher<@NonNull R>> selector, int bufferSize, boolean eagerTruncate) Returns aFlowable
that emits items that are the results of invoking a specified selector on items emitted by aConnectableFlowable
that shares a single subscription to the currentFlowable
, replayingbufferSize
notifications.Flowable.replay
(@NonNull Function<? super Flowable<@NonNull T>, @NonNull ? extends org.reactivestreams.Publisher<@NonNull R>> selector, int bufferSize, long time, @NonNull TimeUnit unit) Returns aFlowable
that emits items that are the results of invoking a specified selector on items emitted by aConnectableFlowable
that shares a single subscription to the currentFlowable
, replaying no more thanbufferSize
items that were emitted within a specified time window.Flowable.replay
(@NonNull Function<? super Flowable<@NonNull T>, @NonNull ? extends org.reactivestreams.Publisher<@NonNull R>> selector, int bufferSize, long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Returns aFlowable
that emits items that are the results of invoking a specified selector on items emitted by aConnectableFlowable
that shares a single subscription to the currentFlowable
, replaying no more thanbufferSize
items that were emitted within a specified time window.Flowable.replay
(@NonNull Function<? super Flowable<@NonNull T>, @NonNull ? extends org.reactivestreams.Publisher<@NonNull R>> selector, int bufferSize, long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean eagerTruncate) Returns aFlowable
that emits items that are the results of invoking a specified selector on items emitted by aConnectableFlowable
that shares a single subscription to the currentFlowable
, replaying no more thanbufferSize
items that were emitted within a specified time window.Flowable.replay
(@NonNull Function<? super Flowable<@NonNull T>, @NonNull ? extends org.reactivestreams.Publisher<@NonNull R>> selector, long time, @NonNull TimeUnit unit) Returns aFlowable
that emits items that are the results of invoking a specified selector on items emitted by aConnectableFlowable
that shares a single subscription to the currentFlowable
, replaying all items that were emitted within a specified time window.Flowable.replay
(@NonNull Function<? super Flowable<@NonNull T>, @NonNull ? extends org.reactivestreams.Publisher<@NonNull R>> selector, long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Returns aFlowable
that emits items that are the results of invoking a specified selector on items emitted by aConnectableFlowable
that shares a single subscription to the currentFlowable
, replaying all items that were emitted within a specified time window.Flowable.replay
(@NonNull Function<? super Flowable<@NonNull T>, @NonNull ? extends org.reactivestreams.Publisher<@NonNull R>> selector, long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean eagerTruncate) Returns aFlowable
that emits items that are the results of invoking a specified selector on items emitted by aConnectableFlowable
that shares a single subscription to the currentFlowable
, replaying all items that were emitted within a specified time window.final @NonNull ConnectableObservable
<T> Observable.replay()
Returns aConnectableObservable
that shares a single subscription to the currentObservable
that will replay all of its items and notifications to any futureObserver
.final @NonNull ConnectableObservable
<T> Observable.replay
(int bufferSize) Returns aConnectableObservable
that shares a single subscription to the currentObservable
that replays at mostbufferSize
items emitted by the currentObservable
.final @NonNull ConnectableObservable
<T> Observable.replay
(int bufferSize, boolean eagerTruncate) Returns aConnectableObservable
that shares a single subscription to the currentObservable
that replays at mostbufferSize
items emitted by the currentObservable
.final @NonNull ConnectableObservable
<T> Returns aConnectableObservable
that shares a single subscription to the currentObservable
and replays at mostbufferSize
items that were emitted during a specified time window.final @NonNull ConnectableObservable
<T> Returns aConnectableObservable
that shares a single subscription to the currentObservable
and that replays a maximum ofbufferSize
items that are emitted within a specified time window.final @NonNull ConnectableObservable
<T> Observable.replay
(int bufferSize, long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean eagerTruncate) Returns aConnectableObservable
that shares a single subscription to the currentObservable
and that replays a maximum ofbufferSize
items that are emitted within a specified time window.final @NonNull ConnectableObservable
<T> Returns aConnectableObservable
that shares a single subscription to the currentObservable
and replays all items emitted by the currentObservable
within a specified time window.final @NonNull ConnectableObservable
<T> Returns aConnectableObservable
that shares a single subscription to the currentObservable
and replays all items emitted by the currentObservable
within a specified time window.final @NonNull ConnectableObservable
<T> Observable.replay
(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean eagerTruncate) Returns aConnectableObservable
that shares a single subscription to the currentObservable
and replays all items emitted by the currentObservable
within a specified time window.final <@NonNull R>
@NonNull Observable<R> Observable.replay
(@NonNull Function<? super Observable<@NonNull T>, ? extends ObservableSource<@NonNull R>> selector) Returns anObservable
that emits items that are the results of invoking a specified selector on the items emitted by aConnectableObservable
that shares a single subscription to the currentObservable
.final <@NonNull R>
@NonNull Observable<R> Observable.replay
(@NonNull Function<? super Observable<@NonNull T>, ? extends ObservableSource<@NonNull R>> selector, int bufferSize) Returns anObservable
that emits items that are the results of invoking a specified selector on items emitted by aConnectableObservable
that shares a single subscription to the currentObservable
, replayingbufferSize
notifications.final <@NonNull R>
@NonNull Observable<R> Observable.replay
(@NonNull Function<? super Observable<@NonNull T>, ? extends ObservableSource<@NonNull R>> selector, int bufferSize, boolean eagerTruncate) Returns anObservable
that emits items that are the results of invoking a specified selector on items emitted by aConnectableObservable
that shares a single subscription to the currentObservable
, replayingbufferSize
notifications.final <@NonNull R>
@NonNull Observable<R> Observable.replay
(@NonNull Function<? super Observable<@NonNull T>, ? extends ObservableSource<@NonNull R>> selector, int bufferSize, long time, @NonNull TimeUnit unit) Returns anObservable
that emits items that are the results of invoking a specified selector on items emitted by aConnectableObservable
that shares a single subscription to the currentObservable
, replaying no more thanbufferSize
items that were emitted within a specified time window.final <@NonNull R>
@NonNull Observable<R> Observable.replay
(@NonNull Function<? super Observable<@NonNull T>, ? extends ObservableSource<@NonNull R>> selector, int bufferSize, long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Returns anObservable
that emits items that are the results of invoking a specified selector on items emitted by aConnectableObservable
that shares a single subscription to the currentObservable
, replaying no more thanbufferSize
items that were emitted within a specified time window.final <@NonNull R>
@NonNull Observable<R> Observable.replay
(@NonNull Function<? super Observable<@NonNull T>, ? extends ObservableSource<@NonNull R>> selector, int bufferSize, long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean eagerTruncate) Returns anObservable
that emits items that are the results of invoking a specified selector on items emitted by aConnectableObservable
that shares a single subscription to the currentObservable
, replaying no more thanbufferSize
items that were emitted within a specified time window.final <@NonNull R>
@NonNull Observable<R> Observable.replay
(@NonNull Function<? super Observable<@NonNull T>, ? extends ObservableSource<@NonNull R>> selector, long time, @NonNull TimeUnit unit) Returns anObservable
that emits items that are the results of invoking a specified selector on items emitted by aConnectableObservable
that shares a single subscription to the currentObservable
, replaying all items that were emitted within a specified time window.final <@NonNull R>
@NonNull Observable<R> Observable.replay
(@NonNull Function<? super Observable<@NonNull T>, ? extends ObservableSource<@NonNull R>> selector, long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Returns anObservable
that emits items that are the results of invoking a specified selector on items emitted by aConnectableObservable
that shares a single subscription to the currentObservable
, replaying all items that were emitted within a specified time window.final <@NonNull R>
@NonNull Observable<R> Observable.replay
(@NonNull Function<? super Observable<@NonNull T>, ? extends ObservableSource<@NonNull R>> selector, long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean eagerTruncate) Returns anObservable
that emits items that are the results of invoking a specified selector on items emitted by aConnectableObservable
that shares a single subscription to the currentObservable
, replaying all items that were emitted within a specified time window.final @NonNull Completable
Completable.retry()
Returns aCompletable
that retries thisCompletable
as long as it emits anonError
event.final @NonNull Completable
Completable.retry
(long times) Returns aCompletable
that when thisCompletable
emits an error, retries at most the given number of times before giving up and emitting the last error.final @NonNull Completable
Returns aCompletable
that when thisCompletable
emits an error, retries at most times or until the predicate returnsfalse
, whichever happens first and emitting the last error.final @NonNull Completable
Completable.retry
(@NonNull BiPredicate<? super Integer, ? super Throwable> predicate) Returns aCompletable
that retries thisCompletable
in case of an error as long as thepredicate
returnstrue
.final @NonNull Completable
Returns aCompletable
that when thisCompletable
emits an error, calls the given predicate with the latestThrowable
to decide whether to resubscribe to the upstream or not.Flowable.retry()
Returns aFlowable
that mirrors the currentFlowable
, resubscribing to it if it callsonError
(infinite retry count).Flowable.retry
(long times) Returns aFlowable
that mirrors the currentFlowable
, resubscribing to it if it callsonError
up to a specified number of retries.Retries at most times or until the predicate returnsfalse
, whichever happens first.Returns aFlowable
that mirrors the currentFlowable
, resubscribing to it if it callsonError
and the predicate returnstrue
for that specific exception and retry count.Retries the currentFlowable
if the predicate returnstrue
.Maybe.retry()
Returns aMaybe
that mirrors the currentMaybe
, resubscribing to it if it callsonError
(infinite retry count).Maybe.retry
(long times) Returns aMaybe
that mirrors the currentMaybe
, resubscribing to it if it callsonError
up to a specified number of retries.Retries at mosttimes
or until the predicate returnsfalse
, whichever happens first.Maybe.retry
(@NonNull BiPredicate<? super Integer, ? super Throwable> predicate) Returns aMaybe
that mirrors the currentMaybe
, resubscribing to it if it callsonError
and the predicate returnstrue
for that specific exception and retry count.Retries the currentMaybe
if it fails and the predicate returnstrue
.final @NonNull Observable
<T> Observable.retry()
Returns anObservable
that mirrors the currentObservable
, resubscribing to it if it callsonError
(infinite retry count).final @NonNull Observable
<T> Observable.retry
(long times) Returns anObservable
that mirrors the currentObservable
, resubscribing to it if it callsonError
up to a specified number of retries.final @NonNull Observable
<T> Retries at most times or until the predicate returnsfalse
, whichever happens first.final @NonNull Observable
<T> Observable.retry
(@NonNull BiPredicate<? super Integer, ? super Throwable> predicate) Returns anObservable
that mirrors the currentObservable
, resubscribing to it if it callsonError
and the predicate returnstrue
for that specific exception and retry count.final @NonNull Observable
<T> Retries the currentObservable
if the predicate returnstrue
.Single.retry()
Repeatedly re-subscribes to the currentSingle
indefinitely if it fails with anonError
.Single.retry
(long times) Repeatedly re-subscribe at most the specified times to the currentSingle
if it fails with anonError
.Repeatedly re-subscribe at most times or until the predicate returnsfalse
, whichever happens first if it fails with anonError
.Single.retry
(@NonNull BiPredicate<? super Integer, ? super Throwable> predicate) Re-subscribe to the currentSingle
if the given predicate returnstrue
when theSingle
fails with anonError
.Re-subscribe to the currentSingle
if the given predicate returnstrue
when theSingle
fails with anonError
.final @NonNull Completable
Completable.retryUntil
(@NonNull BooleanSupplier stop) Retries until the given stop function returnstrue
.Flowable.retryUntil
(@NonNull BooleanSupplier stop) Retries until the given stop function returnstrue
.Maybe.retryUntil
(@NonNull BooleanSupplier stop) Retries until the given stop function returnstrue
.final @NonNull Observable
<T> Observable.retryUntil
(@NonNull BooleanSupplier stop) Retries until the given stop function returnstrue
.Single.retryUntil
(@NonNull BooleanSupplier stop) Retries until the given stop function returnstrue
.final @NonNull Completable
Completable.retryWhen
(@NonNull Function<? super Flowable<Throwable>, @NonNull ? extends org.reactivestreams.Publisher<@NonNull ?>> handler) Returns aCompletable
which given aPublisher
and when thisCompletable
emits an error, delivers that error through aFlowable
and thePublisher
should signal a value indicating a retry in response or a terminal event indicating a termination.Flowable.retryWhen
(@NonNull Function<? super Flowable<Throwable>, @NonNull ? extends org.reactivestreams.Publisher<@NonNull ?>> handler) Returns aFlowable
that emits the same values as the currentFlowable
with the exception of anonError
.Maybe.retryWhen
(@NonNull Function<? super Flowable<Throwable>, @NonNull ? extends org.reactivestreams.Publisher<@NonNull ?>> handler) Returns aMaybe
that emits the same values as the currentMaybe
with the exception of anonError
.final @NonNull Observable
<T> Observable.retryWhen
(@NonNull Function<? super Observable<Throwable>, ? extends ObservableSource<?>> handler) Returns anObservable
that emits the same values as the currentObservable
with the exception of anonError
.Single.retryWhen
(@NonNull Function<? super Flowable<Throwable>, @NonNull ? extends org.reactivestreams.Publisher<@NonNull ?>> handler) Re-subscribes to the currentSingle
if and when thePublisher
returned by the handler function signals a value.Returns aFlowable
that emits the most recently emitted item (if any) emitted by the currentFlowable
within periodic time intervals.Returns aFlowable
that emits the most recently emitted item (if any) emitted by the currentFlowable
within periodic time intervals and optionally emit the very last upstream item when the upstream completes.Returns aFlowable
that emits the most recently emitted item (if any) emitted by the currentFlowable
within periodic time intervals, where the intervals are defined on a particularScheduler
.Flowable.sample
(long period, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean emitLast) Returns aFlowable
that emits the most recently emitted item (if any) emitted by the currentFlowable
within periodic time intervals, where the intervals are defined on a particularScheduler
and optionally emit the very last upstream item when the upstream completes.Flowable.sample
(long period, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean emitLast, @NonNull Consumer<? super @NonNull T> onDropped) Returns aFlowable
that emits the most recently emitted item (if any) emitted by the currentFlowable
within periodic time intervals, where the intervals are defined on a particularScheduler
and optionally emit the very last upstream item when the upstream completes.Returns aFlowable
that, when the specifiedsampler
Publisher
emits an item or completes, emits the most recently emitted item (if any) emitted by the currentFlowable
since the previous emission from thesampler
Publisher
.Returns aFlowable
that, when the specifiedsampler
Publisher
emits an item or completes, emits the most recently emitted item (if any) emitted by the currentFlowable
since the previous emission from thesampler
Publisher
and optionally emit the very last upstream item when the upstream or otherPublisher
complete.final @NonNull Observable
<T> Returns anObservable
that emits the most recently emitted item (if any) emitted by the currentObservable
within periodic time intervals.final @NonNull Observable
<T> Returns anObservable
that emits the most recently emitted item (if any) emitted by the currentObservable
within periodic time intervals and optionally emit the very last upstream item when the upstream completes.final @NonNull Observable
<T> Returns anObservable
that emits the most recently emitted item (if any) emitted by the currentObservable
within periodic time intervals, where the intervals are defined on a particularScheduler
.final @NonNull Observable
<T> Observable.sample
(long period, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean emitLast) Returns anObservable
that emits the most recently emitted item (if any) emitted by the currentObservable
within periodic time intervals, where the intervals are defined on a particularScheduler
and optionally emit the very last upstream item when the upstream completes.final @NonNull Observable
<T> Observable.sample
(long period, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean emitLast, @NonNull Consumer<? super @NonNull T> onDropped) Returns anObservable
that emits the most recently emitted item (if any) emitted by the currentObservable
within periodic time intervals, where the intervals are defined on a particularScheduler
.final <@NonNull U>
@NonNull Observable<T> Observable.sample
(@NonNull ObservableSource<@NonNull U> sampler) Returns anObservable
that, when the specifiedsampler
ObservableSource
emits an item or completes, emits the most recently emitted item (if any) emitted by the currentObservable
since the previous emission from thesampler
ObservableSource
.final <@NonNull U>
@NonNull Observable<T> Observable.sample
(@NonNull ObservableSource<@NonNull U> sampler, boolean emitLast) Returns anObservable
that, when the specifiedsampler
ObservableSource
emits an item or completes, emits the most recently emitted item (if any) emitted by the currentObservable
since the previous emission from thesampler
ObservableSource
and optionally emit the very last upstream item when the upstream or otherObservableSource
complete.Returns aFlowable
that emits the first value emitted by the currentFlowable
, then emits one value for each subsequent value emitted by the currentFlowable
.Flowable.scan
(@NonNull R initialValue, @NonNull BiFunction<@NonNull R, ? super @NonNull T, @NonNull R> accumulator) Returns aFlowable
that emits the provided initial (seed) value, then emits one value for each value emitted by the currentFlowable
.final @NonNull Observable
<T> Returns anObservable
that emits the first value emitted by the currentObservable
, then emits one value for each subsequent value emitted by the currentObservable
.final <@NonNull R>
@NonNull Observable<R> Observable.scan
(@NonNull R initialValue, @NonNull BiFunction<@NonNull R, ? super @NonNull T, @NonNull R> accumulator) Returns anObservable
that emits the provided initial (seed) value, then emits one value for each value emitted by the currentObservable
.Flowable.scanWith
(@NonNull Supplier<@NonNull R> seedSupplier, @NonNull BiFunction<@NonNull R, ? super @NonNull T, @NonNull R> accumulator) Returns aFlowable
that emits the provided initial (seed) value, then emits one value for each value emitted by the currentFlowable
.final <@NonNull R>
@NonNull Observable<R> Observable.scanWith
(@NonNull Supplier<@NonNull R> seedSupplier, @NonNull BiFunction<@NonNull R, ? super @NonNull T, @NonNull R> accumulator) Returns anObservable
that emits the provided initial (seed) value, then emits one value for each value emitted by the currentObservable
.Schedules a Runnable for execution without any time delay.abstract @NonNull Disposable
Schedules an Runnable for execution at some point in the future specified by a time delay relative to the current time.Scheduler.scheduleDirect
(@NonNull Runnable run) Schedules the given task on this Scheduler without any time delay.Scheduler.scheduleDirect
(@NonNull Runnable run, long delay, @NonNull TimeUnit unit) Schedules the execution of the given task with the given time delay.Scheduler.Worker.schedulePeriodically
(@NonNull Runnable run, long initialDelay, long period, @NonNull TimeUnit unit) Schedules a periodic execution of the given task with the given initial time delay and repeat period.Scheduler.schedulePeriodicallyDirect
(@NonNull Runnable run, long initialDelay, long period, @NonNull TimeUnit unit) Schedules a periodic execution of the given task with the given initial time delay and repeat period.Completable.sequenceEqual
(@NonNull CompletableSource source1, @NonNull CompletableSource source2) Flowable.sequenceEqual
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source2) Flowable.sequenceEqual
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source2, int bufferSize) 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) 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) Maybe.sequenceEqual
(@NonNull MaybeSource<? extends @NonNull T> source1, @NonNull MaybeSource<? extends @NonNull T> source2) Returns aSingle
that emits aBoolean
value that indicates whether twoMaybeSource
sequences are the same by comparing the items emitted by eachMaybeSource
pairwise.Maybe.sequenceEqual
(@NonNull MaybeSource<? extends @NonNull T> source1, @NonNull MaybeSource<? extends @NonNull T> source2, @NonNull BiPredicate<? super @NonNull T, ? super @NonNull T> isEqual) Returns aSingle
that emits aBoolean
value that indicates whether twoMaybeSource
s are the same by comparing the items emitted by eachMaybeSource
pairwise based on the results of a specified equality function.Observable.sequenceEqual
(@NonNull ObservableSource<? extends @NonNull T> source1, @NonNull ObservableSource<? extends @NonNull T> source2) Returns aSingle
that emits aBoolean
value that indicates whether twoObservableSource
sequences are the same by comparing the items emitted by eachObservableSource
pairwise.Observable.sequenceEqual
(@NonNull ObservableSource<? extends @NonNull T> source1, @NonNull ObservableSource<? extends @NonNull T> source2, int bufferSize) Returns aSingle
that emits aBoolean
value that indicates whether twoObservableSource
sequences are the same by comparing the items emitted by eachObservableSource
pairwise.Observable.sequenceEqual
(@NonNull ObservableSource<? extends @NonNull T> source1, @NonNull ObservableSource<? extends @NonNull T> source2, @NonNull BiPredicate<? super @NonNull T, ? super @NonNull T> isEqual) Returns aSingle
that emits aBoolean
value that indicates whether twoObservableSource
sequences are the same by comparing the items emitted by eachObservableSource
pairwise based on the results of a specified equality function.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 aSingle
that emits aBoolean
value that indicates whether twoObservableSource
sequences are the same by comparing the items emitted by eachObservableSource
pairwise based on the results of a specified equality function.Single.sequenceEqual
(@NonNull SingleSource<? extends @NonNull T> source1, @NonNull SingleSource<? extends @NonNull T> source2) Compares twoSingleSource
s and emitstrue
if they emit the same value (compared viaObject.equals(Object)
).Flowable.serialize()
Forces the currentFlowable
's emissions and notifications to be serialized and for it to obey thePublisher
contract in other ways.FlowableEmitter.serialize()
Ensures that calls toonNext
,onError
andonComplete
are properly serialized.final @NonNull Observable
<T> Observable.serialize()
Forces the currentObservable
's emissions and notifications to be serialized and for it to obey theObservableSource
contract in other ways.ObservableEmitter.serialize()
Ensures that calls toonNext
,onError
andonComplete
are properly serialized.Flowable.share()
Returns a newFlowable
that multicasts (and shares a single subscription to) the currentFlowable
.final @NonNull Observable
<T> Observable.share()
Returns a newObservable
that multicasts (and shares a single subscription to) the currentObservable
.Returns aSingle
that emits the single item emitted by the currentFlowable
if it emits only a single item, or a default item if the currentFlowable
emits no items.Returns aSingle
that emits the single item emitted by the currentObservable
, if the currentObservable
emits only a single item, or a default item if the currentObservable
emits no items.Flowable.singleElement()
Returns aMaybe
that completes if thisFlowable
is empty, signals one item if thisFlowable
signals exactly one item or signals anIllegalArgumentException
if thisFlowable
signals more than one item.Observable.singleElement()
Returns aMaybe
that completes if the currentObservable
is empty or emits the single item emitted by the currentObservable
, or signals anIllegalArgumentException
if the currentObservable
emits more than one item.Flowable.singleOrError()
Returns aSingle
that emits the single item emitted by thisFlowable
, if thisFlowable
emits only a single item, otherwise if thisFlowable
completes without emitting any items aNoSuchElementException
will be signaled and if thisFlowable
emits more than one item, anIllegalArgumentException
will be signaled.Observable.singleOrError()
Returns aSingle
that emits the single item emitted by the currentObservable
if it emits only a single item, otherwise if the currentObservable
completes without emitting any items or emits more than one item aNoSuchElementException
orIllegalArgumentException
will be signaled respectively.final @NonNull CompletionStage
<T> Flowable.singleOrErrorStage()
Signals the only expected upstream item, aNoSuchElementException
if the upstream is empty or signalsIllegalArgumentException
if the upstream has more than one item via aCompletionStage
.final @NonNull CompletionStage
<T> Observable.singleOrErrorStage()
Signals the only expected upstream item, aNoSuchElementException
if the upstream is empty or signalsIllegalArgumentException
if the upstream has more than one item via aCompletionStage
.final @NonNull CompletionStage
<T> Flowable.singleStage
(@NonNull T defaultItem) Signals the only expected upstream item (or the default item if the upstream is empty) or signalsIllegalArgumentException
if the upstream has more than one item via aCompletionStage
.final @NonNull CompletionStage
<T> Observable.singleStage
(@NonNull T defaultItem) Signals the only expected upstream item (or the default item if the upstream is empty) or signalsIllegalArgumentException
if the upstream has more than one item via aCompletionStage
.Flowable.skip
(long count) Returns aFlowable
that skips the firstcount
items emitted by the currentFlowable
and emits the remainder.Returns aFlowable
that skips values emitted by the currentFlowable
before a specified time window elapses.Returns aFlowable
that skips values emitted by the currentFlowable
before a specified time window on a specifiedScheduler
elapses.final @NonNull Observable
<T> Observable.skip
(long count) Returns anObservable
that skips the firstcount
items emitted by the currentObservable
and emits the remainder.final @NonNull Observable
<T> Returns anObservable
that skips values emitted by the currentObservable
before a specified time window elapses.final @NonNull Observable
<T> Returns anObservable
that skips values emitted by the currentObservable
before a specified time window on a specifiedScheduler
elapses.Flowable.skipLast
(int count) Returns aFlowable
that drops a specified number of items from the end of the sequence emitted by the currentFlowable
.Returns aFlowable
that drops items emitted by the currentFlowable
during a specified time window before the source completes.Returns aFlowable
that drops items emitted by the currentFlowable
during a specified time window before the source completes.Returns aFlowable
that drops items emitted by the currentFlowable
during a specified time window (defined on a specified scheduler) before the source completes.Flowable.skipLast
(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean delayError) Returns aFlowable
that drops items emitted by the currentFlowable
during a specified time window (defined on a specified scheduler) before the source completes.Flowable.skipLast
(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean delayError, int bufferSize) Returns aFlowable
that drops items emitted by the currentFlowable
during a specified time window (defined on a specified scheduler) before the source completes.final @NonNull Observable
<T> Observable.skipLast
(int count) Returns anObservable
that drops a specified number of items from the end of the sequence emitted by the currentObservable
.final @NonNull Observable
<T> Returns anObservable
that drops items emitted by the currentObservable
during a specified time window before the source completes.final @NonNull Observable
<T> Returns anObservable
that drops items emitted by the currentObservable
during a specified time window before the source completes.final @NonNull Observable
<T> Returns anObservable
that drops items emitted by the currentObservable
during a specified time window (defined on a specified scheduler) before the source completes.final @NonNull Observable
<T> Observable.skipLast
(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean delayError) Returns anObservable
that drops items emitted by the currentObservable
during a specified time window (defined on a specified scheduler) before the source completes.final @NonNull Observable
<T> Observable.skipLast
(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean delayError, int bufferSize) Returns anObservable
that drops items emitted by the currentObservable
during a specified time window (defined on a specified scheduler) before the source completes.Returns aFlowable
that skips items emitted by the currentFlowable
until a secondPublisher
emits an item.final <@NonNull U>
@NonNull Observable<T> Observable.skipUntil
(@NonNull ObservableSource<@NonNull U> other) Returns anObservable
that skips items emitted by the currentObservable
until a secondObservableSource
emits an item.Returns aFlowable
that skips all items emitted by the currentFlowable
as long as a specified condition holdstrue
, but emits all further source items as soon as the condition becomesfalse
.final @NonNull Observable
<T> Returns anObservable
that skips all items emitted by the currentObservable
as long as a specified condition holdstrue
, but emits all further source items as soon as the condition becomesfalse
.Flowable.sorted()
Returns aFlowable
that emits the events emitted by sourcePublisher
, in a sorted order.Returns aFlowable
that emits the events emitted by sourcePublisher
, in a sorted order based on a specified comparison function.final @NonNull Observable
<T> Observable.sorted()
Returns anObservable
that emits the events emitted by the currentObservable
, in a sorted order.final @NonNull Observable
<T> Observable.sorted
(@NonNull Comparator<? super @NonNull T> comparator) Returns anObservable
that emits the events emitted by the currentObservable
, in a sorted order based on a specified comparison function.final @NonNull Completable
Completable.startWith
(@NonNull CompletableSource other) Returns aCompletable
which first runs the otherCompletableSource
then the currentCompletable
if the other completed normally.Completable.startWith
(@NonNull MaybeSource<@NonNull T> other) Returns aFlowable
which first runs the otherMaybeSource
then the currentCompletable
if the other succeeded or completed normally.final <@NonNull T>
@NonNull Observable<T> Completable.startWith
(@NonNull ObservableSource<@NonNull T> other) Returns anObservable
which first delivers the events of the otherObservableSource
then runs the currentCompletable
.Completable.startWith
(@NonNull SingleSource<@NonNull T> other) Returns aFlowable
which first runs the otherSingleSource
then the currentCompletable
if the other succeeded normally.Returns aFlowable
which first delivers the events of the otherPublisher
then runs the currentCompletable
.Flowable.startWith
(@NonNull CompletableSource other) Returns aFlowable
which first runs the otherCompletableSource
then the currentFlowable
if the other completed normally.Flowable.startWith
(@NonNull MaybeSource<@NonNull T> other) Returns aFlowable
which first runs the otherMaybeSource
then the currentFlowable
if the other succeeded or completed normally.Flowable.startWith
(@NonNull SingleSource<@NonNull T> other) Returns aFlowable
which first runs the otherSingleSource
then the currentFlowable
if the other succeeded normally.Returns aFlowable
that emits the items in a specifiedPublisher
before it begins to emit items emitted by the currentFlowable
.Maybe.startWith
(@NonNull CompletableSource other) Returns aFlowable
which first runs the otherCompletableSource
then the currentMaybe
if the other completed normally.Maybe.startWith
(@NonNull MaybeSource<@NonNull T> other) Returns aFlowable
which first runs the otherMaybeSource
then the currentMaybe
if the other succeeded or completed normally.final @NonNull Observable
<T> Maybe.startWith
(@NonNull ObservableSource<@NonNull T> other) Returns anObservable
which first delivers the events of the otherObservableSource
then runs the currentMaybe
.Maybe.startWith
(@NonNull SingleSource<@NonNull T> other) Returns aFlowable
which first runs the otherSingleSource
then the currentMaybe
if the other succeeded normally.Returns aFlowable
which first delivers the events of the otherPublisher
then runs the currentMaybe
.final @NonNull Observable
<T> Observable.startWith
(@NonNull CompletableSource other) Returns anObservable
which first runs the otherCompletableSource
then the currentObservable
if the other completed normally.final @NonNull Observable
<T> Observable.startWith
(@NonNull MaybeSource<@NonNull T> other) Returns anObservable
which first runs the otherMaybeSource
then the currentObservable
if the other succeeded or completed normally.final @NonNull Observable
<T> Observable.startWith
(@NonNull ObservableSource<? extends @NonNull T> other) Returns anObservable
that emits the items in a specifiedObservableSource
before it begins to emit items emitted by the currentObservable
.final @NonNull Observable
<T> Observable.startWith
(@NonNull SingleSource<@NonNull T> other) Returns anObservable
which first runs the otherSingleSource
then the currentObservable
if the other succeeded normally.Single.startWith
(@NonNull CompletableSource other) Returns aFlowable
which first runs the otherCompletableSource
then the currentSingle
if the other completed normally.Single.startWith
(@NonNull MaybeSource<@NonNull T> other) Returns aFlowable
which first runs the otherMaybeSource
then the currentSingle
if the other succeeded or completed normally.final @NonNull Observable
<T> Single.startWith
(@NonNull ObservableSource<@NonNull T> other) Returns anObservable
which first delivers the events of the otherObservableSource
then runs the currentSingle
.Single.startWith
(@NonNull SingleSource<@NonNull T> other) Returns aFlowable
which first runs the otherSingleSource
then the currentSingle
if the other succeeded normally.Returns aFlowable
which first delivers the events of the otherPublisher
then runs the currentSingle
.Flowable.startWithArray
(@NonNull T... items) Returns aFlowable
that emits the specified items before it begins to emit items emitted by the currentFlowable
.final @NonNull Observable
<T> Observable.startWithArray
(@NonNull T... items) Returns anObservable
that emits the specified items before it begins to emit items emitted by the currentObservable
.Flowable.startWithItem
(@NonNull T item) Returns aFlowable
that emits a specified item before it begins to emit items emitted by the currentFlowable
.final @NonNull Observable
<T> Observable.startWithItem
(@NonNull T item) Returns anObservable
that emits a specified item before it begins to emit items emitted by the currentObservable
.Flowable.startWithIterable
(@NonNull Iterable<? extends @NonNull T> items) Returns aFlowable
that emits the items in a specifiedIterable
before it begins to emit items emitted by the currentFlowable
.final @NonNull Observable
<T> Observable.startWithIterable
(@NonNull Iterable<? extends @NonNull T> items) Returns anObservable
that emits the items in a specifiedIterable
before it begins to emit items emitted by the currentObservable
.final @NonNull Disposable
Completable.subscribe()
Subscribes to thisCompletable
and returns aDisposable
which can be used to dispose the subscription.final @NonNull Disposable
final @NonNull Disposable
Subscribes to thisCompletable
and calls back either theonError
oronComplete
functions.final @NonNull Disposable
Completable.subscribe
(@NonNull Action onComplete, @NonNull Consumer<? super Throwable> onError, @NonNull DisposableContainer container) Wraps the given onXXX callbacks into aDisposable
CompletableObserver
, adds it to the givenDisposableContainer
and ensures, that if the upstream terminates or this particularDisposable
is disposed, theCompletableObserver
is removed from the given composite.final @NonNull Disposable
Flowable.subscribe()
Subscribes to the currentFlowable
and ignoresonNext
andonComplete
emissions.final @NonNull Disposable
Subscribes to the currentFlowable
and provides a callback to handle the items it emits.final @NonNull Disposable
Flowable.subscribe
(@NonNull Consumer<? super @NonNull T> onNext, @NonNull Consumer<? super Throwable> onError) Subscribes to the currentFlowable
and provides callbacks to handle the items it emits and any error notification it issues.final @NonNull Disposable
Flowable.subscribe
(@NonNull Consumer<? super @NonNull T> onNext, @NonNull Consumer<? super Throwable> onError, @NonNull Action onComplete) Subscribes to the currentFlowable
and provides callbacks to handle the items it emits and any error or completion notification it issues.final @NonNull Disposable
Flowable.subscribe
(@NonNull Consumer<? super @NonNull T> onNext, @NonNull Consumer<? super Throwable> onError, @NonNull Action onComplete, @NonNull DisposableContainer container) Wraps the given onXXX callbacks into aDisposable
Subscriber
, adds it to the givenDisposableContainer
and ensures, that if the upstream terminates or this particularDisposable
is disposed, theSubscriber
is removed from the given container.final @NonNull Disposable
Maybe.subscribe()
Subscribes to aMaybe
and ignoresonSuccess
andonComplete
emissions.final @NonNull Disposable
Subscribes to aMaybe
and provides a callback to handle the items it emits.final @NonNull Disposable
Maybe.subscribe
(@NonNull Consumer<? super @NonNull T> onSuccess, @NonNull Consumer<? super Throwable> onError) Subscribes to aMaybe
and provides callbacks to handle the items it emits and any error notification it issues.final @NonNull Disposable
Maybe.subscribe
(@NonNull Consumer<? super @NonNull T> onSuccess, @NonNull Consumer<? super Throwable> onError, @NonNull Action onComplete) Subscribes to aMaybe
and provides callbacks to handle the items it emits and any error or completion notification it issues.final @NonNull Disposable
Maybe.subscribe
(@NonNull Consumer<? super @NonNull T> onSuccess, @NonNull Consumer<? super Throwable> onError, @NonNull Action onComplete, @NonNull DisposableContainer container) Wraps the given onXXX callbacks into aDisposable
MaybeObserver
, adds it to the givenDisposableContainer
and ensures, that if the upstream terminates or this particularDisposable
is disposed, theMaybeObserver
is removed from the given composite.final @NonNull Disposable
Observable.subscribe()
Subscribes to the currentObservable
and ignoresonNext
andonComplete
emissions.final @NonNull Disposable
Subscribes to the currentObservable
and provides a callback to handle the items it emits.final @NonNull Disposable
Observable.subscribe
(@NonNull Consumer<? super @NonNull T> onNext, @NonNull Consumer<? super Throwable> onError) Subscribes to the currentObservable
and provides callbacks to handle the items it emits and any error notification it signals.final @NonNull Disposable
Observable.subscribe
(@NonNull Consumer<? super @NonNull T> onNext, @NonNull Consumer<? super Throwable> onError, @NonNull Action onComplete) Subscribes to the currentObservable
and provides callbacks to handle the items it emits and any error or completion notification it signals.final @NonNull Disposable
Observable.subscribe
(@NonNull Consumer<? super @NonNull T> onNext, @NonNull Consumer<? super Throwable> onError, @NonNull Action onComplete, @NonNull DisposableContainer container) Wraps the given onXXX callbacks into aDisposable
Observer
, adds it to the givenDisposableContainer
and ensures, that if the upstream terminates or this particularDisposable
is disposed, theObserver
is removed from the given container.final @NonNull Disposable
Single.subscribe()
Subscribes to aSingle
but ignore its emission or notification.final @NonNull Disposable
Single.subscribe
(@NonNull BiConsumer<@Nullable ? super @NonNull T, @Nullable ? super Throwable> onCallback) Subscribes to aSingle
and provides a composite callback to handle the item it emits or any error notification it issues.final @NonNull Disposable
Subscribes to aSingle
and provides a callback to handle the item it emits.final @NonNull Disposable
Single.subscribe
(@NonNull Consumer<? super @NonNull T> onSuccess, @NonNull Consumer<? super Throwable> onError) Subscribes to aSingle
and provides callbacks to handle the item it emits or any error notification it issues.final @NonNull Disposable
Single.subscribe
(@NonNull Consumer<? super @NonNull T> onSuccess, @NonNull Consumer<? super Throwable> onError, @NonNull DisposableContainer container) Wraps the given onXXX callbacks into aDisposable
SingleObserver
, adds it to the givenDisposableContainer
and ensures, that if the upstream terminates or this particularDisposable
is disposed, theSingleObserver
is removed from the given container.final @NonNull Completable
Completable.subscribeOn
(@NonNull Scheduler scheduler) Returns aCompletable
which subscribes the downstream subscriber on the specified scheduler, making sure the subscription side-effects happen on that specific thread of theScheduler
.Flowable.subscribeOn
(@NonNull Scheduler scheduler) Flowable.subscribeOn
(@NonNull Scheduler scheduler, boolean requestOn) Asynchronously subscribesSubscriber
s to the currentFlowable
on the specifiedScheduler
optionally reroutes requests from other threads to the sameScheduler
thread.Maybe.subscribeOn
(@NonNull Scheduler scheduler) Asynchronously subscribes subscribers to thisMaybe
on the specifiedScheduler
.final @NonNull Observable
<T> Observable.subscribeOn
(@NonNull Scheduler scheduler) Single.subscribeOn
(@NonNull Scheduler scheduler) final <@NonNull E extends CompletableObserver>
ECompletable.subscribeWith
(@NonNull E observer) Subscribes a givenCompletableObserver
(subclass) to thisCompletable
and returns the givenCompletableObserver
as is.Flowable.subscribeWith
(@NonNull E subscriber) Subscribes a givenSubscriber
(subclass) to thisFlowable
and returns the givenSubscriber
as is.final <@NonNull E extends MaybeObserver<? super @NonNull T>>
EMaybe.subscribeWith
(@NonNull E observer) Subscribes a givenMaybeObserver
(subclass) to thisMaybe
and returns the givenMaybeObserver
as is.Observable.subscribeWith
(@NonNull E observer) Subscribes a givenObserver
(subclass) to the currentObservable
and returns the givenObserver
instance as is.final <@NonNull E extends SingleObserver<? super @NonNull T>>
ESingle.subscribeWith
(@NonNull E observer) Subscribes a givenSingleObserver
(subclass) to thisSingle
and returns the givenSingleObserver
as is.Flowable.switchIfEmpty
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T> other) Returns aFlowable
that emits the items emitted by the currentFlowable
or the items of an alternatePublisher
if the currentFlowable
is empty.Maybe.switchIfEmpty
(@NonNull MaybeSource<? extends @NonNull T> other) Returns aMaybe
that emits the items emitted by the currentMaybe
or the items of an alternateMaybeSource
if the currentMaybe
is empty.Maybe.switchIfEmpty
(@NonNull SingleSource<? extends @NonNull T> other) Returns aSingle
that emits the items emitted by the currentMaybe
or the item of an alternateSingleSource
if the currentMaybe
is empty.final @NonNull Observable
<T> Observable.switchIfEmpty
(@NonNull ObservableSource<? extends @NonNull T> other) Returns anObservable
that emits the items emitted by the currentObservable
or the items of an alternateObservableSource
if the currentObservable
is empty.Flowable.switchMap
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper) Returns a newFlowable
by applying a function that you supply to each item emitted by the currentFlowable
that returns aPublisher
, and then emitting the items emitted by the most recently emitted of thesePublisher
s.Flowable.switchMap
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper, int bufferSize) Returns a newFlowable
by applying a function that you supply to each item emitted by the currentFlowable
that returns aPublisher
, and then emitting the items emitted by the most recently emitted of thesePublisher
s.final <@NonNull R>
@NonNull Observable<R> Observable.switchMap
(@NonNull Function<? super @NonNull T, ? extends ObservableSource<? extends @NonNull R>> mapper) Returns a newObservable
by applying a function that you supply to each item emitted by the currentObservable
that returns anObservableSource
, and then emitting the items emitted by the most recently emitted of theseObservableSource
s.final <@NonNull R>
@NonNull Observable<R> Observable.switchMap
(@NonNull Function<? super @NonNull T, ? extends ObservableSource<? extends @NonNull R>> mapper, int bufferSize) Returns a newObservable
by applying a function that you supply to each item emitted by the currentObservable
that returns anObservableSource
, and then emitting the items emitted by the most recently emitted of theseObservableSource
s.final @NonNull Completable
Flowable.switchMapCompletable
(@NonNull Function<? super @NonNull T, ? extends CompletableSource> mapper) Maps the upstream values intoCompletableSource
s, subscribes to the newer one while disposing the subscription to the previousCompletableSource
, thus keeping at most one activeCompletableSource
running.final @NonNull Completable
Observable.switchMapCompletable
(@NonNull Function<? super @NonNull T, ? extends CompletableSource> mapper) Maps the items of the currentObservable
intoCompletableSource
s, subscribes to the newer one while disposing the subscription to the previousCompletableSource
, thus keeping at most one activeCompletableSource
running.final @NonNull Completable
Flowable.switchMapCompletableDelayError
(@NonNull Function<? super @NonNull T, ? extends CompletableSource> mapper) Maps the upstream values intoCompletableSource
s, subscribes to the newer one while disposing the subscription to the previousCompletableSource
, thus keeping at most one activeCompletableSource
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 intoCompletableSource
s, subscribes to the newer one while disposing the subscription to the previousCompletableSource
, thus keeping at most one activeCompletableSource
running and delaying any main or inner errors until all of them terminate.Flowable.switchMapDelayError
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper) Returns a newFlowable
by applying a function that you supply to each item emitted by the currentFlowable
that returns aPublisher
, and then emitting the items emitted by the most recently emitted of thesePublisher
s and delays any error until allPublisher
s terminate.Flowable.switchMapDelayError
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper, int bufferSize) Returns a newFlowable
by applying a function that you supply to each item emitted by the currentFlowable
that returns aPublisher
, and then emitting the items emitted by the most recently emitted of thesePublisher
s and delays any error until allPublisher
s terminate.final <@NonNull R>
@NonNull Observable<R> Observable.switchMapDelayError
(@NonNull Function<? super @NonNull T, ? extends ObservableSource<? extends @NonNull R>> mapper) Returns a newObservable
by applying a function that you supply to each item emitted by the currentObservable
that returns anObservableSource
, and then emitting the items emitted by the most recently emitted of theseObservableSource
s and delays any error until allObservableSource
s terminate.final <@NonNull R>
@NonNull Observable<R> Observable.switchMapDelayError
(@NonNull Function<? super @NonNull T, ? extends ObservableSource<? extends @NonNull R>> mapper, int bufferSize) Returns a newObservable
by applying a function that you supply to each item emitted by the currentObservable
that returns anObservableSource
, and then emitting the items emitted by the most recently emitted of theseObservableSource
s and delays any error until allObservableSource
s terminate.Flowable.switchMapMaybe
(@NonNull Function<? super @NonNull T, ? extends MaybeSource<? extends @NonNull R>> mapper) Maps the upstream items intoMaybeSource
s and switches (subscribes) to the newer ones while disposing the older ones (and ignoring their signals) and emits the latest success value of the current one if available while failing immediately if thisFlowable
or any of the active innerMaybeSource
s fail.final <@NonNull R>
@NonNull Observable<R> Observable.switchMapMaybe
(@NonNull Function<? super @NonNull T, ? extends MaybeSource<? extends @NonNull R>> mapper) Maps the items of the currentObservable
intoMaybeSource
s and switches (subscribes) to the newer ones while disposing the older ones (and ignoring their signals) and emits the latest success value of the current one if available while failing immediately if the currentObservable
or any of the active innerMaybeSource
s fail.Flowable.switchMapMaybeDelayError
(@NonNull Function<? super @NonNull T, ? extends MaybeSource<? extends @NonNull R>> mapper) Maps the upstream items intoMaybeSource
s and switches (subscribes) to the newer ones while disposing the older ones (and ignoring their signals) and emits the latest success value of the current one if available, delaying errors from thisFlowable
or the innerMaybeSource
s until all terminate.final <@NonNull R>
@NonNull Observable<R> Observable.switchMapMaybeDelayError
(@NonNull Function<? super @NonNull T, ? extends MaybeSource<? extends @NonNull R>> mapper) Maps the upstream items intoMaybeSource
s and switches (subscribes) to the newer ones while disposing the older ones (and ignoring their signals) and emits the latest success value of the current one if available, delaying errors from the currentObservable
or the innerMaybeSource
s until all terminate.Flowable.switchMapSingle
(@NonNull Function<? super @NonNull T, ? extends SingleSource<? extends @NonNull R>> mapper) Maps the upstream items intoSingleSource
s and switches (subscribes) to the newer ones while disposing the older ones (and ignoring their signals) and emits the latest success value of the current one while failing immediately if thisFlowable
or any of the active innerSingleSource
s fail.final <@NonNull R>
@NonNull Observable<R> Observable.switchMapSingle
(@NonNull Function<? super @NonNull T, ? extends SingleSource<? extends @NonNull R>> mapper) Returns a newObservable
by applying a function that you supply to each item emitted by the currentObservable
that returns aSingleSource
, and then emitting the item emitted by the most recently emitted of theseSingleSource
s.Flowable.switchMapSingleDelayError
(@NonNull Function<? super @NonNull T, ? extends SingleSource<? extends @NonNull R>> mapper) Maps the upstream items intoSingleSource
s and switches (subscribes) to the newer ones while disposing the older ones (and ignoring their signals) and emits the latest success value of the current one, delaying errors from thisFlowable
or the innerSingleSource
s until all terminate.final <@NonNull R>
@NonNull Observable<R> Observable.switchMapSingleDelayError
(@NonNull Function<? super @NonNull T, ? extends SingleSource<? extends @NonNull R>> mapper) Returns a newObservable
by applying a function that you supply to each item emitted by the currentObservable
that returns aSingleSource
, and then emitting the item emitted by the most recently emitted of theseSingleSource
s and delays any error until allSingleSource
s terminate.static @NonNull Completable
Completable.switchOnNext
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends CompletableSource> sources) Switches betweenCompletableSource
s emitted by the sourcePublisher
whenever a newCompletableSource
is emitted, disposing the previously runningCompletableSource
, exposing the setup as aCompletable
sequence.Flowable.switchOnNext
(@NonNull org.reactivestreams.Publisher<? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources, int bufferSize) Converts aPublisher
that emitsPublisher
s into aPublisher
that emits the items emitted by the most recently emitted of thosePublisher
s.Flowable.switchOnNext
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources) Converts aPublisher
that emitsPublisher
s into aPublisher
that emits the items emitted by the most recently emitted of thosePublisher
s.Maybe.switchOnNext
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources) Switches betweenMaybeSource
s emitted by the sourcePublisher
whenever a newMaybeSource
is emitted, disposing the previously runningMaybeSource
, exposing the success items as aFlowable
sequence.static <@NonNull T>
@NonNull Observable<T> Observable.switchOnNext
(@NonNull ObservableSource<? extends ObservableSource<? extends @NonNull T>> sources) Converts anObservableSource
that emitsObservableSource
s into anObservable
that emits the items emitted by the most recently emitted of thoseObservableSource
s.static <@NonNull T>
@NonNull Observable<T> Observable.switchOnNext
(@NonNull ObservableSource<? extends ObservableSource<? extends @NonNull T>> sources, int bufferSize) Converts anObservableSource
that emitsObservableSource
s into anObservable
that emits the items emitted by the most recently emitted of thoseObservableSource
s.Single.switchOnNext
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends SingleSource<? extends @NonNull T>> sources) Switches betweenSingleSource
s emitted by the sourcePublisher
whenever a newSingleSource
is emitted, disposing the previously runningSingleSource
, exposing the success items as aFlowable
sequence.static @NonNull Completable
Completable.switchOnNextDelayError
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends CompletableSource> sources) Switches betweenCompletableSource
s emitted by the sourcePublisher
whenever a newCompletableSource
is emitted, disposing the previously runningCompletableSource
, exposing the setup as aCompletable
sequence and delaying all errors from all of them until all terminate.Flowable.switchOnNextDelayError
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources) Converts aPublisher
that emitsPublisher
s into aPublisher
that emits the items emitted by the most recently emitted of thosePublisher
s and delays any exception until allPublisher
s terminate.Flowable.switchOnNextDelayError
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources, int prefetch) Converts aPublisher
that emitsPublisher
s into aPublisher
that emits the items emitted by the most recently emitted of thosePublisher
s and delays any exception until allPublisher
s terminate.Maybe.switchOnNextDelayError
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources) Switches betweenMaybeSource
s emitted by the sourcePublisher
whenever a newMaybeSource
is emitted, disposing the previously runningMaybeSource
, exposing the success items as aFlowable
sequence and delaying all errors from all of them until all terminate.static <@NonNull T>
@NonNull Observable<T> Observable.switchOnNextDelayError
(@NonNull ObservableSource<? extends ObservableSource<? extends @NonNull T>> sources) Converts anObservableSource
that emitsObservableSource
s into anObservable
that emits the items emitted by the most recently emitted of thoseObservableSource
s and delays any exception until allObservableSource
s terminate.static <@NonNull T>
@NonNull Observable<T> Observable.switchOnNextDelayError
(@NonNull ObservableSource<? extends ObservableSource<? extends @NonNull T>> sources, int bufferSize) Converts anObservableSource
that emitsObservableSource
s into anObservable
that emits the items emitted by the most recently emitted of thoseObservableSource
s and delays any exception until allObservableSource
s terminate.Single.switchOnNextDelayError
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends SingleSource<? extends @NonNull T>> sources) Switches betweenSingleSource
s emitted by the sourcePublisher
whenever a newSingleSource
is emitted, disposing the previously runningSingleSource
, exposing the success items as aFlowable
sequence and delaying all errors from all of them until all terminate.Flowable.take
(long count) Returns aFlowable
that emits only the firstcount
items emitted by the currentFlowable
.Returns aFlowable
that emits those items emitted by sourcePublisher
before a specified time runs out.Returns aFlowable
that emits those items emitted by sourcePublisher
before a specified time (on a specifiedScheduler
) runs out.final @NonNull Observable
<T> Observable.take
(long count) Returns anObservable
that emits only the firstcount
items emitted by the currentObservable
.final @NonNull Observable
<T> Returns anObservable
that emits those items emitted by the currentObservable
before a specified time runs out.final @NonNull Observable
<T> Returns anObservable
that emits those items emitted by the currentObservable
before a specified time (on a specifiedScheduler
) runs out.Flowable.takeLast
(int count) Returns aFlowable
that emits at most the lastcount
items emitted by the currentFlowable
.Returns aFlowable
that emits at most a specified number of items from the currentFlowable
that were emitted in a specified window of time before the currentFlowable
completed.Returns aFlowable
that emits at most a specified number of items from the currentFlowable
that were emitted in a specified window of time before the currentFlowable
completed, where the timing information is provided by a givenScheduler
.Flowable.takeLast
(long count, long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean delayError, int bufferSize) Returns aFlowable
that emits at most a specified number of items from the currentFlowable
that were emitted in a specified window of time before the currentFlowable
completed, where the timing information is provided by a givenScheduler
.Returns aFlowable
that emits the items from the currentFlowable
that were emitted in a specified window of time before the currentFlowable
completed.Returns aFlowable
that emits the items from the currentFlowable
that were emitted in a specified window of time before the currentFlowable
completed.Returns aFlowable
that emits the items from the currentFlowable
that were emitted in a specified window of time before the currentFlowable
completed, where the timing information is provided by a specifiedScheduler
.Flowable.takeLast
(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean delayError) Returns aFlowable
that emits the items from the currentFlowable
that were emitted in a specified window of time before the currentFlowable
completed, where the timing information is provided by a specifiedScheduler
.Flowable.takeLast
(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean delayError, int bufferSize) Returns aFlowable
that emits the items from the currentFlowable
that were emitted in a specified window of time before the currentFlowable
completed, where the timing information is provided by a specifiedScheduler
.final @NonNull Observable
<T> Observable.takeLast
(int count) Returns anObservable
that emits at most the lastcount
items emitted by the currentObservable
.final @NonNull Observable
<T> Returns anObservable
that emits at most a specified number of items from the currentObservable
that were emitted in a specified window of time before the currentObservable
completed.final @NonNull Observable
<T> Returns anObservable
that emits at most a specified number of items from the currentObservable
that were emitted in a specified window of time before the currentObservable
completed, where the timing information is provided by a givenScheduler
.final @NonNull Observable
<T> Observable.takeLast
(long count, long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean delayError, int bufferSize) Returns anObservable
that emits at most a specified number of items from the currentObservable
that were emitted in a specified window of time before the currentObservable
completed, where the timing information is provided by a givenScheduler
.final @NonNull Observable
<T> Returns anObservable
that emits the items from the currentObservable
that were emitted in a specified window of time before the currentObservable
completed.final @NonNull Observable
<T> Returns anObservable
that emits the items from the currentObservable
that were emitted in a specified window of time before the currentObservable
completed.final @NonNull Observable
<T> Returns anObservable
that emits the items from the currentObservable
that were emitted in a specified window of time before the currentObservable
completed, where the timing information is provided by a specifiedScheduler
.final @NonNull Observable
<T> Observable.takeLast
(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean delayError) Returns anObservable
that emits the items from the currentObservable
that were emitted in a specified window of time before the currentObservable
completed, where the timing information is provided by a specifiedScheduler
.final @NonNull Observable
<T> Observable.takeLast
(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean delayError, int bufferSize) Returns anObservable
that emits the items from the currentObservable
that were emitted in a specified window of time before the currentObservable
completed, where the timing information is provided by a specifiedScheduler
.final @NonNull Completable
Completable.takeUntil
(@NonNull CompletableSource other) Terminates the downstream if this or the otherCompletable
terminates (wins the termination race) while disposing the connection to the losing source.Returns aFlowable
that emits items emitted by the currentFlowable
, checks the specified predicate for each item, and then completes when the condition is satisfied.Returns aFlowable
that emits the items emitted by the currentFlowable
until a secondPublisher
emits an item or completes.Maybe.takeUntil
(@NonNull MaybeSource<@NonNull U> other) Returns aMaybe
that emits the items emitted by the currentMaybe
until a secondMaybeSource
emits an item.Returns aMaybe
that emits the item emitted by the currentMaybe
until a secondPublisher
emits an item.final <@NonNull U>
@NonNull Observable<T> Observable.takeUntil
(@NonNull ObservableSource<@NonNull U> other) Returns anObservable
that emits the items emitted by the currentObservable
until a secondObservableSource
emits an item or completes.final @NonNull Observable
<T> Returns anObservable
that emits items emitted by the currentObservable
, checks the specified predicate for each item, and then completes when the condition is satisfied.Single.takeUntil
(@NonNull CompletableSource other) Returns aSingle
that emits the item emitted by the currentSingle
until aCompletableSource
terminates.Single.takeUntil
(@NonNull SingleSource<? extends @NonNull E> other) Returns aSingle
that emits the item emitted by the currentSingle
until a secondSingle
emits an item.Returns aSingle
that emits the item emitted by the currentSingle
until aPublisher
emits an item or completes.Returns aFlowable
that emits items emitted by the currentFlowable
so long as each item satisfied a specified condition, and then completes as soon as this condition is not satisfied.final @NonNull Observable
<T> Returns anObservable
that emits items emitted by the currentObservable
so long as each item satisfied a specified condition, and then completes as soon as this condition is not satisfied.final @NonNull TestObserver
<Void> Completable.test()
Creates aTestObserver
and subscribes it to thisCompletable
.final @NonNull TestObserver
<Void> Completable.test
(boolean dispose) Creates aTestObserver
optionally in cancelled state, then subscribes it to thisCompletable
.final @NonNull TestSubscriber
<T> Flowable.test()
final @NonNull TestSubscriber
<T> Flowable.test
(long initialRequest) Creates aTestSubscriber
with the given initial request amount and subscribes it to thisFlowable
.final @NonNull TestSubscriber
<T> Flowable.test
(long initialRequest, boolean cancel) Creates aTestSubscriber
with the given initial request amount, optionally cancels it before the subscription and subscribes it to thisFlowable
.final @NonNull TestObserver
<T> Maybe.test()
Creates aTestObserver
and subscribes it to thisMaybe
.final @NonNull TestObserver
<T> Maybe.test
(boolean dispose) Creates aTestObserver
optionally in cancelled state, then subscribes it to thisMaybe
.final @NonNull TestObserver
<T> Observable.test()
Creates aTestObserver
and subscribes it to the currentObservable
.final @NonNull TestObserver
<T> Observable.test
(boolean dispose) Creates aTestObserver
, optionally disposes it and then subscribes it to the currentObservable
.final @NonNull TestObserver
<T> Single.test()
Creates aTestObserver
and subscribes it to thisSingle
.final @NonNull TestObserver
<T> Single.test
(boolean dispose) Creates aTestObserver
optionally in cancelled state, then subscribes it to thisSingle
.Flowable.throttleFirst
(long windowDuration, @NonNull TimeUnit unit) Returns aFlowable
that emits only the first item emitted by the currentFlowable
during sequential time windows of a specified duration.Flowable.throttleFirst
(long skipDuration, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Returns aFlowable
that emits only the first item emitted by the currentFlowable
during sequential time windows of a specified duration, where the windows are managed by a specifiedScheduler
.Flowable.throttleFirst
(long skipDuration, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, @NonNull Consumer<? super @NonNull T> onDropped) Returns aFlowable
that emits only the first item emitted by the currentFlowable
during sequential time windows of a specified duration, where the windows are managed by a specifiedScheduler
.final @NonNull Observable
<T> Observable.throttleFirst
(long windowDuration, @NonNull TimeUnit unit) Returns anObservable
that emits only the first item emitted by the currentObservable
during sequential time windows of a specified duration.final @NonNull Observable
<T> Observable.throttleFirst
(long skipDuration, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Returns anObservable
that emits only the first item emitted by the currentObservable
during sequential time windows of a specified duration, where the windows are managed by a specifiedScheduler
.final @NonNull Observable
<T> Observable.throttleFirst
(long skipDuration, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, @NonNull Consumer<? super @NonNull T> onDropped) Returns anObservable
that emits only the first item emitted by the currentObservable
during sequential time windows of a specified duration, where the windows are managed by a specifiedScheduler
.Flowable.throttleLast
(long intervalDuration, @NonNull TimeUnit unit) Returns aFlowable
that emits only the last item emitted by the currentFlowable
during sequential time windows of a specified duration.Flowable.throttleLast
(long intervalDuration, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Returns aFlowable
that emits only the last item emitted by the currentFlowable
during sequential time windows of a specified duration, where the duration is governed by a specifiedScheduler
.Flowable.throttleLast
(long intervalDuration, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, @NonNull Consumer<? super @NonNull T> onDropped) Returns aFlowable
that emits only the last item emitted by the currentFlowable
during sequential time windows of a specified duration, where the duration is governed by a specifiedScheduler
.final @NonNull Observable
<T> Observable.throttleLast
(long intervalDuration, @NonNull TimeUnit unit) Returns anObservable
that emits only the last item emitted by the currentObservable
during sequential time windows of a specified duration.final @NonNull Observable
<T> Observable.throttleLast
(long intervalDuration, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Returns anObservable
that emits only the last item emitted by the currentObservable
during sequential time windows of a specified duration, where the duration is governed by a specifiedScheduler
.final @NonNull Observable
<T> Observable.throttleLast
(long intervalDuration, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, @NonNull Consumer<? super @NonNull T> onDropped) Returns anObservable
that emits only the last item emitted by the currentObservable
during sequential time windows of a specified duration, where the duration is governed by a specifiedScheduler
.Flowable.throttleLatest
(long timeout, @NonNull TimeUnit unit) Throttles items from the upstreamFlowable
by first emitting the next item from upstream, then periodically emitting the latest item (if any) when the specified timeout elapses between them.Flowable.throttleLatest
(long timeout, @NonNull TimeUnit unit, boolean emitLast) Throttles items from the upstreamFlowable
by first emitting the next item from upstream, then periodically emitting the latest item (if any) when the specified timeout elapses between them.Flowable.throttleLatest
(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Throttles items from the upstreamFlowable
by first emitting the next item from upstream, then periodically emitting the latest item (if any) when the specified timeout elapses between them.Flowable.throttleLatest
(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean emitLast) Throttles items from the upstreamFlowable
by first emitting the next item from upstream, then periodically emitting the latest item (if any) when the specified timeout elapses between them.Flowable.throttleLatest
(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean emitLast, @NonNull Consumer<? super @NonNull T> onDropped) Throttles items from the upstreamFlowable
by first emitting the next item from upstream, then periodically emitting the latest item (if any) when the specified timeout elapses between them, invoking the consumer for any dropped item.final @NonNull Observable
<T> Observable.throttleLatest
(long timeout, @NonNull TimeUnit unit) Throttles items from the currentObservable
by first emitting the next item from upstream, then periodically emitting the latest item (if any) when the specified timeout elapses between them.final @NonNull Observable
<T> Observable.throttleLatest
(long timeout, @NonNull TimeUnit unit, boolean emitLast) Throttles items from the currentObservable
by first emitting the next item from upstream, then periodically emitting the latest item (if any) when the specified timeout elapses between them.final @NonNull Observable
<T> Observable.throttleLatest
(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Throttles items from the currentObservable
by first emitting the next item from upstream, then periodically emitting the latest item (if any) when the specified timeout elapses between them.final @NonNull Observable
<T> Observable.throttleLatest
(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean emitLast) Throttles items from the currentObservable
by first emitting the next item from upstream, then periodically emitting the latest item (if any) when the specified timeout elapses between them.final @NonNull Observable
<T> Observable.throttleLatest
(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean emitLast, @NonNull Consumer<? super @NonNull T> onDropped) Throttles items from the currentObservable
by first emitting the next item from upstream, then periodically emitting the latest item (if any) when the specified timeout elapses between them, invoking the consumer for any dropped item.Flowable.throttleWithTimeout
(long timeout, @NonNull TimeUnit unit) Returns aFlowable
that mirrors the currentFlowable
, except that it drops items emitted by the currentFlowable
that are followed by newer items before a timeout value expires.Flowable.throttleWithTimeout
(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Returns aFlowable
that mirrors the currentFlowable
, except that it drops items emitted by the currentFlowable
that are followed by newer items before a timeout value expires on a specifiedScheduler
.Flowable.throttleWithTimeout
(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, @NonNull Consumer<? super @NonNull T> onDropped) Returns aFlowable
that mirrors the currentFlowable
, except that it drops items emitted by the currentFlowable
that are followed by newer items before a timeout value expires on a specifiedScheduler
.final @NonNull Observable
<T> Observable.throttleWithTimeout
(long timeout, @NonNull TimeUnit unit) Returns anObservable
that mirrors the currentObservable
, except that it drops items emitted by the currentObservable
that are followed by newer items before a timeout value expires.final @NonNull Observable
<T> Observable.throttleWithTimeout
(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Returns anObservable
that mirrors the currentObservable
, except that it drops items emitted by the currentObservable
that are followed by newer items before a timeout value expires on a specifiedScheduler
.final @NonNull Observable
<T> Observable.throttleWithTimeout
(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, @NonNull Consumer<? super @NonNull T> onDropped) Returns anObservable
that mirrors the currentObservable
, except that it drops items emitted by the currentObservable
that are followed by newer items before a timeout value expires on a specifiedScheduler
.Flowable.timeInterval()
Returns aFlowable
that emits records of the time interval between consecutive items emitted by the currentFlowable
.Flowable.timeInterval
(@NonNull Scheduler scheduler) Returns aFlowable
that emits records of the time interval between consecutive items emitted by the currentFlowable
, where this interval is computed on a specifiedScheduler
.Flowable.timeInterval
(@NonNull TimeUnit unit) Returns aFlowable
that emits records of the time interval between consecutive items emitted by the currentFlowable
.Flowable.timeInterval
(@NonNull TimeUnit unit, @NonNull Scheduler scheduler) Returns aFlowable
that emits records of the time interval between consecutive items emitted by the currentFlowable
, where this interval is computed on a specifiedScheduler
.Maybe.timeInterval()
Measures the time (in milliseconds) between the subscription and success item emission of the currentMaybe
and signals it as a tuple (Timed
) success value.Maybe.timeInterval
(@NonNull Scheduler scheduler) Measures the time (in milliseconds) between the subscription and success item emission of the currentMaybe
and signals it as a tuple (Timed
) success value.Maybe.timeInterval
(@NonNull TimeUnit unit) Measures the time between the subscription and success item emission of the currentMaybe
and signals it as a tuple (Timed
) success value.Maybe.timeInterval
(@NonNull TimeUnit unit, @NonNull Scheduler scheduler) Measures the time between the subscription and success item emission of the currentMaybe
and signals it as a tuple (Timed
) success value.final @NonNull Observable
<Timed<T>> Observable.timeInterval()
Returns anObservable
that emits records of the time interval between consecutive items emitted by the currentObservable
.final @NonNull Observable
<Timed<T>> Observable.timeInterval
(@NonNull Scheduler scheduler) Returns anObservable
that emits records of the time interval between consecutive items emitted by the currentObservable
, where this interval is computed on a specifiedScheduler
.final @NonNull Observable
<Timed<T>> Observable.timeInterval
(@NonNull TimeUnit unit) Returns anObservable
that emits records of the time interval between consecutive items emitted by the currentObservable
.final @NonNull Observable
<Timed<T>> Observable.timeInterval
(@NonNull TimeUnit unit, @NonNull Scheduler scheduler) Returns anObservable
that emits records of the time interval between consecutive items emitted by the currentObservable
, where this interval is computed on a specifiedScheduler
.Single.timeInterval()
Measures the time (in milliseconds) between the subscription and success item emission of the currentSingle
and signals it as a tuple (Timed
) success value.Single.timeInterval
(@NonNull Scheduler scheduler) Measures the time (in milliseconds) between the subscription and success item emission of the currentSingle
and signals it as a tuple (Timed
) success value.Single.timeInterval
(@NonNull TimeUnit unit) Measures the time between the subscription and success item emission of the currentSingle
and signals it as a tuple (Timed
) success value.Single.timeInterval
(@NonNull TimeUnit unit, @NonNull Scheduler scheduler) Measures the time between the subscription and success item emission of the currentSingle
and signals it as a tuple (Timed
) success value.final @NonNull Completable
Returns aCompletabl
e that runs thisCompletable
and emits aTimeoutException
in case thisCompletable
doesn't complete within the given time.final @NonNull Completable
Completable.timeout
(long timeout, @NonNull TimeUnit unit, @NonNull CompletableSource fallback) Returns aCompletable
that runs thisCompletable
and switches to the otherCompletableSource
in case thisCompletable
doesn't complete within the given time.final @NonNull Completable
Returns aCompletable
that runs thisCompletable
and emits aTimeoutException
in case thisCompletable
doesn't complete within the given time while "waiting" on the specifiedScheduler
.final @NonNull Completable
Completable.timeout
(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, @NonNull CompletableSource fallback) Returns aCompletable
that runs thisCompletable
and switches to the otherCompletableSource
in case thisCompletable
doesn't complete within the given time while "waiting" on the specifiedScheduler
.Returns aFlowable
that mirrors the currentFlowable
but applies a timeout policy for each emitted item.Returns aFlowable
that mirrors the currentFlowable
but applies a timeout policy for each emitted item, where this policy is governed by a specifiedScheduler
.Flowable.timeout
(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> fallback) Returns aFlowable
that mirrors the currentFlowable
but applies a timeout policy for each emitted item using a specifiedScheduler
.Flowable.timeout
(long timeout, @NonNull TimeUnit unit, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> fallback) Returns aFlowable
that mirrors the currentFlowable
but applies a timeout policy for each emitted item.Flowable.timeout
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<@NonNull V>> itemTimeoutIndicator) Returns aFlowable
that mirrors the currentFlowable
, but notifiesSubscriber
s of aTimeoutException
if an item emitted by the currentFlowable
doesn't arrive within a window of time after the emission of the previous item, where that period of time is measured by aPublisher
that is a function of the previous item.Flowable.timeout
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<@NonNull V>> itemTimeoutIndicator, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> fallback) Returns aFlowable
that mirrors the currentFlowable
, but that switches to a fallbackPublisher
if an item emitted by the currentFlowable
doesn't arrive within a window of time after the emission of the previous item, where that period of time is measured by aPublisher
that is a function of the previous item.Flowable.timeout
(@NonNull org.reactivestreams.Publisher<@NonNull U> firstTimeoutIndicator, @NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<@NonNull V>> itemTimeoutIndicator) Returns aFlowable
that mirrors the currentFlowable
, but notifiesSubscriber
s of aTimeoutException
if either the first item emitted by the currentFlowable
or any subsequent item doesn't arrive within time windows defined by otherPublisher
s.Flowable.timeout
(@NonNull org.reactivestreams.Publisher<@NonNull U> firstTimeoutIndicator, @NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<@NonNull V>> itemTimeoutIndicator, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> fallback) Returns aFlowable
that mirrors the currentFlowable
, but switches to a fallbackPublisher
if either the first item emitted by the currentFlowable
or any subsequent item doesn't arrive within time windows defined by otherPublisher
s.Returns aMaybe
that mirrors the currentMaybe
but applies a timeout policy for each emitted item.Maybe.timeout
(long timeout, @NonNull TimeUnit unit, @NonNull MaybeSource<? extends @NonNull T> fallback) Returns aMaybe
that mirrors the currentMaybe
but applies a timeout policy for each emitted item.Returns aMaybe
that mirrors the currentMaybe
but applies a timeout policy for each emitted item, where this policy is governed on a specifiedScheduler
.Maybe.timeout
(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, @NonNull MaybeSource<? extends @NonNull T> fallback) Returns aMaybe
that mirrors the currentMaybe
but applies a timeout policy for each emitted item using a specifiedScheduler
.Maybe.timeout
(@NonNull MaybeSource<@NonNull U> timeoutIndicator) If the currentMaybe
didn't signal an event before thetimeoutIndicator
MaybeSource
signals, aTimeoutException
is signaled instead.Maybe.timeout
(@NonNull MaybeSource<@NonNull U> timeoutIndicator, @NonNull MaybeSource<? extends @NonNull T> fallback) If the currentMaybe
didn't signal an event before thetimeoutIndicator
MaybeSource
signals, the currentMaybe
is disposed and thefallback
MaybeSource
subscribed to as a continuation.If the currentMaybe
source didn't signal an event before thetimeoutIndicator
Publisher
signals, aTimeoutException
is signaled instead.Maybe.timeout
(@NonNull org.reactivestreams.Publisher<@NonNull U> timeoutIndicator, @NonNull MaybeSource<? extends @NonNull T> fallback) If the currentMaybe
didn't signal an event before thetimeoutIndicator
Publisher
signals, the currentMaybe
is disposed and thefallback
MaybeSource
subscribed to as a continuation.final @NonNull Observable
<T> Returns anObservable
that mirrors the currentObservable
but applies a timeout policy for each emitted item.final @NonNull Observable
<T> Observable.timeout
(long timeout, @NonNull TimeUnit unit, @NonNull ObservableSource<? extends @NonNull T> fallback) Returns anObservable
that mirrors the currentObservable
but applies a timeout policy for each emitted item.final @NonNull Observable
<T> Returns anObservable
that mirrors the currentObservable
but applies a timeout policy for each emitted item, where this policy is governed on a specifiedScheduler
.final @NonNull Observable
<T> Observable.timeout
(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, @NonNull ObservableSource<? extends @NonNull T> fallback) Returns anObservable
that mirrors the currentObservable
but applies a timeout policy for each emitted item using a specifiedScheduler
.final <@NonNull U,
@NonNull V>
@NonNull Observable<T> Observable.timeout
(@NonNull ObservableSource<@NonNull U> firstTimeoutIndicator, @NonNull Function<? super @NonNull T, ? extends ObservableSource<@NonNull V>> itemTimeoutIndicator) Returns anObservable
that mirrors the currentObservable
, but notifies observers of aTimeoutException
if either the first item emitted by the currentObservable
or any subsequent item doesn't arrive within time windows defined by indicatorObservableSource
s.final <@NonNull U,
@NonNull V>
@NonNull Observable<T> Observable.timeout
(@NonNull ObservableSource<@NonNull U> firstTimeoutIndicator, @NonNull Function<? super @NonNull T, ? extends ObservableSource<@NonNull V>> itemTimeoutIndicator, @NonNull ObservableSource<? extends @NonNull T> fallback) Returns anObservable
that mirrors the currentObservable
, but switches to a fallbackObservableSource
if either the first item emitted by the currentObservable
or any subsequent item doesn't arrive within time windows defined by indicatorObservableSource
s.final <@NonNull V>
@NonNull Observable<T> Observable.timeout
(@NonNull Function<? super @NonNull T, ? extends ObservableSource<@NonNull V>> itemTimeoutIndicator) Returns anObservable
that mirrors the currentObservable
, but notifies observers of aTimeoutException
if an item emitted by the currentObservable
doesn't arrive within a window of time after the emission of the previous item, where that period of time is measured by anObservableSource
that is a function of the previous item.final <@NonNull V>
@NonNull Observable<T> Observable.timeout
(@NonNull Function<? super @NonNull T, ? extends ObservableSource<@NonNull V>> itemTimeoutIndicator, @NonNull ObservableSource<? extends @NonNull T> fallback) Returns anObservable
that mirrors the currentObservable
, but that switches to a fallbackObservableSource
if an item emitted by the currentObservable
doesn't arrive within a window of time after the emission of the previous item, where that period of time is measured by anObservableSource
that is a function of the previous item.Signals aTimeoutException
if the currentSingle
doesn't signal a success value within the specified timeout window.Signals aTimeoutException
if the currentSingle
doesn't signal a success value within the specified timeout window.Single.timeout
(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, @NonNull SingleSource<? extends @NonNull T> fallback) Runs the currentSingle
and if it doesn't signal within the specified timeout window, it is disposed and the otherSingleSource
subscribed to.Single.timeout
(long timeout, @NonNull TimeUnit unit, @NonNull SingleSource<? extends @NonNull T> fallback) Runs the currentSingle
and if it doesn't signal within the specified timeout window, it is disposed and the otherSingleSource
subscribed to.private @NonNull Completable
Completable.timeout0
(long timeout, TimeUnit unit, Scheduler scheduler, CompletableSource fallback) Returns aCompletable
that runs thisCompletable
and optionally switches to the otherCompletableSource
in case thisCompletable
doesn't complete within the given time while "waiting" on the specifiedScheduler
.private @NonNull Observable
<T> Observable.timeout0
(long timeout, @NonNull TimeUnit unit, @Nullable ObservableSource<? extends @NonNull T> fallback, @NonNull Scheduler scheduler) private <U,
V> @NonNull Observable <T> Observable.timeout0
(@NonNull ObservableSource<U> firstTimeoutIndicator, @NonNull Function<? super @NonNull T, ? extends ObservableSource<V>> itemTimeoutIndicator, @Nullable ObservableSource<? extends @NonNull T> fallback) static @NonNull Completable
Returns aCompletable
instance that fires itsonComplete
event after the given delay elapsed.static @NonNull Completable
Returns aCompletable
instance that fires itsonComplete
event after the given delay elapsed by using the suppliedScheduler
.Returns aFlowable
that emits0L
after a specified delay, and then completes.Returns aFlowable
that emits0L
after a specified delay, on a specifiedScheduler
, and then completes.Returns aMaybe
that emits0L
after a specified delay.static @NonNull Observable
<Long> Returns anObservable
that emits0L
after a specified delay, and then completes.static @NonNull Observable
<Long> Returns anObservable
that emits0L
after a specified delay, on a specifiedScheduler
, and then completes.Signals success with 0L value after the given delay when aSingleObserver
subscribes.Signals success with 0L value on the specifiedScheduler
after the given delay when aSingleObserver
subscribes.Flowable.timestamp()
Maybe.timestamp()
final @NonNull Observable
<Timed<T>> Observable.timestamp()
Returns anObservable
that emits each item emitted by the currentObservable
, wrapped in aTimed
object.final @NonNull Observable
<Timed<T>> final @NonNull Observable
<Timed<T>> Returns anObservable
that emits each item emitted by the currentObservable
, wrapped in aTimed
object.final @NonNull Observable
<Timed<T>> Single.timestamp()
final <@NonNull R>
RCalls the specified converter function during assembly time and returns its resulting value.final <@Nullable T>
@NonNull CompletionStage<T> Completable.toCompletionStage
(@Nullable T defaultItem) Signals the given default item when the upstream completes or signals the upstream error via aCompletionStage
.final @NonNull CompletionStage
<T> Maybe.toCompletionStage()
Signals the upstream success item (or aNoSuchElementException
if the upstream is empty) via aCompletionStage
.final @NonNull CompletionStage
<T> Maybe.toCompletionStage
(@NonNull T defaultItem) Signals the upstream success item (or the default item if the upstream is empty) via aCompletionStage
.final @NonNull CompletionStage
<T> Single.toCompletionStage()
Signals the upstream success item (or error) via aCompletionStage
.Completable.toFlowable()
Returns aFlowable
which when subscribed to subscribes to thisCompletable
and relays the terminal events to the downstreamSubscriber
.Maybe.toFlowable()
Converts thisMaybe
into a backpressure-awareFlowable
instance composing cancellation through.Observable.toFlowable
(@NonNull BackpressureStrategy strategy) Converts the currentObservable
into aFlowable
by applying the specified backpressure strategy.Single.toFlowable()
Converts thisSingle
into aFlowable
.Completable.toFuture()
Flowable.toFuture()
Returns aFuture
representing the only value emitted by thisFlowable
.Maybe.toFuture()
Returns aFuture
representing the single value emitted by the currentMaybe
ornull
if the currentMaybe
is empty.Observable.toFuture()
Returns aFuture
representing the only value emitted by the currentObservable
.Single.toFuture()
Returns aFuture
representing the single value emitted by thisSingle
.Flowable.toList()
Returns aSingle
that emits a single item, a list composed of all the items emitted by the finite upstream sourcePublisher
.Flowable.toList
(int capacityHint) Returns aSingle
that emits a single item, a list composed of all the items emitted by the finite sourcePublisher
.Returns aSingle
that emits a single item, a list composed of all the items emitted by the finite sourcePublisher
.Observable.toList()
Observable.toList
(int capacityHint) Returns aSingle
that emits a single item, aCollection
(subclass) composed of all the items emitted by the finite upstreamObservable
.Flowable.toMap
(@NonNull Function<? super @NonNull T, ? extends @NonNull K> keySelector, @NonNull Function<? super @NonNull T, ? extends @NonNull V> valueSelector) Flowable.toMap
(@NonNull Function<? super @NonNull T, ? extends @NonNull K> keySelector, @NonNull Function<? super @NonNull T, ? extends @NonNull V> valueSelector, @NonNull Supplier<? extends Map<@NonNull K, @NonNull V>> mapSupplier) Observable.toMap
(@NonNull Function<? super @NonNull T, ? extends @NonNull K> keySelector, @NonNull Function<? super @NonNull T, ? extends @NonNull V> valueSelector) Observable.toMap
(@NonNull Function<? super @NonNull T, ? extends @NonNull K> keySelector, @NonNull Function<? super @NonNull T, ? extends @NonNull V> valueSelector, @NonNull Supplier<? extends Map<@NonNull K, @NonNull V>> mapSupplier) Completable.toMaybe()
Converts thisCompletable
into aMaybe
.Single.toMaybe()
Converts thisSingle
into aMaybe
.Flowable.toMultimap
(@NonNull Function<? super @NonNull T, ? extends @NonNull K> keySelector, @NonNull Function<? super @NonNull T, ? extends @NonNull V> valueSelector) Flowable.toMultimap
(@NonNull Function<? super @NonNull T, ? extends @NonNull K> keySelector, @NonNull Function<? super @NonNull T, ? extends @NonNull V> valueSelector, @NonNull Supplier<? extends Map<@NonNull K, Collection<@NonNull V>>> mapSupplier, @NonNull Function<? super @NonNull K, ? extends Collection<? super @NonNull V>> collectionFactory) Flowable.toMultimap
(@NonNull Function<? super @NonNull T, ? extends @NonNull K> keySelector, @NonNull Function<? super @NonNull T, ? extends @NonNull V> valueSelector, @NonNull Supplier<Map<@NonNull K, Collection<@NonNull V>>> mapSupplier) Observable.toMultimap
(@NonNull Function<? super @NonNull T, ? extends @NonNull K> keySelector, @NonNull Function<? super @NonNull T, ? extends @NonNull V> valueSelector, @NonNull Supplier<? extends Map<@NonNull K, Collection<@NonNull V>>> mapSupplier, @NonNull Function<? super @NonNull K, ? extends Collection<? super @NonNull V>> collectionFactory) Returns aSingle
that emits a singleMap
(subclass), returned by a specifiedmapFactory
function, that contains a customCollection
of values, extracted by a specifiedvalueSelector
function from items emitted by the current and finiteObservable
, and keyed by thekeySelector
function.Observable.toMultimap
(@NonNull Function<? super @NonNull T, ? extends @NonNull K> keySelector, @NonNull Function<? super @NonNull T, ? extends @NonNull V> valueSelector, @NonNull Supplier<Map<@NonNull K, Collection<@NonNull V>>> mapSupplier) Observable.toMultimap
(@NonNull Function<? super @NonNull T, ? extends @NonNull K> keySelector, Function<? super @NonNull T, ? extends @NonNull V> valueSelector) final <@NonNull T>
@NonNull Observable<T> Completable.toObservable()
Returns anObservable
which when subscribed to subscribes to thisCompletable
and relays the terminal events to the downstreamObserver
.final @NonNull Observable
<T> Flowable.toObservable()
Converts the currentFlowable
into a non-backpressuredObservable
.final @NonNull Observable
<T> Maybe.toObservable()
Converts thisMaybe
into anObservable
instance composing disposal through.final @NonNull Observable
<T> Single.toObservable()
Converts thisSingle
into anObservable
.Maybe.toSingle()
Converts thisMaybe
into aSingle
instance composing disposal through and turning an emptyMaybe
into a signal ofNoSuchElementException
.Completable.toSingleDefault
(@NonNull T completionValue) Converts thisCompletable
into aSingle
which when thisCompletable
completes normally, emits the given value throughonSuccess
.Flowable.toSortedList()
Flowable.toSortedList
(int capacityHint) Flowable.toSortedList
(@NonNull Comparator<? super @NonNull T> comparator) Flowable.toSortedList
(@NonNull Comparator<? super @NonNull T> comparator, int capacityHint) Observable.toSortedList()
Observable.toSortedList
(int capacityHint) Observable.toSortedList
(@NonNull Comparator<? super @NonNull T> comparator) Observable.toSortedList
(@NonNull Comparator<? super @NonNull T> comparator, int capacityHint) static @NonNull Completable
Completable.unsafeCreate
(@NonNull CompletableSource onSubscribe) Constructs aCompletable
instance by wrapping the given source callback without any safeguards; you should manage the lifecycle and response to downstream disposal.Flowable.unsafeCreate
(@NonNull org.reactivestreams.Publisher<@NonNull T> onSubscribe) Create aFlowable
by wrapping aPublisher
which has to be implemented according to the Reactive Streams specification by handling backpressure and cancellation correctly; no safeguards are provided by theFlowable
itself.Maybe.unsafeCreate
(@NonNull MaybeSource<@NonNull T> onSubscribe) Advanced use only: creates aMaybe
instance without any safeguards by using a callback that is called with aMaybeObserver
.static <@NonNull T>
@NonNull Observable<T> Observable.unsafeCreate
(@NonNull ObservableSource<@NonNull T> onSubscribe) Create anObservable
by wrapping anObservableSource
which has to be implemented according to theObservable
specification derived from the Reactive Streams specification by handling disposal correctly; no safeguards are provided by theObservable
itself.Single.unsafeCreate
(@NonNull SingleSource<@NonNull T> onSubscribe) Advanced use only: creates aSingle
instance without any safeguards by using a callback that is called with aSingleObserver
.final @NonNull Completable
Completable.unsubscribeOn
(@NonNull Scheduler scheduler) Returns aCompletable
which makes sure when an observer disposes the subscription, thedispose()
method is called on the specifiedScheduler
.Flowable.unsubscribeOn
(@NonNull Scheduler scheduler) Cancels the currentFlowable
asynchronously by invokingSubscription.cancel()
on the specifiedScheduler
.Maybe.unsubscribeOn
(@NonNull Scheduler scheduler) Returns aMaybe
which makes sure when aMaybeObserver
disposes theDisposable
, that call is propagated up on the specifiedScheduler
.final @NonNull Observable
<T> Observable.unsubscribeOn
(@NonNull Scheduler scheduler) Single.unsubscribeOn
(@NonNull Scheduler scheduler) Returns aSingle
which makes sure when aSingleObserver
disposes theDisposable
, that call is propagated up on the specifiedScheduler
.static <@NonNull R>
@NonNull CompletableCompletable.using
(@NonNull Supplier<@NonNull R> resourceSupplier, @NonNull Function<? super @NonNull R, ? extends CompletableSource> sourceSupplier, @NonNull Consumer<? super @NonNull R> resourceCleanup) Returns aCompletable
instance which manages a resource along with a customCompletableSource
instance while the subscription is active.static <@NonNull R>
@NonNull CompletableCompletable.using
(@NonNull Supplier<@NonNull R> resourceSupplier, @NonNull Function<? super @NonNull R, ? extends CompletableSource> sourceSupplier, @NonNull Consumer<? super @NonNull R> resourceCleanup, boolean eager) Returns aCompletable
instance which manages a resource along with a customCompletableSource
instance while the subscription is active and performs eager or lazy resource disposition.Flowable.using
(@NonNull Supplier<? extends @NonNull D> resourceSupplier, @NonNull Function<? super @NonNull D, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sourceSupplier, @NonNull Consumer<? super @NonNull D> resourceCleanup) Constructs aFlowable
that creates a dependent resource object, aPublisher
with that resource and calls the providedresourceDisposer
function if this inner source terminates or the downstream cancels the flow.Flowable.using
(@NonNull Supplier<? extends @NonNull D> resourceSupplier, @NonNull Function<? super @NonNull D, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sourceSupplier, @NonNull Consumer<? super @NonNull D> resourceCleanup, boolean eager) Constructs aFlowable
that creates a dependent resource object, aPublisher
with that resource and calls the providedresourceDisposer
function if this inner source terminates or the downstream disposes the flow; doing it before these end-states have been reached ifeager == true
, after otherwise.Maybe.using
(@NonNull Supplier<? extends @NonNull D> resourceSupplier, @NonNull Function<? super @NonNull D, ? extends MaybeSource<? extends @NonNull T>> sourceSupplier, @NonNull Consumer<? super @NonNull D> resourceCleanup) Constructs aMaybe
that creates a dependent resource object which is disposed of when the generatedMaybeSource
terminates or the downstream calls dispose().Maybe.using
(@NonNull Supplier<? extends @NonNull D> resourceSupplier, @NonNull Function<? super @NonNull D, ? extends MaybeSource<? extends @NonNull T>> sourceSupplier, @NonNull Consumer<? super @NonNull D> resourceCleanup, boolean eager) Constructs aMaybe
that creates a dependent resource object which is disposed first ({code eager == true}) when the generatedMaybeSource
terminates or the downstream disposes; or after ({code eager == false}).static <@NonNull T,
@NonNull D>
@NonNull Observable<T> Observable.using
(@NonNull Supplier<? extends @NonNull D> resourceSupplier, @NonNull Function<? super @NonNull D, ? extends ObservableSource<? extends @NonNull T>> sourceSupplier, @NonNull Consumer<? super @NonNull D> resourceCleanup) Constructs anObservable
that creates a dependent resource object, anObservableSource
with that resource and calls the providedresourceDisposer
function if this inner source terminates or the downstream disposes the flow.static <@NonNull T,
@NonNull D>
@NonNull Observable<T> Observable.using
(@NonNull Supplier<? extends @NonNull D> resourceSupplier, @NonNull Function<? super @NonNull D, ? extends ObservableSource<? extends @NonNull T>> sourceSupplier, @NonNull Consumer<? super @NonNull D> resourceCleanup, boolean eager) Constructs anObservable
that creates a dependent resource object, anObservableSource
with that resource and calls the provideddisposer
function if this inner source terminates or the downstream disposes the flow; doing it before these end-states have been reached ifeager == true
, after otherwise.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 aSingleSource
instance generated from that resource (similar to a try-with-resources).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 aSingleSource
instance generated from that resource (similar to a try-with-resources).<S extends Scheduler & Disposable>
SScheduler.when
(@NonNull Function<Flowable<Flowable<Completable>>, Completable> combine) Allows the use of operators for controlling the timing around when actions scheduled on workers are actually done.Flowable.window
(long count) Returns aFlowable
that emits windows of items it collects from the currentFlowable
.Flowable.window
(long count, long skip) Returns aFlowable
that emits windows of items it collects from the currentFlowable
.Flowable.window
(long count, long skip, int bufferSize) Returns aFlowable
that emits windows of items it collects from the currentFlowable
.Returns aFlowable
that emits windows of items it collects from the currentFlowable
.Returns aFlowable
that emits windows of items it collects from the currentFlowable
.Flowable.window
(long timespan, long timeskip, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, int bufferSize) Returns aFlowable
that emits windows of items it collects from the currentFlowable
.Returns aFlowable
that emits windows of items it collects from the currentFlowable
.Returns aFlowable
that emits windows of items it collects from the currentFlowable
.Returns aFlowable
that emits windows of items it collects from the currentFlowable
.Returns aFlowable
that emits windows of items it collects from the currentFlowable
.Returns aFlowable
that emits windows of items it collects from the currentFlowable
.Flowable.window
(long timespan, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, long count, boolean restart) Returns aFlowable
that emits windows of items it collects from the currentFlowable
.Flowable.window
(long timespan, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, long count, boolean restart, int bufferSize) Returns aFlowable
that emits windows of items it collects from the currentFlowable
.Returns aFlowable
that emits non-overlapping windows of items it collects from the currentFlowable
where the boundary of each window is determined by the items emitted from a specified boundary-governingPublisher
.Flowable.window
(@NonNull org.reactivestreams.Publisher<@NonNull B> boundaryIndicator, int bufferSize) Returns aFlowable
that emits non-overlapping windows of items it collects from the currentFlowable
where the boundary of each window is determined by the items emitted from a specified boundary-governingPublisher
.Flowable.window
(@NonNull org.reactivestreams.Publisher<@NonNull U> openingIndicator, @NonNull Function<? super @NonNull U, @NonNull ? extends org.reactivestreams.Publisher<@NonNull V>> closingIndicator) Returns aFlowable
that emits windows of items it collects from the currentFlowable
.Flowable.window
(@NonNull org.reactivestreams.Publisher<@NonNull U> openingIndicator, @NonNull Function<? super @NonNull U, @NonNull ? extends org.reactivestreams.Publisher<@NonNull V>> closingIndicator, int bufferSize) Returns aFlowable
that emits windows of items it collects from the currentFlowable
.final @NonNull Observable
<Observable<T>> Observable.window
(long count) Returns anObservable
that emits windows of items it collects from the currentObservable
.final @NonNull Observable
<Observable<T>> Observable.window
(long count, long skip) Returns anObservable
that emits windows of items it collects from the currentObservable
.final @NonNull Observable
<Observable<T>> Observable.window
(long count, long skip, int bufferSize) Returns anObservable
that emits windows of items it collects from the currentObservable
.final @NonNull Observable
<Observable<T>> Returns anObservable
that emits windows of items it collects from the currentObservable
.final @NonNull Observable
<Observable<T>> Observable.window
(long timespan, long timeskip, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Returns anObservable
that emits windows of items it collects from the currentObservable
.final @NonNull Observable
<Observable<T>> Observable.window
(long timespan, long timeskip, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, int bufferSize) Returns anObservable
that emits windows of items it collects from the currentObservable
.final @NonNull Observable
<Observable<T>> Returns anObservable
that emits windows of items it collects from the currentObservable
.final @NonNull Observable
<Observable<T>> Returns anObservable
that emits windows of items it collects from the currentObservable
.final @NonNull Observable
<Observable<T>> Returns anObservable
that emits windows of items it collects from the currentObservable
.final @NonNull Observable
<Observable<T>> Returns anObservable
that emits windows of items it collects from the currentObservable
.final @NonNull Observable
<Observable<T>> Returns anObservable
that emits windows of items it collects from the currentObservable
.final @NonNull Observable
<Observable<T>> Observable.window
(long timespan, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, long count, boolean restart) Returns anObservable
that emits windows of items it collects from the currentObservable
.final @NonNull Observable
<Observable<T>> Observable.window
(long timespan, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, long count, boolean restart, int bufferSize) Returns anObservable
that emits windows of items it collects from the currentObservable
.final <@NonNull B>
@NonNull Observable<Observable<T>> Observable.window
(@NonNull ObservableSource<@NonNull B> boundaryIndicator) Returns anObservable
that emits non-overlapping windows of items it collects from the currentObservable
where the boundary of each window is determined by the items emitted from a specified boundary-governingObservableSource
.final <@NonNull B>
@NonNull Observable<Observable<T>> Observable.window
(@NonNull ObservableSource<@NonNull B> boundaryIndicator, int bufferSize) Returns anObservable
that emits non-overlapping windows of items it collects from the currentObservable
where the boundary of each window is determined by the items emitted from a specified boundary-governingObservableSource
.final <@NonNull U,
@NonNull V>
@NonNull Observable<Observable<T>> Observable.window
(@NonNull ObservableSource<@NonNull U> openingIndicator, @NonNull Function<? super @NonNull U, ? extends ObservableSource<@NonNull V>> closingIndicator) Returns anObservable
that emits windows of items it collects from the currentObservable
.final <@NonNull U,
@NonNull V>
@NonNull Observable<Observable<T>> Observable.window
(@NonNull ObservableSource<@NonNull U> openingIndicator, @NonNull Function<? super @NonNull U, ? extends ObservableSource<@NonNull V>> closingIndicator, int bufferSize) Returns anObservable
that emits windows of items it collects from the currentObservable
.Flowable.withLatestFrom
(@NonNull Iterable<@NonNull ? extends org.reactivestreams.Publisher<@NonNull ?>> others, @NonNull Function<? super Object[], @NonNull R> combiner) Combines the value emission from the currentFlowable
with the latest emissions from the otherPublisher
s via a function to produce the output item.Flowable.withLatestFrom
(@NonNull org.reactivestreams.Publisher<? extends @NonNull U> other, @NonNull BiFunction<? super @NonNull T, ? super @NonNull U, ? extends @NonNull R> combiner) Merges the specifiedPublisher
into the currentFlowable
sequence by using theresultSelector
function only when the currentFlowable
(this instance) emits an item.Flowable.withLatestFrom
(@NonNull org.reactivestreams.Publisher<@NonNull ?>[] others, @NonNull Function<? super Object[], @NonNull R> combiner) Combines the value emission from the currentFlowable
with the latest emissions from the otherPublisher
s via a function to produce the output item.Flowable.withLatestFrom
(@NonNull org.reactivestreams.Publisher<@NonNull T1> source1, @NonNull org.reactivestreams.Publisher<@NonNull T2> source2, @NonNull Function3<? super @NonNull T, ? super @NonNull T1, ? super @NonNull T2, @NonNull R> combiner) Combines the value emission from the currentFlowable
with the latest emissions from the otherPublisher
s via a function to produce the output item.Flowable.withLatestFrom
(@NonNull org.reactivestreams.Publisher<@NonNull T1> source1, @NonNull org.reactivestreams.Publisher<@NonNull T2> source2, @NonNull org.reactivestreams.Publisher<@NonNull T3> source3, @NonNull Function4<? super @NonNull T, ? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, @NonNull R> combiner) Combines the value emission from the currentFlowable
with the latest emissions from the otherPublisher
s via a function to produce the output item.Flowable.withLatestFrom
(@NonNull org.reactivestreams.Publisher<@NonNull T1> source1, @NonNull org.reactivestreams.Publisher<@NonNull T2> source2, @NonNull org.reactivestreams.Publisher<@NonNull T3> source3, @NonNull org.reactivestreams.Publisher<@NonNull T4> source4, @NonNull Function5<? super @NonNull T, ? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, ? super @NonNull T4, @NonNull R> combiner) Combines the value emission from the currentFlowable
with the latest emissions from the otherPublisher
s via a function to produce the output item.final <@NonNull R>
@NonNull Observable<R> Observable.withLatestFrom
(@NonNull ObservableSource<?>[] others, @NonNull Function<? super Object[], @NonNull R> combiner) Combines the value emission from the currentObservable
with the latest emissions from the otherObservableSource
s via a function to produce the output item.final <@NonNull U,
@NonNull R>
@NonNull Observable<R> Observable.withLatestFrom
(@NonNull ObservableSource<? extends @NonNull U> other, @NonNull BiFunction<? super @NonNull T, ? super @NonNull U, ? extends @NonNull R> combiner) Merges the specifiedObservableSource
into the currentObservable
sequence by using theresultSelector
function only when the currentObservable
emits an item.Observable.withLatestFrom
(@NonNull ObservableSource<@NonNull T1> source1, @NonNull ObservableSource<@NonNull T2> source2, @NonNull ObservableSource<@NonNull T3> source3, @NonNull ObservableSource<@NonNull T4> source4, @NonNull Function5<? super @NonNull T, ? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, ? super @NonNull T4, @NonNull R> combiner) Combines the value emission from the currentObservable
with the latest emissions from the otherObservableSource
s via a function to produce the output item.Observable.withLatestFrom
(@NonNull ObservableSource<@NonNull T1> source1, @NonNull ObservableSource<@NonNull T2> source2, @NonNull ObservableSource<@NonNull T3> source3, @NonNull Function4<? super @NonNull T, ? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, @NonNull R> combiner) Combines the value emission from the currentObservable
with the latest emissions from the otherObservableSource
s via a function to produce the output item.final <@NonNull T1,
@NonNull T2, @NonNull R>
@NonNull Observable<R> Observable.withLatestFrom
(@NonNull ObservableSource<@NonNull T1> source1, @NonNull ObservableSource<@NonNull T2> source2, @NonNull Function3<? super @NonNull T, ? super @NonNull T1, ? super @NonNull T2, @NonNull R> combiner) Combines the value emission from the currentObservable
with the latest emissions from the otherObservableSource
s via a function to produce the output item.final <@NonNull R>
@NonNull Observable<R> Observable.withLatestFrom
(@NonNull Iterable<@NonNull ? extends ObservableSource<?>> others, @NonNull Function<? super Object[], @NonNull R> combiner) Combines the value emission from the currentObservable
with the latest emissions from the otherObservableSource
s via a function to produce the output item.static @NonNull Completable
Completable.wrap
(@NonNull CompletableSource source) Maybe.wrap
(@NonNull MaybeSource<@NonNull T> source) static <@NonNull T>
@NonNull Observable<T> Observable.wrap
(@NonNull ObservableSource<@NonNull T> source) Single.wrap
(@NonNull SingleSource<@NonNull T> source) Flowable.zip
(@NonNull Iterable<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources, @NonNull Function<? super Object[], ? extends @NonNull R> zipper) Returns aFlowable
that emits the results of a specified combiner function applied to combinations of items emitted, in sequence, by anIterable
of otherPublisher
s.Flowable.zip
(@NonNull Iterable<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources, @NonNull Function<? super Object[], ? extends @NonNull R> zipper, boolean delayError, int bufferSize) Returns aFlowable
that emits the results of a specified combiner function applied to combinations of items emitted, in sequence, by anIterable
of otherPublisher
s.Flowable.zip
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull BiFunction<? super @NonNull T1, ? super @NonNull T2, ? extends @NonNull R> zipper) Returns aFlowable
that emits the results of a specified combiner function applied to combinations of two items emitted, in sequence, by two otherPublisher
s.Flowable.zip
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull BiFunction<? super @NonNull T1, ? super @NonNull T2, ? extends @NonNull R> zipper, boolean delayError) Returns aFlowable
that emits the results of a specified combiner function applied to combinations of two items emitted, in sequence, by two otherPublisher
s.Flowable.zip
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull BiFunction<? super @NonNull T1, ? super @NonNull T2, ? extends @NonNull R> zipper, boolean delayError, int bufferSize) Returns aFlowable
that emits the results of a specified combiner function applied to combinations of two items emitted, in sequence, by two otherPublisher
s.Flowable.zip
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull Function3<? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, ? extends @NonNull R> zipper) Returns aFlowable
that emits the results of a specified combiner function applied to combinations of three items emitted, in sequence, by three otherPublisher
s.Flowable.zip
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull Function4<? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, ? super @NonNull T4, ? extends @NonNull R> zipper) Returns aFlowable
that emits the results of a specified combiner function applied to combinations of four items emitted, in sequence, by four otherPublisher
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull R>
@NonNull Flowable<R> Flowable.zip
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull org.reactivestreams.Publisher<? 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 aFlowable
that emits the results of a specified combiner function applied to combinations of five items emitted, in sequence, by five otherPublisher
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull R>
@NonNull Flowable<R> Flowable.zip
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull org.reactivestreams.Publisher<? extends @NonNull T5> source5, @NonNull org.reactivestreams.Publisher<? 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 aFlowable
that emits the results of a specified combiner function applied to combinations of six items emitted, in sequence, by six otherPublisher
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull R>
@NonNull Flowable<R> Flowable.zip
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull org.reactivestreams.Publisher<? extends @NonNull T5> source5, @NonNull org.reactivestreams.Publisher<? extends @NonNull T6> source6, @NonNull org.reactivestreams.Publisher<? 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 aFlowable
that emits the results of a specified combiner function applied to combinations of seven items emitted, in sequence, by seven otherPublisher
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull R>
@NonNull Flowable<R> Flowable.zip
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull org.reactivestreams.Publisher<? extends @NonNull T5> source5, @NonNull org.reactivestreams.Publisher<? extends @NonNull T6> source6, @NonNull org.reactivestreams.Publisher<? extends @NonNull T7> source7, @NonNull org.reactivestreams.Publisher<? 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 aFlowable
that emits the results of a specified combiner function applied to combinations of eight items emitted, in sequence, by eight otherPublisher
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull T9, @NonNull R>
@NonNull Flowable<R> Flowable.zip
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull org.reactivestreams.Publisher<? extends @NonNull T5> source5, @NonNull org.reactivestreams.Publisher<? extends @NonNull T6> source6, @NonNull org.reactivestreams.Publisher<? extends @NonNull T7> source7, @NonNull org.reactivestreams.Publisher<? extends @NonNull T8> source8, @NonNull org.reactivestreams.Publisher<? 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 aFlowable
that emits the results of a specified combiner function applied to combinations of nine items emitted, in sequence, by nine otherPublisher
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull T9, @NonNull R>
@NonNull Maybe<R> Maybe.zip
(@NonNull MaybeSource<? extends @NonNull T1> source1, @NonNull MaybeSource<? extends @NonNull T2> source2, @NonNull MaybeSource<? extends @NonNull T3> source3, @NonNull MaybeSource<? extends @NonNull T4> source4, @NonNull MaybeSource<? extends @NonNull T5> source5, @NonNull MaybeSource<? extends @NonNull T6> source6, @NonNull MaybeSource<? extends @NonNull T7> source7, @NonNull MaybeSource<? extends @NonNull T8> source8, @NonNull MaybeSource<? 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 aMaybe
that emits the results of a specified combiner function applied to combinations of nine items emitted, in sequence, by nine otherMaybeSource
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull R>
@NonNull Maybe<R> Maybe.zip
(@NonNull MaybeSource<? extends @NonNull T1> source1, @NonNull MaybeSource<? extends @NonNull T2> source2, @NonNull MaybeSource<? extends @NonNull T3> source3, @NonNull MaybeSource<? extends @NonNull T4> source4, @NonNull MaybeSource<? extends @NonNull T5> source5, @NonNull MaybeSource<? extends @NonNull T6> source6, @NonNull MaybeSource<? extends @NonNull T7> source7, @NonNull MaybeSource<? 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 aMaybe
that emits the results of a specified combiner function applied to combinations of eight items emitted, in sequence, by eight otherMaybeSource
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull R>
@NonNull Maybe<R> Maybe.zip
(@NonNull MaybeSource<? extends @NonNull T1> source1, @NonNull MaybeSource<? extends @NonNull T2> source2, @NonNull MaybeSource<? extends @NonNull T3> source3, @NonNull MaybeSource<? extends @NonNull T4> source4, @NonNull MaybeSource<? extends @NonNull T5> source5, @NonNull MaybeSource<? extends @NonNull T6> source6, @NonNull MaybeSource<? 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 aMaybe
that emits the results of a specified combiner function applied to combinations of seven items emitted, in sequence, by seven otherMaybeSource
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull R>
@NonNull Maybe<R> Maybe.zip
(@NonNull MaybeSource<? extends @NonNull T1> source1, @NonNull MaybeSource<? extends @NonNull T2> source2, @NonNull MaybeSource<? extends @NonNull T3> source3, @NonNull MaybeSource<? extends @NonNull T4> source4, @NonNull MaybeSource<? extends @NonNull T5> source5, @NonNull MaybeSource<? 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 aMaybe
that emits the results of a specified combiner function applied to combinations of six items emitted, in sequence, by six otherMaybeSource
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull R>
@NonNull Maybe<R> Maybe.zip
(@NonNull MaybeSource<? extends @NonNull T1> source1, @NonNull MaybeSource<? extends @NonNull T2> source2, @NonNull MaybeSource<? extends @NonNull T3> source3, @NonNull MaybeSource<? extends @NonNull T4> source4, @NonNull MaybeSource<? 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 aMaybe
that emits the results of a specified combiner function applied to combinations of five items emitted, in sequence, by five otherMaybeSource
s.Maybe.zip
(@NonNull MaybeSource<? extends @NonNull T1> source1, @NonNull MaybeSource<? extends @NonNull T2> source2, @NonNull MaybeSource<? extends @NonNull T3> source3, @NonNull MaybeSource<? extends @NonNull T4> source4, @NonNull Function4<? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, ? super @NonNull T4, ? extends @NonNull R> zipper) Returns aMaybe
that emits the results of a specified combiner function applied to combinations of four items emitted, in sequence, by four otherMaybeSource
s.Maybe.zip
(@NonNull MaybeSource<? extends @NonNull T1> source1, @NonNull MaybeSource<? extends @NonNull T2> source2, @NonNull MaybeSource<? extends @NonNull T3> source3, @NonNull Function3<? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, ? extends @NonNull R> zipper) Returns aMaybe
that emits the results of a specified combiner function applied to combinations of three items emitted, in sequence, by three otherMaybeSource
s.Maybe.zip
(@NonNull MaybeSource<? extends @NonNull T1> source1, @NonNull MaybeSource<? extends @NonNull T2> source2, @NonNull BiFunction<? super @NonNull T1, ? super @NonNull T2, ? extends @NonNull R> zipper) Returns aMaybe
that emits the results of a specified combiner function applied to combinations of two items emitted, in sequence, by two otherMaybeSource
s.Maybe.zip
(@NonNull Iterable<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources, @NonNull Function<? super Object[], ? extends @NonNull R> zipper) Returns aMaybe
that emits the results of a specified combiner function applied to combinations of items emitted, in sequence, by anIterable
of otherMaybeSource
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull T9, @NonNull R>
@NonNull Observable<R> Observable.zip
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull ObservableSource<? extends @NonNull T5> source5, @NonNull ObservableSource<? extends @NonNull T6> source6, @NonNull ObservableSource<? extends @NonNull T7> source7, @NonNull ObservableSource<? extends @NonNull T8> source8, @NonNull ObservableSource<? 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 anObservable
that emits the results of a specified combiner function applied to combinations of nine items emitted, in sequence, by nine otherObservableSource
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull R>
@NonNull Observable<R> Observable.zip
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull ObservableSource<? extends @NonNull T5> source5, @NonNull ObservableSource<? extends @NonNull T6> source6, @NonNull ObservableSource<? extends @NonNull T7> source7, @NonNull ObservableSource<? 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 anObservable
that emits the results of a specified combiner function applied to combinations of eight items emitted, in sequence, by eight otherObservableSource
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull R>
@NonNull Observable<R> Observable.zip
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull ObservableSource<? extends @NonNull T5> source5, @NonNull ObservableSource<? extends @NonNull T6> source6, @NonNull ObservableSource<? 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 anObservable
that emits the results of a specified combiner function applied to combinations of seven items emitted, in sequence, by seven otherObservableSource
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull R>
@NonNull Observable<R> Observable.zip
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull ObservableSource<? extends @NonNull T5> source5, @NonNull ObservableSource<? 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 anObservable
that emits the results of a specified combiner function applied to combinations of six items emitted, in sequence, by six otherObservableSource
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull R>
@NonNull Observable<R> Observable.zip
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull ObservableSource<? 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 anObservable
that emits the results of a specified combiner function applied to combinations of five items emitted, in sequence, by five otherObservableSource
s.Observable.zip
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull Function4<? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, ? super @NonNull T4, ? extends @NonNull R> zipper) Returns anObservable
that emits the results of a specified combiner function applied to combinations of four items emitted, in sequence, by four otherObservableSource
s.Observable.zip
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull Function3<? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, ? extends @NonNull R> zipper) Returns anObservable
that emits the results of a specified combiner function applied to combinations of three items emitted, in sequence, by three otherObservableSource
s.static <@NonNull T1,
@NonNull T2, @NonNull R>
@NonNull Observable<R> Observable.zip
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull BiFunction<? super @NonNull T1, ? super @NonNull T2, ? extends @NonNull R> zipper) Returns anObservable
that emits the results of a specified combiner function applied to combinations of two items emitted, in sequence, by two otherObservableSource
s.static <@NonNull T1,
@NonNull T2, @NonNull R>
@NonNull Observable<R> Observable.zip
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull BiFunction<? super @NonNull T1, ? super @NonNull T2, ? extends @NonNull R> zipper, boolean delayError) Returns anObservable
that emits the results of a specified combiner function applied to combinations of two items emitted, in sequence, by two otherObservableSource
s.static <@NonNull T1,
@NonNull T2, @NonNull R>
@NonNull Observable<R> Observable.zip
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull BiFunction<? super @NonNull T1, ? super @NonNull T2, ? extends @NonNull R> zipper, boolean delayError, int bufferSize) Returns anObservable
that emits the results of a specified combiner function applied to combinations of two items emitted, in sequence, by two otherObservableSource
s.static <@NonNull T,
@NonNull R>
@NonNull Observable<R> Observable.zip
(@NonNull Iterable<@NonNull ? extends ObservableSource<? extends @NonNull T>> sources, @NonNull Function<? super Object[], ? extends @NonNull R> zipper) Returns anObservable
that emits the results of a specified combiner function applied to combinations of items emitted, in sequence, by anIterable
of otherObservableSource
s.static <@NonNull T,
@NonNull R>
@NonNull Observable<R> Observable.zip
(@NonNull Iterable<@NonNull ? extends ObservableSource<? extends @NonNull T>> sources, @NonNull Function<? super Object[], ? extends @NonNull R> zipper, boolean delayError, int bufferSize) Returns anObservable
that emits the results of a specified combiner function applied to combinations of items emitted, in sequence, by anIterable
of otherObservableSource
s.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 aSingle
that emits the results of a specified combiner function applied to nine items emitted by nine otherSingleSource
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 aSingle
that emits the results of a specified combiner function applied to eight items emitted by eight otherSingleSource
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 aSingle
that emits the results of a specified combiner function applied to seven items emitted by seven otherSingleSource
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 aSingle
that emits the results of a specified combiner function applied to six items emitted by six otherSingleSource
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 aSingle
that emits the results of a specified combiner function applied to five items emitted by five otherSingleSource
s.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 aSingle
that emits the results of a specified combiner function applied to four items emitted by four otherSingleSource
s.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 aSingle
that emits the results of a specified combiner function applied to three items emitted by three otherSingleSource
s.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 aSingle
that emits the results of a specified combiner function applied to two items emitted by two otherSingleSource
s.Single.zip
(@NonNull Iterable<@NonNull ? extends SingleSource<? extends @NonNull T>> sources, @NonNull Function<? super Object[], ? extends @NonNull R> zipper) Waits until allSingleSource
sources provided by theIterable
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.Flowable.zipArray
(@NonNull Function<? super Object[], ? extends @NonNull R> zipper, boolean delayError, int bufferSize, @NonNull org.reactivestreams.Publisher<? extends @NonNull T>... sources) Returns aFlowable
that emits the results of a specified combiner function applied to combinations of items emitted, in sequence, by an array of otherPublisher
s.Maybe.zipArray
(@NonNull Function<? super Object[], ? extends @NonNull R> zipper, @NonNull MaybeSource<? extends @NonNull T>... sources) Returns aMaybe
that emits the results of a specified combiner function applied to combinations of items emitted, in sequence, by an array of otherMaybeSource
s.static <@NonNull T,
@NonNull R>
@NonNull Observable<R> Observable.zipArray
(@NonNull Function<? super Object[], ? extends @NonNull R> zipper, boolean delayError, int bufferSize, @NonNull ObservableSource<? extends @NonNull T>... sources) Returns anObservable
that emits the results of a specified combiner function applied to combinations of items emitted, in sequence, by an array of otherObservableSource
s.Single.zipArray
(@NonNull Function<? super Object[], ? extends @NonNull R> zipper, @NonNull SingleSource<? extends @NonNull T>... sources) Waits until allSingleSource
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.Flowable.zipWith
(@NonNull Iterable<@NonNull U> other, @NonNull BiFunction<? super @NonNull T, ? super @NonNull U, ? extends @NonNull R> zipper) Returns aFlowable
that emits items that are the result of applying a specified function to pairs of values, one each from the currentFlowable
and a specifiedIterable
sequence.Flowable.zipWith
(@NonNull org.reactivestreams.Publisher<? extends @NonNull U> other, @NonNull BiFunction<? super @NonNull T, ? super @NonNull U, ? extends @NonNull R> zipper) Returns aFlowable
that emits items that are the result of applying a specified function to pairs of values, one each from the currentFlowable
and another specifiedPublisher
.Flowable.zipWith
(@NonNull org.reactivestreams.Publisher<? extends @NonNull U> other, @NonNull BiFunction<? super @NonNull T, ? super @NonNull U, ? extends @NonNull R> zipper, boolean delayError) Returns aFlowable
that emits items that are the result of applying a specified function to pairs of values, one each from the currentFlowable
and another specifiedPublisher
.Flowable.zipWith
(@NonNull org.reactivestreams.Publisher<? extends @NonNull U> other, @NonNull BiFunction<? super @NonNull T, ? super @NonNull U, ? extends @NonNull R> zipper, boolean delayError, int bufferSize) Returns aFlowable
that emits items that are the result of applying a specified function to pairs of values, one each from the currentFlowable
and another specifiedPublisher
.Maybe.zipWith
(@NonNull MaybeSource<? extends @NonNull U> other, @NonNull BiFunction<? super @NonNull T, ? super @NonNull U, ? extends @NonNull R> zipper) Waits until this and the otherMaybeSource
signal a success value then applies the givenBiFunction
to those values and emits theBiFunction
's resulting value to downstream.final <@NonNull U,
@NonNull R>
@NonNull Observable<R> Observable.zipWith
(@NonNull ObservableSource<? extends @NonNull U> other, @NonNull BiFunction<? super @NonNull T, ? super @NonNull U, ? extends @NonNull R> zipper) Returns anObservable
that emits items that are the result of applying a specified function to pairs of values, one each from the currentObservable
and another specifiedObservableSource
.final <@NonNull U,
@NonNull R>
@NonNull Observable<R> Observable.zipWith
(@NonNull ObservableSource<? extends @NonNull U> other, @NonNull BiFunction<? super @NonNull T, ? super @NonNull U, ? extends @NonNull R> zipper, boolean delayError) Returns anObservable
that emits items that are the result of applying a specified function to pairs of values, one each from the currentObservable
and another specifiedObservableSource
.final <@NonNull U,
@NonNull R>
@NonNull Observable<R> Observable.zipWith
(@NonNull ObservableSource<? extends @NonNull U> other, @NonNull BiFunction<? super @NonNull T, ? super @NonNull U, ? extends @NonNull R> zipper, boolean delayError, int bufferSize) Returns anObservable
that emits items that are the result of applying a specified function to pairs of values, one each from the currentObservable
and another specifiedObservableSource
.final <@NonNull U,
@NonNull R>
@NonNull Observable<R> Observable.zipWith
(@NonNull Iterable<@NonNull U> other, @NonNull BiFunction<? super @NonNull T, ? super @NonNull U, ? extends @NonNull R> zipper) Returns anObservable
that emits items that are the result of applying a specified function to pairs of values, one each from the currentObservable
and a specifiedIterable
sequence.Single.zipWith
(@NonNull SingleSource<@NonNull U> other, @NonNull BiFunction<? super @NonNull T, ? super @NonNull U, ? extends @NonNull R> zipper) Returns aSingle
that emits the result of applying a specified function to the pair of items emitted by the currentSingle
and another specifiedSingleSource
.Method parameters in io.reactivex.rxjava3.core with annotations of type NonNullModifier and TypeMethodDescriptionstatic @NonNull Completable
Completable.amb
(@NonNull Iterable<@NonNull ? extends CompletableSource> sources) Returns aCompletable
which terminates as soon as one of the sourceCompletable
s in theIterable
sequence terminates (normally or with an error) and disposes all otherCompletable
s.Flowable.amb
(@NonNull Iterable<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources) Mirrors the onePublisher
in anIterable
of severalPublisher
s that first either emits an item or sends a termination notification.Runs multipleMaybeSource
s provided by anIterable
sequence and signals the events of the first one that signals (disposing the rest).static <@NonNull T>
@NonNull Observable<T> Observable.amb
(@NonNull Iterable<@NonNull ? extends ObservableSource<? extends @NonNull T>> sources) Mirrors the oneObservableSource
in anIterable
of severalObservableSource
s that first either emits an item or sends a termination notification.Runs multipleSingleSource
s and signals the events of the first one that signals (disposing the rest).static @NonNull Completable
Completable.ambArray
(@NonNull CompletableSource... sources) Returns aCompletable
which terminates as soon as one of the sourceCompletable
s terminates (normally or with an error) and disposes all otherCompletable
s.Mirrors the onePublisher
in an array of severalPublisher
s that first either emits an item or sends a termination notification.Maybe.ambArray
(@NonNull MaybeSource<? extends @NonNull T>... sources) Runs multipleMaybeSource
s and signals the events of the first one that signals (disposing the rest).static <@NonNull T>
@NonNull Observable<T> Observable.ambArray
(@NonNull ObservableSource<? extends @NonNull T>... sources) Mirrors the oneObservableSource
in an array of severalObservableSource
s that first either emits an item or sends a termination notification.Single.ambArray
(@NonNull SingleSource<? extends @NonNull T>... sources) Runs multipleSingleSource
s and signals the events of the first one that signals (disposing the rest).final @NonNull Completable
Completable.ambWith
(@NonNull CompletableSource other) Returns aCompletable
that emits the a terminated event of either thisCompletable
or the otherCompletableSource
, whichever fires first.Mirrors thePublisher
(current or provided) that first either emits an item or sends a termination notification.Maybe.ambWith
(@NonNull MaybeSource<? extends @NonNull T> other) Mirrors theMaybeSource
(current or provided) that first signals an event.final @NonNull Observable
<T> Observable.ambWith
(@NonNull ObservableSource<? extends @NonNull T> other) Mirrors the currentObservable
or the otherObservableSource
provided of which the first either emits an item or sends a termination notification.Single.ambWith
(@NonNull SingleSource<? extends @NonNull T> other) Signals the event of this or the otherSingleSource
whichever signals first.final @NonNull Completable
Completable.andThen
(@NonNull CompletableSource next) Completable.andThen
(@NonNull MaybeSource<@NonNull T> next) Returns aMaybe
which will subscribe to thisCompletable
and once that is completed then will subscribe to thenext
MaybeSource
.final <@NonNull T>
@NonNull Observable<T> Completable.andThen
(@NonNull ObservableSource<@NonNull T> next) Returns anObservable
which will subscribe to thisCompletable
and once that is completed then will subscribe to thenext
ObservableSource
.Completable.andThen
(@NonNull SingleSource<@NonNull T> next) Returns aSingle
which will subscribe to thisCompletable
and once that is completed then will subscribe to thenext
SingleSource
.Returns aFlowable
which will subscribe to thisCompletable
and once that is completed then will subscribe to thenext
Publisher
.Returns aSingle
that emitstrue
if any item emitted by the currentFlowable
satisfies a specified condition, otherwisefalse
.Returns aSingle
that emitstrue
if any item emitted by the currentObservable
satisfies a specified condition, otherwisefalse
.CompletableConverter.apply
(@NonNull Completable upstream) Applies a function to the upstream Completable and returns a converted value of typeR
.CompletableOperator.apply
(@NonNull CompletableObserver observer) Applies a function to the childCompletableObserver
and returns a new parentCompletableObserver
.CompletableTransformer.apply
(@NonNull Completable upstream) Applies a function to the upstreamCompletable
and returns aCompletableSource
.Applies a function to the upstreamFlowable
and returns a converted value of typeR
.FlowableOperator.apply
(@NonNull org.reactivestreams.Subscriber<? super @NonNull Downstream> subscriber) Applies a function to the childSubscriber
and returns a new parentSubscriber
.@NonNull org.reactivestreams.Publisher
<Downstream> Applies a function to the upstreamFlowable
and returns aPublisher
with optionally different element type.Applies a function to the upstreamMaybe
and returns a converted value of typeR
.@NonNull MaybeObserver
<? super Upstream> MaybeOperator.apply
(@NonNull MaybeObserver<? super @NonNull Downstream> observer) Applies a function to the childMaybeObserver
and returns a new parentMaybeObserver
.Applies a function to the upstreamMaybe
and returns aMaybeSource
with optionally different element type.ObservableConverter.apply
(@NonNull Observable<@NonNull T> upstream) Applies a function to the upstreamObservable
and returns a converted value of typeR
.ObservableOperator.apply
(@NonNull Observer<? super @NonNull Downstream> observer) Applies a function to the childObserver
and returns a new parentObserver
.ObservableTransformer.apply
(@NonNull Observable<@NonNull Upstream> upstream) Applies a function to the upstreamObservable
and returns anObservableSource
with optionally different element type.Applies a function to the upstreamSingle
and returns a converted value of typeR
.@NonNull SingleObserver
<? super Upstream> SingleOperator.apply
(@NonNull SingleObserver<? super @NonNull Downstream> observer) Applies a function to the childSingleObserver
and returns a new parentSingleObserver
.Applies a function to the upstreamSingle
and returns aSingleSource
with optionally different element type.final boolean
Completable.blockingAwait
(long timeout, @NonNull TimeUnit unit) Subscribes to and awaits the termination of thisCompletable
instance in a blocking manner with a specific timeout and rethrows any exception emitted within the timeout window.final T
Flowable.blockingFirst
(@NonNull T defaultItem) Returns the first item emitted by thisFlowable
, or a default value if it emits no items.final T
Observable.blockingFirst
(@NonNull T defaultItem) Returns the first item emitted by the currentObservable
, or a default value if it emits no items.final void
Flowable.blockingForEach
(@NonNull Consumer<? super @NonNull T> onNext) Consumes the currentFlowable
in a blocking fashion and invokes the givenConsumer
with each upstream item on the current thread until the upstream terminates.final void
Flowable.blockingForEach
(@NonNull Consumer<? super @NonNull T> onNext, int bufferSize) Consumes the currentFlowable
in a blocking fashion and invokes the givenConsumer
with each upstream item on the current thread until the upstream terminates.final void
Observable.blockingForEach
(@NonNull Consumer<? super @NonNull T> onNext) Consumes the currentObservable
in a blocking fashion and invokes the givenConsumer
with each upstream item on the current thread until the upstream terminates.final void
Observable.blockingForEach
(@NonNull Consumer<? super @NonNull T> onNext, int capacityHint) Consumes the currentObservable
in a blocking fashion and invokes the givenConsumer
with each upstream item on the current thread until the upstream terminates.final T
Maybe.blockingGet
(@NonNull T defaultValue) Waits in a blocking fashion until the currentMaybe
signals a success value (which is returned), defaultValue if completed or an exception (which is propagated).final T
Flowable.blockingLast
(@NonNull T defaultItem) Returns the last item emitted by thisFlowable
, or a default value if it emits no items.final T
Observable.blockingLast
(@NonNull T defaultItem) Returns the last item emitted by the currentObservable
, or a default value if it emits no items.Flowable.blockingMostRecent
(@NonNull T initialItem) Returns anIterable
that always returns the item most recently emitted by thisFlowable
.Observable.blockingMostRecent
(@NonNull T initialItem) Returns anIterable
that always returns the item most recently emitted by the currentObservable
.final T
Flowable.blockingSingle
(@NonNull T defaultItem) If thisFlowable
completes after emitting a single item, return that item; if it emits more than one item, throw anIllegalArgumentException
; if it emits no items, return a default value.final T
Observable.blockingSingle
(@NonNull T defaultItem) If the currentObservable
completes after emitting a single item, return that item; if it emits more than one item, throw anIllegalArgumentException
; if it emits no items, return a default value.final void
Completable.blockingSubscribe
(@NonNull CompletableObserver observer) Subscribes to the currentCompletable
and calls the appropriateCompletableObserver
method on the current thread.final void
Completable.blockingSubscribe
(@NonNull Action onComplete) Subscribes to the currentCompletable
and calls givenonComplete
callback on the current thread when it completes normally.final void
Completable.blockingSubscribe
(@NonNull Action onComplete, @NonNull Consumer<? super Throwable> onError) Subscribes to the currentCompletable
and calls the appropriate callback on the current thread when it terminates.final void
Completable.blockingSubscribe
(@NonNull Action onComplete, @NonNull Consumer<? super Throwable> onError) Subscribes to the currentCompletable
and calls the appropriate callback on the current thread when it terminates.final void
Flowable.blockingSubscribe
(@NonNull Consumer<? super @NonNull T> onNext) Subscribes to the source and calls the given callbacks on the current thread.final void
Flowable.blockingSubscribe
(@NonNull Consumer<? super @NonNull T> onNext, int bufferSize) Subscribes to the source and calls the given callbacks on the current thread.final void
Flowable.blockingSubscribe
(@NonNull Consumer<? super @NonNull T> onNext, @NonNull Consumer<? super Throwable> onError) Subscribes to the source and calls the given callbacks on the current thread.final void
Flowable.blockingSubscribe
(@NonNull Consumer<? super @NonNull T> onNext, @NonNull Consumer<? super Throwable> onError) Subscribes to the source and calls the given callbacks on the current thread.final void
Flowable.blockingSubscribe
(@NonNull Consumer<? super @NonNull T> onNext, @NonNull Consumer<? super Throwable> onError, int bufferSize) Subscribes to the source and calls the given callbacks on the current thread.final void
Flowable.blockingSubscribe
(@NonNull Consumer<? super @NonNull T> onNext, @NonNull Consumer<? super Throwable> onError, int bufferSize) Subscribes to the source and calls the given callbacks on the current thread.final void
Flowable.blockingSubscribe
(@NonNull Consumer<? super @NonNull T> onNext, @NonNull Consumer<? super Throwable> onError, @NonNull Action onComplete) Subscribes to the source and calls the given callbacks on the current thread.final void
Flowable.blockingSubscribe
(@NonNull Consumer<? super @NonNull T> onNext, @NonNull Consumer<? super Throwable> onError, @NonNull Action onComplete) Subscribes to the source and calls the given callbacks on the current thread.final void
Flowable.blockingSubscribe
(@NonNull Consumer<? super @NonNull T> onNext, @NonNull Consumer<? super Throwable> onError, @NonNull Action onComplete) Subscribes to the source and calls the given callbacks on the current thread.final void
Flowable.blockingSubscribe
(@NonNull Consumer<? super @NonNull T> onNext, @NonNull Consumer<? super Throwable> onError, @NonNull Action onComplete, int bufferSize) Subscribes to the source and calls the given callbacks on the current thread.final void
Flowable.blockingSubscribe
(@NonNull Consumer<? super @NonNull T> onNext, @NonNull Consumer<? super Throwable> onError, @NonNull Action onComplete, int bufferSize) Subscribes to the source and calls the given callbacks on the current thread.final void
Flowable.blockingSubscribe
(@NonNull Consumer<? super @NonNull T> onNext, @NonNull Consumer<? super Throwable> onError, @NonNull Action onComplete, int bufferSize) Subscribes to the source and calls the given callbacks on the current thread.final void
Flowable.blockingSubscribe
(@NonNull org.reactivestreams.Subscriber<? super @NonNull T> subscriber) Subscribes to the source and calls theSubscriber
methods on the current thread.final void
Maybe.blockingSubscribe
(@NonNull MaybeObserver<? super @NonNull T> observer) Subscribes to the currentMaybe
and calls the appropriateMaybeObserver
method on the current thread.final void
Maybe.blockingSubscribe
(@NonNull Consumer<? super @NonNull T> onSuccess) Subscribes to the currentMaybe
and calls givenonSuccess
callback on the current thread when it completes normally.final void
Maybe.blockingSubscribe
(@NonNull Consumer<? super @NonNull T> onSuccess, @NonNull Consumer<? super Throwable> onError) Subscribes to the currentMaybe
and calls the appropriate callback on the current thread when it terminates.final void
Maybe.blockingSubscribe
(@NonNull Consumer<? super @NonNull T> onSuccess, @NonNull Consumer<? super Throwable> onError) Subscribes to the currentMaybe
and calls the appropriate callback on the current thread when it terminates.final void
Maybe.blockingSubscribe
(@NonNull Consumer<? super @NonNull T> onSuccess, @NonNull Consumer<? super Throwable> onError, @NonNull Action onComplete) Subscribes to the currentMaybe
and calls the appropriate callback on the current thread when it terminates.final void
Maybe.blockingSubscribe
(@NonNull Consumer<? super @NonNull T> onSuccess, @NonNull Consumer<? super Throwable> onError, @NonNull Action onComplete) Subscribes to the currentMaybe
and calls the appropriate callback on the current thread when it terminates.final void
Maybe.blockingSubscribe
(@NonNull Consumer<? super @NonNull T> onSuccess, @NonNull Consumer<? super Throwable> onError, @NonNull Action onComplete) Subscribes to the currentMaybe
and calls the appropriate callback on the current thread when it terminates.final void
Observable.blockingSubscribe
(@NonNull Observer<? super @NonNull T> observer) Subscribes to the source and calls theObserver
methods on the current thread.final void
Observable.blockingSubscribe
(@NonNull Consumer<? super @NonNull T> onNext) Subscribes to the source and calls the given callbacks on the current thread.final void
Observable.blockingSubscribe
(@NonNull Consumer<? super @NonNull T> onNext, @NonNull Consumer<? super Throwable> onError) Subscribes to the source and calls the given callbacks on the current thread.final void
Observable.blockingSubscribe
(@NonNull Consumer<? super @NonNull T> onNext, @NonNull Consumer<? super Throwable> onError) Subscribes to the source and calls the given callbacks on the current thread.final void
Observable.blockingSubscribe
(@NonNull Consumer<? super @NonNull T> onNext, @NonNull Consumer<? super Throwable> onError, @NonNull Action onComplete) Subscribes to the source and calls the given callbacks on the current thread.final void
Observable.blockingSubscribe
(@NonNull Consumer<? super @NonNull T> onNext, @NonNull Consumer<? super Throwable> onError, @NonNull Action onComplete) Subscribes to the source and calls the given callbacks on the current thread.final void
Observable.blockingSubscribe
(@NonNull Consumer<? super @NonNull T> onNext, @NonNull Consumer<? super Throwable> onError, @NonNull Action onComplete) Subscribes to the source and calls the given callbacks on the current thread.final void
Single.blockingSubscribe
(@NonNull SingleObserver<? super @NonNull T> observer) Subscribes to the currentSingle
and calls the appropriateSingleObserver
method on the current thread.final void
Single.blockingSubscribe
(@NonNull Consumer<? super @NonNull T> onSuccess) Subscribes to the currentSingle
and calls givenonSuccess
callback on the current thread when it completes normally.final void
Single.blockingSubscribe
(@NonNull Consumer<? super @NonNull T> onSuccess, @NonNull Consumer<? super Throwable> onError) Subscribes to the currentSingle
and calls the appropriate callback on the current thread when it terminates.final void
Single.blockingSubscribe
(@NonNull Consumer<? super @NonNull T> onSuccess, @NonNull Consumer<? super Throwable> onError) Subscribes to the currentSingle
and calls the appropriate callback on the current thread when it terminates.Returns aFlowable
that emits buffers of items it collects from the currentFlowable
.Returns aFlowable
that emits buffers of items it collects from the currentFlowable
.Returns aFlowable
that emits buffers of items it collects from the currentFlowable
.Returns aFlowable
that emits buffers of items it collects from the currentFlowable
.Returns aFlowable
that emits buffers of items it collects from the currentFlowable
.Flowable.buffer
(long timespan, long timeskip, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, @NonNull Supplier<@NonNull U> bufferSupplier) Returns aFlowable
that emits buffers of items it collects from the currentFlowable
.Flowable.buffer
(long timespan, long timeskip, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, @NonNull Supplier<@NonNull U> bufferSupplier) Returns aFlowable
that emits buffers of items it collects from the currentFlowable
.Flowable.buffer
(long timespan, long timeskip, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, @NonNull Supplier<@NonNull U> bufferSupplier) Returns aFlowable
that emits buffers of items it collects from the currentFlowable
.Returns aFlowable
that emits buffers of items it collects from the currentFlowable
.Returns aFlowable
that emits buffers of items it collects from the currentFlowable
.Returns aFlowable
that emits buffers of items it collects from the currentFlowable
.Returns aFlowable
that emits buffers of items it collects from the currentFlowable
.Returns aFlowable
that emits buffers of items it collects from the currentFlowable
.Returns aFlowable
that emits buffers of items it collects from the currentFlowable
.Flowable.buffer
(long timespan, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, int count, @NonNull Supplier<@NonNull U> bufferSupplier, boolean restartTimerOnMaxSize) Returns aFlowable
that emits buffers of items it collects from the currentFlowable
.Flowable.buffer
(long timespan, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, int count, @NonNull Supplier<@NonNull U> bufferSupplier, boolean restartTimerOnMaxSize) Returns aFlowable
that emits buffers of items it collects from the currentFlowable
.Flowable.buffer
(long timespan, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, int count, @NonNull Supplier<@NonNull U> bufferSupplier, boolean restartTimerOnMaxSize) Returns aFlowable
that emits buffers of items it collects from the currentFlowable
.Flowable.buffer
(@NonNull org.reactivestreams.Publisher<? extends @NonNull TOpening> openingIndicator, @NonNull Function<? super @NonNull TOpening, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull TClosing>> closingIndicator) Returns aFlowable
that emits buffers of items it collects from the currentFlowable
.Flowable.buffer
(@NonNull org.reactivestreams.Publisher<? extends @NonNull TOpening> openingIndicator, @NonNull Function<? super @NonNull TOpening, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull TClosing>> closingIndicator) Returns aFlowable
that emits buffers of items it collects from the currentFlowable
.final <@NonNull TOpening,
@NonNull TClosing, @NonNull U extends Collection<? super @NonNull T>>
@NonNull Flowable<U> Flowable.buffer
(@NonNull org.reactivestreams.Publisher<? extends @NonNull TOpening> openingIndicator, @NonNull Function<? super @NonNull TOpening, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull TClosing>> closingIndicator, @NonNull Supplier<@NonNull U> bufferSupplier) Returns aFlowable
that emits buffers of items it collects from the currentFlowable
.final <@NonNull TOpening,
@NonNull TClosing, @NonNull U extends Collection<? super @NonNull T>>
@NonNull Flowable<U> Flowable.buffer
(@NonNull org.reactivestreams.Publisher<? extends @NonNull TOpening> openingIndicator, @NonNull Function<? super @NonNull TOpening, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull TClosing>> closingIndicator, @NonNull Supplier<@NonNull U> bufferSupplier) Returns aFlowable
that emits buffers of items it collects from the currentFlowable
.final <@NonNull TOpening,
@NonNull TClosing, @NonNull U extends Collection<? super @NonNull T>>
@NonNull Flowable<U> Flowable.buffer
(@NonNull org.reactivestreams.Publisher<? extends @NonNull TOpening> openingIndicator, @NonNull Function<? super @NonNull TOpening, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull TClosing>> closingIndicator, @NonNull Supplier<@NonNull U> bufferSupplier) Returns aFlowable
that emits buffers of items it collects from the currentFlowable
.Returns aFlowable
that emits non-overlapping buffered items from the currentFlowable
each time the specified boundaryPublisher
emits an item.Flowable.buffer
(@NonNull org.reactivestreams.Publisher<@NonNull B> boundaryIndicator, int initialCapacity) Returns aFlowable
that emits non-overlapping buffered items from the currentFlowable
each time the specified boundaryPublisher
emits an item.Flowable.buffer
(@NonNull org.reactivestreams.Publisher<@NonNull B> boundaryIndicator, @NonNull Supplier<@NonNull U> bufferSupplier) Returns aFlowable
that emits non-overlapping buffered items from the currentFlowable
each time the specified boundaryPublisher
emits an item.Flowable.buffer
(@NonNull org.reactivestreams.Publisher<@NonNull B> boundaryIndicator, @NonNull Supplier<@NonNull U> bufferSupplier) Returns aFlowable
that emits non-overlapping buffered items from the currentFlowable
each time the specified boundaryPublisher
emits an item.final <@NonNull U extends Collection<? super @NonNull T>>
@NonNull Observable<U> Returns anObservable
that emits buffers of items it collects from the currentObservable
.final <@NonNull U extends Collection<? super @NonNull T>>
@NonNull Observable<U> Returns anObservable
that emits buffers of items it collects from the currentObservable
.final @NonNull Observable
<@NonNull List<T>> Returns anObservable
that emits buffers of items it collects from the currentObservable
.final @NonNull Observable
<@NonNull List<T>> Observable.buffer
(long timespan, long timeskip, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Returns anObservable
that emits buffers of items it collects from the currentObservable
.final @NonNull Observable
<@NonNull List<T>> Observable.buffer
(long timespan, long timeskip, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Returns anObservable
that emits buffers of items it collects from the currentObservable
.final <@NonNull U extends Collection<? super @NonNull T>>
@NonNull Observable<U> Observable.buffer
(long timespan, long timeskip, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, @NonNull Supplier<@NonNull U> bufferSupplier) Returns anObservable
that emits buffers of items it collects from the currentObservable
.final <@NonNull U extends Collection<? super @NonNull T>>
@NonNull Observable<U> Observable.buffer
(long timespan, long timeskip, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, @NonNull Supplier<@NonNull U> bufferSupplier) Returns anObservable
that emits buffers of items it collects from the currentObservable
.final <@NonNull U extends Collection<? super @NonNull T>>
@NonNull Observable<U> Observable.buffer
(long timespan, long timeskip, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, @NonNull Supplier<@NonNull U> bufferSupplier) Returns anObservable
that emits buffers of items it collects from the currentObservable
.final @NonNull Observable
<@NonNull List<T>> Returns anObservable
that emits buffers of items it collects from the currentObservable
.final @NonNull Observable
<@NonNull List<T>> Returns anObservable
that emits buffers of items it collects from the currentObservable
.final @NonNull Observable
<@NonNull List<T>> Returns anObservable
that emits buffers of items it collects from the currentObservable
.final @NonNull Observable
<@NonNull List<T>> Returns anObservable
that emits buffers of items it collects from the currentObservable
.final @NonNull Observable
<@NonNull List<T>> Returns anObservable
that emits buffers of items it collects from the currentObservable
.final @NonNull Observable
<@NonNull List<T>> Returns anObservable
that emits buffers of items it collects from the currentObservable
.final <@NonNull U extends Collection<? super @NonNull T>>
@NonNull Observable<U> Observable.buffer
(long timespan, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, int count, @NonNull Supplier<@NonNull U> bufferSupplier, boolean restartTimerOnMaxSize) Returns anObservable
that emits buffers of items it collects from the currentObservable
.final <@NonNull U extends Collection<? super @NonNull T>>
@NonNull Observable<U> Observable.buffer
(long timespan, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, int count, @NonNull Supplier<@NonNull U> bufferSupplier, boolean restartTimerOnMaxSize) Returns anObservable
that emits buffers of items it collects from the currentObservable
.final <@NonNull U extends Collection<? super @NonNull T>>
@NonNull Observable<U> Observable.buffer
(long timespan, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, int count, @NonNull Supplier<@NonNull U> bufferSupplier, boolean restartTimerOnMaxSize) Returns anObservable
that emits buffers of items it collects from the currentObservable
.Observable.buffer
(@NonNull ObservableSource<? extends @NonNull TOpening> openingIndicator, @NonNull Function<? super @NonNull TOpening, ? extends ObservableSource<? extends @NonNull TClosing>> closingIndicator) Returns anObservable
that emits buffers of items it collects from the currentObservable
.Observable.buffer
(@NonNull ObservableSource<? extends @NonNull TOpening> openingIndicator, @NonNull Function<? super @NonNull TOpening, ? extends ObservableSource<? extends @NonNull TClosing>> closingIndicator) Returns anObservable
that emits buffers of items it collects from the currentObservable
.final <@NonNull TOpening,
@NonNull TClosing, @NonNull U extends Collection<? super @NonNull T>>
@NonNull Observable<U> Observable.buffer
(@NonNull ObservableSource<? extends @NonNull TOpening> openingIndicator, @NonNull Function<? super @NonNull TOpening, ? extends ObservableSource<? extends @NonNull TClosing>> closingIndicator, @NonNull Supplier<@NonNull U> bufferSupplier) Returns anObservable
that emits buffers of items it collects from the currentObservable
.final <@NonNull TOpening,
@NonNull TClosing, @NonNull U extends Collection<? super @NonNull T>>
@NonNull Observable<U> Observable.buffer
(@NonNull ObservableSource<? extends @NonNull TOpening> openingIndicator, @NonNull Function<? super @NonNull TOpening, ? extends ObservableSource<? extends @NonNull TClosing>> closingIndicator, @NonNull Supplier<@NonNull U> bufferSupplier) Returns anObservable
that emits buffers of items it collects from the currentObservable
.final <@NonNull TOpening,
@NonNull TClosing, @NonNull U extends Collection<? super @NonNull T>>
@NonNull Observable<U> Observable.buffer
(@NonNull ObservableSource<? extends @NonNull TOpening> openingIndicator, @NonNull Function<? super @NonNull TOpening, ? extends ObservableSource<? extends @NonNull TClosing>> closingIndicator, @NonNull Supplier<@NonNull U> bufferSupplier) Returns anObservable
that emits buffers of items it collects from the currentObservable
.Observable.buffer
(@NonNull ObservableSource<@NonNull B> boundaryIndicator) Returns anObservable
that emits non-overlapping buffered items from the currentObservable
each time the specified boundaryObservableSource
emits an item.Observable.buffer
(@NonNull ObservableSource<@NonNull B> boundaryIndicator, int initialCapacity) Returns anObservable
that emits non-overlapping buffered items from the currentObservable
each time the specified boundaryObservableSource
emits an item.final <@NonNull B,
@NonNull U extends Collection<? super @NonNull T>>
@NonNull Observable<U> Observable.buffer
(@NonNull ObservableSource<@NonNull B> boundaryIndicator, @NonNull Supplier<@NonNull U> bufferSupplier) Returns anObservable
that emits non-overlapping buffered items from the currentObservable
each time the specified boundaryObservableSource
emits an item.final <@NonNull B,
@NonNull U extends Collection<? super @NonNull T>>
@NonNull Observable<U> Observable.buffer
(@NonNull ObservableSource<@NonNull B> boundaryIndicator, @NonNull Supplier<@NonNull U> bufferSupplier) Returns anObservable
that emits non-overlapping buffered items from the currentObservable
each time the specified boundaryObservableSource
emits an item.Returns aFlowable
that emits the upstream items while they can be cast viaClass.cast(Object)
until the upstream terminates, or until the upstream signals an item which can't be cast, resulting in aClassCastException
to be signaled to the downstream.Casts the success value of the currentMaybe
into the target type or signals aClassCastException
if not compatible.final <@NonNull U>
@NonNull Observable<U> Returns anObservable
that emits the upstream items while they can be cast viaClass.cast(Object)
until the upstream terminates, or until the upstream signals an item which can't be cast, resulting in aClassCastException
to be signaled to the downstream.Casts the success value of the currentSingle
into the target type or signals aClassCastException
if not compatible.Flowable.collect
(@NonNull Supplier<? extends @NonNull U> initialItemSupplier, @NonNull BiConsumer<? super @NonNull U, ? super @NonNull T> collector) Collects items emitted by the finite sourcePublisher
into a single mutable data structure and returns aSingle
that emits this structure.Flowable.collect
(@NonNull Supplier<? extends @NonNull U> initialItemSupplier, @NonNull BiConsumer<? super @NonNull U, ? super @NonNull T> collector) Collects items emitted by the finite sourcePublisher
into a single mutable data structure and returns aSingle
that emits this structure.Observable.collect
(@NonNull Supplier<? extends @NonNull U> initialItemSupplier, @NonNull BiConsumer<? super @NonNull U, ? super @NonNull T> collector) Collects items emitted by the finite sourceObservable
into a single mutable data structure and returns aSingle
that emits this structure.Observable.collect
(@NonNull Supplier<? extends @NonNull U> initialItemSupplier, @NonNull BiConsumer<? super @NonNull U, ? super @NonNull T> collector) Collects items emitted by the finite sourceObservable
into a single mutable data structure and returns aSingle
that emits this structure.Flowable.collectInto
(@NonNull U initialItem, @NonNull BiConsumer<? super @NonNull U, ? super @NonNull T> collector) Collects items emitted by the finite sourcePublisher
into a single mutable data structure and returns aSingle
that emits this structure.Observable.collectInto
(@NonNull U initialItem, @NonNull BiConsumer<? super @NonNull U, ? super @NonNull T> collector) Collects items emitted by the finite sourceObservable
into a single mutable data structure and returns aSingle
that emits this structure.Observable.collectInto
(@NonNull U initialItem, @NonNull BiConsumer<? super @NonNull U, ? super @NonNull T> collector) Collects items emitted by the finite sourceObservable
into a single mutable data structure and returns aSingle
that emits this structure.Flowable.combineLatest
(@NonNull Iterable<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources, @NonNull Function<? super Object[], ? extends @NonNull R> combiner) Combines a collection of sourcePublisher
s by emitting an item that aggregates the latest values of each of the sourcePublisher
s each time an item is received from any of the sourcePublisher
s, where this aggregation is defined by a specified function.Flowable.combineLatest
(@NonNull Iterable<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources, @NonNull Function<? super Object[], ? extends @NonNull R> combiner) Combines a collection of sourcePublisher
s by emitting an item that aggregates the latest values of each of the sourcePublisher
s each time an item is received from any of the sourcePublisher
s, where this aggregation is defined by a specified function.Flowable.combineLatest
(@NonNull Iterable<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources, @NonNull Function<? super Object[], ? extends @NonNull R> combiner, int bufferSize) Combines a collection of sourcePublisher
s by emitting an item that aggregates the latest values of each of the sourcePublisher
s each time an item is received from any of the sourcePublisher
s, where this aggregation is defined by a specified function.Flowable.combineLatest
(@NonNull Iterable<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources, @NonNull Function<? super Object[], ? extends @NonNull R> combiner, int bufferSize) Combines a collection of sourcePublisher
s by emitting an item that aggregates the latest values of each of the sourcePublisher
s each time an item is received from any of the sourcePublisher
s, where this aggregation is defined by a specified function.Flowable.combineLatest
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull BiFunction<? super @NonNull T1, ? super @NonNull T2, ? extends @NonNull R> combiner) Combines two sourcePublisher
s by emitting an item that aggregates the latest values of each of the sourcePublisher
s each time an item is received from either of the sourcePublisher
s, where this aggregation is defined by a specified function.Flowable.combineLatest
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull BiFunction<? super @NonNull T1, ? super @NonNull T2, ? extends @NonNull R> combiner) Combines two sourcePublisher
s by emitting an item that aggregates the latest values of each of the sourcePublisher
s each time an item is received from either of the sourcePublisher
s, where this aggregation is defined by a specified function.Flowable.combineLatest
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull BiFunction<? super @NonNull T1, ? super @NonNull T2, ? extends @NonNull R> combiner) Combines two sourcePublisher
s by emitting an item that aggregates the latest values of each of the sourcePublisher
s each time an item is received from either of the sourcePublisher
s, where this aggregation is defined by a specified function.Flowable.combineLatest
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull Function3<? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, ? extends @NonNull R> combiner) Combines three sourcePublisher
s by emitting an item that aggregates the latest values of each of the sourcePublisher
s each time an item is received from any of the sourcePublisher
s, where this aggregation is defined by a specified function.Flowable.combineLatest
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull Function3<? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, ? extends @NonNull R> combiner) Combines three sourcePublisher
s by emitting an item that aggregates the latest values of each of the sourcePublisher
s each time an item is received from any of the sourcePublisher
s, where this aggregation is defined by a specified function.Flowable.combineLatest
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull Function3<? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, ? extends @NonNull R> combiner) Combines three sourcePublisher
s by emitting an item that aggregates the latest values of each of the sourcePublisher
s each time an item is received from any of the sourcePublisher
s, where this aggregation is defined by a specified function.Flowable.combineLatest
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull Function3<? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, ? extends @NonNull R> combiner) Combines three sourcePublisher
s by emitting an item that aggregates the latest values of each of the sourcePublisher
s each time an item is received from any of the sourcePublisher
s, where this aggregation is defined by a specified function.Flowable.combineLatest
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull Function4<? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, ? super @NonNull T4, ? extends @NonNull R> combiner) Combines four sourcePublisher
s by emitting an item that aggregates the latest values of each of the sourcePublisher
s each time an item is received from any of the sourcePublisher
s, where this aggregation is defined by a specified function.Flowable.combineLatest
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull Function4<? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, ? super @NonNull T4, ? extends @NonNull R> combiner) Combines four sourcePublisher
s by emitting an item that aggregates the latest values of each of the sourcePublisher
s each time an item is received from any of the sourcePublisher
s, where this aggregation is defined by a specified function.Flowable.combineLatest
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull Function4<? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, ? super @NonNull T4, ? extends @NonNull R> combiner) Combines four sourcePublisher
s by emitting an item that aggregates the latest values of each of the sourcePublisher
s each time an item is received from any of the sourcePublisher
s, where this aggregation is defined by a specified function.Flowable.combineLatest
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull Function4<? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, ? super @NonNull T4, ? extends @NonNull R> combiner) Combines four sourcePublisher
s by emitting an item that aggregates the latest values of each of the sourcePublisher
s each time an item is received from any of the sourcePublisher
s, where this aggregation is defined by a specified function.Flowable.combineLatest
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull Function4<? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, ? super @NonNull T4, ? extends @NonNull R> combiner) Combines four sourcePublisher
s by emitting an item that aggregates the latest values of each of the sourcePublisher
s each time an item is received from any of the sourcePublisher
s, where this aggregation is defined by a specified function.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull R>
@NonNull Flowable<R> Flowable.combineLatest
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull org.reactivestreams.Publisher<? extends @NonNull T5> source5, @NonNull Function5<? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, ? super @NonNull T4, ? super @NonNull T5, ? extends @NonNull R> combiner) Combines five sourcePublisher
s by emitting an item that aggregates the latest values of each of the sourcePublisher
s each time an item is received from any of the sourcePublisher
s, where this aggregation is defined by a specified function.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull R>
@NonNull Flowable<R> Flowable.combineLatest
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull org.reactivestreams.Publisher<? extends @NonNull T5> source5, @NonNull Function5<? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, ? super @NonNull T4, ? super @NonNull T5, ? extends @NonNull R> combiner) Combines five sourcePublisher
s by emitting an item that aggregates the latest values of each of the sourcePublisher
s each time an item is received from any of the sourcePublisher
s, where this aggregation is defined by a specified function.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull R>
@NonNull Flowable<R> Flowable.combineLatest
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull org.reactivestreams.Publisher<? extends @NonNull T5> source5, @NonNull Function5<? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, ? super @NonNull T4, ? super @NonNull T5, ? extends @NonNull R> combiner) Combines five sourcePublisher
s by emitting an item that aggregates the latest values of each of the sourcePublisher
s each time an item is received from any of the sourcePublisher
s, where this aggregation is defined by a specified function.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull R>
@NonNull Flowable<R> Flowable.combineLatest
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull org.reactivestreams.Publisher<? extends @NonNull T5> source5, @NonNull Function5<? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, ? super @NonNull T4, ? super @NonNull T5, ? extends @NonNull R> combiner) Combines five sourcePublisher
s by emitting an item that aggregates the latest values of each of the sourcePublisher
s each time an item is received from any of the sourcePublisher
s, where this aggregation is defined by a specified function.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull R>
@NonNull Flowable<R> Flowable.combineLatest
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull org.reactivestreams.Publisher<? extends @NonNull T5> source5, @NonNull Function5<? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, ? super @NonNull T4, ? super @NonNull T5, ? extends @NonNull R> combiner) Combines five sourcePublisher
s by emitting an item that aggregates the latest values of each of the sourcePublisher
s each time an item is received from any of the sourcePublisher
s, where this aggregation is defined by a specified function.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull R>
@NonNull Flowable<R> Flowable.combineLatest
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull org.reactivestreams.Publisher<? extends @NonNull T5> source5, @NonNull Function5<? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, ? super @NonNull T4, ? super @NonNull T5, ? extends @NonNull R> combiner) Combines five sourcePublisher
s by emitting an item that aggregates the latest values of each of the sourcePublisher
s each time an item is received from any of the sourcePublisher
s, where this aggregation is defined by a specified function.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull R>
@NonNull Flowable<R> Flowable.combineLatest
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull org.reactivestreams.Publisher<? extends @NonNull T5> source5, @NonNull org.reactivestreams.Publisher<? 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> combiner) Combines six sourcePublisher
s by emitting an item that aggregates the latest values of each of the sourcePublisher
s each time an item is received from any of the sourcePublisher
s, where this aggregation is defined by a specified function.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull R>
@NonNull Flowable<R> Flowable.combineLatest
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull org.reactivestreams.Publisher<? extends @NonNull T5> source5, @NonNull org.reactivestreams.Publisher<? 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> combiner) Combines six sourcePublisher
s by emitting an item that aggregates the latest values of each of the sourcePublisher
s each time an item is received from any of the sourcePublisher
s, where this aggregation is defined by a specified function.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull R>
@NonNull Flowable<R> Flowable.combineLatest
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull org.reactivestreams.Publisher<? extends @NonNull T5> source5, @NonNull org.reactivestreams.Publisher<? 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> combiner) Combines six sourcePublisher
s by emitting an item that aggregates the latest values of each of the sourcePublisher
s each time an item is received from any of the sourcePublisher
s, where this aggregation is defined by a specified function.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull R>
@NonNull Flowable<R> Flowable.combineLatest
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull org.reactivestreams.Publisher<? extends @NonNull T5> source5, @NonNull org.reactivestreams.Publisher<? 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> combiner) Combines six sourcePublisher
s by emitting an item that aggregates the latest values of each of the sourcePublisher
s each time an item is received from any of the sourcePublisher
s, where this aggregation is defined by a specified function.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull R>
@NonNull Flowable<R> Flowable.combineLatest
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull org.reactivestreams.Publisher<? extends @NonNull T5> source5, @NonNull org.reactivestreams.Publisher<? 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> combiner) Combines six sourcePublisher
s by emitting an item that aggregates the latest values of each of the sourcePublisher
s each time an item is received from any of the sourcePublisher
s, where this aggregation is defined by a specified function.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull R>
@NonNull Flowable<R> Flowable.combineLatest
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull org.reactivestreams.Publisher<? extends @NonNull T5> source5, @NonNull org.reactivestreams.Publisher<? 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> combiner) Combines six sourcePublisher
s by emitting an item that aggregates the latest values of each of the sourcePublisher
s each time an item is received from any of the sourcePublisher
s, where this aggregation is defined by a specified function.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull R>
@NonNull Flowable<R> Flowable.combineLatest
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull org.reactivestreams.Publisher<? extends @NonNull T5> source5, @NonNull org.reactivestreams.Publisher<? 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> combiner) Combines six sourcePublisher
s by emitting an item that aggregates the latest values of each of the sourcePublisher
s each time an item is received from any of the sourcePublisher
s, where this aggregation is defined by a specified function.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull R>
@NonNull Flowable<R> Flowable.combineLatest
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull org.reactivestreams.Publisher<? extends @NonNull T5> source5, @NonNull org.reactivestreams.Publisher<? extends @NonNull T6> source6, @NonNull org.reactivestreams.Publisher<? 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> combiner) Combines seven sourcePublisher
s by emitting an item that aggregates the latest values of each of the sourcePublisher
s each time an item is received from any of the sourcePublisher
s, where this aggregation is defined by a specified function.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull R>
@NonNull Flowable<R> Flowable.combineLatest
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull org.reactivestreams.Publisher<? extends @NonNull T5> source5, @NonNull org.reactivestreams.Publisher<? extends @NonNull T6> source6, @NonNull org.reactivestreams.Publisher<? 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> combiner) Combines seven sourcePublisher
s by emitting an item that aggregates the latest values of each of the sourcePublisher
s each time an item is received from any of the sourcePublisher
s, where this aggregation is defined by a specified function.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull R>
@NonNull Flowable<R> Flowable.combineLatest
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull org.reactivestreams.Publisher<? extends @NonNull T5> source5, @NonNull org.reactivestreams.Publisher<? extends @NonNull T6> source6, @NonNull org.reactivestreams.Publisher<? 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> combiner) Combines seven sourcePublisher
s by emitting an item that aggregates the latest values of each of the sourcePublisher
s each time an item is received from any of the sourcePublisher
s, where this aggregation is defined by a specified function.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull R>
@NonNull Flowable<R> Flowable.combineLatest
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull org.reactivestreams.Publisher<? extends @NonNull T5> source5, @NonNull org.reactivestreams.Publisher<? extends @NonNull T6> source6, @NonNull org.reactivestreams.Publisher<? 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> combiner) Combines seven sourcePublisher
s by emitting an item that aggregates the latest values of each of the sourcePublisher
s each time an item is received from any of the sourcePublisher
s, where this aggregation is defined by a specified function.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull R>
@NonNull Flowable<R> Flowable.combineLatest
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull org.reactivestreams.Publisher<? extends @NonNull T5> source5, @NonNull org.reactivestreams.Publisher<? extends @NonNull T6> source6, @NonNull org.reactivestreams.Publisher<? 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> combiner) Combines seven sourcePublisher
s by emitting an item that aggregates the latest values of each of the sourcePublisher
s each time an item is received from any of the sourcePublisher
s, where this aggregation is defined by a specified function.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull R>
@NonNull Flowable<R> Flowable.combineLatest
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull org.reactivestreams.Publisher<? extends @NonNull T5> source5, @NonNull org.reactivestreams.Publisher<? extends @NonNull T6> source6, @NonNull org.reactivestreams.Publisher<? 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> combiner) Combines seven sourcePublisher
s by emitting an item that aggregates the latest values of each of the sourcePublisher
s each time an item is received from any of the sourcePublisher
s, where this aggregation is defined by a specified function.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull R>
@NonNull Flowable<R> Flowable.combineLatest
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull org.reactivestreams.Publisher<? extends @NonNull T5> source5, @NonNull org.reactivestreams.Publisher<? extends @NonNull T6> source6, @NonNull org.reactivestreams.Publisher<? 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> combiner) Combines seven sourcePublisher
s by emitting an item that aggregates the latest values of each of the sourcePublisher
s each time an item is received from any of the sourcePublisher
s, where this aggregation is defined by a specified function.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull R>
@NonNull Flowable<R> Flowable.combineLatest
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull org.reactivestreams.Publisher<? extends @NonNull T5> source5, @NonNull org.reactivestreams.Publisher<? extends @NonNull T6> source6, @NonNull org.reactivestreams.Publisher<? 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> combiner) Combines seven sourcePublisher
s by emitting an item that aggregates the latest values of each of the sourcePublisher
s each time an item is received from any of the sourcePublisher
s, where this aggregation is defined by a specified function.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull R>
@NonNull Flowable<R> Flowable.combineLatest
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull org.reactivestreams.Publisher<? extends @NonNull T5> source5, @NonNull org.reactivestreams.Publisher<? extends @NonNull T6> source6, @NonNull org.reactivestreams.Publisher<? extends @NonNull T7> source7, @NonNull org.reactivestreams.Publisher<? 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> combiner) Combines eight sourcePublisher
s by emitting an item that aggregates the latest values of each of the sourcePublisher
s each time an item is received from any of the sourcePublisher
s, where this aggregation is defined by a specified function.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull R>
@NonNull Flowable<R> Flowable.combineLatest
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull org.reactivestreams.Publisher<? extends @NonNull T5> source5, @NonNull org.reactivestreams.Publisher<? extends @NonNull T6> source6, @NonNull org.reactivestreams.Publisher<? extends @NonNull T7> source7, @NonNull org.reactivestreams.Publisher<? 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> combiner) Combines eight sourcePublisher
s by emitting an item that aggregates the latest values of each of the sourcePublisher
s each time an item is received from any of the sourcePublisher
s, where this aggregation is defined by a specified function.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull R>
@NonNull Flowable<R> Flowable.combineLatest
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull org.reactivestreams.Publisher<? extends @NonNull T5> source5, @NonNull org.reactivestreams.Publisher<? extends @NonNull T6> source6, @NonNull org.reactivestreams.Publisher<? extends @NonNull T7> source7, @NonNull org.reactivestreams.Publisher<? 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> combiner) Combines eight sourcePublisher
s by emitting an item that aggregates the latest values of each of the sourcePublisher
s each time an item is received from any of the sourcePublisher
s, where this aggregation is defined by a specified function.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull R>
@NonNull Flowable<R> Flowable.combineLatest
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull org.reactivestreams.Publisher<? extends @NonNull T5> source5, @NonNull org.reactivestreams.Publisher<? extends @NonNull T6> source6, @NonNull org.reactivestreams.Publisher<? extends @NonNull T7> source7, @NonNull org.reactivestreams.Publisher<? 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> combiner) Combines eight sourcePublisher
s by emitting an item that aggregates the latest values of each of the sourcePublisher
s each time an item is received from any of the sourcePublisher
s, where this aggregation is defined by a specified function.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull R>
@NonNull Flowable<R> Flowable.combineLatest
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull org.reactivestreams.Publisher<? extends @NonNull T5> source5, @NonNull org.reactivestreams.Publisher<? extends @NonNull T6> source6, @NonNull org.reactivestreams.Publisher<? extends @NonNull T7> source7, @NonNull org.reactivestreams.Publisher<? 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> combiner) Combines eight sourcePublisher
s by emitting an item that aggregates the latest values of each of the sourcePublisher
s each time an item is received from any of the sourcePublisher
s, where this aggregation is defined by a specified function.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull R>
@NonNull Flowable<R> Flowable.combineLatest
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull org.reactivestreams.Publisher<? extends @NonNull T5> source5, @NonNull org.reactivestreams.Publisher<? extends @NonNull T6> source6, @NonNull org.reactivestreams.Publisher<? extends @NonNull T7> source7, @NonNull org.reactivestreams.Publisher<? 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> combiner) Combines eight sourcePublisher
s by emitting an item that aggregates the latest values of each of the sourcePublisher
s each time an item is received from any of the sourcePublisher
s, where this aggregation is defined by a specified function.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull R>
@NonNull Flowable<R> Flowable.combineLatest
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull org.reactivestreams.Publisher<? extends @NonNull T5> source5, @NonNull org.reactivestreams.Publisher<? extends @NonNull T6> source6, @NonNull org.reactivestreams.Publisher<? extends @NonNull T7> source7, @NonNull org.reactivestreams.Publisher<? 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> combiner) Combines eight sourcePublisher
s by emitting an item that aggregates the latest values of each of the sourcePublisher
s each time an item is received from any of the sourcePublisher
s, where this aggregation is defined by a specified function.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull R>
@NonNull Flowable<R> Flowable.combineLatest
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull org.reactivestreams.Publisher<? extends @NonNull T5> source5, @NonNull org.reactivestreams.Publisher<? extends @NonNull T6> source6, @NonNull org.reactivestreams.Publisher<? extends @NonNull T7> source7, @NonNull org.reactivestreams.Publisher<? 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> combiner) Combines eight sourcePublisher
s by emitting an item that aggregates the latest values of each of the sourcePublisher
s each time an item is received from any of the sourcePublisher
s, where this aggregation is defined by a specified function.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull R>
@NonNull Flowable<R> Flowable.combineLatest
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull org.reactivestreams.Publisher<? extends @NonNull T5> source5, @NonNull org.reactivestreams.Publisher<? extends @NonNull T6> source6, @NonNull org.reactivestreams.Publisher<? extends @NonNull T7> source7, @NonNull org.reactivestreams.Publisher<? 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> combiner) Combines eight sourcePublisher
s by emitting an item that aggregates the latest values of each of the sourcePublisher
s each time an item is received from any of the sourcePublisher
s, where this aggregation is defined by a specified function.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull T9, @NonNull R>
@NonNull Flowable<R> Flowable.combineLatest
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull org.reactivestreams.Publisher<? extends @NonNull T5> source5, @NonNull org.reactivestreams.Publisher<? extends @NonNull T6> source6, @NonNull org.reactivestreams.Publisher<? extends @NonNull T7> source7, @NonNull org.reactivestreams.Publisher<? extends @NonNull T8> source8, @NonNull org.reactivestreams.Publisher<? 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> combiner) Combines nine sourcePublisher
s by emitting an item that aggregates the latest values of each of the sourcePublisher
s each time an item is received from any of the sourcePublisher
s, where this aggregation is defined by a specified function.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull T9, @NonNull R>
@NonNull Flowable<R> Flowable.combineLatest
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull org.reactivestreams.Publisher<? extends @NonNull T5> source5, @NonNull org.reactivestreams.Publisher<? extends @NonNull T6> source6, @NonNull org.reactivestreams.Publisher<? extends @NonNull T7> source7, @NonNull org.reactivestreams.Publisher<? extends @NonNull T8> source8, @NonNull org.reactivestreams.Publisher<? 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> combiner) Combines nine sourcePublisher
s by emitting an item that aggregates the latest values of each of the sourcePublisher
s each time an item is received from any of the sourcePublisher
s, where this aggregation is defined by a specified function.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull T9, @NonNull R>
@NonNull Flowable<R> Flowable.combineLatest
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull org.reactivestreams.Publisher<? extends @NonNull T5> source5, @NonNull org.reactivestreams.Publisher<? extends @NonNull T6> source6, @NonNull org.reactivestreams.Publisher<? extends @NonNull T7> source7, @NonNull org.reactivestreams.Publisher<? extends @NonNull T8> source8, @NonNull org.reactivestreams.Publisher<? 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> combiner) Combines nine sourcePublisher
s by emitting an item that aggregates the latest values of each of the sourcePublisher
s each time an item is received from any of the sourcePublisher
s, where this aggregation is defined by a specified function.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull T9, @NonNull R>
@NonNull Flowable<R> Flowable.combineLatest
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull org.reactivestreams.Publisher<? extends @NonNull T5> source5, @NonNull org.reactivestreams.Publisher<? extends @NonNull T6> source6, @NonNull org.reactivestreams.Publisher<? extends @NonNull T7> source7, @NonNull org.reactivestreams.Publisher<? extends @NonNull T8> source8, @NonNull org.reactivestreams.Publisher<? 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> combiner) Combines nine sourcePublisher
s by emitting an item that aggregates the latest values of each of the sourcePublisher
s each time an item is received from any of the sourcePublisher
s, where this aggregation is defined by a specified function.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull T9, @NonNull R>
@NonNull Flowable<R> Flowable.combineLatest
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull org.reactivestreams.Publisher<? extends @NonNull T5> source5, @NonNull org.reactivestreams.Publisher<? extends @NonNull T6> source6, @NonNull org.reactivestreams.Publisher<? extends @NonNull T7> source7, @NonNull org.reactivestreams.Publisher<? extends @NonNull T8> source8, @NonNull org.reactivestreams.Publisher<? 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> combiner) Combines nine sourcePublisher
s by emitting an item that aggregates the latest values of each of the sourcePublisher
s each time an item is received from any of the sourcePublisher
s, where this aggregation is defined by a specified function.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull T9, @NonNull R>
@NonNull Flowable<R> Flowable.combineLatest
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull org.reactivestreams.Publisher<? extends @NonNull T5> source5, @NonNull org.reactivestreams.Publisher<? extends @NonNull T6> source6, @NonNull org.reactivestreams.Publisher<? extends @NonNull T7> source7, @NonNull org.reactivestreams.Publisher<? extends @NonNull T8> source8, @NonNull org.reactivestreams.Publisher<? 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> combiner) Combines nine sourcePublisher
s by emitting an item that aggregates the latest values of each of the sourcePublisher
s each time an item is received from any of the sourcePublisher
s, where this aggregation is defined by a specified function.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull T9, @NonNull R>
@NonNull Flowable<R> Flowable.combineLatest
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull org.reactivestreams.Publisher<? extends @NonNull T5> source5, @NonNull org.reactivestreams.Publisher<? extends @NonNull T6> source6, @NonNull org.reactivestreams.Publisher<? extends @NonNull T7> source7, @NonNull org.reactivestreams.Publisher<? extends @NonNull T8> source8, @NonNull org.reactivestreams.Publisher<? 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> combiner) Combines nine sourcePublisher
s by emitting an item that aggregates the latest values of each of the sourcePublisher
s each time an item is received from any of the sourcePublisher
s, where this aggregation is defined by a specified function.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull T9, @NonNull R>
@NonNull Flowable<R> Flowable.combineLatest
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull org.reactivestreams.Publisher<? extends @NonNull T5> source5, @NonNull org.reactivestreams.Publisher<? extends @NonNull T6> source6, @NonNull org.reactivestreams.Publisher<? extends @NonNull T7> source7, @NonNull org.reactivestreams.Publisher<? extends @NonNull T8> source8, @NonNull org.reactivestreams.Publisher<? 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> combiner) Combines nine sourcePublisher
s by emitting an item that aggregates the latest values of each of the sourcePublisher
s each time an item is received from any of the sourcePublisher
s, where this aggregation is defined by a specified function.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull T9, @NonNull R>
@NonNull Flowable<R> Flowable.combineLatest
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull org.reactivestreams.Publisher<? extends @NonNull T5> source5, @NonNull org.reactivestreams.Publisher<? extends @NonNull T6> source6, @NonNull org.reactivestreams.Publisher<? extends @NonNull T7> source7, @NonNull org.reactivestreams.Publisher<? extends @NonNull T8> source8, @NonNull org.reactivestreams.Publisher<? 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> combiner) Combines nine sourcePublisher
s by emitting an item that aggregates the latest values of each of the sourcePublisher
s each time an item is received from any of the sourcePublisher
s, where this aggregation is defined by a specified function.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull T9, @NonNull R>
@NonNull Flowable<R> Flowable.combineLatest
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull org.reactivestreams.Publisher<? extends @NonNull T5> source5, @NonNull org.reactivestreams.Publisher<? extends @NonNull T6> source6, @NonNull org.reactivestreams.Publisher<? extends @NonNull T7> source7, @NonNull org.reactivestreams.Publisher<? extends @NonNull T8> source8, @NonNull org.reactivestreams.Publisher<? 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> combiner) Combines nine sourcePublisher
s by emitting an item that aggregates the latest values of each of the sourcePublisher
s each time an item is received from any of the sourcePublisher
s, where this aggregation is defined by a specified function.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull T9, @NonNull R>
@NonNull Observable<R> Observable.combineLatest
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull ObservableSource<? extends @NonNull T5> source5, @NonNull ObservableSource<? extends @NonNull T6> source6, @NonNull ObservableSource<? extends @NonNull T7> source7, @NonNull ObservableSource<? extends @NonNull T8> source8, @NonNull ObservableSource<? 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> combiner) Combines nine sourceObservableSource
s by emitting an item that aggregates the latest values of each of theObservableSource
s each time an item is received from any of theObservableSource
s, where this aggregation is defined by a specified function.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull T9, @NonNull R>
@NonNull Observable<R> Observable.combineLatest
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull ObservableSource<? extends @NonNull T5> source5, @NonNull ObservableSource<? extends @NonNull T6> source6, @NonNull ObservableSource<? extends @NonNull T7> source7, @NonNull ObservableSource<? extends @NonNull T8> source8, @NonNull ObservableSource<? 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> combiner) Combines nine sourceObservableSource
s by emitting an item that aggregates the latest values of each of theObservableSource
s each time an item is received from any of theObservableSource
s, where this aggregation is defined by a specified function.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull T9, @NonNull R>
@NonNull Observable<R> Observable.combineLatest
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull ObservableSource<? extends @NonNull T5> source5, @NonNull ObservableSource<? extends @NonNull T6> source6, @NonNull ObservableSource<? extends @NonNull T7> source7, @NonNull ObservableSource<? extends @NonNull T8> source8, @NonNull ObservableSource<? 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> combiner) Combines nine sourceObservableSource
s by emitting an item that aggregates the latest values of each of theObservableSource
s each time an item is received from any of theObservableSource
s, where this aggregation is defined by a specified function.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull T9, @NonNull R>
@NonNull Observable<R> Observable.combineLatest
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull ObservableSource<? extends @NonNull T5> source5, @NonNull ObservableSource<? extends @NonNull T6> source6, @NonNull ObservableSource<? extends @NonNull T7> source7, @NonNull ObservableSource<? extends @NonNull T8> source8, @NonNull ObservableSource<? 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> combiner) Combines nine sourceObservableSource
s by emitting an item that aggregates the latest values of each of theObservableSource
s each time an item is received from any of theObservableSource
s, where this aggregation is defined by a specified function.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull T9, @NonNull R>
@NonNull Observable<R> Observable.combineLatest
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull ObservableSource<? extends @NonNull T5> source5, @NonNull ObservableSource<? extends @NonNull T6> source6, @NonNull ObservableSource<? extends @NonNull T7> source7, @NonNull ObservableSource<? extends @NonNull T8> source8, @NonNull ObservableSource<? 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> combiner) Combines nine sourceObservableSource
s by emitting an item that aggregates the latest values of each of theObservableSource
s each time an item is received from any of theObservableSource
s, where this aggregation is defined by a specified function.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull T9, @NonNull R>
@NonNull Observable<R> Observable.combineLatest
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull ObservableSource<? extends @NonNull T5> source5, @NonNull ObservableSource<? extends @NonNull T6> source6, @NonNull ObservableSource<? extends @NonNull T7> source7, @NonNull ObservableSource<? extends @NonNull T8> source8, @NonNull ObservableSource<? 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> combiner) Combines nine sourceObservableSource
s by emitting an item that aggregates the latest values of each of theObservableSource
s each time an item is received from any of theObservableSource
s, where this aggregation is defined by a specified function.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull T9, @NonNull R>
@NonNull Observable<R> Observable.combineLatest
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull ObservableSource<? extends @NonNull T5> source5, @NonNull ObservableSource<? extends @NonNull T6> source6, @NonNull ObservableSource<? extends @NonNull T7> source7, @NonNull ObservableSource<? extends @NonNull T8> source8, @NonNull ObservableSource<? 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> combiner) Combines nine sourceObservableSource
s by emitting an item that aggregates the latest values of each of theObservableSource
s each time an item is received from any of theObservableSource
s, where this aggregation is defined by a specified function.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull T9, @NonNull R>
@NonNull Observable<R> Observable.combineLatest
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull ObservableSource<? extends @NonNull T5> source5, @NonNull ObservableSource<? extends @NonNull T6> source6, @NonNull ObservableSource<? extends @NonNull T7> source7, @NonNull ObservableSource<? extends @NonNull T8> source8, @NonNull ObservableSource<? 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> combiner) Combines nine sourceObservableSource
s by emitting an item that aggregates the latest values of each of theObservableSource
s each time an item is received from any of theObservableSource
s, where this aggregation is defined by a specified function.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull T9, @NonNull R>
@NonNull Observable<R> Observable.combineLatest
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull ObservableSource<? extends @NonNull T5> source5, @NonNull ObservableSource<? extends @NonNull T6> source6, @NonNull ObservableSource<? extends @NonNull T7> source7, @NonNull ObservableSource<? extends @NonNull T8> source8, @NonNull ObservableSource<? 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> combiner) Combines nine sourceObservableSource
s by emitting an item that aggregates the latest values of each of theObservableSource
s each time an item is received from any of theObservableSource
s, where this aggregation is defined by a specified function.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull T9, @NonNull R>
@NonNull Observable<R> Observable.combineLatest
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull ObservableSource<? extends @NonNull T5> source5, @NonNull ObservableSource<? extends @NonNull T6> source6, @NonNull ObservableSource<? extends @NonNull T7> source7, @NonNull ObservableSource<? extends @NonNull T8> source8, @NonNull ObservableSource<? 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> combiner) Combines nine sourceObservableSource
s by emitting an item that aggregates the latest values of each of theObservableSource
s each time an item is received from any of theObservableSource
s, where this aggregation is defined by a specified function.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull R>
@NonNull Observable<R> Observable.combineLatest
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull ObservableSource<? extends @NonNull T5> source5, @NonNull ObservableSource<? extends @NonNull T6> source6, @NonNull ObservableSource<? extends @NonNull T7> source7, @NonNull ObservableSource<? 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> combiner) Combines eight sourceObservableSource
s by emitting an item that aggregates the latest values of each of theObservableSource
s each time an item is received from any of theObservableSource
s, where this aggregation is defined by a specified function.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull R>
@NonNull Observable<R> Observable.combineLatest
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull ObservableSource<? extends @NonNull T5> source5, @NonNull ObservableSource<? extends @NonNull T6> source6, @NonNull ObservableSource<? extends @NonNull T7> source7, @NonNull ObservableSource<? 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> combiner) Combines eight sourceObservableSource
s by emitting an item that aggregates the latest values of each of theObservableSource
s each time an item is received from any of theObservableSource
s, where this aggregation is defined by a specified function.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull R>
@NonNull Observable<R> Observable.combineLatest
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull ObservableSource<? extends @NonNull T5> source5, @NonNull ObservableSource<? extends @NonNull T6> source6, @NonNull ObservableSource<? extends @NonNull T7> source7, @NonNull ObservableSource<? 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> combiner) Combines eight sourceObservableSource
s by emitting an item that aggregates the latest values of each of theObservableSource
s each time an item is received from any of theObservableSource
s, where this aggregation is defined by a specified function.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull R>
@NonNull Observable<R> Observable.combineLatest
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull ObservableSource<? extends @NonNull T5> source5, @NonNull ObservableSource<? extends @NonNull T6> source6, @NonNull ObservableSource<? extends @NonNull T7> source7, @NonNull ObservableSource<? 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> combiner) Combines eight sourceObservableSource
s by emitting an item that aggregates the latest values of each of theObservableSource
s each time an item is received from any of theObservableSource
s, where this aggregation is defined by a specified function.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull R>
@NonNull Observable<R> Observable.combineLatest
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull ObservableSource<? extends @NonNull T5> source5, @NonNull ObservableSource<? extends @NonNull T6> source6, @NonNull ObservableSource<? extends @NonNull T7> source7, @NonNull ObservableSource<? 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> combiner) Combines eight sourceObservableSource
s by emitting an item that aggregates the latest values of each of theObservableSource
s each time an item is received from any of theObservableSource
s, where this aggregation is defined by a specified function.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull R>
@NonNull Observable<R> Observable.combineLatest
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull ObservableSource<? extends @NonNull T5> source5, @NonNull ObservableSource<? extends @NonNull T6> source6, @NonNull ObservableSource<? extends @NonNull T7> source7, @NonNull ObservableSource<? 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> combiner) Combines eight sourceObservableSource
s by emitting an item that aggregates the latest values of each of theObservableSource
s each time an item is received from any of theObservableSource
s, where this aggregation is defined by a specified function.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull R>
@NonNull Observable<R> Observable.combineLatest
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull ObservableSource<? extends @NonNull T5> source5, @NonNull ObservableSource<? extends @NonNull T6> source6, @NonNull ObservableSource<? extends @NonNull T7> source7, @NonNull ObservableSource<? 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> combiner) Combines eight sourceObservableSource
s by emitting an item that aggregates the latest values of each of theObservableSource
s each time an item is received from any of theObservableSource
s, where this aggregation is defined by a specified function.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull R>
@NonNull Observable<R> Observable.combineLatest
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull ObservableSource<? extends @NonNull T5> source5, @NonNull ObservableSource<? extends @NonNull T6> source6, @NonNull ObservableSource<? extends @NonNull T7> source7, @NonNull ObservableSource<? 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> combiner) Combines eight sourceObservableSource
s by emitting an item that aggregates the latest values of each of theObservableSource
s each time an item is received from any of theObservableSource
s, where this aggregation is defined by a specified function.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull R>
@NonNull Observable<R> Observable.combineLatest
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull ObservableSource<? extends @NonNull T5> source5, @NonNull ObservableSource<? extends @NonNull T6> source6, @NonNull ObservableSource<? extends @NonNull T7> source7, @NonNull ObservableSource<? 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> combiner) Combines eight sourceObservableSource
s by emitting an item that aggregates the latest values of each of theObservableSource
s each time an item is received from any of theObservableSource
s, where this aggregation is defined by a specified function.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull R>
@NonNull Observable<R> Observable.combineLatest
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull ObservableSource<? extends @NonNull T5> source5, @NonNull ObservableSource<? extends @NonNull T6> source6, @NonNull ObservableSource<? 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> combiner) Combines seven sourceObservableSource
s by emitting an item that aggregates the latest values of each of theObservableSource
s each time an item is received from any of theObservableSource
s, where this aggregation is defined by a specified function.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull R>
@NonNull Observable<R> Observable.combineLatest
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull ObservableSource<? extends @NonNull T5> source5, @NonNull ObservableSource<? extends @NonNull T6> source6, @NonNull ObservableSource<? 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> combiner) Combines seven sourceObservableSource
s by emitting an item that aggregates the latest values of each of theObservableSource
s each time an item is received from any of theObservableSource
s, where this aggregation is defined by a specified function.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull R>
@NonNull Observable<R> Observable.combineLatest
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull ObservableSource<? extends @NonNull T5> source5, @NonNull ObservableSource<? extends @NonNull T6> source6, @NonNull ObservableSource<? 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> combiner) Combines seven sourceObservableSource
s by emitting an item that aggregates the latest values of each of theObservableSource
s each time an item is received from any of theObservableSource
s, where this aggregation is defined by a specified function.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull R>
@NonNull Observable<R> Observable.combineLatest
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull ObservableSource<? extends @NonNull T5> source5, @NonNull ObservableSource<? extends @NonNull T6> source6, @NonNull ObservableSource<? 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> combiner) Combines seven sourceObservableSource
s by emitting an item that aggregates the latest values of each of theObservableSource
s each time an item is received from any of theObservableSource
s, where this aggregation is defined by a specified function.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull R>
@NonNull Observable<R> Observable.combineLatest
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull ObservableSource<? extends @NonNull T5> source5, @NonNull ObservableSource<? extends @NonNull T6> source6, @NonNull ObservableSource<? 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> combiner) Combines seven sourceObservableSource
s by emitting an item that aggregates the latest values of each of theObservableSource
s each time an item is received from any of theObservableSource
s, where this aggregation is defined by a specified function.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull R>
@NonNull Observable<R> Observable.combineLatest
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull ObservableSource<? extends @NonNull T5> source5, @NonNull ObservableSource<? extends @NonNull T6> source6, @NonNull ObservableSource<? 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> combiner) Combines seven sourceObservableSource
s by emitting an item that aggregates the latest values of each of theObservableSource
s each time an item is received from any of theObservableSource
s, where this aggregation is defined by a specified function.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull R>
@NonNull Observable<R> Observable.combineLatest
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull ObservableSource<? extends @NonNull T5> source5, @NonNull ObservableSource<? extends @NonNull T6> source6, @NonNull ObservableSource<? 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> combiner) Combines seven sourceObservableSource
s by emitting an item that aggregates the latest values of each of theObservableSource
s each time an item is received from any of theObservableSource
s, where this aggregation is defined by a specified function.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull R>
@NonNull Observable<R> Observable.combineLatest
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull ObservableSource<? extends @NonNull T5> source5, @NonNull ObservableSource<? extends @NonNull T6> source6, @NonNull ObservableSource<? 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> combiner) Combines seven sourceObservableSource
s by emitting an item that aggregates the latest values of each of theObservableSource
s each time an item is received from any of theObservableSource
s, where this aggregation is defined by a specified function.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull R>
@NonNull Observable<R> Observable.combineLatest
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull ObservableSource<? extends @NonNull T5> source5, @NonNull ObservableSource<? 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> combiner) Combines six sourceObservableSource
s by emitting an item that aggregates the latest values of each of theObservableSource
s each time an item is received from any of theObservableSource
s, where this aggregation is defined by a specified function.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull R>
@NonNull Observable<R> Observable.combineLatest
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull ObservableSource<? extends @NonNull T5> source5, @NonNull ObservableSource<? 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> combiner) Combines six sourceObservableSource
s by emitting an item that aggregates the latest values of each of theObservableSource
s each time an item is received from any of theObservableSource
s, where this aggregation is defined by a specified function.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull R>
@NonNull Observable<R> Observable.combineLatest
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull ObservableSource<? extends @NonNull T5> source5, @NonNull ObservableSource<? 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> combiner) Combines six sourceObservableSource
s by emitting an item that aggregates the latest values of each of theObservableSource
s each time an item is received from any of theObservableSource
s, where this aggregation is defined by a specified function.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull R>
@NonNull Observable<R> Observable.combineLatest
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull ObservableSource<? extends @NonNull T5> source5, @NonNull ObservableSource<? 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> combiner) Combines six sourceObservableSource
s by emitting an item that aggregates the latest values of each of theObservableSource
s each time an item is received from any of theObservableSource
s, where this aggregation is defined by a specified function.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull R>
@NonNull Observable<R> Observable.combineLatest
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull ObservableSource<? extends @NonNull T5> source5, @NonNull ObservableSource<? 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> combiner) Combines six sourceObservableSource
s by emitting an item that aggregates the latest values of each of theObservableSource
s each time an item is received from any of theObservableSource
s, where this aggregation is defined by a specified function.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull R>
@NonNull Observable<R> Observable.combineLatest
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull ObservableSource<? extends @NonNull T5> source5, @NonNull ObservableSource<? 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> combiner) Combines six sourceObservableSource
s by emitting an item that aggregates the latest values of each of theObservableSource
s each time an item is received from any of theObservableSource
s, where this aggregation is defined by a specified function.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull R>
@NonNull Observable<R> Observable.combineLatest
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull ObservableSource<? extends @NonNull T5> source5, @NonNull ObservableSource<? 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> combiner) Combines six sourceObservableSource
s by emitting an item that aggregates the latest values of each of theObservableSource
s each time an item is received from any of theObservableSource
s, where this aggregation is defined by a specified function.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull R>
@NonNull Observable<R> Observable.combineLatest
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull ObservableSource<? extends @NonNull T5> source5, @NonNull Function5<? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, ? super @NonNull T4, ? super @NonNull T5, ? extends @NonNull R> combiner) Combines five sourceObservableSource
s by emitting an item that aggregates the latest values of each of theObservableSource
s each time an item is received from any of theObservableSource
s, where this aggregation is defined by a specified function.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull R>
@NonNull Observable<R> Observable.combineLatest
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull ObservableSource<? extends @NonNull T5> source5, @NonNull Function5<? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, ? super @NonNull T4, ? super @NonNull T5, ? extends @NonNull R> combiner) Combines five sourceObservableSource
s by emitting an item that aggregates the latest values of each of theObservableSource
s each time an item is received from any of theObservableSource
s, where this aggregation is defined by a specified function.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull R>
@NonNull Observable<R> Observable.combineLatest
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull ObservableSource<? extends @NonNull T5> source5, @NonNull Function5<? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, ? super @NonNull T4, ? super @NonNull T5, ? extends @NonNull R> combiner) Combines five sourceObservableSource
s by emitting an item that aggregates the latest values of each of theObservableSource
s each time an item is received from any of theObservableSource
s, where this aggregation is defined by a specified function.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull R>
@NonNull Observable<R> Observable.combineLatest
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull ObservableSource<? extends @NonNull T5> source5, @NonNull Function5<? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, ? super @NonNull T4, ? super @NonNull T5, ? extends @NonNull R> combiner) Combines five sourceObservableSource
s by emitting an item that aggregates the latest values of each of theObservableSource
s each time an item is received from any of theObservableSource
s, where this aggregation is defined by a specified function.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull R>
@NonNull Observable<R> Observable.combineLatest
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull ObservableSource<? extends @NonNull T5> source5, @NonNull Function5<? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, ? super @NonNull T4, ? super @NonNull T5, ? extends @NonNull R> combiner) Combines five sourceObservableSource
s by emitting an item that aggregates the latest values of each of theObservableSource
s each time an item is received from any of theObservableSource
s, where this aggregation is defined by a specified function.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull R>
@NonNull Observable<R> Observable.combineLatest
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull ObservableSource<? extends @NonNull T5> source5, @NonNull Function5<? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, ? super @NonNull T4, ? super @NonNull T5, ? extends @NonNull R> combiner) Combines five sourceObservableSource
s by emitting an item that aggregates the latest values of each of theObservableSource
s each time an item is received from any of theObservableSource
s, where this aggregation is defined by a specified function.Observable.combineLatest
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull Function4<? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, ? super @NonNull T4, ? extends @NonNull R> combiner) Combines four sourceObservableSource
s by emitting an item that aggregates the latest values of each of theObservableSource
s each time an item is received from any of theObservableSource
s, where this aggregation is defined by a specified function.Observable.combineLatest
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull Function4<? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, ? super @NonNull T4, ? extends @NonNull R> combiner) Combines four sourceObservableSource
s by emitting an item that aggregates the latest values of each of theObservableSource
s each time an item is received from any of theObservableSource
s, where this aggregation is defined by a specified function.Observable.combineLatest
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull Function4<? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, ? super @NonNull T4, ? extends @NonNull R> combiner) Combines four sourceObservableSource
s by emitting an item that aggregates the latest values of each of theObservableSource
s each time an item is received from any of theObservableSource
s, where this aggregation is defined by a specified function.Observable.combineLatest
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull Function4<? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, ? super @NonNull T4, ? extends @NonNull R> combiner) Combines four sourceObservableSource
s by emitting an item that aggregates the latest values of each of theObservableSource
s each time an item is received from any of theObservableSource
s, where this aggregation is defined by a specified function.Observable.combineLatest
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull Function4<? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, ? super @NonNull T4, ? extends @NonNull R> combiner) Combines four sourceObservableSource
s by emitting an item that aggregates the latest values of each of theObservableSource
s each time an item is received from any of theObservableSource
s, where this aggregation is defined by a specified function.Observable.combineLatest
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull Function3<? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, ? extends @NonNull R> combiner) Combines three sourceObservableSource
s by emitting an item that aggregates the latest values of each of theObservableSource
s each time an item is received from any of theObservableSource
s, where this aggregation is defined by a specified function.Observable.combineLatest
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull Function3<? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, ? extends @NonNull R> combiner) Combines three sourceObservableSource
s by emitting an item that aggregates the latest values of each of theObservableSource
s each time an item is received from any of theObservableSource
s, where this aggregation is defined by a specified function.Observable.combineLatest
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull Function3<? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, ? extends @NonNull R> combiner) Combines three sourceObservableSource
s by emitting an item that aggregates the latest values of each of theObservableSource
s each time an item is received from any of theObservableSource
s, where this aggregation is defined by a specified function.Observable.combineLatest
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull Function3<? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, ? extends @NonNull R> combiner) Combines three sourceObservableSource
s by emitting an item that aggregates the latest values of each of theObservableSource
s each time an item is received from any of theObservableSource
s, where this aggregation is defined by a specified function.static <@NonNull T1,
@NonNull T2, @NonNull R>
@NonNull Observable<R> Observable.combineLatest
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull BiFunction<? super @NonNull T1, ? super @NonNull T2, ? extends @NonNull R> combiner) Combines two sourceObservableSource
s by emitting an item that aggregates the latest values of each of theObservableSource
s each time an item is received from either of theObservableSource
s, where this aggregation is defined by a specified function.static <@NonNull T1,
@NonNull T2, @NonNull R>
@NonNull Observable<R> Observable.combineLatest
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull BiFunction<? super @NonNull T1, ? super @NonNull T2, ? extends @NonNull R> combiner) Combines two sourceObservableSource
s by emitting an item that aggregates the latest values of each of theObservableSource
s each time an item is received from either of theObservableSource
s, where this aggregation is defined by a specified function.static <@NonNull T1,
@NonNull T2, @NonNull R>
@NonNull Observable<R> Observable.combineLatest
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull BiFunction<? super @NonNull T1, ? super @NonNull T2, ? extends @NonNull R> combiner) Combines two sourceObservableSource
s by emitting an item that aggregates the latest values of each of theObservableSource
s each time an item is received from either of theObservableSource
s, where this aggregation is defined by a specified function.static <@NonNull T,
@NonNull R>
@NonNull Observable<R> Observable.combineLatest
(@NonNull Iterable<@NonNull ? extends ObservableSource<? extends @NonNull T>> sources, @NonNull Function<? super Object[], ? extends @NonNull R> combiner) Combines a collection of sourceObservableSource
s by emitting an item that aggregates the latest values of each of the returnedObservableSource
s each time an item is received from any of the returnedObservableSource
s, where this aggregation is defined by a specified function.static <@NonNull T,
@NonNull R>
@NonNull Observable<R> Observable.combineLatest
(@NonNull Iterable<@NonNull ? extends ObservableSource<? extends @NonNull T>> sources, @NonNull Function<? super Object[], ? extends @NonNull R> combiner) Combines a collection of sourceObservableSource
s by emitting an item that aggregates the latest values of each of the returnedObservableSource
s each time an item is received from any of the returnedObservableSource
s, where this aggregation is defined by a specified function.static <@NonNull T,
@NonNull R>
@NonNull Observable<R> Observable.combineLatest
(@NonNull Iterable<@NonNull ? extends ObservableSource<? extends @NonNull T>> sources, @NonNull Function<? super Object[], ? extends @NonNull R> combiner, int bufferSize) Combines anIterable
of sourceObservableSource
s by emitting an item that aggregates the latest values of each of the returnedObservableSource
s each time an item is received from any of the returnedObservableSource
s, where this aggregation is defined by a specified function.static <@NonNull T,
@NonNull R>
@NonNull Observable<R> Observable.combineLatest
(@NonNull Iterable<@NonNull ? extends ObservableSource<? extends @NonNull T>> sources, @NonNull Function<? super Object[], ? extends @NonNull R> combiner, int bufferSize) Combines anIterable
of sourceObservableSource
s by emitting an item that aggregates the latest values of each of the returnedObservableSource
s each time an item is received from any of the returnedObservableSource
s, where this aggregation is defined by a specified function.Flowable.combineLatestArray
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T>[] sources, @NonNull Function<? super Object[], ? extends @NonNull R> combiner) Combines a collection of sourcePublisher
s by emitting an item that aggregates the latest values of each of the sourcePublisher
s each time an item is received from any of the sourcePublisher
s, where this aggregation is defined by a specified function.Flowable.combineLatestArray
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T>[] sources, @NonNull Function<? super Object[], ? extends @NonNull R> combiner) Combines a collection of sourcePublisher
s by emitting an item that aggregates the latest values of each of the sourcePublisher
s each time an item is received from any of the sourcePublisher
s, where this aggregation is defined by a specified function.Flowable.combineLatestArray
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T>[] sources, @NonNull Function<? super Object[], ? extends @NonNull R> combiner, int bufferSize) Combines a collection of sourcePublisher
s by emitting an item that aggregates the latest values of each of the sourcePublisher
s each time an item is received from any of the sourcePublisher
s, where this aggregation is defined by a specified function.Flowable.combineLatestArray
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T>[] sources, @NonNull Function<? super Object[], ? extends @NonNull R> combiner, int bufferSize) Combines a collection of sourcePublisher
s by emitting an item that aggregates the latest values of each of the sourcePublisher
s each time an item is received from any of the sourcePublisher
s, where this aggregation is defined by a specified function.static <@NonNull T,
@NonNull R>
@NonNull Observable<R> Observable.combineLatestArray
(@NonNull ObservableSource<? extends @NonNull T>[] sources, @NonNull Function<? super Object[], ? extends @NonNull R> combiner) Combines an array of sourceObservableSource
s by emitting an item that aggregates the latest values of each of theObservableSource
s each time an item is received from any of the returnedObservableSource
s, where this aggregation is defined by a specified function.static <@NonNull T,
@NonNull R>
@NonNull Observable<R> Observable.combineLatestArray
(@NonNull ObservableSource<? extends @NonNull T>[] sources, @NonNull Function<? super Object[], ? extends @NonNull R> combiner) Combines an array of sourceObservableSource
s by emitting an item that aggregates the latest values of each of theObservableSource
s each time an item is received from any of the returnedObservableSource
s, where this aggregation is defined by a specified function.static <@NonNull T,
@NonNull R>
@NonNull Observable<R> Observable.combineLatestArray
(@NonNull ObservableSource<? extends @NonNull T>[] sources, @NonNull Function<? super Object[], ? extends @NonNull R> combiner, int bufferSize) Combines an array of sourceObservableSource
s by emitting an item that aggregates the latest values of each of theObservableSource
s each time an item is received from any of theObservableSource
s, where this aggregation is defined by a specified function.static <@NonNull T,
@NonNull R>
@NonNull Observable<R> Observable.combineLatestArray
(@NonNull ObservableSource<? extends @NonNull T>[] sources, @NonNull Function<? super Object[], ? extends @NonNull R> combiner, int bufferSize) Combines an array of sourceObservableSource
s by emitting an item that aggregates the latest values of each of theObservableSource
s each time an item is received from any of theObservableSource
s, where this aggregation is defined by a specified function.Flowable.combineLatestArrayDelayError
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T>[] sources, @NonNull Function<? super Object[], ? extends @NonNull R> combiner) Combines a collection of sourcePublisher
s by emitting an item that aggregates the latest values of each of the sourcePublisher
s each time an item is received from any of the sourcePublisher
s, where this aggregation is defined by a specified function.Flowable.combineLatestArrayDelayError
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T>[] sources, @NonNull Function<? super Object[], ? extends @NonNull R> combiner) Combines a collection of sourcePublisher
s by emitting an item that aggregates the latest values of each of the sourcePublisher
s each time an item is received from any of the sourcePublisher
s, where this aggregation is defined by a specified function.Flowable.combineLatestArrayDelayError
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T>[] sources, @NonNull Function<? super Object[], ? extends @NonNull R> combiner, int bufferSize) Combines a collection of sourcePublisher
s by emitting an item that aggregates the latest values of each of the sourcePublisher
s each time an item is received from any of the sourcePublisher
s, where this aggregation is defined by a specified function and delays any error from the sources until all sourcePublisher
s terminate.Flowable.combineLatestArrayDelayError
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T>[] sources, @NonNull Function<? super Object[], ? extends @NonNull R> combiner, int bufferSize) Combines a collection of sourcePublisher
s by emitting an item that aggregates the latest values of each of the sourcePublisher
s each time an item is received from any of the sourcePublisher
s, where this aggregation is defined by a specified function and delays any error from the sources until all sourcePublisher
s terminate.static <@NonNull T,
@NonNull R>
@NonNull Observable<R> Observable.combineLatestArrayDelayError
(@NonNull ObservableSource<? extends @NonNull T>[] sources, @NonNull Function<? super Object[], ? extends @NonNull R> combiner) Combines an array ofObservableSource
s by emitting an item that aggregates the latest values of each of theObservableSource
s each time an item is received from any of theObservableSource
s, where this aggregation is defined by a specified function.static <@NonNull T,
@NonNull R>
@NonNull Observable<R> Observable.combineLatestArrayDelayError
(@NonNull ObservableSource<? extends @NonNull T>[] sources, @NonNull Function<? super Object[], ? extends @NonNull R> combiner) Combines an array ofObservableSource
s by emitting an item that aggregates the latest values of each of theObservableSource
s each time an item is received from any of theObservableSource
s, where this aggregation is defined by a specified function.static <@NonNull T,
@NonNull R>
@NonNull Observable<R> Observable.combineLatestArrayDelayError
(@NonNull ObservableSource<? extends @NonNull T>[] sources, @NonNull Function<? super Object[], ? extends @NonNull R> combiner, int bufferSize) Combines an array ofObservableSource
s by emitting an item that aggregates the latest values of each of theObservableSource
s each time an item is received from any of theObservableSource
s, where this aggregation is defined by a specified function and delays any error from the sources until all sourceObservableSource
s terminate.static <@NonNull T,
@NonNull R>
@NonNull Observable<R> Observable.combineLatestArrayDelayError
(@NonNull ObservableSource<? extends @NonNull T>[] sources, @NonNull Function<? super Object[], ? extends @NonNull R> combiner, int bufferSize) Combines an array ofObservableSource
s by emitting an item that aggregates the latest values of each of theObservableSource
s each time an item is received from any of theObservableSource
s, where this aggregation is defined by a specified function and delays any error from the sources until all sourceObservableSource
s terminate.Flowable.combineLatestDelayError
(@NonNull Iterable<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources, @NonNull Function<? super Object[], ? extends @NonNull R> combiner) Combines a collection of sourcePublisher
s by emitting an item that aggregates the latest values of each of the sourcePublisher
s each time an item is received from any of the sourcePublisher
s, where this aggregation is defined by a specified function and delays any error from the sources until all sourcePublisher
s terminate.Flowable.combineLatestDelayError
(@NonNull Iterable<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources, @NonNull Function<? super Object[], ? extends @NonNull R> combiner) Combines a collection of sourcePublisher
s by emitting an item that aggregates the latest values of each of the sourcePublisher
s each time an item is received from any of the sourcePublisher
s, where this aggregation is defined by a specified function and delays any error from the sources until all sourcePublisher
s terminate.Flowable.combineLatestDelayError
(@NonNull Iterable<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources, @NonNull Function<? super Object[], ? extends @NonNull R> combiner, int bufferSize) Combines a collection of sourcePublisher
s by emitting an item that aggregates the latest values of each of the sourcePublisher
s each time an item is received from any of the sourcePublisher
s, where this aggregation is defined by a specified function and delays any error from the sources until all sourcePublisher
s terminate.Flowable.combineLatestDelayError
(@NonNull Iterable<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources, @NonNull Function<? super Object[], ? extends @NonNull R> combiner, int bufferSize) Combines a collection of sourcePublisher
s by emitting an item that aggregates the latest values of each of the sourcePublisher
s each time an item is received from any of the sourcePublisher
s, where this aggregation is defined by a specified function and delays any error from the sources until all sourcePublisher
s terminate.static <@NonNull T,
@NonNull R>
@NonNull Observable<R> Observable.combineLatestDelayError
(@NonNull Iterable<@NonNull ? extends ObservableSource<? extends @NonNull T>> sources, @NonNull Function<? super Object[], ? extends @NonNull R> combiner) Combines anIterable
ofObservableSource
s by emitting an item that aggregates the latest values of each of theObservableSource
s each time an item is received from any of theObservableSource
s, where this aggregation is defined by a specified function and delays any error from the sources until all sourceObservableSource
s terminate.static <@NonNull T,
@NonNull R>
@NonNull Observable<R> Observable.combineLatestDelayError
(@NonNull Iterable<@NonNull ? extends ObservableSource<? extends @NonNull T>> sources, @NonNull Function<? super Object[], ? extends @NonNull R> combiner) Combines anIterable
ofObservableSource
s by emitting an item that aggregates the latest values of each of theObservableSource
s each time an item is received from any of theObservableSource
s, where this aggregation is defined by a specified function and delays any error from the sources until all sourceObservableSource
s terminate.static <@NonNull T,
@NonNull R>
@NonNull Observable<R> Observable.combineLatestDelayError
(@NonNull Iterable<@NonNull ? extends ObservableSource<? extends @NonNull T>> sources, @NonNull Function<? super Object[], ? extends @NonNull R> combiner, int bufferSize) Combines anIterable
ofObservableSource
s by emitting an item that aggregates the latest values of each of theObservableSource
s each time an item is received from any of theObservableSource
s, where this aggregation is defined by a specified function and delays any error from the sources until all sourceObservableSource
s terminate.static <@NonNull T,
@NonNull R>
@NonNull Observable<R> Observable.combineLatestDelayError
(@NonNull Iterable<@NonNull ? extends ObservableSource<? extends @NonNull T>> sources, @NonNull Function<? super Object[], ? extends @NonNull R> combiner, int bufferSize) Combines anIterable
ofObservableSource
s by emitting an item that aggregates the latest values of each of theObservableSource
s each time an item is received from any of theObservableSource
s, where this aggregation is defined by a specified function and delays any error from the sources until all sourceObservableSource
s terminate.final @NonNull Completable
Completable.compose
(@NonNull CompletableTransformer transformer) Calls the given transformer function with this instance and returns the function's resultingCompletableSource
wrapped withCompletable.wrap(CompletableSource)
.Transform the currentFlowable
by applying a particularFlowableTransformer
function to it.Transform aMaybe
by applying a particularMaybeTransformer
function to it.final <@NonNull R>
@NonNull Observable<R> Observable.compose
(@NonNull ObservableTransformer<? super @NonNull T, ? extends @NonNull R> composer) Transform the currentObservable
by applying a particularObservableTransformer
function to it.Transform aSingle
by applying a particularSingleTransformer
function to it.static @NonNull Completable
Completable.concat
(@NonNull Iterable<@NonNull ? extends CompletableSource> sources) Returns aCompletable
which completes only when all sources complete, one after another.static @NonNull Completable
Completable.concat
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends CompletableSource> sources) Returns aCompletable
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 aCompletable
which completes only when all sources complete, one after another.Flowable.concat
(@NonNull Iterable<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources) Concatenates elements of eachPublisher
provided via anIterable
sequence into a single sequence of elements without interleaving them.Flowable.concat
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source2) Returns aFlowable
that emits the items emitted by twoPublisher
s, one after the other, without interleaving them.Flowable.concat
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source2) Returns aFlowable
that emits the items emitted by twoPublisher
s, one after the other, without interleaving them.Flowable.concat
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source3) Returns aFlowable
that emits the items emitted by threePublisher
s, one after the other, without interleaving them.Flowable.concat
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source3) Returns aFlowable
that emits the items emitted by threePublisher
s, one after the other, without interleaving them.Flowable.concat
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source3) Returns aFlowable
that emits the items emitted by threePublisher
s, one after the other, without interleaving them.Flowable.concat
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source4) Returns aFlowable
that emits the items emitted by fourPublisher
s, one after the other, without interleaving them.Flowable.concat
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source4) Returns aFlowable
that emits the items emitted by fourPublisher
s, one after the other, without interleaving them.Flowable.concat
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source4) Returns aFlowable
that emits the items emitted by fourPublisher
s, one after the other, without interleaving them.Flowable.concat
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source4) Returns aFlowable
that emits the items emitted by fourPublisher
s, one after the other, without interleaving them.Flowable.concat
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources) Returns aFlowable
that emits the items emitted by each of thePublisher
s emitted by the sourcePublisher
, one after the other, without interleaving them.Flowable.concat
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources, int prefetch) Returns aFlowable
that emits the items emitted by each of thePublisher
s emitted by the sourcePublisher
, one after the other, without interleaving them.Maybe.concat
(@NonNull MaybeSource<? extends @NonNull T> source1, @NonNull MaybeSource<? extends @NonNull T> source2) Returns aFlowable
that emits the items emitted by twoMaybeSource
s, one after the other.Maybe.concat
(@NonNull MaybeSource<? extends @NonNull T> source1, @NonNull MaybeSource<? extends @NonNull T> source2) Returns aFlowable
that emits the items emitted by twoMaybeSource
s, one after the other.Maybe.concat
(@NonNull MaybeSource<? extends @NonNull T> source1, @NonNull MaybeSource<? extends @NonNull T> source2, @NonNull MaybeSource<? extends @NonNull T> source3) Returns aFlowable
that emits the items emitted by threeMaybeSource
s, one after the other.Maybe.concat
(@NonNull MaybeSource<? extends @NonNull T> source1, @NonNull MaybeSource<? extends @NonNull T> source2, @NonNull MaybeSource<? extends @NonNull T> source3) Returns aFlowable
that emits the items emitted by threeMaybeSource
s, one after the other.Maybe.concat
(@NonNull MaybeSource<? extends @NonNull T> source1, @NonNull MaybeSource<? extends @NonNull T> source2, @NonNull MaybeSource<? extends @NonNull T> source3) Returns aFlowable
that emits the items emitted by threeMaybeSource
s, one after the other.Maybe.concat
(@NonNull MaybeSource<? extends @NonNull T> source1, @NonNull MaybeSource<? extends @NonNull T> source2, @NonNull MaybeSource<? extends @NonNull T> source3, @NonNull MaybeSource<? extends @NonNull T> source4) Returns aFlowable
that emits the items emitted by fourMaybeSource
s, one after the other.Maybe.concat
(@NonNull MaybeSource<? extends @NonNull T> source1, @NonNull MaybeSource<? extends @NonNull T> source2, @NonNull MaybeSource<? extends @NonNull T> source3, @NonNull MaybeSource<? extends @NonNull T> source4) Returns aFlowable
that emits the items emitted by fourMaybeSource
s, one after the other.Maybe.concat
(@NonNull MaybeSource<? extends @NonNull T> source1, @NonNull MaybeSource<? extends @NonNull T> source2, @NonNull MaybeSource<? extends @NonNull T> source3, @NonNull MaybeSource<? extends @NonNull T> source4) Returns aFlowable
that emits the items emitted by fourMaybeSource
s, one after the other.Maybe.concat
(@NonNull MaybeSource<? extends @NonNull T> source1, @NonNull MaybeSource<? extends @NonNull T> source2, @NonNull MaybeSource<? extends @NonNull T> source3, @NonNull MaybeSource<? extends @NonNull T> source4) Returns aFlowable
that emits the items emitted by fourMaybeSource
s, one after the other.Concatenate the single values, in a non-overlapping fashion, of theMaybeSource
sources provided by anIterable
sequence as aFlowable
sequence.Maybe.concat
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources) Concatenate the single values, in a non-overlapping fashion, of theMaybeSource
sources provided by aPublisher
sequence as aFlowable
sequence.Maybe.concat
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources, int prefetch) Concatenate the single values, in a non-overlapping fashion, of theMaybeSource
sources provided by aPublisher
sequence as aFlowable
sequence.static <@NonNull T>
@NonNull Observable<T> Observable.concat
(@NonNull ObservableSource<? extends ObservableSource<? extends @NonNull T>> sources) Returns anObservable
that emits the items emitted by each of theObservableSource
s emitted by theObservableSource
, one after the other, without interleaving them.static <@NonNull T>
@NonNull Observable<T> Observable.concat
(@NonNull ObservableSource<? extends ObservableSource<? extends @NonNull T>> sources, int bufferSize) Returns anObservable
that emits the items emitted by each of theObservableSource
s emitted by the outerObservableSource
, one after the other, without interleaving them.static <@NonNull T>
@NonNull Observable<T> Observable.concat
(@NonNull ObservableSource<? extends @NonNull T> source1, @NonNull ObservableSource<? extends @NonNull T> source2, @NonNull ObservableSource<? extends @NonNull T> source3) Returns anObservable
that emits the items emitted by threeObservableSource
s, one after the other, without interleaving them.static <@NonNull T>
@NonNull Observable<T> Observable.concat
(@NonNull ObservableSource<? extends @NonNull T> source1, @NonNull ObservableSource<? extends @NonNull T> source2, @NonNull ObservableSource<? extends @NonNull T> source3) Returns anObservable
that emits the items emitted by threeObservableSource
s, one after the other, without interleaving them.static <@NonNull T>
@NonNull Observable<T> Observable.concat
(@NonNull ObservableSource<? extends @NonNull T> source1, @NonNull ObservableSource<? extends @NonNull T> source2, @NonNull ObservableSource<? extends @NonNull T> source3) Returns anObservable
that emits the items emitted by threeObservableSource
s, one after the other, without interleaving them.static <@NonNull T>
@NonNull Observable<T> Observable.concat
(@NonNull ObservableSource<? extends @NonNull T> source1, @NonNull ObservableSource<? extends @NonNull T> source2, @NonNull ObservableSource<? extends @NonNull T> source3, @NonNull ObservableSource<? extends @NonNull T> source4) Returns anObservable
that emits the items emitted by fourObservableSource
s, one after the other, without interleaving them.static <@NonNull T>
@NonNull Observable<T> Observable.concat
(@NonNull ObservableSource<? extends @NonNull T> source1, @NonNull ObservableSource<? extends @NonNull T> source2, @NonNull ObservableSource<? extends @NonNull T> source3, @NonNull ObservableSource<? extends @NonNull T> source4) Returns anObservable
that emits the items emitted by fourObservableSource
s, one after the other, without interleaving them.static <@NonNull T>
@NonNull Observable<T> Observable.concat
(@NonNull ObservableSource<? extends @NonNull T> source1, @NonNull ObservableSource<? extends @NonNull T> source2, @NonNull ObservableSource<? extends @NonNull T> source3, @NonNull ObservableSource<? extends @NonNull T> source4) Returns anObservable
that emits the items emitted by fourObservableSource
s, one after the other, without interleaving them.static <@NonNull T>
@NonNull Observable<T> Observable.concat
(@NonNull ObservableSource<? extends @NonNull T> source1, @NonNull ObservableSource<? extends @NonNull T> source2, @NonNull ObservableSource<? extends @NonNull T> source3, @NonNull ObservableSource<? extends @NonNull T> source4) Returns anObservable
that emits the items emitted by fourObservableSource
s, one after the other, without interleaving them.static <@NonNull T>
@NonNull Observable<T> Observable.concat
(@NonNull ObservableSource<? extends @NonNull T> source1, ObservableSource<? extends @NonNull T> source2) Returns anObservable
that emits the items emitted by twoObservableSource
s, one after the other, without interleaving them.static <@NonNull T>
@NonNull Observable<T> Observable.concat
(@NonNull Iterable<@NonNull ? extends ObservableSource<? extends @NonNull T>> sources) Concatenates elements of eachObservableSource
provided via anIterable
sequence into a single sequence of elements without interleaving them.static <@NonNull T>
@NonNull Observable<T> Single.concat
(@NonNull ObservableSource<? extends SingleSource<? extends @NonNull T>> sources) Concatenate the single values, in a non-overlapping fashion, of theSingleSource
s provided by anObservableSource
sequence.Single.concat
(@NonNull SingleSource<? extends @NonNull T> source1, @NonNull SingleSource<? extends @NonNull T> source2) Returns aFlowable
that emits the items emitted by twoSingleSource
s, one after the other.Single.concat
(@NonNull SingleSource<? extends @NonNull T> source1, @NonNull SingleSource<? extends @NonNull T> source2) Returns aFlowable
that emits the items emitted by twoSingleSource
s, one after the other.Single.concat
(@NonNull SingleSource<? extends @NonNull T> source1, @NonNull SingleSource<? extends @NonNull T> source2, @NonNull SingleSource<? extends @NonNull T> source3) Returns aFlowable
that emits the items emitted by threeSingleSource
s, one after the other.Single.concat
(@NonNull SingleSource<? extends @NonNull T> source1, @NonNull SingleSource<? extends @NonNull T> source2, @NonNull SingleSource<? extends @NonNull T> source3) Returns aFlowable
that emits the items emitted by threeSingleSource
s, one after the other.Single.concat
(@NonNull SingleSource<? extends @NonNull T> source1, @NonNull SingleSource<? extends @NonNull T> source2, @NonNull SingleSource<? extends @NonNull T> source3) Returns aFlowable
that emits the items emitted by threeSingleSource
s, one after the other.Single.concat
(@NonNull SingleSource<? extends @NonNull T> source1, @NonNull SingleSource<? extends @NonNull T> source2, @NonNull SingleSource<? extends @NonNull T> source3, @NonNull SingleSource<? extends @NonNull T> source4) Returns aFlowable
that emits the items emitted by fourSingleSource
s, one after the other.Single.concat
(@NonNull SingleSource<? extends @NonNull T> source1, @NonNull SingleSource<? extends @NonNull T> source2, @NonNull SingleSource<? extends @NonNull T> source3, @NonNull SingleSource<? extends @NonNull T> source4) Returns aFlowable
that emits the items emitted by fourSingleSource
s, one after the other.Single.concat
(@NonNull SingleSource<? extends @NonNull T> source1, @NonNull SingleSource<? extends @NonNull T> source2, @NonNull SingleSource<? extends @NonNull T> source3, @NonNull SingleSource<? extends @NonNull T> source4) Returns aFlowable
that emits the items emitted by fourSingleSource
s, one after the other.Single.concat
(@NonNull SingleSource<? extends @NonNull T> source1, @NonNull SingleSource<? extends @NonNull T> source2, @NonNull SingleSource<? extends @NonNull T> source3, @NonNull SingleSource<? extends @NonNull T> source4) Returns aFlowable
that emits the items emitted by fourSingleSource
s, one after the other.Concatenate the single values, in a non-overlapping fashion, of theSingleSource
s provided by anIterable
sequence.Single.concat
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends SingleSource<? extends @NonNull T>> sources) Concatenate the single values, in a non-overlapping fashion, of theSingleSource
s provided by aPublisher
sequence.Single.concat
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends SingleSource<? extends @NonNull T>> sources, int prefetch) Concatenate the single values, in a non-overlapping fashion, of theSingleSource
s provided by aPublisher
sequence and prefetched by the specified amount.static @NonNull Completable
Completable.concatArray
(@NonNull CompletableSource... sources) Returns aCompletable
which completes only when all sources complete, one after another.Flowable.concatArray
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T>... sources) Concatenates a variable number ofPublisher
sources.Maybe.concatArray
(@NonNull MaybeSource<? extends @NonNull T>... sources) Concatenate the single values, in a non-overlapping fashion, of theMaybeSource
sources in the array as aFlowable
sequence.static <@NonNull T>
@NonNull Observable<T> Observable.concatArray
(@NonNull ObservableSource<? extends @NonNull T>... sources) Concatenates a variable number ofObservableSource
sources.Single.concatArray
(@NonNull SingleSource<? extends @NonNull T>... sources) Concatenate the single values, in a non-overlapping fashion, of theSingleSource
s provided in an array.static @NonNull Completable
Completable.concatArrayDelayError
(@NonNull CompletableSource... sources) Returns aCompletable
which completes only when all sources complete, one after another.Flowable.concatArrayDelayError
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T>... sources) Concatenates a variable number ofPublisher
sources and delays errors from any of them till all terminate.Maybe.concatArrayDelayError
(@NonNull MaybeSource<? extends @NonNull T>... sources) Concatenates a variable number ofMaybeSource
sources and delays errors from any of them till all terminate as aFlowable
sequence.static <@NonNull T>
@NonNull Observable<T> Observable.concatArrayDelayError
(@NonNull ObservableSource<? extends @NonNull T>... sources) Concatenates a variable number ofObservableSource
sources and delays errors from any of them till all terminate.Single.concatArrayDelayError
(@NonNull SingleSource<? extends @NonNull T>... sources) Concatenate the single values, in a non-overlapping fashion, of theSingleSource
s provided in an array.Flowable.concatArrayEager
(int maxConcurrency, int prefetch, @NonNull org.reactivestreams.Publisher<? extends @NonNull T>... sources) Concatenates an array ofPublisher
s eagerly into a single stream of values.Flowable.concatArrayEager
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T>... sources) Concatenates an array ofPublisher
s eagerly into a single stream of values.Maybe.concatArrayEager
(@NonNull MaybeSource<? extends @NonNull T>... sources) Concatenates a sequence ofMaybeSource
eagerly into aFlowable
sequence.static <@NonNull T>
@NonNull Observable<T> Observable.concatArrayEager
(int maxConcurrency, int bufferSize, @NonNull ObservableSource<? extends @NonNull T>... sources) Concatenates an array ofObservableSource
s eagerly into a single stream of values.static <@NonNull T>
@NonNull Observable<T> Observable.concatArrayEager
(@NonNull ObservableSource<? extends @NonNull T>... sources) Concatenates an array ofObservableSource
s eagerly into a single stream of values.Single.concatArrayEager
(@NonNull SingleSource<? extends @NonNull T>... sources) Concatenates a sequence ofSingleSource
eagerly into a single stream of values.Flowable.concatArrayEagerDelayError
(int maxConcurrency, int prefetch, @NonNull org.reactivestreams.Publisher<? extends @NonNull T>... sources) Concatenates an array ofPublisher
s eagerly into a single stream of values and delaying any errors until all sources terminate.Flowable.concatArrayEagerDelayError
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T>... sources) Concatenates an array ofPublisher
s eagerly into a single stream of values and delaying any errors until all sources terminate.Maybe.concatArrayEagerDelayError
(@NonNull MaybeSource<? extends @NonNull T>... sources) Concatenates a sequence ofMaybeSource
eagerly into aFlowable
sequence.static <@NonNull T>
@NonNull Observable<T> Observable.concatArrayEagerDelayError
(int maxConcurrency, int bufferSize, @NonNull ObservableSource<? extends @NonNull T>... sources) Concatenates an array ofObservableSource
s eagerly into a single stream of values and delaying any errors until all sources terminate.static <@NonNull T>
@NonNull Observable<T> Observable.concatArrayEagerDelayError
(@NonNull ObservableSource<? extends @NonNull T>... sources) Concatenates an array ofObservableSource
s eagerly into a single stream of values and delaying any errors until all sources terminate.Single.concatArrayEagerDelayError
(@NonNull SingleSource<? extends @NonNull T>... sources) Concatenates a sequence ofSingleSource
eagerly into a single stream of values.static @NonNull Completable
Completable.concatDelayError
(@NonNull Iterable<@NonNull ? extends CompletableSource> sources) Returns aCompletable
which completes only when all sources complete, one after another.static @NonNull Completable
Completable.concatDelayError
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends CompletableSource> sources) Returns aCompletable
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 aCompletable
which completes only when all sources complete, one after another.Flowable.concatDelayError
(@NonNull Iterable<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources) Concatenates theIterable
sequence ofPublisher
s into a single sequence by subscribing to eachPublisher
, one after the other, one at a time and delays any errors till the all innerPublisher
s terminate.Flowable.concatDelayError
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources) Concatenates thePublisher
sequence ofPublisher
s into a single sequence by subscribing to each innerPublisher
, one after the other, one at a time and delays any errors till the all inner and the outerPublisher
s terminate.Flowable.concatDelayError
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources, int prefetch, boolean tillTheEnd) Concatenates thePublisher
sequence ofPublisher
s into a single sequence by subscribing to each innerPublisher
, one after the other, one at a time and delays any errors till the all inner and the outerPublisher
s terminate.Maybe.concatDelayError
(@NonNull Iterable<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources) Concatenates theIterable
sequence ofMaybeSource
s into a single sequence by subscribing to eachMaybeSource
, one after the other, one at a time and delays any errors till the all innerMaybeSource
s terminate as aFlowable
sequence.Maybe.concatDelayError
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources) Concatenates thePublisher
sequence ofMaybeSource
s into a single sequence by subscribing to each innerMaybeSource
, one after the other, one at a time and delays any errors till the all inner and the outerPublisher
terminate as aFlowable
sequence.Maybe.concatDelayError
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources, int prefetch) Concatenates thePublisher
sequence ofMaybeSource
s into a single sequence by subscribing to each innerMaybeSource
, one after the other, one at a time and delays any errors till the all inner and the outerPublisher
terminate as aFlowable
sequence.static <@NonNull T>
@NonNull Observable<T> Observable.concatDelayError
(@NonNull ObservableSource<? extends ObservableSource<? extends @NonNull T>> sources) Concatenates theObservableSource
sequence ofObservableSource
s into a singleObservable
sequence by subscribing to each innerObservableSource
, one after the other, one at a time and delays any errors till the all inner and the outerObservableSource
s terminate.static <@NonNull T>
@NonNull Observable<T> Observable.concatDelayError
(@NonNull ObservableSource<? extends ObservableSource<? extends @NonNull T>> sources, int bufferSize, boolean tillTheEnd) Concatenates theObservableSource
sequence ofObservableSource
s into a single sequence by subscribing to each innerObservableSource
, one after the other, one at a time and delays any errors till the all inner and the outerObservableSource
s terminate.static <@NonNull T>
@NonNull Observable<T> Observable.concatDelayError
(@NonNull Iterable<@NonNull ? extends ObservableSource<? extends @NonNull T>> sources) Concatenates theIterable
sequence ofObservableSource
s into a singleObservable
sequence by subscribing to eachObservableSource
, one after the other, one at a time and delays any errors till the all innerObservableSource
s terminate.Single.concatDelayError
(@NonNull Iterable<@NonNull ? extends SingleSource<? extends @NonNull T>> sources) Concatenates theIterable
sequence ofSingleSource
s into a single sequence by subscribing to eachSingleSource
, one after the other, one at a time and delays any errors till the all innerSingleSource
s terminate as aFlowable
sequence.Single.concatDelayError
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends SingleSource<? extends @NonNull T>> sources) Concatenates thePublisher
sequence ofSingleSource
s into a single sequence by subscribing to each innerSingleSource
, one after the other, one at a time and delays any errors till the all inner and the outerPublisher
terminate as aFlowable
sequence.Single.concatDelayError
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends SingleSource<? extends @NonNull T>> sources, int prefetch) Concatenates thePublisher
sequence ofSingleSource
s into a single sequence by subscribing to each innerSingleSource
, one after the other, one at a time and delays any errors till the all inner and the outerPublisher
terminate as aFlowable
sequence.Flowable.concatEager
(@NonNull Iterable<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources) Concatenates a sequence ofPublisher
s eagerly into a single stream of values.Flowable.concatEager
(@NonNull Iterable<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources, int maxConcurrency, int prefetch) Concatenates a sequence ofPublisher
s eagerly into a single stream of values and runs a limited number of inner sequences at once.Flowable.concatEager
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources) Concatenates aPublisher
sequence ofPublisher
s eagerly into a single stream of values.Flowable.concatEager
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources, int maxConcurrency, int prefetch) Concatenates aPublisher
sequence ofPublisher
s eagerly into a single stream of values and runs a limited number of inner sequences at once.Maybe.concatEager
(@NonNull Iterable<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources) Concatenates a sequence ofMaybeSource
s eagerly into aFlowable
sequence.Maybe.concatEager
(@NonNull Iterable<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources, int maxConcurrency) Concatenates a sequence ofMaybeSource
s eagerly into aFlowable
sequence and runs a limited number of the inner sequences at once.Maybe.concatEager
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources) Maybe.concatEager
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources, int maxConcurrency) Concatenates aPublisher
sequence ofMaybeSource
s eagerly into aFlowable
sequence, running at most the given number of innerMaybeSource
s at once.static <@NonNull T>
@NonNull Observable<T> Observable.concatEager
(@NonNull ObservableSource<? extends ObservableSource<? extends @NonNull T>> sources) Concatenates anObservableSource
sequence ofObservableSource
s eagerly into a single stream of values.static <@NonNull T>
@NonNull Observable<T> Observable.concatEager
(@NonNull ObservableSource<? extends ObservableSource<? extends @NonNull T>> sources, int maxConcurrency, int bufferSize) Concatenates anObservableSource
sequence ofObservableSource
s eagerly into a single stream of values and runs a limited number of inner sequences at once.static <@NonNull T>
@NonNull Observable<T> Observable.concatEager
(@NonNull Iterable<@NonNull ? extends ObservableSource<? extends @NonNull T>> sources) Concatenates a sequence ofObservableSource
s eagerly into a single stream of values.static <@NonNull T>
@NonNull Observable<T> Observable.concatEager
(@NonNull Iterable<@NonNull ? extends ObservableSource<? extends @NonNull T>> sources, int maxConcurrency, int bufferSize) Concatenates a sequence ofObservableSource
s eagerly into a single stream of values and runs a limited number of inner sequences at once.Single.concatEager
(@NonNull Iterable<@NonNull ? extends SingleSource<? extends @NonNull T>> sources) Concatenates anIterable
sequence ofSingleSource
s eagerly into a single stream of values.Single.concatEager
(@NonNull Iterable<@NonNull ? extends SingleSource<? extends @NonNull T>> sources, int maxConcurrency) Concatenates anIterable
sequence ofSingleSource
s eagerly into a single stream of values and runs a limited number of the inner sources at once.Single.concatEager
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends SingleSource<? extends @NonNull T>> sources) Concatenates aPublisher
sequence ofSingleSource
s eagerly into a single stream of values.Single.concatEager
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends SingleSource<? extends @NonNull T>> sources, int maxConcurrency) Concatenates aPublisher
sequence ofSingleSource
s eagerly into a single stream of values and runs a limited number of those innerSingleSource
s at once.Flowable.concatEagerDelayError
(@NonNull Iterable<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources) Concatenates a sequence ofPublisher
s eagerly into a single stream of values, delaying errors until all the inner sequences terminate.Flowable.concatEagerDelayError
(@NonNull Iterable<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources, int maxConcurrency, int prefetch) Concatenates a sequence ofPublisher
s eagerly into a single stream of values, delaying errors until all the inner sequences terminate and runs a limited number of inner sequences at once.Flowable.concatEagerDelayError
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources) Concatenates aPublisher
sequence ofPublisher
s eagerly into a single stream of values, delaying errors until all the inner and the outer sequences terminate.Flowable.concatEagerDelayError
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources, int maxConcurrency, int prefetch) Concatenates aPublisher
sequence ofPublisher
s eagerly into a single stream of values, delaying errors until all the inner and outer sequences terminate and runs a limited number of inner sequences at once.Maybe.concatEagerDelayError
(@NonNull Iterable<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources) Concatenates a sequence ofMaybeSource
s eagerly into aFlowable
sequence, delaying errors until all innerMaybeSource
s terminate.Maybe.concatEagerDelayError
(@NonNull Iterable<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources, int maxConcurrency) Concatenates a sequence ofMaybeSource
s eagerly into aFlowable
sequence, delaying errors until all innerMaybeSource
s terminate and runs a limited number of innerMaybeSource
s at once.Maybe.concatEagerDelayError
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources) Concatenates aPublisher
sequence ofMaybeSource
s eagerly into aFlowable
sequence, delaying errors until all the inner and the outer sequence terminate.Maybe.concatEagerDelayError
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources, int maxConcurrency) Concatenates aPublisher
sequence ofMaybeSource
s eagerly into aFlowable
sequence, delaying errors until all the inner and the outer sequence terminate and runs a limited number of the innerMaybeSource
s at once.static <@NonNull T>
@NonNull Observable<T> Observable.concatEagerDelayError
(@NonNull ObservableSource<? extends ObservableSource<? extends @NonNull T>> sources) Concatenates anObservableSource
sequence ofObservableSource
s eagerly into a single stream of values, delaying errors until all the inner and the outer sequence terminate.static <@NonNull T>
@NonNull Observable<T> Observable.concatEagerDelayError
(@NonNull ObservableSource<? extends ObservableSource<? extends @NonNull T>> sources, int maxConcurrency, int bufferSize) Concatenates anObservableSource
sequence ofObservableSource
s eagerly into a single stream of values, delaying errors until all the inner and the outer sequence terminate and runs a limited number of inner sequences at once.static <@NonNull T>
@NonNull Observable<T> Observable.concatEagerDelayError
(@NonNull Iterable<@NonNull ? extends ObservableSource<? extends @NonNull T>> sources) Concatenates a sequence ofObservableSource
s eagerly into a single stream of values, delaying errors until all the inner sequences terminate.static <@NonNull T>
@NonNull Observable<T> Observable.concatEagerDelayError
(@NonNull Iterable<@NonNull ? extends ObservableSource<? extends @NonNull T>> sources, int maxConcurrency, int bufferSize) Concatenates a sequence ofObservableSource
s eagerly into a single stream of values, delaying errors until all the inner sequences terminate and runs a limited number of inner sequences at once.Single.concatEagerDelayError
(@NonNull Iterable<@NonNull ? extends SingleSource<? extends @NonNull T>> sources) Concatenates anIterable
sequence ofSingleSource
s eagerly into a single stream of values, delaying errors until all the inner sources terminate.Single.concatEagerDelayError
(@NonNull Iterable<@NonNull ? extends SingleSource<? extends @NonNull T>> sources, int maxConcurrency) Concatenates anIterable
sequence ofSingleSource
s eagerly into a single stream of values, delaying errors until all the inner sources terminate.Single.concatEagerDelayError
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends SingleSource<? extends @NonNull T>> sources) Concatenates aPublisher
sequence ofSingleSource
s eagerly into a single stream of values, delaying errors until all the inner and the outer sequence terminate.Single.concatEagerDelayError
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends SingleSource<? extends @NonNull T>> sources, int maxConcurrency) Concatenates aPublisher
sequence ofSingleSource
s eagerly into a single stream of values, running at most the specified number of those innerSingleSource
s at once and delaying errors until all the inner and the outer sequence terminate.Flowable.concatMap
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper) Returns a newFlowable
that emits items resulting from applying a function that you supply to each item emitted by the currentFlowable
, where that function returns aPublisher
, and then emitting the items that result from concatenating those returnedPublisher
s.Flowable.concatMap
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper, int prefetch) Returns a newFlowable
that emits items resulting from applying a function that you supply to each item emitted by the currentFlowable
, where that function returns aPublisher
, and then emitting the items that result from concatenating those returnedPublisher
s.Flowable.concatMap
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper, int prefetch, @NonNull Scheduler scheduler) Returns a newFlowable
that emits items resulting from applying a function (on a designated scheduler) that you supply to each item emitted by the currentFlowable
, where that function returns aPublisher
, and then emitting the items that result from concatenating those returnedPublisher
s.Flowable.concatMap
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper, int prefetch, @NonNull Scheduler scheduler) Returns a newFlowable
that emits items resulting from applying a function (on a designated scheduler) that you supply to each item emitted by the currentFlowable
, where that function returns aPublisher
, and then emitting the items that result from concatenating those returnedPublisher
s.Maybe.concatMap
(@NonNull Function<? super @NonNull T, ? extends MaybeSource<? extends @NonNull R>> mapper) Returns aMaybe
that is based on applying a specified function to the item emitted by the currentMaybe
, where that function returns aMaybeSource
.final <@NonNull R>
@NonNull Observable<R> Observable.concatMap
(@NonNull Function<? super @NonNull T, ? extends ObservableSource<? extends @NonNull R>> mapper) Returns a newObservable
that emits items resulting from applying a function that you supply to each item emitted by the currentObservable
, where that function returns anObservableSource
, and then emitting the items that result from concatenating those returnedObservableSource
s.final <@NonNull R>
@NonNull Observable<R> Observable.concatMap
(@NonNull Function<? super @NonNull T, ? extends ObservableSource<? extends @NonNull R>> mapper, int bufferSize) Returns a newObservable
that emits items resulting from applying a function that you supply to each item emitted by the currentObservable
, where that function returns anObservableSource
, and then emitting the items that result from concatenating those returnedObservableSource
s.final <@NonNull R>
@NonNull Observable<R> Observable.concatMap
(@NonNull Function<? super @NonNull T, ? extends ObservableSource<? extends @NonNull R>> mapper, int bufferSize, @NonNull Scheduler scheduler) Returns a newObservable
that emits items resulting from applying a function that you supply to each item emitted by the currentObservable
, where that function returns anObservableSource
, and then emitting the items that result from concatenating those returnedObservableSource
s.final <@NonNull R>
@NonNull Observable<R> Observable.concatMap
(@NonNull Function<? super @NonNull T, ? extends ObservableSource<? extends @NonNull R>> mapper, int bufferSize, @NonNull Scheduler scheduler) Returns a newObservable
that emits items resulting from applying a function that you supply to each item emitted by the currentObservable
, where that function returns anObservableSource
, and then emitting the items that result from concatenating those returnedObservableSource
s.Single.concatMap
(@NonNull Function<? super @NonNull T, ? extends SingleSource<? extends @NonNull R>> mapper) Returns aSingle
that is based on applying a specified function to the item emitted by the currentSingle
, where that function returns aSingleSource
.final @NonNull Completable
Flowable.concatMapCompletable
(@NonNull Function<? super @NonNull T, ? extends CompletableSource> mapper) Maps the upstream items intoCompletableSource
s 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 intoCompletableSource
s and subscribes to them one after the other completes.final @NonNull Completable
Maybe.concatMapCompletable
(@NonNull Function<? super @NonNull T, ? extends CompletableSource> mapper) Returns aCompletable
that completes based on applying a specified function to the item emitted by the currentMaybe
, where that function returns aCompletable
.final @NonNull Completable
Observable.concatMapCompletable
(@NonNull Function<? super @NonNull T, ? extends CompletableSource> mapper) Maps each element of the currentObservable
intoCompletableSource
s, subscribes to them one at a time in order and waits until the upstream and allCompletableSource
s complete.final @NonNull Completable
Observable.concatMapCompletable
(@NonNull Function<? super @NonNull T, ? extends CompletableSource> mapper, int capacityHint) Maps each element of the currentObservable
intoCompletableSource
s, subscribes to them one at a time in order and waits until the upstream and allCompletableSource
s complete.final @NonNull Completable
Single.concatMapCompletable
(@NonNull Function<? super @NonNull T, ? extends CompletableSource> mapper) Returns aCompletable
that completes based on applying a specified function to the item emitted by the currentSingle
, where that function returns aCompletableSource
.final @NonNull Completable
Flowable.concatMapCompletableDelayError
(@NonNull Function<? super @NonNull T, ? extends CompletableSource> mapper) Maps the upstream items intoCompletableSource
s and subscribes to them one after the other terminates, delaying all errors till both thisFlowable
and all innerCompletableSource
s terminate.final @NonNull Completable
Flowable.concatMapCompletableDelayError
(@NonNull Function<? super @NonNull T, ? extends CompletableSource> mapper, boolean tillTheEnd) Maps the upstream items intoCompletableSource
s and subscribes to them one after the other terminates, optionally delaying all errors till both thisFlowable
and all innerCompletableSource
s terminate.final @NonNull Completable
Flowable.concatMapCompletableDelayError
(@NonNull Function<? super @NonNull T, ? extends CompletableSource> mapper, boolean tillTheEnd, int prefetch) Maps the upstream items intoCompletableSource
s and subscribes to them one after the other terminates, optionally delaying all errors till both thisFlowable
and all innerCompletableSource
s terminate.final @NonNull Completable
Observable.concatMapCompletableDelayError
(@NonNull Function<? super @NonNull T, ? extends CompletableSource> mapper) Maps the upstream items intoCompletableSource
s and subscribes to them one after the other terminates, delaying all errors till both the currentObservable
and all innerCompletableSource
s terminate.final @NonNull Completable
Observable.concatMapCompletableDelayError
(@NonNull Function<? super @NonNull T, ? extends CompletableSource> mapper, boolean tillTheEnd) Maps the upstream items intoCompletableSource
s and subscribes to them one after the other terminates, optionally delaying all errors till both the currentObservable
and all innerCompletableSource
s terminate.final @NonNull Completable
Observable.concatMapCompletableDelayError
(@NonNull Function<? super @NonNull T, ? extends CompletableSource> mapper, boolean tillTheEnd, int bufferSize) Maps the upstream items intoCompletableSource
s and subscribes to them one after the other terminates, optionally delaying all errors till both the currentObservable
and all innerCompletableSource
s terminate.Flowable.concatMapDelayError
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper) Maps each of the items into aPublisher
, subscribes to them one after the other, one at a time and emits their values in order while delaying any error from either this or any of the innerPublisher
s till all of them terminate.Flowable.concatMapDelayError
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper, boolean tillTheEnd, int prefetch) Maps each of the items into aPublisher
, subscribes to them one after the other, one at a time and emits their values in order while delaying any error from either this or any of the innerPublisher
s till all of them terminate.Flowable.concatMapDelayError
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper, boolean tillTheEnd, int prefetch, @NonNull Scheduler scheduler) Maps each of the upstream items into aPublisher
, subscribes to them one after the other, one at a time and emits their values in order while executing the mapper function on the designated scheduler, delaying any error from either this or any of the innerPublisher
s till all of them terminate.Flowable.concatMapDelayError
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper, boolean tillTheEnd, int prefetch, @NonNull Scheduler scheduler) Maps each of the upstream items into aPublisher
, subscribes to them one after the other, one at a time and emits their values in order while executing the mapper function on the designated scheduler, delaying any error from either this or any of the innerPublisher
s till all of them terminate.final <@NonNull R>
@NonNull Observable<R> Observable.concatMapDelayError
(@NonNull Function<? super @NonNull T, ? extends ObservableSource<? extends @NonNull R>> mapper) Maps each of the items into anObservableSource
, subscribes to them one after the other, one at a time and emits their values in order while delaying any error from either this or any of the innerObservableSource
s till all of them terminate.final <@NonNull R>
@NonNull Observable<R> Observable.concatMapDelayError
(@NonNull Function<? super @NonNull T, ? extends ObservableSource<? extends @NonNull R>> mapper, boolean tillTheEnd, int bufferSize) Maps each of the items into anObservableSource
, subscribes to them one after the other, one at a time and emits their values in order while delaying any error from either this or any of the innerObservableSource
s till all of them terminate.final <@NonNull R>
@NonNull Observable<R> Observable.concatMapDelayError
(@NonNull Function<? super @NonNull T, ? extends ObservableSource<? extends @NonNull R>> mapper, boolean tillTheEnd, int bufferSize, @NonNull Scheduler scheduler) Maps each of the items into anObservableSource
, subscribes to them one after the other, one at a time and emits their values in order while delaying any error from either this or any of the innerObservableSource
s till all of them terminate.final <@NonNull R>
@NonNull Observable<R> Observable.concatMapDelayError
(@NonNull Function<? super @NonNull T, ? extends ObservableSource<? extends @NonNull R>> mapper, boolean tillTheEnd, int bufferSize, @NonNull Scheduler scheduler) Maps each of the items into anObservableSource
, subscribes to them one after the other, one at a time and emits their values in order while delaying any error from either this or any of the innerObservableSource
s till all of them terminate.Flowable.concatMapEager
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper) Maps a sequence of values intoPublisher
s and concatenates thesePublisher
s eagerly into a singlePublisher
.Flowable.concatMapEager
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper, int maxConcurrency, int prefetch) Maps a sequence of values intoPublisher
s and concatenates thesePublisher
s eagerly into a singlePublisher
.final <@NonNull R>
@NonNull Observable<R> Observable.concatMapEager
(@NonNull Function<? super @NonNull T, ? extends ObservableSource<? extends @NonNull R>> mapper) Maps a sequence of values intoObservableSource
s and concatenates theseObservableSource
s eagerly into a singleObservable
sequence.final <@NonNull R>
@NonNull Observable<R> Observable.concatMapEager
(@NonNull Function<? super @NonNull T, ? extends ObservableSource<? extends @NonNull R>> mapper, int maxConcurrency, int bufferSize) Maps a sequence of values intoObservableSource
s and concatenates theseObservableSource
s eagerly into a singleObservable
sequence.Flowable.concatMapEagerDelayError
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper, boolean tillTheEnd) Maps a sequence of values intoPublisher
s and concatenates thesePublisher
s eagerly into a singlePublisher
.Flowable.concatMapEagerDelayError
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper, boolean tillTheEnd, int maxConcurrency, int prefetch) Maps a sequence of values intoPublisher
s and concatenates thesePublisher
s eagerly into a singleFlowable
sequence.final <@NonNull R>
@NonNull Observable<R> Observable.concatMapEagerDelayError
(@NonNull Function<? super @NonNull T, ? extends ObservableSource<? extends @NonNull R>> mapper, boolean tillTheEnd) Maps a sequence of values intoObservableSource
s and concatenates theseObservableSource
s eagerly into a singleObservable
sequence.final <@NonNull R>
@NonNull Observable<R> Observable.concatMapEagerDelayError
(@NonNull Function<? super @NonNull T, ? extends ObservableSource<? extends @NonNull R>> mapper, boolean tillTheEnd, int maxConcurrency, int bufferSize) Maps a sequence of values intoObservableSource
s and concatenates theseObservableSource
s eagerly into a singleObservable
sequence.Flowable.concatMapIterable
(@NonNull Function<? super @NonNull T, @NonNull ? extends Iterable<? extends @NonNull U>> mapper) Returns aFlowable
that concatenate each item emitted by the currentFlowable
with the values in anIterable
corresponding to that item that is generated by a selector.Flowable.concatMapIterable
(@NonNull Function<? super @NonNull T, @NonNull ? extends Iterable<? extends @NonNull U>> mapper, int prefetch) Returns aFlowable
that concatenate each item emitted by the currentFlowable
with the values in anIterable
corresponding to that item that is generated by a selector.final <@NonNull U>
@NonNull Observable<U> Observable.concatMapIterable
(@NonNull Function<? super @NonNull T, @NonNull ? extends Iterable<? extends @NonNull U>> mapper) Returns anObservable
that concatenate each item emitted by the currentObservable
with the values in anIterable
corresponding to that item that is generated by a selector.Flowable.concatMapMaybe
(@NonNull Function<? super @NonNull T, ? extends MaybeSource<? extends @NonNull R>> mapper) Maps the upstream items intoMaybeSource
s and subscribes to them one after the other succeeds or completes, emits their success value if available or terminates immediately if either thisFlowable
or the current innerMaybeSource
fail.Flowable.concatMapMaybe
(@NonNull Function<? super @NonNull T, ? extends MaybeSource<? extends @NonNull R>> mapper, int prefetch) Maps the upstream items intoMaybeSource
s and subscribes to them one after the other succeeds or completes, emits their success value if available or terminates immediately if either thisFlowable
or the current innerMaybeSource
fail.final <@NonNull R>
@NonNull Observable<R> Observable.concatMapMaybe
(@NonNull Function<? super @NonNull T, ? extends MaybeSource<? extends @NonNull R>> mapper) Maps the upstream items intoMaybeSource
s and subscribes to them one after the other succeeds or completes, emits their success value if available or terminates immediately if either the currentObservable
or the current innerMaybeSource
fail.final <@NonNull R>
@NonNull Observable<R> Observable.concatMapMaybe
(@NonNull Function<? super @NonNull T, ? extends MaybeSource<? extends @NonNull R>> mapper, int bufferSize) Maps the upstream items intoMaybeSource
s and subscribes to them one after the other succeeds or completes, emits their success value if available or terminates immediately if either the currentObservable
or the current innerMaybeSource
fail.Single.concatMapMaybe
(@NonNull Function<? super @NonNull T, ? extends MaybeSource<? extends @NonNull R>> mapper) Returns aMaybe
that is based on applying a specified function to the item emitted by the currentSingle
, where that function returns aMaybeSource
.Flowable.concatMapMaybeDelayError
(@NonNull Function<? super @NonNull T, ? extends MaybeSource<? extends @NonNull R>> mapper) Maps the upstream items intoMaybeSource
s and subscribes to them one after the other terminates, emits their success value if available and delaying all errors till both thisFlowable
and all innerMaybeSource
s terminate.Flowable.concatMapMaybeDelayError
(@NonNull Function<? super @NonNull T, ? extends MaybeSource<? extends @NonNull R>> mapper, boolean tillTheEnd) Maps the upstream items intoMaybeSource
s and subscribes to them one after the other terminates, emits their success value if available and optionally delaying all errors till both thisFlowable
and all innerMaybeSource
s terminate.Flowable.concatMapMaybeDelayError
(@NonNull Function<? super @NonNull T, ? extends MaybeSource<? extends @NonNull R>> mapper, boolean tillTheEnd, int prefetch) Maps the upstream items intoMaybeSource
s and subscribes to them one after the other terminates, emits their success value if available and optionally delaying all errors till both thisFlowable
and all innerMaybeSource
s terminate.final <@NonNull R>
@NonNull Observable<R> Observable.concatMapMaybeDelayError
(@NonNull Function<? super @NonNull T, ? extends MaybeSource<? extends @NonNull R>> mapper) Maps the upstream items intoMaybeSource
s and subscribes to them one after the other terminates, emits their success value if available and delaying all errors till both the currentObservable
and all innerMaybeSource
s terminate.final <@NonNull R>
@NonNull Observable<R> Observable.concatMapMaybeDelayError
(@NonNull Function<? super @NonNull T, ? extends MaybeSource<? extends @NonNull R>> mapper, boolean tillTheEnd) Maps the upstream items intoMaybeSource
s and subscribes to them one after the other terminates, emits their success value if available and optionally delaying all errors till both the currentObservable
and all innerMaybeSource
s terminate.final <@NonNull R>
@NonNull Observable<R> Observable.concatMapMaybeDelayError
(@NonNull Function<? super @NonNull T, ? extends MaybeSource<? extends @NonNull R>> mapper, boolean tillTheEnd, int bufferSize) Maps the upstream items intoMaybeSource
s and subscribes to them one after the other terminates, emits their success value if available and optionally delaying all errors till both the currentObservable
and all innerMaybeSource
s terminate.Flowable.concatMapSingle
(@NonNull Function<? super @NonNull T, ? extends SingleSource<? extends @NonNull R>> mapper) Maps the upstream items intoSingleSource
s and subscribes to them one after the other succeeds, emits their success values or terminates immediately if either thisFlowable
or the current innerSingleSource
fail.Flowable.concatMapSingle
(@NonNull Function<? super @NonNull T, ? extends SingleSource<? extends @NonNull R>> mapper, int prefetch) Maps the upstream items intoSingleSource
s and subscribes to them one after the other succeeds, emits their success values or terminates immediately if either thisFlowable
or the current innerSingleSource
fail.Maybe.concatMapSingle
(@NonNull Function<? super @NonNull T, ? extends SingleSource<? extends @NonNull R>> mapper) Returns aMaybe
based on applying a specified function to the item emitted by the currentMaybe
, where that function returns aSingle
.final <@NonNull R>
@NonNull Observable<R> Observable.concatMapSingle
(@NonNull Function<? super @NonNull T, ? extends SingleSource<? extends @NonNull R>> mapper) Maps the upstream items intoSingleSource
s and subscribes to them one after the other succeeds, emits their success values or terminates immediately if either the currentObservable
or the current innerSingleSource
fail.final <@NonNull R>
@NonNull Observable<R> Observable.concatMapSingle
(@NonNull Function<? super @NonNull T, ? extends SingleSource<? extends @NonNull R>> mapper, int bufferSize) Maps the upstream items intoSingleSource
s and subscribes to them one after the other succeeds, emits their success values or terminates immediately if either the currentObservable
or the current innerSingleSource
fail.Flowable.concatMapSingleDelayError
(@NonNull Function<? super @NonNull T, ? extends SingleSource<? extends @NonNull R>> mapper) Maps the upstream items intoSingleSource
s and subscribes to them one after the other succeeds or fails, emits their success values and delays all errors till both thisFlowable
and all innerSingleSource
s terminate.Flowable.concatMapSingleDelayError
(@NonNull Function<? super @NonNull T, ? extends SingleSource<? extends @NonNull R>> mapper, boolean tillTheEnd) Maps the upstream items intoSingleSource
s and subscribes to them one after the other succeeds or fails, emits their success values and optionally delays all errors till both thisFlowable
and all innerSingleSource
s terminate.Flowable.concatMapSingleDelayError
(@NonNull Function<? super @NonNull T, ? extends SingleSource<? extends @NonNull R>> mapper, boolean tillTheEnd, int prefetch) Maps the upstream items intoSingleSource
s and subscribes to them one after the other succeeds or fails, emits their success values and optionally delays errors till both thisFlowable
and all innerSingleSource
s terminate.final <@NonNull R>
@NonNull Observable<R> Observable.concatMapSingleDelayError
(@NonNull Function<? super @NonNull T, ? extends SingleSource<? extends @NonNull R>> mapper) Maps the upstream items intoSingleSource
s and subscribes to them one after the other succeeds or fails, emits their success values and delays all errors till both the currentObservable
and all innerSingleSource
s terminate.final <@NonNull R>
@NonNull Observable<R> Observable.concatMapSingleDelayError
(@NonNull Function<? super @NonNull T, ? extends SingleSource<? extends @NonNull R>> mapper, boolean tillTheEnd) Maps the upstream items intoSingleSource
s and subscribes to them one after the other succeeds or fails, emits their success values and optionally delays all errors till both the currentObservable
and all innerSingleSource
s terminate.final <@NonNull R>
@NonNull Observable<R> Observable.concatMapSingleDelayError
(@NonNull Function<? super @NonNull T, ? extends SingleSource<? extends @NonNull R>> mapper, boolean tillTheEnd, int bufferSize) Maps the upstream items intoSingleSource
s and subscribes to them one after the other succeeds or fails, emits their success values and optionally delays errors till both the currentObservable
and all innerSingleSource
s terminate.Flowable.concatMapStream
(@NonNull Function<? super @NonNull T, @NonNull ? extends Stream<? extends @NonNull R>> mapper) Maps each upstream item into aStream
and emits theStream
's items to the downstream in a sequential fashion.Flowable.concatMapStream
(@NonNull Function<? super @NonNull T, @NonNull ? extends Stream<? extends @NonNull R>> mapper, int prefetch) Maps each upstream item into aStream
and emits theStream
's items to the downstream in a sequential fashion.final <@NonNull R>
@NonNull Observable<R> Observable.concatMapStream
(@NonNull Function<? super @NonNull T, @NonNull ? extends Stream<? extends @NonNull R>> mapper) Maps each upstream item into aStream
and emits theStream
's items to the downstream in a sequential fashion.final @NonNull Completable
Completable.concatWith
(@NonNull CompletableSource other) Concatenates thisCompletable
with anotherCompletableSource
.Flowable.concatWith
(@NonNull CompletableSource other) Returns aFlowable
that emits items from thisFlowable
and when it completes normally, the otherCompletableSource
is subscribed to and the returnedFlowable
emits its terminal events.Flowable.concatWith
(@NonNull MaybeSource<? extends @NonNull T> other) Returns aFlowable
that emits the items from thisFlowable
followed by the success item or terminal events of the otherMaybeSource
.Flowable.concatWith
(@NonNull SingleSource<? extends @NonNull T> other) Returns aFlowable
that emits the items from thisFlowable
followed by the success item or error event of the otherSingleSource
.Flowable.concatWith
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T> other) Returns aFlowable
that emits the items emitted from the currentFlowable
, then the next, one after the other, without interleaving them.Maybe.concatWith
(@NonNull MaybeSource<? extends @NonNull T> other) Returns aFlowable
that emits the items emitted from the currentMaybe
, then theother
MaybeSource
, one after the other, without interleaving them.final @NonNull Observable
<T> Observable.concatWith
(@NonNull CompletableSource other) Returns anObservable
that emits items from the currentObservable
and when it completes normally, the otherCompletableSource
is subscribed to and the returnedObservable
emits its terminal events.final @NonNull Observable
<T> Observable.concatWith
(@NonNull MaybeSource<? extends @NonNull T> other) Returns anObservable
that emits the items from the currentObservable
followed by the success item or terminal events of the otherMaybeSource
.final @NonNull Observable
<T> Observable.concatWith
(@NonNull ObservableSource<? extends @NonNull T> other) Returns anObservable
that first emits the items emitted from the currentObservable
, then items from theother
ObservableSource
without interleaving them.final @NonNull Observable
<T> Observable.concatWith
(@NonNull SingleSource<? extends @NonNull T> other) Returns anObservable
that emits the items from the currentObservable
followed by the success item or error event of theother
SingleSource
.Single.concatWith
(@NonNull SingleSource<? extends @NonNull T> other) Returns aFlowable
that emits the item emitted by the currentSingle
, then the item emitted by the specifiedSingleSource
.Signalstrue
if the currentSingle
signals a success value that isObject.equals(Object)
with the value provided.Signalstrue
if the currentSingle
signals a success value that is equal with the value provided by calling aBiPredicate
.Signalstrue
if the currentSingle
signals a success value that is equal with the value provided by calling aBiPredicate
.static @NonNull Completable
Completable.create
(@NonNull CompletableOnSubscribe source) Provides an API (via a coldCompletable
) that bridges the reactive world with the callback-style world.Flowable.create
(@NonNull FlowableOnSubscribe<@NonNull T> source, @NonNull BackpressureStrategy mode) Provides an API (via a coldFlowable
) that bridges the reactive world with the callback-style, generally non-backpressured world.Flowable.create
(@NonNull FlowableOnSubscribe<@NonNull T> source, @NonNull BackpressureStrategy mode) Provides an API (via a coldFlowable
) that bridges the reactive world with the callback-style, generally non-backpressured world.Maybe.create
(@NonNull MaybeOnSubscribe<@NonNull T> onSubscribe) Provides an API (via a coldMaybe
) that bridges the reactive world with the callback-style world.static <@NonNull T>
@NonNull Observable<T> Observable.create
(@NonNull ObservableOnSubscribe<@NonNull T> source) Provides an API (via a coldObservable
) that bridges the reactive world with the callback-style world.Single.create
(@NonNull SingleOnSubscribe<@NonNull T> source) Provides an API (via a coldSingle
) that bridges the reactive world with the callback-style world.static <T> @NonNull Notification
<T> Notification.createOnError
(@NonNull Throwable error) Constructs an onError notification containing the error.Returns aFlowable
that mirrors the currentFlowable
, except that it drops items emitted by the currentFlowable
that are followed by newer items before a timeout value expires.Returns aFlowable
that mirrors the currentFlowable
, except that it drops items emitted by the currentFlowable
that are followed by newer items before a timeout value expires on a specifiedScheduler
.Returns aFlowable
that mirrors the currentFlowable
, except that it drops items emitted by the currentFlowable
that are followed by newer items before a timeout value expires on a specifiedScheduler
.Flowable.debounce
(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, @NonNull Consumer<? super @NonNull T> onDropped) Returns aFlowable
that mirrors the currentFlowable
, except that it drops items emitted by the currentFlowable
that are followed by newer items before a timeout value expires on a specifiedScheduler
.Flowable.debounce
(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, @NonNull Consumer<? super @NonNull T> onDropped) Returns aFlowable
that mirrors the currentFlowable
, except that it drops items emitted by the currentFlowable
that are followed by newer items before a timeout value expires on a specifiedScheduler
.Flowable.debounce
(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, @NonNull Consumer<? super @NonNull T> onDropped) Returns aFlowable
that mirrors the currentFlowable
, except that it drops items emitted by the currentFlowable
that are followed by newer items before a timeout value expires on a specifiedScheduler
.Flowable.debounce
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<@NonNull U>> debounceIndicator) Returns aFlowable
that mirrors the currentFlowable
, except that it drops items emitted by the currentFlowable
that are followed by another item within a computed debounce duration.final @NonNull Observable
<T> Returns anObservable
that mirrors the currentObservable
, except that it drops items emitted by the currentObservable
that are followed by newer items before a timeout value expires.final @NonNull Observable
<T> Returns anObservable
that mirrors the currentObservable
, except that it drops items emitted by the currentObservable
that are followed by newer items before a timeout value expires on a specifiedScheduler
.final @NonNull Observable
<T> Returns anObservable
that mirrors the currentObservable
, except that it drops items emitted by the currentObservable
that are followed by newer items before a timeout value expires on a specifiedScheduler
.final @NonNull Observable
<T> Observable.debounce
(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, @NonNull Consumer<? super @NonNull T> onDropped) Returns anObservable
that mirrors the currentObservable
, except that it drops items emitted by the currentObservable
that are followed by newer items before a timeout value expires on a specifiedScheduler
.final @NonNull Observable
<T> Observable.debounce
(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, @NonNull Consumer<? super @NonNull T> onDropped) Returns anObservable
that mirrors the currentObservable
, except that it drops items emitted by the currentObservable
that are followed by newer items before a timeout value expires on a specifiedScheduler
.final @NonNull Observable
<T> Observable.debounce
(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, @NonNull Consumer<? super @NonNull T> onDropped) Returns anObservable
that mirrors the currentObservable
, except that it drops items emitted by the currentObservable
that are followed by newer items before a timeout value expires on a specifiedScheduler
.final <@NonNull U>
@NonNull Observable<T> Observable.debounce
(@NonNull Function<? super @NonNull T, ? extends ObservableSource<@NonNull U>> debounceIndicator) Returns anObservable
that mirrors the currentObservable
, except that it drops items emitted by the currentObservable
that are followed by another item within a computed debounce duration denoted by an item emission or completion from a generated innerObservableSource
for that original item.Flowable.defaultIfEmpty
(@NonNull T defaultItem) Returns aFlowable
that emits the items emitted by the currentFlowable
or a specified default item if the currentFlowable
is empty.Maybe.defaultIfEmpty
(@NonNull T defaultItem) Returns aSingle
that emits the item emitted by the currentMaybe
or a specified default item if the currentMaybe
is empty.final @NonNull Observable
<T> Observable.defaultIfEmpty
(@NonNull T defaultItem) Returns anObservable
that emits the items emitted by the currentObservable
or a specified default item if the currentObservable
is empty.static @NonNull Completable
Completable.defer
(@NonNull Supplier<? extends @NonNull CompletableSource> supplier) Defers the subscription to aCompletable
instance returned by a supplier.Flowable.defer
(@NonNull Supplier<? extends @NonNull org.reactivestreams.Publisher<? extends @NonNull T>> supplier) Returns aFlowable
that calls aPublisher
factory to create aPublisher
for each newSubscriber
that subscribes.Calls aSupplier
for each individualMaybeObserver
to return the actualMaybeSource
source to be subscribed to.static <@NonNull T>
@NonNull Observable<T> Observable.defer
(@NonNull Supplier<? extends @NonNull ObservableSource<? extends @NonNull T>> supplier) Returns anObservable
that calls anObservableSource
factory to create anObservableSource
for each newObserver
that subscribes.Calls aSupplier
for each individualSingleObserver
to return the actualSingleSource
to be subscribed to.final @NonNull Completable
Returns aCompletable
which delays the emission of the completion event by the given time.final @NonNull Completable
Returns aCompletable
which delays the emission of the completion event by the given time while running on the specifiedScheduler
.final @NonNull Completable
Returns aCompletable
which delays the emission of the completion event by the given time while running on the specifiedScheduler
.final @NonNull Completable
Completable.delay
(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean delayError) Returns aCompletable
which delays the emission of the completion event, and optionally the error as well, by the given time while running on the specifiedScheduler
.final @NonNull Completable
Completable.delay
(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean delayError) Returns aCompletable
which delays the emission of the completion event, and optionally the error as well, by the given time while running on the specifiedScheduler
.Returns aFlowable
that emits the items emitted by the currentFlowable
shifted forward in time by a specified delay.Returns aFlowable
that emits the items emitted by the currentFlowable
shifted forward in time by a specified delay.Returns aFlowable
that emits the items emitted by the currentFlowable
shifted forward in time by a specified delay.Returns aFlowable
that emits the items emitted by the currentFlowable
shifted forward in time by a specified delay.Returns aFlowable
that emits the items emitted by the currentFlowable
shifted forward in time by a specified delay.Returns aFlowable
that emits the items emitted by the currentFlowable
shifted forward in time by a specified delay.Flowable.delay
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<@NonNull U>> itemDelayIndicator) Returns aFlowable
that delays the emissions of the currentFlowable
via anotherPublisher
on a per-item basis.Flowable.delay
(@NonNull org.reactivestreams.Publisher<@NonNull U> subscriptionIndicator, @NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<@NonNull V>> itemDelayIndicator) Returns aFlowable
that delays the subscription to and emissions from the currentFlowable
via anotherPublisher
on a per-item basis.Flowable.delay
(@NonNull org.reactivestreams.Publisher<@NonNull U> subscriptionIndicator, @NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<@NonNull V>> itemDelayIndicator) Returns aFlowable
that delays the subscription to and emissions from the currentFlowable
via anotherPublisher
on a per-item basis.Returns aMaybe
that signals the events emitted by the currentMaybe
shifted forward in time by a specified delay.Returns aMaybe
that signals the events emitted by the currentMaybe
shifted forward in time by a specified delay.Returns aMaybe
that signals the events emitted by the currentMaybe
shifted forward in time by a specified delay.Returns aMaybe
that signals the events emitted by the currentMaybe
shifted forward in time by a specified delay.Returns aMaybe
that signals the events emitted by the currentMaybe
shifted forward in time by a specified delay running on the specifiedScheduler
.Returns aMaybe
that signals the events emitted by the currentMaybe
shifted forward in time by a specified delay running on the specifiedScheduler
.Delays the emission of thisMaybe
until the givenPublisher
signals an item or completes.final @NonNull Observable
<T> Returns anObservable
that emits the items emitted by the currentObservable
shifted forward in time by a specified delay.final @NonNull Observable
<T> Returns anObservable
that emits the items emitted by the currentObservable
shifted forward in time by a specified delay.final @NonNull Observable
<T> Returns anObservable
that emits the items emitted by the currentObservable
shifted forward in time by a specified delay.final @NonNull Observable
<T> Returns anObservable
that emits the items emitted by the currentObservable
shifted forward in time by a specified delay.final @NonNull Observable
<T> Observable.delay
(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean delayError) Returns anObservable
that emits the items emitted by the currentObservable
shifted forward in time by a specified delay.final @NonNull Observable
<T> Observable.delay
(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean delayError) Returns anObservable
that emits the items emitted by the currentObservable
shifted forward in time by a specified delay.final <@NonNull U,
@NonNull V>
@NonNull Observable<T> Observable.delay
(@NonNull ObservableSource<@NonNull U> subscriptionIndicator, @NonNull Function<? super @NonNull T, ? extends ObservableSource<@NonNull V>> itemDelayIndicator) Returns anObservable
that delays the subscription to and emissions from the currentObservable
viaObservableSource
s for the subscription itself and on a per-item basis.final <@NonNull U,
@NonNull V>
@NonNull Observable<T> Observable.delay
(@NonNull ObservableSource<@NonNull U> subscriptionIndicator, @NonNull Function<? super @NonNull T, ? extends ObservableSource<@NonNull V>> itemDelayIndicator) Returns anObservable
that delays the subscription to and emissions from the currentObservable
viaObservableSource
s for the subscription itself and on a per-item basis.final <@NonNull U>
@NonNull Observable<T> Observable.delay
(@NonNull Function<? super @NonNull T, ? extends ObservableSource<@NonNull U>> itemDelayIndicator) Returns anObservable
that delays the emissions of the currentObservable
via a per-item derivedObservableSource
's item emission or termination, on a per source item basis.Delays the emission of the success signal from the currentSingle
by the specified amount.Delays the emission of the success or error signal from the currentSingle
by the specified amount.Delays the emission of the success signal from the currentSingle
by the specified amount.Delays the emission of the success signal from the currentSingle
by the specified amount.Delays the emission of the success or error signal from the currentSingle
by the specified amount.Delays the emission of the success or error signal from the currentSingle
by the specified amount.final @NonNull Completable
Completable.delaySubscription
(long time, @NonNull TimeUnit unit) Returns aCompletable
that delays the subscription to the upstream by a given amount of time.final @NonNull Completable
Completable.delaySubscription
(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Returns aCompletable
that delays the subscription to the upstream by a given amount of time, both waiting and subscribing on a givenScheduler
.final @NonNull Completable
Completable.delaySubscription
(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Returns aCompletable
that delays the subscription to the upstream by a given amount of time, both waiting and subscribing on a givenScheduler
.Flowable.delaySubscription
(long time, @NonNull TimeUnit unit) Returns aFlowable
that delays the subscription to the currentFlowable
by a given amount of time.Flowable.delaySubscription
(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Returns aFlowable
that delays the subscription to the currentFlowable
by a given amount of time, both waiting and subscribing on a givenScheduler
.Flowable.delaySubscription
(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Returns aFlowable
that delays the subscription to the currentFlowable
by a given amount of time, both waiting and subscribing on a givenScheduler
.Flowable.delaySubscription
(@NonNull org.reactivestreams.Publisher<@NonNull U> subscriptionIndicator) Returns aFlowable
that delays the subscription to thisPublisher
until the otherPublisher
emits an element or completes normally.Maybe.delaySubscription
(long time, @NonNull TimeUnit unit) Returns aMaybe
that delays the subscription to the currentMaybe
by a given amount of time.Maybe.delaySubscription
(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Returns aMaybe
that delays the subscription to the currentMaybe
by a given amount of time, both waiting and subscribing on a givenScheduler
.Maybe.delaySubscription
(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Returns aMaybe
that delays the subscription to the currentMaybe
by a given amount of time, both waiting and subscribing on a givenScheduler
.Maybe.delaySubscription
(@NonNull org.reactivestreams.Publisher<@NonNull U> subscriptionIndicator) Returns aMaybe
that delays the subscription to thisMaybe
until the otherPublisher
emits an element or completes normally.final @NonNull Observable
<T> Observable.delaySubscription
(long time, @NonNull TimeUnit unit) Returns anObservable
that delays the subscription to the currentObservable
by a given amount of time.final @NonNull Observable
<T> Observable.delaySubscription
(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Returns anObservable
that delays the subscription to the currentObservable
by a given amount of time, both waiting and subscribing on a givenScheduler
.final @NonNull Observable
<T> Observable.delaySubscription
(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Returns anObservable
that delays the subscription to the currentObservable
by a given amount of time, both waiting and subscribing on a givenScheduler
.final <@NonNull U>
@NonNull Observable<T> Observable.delaySubscription
(@NonNull ObservableSource<@NonNull U> subscriptionIndicator) Returns anObservable
that delays the subscription to the currentObservable
until the otherObservableSource
emits an element or completes normally.Single.delaySubscription
(long time, @NonNull TimeUnit unit) Delays the actual subscription to the currentSingle
until the given time delay elapsed.Single.delaySubscription
(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Delays the actual subscription to the currentSingle
until the given time delay elapsed.Single.delaySubscription
(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Delays the actual subscription to the currentSingle
until the given time delay elapsed.Single.delaySubscription
(@NonNull CompletableSource subscriptionIndicator) Delays the actual subscription to the currentSingle
until the given otherCompletableSource
completes.Single.delaySubscription
(@NonNull ObservableSource<@NonNull U> subscriptionIndicator) Delays the actual subscription to the currentSingle
until the given otherObservableSource
signals its first value or completes.Single.delaySubscription
(@NonNull SingleSource<@NonNull U> subscriptionIndicator) Delays the actual subscription to the currentSingle
until the given otherSingleSource
signals success.Single.delaySubscription
(@NonNull org.reactivestreams.Publisher<@NonNull U> subscriptionIndicator) Delays the actual subscription to the currentSingle
until the given otherPublisher
signals its first value or completes.Flowable.dematerialize
(@NonNull Function<@NonNull ? super @NonNull T, @NonNull Notification<@NonNull R>> selector) Returns aFlowable
that reverses the effect ofmaterialize
by transforming theNotification
objects extracted from the source items via a selector function into their respectiveSubscriber
signal types.Maybe.dematerialize
(@NonNull Function<? super @NonNull T, @NonNull Notification<@NonNull R>> selector) Maps theNotification
success value of the currentMaybe
back into normalonSuccess
,onError
oronComplete
signals.final <@NonNull R>
@NonNull Observable<R> Observable.dematerialize
(@NonNull Function<? super @NonNull T, Notification<@NonNull R>> selector) Returns anObservable
that reverses the effect ofmaterialize
by transforming theNotification
objects extracted from the source items via a selector function into their respectiveObserver
signal types.Single.dematerialize
(@NonNull Function<? super @NonNull T, @NonNull Notification<@NonNull R>> selector) Maps theNotification
success value of the currentSingle
back into normalonSuccess
,onError
oronComplete
signals as aMaybe
source.Returns aFlowable
that emits all items emitted by the currentFlowable
that are distinct according to a key selector function and based onObject.equals(Object)
comparison of the objects returned by the key selector function.Flowable.distinct
(@NonNull Function<? super @NonNull T, @NonNull K> keySelector, @NonNull Supplier<? extends Collection<? super @NonNull K>> collectionSupplier) Returns aFlowable
that emits all items emitted by the currentFlowable
that are distinct according to a key selector function and based onObject.equals(Object)
comparison of the objects returned by the key selector function.Flowable.distinct
(@NonNull Function<? super @NonNull T, @NonNull K> keySelector, @NonNull Supplier<? extends Collection<? super @NonNull K>> collectionSupplier) Returns aFlowable
that emits all items emitted by the currentFlowable
that are distinct according to a key selector function and based onObject.equals(Object)
comparison of the objects returned by the key selector function.final <@NonNull K>
@NonNull Observable<T> Returns anObservable
that emits all items emitted by the currentObservable
that are distinct according to a key selector function and based onObject.equals(Object)
comparison of the objects returned by the key selector function.final <@NonNull K>
@NonNull Observable<T> Observable.distinct
(@NonNull Function<? super @NonNull T, @NonNull K> keySelector, @NonNull Supplier<? extends Collection<? super @NonNull K>> collectionSupplier) Returns anObservable
that emits all items emitted by the currentObservable
that are distinct according to a key selector function and based onObject.equals(Object)
comparison of the objects returned by the key selector function.final <@NonNull K>
@NonNull Observable<T> Observable.distinct
(@NonNull Function<? super @NonNull T, @NonNull K> keySelector, @NonNull Supplier<? extends Collection<? super @NonNull K>> collectionSupplier) Returns anObservable
that emits all items emitted by the currentObservable
that are distinct according to a key selector function and based onObject.equals(Object)
comparison of the objects returned by the key selector function.Flowable.distinctUntilChanged
(@NonNull BiPredicate<? super @NonNull T, ? super @NonNull T> comparer) Returns aFlowable
that emits all items emitted by the currentFlowable
that are distinct from their immediate predecessors when compared with each other via the provided comparator function.Returns aFlowable
that emits all items emitted by the currentFlowable
that are distinct from their immediate predecessors, according to a key selector function and based onObject.equals(Object)
comparison of those objects returned by the key selector function.final @NonNull Observable
<T> Observable.distinctUntilChanged
(@NonNull BiPredicate<? super @NonNull T, ? super @NonNull T> comparer) Returns anObservable
that emits all items emitted by the currentObservable
that are distinct from their immediate predecessors when compared with each other via the provided comparator function.final <@NonNull K>
@NonNull Observable<T> Returns anObservable
that emits all items emitted by the currentObservable
that are distinct from their immediate predecessors, according to a key selector function and based onObject.equals(Object)
comparison of those objects returned by the key selector function.Flowable.doAfterNext
(@NonNull Consumer<? super @NonNull T> onAfterNext) Calls the specified consumer with the current item after this item has been emitted to the downstream.final @NonNull Observable
<T> Observable.doAfterNext
(@NonNull Consumer<? super @NonNull T> onAfterNext) Calls the specifiedConsumer
with the current item after this item has been emitted to the downstream.Maybe.doAfterSuccess
(@NonNull Consumer<? super @NonNull T> onAfterSuccess) Calls the specifiedConsumer
with the success item after this item has been emitted to the downstream.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.final @NonNull Completable
Completable.doAfterTerminate
(@NonNull Action onAfterTerminate) Returns aCompletable
instance that calls the givenonAfterTerminate
Action
after thisCompletable
completes normally or with an exception.Flowable.doAfterTerminate
(@NonNull Action onAfterTerminate) Maybe.doAfterTerminate
(@NonNull Action onAfterTerminate) final @NonNull Observable
<T> Observable.doAfterTerminate
(@NonNull Action onAfterTerminate) Single.doAfterTerminate
(@NonNull Action onAfterTerminate) final @NonNull Completable
Calls the specifiedAction
after thisCompletable
signalsonError
oronComplete
or gets disposed by the downstream.Calls the specified action after thisFlowable
signalsonError
oronComplete
or gets canceled by the downstream.Calls the specified action after thisMaybe
signalsonSuccess
,onError
oronComplete
or gets disposed by the downstream.final @NonNull Observable
<T> Calls the specified action after the currentObservable
signalsonError
oronCompleted
or gets disposed by the downstream.Calls the specified action after thisSingle
signalsonSuccess
oronError
or gets disposed by the downstream.Flowable.doOnCancel
(@NonNull Action onCancel) Calls the cancelAction
if the downstream cancels the sequence.final @NonNull Completable
Completable.doOnComplete
(@NonNull Action onComplete) Flowable.doOnComplete
(@NonNull Action onComplete) Maybe.doOnComplete
(@NonNull Action onComplete) final @NonNull Observable
<T> Observable.doOnComplete
(@NonNull Action onComplete) final @NonNull Completable
Completable.doOnDispose
(@NonNull Action onDispose) Calls the sharedAction
if aCompletableObserver
subscribed to the currentCompletable
disposes the commonDisposable
it received viaonSubscribe
.Maybe.doOnDispose
(@NonNull Action onDispose) Calls the sharedAction
if aMaybeObserver
subscribed to the currentMaybe
disposes the commonDisposable
it received viaonSubscribe
.final @NonNull Observable
<T> Observable.doOnDispose
(@NonNull Action onDispose) Calls the given sharedAction
if the downstream disposes the sequence.Single.doOnDispose
(@NonNull Action onDispose) Calls the sharedAction
if aSingleObserver
subscribed to the currentSingle
disposes the commonDisposable
it received viaonSubscribe
.Flowable.doOnEach
(@NonNull Consumer<? super @NonNull T> onNext, @NonNull Consumer<? super Throwable> onError, Action onComplete, Action onAfterTerminate) Calls the appropriate onXXX consumer (shared between all subscribers) whenever a signal with the same type passes through, before forwarding them to downstream.Flowable.doOnEach
(@NonNull Consumer<? super @NonNull T> onNext, @NonNull Consumer<? super Throwable> onError, Action onComplete, Action onAfterTerminate) Calls the appropriate onXXX consumer (shared between all subscribers) whenever a signal with the same type passes through, before forwarding them to downstream.Invokes aConsumer
with aNotification
instances matching the signals emitted by the currentFlowable
before they are forwarded to the downstream.Calls the appropriate methods of the givenSubscriber
when the currentFlowable
signals events before forwarding it to the downstream.final @NonNull Observable
<T> Returns anObservable
that forwards the items and terminal events of the currentObservable
to itsObserver
s and to the given sharedObserver
instance.final @NonNull Observable
<T> Returns anObservable
that invokes aConsumer
with the appropriateNotification
object when the currentObservable
signals an item or terminates.private @NonNull Observable
<T> Observable.doOnEach
(@NonNull Consumer<? super @NonNull T> onNext, @NonNull Consumer<? super Throwable> onError, @NonNull Action onComplete, @NonNull Action onAfterTerminate) Calls the appropriateonXXX
consumer (shared between allObserver
s) whenever a signal with the same type passes through, before forwarding them to the downstream.private @NonNull Observable
<T> Observable.doOnEach
(@NonNull Consumer<? super @NonNull T> onNext, @NonNull Consumer<? super Throwable> onError, @NonNull Action onComplete, @NonNull Action onAfterTerminate) Calls the appropriateonXXX
consumer (shared between allObserver
s) whenever a signal with the same type passes through, before forwarding them to the downstream.private @NonNull Observable
<T> Observable.doOnEach
(@NonNull Consumer<? super @NonNull T> onNext, @NonNull Consumer<? super Throwable> onError, @NonNull Action onComplete, @NonNull Action onAfterTerminate) Calls the appropriateonXXX
consumer (shared between allObserver
s) whenever a signal with the same type passes through, before forwarding them to the downstream.private @NonNull Observable
<T> Observable.doOnEach
(@NonNull Consumer<? super @NonNull T> onNext, @NonNull Consumer<? super Throwable> onError, @NonNull Action onComplete, @NonNull Action onAfterTerminate) Calls the appropriateonXXX
consumer (shared between allObserver
s) whenever a signal with the same type passes through, before forwarding them to the downstream.final @NonNull Completable
Calls the sharedConsumer
with the error sent viaonError
for eachMaybeObserver
that subscribes to the currentMaybe
.final @NonNull Observable
<T> Calls the shared consumer with the error sent viaonError
for eachSingleObserver
that subscribes to the currentSingle
.final @NonNull Completable
Maybe.doOnEvent
(@NonNull BiConsumer<@Nullable ? super @NonNull T, @Nullable ? super Throwable> onEvent) Calls the givenonEvent
callback with the (success value,null
) for anonSuccess
, (null
, throwable) for anonError
or (null
,null
) for anonComplete
signal from thisMaybe
before delivering said signal to the downstream.Single.doOnEvent
(@NonNull BiConsumer<@Nullable ? super @NonNull T, @Nullable ? super Throwable> onEvent) Calls the shared consumer with the error sent viaonError
or the value viaonSuccess
for eachSingleObserver
that subscribes to the currentSingle
.final @NonNull Completable
Completable.doOnLifecycle
(@NonNull Consumer<? super Disposable> onSubscribe, @NonNull Action onDispose) Calls the appropriateonXXX
method (shared between allCompletableObserver
s) for the lifecycle events of the sequence (subscription, disposal).final @NonNull Completable
Completable.doOnLifecycle
(@NonNull Consumer<? super Disposable> onSubscribe, @NonNull Action onDispose) Calls the appropriateonXXX
method (shared between allCompletableObserver
s) for the lifecycle events of the sequence (subscription, disposal).Flowable.doOnLifecycle
(@NonNull Consumer<? super org.reactivestreams.Subscription> onSubscribe, @NonNull LongConsumer onRequest, @NonNull Action onCancel) Calls the appropriateonXXX
method (shared between allSubscriber
s) for the lifecycle events of the sequence (subscription, cancellation, requesting).Flowable.doOnLifecycle
(@NonNull Consumer<? super org.reactivestreams.Subscription> onSubscribe, @NonNull LongConsumer onRequest, @NonNull Action onCancel) Calls the appropriateonXXX
method (shared between allSubscriber
s) for the lifecycle events of the sequence (subscription, cancellation, requesting).Flowable.doOnLifecycle
(@NonNull Consumer<? super org.reactivestreams.Subscription> onSubscribe, @NonNull LongConsumer onRequest, @NonNull Action onCancel) Calls the appropriateonXXX
method (shared between allSubscriber
s) for the lifecycle events of the sequence (subscription, cancellation, requesting).Maybe.doOnLifecycle
(@NonNull Consumer<? super Disposable> onSubscribe, @NonNull Action onDispose) Calls the appropriateonXXX
method (shared between allMaybeObserver
s) for the lifecycle events of the sequence (subscription, disposal).Maybe.doOnLifecycle
(@NonNull Consumer<? super Disposable> onSubscribe, @NonNull Action onDispose) Calls the appropriateonXXX
method (shared between allMaybeObserver
s) for the lifecycle events of the sequence (subscription, disposal).final @NonNull Observable
<T> Observable.doOnLifecycle
(@NonNull Consumer<? super Disposable> onSubscribe, @NonNull Action onDispose) Calls the appropriateonXXX
method (shared between allObserver
s) for the lifecycle events of the sequence (subscription, disposal).final @NonNull Observable
<T> Observable.doOnLifecycle
(@NonNull Consumer<? super Disposable> onSubscribe, @NonNull Action onDispose) Calls the appropriateonXXX
method (shared between allObserver
s) for the lifecycle events of the sequence (subscription, disposal).Single.doOnLifecycle
(@NonNull Consumer<? super Disposable> onSubscribe, @NonNull Action onDispose) Calls the appropriateonXXX
method (shared between allSingleObserver
s) for the lifecycle events of the sequence (subscription, disposal).Single.doOnLifecycle
(@NonNull Consumer<? super Disposable> onSubscribe, @NonNull Action onDispose) Calls the appropriateonXXX
method (shared between allSingleObserver
s) for the lifecycle events of the sequence (subscription, disposal).Calls the givenConsumer
with the value emitted by the currentFlowable
before forwarding it to the downstream.final @NonNull Observable
<T> Calls the givenConsumer
with the value emitted by the currentObservable
before forwarding it to the downstream.Flowable.doOnRequest
(@NonNull LongConsumer onRequest) Calls the givenLongConsumer
with the request amount from the downstream before forwarding it to the currentFlowable
.final @NonNull Completable
Completable.doOnSubscribe
(@NonNull Consumer<? super Disposable> onSubscribe) Returns aCompletable
instance that calls the givenonSubscribe
callback with the disposable that the downstreamCompletableObserver
s receive upon subscription.Flowable.doOnSubscribe
(@NonNull Consumer<? super org.reactivestreams.Subscription> onSubscribe) Calls the givenConsumer
with theSubscription
provided by the currentFlowable
upon subscription from the downstream before forwarding it to the subscriber'sonSubscribe
method.Maybe.doOnSubscribe
(@NonNull Consumer<? super Disposable> onSubscribe) Calls the sharedConsumer
with theDisposable
sent through theonSubscribe
for eachMaybeObserver
that subscribes to the currentMaybe
.final @NonNull Observable
<T> Observable.doOnSubscribe
(@NonNull Consumer<? super Disposable> onSubscribe) Single.doOnSubscribe
(@NonNull Consumer<? super Disposable> onSubscribe) Calls the shared consumer with theDisposable
sent through theonSubscribe
for eachSingleObserver
that subscribes to the currentSingle
.Maybe.doOnSuccess
(@NonNull Consumer<? super @NonNull T> onSuccess) Calls the sharedConsumer
with the success value sent viaonSuccess
for eachMaybeObserver
that subscribes to the currentMaybe
.Single.doOnSuccess
(@NonNull Consumer<? super @NonNull T> onSuccess) Calls the shared consumer with the success value sent viaonSuccess
for eachSingleObserver
that subscribes to the currentSingle
.final @NonNull Completable
Completable.doOnTerminate
(@NonNull Action onTerminate) Returns aCompletable
instance that calls the givenonTerminate
Action
just before thisCompletable
completes normally or with an exception.Flowable.doOnTerminate
(@NonNull Action onTerminate) Calls the givenAction
when the currentFlowable
completes normally or with an error before those signals are forwarded to the downstream.Maybe.doOnTerminate
(@NonNull Action onTerminate) Returns aMaybe
instance that calls the given onTerminate callback just before thisMaybe
completes normally or with an exception.final @NonNull Observable
<T> Observable.doOnTerminate
(@NonNull Action onTerminate) Returns anObservable
so that it invokes an action when the currentObservable
callsonComplete
oronError
.Single.doOnTerminate
(@NonNull Action onTerminate) Returns aSingle
instance that calls the givenonTerminate
callback just before thisSingle
completes normally or with an exception.Returns aSingle
that emits the item found at a specified index in a sequence of emissions from thisFlowable
, or a default item if that index is out of range.Returns aSingle
that emits the item found at a specified index in a sequence of emissions from the currentObservable
, or a default item if that index is out of range.static @NonNull Completable
Creates aCompletable
which calls the given error supplier for each subscriber and emits its returnedThrowable
.static @NonNull Completable
Creates aCompletable
instance that emits the givenThrowable
exception to subscribers.Returns aFlowable
that invokes aSubscriber
'sonError
method when theSubscriber
subscribes to it.Returns aFlowable
that invokes aSubscriber
'sonError
method when theSubscriber
subscribes to it.Returns aMaybe
that invokes aMaybeObserver
'sonError
method when theMaybeObserver
subscribes to it.Returns aMaybe
that invokes a subscriber'sonError
method when the subscriber subscribes to it.static <@NonNull T>
@NonNull Observable<T> static <@NonNull T>
@NonNull Observable<T> Signals aThrowable
returned by the callback function for each individualSingleObserver
.Returns aSingle
that invokes a subscriber'sonError
method when the subscriber subscribes to it.Filters items emitted by the currentFlowable
by only emitting those that satisfy a specified predicate.Filters the success item of theMaybe
via a predicate function and emitting it if the predicate returnstrue
, completing otherwise.final @NonNull Observable
<T> Filters items emitted by the currentObservable
by only emitting those that satisfy a specifiedPredicate
.Filters the success item of theSingle
via a predicate function and emitting it if the predicate returnstrue
, completing otherwise.Returns aSingle
that emits only the very first item emitted by thisFlowable
, or a default item if thisFlowable
completes without emitting anything.Returns aSingle
that emits only the very first item emitted by the currentObservable
, or a default item if the currentObservable
completes without emitting any items.Flowable.flatMap
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper) Returns aFlowable
that emits items based on applying a function that you supply to each item emitted by the currentFlowable
, where that function returns aPublisher
, and then merging those resultingPublisher
s and emitting the results of this merger.Flowable.flatMap
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper, boolean delayErrors) Returns aFlowable
that emits items based on applying a function that you supply to each item emitted by the currentFlowable
, where that function returns aPublisher
, and then merging those resultingPublisher
s and emitting the results of this merger.Flowable.flatMap
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper, boolean delayErrors, int maxConcurrency) Returns aFlowable
that emits items based on applying a function that you supply to each item emitted by the currentFlowable
, where that function returns aPublisher
, and then merging those resultingPublisher
s and emitting the results of this merger, while limiting the maximum number of concurrent subscriptions to thesePublisher
s.Flowable.flatMap
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper, boolean delayErrors, int maxConcurrency, int bufferSize) Returns aFlowable
that emits items based on applying a function that you supply to each item emitted by the currentFlowable
, where that function returns aPublisher
, and then merging those resultingPublisher
s and emitting the results of this merger, while limiting the maximum number of concurrent subscriptions to thesePublisher
s.Flowable.flatMap
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper, int maxConcurrency) Returns aFlowable
that emits items based on applying a function that you supply to each item emitted by the currentFlowable
, where that function returns aPublisher
, and then merging those resultingPublisher
s and emitting the results of this merger, while limiting the maximum number of concurrent subscriptions to thesePublisher
s.Flowable.flatMap
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> onNextMapper, @NonNull Function<? super Throwable, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> onErrorMapper, @NonNull Supplier<? extends org.reactivestreams.Publisher<? extends @NonNull R>> onCompleteSupplier) Returns aFlowable
that applies a function to each item emitted or notification raised by the currentFlowable
and then flattens thePublisher
s returned from these functions and emits the resulting items.Flowable.flatMap
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> onNextMapper, @NonNull Function<? super Throwable, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> onErrorMapper, @NonNull Supplier<? extends org.reactivestreams.Publisher<? extends @NonNull R>> onCompleteSupplier) Returns aFlowable
that applies a function to each item emitted or notification raised by the currentFlowable
and then flattens thePublisher
s returned from these functions and emits the resulting items.Flowable.flatMap
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> onNextMapper, @NonNull Function<? super Throwable, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> onErrorMapper, @NonNull Supplier<? extends org.reactivestreams.Publisher<? extends @NonNull R>> onCompleteSupplier) Returns aFlowable
that applies a function to each item emitted or notification raised by the currentFlowable
and then flattens thePublisher
s returned from these functions and emits the resulting items.Flowable.flatMap
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> onNextMapper, @NonNull Function<Throwable, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> onErrorMapper, @NonNull Supplier<? extends org.reactivestreams.Publisher<? extends @NonNull R>> onCompleteSupplier, int maxConcurrency) Returns aFlowable
that applies a function to each item emitted or notification raised by the currentFlowable
and then flattens thePublisher
s returned from these functions and emits the resulting items, while limiting the maximum number of concurrent subscriptions to thesePublisher
s.Flowable.flatMap
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> onNextMapper, @NonNull Function<Throwable, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> onErrorMapper, @NonNull Supplier<? extends org.reactivestreams.Publisher<? extends @NonNull R>> onCompleteSupplier, int maxConcurrency) Returns aFlowable
that applies a function to each item emitted or notification raised by the currentFlowable
and then flattens thePublisher
s returned from these functions and emits the resulting items, while limiting the maximum number of concurrent subscriptions to thesePublisher
s.Flowable.flatMap
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> onNextMapper, @NonNull Function<Throwable, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> onErrorMapper, @NonNull Supplier<? extends org.reactivestreams.Publisher<? extends @NonNull R>> onCompleteSupplier, int maxConcurrency) Returns aFlowable
that applies a function to each item emitted or notification raised by the currentFlowable
and then flattens thePublisher
s returned from these functions and emits the resulting items, while limiting the maximum number of concurrent subscriptions to thesePublisher
s.Flowable.flatMap
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull U>> mapper, @NonNull BiFunction<? super @NonNull T, ? super @NonNull U, ? extends @NonNull R> combiner) Returns aFlowable
that emits the results of a specified function to the pair of values emitted by the currentFlowable
and a specified collectionPublisher
.Flowable.flatMap
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull U>> mapper, @NonNull BiFunction<? super @NonNull T, ? super @NonNull U, ? extends @NonNull R> combiner) Returns aFlowable
that emits the results of a specified function to the pair of values emitted by the currentFlowable
and a specified collectionPublisher
.Flowable.flatMap
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull U>> mapper, @NonNull BiFunction<? super @NonNull T, ? super @NonNull U, ? extends @NonNull R> combiner, boolean delayErrors) Returns aFlowable
that emits the results of a specified function to the pair of values emitted by the currentFlowable
and a specified innerPublisher
.Flowable.flatMap
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull U>> mapper, @NonNull BiFunction<? super @NonNull T, ? super @NonNull U, ? extends @NonNull R> combiner, boolean delayErrors) Returns aFlowable
that emits the results of a specified function to the pair of values emitted by the currentFlowable
and a specified innerPublisher
.Flowable.flatMap
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull U>> mapper, @NonNull BiFunction<? super @NonNull T, ? super @NonNull U, ? extends @NonNull R> combiner, boolean delayErrors, int maxConcurrency) Returns aFlowable
that emits the results of a specified function to the pair of values emitted by the currentFlowable
and a specified collectionPublisher
, while limiting the maximum number of concurrent subscriptions to thesePublisher
s.Flowable.flatMap
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull U>> mapper, @NonNull BiFunction<? super @NonNull T, ? super @NonNull U, ? extends @NonNull R> combiner, boolean delayErrors, int maxConcurrency) Returns aFlowable
that emits the results of a specified function to the pair of values emitted by the currentFlowable
and a specified collectionPublisher
, while limiting the maximum number of concurrent subscriptions to thesePublisher
s.Flowable.flatMap
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull U>> mapper, @NonNull BiFunction<? super @NonNull T, ? super @NonNull U, ? extends @NonNull R> combiner, boolean delayErrors, int maxConcurrency, int bufferSize) Returns aFlowable
that emits the results of a specified function to the pair of values emitted by the currentFlowable
and a specified collectionPublisher
, while limiting the maximum number of concurrent subscriptions to thesePublisher
s.Flowable.flatMap
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull U>> mapper, @NonNull BiFunction<? super @NonNull T, ? super @NonNull U, ? extends @NonNull R> combiner, boolean delayErrors, int maxConcurrency, int bufferSize) Returns aFlowable
that emits the results of a specified function to the pair of values emitted by the currentFlowable
and a specified collectionPublisher
, while limiting the maximum number of concurrent subscriptions to thesePublisher
s.Flowable.flatMap
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull U>> mapper, @NonNull BiFunction<? super @NonNull T, ? super @NonNull U, ? extends @NonNull R> combiner, int maxConcurrency) Returns aFlowable
that emits the results of a specified function to the pair of values emitted by the currentFlowable
and a specified collectionPublisher
, while limiting the maximum number of concurrent subscriptions to thesePublisher
s.Flowable.flatMap
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull U>> mapper, @NonNull BiFunction<? super @NonNull T, ? super @NonNull U, ? extends @NonNull R> combiner, int maxConcurrency) Returns aFlowable
that emits the results of a specified function to the pair of values emitted by the currentFlowable
and a specified collectionPublisher
, while limiting the maximum number of concurrent subscriptions to thesePublisher
s.Maybe.flatMap
(@NonNull Function<? super @NonNull T, ? extends MaybeSource<? extends @NonNull R>> mapper) Returns aMaybe
that is based on applying a specified function to the item emitted by the currentMaybe
, where that function returns aMaybeSource
.Maybe.flatMap
(@NonNull Function<? super @NonNull T, ? extends MaybeSource<? extends @NonNull R>> onSuccessMapper, @NonNull Function<? super Throwable, ? extends MaybeSource<? extends @NonNull R>> onErrorMapper, @NonNull Supplier<? extends MaybeSource<? extends @NonNull R>> onCompleteSupplier) Maps theonSuccess
,onError
oronComplete
signals of the currentMaybe
into aMaybeSource
and emits thatMaybeSource
's signals.Maybe.flatMap
(@NonNull Function<? super @NonNull T, ? extends MaybeSource<? extends @NonNull R>> onSuccessMapper, @NonNull Function<? super Throwable, ? extends MaybeSource<? extends @NonNull R>> onErrorMapper, @NonNull Supplier<? extends MaybeSource<? extends @NonNull R>> onCompleteSupplier) Maps theonSuccess
,onError
oronComplete
signals of the currentMaybe
into aMaybeSource
and emits thatMaybeSource
's signals.Maybe.flatMap
(@NonNull Function<? super @NonNull T, ? extends MaybeSource<? extends @NonNull R>> onSuccessMapper, @NonNull Function<? super Throwable, ? extends MaybeSource<? extends @NonNull R>> onErrorMapper, @NonNull Supplier<? extends MaybeSource<? extends @NonNull R>> onCompleteSupplier) Maps theonSuccess
,onError
oronComplete
signals of the currentMaybe
into aMaybeSource
and emits thatMaybeSource
's signals.Maybe.flatMap
(@NonNull Function<? super @NonNull T, ? extends MaybeSource<? extends @NonNull U>> mapper, @NonNull BiFunction<? super @NonNull T, ? super @NonNull U, ? extends @NonNull R> combiner) Returns aMaybe
that emits the results of a specified function to the pair of values emitted by the currentMaybe
and a specified mappedMaybeSource
.Maybe.flatMap
(@NonNull Function<? super @NonNull T, ? extends MaybeSource<? extends @NonNull U>> mapper, @NonNull BiFunction<? super @NonNull T, ? super @NonNull U, ? extends @NonNull R> combiner) Returns aMaybe
that emits the results of a specified function to the pair of values emitted by the currentMaybe
and a specified mappedMaybeSource
.final <@NonNull R>
@NonNull Observable<R> Observable.flatMap
(@NonNull Function<? super @NonNull T, ? extends ObservableSource<? extends @NonNull R>> mapper) Returns anObservable
that emits items based on applying a function that you supply to each item emitted by the currentObservable
, where that function returns anObservableSource
, and then merging those returnedObservableSource
s and emitting the results of this merger.final <@NonNull R>
@NonNull Observable<R> Observable.flatMap
(@NonNull Function<? super @NonNull T, ? extends ObservableSource<? extends @NonNull R>> mapper, boolean delayErrors) Returns anObservable
that emits items based on applying a function that you supply to each item emitted by the currentObservable
, where that function returns anObservableSource
, and then merging those returnedObservableSource
s and emitting the results of this merger.final <@NonNull R>
@NonNull Observable<R> Observable.flatMap
(@NonNull Function<? super @NonNull T, ? extends ObservableSource<? extends @NonNull R>> mapper, boolean delayErrors, int maxConcurrency) Returns anObservable
that emits items based on applying a function that you supply to each item emitted by the currentObservable
, where that function returns anObservableSource
, and then merging those returnedObservableSource
s and emitting the results of this merger, while limiting the maximum number of concurrent subscriptions to theseObservableSource
s.final <@NonNull R>
@NonNull Observable<R> Observable.flatMap
(@NonNull Function<? super @NonNull T, ? extends ObservableSource<? extends @NonNull R>> mapper, boolean delayErrors, int maxConcurrency, int bufferSize) Returns anObservable
that emits items based on applying a function that you supply to each item emitted by the currentObservable
, where that function returns anObservableSource
, and then merging those returnedObservableSource
s and emitting the results of this merger, while limiting the maximum number of concurrent subscriptions to theseObservableSource
s.final <@NonNull R>
@NonNull Observable<R> Observable.flatMap
(@NonNull Function<? super @NonNull T, ? extends ObservableSource<? extends @NonNull R>> mapper, int maxConcurrency) Returns anObservable
that emits items based on applying a function that you supply to each item emitted by the currentObservable
, where that function returns anObservableSource
, and then merging those returnedObservableSource
s and emitting the results of this merger, while limiting the maximum number of concurrent subscriptions to theseObservableSource
s.final <@NonNull R>
@NonNull Observable<R> Observable.flatMap
(@NonNull Function<? super @NonNull T, ? extends ObservableSource<? extends @NonNull R>> onNextMapper, @NonNull Function<? super Throwable, ? extends ObservableSource<? extends @NonNull R>> onErrorMapper, @NonNull Supplier<? extends ObservableSource<? extends @NonNull R>> onCompleteSupplier) Returns anObservable
that applies a function to each item emitted or notification raised by the currentObservable
and then flattens theObservableSource
s returned from these functions and emits the resulting items.final <@NonNull R>
@NonNull Observable<R> Observable.flatMap
(@NonNull Function<? super @NonNull T, ? extends ObservableSource<? extends @NonNull R>> onNextMapper, @NonNull Function<? super Throwable, ? extends ObservableSource<? extends @NonNull R>> onErrorMapper, @NonNull Supplier<? extends ObservableSource<? extends @NonNull R>> onCompleteSupplier) Returns anObservable
that applies a function to each item emitted or notification raised by the currentObservable
and then flattens theObservableSource
s returned from these functions and emits the resulting items.final <@NonNull R>
@NonNull Observable<R> Observable.flatMap
(@NonNull Function<? super @NonNull T, ? extends ObservableSource<? extends @NonNull R>> onNextMapper, @NonNull Function<? super Throwable, ? extends ObservableSource<? extends @NonNull R>> onErrorMapper, @NonNull Supplier<? extends ObservableSource<? extends @NonNull R>> onCompleteSupplier) Returns anObservable
that applies a function to each item emitted or notification raised by the currentObservable
and then flattens theObservableSource
s returned from these functions and emits the resulting items.final <@NonNull R>
@NonNull Observable<R> Observable.flatMap
(@NonNull Function<? super @NonNull T, ? extends ObservableSource<? extends @NonNull R>> onNextMapper, @NonNull Function<Throwable, ? extends ObservableSource<? extends @NonNull R>> onErrorMapper, @NonNull Supplier<? extends ObservableSource<? extends @NonNull R>> onCompleteSupplier, int maxConcurrency) Returns anObservable
that applies a function to each item emitted or notification raised by the currentObservable
and then flattens theObservableSource
s returned from these functions and emits the resulting items, while limiting the maximum number of concurrent subscriptions to theseObservableSource
s.final <@NonNull R>
@NonNull Observable<R> Observable.flatMap
(@NonNull Function<? super @NonNull T, ? extends ObservableSource<? extends @NonNull R>> onNextMapper, @NonNull Function<Throwable, ? extends ObservableSource<? extends @NonNull R>> onErrorMapper, @NonNull Supplier<? extends ObservableSource<? extends @NonNull R>> onCompleteSupplier, int maxConcurrency) Returns anObservable
that applies a function to each item emitted or notification raised by the currentObservable
and then flattens theObservableSource
s returned from these functions and emits the resulting items, while limiting the maximum number of concurrent subscriptions to theseObservableSource
s.final <@NonNull R>
@NonNull Observable<R> Observable.flatMap
(@NonNull Function<? super @NonNull T, ? extends ObservableSource<? extends @NonNull R>> onNextMapper, @NonNull Function<Throwable, ? extends ObservableSource<? extends @NonNull R>> onErrorMapper, @NonNull Supplier<? extends ObservableSource<? extends @NonNull R>> onCompleteSupplier, int maxConcurrency) Returns anObservable
that applies a function to each item emitted or notification raised by the currentObservable
and then flattens theObservableSource
s returned from these functions and emits the resulting items, while limiting the maximum number of concurrent subscriptions to theseObservableSource
s.final <@NonNull U,
@NonNull R>
@NonNull Observable<R> Observable.flatMap
(@NonNull Function<? super @NonNull T, ? extends ObservableSource<? extends @NonNull U>> mapper, @NonNull BiFunction<? super @NonNull T, ? super @NonNull U, ? extends @NonNull R> combiner) Returns anObservable
that emits the results of a specified function to the pair of values emitted by the currentObservable
and the mapped innerObservableSource
.final <@NonNull U,
@NonNull R>
@NonNull Observable<R> Observable.flatMap
(@NonNull Function<? super @NonNull T, ? extends ObservableSource<? extends @NonNull U>> mapper, @NonNull BiFunction<? super @NonNull T, ? super @NonNull U, ? extends @NonNull R> combiner) Returns anObservable
that emits the results of a specified function to the pair of values emitted by the currentObservable
and the mapped innerObservableSource
.final <@NonNull U,
@NonNull R>
@NonNull Observable<R> Observable.flatMap
(@NonNull Function<? super @NonNull T, ? extends ObservableSource<? extends @NonNull U>> mapper, @NonNull BiFunction<? super @NonNull T, ? super @NonNull U, ? extends @NonNull R> combiner, boolean delayErrors) Returns anObservable
that emits the results of a specified function to the pair of values emitted by the currentObservable
and the mapped innerObservableSource
.final <@NonNull U,
@NonNull R>
@NonNull Observable<R> Observable.flatMap
(@NonNull Function<? super @NonNull T, ? extends ObservableSource<? extends @NonNull U>> mapper, @NonNull BiFunction<? super @NonNull T, ? super @NonNull U, ? extends @NonNull R> combiner, boolean delayErrors) Returns anObservable
that emits the results of a specified function to the pair of values emitted by the currentObservable
and the mapped innerObservableSource
.final <@NonNull U,
@NonNull R>
@NonNull Observable<R> Observable.flatMap
(@NonNull Function<? super @NonNull T, ? extends ObservableSource<? extends @NonNull U>> mapper, @NonNull BiFunction<? super @NonNull T, ? super @NonNull U, ? extends @NonNull R> combiner, boolean delayErrors, int maxConcurrency) Returns anObservable
that emits the results of a specified function to the pair of values emitted by the currentObservable
and the mapped innerObservableSource
, while limiting the maximum number of concurrent subscriptions to theseObservableSource
s.final <@NonNull U,
@NonNull R>
@NonNull Observable<R> Observable.flatMap
(@NonNull Function<? super @NonNull T, ? extends ObservableSource<? extends @NonNull U>> mapper, @NonNull BiFunction<? super @NonNull T, ? super @NonNull U, ? extends @NonNull R> combiner, boolean delayErrors, int maxConcurrency) Returns anObservable
that emits the results of a specified function to the pair of values emitted by the currentObservable
and the mapped innerObservableSource
, while limiting the maximum number of concurrent subscriptions to theseObservableSource
s.final <@NonNull U,
@NonNull R>
@NonNull Observable<R> Observable.flatMap
(@NonNull Function<? super @NonNull T, ? extends ObservableSource<? extends @NonNull U>> mapper, @NonNull BiFunction<? super @NonNull T, ? super @NonNull U, ? extends @NonNull R> combiner, boolean delayErrors, int maxConcurrency, int bufferSize) Returns anObservable
that emits the results of a specified function to the pair of values emitted by the currentObservable
and the mapped innerObservableSource
, while limiting the maximum number of concurrent subscriptions to theseObservableSource
s.final <@NonNull U,
@NonNull R>
@NonNull Observable<R> Observable.flatMap
(@NonNull Function<? super @NonNull T, ? extends ObservableSource<? extends @NonNull U>> mapper, @NonNull BiFunction<? super @NonNull T, ? super @NonNull U, ? extends @NonNull R> combiner, boolean delayErrors, int maxConcurrency, int bufferSize) Returns anObservable
that emits the results of a specified function to the pair of values emitted by the currentObservable
and the mapped innerObservableSource
, while limiting the maximum number of concurrent subscriptions to theseObservableSource
s.final <@NonNull U,
@NonNull R>
@NonNull Observable<R> Observable.flatMap
(@NonNull Function<? super @NonNull T, ? extends ObservableSource<? extends @NonNull U>> mapper, @NonNull BiFunction<? super @NonNull T, ? super @NonNull U, ? extends @NonNull R> combiner, int maxConcurrency) Returns anObservable
that emits the results of a specified function to the pair of values emitted by the currentObservable
and the mapped innerObservableSource
, while limiting the maximum number of concurrent subscriptions to theseObservableSource
s.final <@NonNull U,
@NonNull R>
@NonNull Observable<R> Observable.flatMap
(@NonNull Function<? super @NonNull T, ? extends ObservableSource<? extends @NonNull U>> mapper, @NonNull BiFunction<? super @NonNull T, ? super @NonNull U, ? extends @NonNull R> combiner, int maxConcurrency) Returns anObservable
that emits the results of a specified function to the pair of values emitted by the currentObservable
and the mapped innerObservableSource
, while limiting the maximum number of concurrent subscriptions to theseObservableSource
s.Single.flatMap
(@NonNull Function<? super @NonNull T, ? extends SingleSource<? extends @NonNull R>> mapper) Returns aSingle
that is based on applying a specified function to the item emitted by the currentSingle
, where that function returns aSingleSource
.Single.flatMap
(@NonNull Function<? super @NonNull T, ? extends SingleSource<? extends @NonNull R>> onSuccessMapper, @NonNull Function<? super Throwable, ? extends SingleSource<? extends @NonNull R>> onErrorMapper) Maps theonSuccess
oronError
signals of the currentSingle
into aSingleSource
and emits thatSingleSource
's signals.Single.flatMap
(@NonNull Function<? super @NonNull T, ? extends SingleSource<? extends @NonNull R>> onSuccessMapper, @NonNull Function<? super Throwable, ? extends SingleSource<? extends @NonNull R>> onErrorMapper) Maps theonSuccess
oronError
signals of the currentSingle
into aSingleSource
and emits thatSingleSource
's signals.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 aSingle
that emits the results of a specified function to the pair of values emitted by the currentSingle
and a specified mappedSingleSource
.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 aSingle
that emits the results of a specified function to the pair of values emitted by the currentSingle
and a specified mappedSingleSource
.final @NonNull Completable
Flowable.flatMapCompletable
(@NonNull Function<? super @NonNull T, ? extends CompletableSource> mapper) Maps each element of the upstreamFlowable
intoCompletableSource
s, subscribes to them and waits until the upstream and allCompletableSource
s complete.final @NonNull Completable
Flowable.flatMapCompletable
(@NonNull Function<? super @NonNull T, ? extends CompletableSource> mapper, boolean delayErrors, int maxConcurrency) Maps each element of the upstreamFlowable
intoCompletableSource
s, subscribes to them and waits until the upstream and allCompletableSource
s complete, optionally delaying all errors.final @NonNull Completable
Maybe.flatMapCompletable
(@NonNull Function<? super @NonNull T, ? extends CompletableSource> mapper) Returns aCompletable
that completes based on applying a specified function to the item emitted by the currentMaybe
, where that function returns aCompletable
.final @NonNull Completable
Observable.flatMapCompletable
(@NonNull Function<? super @NonNull T, ? extends CompletableSource> mapper) Maps each element of the currentObservable
intoCompletableSource
s, subscribes to them and waits until the upstream and allCompletableSource
s complete.final @NonNull Completable
Observable.flatMapCompletable
(@NonNull Function<? super @NonNull T, ? extends CompletableSource> mapper, boolean delayErrors) Maps each element of the currentObservable
intoCompletableSource
s, subscribes to them and waits until the upstream and allCompletableSource
s complete, optionally delaying all errors.final @NonNull Completable
Single.flatMapCompletable
(@NonNull Function<? super @NonNull T, ? extends CompletableSource> mapper) Returns aCompletable
that completes based on applying a specified function to the item emitted by the currentSingle
, where that function returns aCompletableSource
.Flowable.flatMapIterable
(@NonNull Function<? super @NonNull T, @NonNull ? extends Iterable<? extends @NonNull U>> mapper) Flowable.flatMapIterable
(@NonNull Function<? super @NonNull T, @NonNull ? extends Iterable<? extends @NonNull U>> mapper, int bufferSize) Flowable.flatMapIterable
(@NonNull Function<? super @NonNull T, @NonNull ? extends Iterable<? extends @NonNull U>> mapper, @NonNull BiFunction<? super @NonNull T, ? super @NonNull U, ? extends @NonNull V> combiner) MergesIterable
s generated by a mapperFunction
for each individual item emitted by the currentFlowable
into a singleFlowable
sequence where the resulting items will be the combination of the original item and each inner item of the respectiveIterable
as returned by theresultSelector
BiFunction
.Flowable.flatMapIterable
(@NonNull Function<? super @NonNull T, @NonNull ? extends Iterable<? extends @NonNull U>> mapper, @NonNull BiFunction<? super @NonNull T, ? super @NonNull U, ? extends @NonNull V> combiner) MergesIterable
s generated by a mapperFunction
for each individual item emitted by the currentFlowable
into a singleFlowable
sequence where the resulting items will be the combination of the original item and each inner item of the respectiveIterable
as returned by theresultSelector
BiFunction
.Flowable.flatMapIterable
(@NonNull Function<? super @NonNull T, @NonNull ? extends Iterable<? extends @NonNull U>> mapper, @NonNull BiFunction<? super @NonNull T, ? super @NonNull U, ? extends @NonNull V> combiner, int prefetch) MergesIterable
s generated by a mapperFunction
for each individual item emitted by the currentFlowable
into a singleFlowable
sequence where the resulting items will be the combination of the original item and each inner item of the respectiveIterable
as returned by theresultSelector
BiFunction
.Flowable.flatMapIterable
(@NonNull Function<? super @NonNull T, @NonNull ? extends Iterable<? extends @NonNull U>> mapper, @NonNull BiFunction<? super @NonNull T, ? super @NonNull U, ? extends @NonNull V> combiner, int prefetch) MergesIterable
s generated by a mapperFunction
for each individual item emitted by the currentFlowable
into a singleFlowable
sequence where the resulting items will be the combination of the original item and each inner item of the respectiveIterable
as returned by theresultSelector
BiFunction
.final <@NonNull U>
@NonNull Observable<U> Observable.flatMapIterable
(@NonNull Function<? super @NonNull T, @NonNull ? extends Iterable<? extends @NonNull U>> mapper) final <@NonNull U,
@NonNull V>
@NonNull Observable<V> Observable.flatMapIterable
(@NonNull Function<? super @NonNull T, @NonNull ? extends Iterable<? extends @NonNull U>> mapper, @NonNull BiFunction<? super @NonNull T, ? super @NonNull U, ? extends @NonNull V> combiner) MergesIterable
s generated by a mapperFunction
for each individual item emitted by the currentObservable
into a singleObservable
sequence where the resulting items will be the combination of the original item and each inner item of the respectiveIterable
as returned by theresultSelector
BiFunction
.final <@NonNull U,
@NonNull V>
@NonNull Observable<V> Observable.flatMapIterable
(@NonNull Function<? super @NonNull T, @NonNull ? extends Iterable<? extends @NonNull U>> mapper, @NonNull BiFunction<? super @NonNull T, ? super @NonNull U, ? extends @NonNull V> combiner) MergesIterable
s generated by a mapperFunction
for each individual item emitted by the currentObservable
into a singleObservable
sequence where the resulting items will be the combination of the original item and each inner item of the respectiveIterable
as returned by theresultSelector
BiFunction
.Flowable.flatMapMaybe
(@NonNull Function<? super @NonNull T, ? extends MaybeSource<? extends @NonNull R>> mapper) Maps each element of the upstreamFlowable
intoMaybeSource
s, subscribes to all of them and merges theironSuccess
values, in no particular order, into a singleFlowable
sequence.Flowable.flatMapMaybe
(@NonNull Function<? super @NonNull T, ? extends MaybeSource<? extends @NonNull R>> mapper, boolean delayErrors, int maxConcurrency) Maps each element of the upstreamFlowable
intoMaybeSource
s, subscribes to at mostmaxConcurrency
MaybeSource
s at a time and merges theironSuccess
values, in no particular order, into a singleFlowable
sequence, optionally delaying all errors.final <@NonNull R>
@NonNull Observable<R> Observable.flatMapMaybe
(@NonNull Function<? super @NonNull T, ? extends MaybeSource<? extends @NonNull R>> mapper) Maps each element of the currentObservable
intoMaybeSource
s, subscribes to all of them and merges theironSuccess
values, in no particular order, into a singleObservable
sequence.final <@NonNull R>
@NonNull Observable<R> Observable.flatMapMaybe
(@NonNull Function<? super @NonNull T, ? extends MaybeSource<? extends @NonNull R>> mapper, boolean delayErrors) Maps each element of the currentObservable
intoMaybeSource
s, subscribes to them and merges theironSuccess
values, in no particular order, into a singleObservable
sequence, optionally delaying all errors.Single.flatMapMaybe
(@NonNull Function<? super @NonNull T, ? extends MaybeSource<? extends @NonNull R>> mapper) Returns aMaybe
that is based on applying a specified function to the item emitted by the currentSingle
, where that function returns aMaybeSource
.final <@NonNull R>
@NonNull Observable<R> Maybe.flatMapObservable
(@NonNull Function<? super @NonNull T, ? extends ObservableSource<? extends @NonNull R>> mapper) Returns anObservable
that is based on applying a specified function to the item emitted by the currentMaybe
, where that function returns anObservableSource
.final <@NonNull R>
@NonNull Observable<R> Single.flatMapObservable
(@NonNull Function<? super @NonNull T, ? extends ObservableSource<? extends @NonNull R>> mapper) Returns anObservable
that is based on applying a specified function to the item emitted by the currentSingle
, where that function returns anObservableSource
.Maybe.flatMapPublisher
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper) Returns aFlowable
that emits items based on applying a specified function to the item emitted by the currentMaybe
, where that function returns aPublisher
.Single.flatMapPublisher
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper) Returns aFlowable
that emits items based on applying a specified function to the item emitted by the currentSingle
, where that function returns aPublisher
.Flowable.flatMapSingle
(@NonNull Function<? super @NonNull T, ? extends SingleSource<? extends @NonNull R>> mapper) Maps each element of the upstreamFlowable
intoSingleSource
s, subscribes to all of them and merges theironSuccess
values, in no particular order, into a singleFlowable
sequence.Flowable.flatMapSingle
(@NonNull Function<? super @NonNull T, ? extends SingleSource<? extends @NonNull R>> mapper, boolean delayErrors, int maxConcurrency) Maps each element of the upstreamFlowable
intoSingleSource
s, subscribes to at mostmaxConcurrency
SingleSource
s at a time and merges theironSuccess
values, in no particular order, into a singleFlowable
sequence, optionally delaying all errors.Maybe.flatMapSingle
(@NonNull Function<? super @NonNull T, ? extends SingleSource<? extends @NonNull R>> mapper) Returns aMaybe
based on applying a specified function to the item emitted by the currentMaybe
, where that function returns aSingle
.final <@NonNull R>
@NonNull Observable<R> Observable.flatMapSingle
(@NonNull Function<? super @NonNull T, ? extends SingleSource<? extends @NonNull R>> mapper) Maps each element of the currentObservable
intoSingleSource
s, subscribes to all of them and merges theironSuccess
values, in no particular order, into a singleObservable
sequence.final <@NonNull R>
@NonNull Observable<R> Observable.flatMapSingle
(@NonNull Function<? super @NonNull T, ? extends SingleSource<? extends @NonNull R>> mapper, boolean delayErrors) Maps each element of the currentObservable
intoSingleSource
s, subscribes to them and merges theironSuccess
values, in no particular order, into a singleObservable
sequence, optionally delaying all errors.Flowable.flatMapStream
(@NonNull Function<? super @NonNull T, @NonNull ? extends Stream<? extends @NonNull R>> mapper) Maps each upstream item into aStream
and emits theStream
's items to the downstream in a sequential fashion.Flowable.flatMapStream
(@NonNull Function<? super @NonNull T, @NonNull ? extends Stream<? extends @NonNull R>> mapper, int prefetch) Maps each upstream item into aStream
and emits theStream
's items to the downstream in a sequential fashion.final <@NonNull R>
@NonNull Observable<R> Observable.flatMapStream
(@NonNull Function<? super @NonNull T, @NonNull ? extends Stream<? extends @NonNull R>> mapper) Maps each upstream item into aStream
and emits theStream
's items to the downstream in a sequential fashion.Maybe.flattenAsFlowable
(@NonNull Function<? super @NonNull T, @NonNull ? extends Iterable<? extends @NonNull U>> mapper) Single.flattenAsFlowable
(@NonNull Function<? super @NonNull T, @NonNull ? extends Iterable<? extends @NonNull U>> mapper) final <@NonNull U>
@NonNull Observable<U> Maybe.flattenAsObservable
(@NonNull Function<? super @NonNull T, @NonNull ? extends Iterable<? extends @NonNull U>> mapper) Maps the success value of the currentMaybe
into anIterable
and emits its items as anObservable
sequence.final <@NonNull U>
@NonNull Observable<U> Single.flattenAsObservable
(@NonNull Function<@NonNull ? super @NonNull T, @NonNull ? extends Iterable<? extends @NonNull U>> mapper) Maps the success value of the currentSingle
into anIterable
and emits its items as anObservable
sequence.Maybe.flattenStreamAsFlowable
(@NonNull Function<? super @NonNull T, @NonNull ? extends Stream<? extends @NonNull R>> mapper) Single.flattenStreamAsFlowable
(@NonNull Function<? super @NonNull T, @NonNull ? extends Stream<? extends @NonNull R>> mapper) final <@NonNull R>
@NonNull Observable<R> Maybe.flattenStreamAsObservable
(@NonNull Function<? super @NonNull T, @NonNull ? extends Stream<? extends @NonNull R>> mapper) Maps the upstream succecss value into a JavaStream
and emits its items to the downstream consumer as anObservable
.final <@NonNull R>
@NonNull Observable<R> Single.flattenStreamAsObservable
(@NonNull Function<? super @NonNull T, @NonNull ? extends Stream<? extends @NonNull R>> mapper) Maps the upstream succecss value into a JavaStream
and emits its items to the downstream consumer as anObservable
.final @NonNull Disposable
Subscribes to the currentFlowable
and receives notifications for each element.final @NonNull Disposable
Subscribes to theObservableSource
and calls aConsumer
for each item of the currentObservable
on its emission thread.final @NonNull Disposable
Flowable.forEachWhile
(@NonNull Predicate<? super @NonNull T> onNext) Subscribes to the currentFlowable
and receives notifications for each element until theonNext
Predicate returnsfalse
.final @NonNull Disposable
Flowable.forEachWhile
(@NonNull Predicate<? super @NonNull T> onNext, @NonNull Consumer<? super Throwable> onError) Subscribes to the currentFlowable
and receives notifications for each element and error events until theonNext
Predicate returnsfalse
.final @NonNull Disposable
Flowable.forEachWhile
(@NonNull Predicate<? super @NonNull T> onNext, @NonNull Consumer<? super Throwable> onError) Subscribes to the currentFlowable
and receives notifications for each element and error events until theonNext
Predicate returnsfalse
.final @NonNull Disposable
Flowable.forEachWhile
(@NonNull Predicate<? super @NonNull T> onNext, @NonNull Consumer<? super Throwable> onError, @NonNull Action onComplete) Subscribes to the currentFlowable
and receives notifications for each element and the terminal events until theonNext
Predicate returnsfalse
.final @NonNull Disposable
Flowable.forEachWhile
(@NonNull Predicate<? super @NonNull T> onNext, @NonNull Consumer<? super Throwable> onError, @NonNull Action onComplete) Subscribes to the currentFlowable
and receives notifications for each element and the terminal events until theonNext
Predicate returnsfalse
.final @NonNull Disposable
Flowable.forEachWhile
(@NonNull Predicate<? super @NonNull T> onNext, @NonNull Consumer<? super Throwable> onError, @NonNull Action onComplete) Subscribes to the currentFlowable
and receives notifications for each element and the terminal events until theonNext
Predicate returnsfalse
.final @NonNull Disposable
Observable.forEachWhile
(@NonNull Predicate<? super @NonNull T> onNext) Subscribes to theObservableSource
and calls aPredicate
for each item of the currentObservable
, on its emission thread, until the predicate returnsfalse
.final @NonNull Disposable
Observable.forEachWhile
(@NonNull Predicate<? super @NonNull T> onNext, @NonNull Consumer<? super Throwable> onError) Subscribes to theObservableSource
and calls aPredicate
for each item or aConsumer
with the error of the currentObservable
, on their original emission threads, until the predicate returnsfalse
.final @NonNull Disposable
Observable.forEachWhile
(@NonNull Predicate<? super @NonNull T> onNext, @NonNull Consumer<? super Throwable> onError) Subscribes to theObservableSource
and calls aPredicate
for each item or aConsumer
with the error of the currentObservable
, on their original emission threads, until the predicate returnsfalse
.final @NonNull Disposable
Observable.forEachWhile
(@NonNull Predicate<? super @NonNull T> onNext, @NonNull Consumer<? super Throwable> onError, @NonNull Action onComplete) Subscribes to theObservableSource
and calls aPredicate
for each item, aConsumer
with the error or anAction
upon completion of the currentObservable
, on their original emission threads, until the predicate returnsfalse
.final @NonNull Disposable
Observable.forEachWhile
(@NonNull Predicate<? super @NonNull T> onNext, @NonNull Consumer<? super Throwable> onError, @NonNull Action onComplete) Subscribes to theObservableSource
and calls aPredicate
for each item, aConsumer
with the error or anAction
upon completion of the currentObservable
, on their original emission threads, until the predicate returnsfalse
.final @NonNull Disposable
Observable.forEachWhile
(@NonNull Predicate<? super @NonNull T> onNext, @NonNull Consumer<? super Throwable> onError, @NonNull Action onComplete) Subscribes to theObservableSource
and calls aPredicate
for each item, aConsumer
with the error or anAction
upon completion of the currentObservable
, on their original emission threads, until the predicate returnsfalse
.static @NonNull Completable
Completable.fromAction
(@NonNull Action action) Returns aCompletable
instance that runs the givenAction
for eachCompletableObserver
and emits either an exception or simply completes.Flowable.fromAction
(@NonNull Action action) Returns aFlowable
instance that runs the givenAction
for eachSubscriber
and emits either its exception or simply completes.Maybe.fromAction
(@NonNull Action action) Returns aMaybe
instance that runs the givenAction
for eachMaybeObserver
and emits either its exception or simply completes.static <@NonNull T>
@NonNull Observable<T> Observable.fromAction
(@NonNull Action action) Converts an array into aPublisher
that emits the items in the array.static <@NonNull T>
@NonNull Observable<T> Converts an array into anObservableSource
that emits the items in the array.static @NonNull Completable
Completable.fromCallable
(@NonNull Callable<?> callable) Returns aCompletable
which when subscribed, executes theCallable
function, ignores its normal result and emitsonError
oronComplete
only.Flowable.fromCallable
(@NonNull Callable<? extends @NonNull T> callable) Returns aFlowable
that, when aSubscriber
subscribes to it, invokes a function you specify and then emits the value returned from that function.Maybe.fromCallable
(@NonNull Callable<? extends @Nullable T> callable) Returns aMaybe
that invokes the givenCallable
for each individualMaybeObserver
that subscribes and emits the resulting non-null
item viaonSuccess
while considering anull
result from theCallable
as indication for valueless completion viaonComplete
.static <@NonNull T>
@NonNull Observable<T> Observable.fromCallable
(@NonNull Callable<? extends @NonNull T> callable) Returns anObservable
that, when an observer subscribes to it, invokes a function you specify and then emits the value returned from that function.Single.fromCallable
(@NonNull Callable<? extends @NonNull T> callable) Returns aSingle
that invokes the givenCallable
for each incomingSingleObserver
and emits its value or exception to them.Flowable.fromCompletable
(@NonNull CompletableSource completableSource) Wraps aCompletableSource
into aFlowable
.Maybe.fromCompletable
(@NonNull CompletableSource completableSource) Wraps aCompletableSource
into aMaybe
.static <@NonNull T>
@NonNull Observable<T> Observable.fromCompletable
(@NonNull CompletableSource completableSource) Wraps aCompletableSource
into anObservable
.static @NonNull Completable
Completable.fromCompletionStage
(@NonNull CompletionStage<?> stage) Signals completion (or error) when theCompletionStage
terminates.Flowable.fromCompletionStage
(@NonNull CompletionStage<@NonNull T> stage) Signals the completion value or error of the given (hot)CompletionStage
-based asynchronous calculation.Maybe.fromCompletionStage
(@NonNull CompletionStage<@NonNull T> stage) Signals the completion value or error of the given (hot)CompletionStage
-based asynchronous calculation.static <@NonNull T>
@NonNull Observable<@NonNull T> Observable.fromCompletionStage
(@NonNull CompletionStage<@NonNull T> stage) Signals the completion value or error of the given (hot)CompletionStage
-based asynchronous calculation.Single.fromCompletionStage
(@NonNull CompletionStage<@NonNull T> stage) Signals the completion value or error of the given (hot)CompletionStage
-based asynchronous calculation.static @NonNull Completable
Completable.fromFuture
(@NonNull Future<?> future) Returns aCompletable
instance that reacts to the termination of the givenFuture
in a blocking fashion.Flowable.fromFuture
(@NonNull Future<? extends @NonNull T> future) Converts aFuture
into aPublisher
.Flowable.fromFuture
(@NonNull Future<? extends @NonNull T> future, long timeout, @NonNull TimeUnit unit) Flowable.fromFuture
(@NonNull Future<? extends @NonNull T> future, long timeout, @NonNull TimeUnit unit) Maybe.fromFuture
(@NonNull Future<? extends @NonNull T> future) Maybe.fromFuture
(@NonNull Future<? extends @NonNull T> future, long timeout, @NonNull TimeUnit unit) Maybe.fromFuture
(@NonNull Future<? extends @NonNull T> future, long timeout, @NonNull TimeUnit unit) static <@NonNull T>
@NonNull Observable<T> Observable.fromFuture
(@NonNull Future<? extends @NonNull T> future) Converts aFuture
into anObservable
.static <@NonNull T>
@NonNull Observable<T> Observable.fromFuture
(@NonNull Future<? extends @NonNull T> future, long timeout, @NonNull TimeUnit unit) static <@NonNull T>
@NonNull Observable<T> Observable.fromFuture
(@NonNull Future<? extends @NonNull T> future, long timeout, @NonNull TimeUnit unit) Single.fromFuture
(@NonNull Future<? extends @NonNull T> future) Converts aFuture
into aSingle
and awaits its outcome in a blocking fashion.Single.fromFuture
(@NonNull Future<? extends @NonNull T> future, long timeout, @NonNull TimeUnit unit) Converts aFuture
into aSingle
and awaits its outcome, or timeout, in a blocking fashion.Single.fromFuture
(@NonNull Future<? extends @NonNull T> future, long timeout, @NonNull TimeUnit unit) Converts aFuture
into aSingle
and awaits its outcome, or timeout, in a blocking fashion.Flowable.fromIterable
(@NonNull Iterable<? extends @NonNull T> source) Converts anIterable
sequence into aPublisher
that emits the items in the sequence.static <@NonNull T>
@NonNull Observable<T> Observable.fromIterable
(@NonNull Iterable<? extends @NonNull T> source) Converts anIterable
sequence into anObservable
that emits the items in the sequence.static <@NonNull T>
@NonNull CompletableCompletable.fromMaybe
(@NonNull MaybeSource<@NonNull T> maybe) Returns aCompletable
instance that when subscribed to, subscribes to theMaybeSource
instance and emits anonComplete
event if the maybe emitsonSuccess
/onComplete
or forwards anyonError
events.Flowable.fromMaybe
(@NonNull MaybeSource<@NonNull T> maybe) Returns aFlowable
instance that when subscribed to, subscribes to theMaybeSource
instance and emitsonSuccess
as a single item or forwards anyonComplete
oronError
signal.static <@NonNull T>
@NonNull Observable<T> Observable.fromMaybe
(@NonNull MaybeSource<@NonNull T> maybe) Returns anObservable
instance that when subscribed to, subscribes to theMaybeSource
instance and emitsonSuccess
as a single item or forwards anyonComplete
oronError
signal.Single.fromMaybe
(@NonNull MaybeSource<@NonNull T> maybe) Returns aSingle
instance that when subscribed to, subscribes to theMaybeSource
instance and emitsonSuccess
as a single item, turns anonComplete
intoNoSuchElementException
error signal or forwards theonError
signal.Single.fromMaybe
(@NonNull MaybeSource<@NonNull T> maybe, @NonNull T defaultItem) Returns aSingle
instance that when subscribed to, subscribes to theMaybeSource
instance and emitsonSuccess
as a single item, emits thedefaultItem
for anonComplete
signal or forwards theonError
signal.Single.fromMaybe
(@NonNull MaybeSource<@NonNull T> maybe, @NonNull T defaultItem) Returns aSingle
instance that when subscribed to, subscribes to theMaybeSource
instance and emitsonSuccess
as a single item, emits thedefaultItem
for anonComplete
signal or forwards theonError
signal.static <@NonNull T>
@NonNull CompletableCompletable.fromObservable
(@NonNull ObservableSource<@NonNull T> observable) Returns aCompletable
instance that subscribes to the givenObservableSource
, ignores all values and emits only the terminal event.Flowable.fromObservable
(@NonNull ObservableSource<@NonNull T> source, @NonNull BackpressureStrategy strategy) Converts the givenObservableSource
into aFlowable
by applying the specified backpressure strategy.Flowable.fromObservable
(@NonNull ObservableSource<@NonNull T> source, @NonNull BackpressureStrategy strategy) Converts the givenObservableSource
into aFlowable
by applying the specified backpressure strategy.Maybe.fromObservable
(@NonNull ObservableSource<@NonNull T> source) Wraps anObservableSource
into aMaybe
and emits the very first item or completes if the source is empty.Single.fromObservable
(@NonNull ObservableSource<? extends @NonNull T> observable) Wraps a specificObservableSource
into aSingle
and signals its single element or error.Flowable.fromOptional
(@NonNull Optional<@NonNull T> optional) Converts the existing value of the provided optional into aFlowable.just(Object)
or an empty optional into anFlowable.empty()
Flowable
instance.Maybe.fromOptional
(@NonNull Optional<@NonNull T> optional) Converts the existing value of the provided optional into aMaybe.just(Object)
or an empty optional into anMaybe.empty()
Maybe
instance.static <@NonNull T>
@NonNull Observable<@NonNull T> Observable.fromOptional
(@NonNull Optional<@NonNull T> optional) Converts the existing value of the provided optional into aObservable.just(Object)
or an empty optional into anObservable.empty()
Observable
instance.static <@NonNull T>
@NonNull CompletableCompletable.fromPublisher
(@NonNull org.reactivestreams.Publisher<@NonNull T> publisher) Returns aCompletable
instance that subscribes to the givenPublisher
, ignores all values and emits only the terminal event.Flowable.fromPublisher
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T> publisher) Converts an arbitrary Reactive StreamsPublisher
into aFlowable
if not already aFlowable
.Maybe.fromPublisher
(@NonNull org.reactivestreams.Publisher<@NonNull T> source) Wraps aPublisher
into aMaybe
and emits the very first item or completes if the source is empty.static <@NonNull T>
@NonNull Observable<T> Observable.fromPublisher
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T> publisher) Converts an arbitrary Reactive StreamsPublisher
into anObservable
.Single.fromPublisher
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T> publisher) Wraps a specificPublisher
into aSingle
and signals its single element or error.static @NonNull Completable
Completable.fromRunnable
(@NonNull Runnable run) Returns aCompletable
instance that runs the givenRunnable
for eachCompletableObserver
and emits either its unchecked exception or simply completes.Flowable.fromRunnable
(@NonNull Runnable run) Returns aFlowable
instance that runs the givenRunnable
for eachSubscriber
and emits either its unchecked exception or simply completes.Maybe.fromRunnable
(@NonNull Runnable run) Returns aMaybe
instance that runs the givenRunnable
for eachMaybeObserver
and emits either its unchecked exception or simply completes.static <@NonNull T>
@NonNull Observable<T> Observable.fromRunnable
(@NonNull Runnable run) static <@NonNull T>
@NonNull CompletableCompletable.fromSingle
(@NonNull SingleSource<@NonNull T> single) Returns aCompletable
instance that when subscribed to, subscribes to theSingleSource
instance and emits a completion event if the single emitsonSuccess
or forwards anyonError
events.Flowable.fromSingle
(@NonNull SingleSource<@NonNull T> source) Returns aFlowable
instance that when subscribed to, subscribes to theSingleSource
instance and emitsonSuccess
as a single item or forwards theonError
signal.Maybe.fromSingle
(@NonNull SingleSource<@NonNull T> single) Wraps aSingleSource
into aMaybe
.static <@NonNull T>
@NonNull Observable<T> Observable.fromSingle
(@NonNull SingleSource<@NonNull T> source) Returns anObservable
instance that when subscribed to, subscribes to theSingleSource
instance and emitsonSuccess
as a single item or forwards theonError
signal.Flowable.fromStream
(@NonNull Stream<@NonNull T> stream) Converts aStream
into a finiteFlowable
and emits its items in the sequence.static <@NonNull T>
@NonNull Observable<@NonNull T> Observable.fromStream
(@NonNull Stream<@NonNull T> stream) Converts aStream
into a finiteObservable
and emits its items in the sequence.static @NonNull Completable
Completable.fromSupplier
(@NonNull Supplier<?> supplier) Returns aCompletable
which when subscribed, executes theSupplier
function, ignores its normal result and emitsonError
oronComplete
only.Flowable.fromSupplier
(@NonNull Supplier<? extends @NonNull T> supplier) Returns aFlowable
that, when aSubscriber
subscribes to it, invokes a supplier function you specify and then emits the value returned from that function.Maybe.fromSupplier
(@NonNull Supplier<? extends @Nullable T> supplier) Returns aMaybe
that invokes the givenSupplier
for each individualMaybeObserver
that subscribes and emits the resulting non-null
item viaonSuccess
while considering anull
result from theSupplier
as indication for valueless completion viaonComplete
.static <@NonNull T>
@NonNull Observable<T> Observable.fromSupplier
(@NonNull Supplier<? extends @NonNull T> supplier) Returns anObservable
that, when an observer subscribes to it, invokes a supplier function you specify and then emits the value returned from that function.Single.fromSupplier
(@NonNull Supplier<? extends @NonNull T> supplier) Returns aSingle
that invokes passed supplier and emits its result for each individualSingleObserver
that subscribes.Returns a cold, synchronous, stateless and backpressure-aware generator of values.Flowable.generate
(@NonNull Supplier<@NonNull S> initialState, @NonNull BiConsumer<@NonNull S, Emitter<@NonNull T>> generator) Returns a cold, synchronous, stateful and backpressure-aware generator of values.Flowable.generate
(@NonNull Supplier<@NonNull S> initialState, @NonNull BiConsumer<@NonNull S, Emitter<@NonNull T>> generator) Returns a cold, synchronous, stateful and backpressure-aware generator of values.Flowable.generate
(@NonNull Supplier<@NonNull S> initialState, @NonNull BiConsumer<@NonNull S, Emitter<@NonNull T>> generator, @NonNull Consumer<? super @NonNull S> disposeState) Returns a cold, synchronous, stateful and backpressure-aware generator of values.Flowable.generate
(@NonNull Supplier<@NonNull S> initialState, @NonNull BiConsumer<@NonNull S, Emitter<@NonNull T>> generator, @NonNull Consumer<? super @NonNull S> disposeState) Returns a cold, synchronous, stateful and backpressure-aware generator of values.Flowable.generate
(@NonNull Supplier<@NonNull S> initialState, @NonNull BiConsumer<@NonNull S, Emitter<@NonNull T>> generator, @NonNull Consumer<? super @NonNull S> disposeState) Returns a cold, synchronous, stateful and backpressure-aware generator of values.Flowable.generate
(@NonNull Supplier<@NonNull S> initialState, @NonNull BiFunction<@NonNull S, @NonNull Emitter<@NonNull T>, @NonNull S> generator) Returns a cold, synchronous, stateful and backpressure-aware generator of values.Flowable.generate
(@NonNull Supplier<@NonNull S> initialState, @NonNull BiFunction<@NonNull S, @NonNull Emitter<@NonNull T>, @NonNull S> generator) Returns a cold, synchronous, stateful and backpressure-aware generator of values.Flowable.generate
(@NonNull Supplier<@NonNull S> initialState, @NonNull BiFunction<@NonNull S, @NonNull Emitter<@NonNull T>, @NonNull S> generator, @NonNull Consumer<? super @NonNull S> disposeState) Returns a cold, synchronous, stateful and backpressure-aware generator of values.Flowable.generate
(@NonNull Supplier<@NonNull S> initialState, @NonNull BiFunction<@NonNull S, @NonNull Emitter<@NonNull T>, @NonNull S> generator, @NonNull Consumer<? super @NonNull S> disposeState) Returns a cold, synchronous, stateful and backpressure-aware generator of values.Flowable.generate
(@NonNull Supplier<@NonNull S> initialState, @NonNull BiFunction<@NonNull S, @NonNull Emitter<@NonNull T>, @NonNull S> generator, @NonNull Consumer<? super @NonNull S> disposeState) Returns a cold, synchronous, stateful and backpressure-aware generator of values.static <@NonNull T>
@NonNull Observable<T> Returns a cold, synchronous and stateless generator of values.static <@NonNull T,
@NonNull S>
@NonNull Observable<T> Observable.generate
(@NonNull Supplier<@NonNull S> initialState, @NonNull BiConsumer<@NonNull S, Emitter<@NonNull T>> generator) Returns a cold, synchronous and stateful generator of values.static <@NonNull T,
@NonNull S>
@NonNull Observable<T> Observable.generate
(@NonNull Supplier<@NonNull S> initialState, @NonNull BiConsumer<@NonNull S, Emitter<@NonNull T>> generator) Returns a cold, synchronous and stateful generator of values.static <@NonNull T,
@NonNull S>
@NonNull Observable<T> Observable.generate
(@NonNull Supplier<@NonNull S> initialState, @NonNull BiConsumer<@NonNull S, Emitter<@NonNull T>> generator, @NonNull Consumer<? super @NonNull S> disposeState) Returns a cold, synchronous and stateful generator of values.static <@NonNull T,
@NonNull S>
@NonNull Observable<T> Observable.generate
(@NonNull Supplier<@NonNull S> initialState, @NonNull BiConsumer<@NonNull S, Emitter<@NonNull T>> generator, @NonNull Consumer<? super @NonNull S> disposeState) Returns a cold, synchronous and stateful generator of values.static <@NonNull T,
@NonNull S>
@NonNull Observable<T> Observable.generate
(@NonNull Supplier<@NonNull S> initialState, @NonNull BiConsumer<@NonNull S, Emitter<@NonNull T>> generator, @NonNull Consumer<? super @NonNull S> disposeState) Returns a cold, synchronous and stateful generator of values.static <@NonNull T,
@NonNull S>
@NonNull Observable<T> Observable.generate
(@NonNull Supplier<@NonNull S> initialState, @NonNull BiFunction<@NonNull S, Emitter<@NonNull T>, @NonNull S> generator) Returns a cold, synchronous and stateful generator of values.static <@NonNull T,
@NonNull S>
@NonNull Observable<T> Observable.generate
(@NonNull Supplier<@NonNull S> initialState, @NonNull BiFunction<@NonNull S, Emitter<@NonNull T>, @NonNull S> generator) Returns a cold, synchronous and stateful generator of values.static <@NonNull T,
@NonNull S>
@NonNull Observable<T> Observable.generate
(@NonNull Supplier<@NonNull S> initialState, @NonNull BiFunction<@NonNull S, Emitter<@NonNull T>, @NonNull S> generator, @NonNull Consumer<? super @NonNull S> disposeState) Returns a cold, synchronous and stateful generator of values.static <@NonNull T,
@NonNull S>
@NonNull Observable<T> Observable.generate
(@NonNull Supplier<@NonNull S> initialState, @NonNull BiFunction<@NonNull S, Emitter<@NonNull T>, @NonNull S> generator, @NonNull Consumer<? super @NonNull S> disposeState) Returns a cold, synchronous and stateful generator of values.static <@NonNull T,
@NonNull S>
@NonNull Observable<T> Observable.generate
(@NonNull Supplier<@NonNull S> initialState, @NonNull BiFunction<@NonNull S, Emitter<@NonNull T>, @NonNull S> generator, @NonNull Consumer<? super @NonNull S> disposeState) Returns a cold, synchronous and stateful generator of values.final <@NonNull K>
@NonNull Flowable<GroupedFlowable<K, T>> Groups the items emitted by the currentFlowable
according to a specified criterion, and emits these grouped items asGroupedFlowable
s.final <@NonNull K>
@NonNull Flowable<GroupedFlowable<K, T>> Flowable.groupBy
(@NonNull Function<? super @NonNull T, ? extends @NonNull K> keySelector, boolean delayError) Groups the items emitted by the currentFlowable
according to a specified criterion, and emits these grouped items asGroupedFlowable
s.final <@NonNull K,
@NonNull V>
@NonNull Flowable<GroupedFlowable<K, V>> Flowable.groupBy
(@NonNull Function<? super @NonNull T, ? extends @NonNull K> keySelector, @NonNull Function<? super @NonNull T, ? extends @NonNull V> valueSelector) Groups the items emitted by the currentFlowable
according to a specified criterion, and emits these grouped items asGroupedFlowable
s.final <@NonNull K,
@NonNull V>
@NonNull Flowable<GroupedFlowable<K, V>> Flowable.groupBy
(@NonNull Function<? super @NonNull T, ? extends @NonNull K> keySelector, @NonNull Function<? super @NonNull T, ? extends @NonNull V> valueSelector) Groups the items emitted by the currentFlowable
according to a specified criterion, and emits these grouped items asGroupedFlowable
s.final <@NonNull K,
@NonNull V>
@NonNull Flowable<GroupedFlowable<K, V>> Flowable.groupBy
(@NonNull Function<? super @NonNull T, ? extends @NonNull K> keySelector, @NonNull Function<? super @NonNull T, ? extends @NonNull V> valueSelector, boolean delayError) Groups the items emitted by the currentFlowable
according to a specified criterion, and emits these grouped items asGroupedFlowable
s.final <@NonNull K,
@NonNull V>
@NonNull Flowable<GroupedFlowable<K, V>> Flowable.groupBy
(@NonNull Function<? super @NonNull T, ? extends @NonNull K> keySelector, @NonNull Function<? super @NonNull T, ? extends @NonNull V> valueSelector, boolean delayError) Groups the items emitted by the currentFlowable
according to a specified criterion, and emits these grouped items asGroupedFlowable
s.final <@NonNull K,
@NonNull V>
@NonNull Flowable<GroupedFlowable<K, V>> Flowable.groupBy
(@NonNull Function<? super @NonNull T, ? extends @NonNull K> keySelector, @NonNull Function<? super @NonNull T, ? extends @NonNull V> valueSelector, boolean delayError, int bufferSize) Groups the items emitted by the currentFlowable
according to a specified criterion, and emits these grouped items asGroupedFlowable
s.final <@NonNull K,
@NonNull V>
@NonNull Flowable<GroupedFlowable<K, V>> Flowable.groupBy
(@NonNull Function<? super @NonNull T, ? extends @NonNull K> keySelector, @NonNull Function<? super @NonNull T, ? extends @NonNull V> valueSelector, boolean delayError, int bufferSize) Groups the items emitted by the currentFlowable
according to a specified criterion, and emits these grouped items asGroupedFlowable
s.final <@NonNull K,
@NonNull V>
@NonNull Flowable<GroupedFlowable<K, V>> Flowable.groupBy
(@NonNull Function<? super @NonNull T, ? extends @NonNull K> keySelector, @NonNull Function<? super @NonNull T, ? extends @NonNull V> valueSelector, boolean delayError, int bufferSize, @NonNull Function<? super Consumer<Object>, ? extends Map<@NonNull K, Object>> evictingMapFactory) Groups the items emitted by the currentFlowable
according to a specified criterion, and emits these grouped items asGroupedFlowable
s.final <@NonNull K,
@NonNull V>
@NonNull Flowable<GroupedFlowable<K, V>> Flowable.groupBy
(@NonNull Function<? super @NonNull T, ? extends @NonNull K> keySelector, @NonNull Function<? super @NonNull T, ? extends @NonNull V> valueSelector, boolean delayError, int bufferSize, @NonNull Function<? super Consumer<Object>, ? extends Map<@NonNull K, Object>> evictingMapFactory) Groups the items emitted by the currentFlowable
according to a specified criterion, and emits these grouped items asGroupedFlowable
s.final <@NonNull K,
@NonNull V>
@NonNull Flowable<GroupedFlowable<K, V>> Flowable.groupBy
(@NonNull Function<? super @NonNull T, ? extends @NonNull K> keySelector, @NonNull Function<? super @NonNull T, ? extends @NonNull V> valueSelector, boolean delayError, int bufferSize, @NonNull Function<? super Consumer<Object>, ? extends Map<@NonNull K, Object>> evictingMapFactory) Groups the items emitted by the currentFlowable
according to a specified criterion, and emits these grouped items asGroupedFlowable
s.final <@NonNull K>
@NonNull Observable<GroupedObservable<K, T>> Groups the items emitted by the currentObservable
according to a specified criterion, and emits these grouped items asGroupedObservable
s.final <@NonNull K>
@NonNull Observable<GroupedObservable<K, T>> Observable.groupBy
(@NonNull Function<? super @NonNull T, ? extends @NonNull K> keySelector, boolean delayError) Groups the items emitted by the currentObservable
according to a specified criterion, and emits these grouped items asGroupedObservable
s.final <@NonNull K,
@NonNull V>
@NonNull Observable<GroupedObservable<K, V>> Observable.groupBy
(@NonNull Function<? super @NonNull T, ? extends @NonNull K> keySelector, @NonNull Function<? super @NonNull T, ? extends @NonNull V> valueSelector, boolean delayError) Groups the items emitted by the currentObservable
according to a specified criterion, and emits these grouped items asGroupedObservable
s.final <@NonNull K,
@NonNull V>
@NonNull Observable<GroupedObservable<K, V>> Observable.groupBy
(@NonNull Function<? super @NonNull T, ? extends @NonNull K> keySelector, @NonNull Function<? super @NonNull T, ? extends @NonNull V> valueSelector, boolean delayError) Groups the items emitted by the currentObservable
according to a specified criterion, and emits these grouped items asGroupedObservable
s.final <@NonNull K,
@NonNull V>
@NonNull Observable<GroupedObservable<K, V>> Observable.groupBy
(@NonNull Function<? super @NonNull T, ? extends @NonNull K> keySelector, @NonNull Function<? super @NonNull T, ? extends @NonNull V> valueSelector, boolean delayError, int bufferSize) Groups the items emitted by the currentObservable
according to a specified criterion, and emits these grouped items asGroupedObservable
s.final <@NonNull K,
@NonNull V>
@NonNull Observable<GroupedObservable<K, V>> Observable.groupBy
(@NonNull Function<? super @NonNull T, ? extends @NonNull K> keySelector, @NonNull Function<? super @NonNull T, ? extends @NonNull V> valueSelector, boolean delayError, int bufferSize) Groups the items emitted by the currentObservable
according to a specified criterion, and emits these grouped items asGroupedObservable
s.final <@NonNull K,
@NonNull V>
@NonNull Observable<GroupedObservable<K, V>> Observable.groupBy
(@NonNull Function<? super @NonNull T, ? extends @NonNull K> keySelector, Function<? super @NonNull T, ? extends @NonNull V> valueSelector) Groups the items emitted by the currentObservable
according to a specified criterion, and emits these grouped items asGroupedObservable
s.Flowable.groupJoin
(@NonNull org.reactivestreams.Publisher<? extends @NonNull TRight> other, @NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<@NonNull TLeftEnd>> leftEnd, @NonNull Function<? super @NonNull TRight, @NonNull ? extends org.reactivestreams.Publisher<@NonNull TRightEnd>> rightEnd, @NonNull BiFunction<? super @NonNull T, ? super Flowable<@NonNull TRight>, ? extends @NonNull R> resultSelector) Returns aFlowable
that correlates twoPublisher
s when they overlap in time and groups the results.Flowable.groupJoin
(@NonNull org.reactivestreams.Publisher<? extends @NonNull TRight> other, @NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<@NonNull TLeftEnd>> leftEnd, @NonNull Function<? super @NonNull TRight, @NonNull ? extends org.reactivestreams.Publisher<@NonNull TRightEnd>> rightEnd, @NonNull BiFunction<? super @NonNull T, ? super Flowable<@NonNull TRight>, ? extends @NonNull R> resultSelector) Returns aFlowable
that correlates twoPublisher
s when they overlap in time and groups the results.Flowable.groupJoin
(@NonNull org.reactivestreams.Publisher<? extends @NonNull TRight> other, @NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<@NonNull TLeftEnd>> leftEnd, @NonNull Function<? super @NonNull TRight, @NonNull ? extends org.reactivestreams.Publisher<@NonNull TRightEnd>> rightEnd, @NonNull BiFunction<? super @NonNull T, ? super Flowable<@NonNull TRight>, ? extends @NonNull R> resultSelector) Returns aFlowable
that correlates twoPublisher
s when they overlap in time and groups the results.Flowable.groupJoin
(@NonNull org.reactivestreams.Publisher<? extends @NonNull TRight> other, @NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<@NonNull TLeftEnd>> leftEnd, @NonNull Function<? super @NonNull TRight, @NonNull ? extends org.reactivestreams.Publisher<@NonNull TRightEnd>> rightEnd, @NonNull BiFunction<? super @NonNull T, ? super Flowable<@NonNull TRight>, ? extends @NonNull R> resultSelector) Returns aFlowable
that correlates twoPublisher
s when they overlap in time and groups the results.Observable.groupJoin
(@NonNull ObservableSource<? extends @NonNull TRight> other, @NonNull Function<? super @NonNull T, ? extends ObservableSource<@NonNull TLeftEnd>> leftEnd, @NonNull Function<? super @NonNull TRight, ? extends ObservableSource<@NonNull TRightEnd>> rightEnd, @NonNull BiFunction<? super @NonNull T, ? super Observable<@NonNull TRight>, ? extends @NonNull R> resultSelector) Returns anObservable
that correlates twoObservableSource
s when they overlap in time and groups the results.Observable.groupJoin
(@NonNull ObservableSource<? extends @NonNull TRight> other, @NonNull Function<? super @NonNull T, ? extends ObservableSource<@NonNull TLeftEnd>> leftEnd, @NonNull Function<? super @NonNull TRight, ? extends ObservableSource<@NonNull TRightEnd>> rightEnd, @NonNull BiFunction<? super @NonNull T, ? super Observable<@NonNull TRight>, ? extends @NonNull R> resultSelector) Returns anObservable
that correlates twoObservableSource
s when they overlap in time and groups the results.Observable.groupJoin
(@NonNull ObservableSource<? extends @NonNull TRight> other, @NonNull Function<? super @NonNull T, ? extends ObservableSource<@NonNull TLeftEnd>> leftEnd, @NonNull Function<? super @NonNull TRight, ? extends ObservableSource<@NonNull TRightEnd>> rightEnd, @NonNull BiFunction<? super @NonNull T, ? super Observable<@NonNull TRight>, ? extends @NonNull R> resultSelector) Returns anObservable
that correlates twoObservableSource
s when they overlap in time and groups the results.Observable.groupJoin
(@NonNull ObservableSource<? extends @NonNull TRight> other, @NonNull Function<? super @NonNull T, ? extends ObservableSource<@NonNull TLeftEnd>> leftEnd, @NonNull Function<? super @NonNull TRight, ? extends ObservableSource<@NonNull TRightEnd>> rightEnd, @NonNull BiFunction<? super @NonNull T, ? super Observable<@NonNull TRight>, ? extends @NonNull R> resultSelector) Returns anObservable
that correlates twoObservableSource
s when they overlap in time and groups the results.Returns aFlowable
that emits a0L
after theinitialDelay
and ever-increasing numbers after eachperiod
of time thereafter.Flowable.interval
(long initialDelay, long period, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Returns aFlowable
that emits a0L
after theinitialDelay
and ever-increasing numbers after eachperiod
of time thereafter, on a specifiedScheduler
.Flowable.interval
(long initialDelay, long period, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Returns aFlowable
that emits a0L
after theinitialDelay
and ever-increasing numbers after eachperiod
of time thereafter, on a specifiedScheduler
.Returns aFlowable
that emits a sequential number every specified interval of time.Returns aFlowable
that emits a sequential number every specified interval of time, on a specifiedScheduler
.Returns aFlowable
that emits a sequential number every specified interval of time, on a specifiedScheduler
.static @NonNull Observable
<Long> Returns anObservable
that emits a0L
after theinitialDelay
and ever increasing numbers after eachperiod
of time thereafter.static @NonNull Observable
<Long> Observable.interval
(long initialDelay, long period, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Returns anObservable
that emits a0L
after theinitialDelay
and ever increasing numbers after eachperiod
of time thereafter, on a specifiedScheduler
.static @NonNull Observable
<Long> Observable.interval
(long initialDelay, long period, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Returns anObservable
that emits a0L
after theinitialDelay
and ever increasing numbers after eachperiod
of time thereafter, on a specifiedScheduler
.static @NonNull Observable
<Long> Returns anObservable
that emits a sequential number every specified interval of time.static @NonNull Observable
<Long> Returns anObservable
that emits a sequential number every specified interval of time, on a specifiedScheduler
.static @NonNull Observable
<Long> Returns anObservable
that emits a sequential number every specified interval of time, on a specifiedScheduler
.Flowable.intervalRange
(long start, long count, long initialDelay, long period, @NonNull TimeUnit unit) Signals a range of long values, the first after some initial delay and the rest periodically after.Flowable.intervalRange
(long start, long count, long initialDelay, long period, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Signals a range of long values, the first after some initial delay and the rest periodically after.Flowable.intervalRange
(long start, long count, long initialDelay, long period, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Signals a range of long values, the first after some initial delay and the rest periodically after.static @NonNull Observable
<Long> Observable.intervalRange
(long start, long count, long initialDelay, long period, @NonNull TimeUnit unit) Signals a range of long values, the first after some initial delay and the rest periodically after.static @NonNull Observable
<Long> Observable.intervalRange
(long start, long count, long initialDelay, long period, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Signals a range of long values, the first after some initial delay and the rest periodically after.static @NonNull Observable
<Long> Observable.intervalRange
(long start, long count, long initialDelay, long period, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Signals a range of long values, the first after some initial delay and the rest periodically after.Flowable.join
(@NonNull org.reactivestreams.Publisher<? extends @NonNull TRight> other, @NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<@NonNull TLeftEnd>> leftEnd, @NonNull Function<? super @NonNull TRight, @NonNull ? extends org.reactivestreams.Publisher<@NonNull TRightEnd>> rightEnd, @NonNull BiFunction<? super @NonNull T, ? super @NonNull TRight, ? extends @NonNull R> resultSelector) Correlates the items emitted by twoPublisher
s based on overlapping durations.Flowable.join
(@NonNull org.reactivestreams.Publisher<? extends @NonNull TRight> other, @NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<@NonNull TLeftEnd>> leftEnd, @NonNull Function<? super @NonNull TRight, @NonNull ? extends org.reactivestreams.Publisher<@NonNull TRightEnd>> rightEnd, @NonNull BiFunction<? super @NonNull T, ? super @NonNull TRight, ? extends @NonNull R> resultSelector) Correlates the items emitted by twoPublisher
s based on overlapping durations.Flowable.join
(@NonNull org.reactivestreams.Publisher<? extends @NonNull TRight> other, @NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<@NonNull TLeftEnd>> leftEnd, @NonNull Function<? super @NonNull TRight, @NonNull ? extends org.reactivestreams.Publisher<@NonNull TRightEnd>> rightEnd, @NonNull BiFunction<? super @NonNull T, ? super @NonNull TRight, ? extends @NonNull R> resultSelector) Correlates the items emitted by twoPublisher
s based on overlapping durations.Flowable.join
(@NonNull org.reactivestreams.Publisher<? extends @NonNull TRight> other, @NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<@NonNull TLeftEnd>> leftEnd, @NonNull Function<? super @NonNull TRight, @NonNull ? extends org.reactivestreams.Publisher<@NonNull TRightEnd>> rightEnd, @NonNull BiFunction<? super @NonNull T, ? super @NonNull TRight, ? extends @NonNull R> resultSelector) Correlates the items emitted by twoPublisher
s based on overlapping durations.Observable.join
(@NonNull ObservableSource<? extends @NonNull TRight> other, @NonNull Function<? super @NonNull T, ? extends ObservableSource<@NonNull TLeftEnd>> leftEnd, @NonNull Function<? super @NonNull TRight, ? extends ObservableSource<@NonNull TRightEnd>> rightEnd, @NonNull BiFunction<? super @NonNull T, ? super @NonNull TRight, ? extends @NonNull R> resultSelector) Correlates the items emitted by twoObservableSource
s based on overlapping durations.Observable.join
(@NonNull ObservableSource<? extends @NonNull TRight> other, @NonNull Function<? super @NonNull T, ? extends ObservableSource<@NonNull TLeftEnd>> leftEnd, @NonNull Function<? super @NonNull TRight, ? extends ObservableSource<@NonNull TRightEnd>> rightEnd, @NonNull BiFunction<? super @NonNull T, ? super @NonNull TRight, ? extends @NonNull R> resultSelector) Correlates the items emitted by twoObservableSource
s based on overlapping durations.Observable.join
(@NonNull ObservableSource<? extends @NonNull TRight> other, @NonNull Function<? super @NonNull T, ? extends ObservableSource<@NonNull TLeftEnd>> leftEnd, @NonNull Function<? super @NonNull TRight, ? extends ObservableSource<@NonNull TRightEnd>> rightEnd, @NonNull BiFunction<? super @NonNull T, ? super @NonNull TRight, ? extends @NonNull R> resultSelector) Correlates the items emitted by twoObservableSource
s based on overlapping durations.Observable.join
(@NonNull ObservableSource<? extends @NonNull TRight> other, @NonNull Function<? super @NonNull T, ? extends ObservableSource<@NonNull TLeftEnd>> leftEnd, @NonNull Function<? super @NonNull TRight, ? extends ObservableSource<@NonNull TRightEnd>> rightEnd, @NonNull BiFunction<? super @NonNull T, ? super @NonNull TRight, ? extends @NonNull R> resultSelector) Correlates the items emitted by twoObservableSource
s based on overlapping durations.static <@NonNull T>
@NonNull Observable<T> Returns anObservable
that signals the given (constant reference) item and then completes.static <@NonNull T>
@NonNull Observable<T> Converts two items into anObservable
that emits those items.static <@NonNull T>
@NonNull Observable<T> Converts two items into anObservable
that emits those items.static <@NonNull T>
@NonNull Observable<T> Converts three items into anObservable
that emits those items.static <@NonNull T>
@NonNull Observable<T> Converts three items into anObservable
that emits those items.static <@NonNull T>
@NonNull Observable<T> Converts three items into anObservable
that emits those items.static <@NonNull T>
@NonNull Observable<T> Converts four items into anObservable
that emits those items.static <@NonNull T>
@NonNull Observable<T> Converts four items into anObservable
that emits those items.static <@NonNull T>
@NonNull Observable<T> Converts four items into anObservable
that emits those items.static <@NonNull T>
@NonNull Observable<T> Converts four items into anObservable
that emits those items.static <@NonNull T>
@NonNull Observable<T> Observable.just
(@NonNull T item1, @NonNull T item2, @NonNull T item3, @NonNull T item4, @NonNull T item5) Converts five items into anObservable
that emits those items.static <@NonNull T>
@NonNull Observable<T> Observable.just
(@NonNull T item1, @NonNull T item2, @NonNull T item3, @NonNull T item4, @NonNull T item5) Converts five items into anObservable
that emits those items.static <@NonNull T>
@NonNull Observable<T> Observable.just
(@NonNull T item1, @NonNull T item2, @NonNull T item3, @NonNull T item4, @NonNull T item5) Converts five items into anObservable
that emits those items.static <@NonNull T>
@NonNull Observable<T> Observable.just
(@NonNull T item1, @NonNull T item2, @NonNull T item3, @NonNull T item4, @NonNull T item5) Converts five items into anObservable
that emits those items.static <@NonNull T>
@NonNull Observable<T> Observable.just
(@NonNull T item1, @NonNull T item2, @NonNull T item3, @NonNull T item4, @NonNull T item5) Converts five items into anObservable
that emits those items.static <@NonNull T>
@NonNull Observable<T> Observable.just
(@NonNull T item1, @NonNull T item2, @NonNull T item3, @NonNull T item4, @NonNull T item5, @NonNull T item6) Converts six items into anObservable
that emits those items.static <@NonNull T>
@NonNull Observable<T> Observable.just
(@NonNull T item1, @NonNull T item2, @NonNull T item3, @NonNull T item4, @NonNull T item5, @NonNull T item6) Converts six items into anObservable
that emits those items.static <@NonNull T>
@NonNull Observable<T> Observable.just
(@NonNull T item1, @NonNull T item2, @NonNull T item3, @NonNull T item4, @NonNull T item5, @NonNull T item6) Converts six items into anObservable
that emits those items.static <@NonNull T>
@NonNull Observable<T> Observable.just
(@NonNull T item1, @NonNull T item2, @NonNull T item3, @NonNull T item4, @NonNull T item5, @NonNull T item6) Converts six items into anObservable
that emits those items.static <@NonNull T>
@NonNull Observable<T> Observable.just
(@NonNull T item1, @NonNull T item2, @NonNull T item3, @NonNull T item4, @NonNull T item5, @NonNull T item6) Converts six items into anObservable
that emits those items.static <@NonNull T>
@NonNull Observable<T> Observable.just
(@NonNull T item1, @NonNull T item2, @NonNull T item3, @NonNull T item4, @NonNull T item5, @NonNull T item6) Converts six items into anObservable
that emits those items.static <@NonNull T>
@NonNull Observable<T> Observable.just
(@NonNull T item1, @NonNull T item2, @NonNull T item3, @NonNull T item4, @NonNull T item5, @NonNull T item6, @NonNull T item7) Converts seven items into anObservable
that emits those items.static <@NonNull T>
@NonNull Observable<T> Observable.just
(@NonNull T item1, @NonNull T item2, @NonNull T item3, @NonNull T item4, @NonNull T item5, @NonNull T item6, @NonNull T item7) Converts seven items into anObservable
that emits those items.static <@NonNull T>
@NonNull Observable<T> Observable.just
(@NonNull T item1, @NonNull T item2, @NonNull T item3, @NonNull T item4, @NonNull T item5, @NonNull T item6, @NonNull T item7) Converts seven items into anObservable
that emits those items.static <@NonNull T>
@NonNull Observable<T> Observable.just
(@NonNull T item1, @NonNull T item2, @NonNull T item3, @NonNull T item4, @NonNull T item5, @NonNull T item6, @NonNull T item7) Converts seven items into anObservable
that emits those items.static <@NonNull T>
@NonNull Observable<T> Observable.just
(@NonNull T item1, @NonNull T item2, @NonNull T item3, @NonNull T item4, @NonNull T item5, @NonNull T item6, @NonNull T item7) Converts seven items into anObservable
that emits those items.static <@NonNull T>
@NonNull Observable<T> Observable.just
(@NonNull T item1, @NonNull T item2, @NonNull T item3, @NonNull T item4, @NonNull T item5, @NonNull T item6, @NonNull T item7) Converts seven items into anObservable
that emits those items.static <@NonNull T>
@NonNull Observable<T> Observable.just
(@NonNull T item1, @NonNull T item2, @NonNull T item3, @NonNull T item4, @NonNull T item5, @NonNull T item6, @NonNull T item7) Converts seven items into anObservable
that emits those items.static <@NonNull T>
@NonNull Observable<T> Observable.just
(@NonNull T item1, @NonNull T item2, @NonNull T item3, @NonNull T item4, @NonNull T item5, @NonNull T item6, @NonNull T item7, @NonNull T item8) Converts eight items into anObservable
that emits those items.static <@NonNull T>
@NonNull Observable<T> Observable.just
(@NonNull T item1, @NonNull T item2, @NonNull T item3, @NonNull T item4, @NonNull T item5, @NonNull T item6, @NonNull T item7, @NonNull T item8) Converts eight items into anObservable
that emits those items.static <@NonNull T>
@NonNull Observable<T> Observable.just
(@NonNull T item1, @NonNull T item2, @NonNull T item3, @NonNull T item4, @NonNull T item5, @NonNull T item6, @NonNull T item7, @NonNull T item8) Converts eight items into anObservable
that emits those items.static <@NonNull T>
@NonNull Observable<T> Observable.just
(@NonNull T item1, @NonNull T item2, @NonNull T item3, @NonNull T item4, @NonNull T item5, @NonNull T item6, @NonNull T item7, @NonNull T item8) Converts eight items into anObservable
that emits those items.static <@NonNull T>
@NonNull Observable<T> Observable.just
(@NonNull T item1, @NonNull T item2, @NonNull T item3, @NonNull T item4, @NonNull T item5, @NonNull T item6, @NonNull T item7, @NonNull T item8) Converts eight items into anObservable
that emits those items.static <@NonNull T>
@NonNull Observable<T> Observable.just
(@NonNull T item1, @NonNull T item2, @NonNull T item3, @NonNull T item4, @NonNull T item5, @NonNull T item6, @NonNull T item7, @NonNull T item8) Converts eight items into anObservable
that emits those items.static <@NonNull T>
@NonNull Observable<T> Observable.just
(@NonNull T item1, @NonNull T item2, @NonNull T item3, @NonNull T item4, @NonNull T item5, @NonNull T item6, @NonNull T item7, @NonNull T item8) Converts eight items into anObservable
that emits those items.static <@NonNull T>
@NonNull Observable<T> Observable.just
(@NonNull T item1, @NonNull T item2, @NonNull T item3, @NonNull T item4, @NonNull T item5, @NonNull T item6, @NonNull T item7, @NonNull T item8) Converts eight items into anObservable
that emits those items.static <@NonNull T>
@NonNull Observable<T> Observable.just
(@NonNull T item1, @NonNull T item2, @NonNull T item3, @NonNull T item4, @NonNull T item5, @NonNull T item6, @NonNull T item7, @NonNull T item8, @NonNull T item9) Converts nine items into anObservable
that emits those items.static <@NonNull T>
@NonNull Observable<T> Observable.just
(@NonNull T item1, @NonNull T item2, @NonNull T item3, @NonNull T item4, @NonNull T item5, @NonNull T item6, @NonNull T item7, @NonNull T item8, @NonNull T item9) Converts nine items into anObservable
that emits those items.static <@NonNull T>
@NonNull Observable<T> Observable.just
(@NonNull T item1, @NonNull T item2, @NonNull T item3, @NonNull T item4, @NonNull T item5, @NonNull T item6, @NonNull T item7, @NonNull T item8, @NonNull T item9) Converts nine items into anObservable
that emits those items.static <@NonNull T>
@NonNull Observable<T> Observable.just
(@NonNull T item1, @NonNull T item2, @NonNull T item3, @NonNull T item4, @NonNull T item5, @NonNull T item6, @NonNull T item7, @NonNull T item8, @NonNull T item9) Converts nine items into anObservable
that emits those items.static <@NonNull T>
@NonNull Observable<T> Observable.just
(@NonNull T item1, @NonNull T item2, @NonNull T item3, @NonNull T item4, @NonNull T item5, @NonNull T item6, @NonNull T item7, @NonNull T item8, @NonNull T item9) Converts nine items into anObservable
that emits those items.static <@NonNull T>
@NonNull Observable<T> Observable.just
(@NonNull T item1, @NonNull T item2, @NonNull T item3, @NonNull T item4, @NonNull T item5, @NonNull T item6, @NonNull T item7, @NonNull T item8, @NonNull T item9) Converts nine items into anObservable
that emits those items.static <@NonNull T>
@NonNull Observable<T> Observable.just
(@NonNull T item1, @NonNull T item2, @NonNull T item3, @NonNull T item4, @NonNull T item5, @NonNull T item6, @NonNull T item7, @NonNull T item8, @NonNull T item9) Converts nine items into anObservable
that emits those items.static <@NonNull T>
@NonNull Observable<T> Observable.just
(@NonNull T item1, @NonNull T item2, @NonNull T item3, @NonNull T item4, @NonNull T item5, @NonNull T item6, @NonNull T item7, @NonNull T item8, @NonNull T item9) Converts nine items into anObservable
that emits those items.static <@NonNull T>
@NonNull Observable<T> Observable.just
(@NonNull T item1, @NonNull T item2, @NonNull T item3, @NonNull T item4, @NonNull T item5, @NonNull T item6, @NonNull T item7, @NonNull T item8, @NonNull T item9) Converts nine items into anObservable
that emits those items.static <@NonNull T>
@NonNull Observable<T> Observable.just
(@NonNull T item1, @NonNull T item2, @NonNull T item3, @NonNull T item4, @NonNull T item5, @NonNull T item6, @NonNull T item7, @NonNull T item8, @NonNull T item9, @NonNull T item10) Converts ten items into anObservable
that emits those items.static <@NonNull T>
@NonNull Observable<T> Observable.just
(@NonNull T item1, @NonNull T item2, @NonNull T item3, @NonNull T item4, @NonNull T item5, @NonNull T item6, @NonNull T item7, @NonNull T item8, @NonNull T item9, @NonNull T item10) Converts ten items into anObservable
that emits those items.static <@NonNull T>
@NonNull Observable<T> Observable.just
(@NonNull T item1, @NonNull T item2, @NonNull T item3, @NonNull T item4, @NonNull T item5, @NonNull T item6, @NonNull T item7, @NonNull T item8, @NonNull T item9, @NonNull T item10) Converts ten items into anObservable
that emits those items.static <@NonNull T>
@NonNull Observable<T> Observable.just
(@NonNull T item1, @NonNull T item2, @NonNull T item3, @NonNull T item4, @NonNull T item5, @NonNull T item6, @NonNull T item7, @NonNull T item8, @NonNull T item9, @NonNull T item10) Converts ten items into anObservable
that emits those items.static <@NonNull T>
@NonNull Observable<T> Observable.just
(@NonNull T item1, @NonNull T item2, @NonNull T item3, @NonNull T item4, @NonNull T item5, @NonNull T item6, @NonNull T item7, @NonNull T item8, @NonNull T item9, @NonNull T item10) Converts ten items into anObservable
that emits those items.static <@NonNull T>
@NonNull Observable<T> Observable.just
(@NonNull T item1, @NonNull T item2, @NonNull T item3, @NonNull T item4, @NonNull T item5, @NonNull T item6, @NonNull T item7, @NonNull T item8, @NonNull T item9, @NonNull T item10) Converts ten items into anObservable
that emits those items.static <@NonNull T>
@NonNull Observable<T> Observable.just
(@NonNull T item1, @NonNull T item2, @NonNull T item3, @NonNull T item4, @NonNull T item5, @NonNull T item6, @NonNull T item7, @NonNull T item8, @NonNull T item9, @NonNull T item10) Converts ten items into anObservable
that emits those items.static <@NonNull T>
@NonNull Observable<T> Observable.just
(@NonNull T item1, @NonNull T item2, @NonNull T item3, @NonNull T item4, @NonNull T item5, @NonNull T item6, @NonNull T item7, @NonNull T item8, @NonNull T item9, @NonNull T item10) Converts ten items into anObservable
that emits those items.static <@NonNull T>
@NonNull Observable<T> Observable.just
(@NonNull T item1, @NonNull T item2, @NonNull T item3, @NonNull T item4, @NonNull T item5, @NonNull T item6, @NonNull T item7, @NonNull T item8, @NonNull T item9, @NonNull T item10) Converts ten items into anObservable
that emits those items.static <@NonNull T>
@NonNull Observable<T> Observable.just
(@NonNull T item1, @NonNull T item2, @NonNull T item3, @NonNull T item4, @NonNull T item5, @NonNull T item6, @NonNull T item7, @NonNull T item8, @NonNull T item9, @NonNull T item10) Converts ten items into anObservable
that emits those items.Returns aSingle
that emits only the last item emitted by thisFlowable
, or a default item if thisFlowable
completes without emitting any items.Returns aSingle
that emits only the last item emitted by the currentObservable
, or a default item if the currentObservable
completes without emitting any items.final @NonNull Completable
Completable.lift
(@NonNull CompletableOperator onLift) This method requires advanced knowledge about building operators, please consider other standard composition methods first; Returns aCompletable
which, when subscribed to, invokes theapply(CompletableObserver)
method of the providedCompletableOperator
for each individual downstreamCompletable
and allows the insertion of a custom operator by accessing the downstream'sCompletableObserver
during this subscription phase and providing a newCompletableObserver
, containing the custom operator's intended business logic, that will be used in the subscription process going further upstream.This method requires advanced knowledge about building operators, please consider other standard composition methods first; Returns aFlowable
which, when subscribed to, invokes theapply(Subscriber)
method of the providedFlowableOperator
for each individual downstreamSubscriber
and allows the insertion of a custom operator by accessing the downstream'sSubscriber
during this subscription phase and providing a newSubscriber
, containing the custom operator's intended business logic, that will be used in the subscription process going further upstream.This method requires advanced knowledge about building operators, please consider other standard composition methods first; Returns aMaybe
which, when subscribed to, invokes theapply(MaybeObserver)
method of the providedMaybeOperator
for each individual downstreamMaybe
and allows the insertion of a custom operator by accessing the downstream'sMaybeObserver
during this subscription phase and providing a newMaybeObserver
, containing the custom operator's intended business logic, that will be used in the subscription process going further upstream.final <@NonNull R>
@NonNull Observable<R> This method requires advanced knowledge about building operators, please consider other standard composition methods first; Returns anObservable
which, when subscribed to, invokes theapply(Observer)
method of the providedObservableOperator
for each individual downstreamObserver
and allows the insertion of a custom operator by accessing the downstream'sObserver
during this subscription phase and providing a newObserver
, containing the custom operator's intended business logic, that will be used in the subscription process going further upstream.This method requires advanced knowledge about building operators, please consider other standard composition methods first; Returns aSingle
which, when subscribed to, invokes theapply(SingleObserver)
method of the providedSingleOperator
for each individual downstreamSingle
and allows the insertion of a custom operator by accessing the downstream'sSingleObserver
during this subscription phase and providing a newSingleObserver
, containing the custom operator's intended business logic, that will be used in the subscription process going further upstream.Returns aFlowable
that applies a specified function to each item emitted by the currentFlowable
and emits the results of these function applications.Returns aMaybe
that applies a specified function to the item emitted by the currentMaybe
and emits the result of this function application.final <@NonNull R>
@NonNull Observable<R> Returns anObservable
that applies a specified function to each item emitted by the currentObservable
and emits the results of these function applications.Returns aSingle
that applies a specified function to the item emitted by the currentSingle
and emits the result of this function application.Flowable.mapOptional
(@NonNull Function<? super @NonNull T, @NonNull Optional<? extends @NonNull R>> mapper) Maps each upstream value into anOptional
and emits the contained item if not empty.Maybe.mapOptional
(@NonNull Function<? super @NonNull T, @NonNull Optional<? extends @NonNull R>> mapper) Maps the upstream success value into anOptional
and emits the contained item if not empty.final <@NonNull R>
@NonNull Observable<R> Observable.mapOptional
(@NonNull Function<? super @NonNull T, @NonNull Optional<? extends @NonNull R>> mapper) Maps each upstream value into anOptional
and emits the contained item if not empty.Single.mapOptional
(@NonNull Function<? super @NonNull T, @NonNull Optional<? extends @NonNull R>> mapper) static @NonNull Completable
Completable.merge
(@NonNull Iterable<@NonNull ? extends CompletableSource> sources) Returns aCompletable
instance that subscribes to all sources at once and completes only when all sourceCompletableSource
s complete or one of them emits an error.static @NonNull Completable
Completable.merge
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends CompletableSource> sources) Returns aCompletable
instance that subscribes to all sources at once and completes only when all sourceCompletableSource
s complete or one of them emits an error.static @NonNull Completable
Completable.merge
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends CompletableSource> sources, int maxConcurrency) Returns aCompletable
instance that keeps subscriptions to a limited number of sources at once and completes only when all sourceCompletableSource
s complete or one of them emits an error.Flowable.merge
(@NonNull Iterable<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources) Flowable.merge
(@NonNull Iterable<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources, int maxConcurrency) Flattens anIterable
ofPublisher
s into onePublisher
, without any transformation, while limiting the number of concurrent subscriptions to thesePublisher
s.Flowable.merge
(@NonNull Iterable<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources, int maxConcurrency, int bufferSize) Flattens anIterable
ofPublisher
s into onePublisher
, without any transformation, while limiting the number of concurrent subscriptions to thesePublisher
s.Flowable.merge
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source2) Flattens twoPublisher
s into a singlePublisher
, without any transformation.Flowable.merge
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source2) Flattens twoPublisher
s into a singlePublisher
, without any transformation.Flowable.merge
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source3) Flattens threePublisher
s into a singlePublisher
, without any transformation.Flowable.merge
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source3) Flattens threePublisher
s into a singlePublisher
, without any transformation.Flowable.merge
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source3) Flattens threePublisher
s into a singlePublisher
, without any transformation.Flowable.merge
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source4) Flattens fourPublisher
s into a singlePublisher
, without any transformation.Flowable.merge
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source4) Flattens fourPublisher
s into a singlePublisher
, without any transformation.Flowable.merge
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source4) Flattens fourPublisher
s into a singlePublisher
, without any transformation.Flowable.merge
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source4) Flattens fourPublisher
s into a singlePublisher
, without any transformation.Flowable.merge
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources) Flattens aPublisher
that emitsPublisher
s into a singlePublisher
that emits the items emitted by thosPublisher
s , without any transformation.Flowable.merge
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources, int maxConcurrency) Flattens aPublisher
that emitsPublisher
s into a singlePublisher
that emits the items emitted by thosePublisher
s, without any transformation, while limiting the maximum number of concurrent subscriptions to thesePublisher
s.Maybe.merge
(@NonNull MaybeSource<? extends MaybeSource<? extends @NonNull T>> source) Flattens aMaybeSource
that emits aMaybeSource
into a singleMaybeSource
that emits the item emitted by the nestedMaybeSource
, without any transformation.Maybe.merge
(@NonNull MaybeSource<? extends @NonNull T> source1, @NonNull MaybeSource<? extends @NonNull T> source2) Flattens twoMaybeSource
s into a singleFlowable
, without any transformation.Maybe.merge
(@NonNull MaybeSource<? extends @NonNull T> source1, @NonNull MaybeSource<? extends @NonNull T> source2) Flattens twoMaybeSource
s into a singleFlowable
, without any transformation.Maybe.merge
(@NonNull MaybeSource<? extends @NonNull T> source1, @NonNull MaybeSource<? extends @NonNull T> source2, @NonNull MaybeSource<? extends @NonNull T> source3) Flattens threeMaybeSource
s into a singleFlowable
, without any transformation.Maybe.merge
(@NonNull MaybeSource<? extends @NonNull T> source1, @NonNull MaybeSource<? extends @NonNull T> source2, @NonNull MaybeSource<? extends @NonNull T> source3) Flattens threeMaybeSource
s into a singleFlowable
, without any transformation.Maybe.merge
(@NonNull MaybeSource<? extends @NonNull T> source1, @NonNull MaybeSource<? extends @NonNull T> source2, @NonNull MaybeSource<? extends @NonNull T> source3) Flattens threeMaybeSource
s into a singleFlowable
, without any transformation.Maybe.merge
(@NonNull MaybeSource<? extends @NonNull T> source1, @NonNull MaybeSource<? extends @NonNull T> source2, @NonNull MaybeSource<? extends @NonNull T> source3, @NonNull MaybeSource<? extends @NonNull T> source4) Flattens fourMaybeSource
s into a singleFlowable
, without any transformation.Maybe.merge
(@NonNull MaybeSource<? extends @NonNull T> source1, @NonNull MaybeSource<? extends @NonNull T> source2, @NonNull MaybeSource<? extends @NonNull T> source3, @NonNull MaybeSource<? extends @NonNull T> source4) Flattens fourMaybeSource
s into a singleFlowable
, without any transformation.Maybe.merge
(@NonNull MaybeSource<? extends @NonNull T> source1, @NonNull MaybeSource<? extends @NonNull T> source2, @NonNull MaybeSource<? extends @NonNull T> source3, @NonNull MaybeSource<? extends @NonNull T> source4) Flattens fourMaybeSource
s into a singleFlowable
, without any transformation.Maybe.merge
(@NonNull MaybeSource<? extends @NonNull T> source1, @NonNull MaybeSource<? extends @NonNull T> source2, @NonNull MaybeSource<? extends @NonNull T> source3, @NonNull MaybeSource<? extends @NonNull T> source4) Flattens fourMaybeSource
s into a singleFlowable
, without any transformation.Merges anIterable
sequence ofMaybeSource
instances into a singleFlowable
sequence, running allMaybeSource
s at once.Maybe.merge
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources) Merges aPublisher
sequence ofMaybeSource
instances into a singleFlowable
sequence, running allMaybeSource
s at once.Maybe.merge
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources, int maxConcurrency) Merges aPublisher
sequence ofMaybeSource
instances into a singleFlowable
sequence, running at most maxConcurrencyMaybeSource
s at once.static <@NonNull T>
@NonNull Observable<T> Observable.merge
(@NonNull ObservableSource<? extends ObservableSource<? extends @NonNull T>> sources) Flattens anObservableSource
that emitsObservableSource
s into a singleObservable
that emits the items emitted by thoseObservableSource
s, without any transformation.static <@NonNull T>
@NonNull Observable<T> Observable.merge
(@NonNull ObservableSource<? extends ObservableSource<? extends @NonNull T>> sources, int maxConcurrency) Flattens anObservableSource
that emitsObservableSource
s into a singleObservable
that emits the items emitted by thoseObservableSource
s, without any transformation, while limiting the maximum number of concurrent subscriptions to theseObservableSource
s.static <@NonNull T>
@NonNull Observable<T> Observable.merge
(@NonNull ObservableSource<? extends @NonNull T> source1, @NonNull ObservableSource<? extends @NonNull T> source2) Flattens twoObservableSource
s into a singleObservable
, without any transformation.static <@NonNull T>
@NonNull Observable<T> Observable.merge
(@NonNull ObservableSource<? extends @NonNull T> source1, @NonNull ObservableSource<? extends @NonNull T> source2) Flattens twoObservableSource
s into a singleObservable
, without any transformation.static <@NonNull T>
@NonNull Observable<T> Observable.merge
(@NonNull ObservableSource<? extends @NonNull T> source1, @NonNull ObservableSource<? extends @NonNull T> source2, @NonNull ObservableSource<? extends @NonNull T> source3) Flattens threeObservableSource
s into a singleObservable
, without any transformation.static <@NonNull T>
@NonNull Observable<T> Observable.merge
(@NonNull ObservableSource<? extends @NonNull T> source1, @NonNull ObservableSource<? extends @NonNull T> source2, @NonNull ObservableSource<? extends @NonNull T> source3) Flattens threeObservableSource
s into a singleObservable
, without any transformation.static <@NonNull T>
@NonNull Observable<T> Observable.merge
(@NonNull ObservableSource<? extends @NonNull T> source1, @NonNull ObservableSource<? extends @NonNull T> source2, @NonNull ObservableSource<? extends @NonNull T> source3) Flattens threeObservableSource
s into a singleObservable
, without any transformation.static <@NonNull T>
@NonNull Observable<T> Observable.merge
(@NonNull ObservableSource<? extends @NonNull T> source1, @NonNull ObservableSource<? extends @NonNull T> source2, @NonNull ObservableSource<? extends @NonNull T> source3, @NonNull ObservableSource<? extends @NonNull T> source4) Flattens fourObservableSource
s into a singleObservable
, without any transformation.static <@NonNull T>
@NonNull Observable<T> Observable.merge
(@NonNull ObservableSource<? extends @NonNull T> source1, @NonNull ObservableSource<? extends @NonNull T> source2, @NonNull ObservableSource<? extends @NonNull T> source3, @NonNull ObservableSource<? extends @NonNull T> source4) Flattens fourObservableSource
s into a singleObservable
, without any transformation.static <@NonNull T>
@NonNull Observable<T> Observable.merge
(@NonNull ObservableSource<? extends @NonNull T> source1, @NonNull ObservableSource<? extends @NonNull T> source2, @NonNull ObservableSource<? extends @NonNull T> source3, @NonNull ObservableSource<? extends @NonNull T> source4) Flattens fourObservableSource
s into a singleObservable
, without any transformation.static <@NonNull T>
@NonNull Observable<T> Observable.merge
(@NonNull ObservableSource<? extends @NonNull T> source1, @NonNull ObservableSource<? extends @NonNull T> source2, @NonNull ObservableSource<? extends @NonNull T> source3, @NonNull ObservableSource<? extends @NonNull T> source4) Flattens fourObservableSource
s into a singleObservable
, without any transformation.static <@NonNull T>
@NonNull Observable<T> Observable.merge
(@NonNull Iterable<@NonNull ? extends ObservableSource<? extends @NonNull T>> sources) static <@NonNull T>
@NonNull Observable<T> Observable.merge
(@NonNull Iterable<@NonNull ? extends ObservableSource<? extends @NonNull T>> sources, int maxConcurrency) Flattens anIterable
ofObservableSource
s into oneObservable
, without any transformation, while limiting the number of concurrent subscriptions to theseObservableSource
s.static <@NonNull T>
@NonNull Observable<T> Observable.merge
(@NonNull Iterable<@NonNull ? extends ObservableSource<? extends @NonNull T>> sources, int maxConcurrency, int bufferSize) Flattens anIterable
ofObservableSource
s into oneObservable
, without any transformation, while limiting the number of concurrent subscriptions to theseObservableSource
s.Single.merge
(@NonNull SingleSource<? extends SingleSource<? extends @NonNull T>> source) Flattens aSingleSource
that emits aSingleSingle
into a singleSingle
that emits the item emitted by the nestedSingleSource
, without any transformation.Single.merge
(@NonNull SingleSource<? extends @NonNull T> source1, @NonNull SingleSource<? extends @NonNull T> source2) Flattens twoSingleSource
s into oneFlowable
sequence, without any transformation.Single.merge
(@NonNull SingleSource<? extends @NonNull T> source1, @NonNull SingleSource<? extends @NonNull T> source2) Flattens twoSingleSource
s into oneFlowable
sequence, without any transformation.Single.merge
(@NonNull SingleSource<? extends @NonNull T> source1, @NonNull SingleSource<? extends @NonNull T> source2, @NonNull SingleSource<? extends @NonNull T> source3) Flattens threeSingleSource
s into oneFlowable
sequence, without any transformation.Single.merge
(@NonNull SingleSource<? extends @NonNull T> source1, @NonNull SingleSource<? extends @NonNull T> source2, @NonNull SingleSource<? extends @NonNull T> source3) Flattens threeSingleSource
s into oneFlowable
sequence, without any transformation.Single.merge
(@NonNull SingleSource<? extends @NonNull T> source1, @NonNull SingleSource<? extends @NonNull T> source2, @NonNull SingleSource<? extends @NonNull T> source3) Flattens threeSingleSource
s into oneFlowable
sequence, without any transformation.Single.merge
(@NonNull SingleSource<? extends @NonNull T> source1, @NonNull SingleSource<? extends @NonNull T> source2, @NonNull SingleSource<? extends @NonNull T> source3, @NonNull SingleSource<? extends @NonNull T> source4) Flattens fourSingleSource
s into oneFlowable
sequence, without any transformation.Single.merge
(@NonNull SingleSource<? extends @NonNull T> source1, @NonNull SingleSource<? extends @NonNull T> source2, @NonNull SingleSource<? extends @NonNull T> source3, @NonNull SingleSource<? extends @NonNull T> source4) Flattens fourSingleSource
s into oneFlowable
sequence, without any transformation.Single.merge
(@NonNull SingleSource<? extends @NonNull T> source1, @NonNull SingleSource<? extends @NonNull T> source2, @NonNull SingleSource<? extends @NonNull T> source3, @NonNull SingleSource<? extends @NonNull T> source4) Flattens fourSingleSource
s into oneFlowable
sequence, without any transformation.Single.merge
(@NonNull SingleSource<? extends @NonNull T> source1, @NonNull SingleSource<? extends @NonNull T> source2, @NonNull SingleSource<? extends @NonNull T> source3, @NonNull SingleSource<? extends @NonNull T> source4) Flattens fourSingleSource
s into oneFlowable
sequence, without any transformation.Merges anIterable
sequence ofSingleSource
instances into a singleFlowable
sequence, running allSingleSource
s at once.Single.merge
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends SingleSource<? extends @NonNull T>> sources) Merges a sequence ofSingleSource
instances emitted by aPublisher
into a singleFlowable
sequence, running allSingleSource
s at once.private static @NonNull Completable
Completable.merge0
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends CompletableSource> sources, int maxConcurrency, boolean delayErrors) Returns aCompletable
instance that keeps subscriptions to a limited number ofCompletableSource
s at once and completes only when all sourceCompletableSource
s terminate in one way or another, combining any exceptions signaled by either the sourcePublisher
or the innerCompletableSource
instances.static @NonNull Completable
Completable.mergeArray
(@NonNull CompletableSource... sources) Returns aCompletable
instance that subscribes to all sources at once and completes only when all sourceCompletableSource
s complete or one of them emits an error.Flowable.mergeArray
(int maxConcurrency, int bufferSize, @NonNull org.reactivestreams.Publisher<? extends @NonNull T>... sources) Flattens an array ofPublisher
s into onePublisher
, without any transformation, while limiting the number of concurrent subscriptions to thesePublisher
s.Flowable.mergeArray
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T>... sources) Flattens an array ofPublisher
s into onePublisher
, without any transformation.static <@NonNull T>
@NonNull Observable<T> Observable.mergeArray
(int maxConcurrency, int bufferSize, @NonNull ObservableSource<? extends @NonNull T>... sources) Flattens an array ofObservableSource
s into oneObservable
, without any transformation, while limiting the number of concurrent subscriptions to theseObservableSource
s.static <@NonNull T>
@NonNull Observable<T> Observable.mergeArray
(@NonNull ObservableSource<? extends @NonNull T>... sources) Flattens an array ofObservableSource
s into oneObservable
, without any transformation.static @NonNull Completable
Completable.mergeArrayDelayError
(@NonNull CompletableSource... sources) Returns aCompletable
that subscribes to allCompletableSource
s in the source array and delays any error emitted by any of the innerCompletableSource
s until all of them terminate in a way or another.Flowable.mergeArrayDelayError
(int maxConcurrency, int bufferSize, @NonNull org.reactivestreams.Publisher<? extends @NonNull T>... sources) Flattens an array ofPublisher
s into onePublisher
, in a way that allows aSubscriber
to receive all successfully emitted items from each of the sourcePublisher
s without being interrupted by an error notification from one of them, while limiting the number of concurrent subscriptions to thesePublisher
s.Flowable.mergeArrayDelayError
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T>... sources) Flattens an array ofPublisher
s into oneFlowable
, in a way that allows aSubscriber
to receive all successfully emitted items from each of the sourcePublisher
s without being interrupted by an error notification from one of them.Maybe.mergeArrayDelayError
(@NonNull MaybeSource<? extends @NonNull T>... sources) Flattens an array ofMaybeSource
s into oneFlowable
, in a way that allows a subscriber to receive all successfully emitted items from each of the sourceMaybeSource
s without being interrupted by an error notification from one of them.static <@NonNull T>
@NonNull Observable<T> Observable.mergeArrayDelayError
(int maxConcurrency, int bufferSize, @NonNull ObservableSource<? extends @NonNull T>... sources) Flattens an array ofObservableSource
s into oneObservable
, in a way that allows anObserver
to receive all successfully emitted items from each of theObservableSource
s without being interrupted by an error notification from one of them, while limiting the number of concurrent subscriptions to theseObservableSource
s.static <@NonNull T>
@NonNull Observable<T> Observable.mergeArrayDelayError
(@NonNull ObservableSource<? extends @NonNull T>... sources) Flattens an array ofObservableSource
s into oneObservable
, in a way that allows anObserver
to receive all successfully emitted items from each of theObservableSource
s without being interrupted by an error notification from one of them.Single.mergeArrayDelayError
(@NonNull SingleSource<? extends @NonNull T>... sources) Flattens an array ofSingleSource
s into oneFlowable
, in a way that allows a subscriber to receive all successfully emitted items from each of the sourceSingleSource
s without being interrupted by an error notification from one of them.static @NonNull Completable
Completable.mergeDelayError
(@NonNull Iterable<@NonNull ? extends CompletableSource> sources) Returns aCompletable
that subscribes to allCompletableSource
s in the source sequence and delays any error emitted by any of the innerCompletableSource
s until all of them terminate in a way or another.static @NonNull Completable
Completable.mergeDelayError
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends CompletableSource> sources) Returns aCompletable
that subscribes to allCompletableSource
s in the source sequence and delays any error emitted by either the sourcesPublisher
or any of the innerCompletableSource
s 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 aCompletable
that subscribes to a limited number of innerCompletableSource
s at once in the source sequence and delays any error emitted by either the sourcesPublisher
or any of the innerCompletableSource
s until all of them terminate in a way or another.Flowable.mergeDelayError
(@NonNull Iterable<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources) Flattens anIterable
ofPublisher
s into onePublisher
, in a way that allows aSubscriber
to receive all successfully emitted items from each of the sourcePublisher
s without being interrupted by an error notification from one of them.Flowable.mergeDelayError
(@NonNull Iterable<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources, int maxConcurrency) Flattens anIterable
ofPublisher
s into onePublisher
, in a way that allows aSubscriber
to receive all successfully emitted items from each of the sourcePublisher
s without being interrupted by an error notification from one of them, while limiting the number of concurrent subscriptions to thesePublisher
s.Flowable.mergeDelayError
(@NonNull Iterable<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources, int maxConcurrency, int bufferSize) Flattens anIterable
ofPublisher
s into onePublisher
, in a way that allows aSubscriber
to receive all successfully emitted items from each of the sourcePublisher
s without being interrupted by an error notification from one of them, while limiting the number of concurrent subscriptions to thesePublisher
s.Flowable.mergeDelayError
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source2) Flattens twoPublisher
s into onePublisher
, in a way that allows aSubscriber
to receive all successfully emitted items from each of the sourcePublisher
s without being interrupted by an error notification from one of them.Flowable.mergeDelayError
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source2) Flattens twoPublisher
s into onePublisher
, in a way that allows aSubscriber
to receive all successfully emitted items from each of the sourcePublisher
s without being interrupted by an error notification from one of them.Flowable.mergeDelayError
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source3) Flattens threePublisher
s into onePublisher
, in a way that allows aSubscriber
to receive all successfully emitted items from all of the sourcePublisher
s without being interrupted by an error notification from one of them.Flowable.mergeDelayError
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source3) Flattens threePublisher
s into onePublisher
, in a way that allows aSubscriber
to receive all successfully emitted items from all of the sourcePublisher
s without being interrupted by an error notification from one of them.Flowable.mergeDelayError
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source3) Flattens threePublisher
s into onePublisher
, in a way that allows aSubscriber
to receive all successfully emitted items from all of the sourcePublisher
s without being interrupted by an error notification from one of them.Flowable.mergeDelayError
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source4) Flattens fourPublisher
s into onePublisher
, in a way that allows aSubscriber
to receive all successfully emitted items from all of the sourcePublisher
s without being interrupted by an error notification from one of them.Flowable.mergeDelayError
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source4) Flattens fourPublisher
s into onePublisher
, in a way that allows aSubscriber
to receive all successfully emitted items from all of the sourcePublisher
s without being interrupted by an error notification from one of them.Flowable.mergeDelayError
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source4) Flattens fourPublisher
s into onePublisher
, in a way that allows aSubscriber
to receive all successfully emitted items from all of the sourcePublisher
s without being interrupted by an error notification from one of them.Flowable.mergeDelayError
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source4) Flattens fourPublisher
s into onePublisher
, in a way that allows aSubscriber
to receive all successfully emitted items from all of the sourcePublisher
s without being interrupted by an error notification from one of them.Flowable.mergeDelayError
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources) Flattens aPublisher
that emitsPublisher
s into onePublisher
, in a way that allows aSubscriber
to receive all successfully emitted items from all of the sourcePublisher
s without being interrupted by an error notification from one of them.Flowable.mergeDelayError
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources, int maxConcurrency) Flattens aPublisher
that emitsPublisher
s into onePublisher
, in a way that allows aSubscriber
to receive all successfully emitted items from all of the sourcePublisher
s without being interrupted by an error notification from one of them, while limiting the number of concurrent subscriptions to thesePublisher
s.Maybe.mergeDelayError
(@NonNull MaybeSource<? extends @NonNull T> source1, @NonNull MaybeSource<? extends @NonNull T> source2) Flattens twoMaybeSource
s into oneFlowable
, in a way that allows a subscriber to receive all successfully emitted items from each of the sourceMaybeSource
s without being interrupted by an error notification from one of them.Maybe.mergeDelayError
(@NonNull MaybeSource<? extends @NonNull T> source1, @NonNull MaybeSource<? extends @NonNull T> source2) Flattens twoMaybeSource
s into oneFlowable
, in a way that allows a subscriber to receive all successfully emitted items from each of the sourceMaybeSource
s without being interrupted by an error notification from one of them.Maybe.mergeDelayError
(@NonNull MaybeSource<? extends @NonNull T> source1, @NonNull MaybeSource<? extends @NonNull T> source2, @NonNull MaybeSource<? extends @NonNull T> source3) Flattens threeMaybeSource
into oneFlowable
, in a way that allows a subscriber to receive all successfully emitted items from all of the sourceMaybeSource
s without being interrupted by an error notification from one of them.Maybe.mergeDelayError
(@NonNull MaybeSource<? extends @NonNull T> source1, @NonNull MaybeSource<? extends @NonNull T> source2, @NonNull MaybeSource<? extends @NonNull T> source3) Flattens threeMaybeSource
into oneFlowable
, in a way that allows a subscriber to receive all successfully emitted items from all of the sourceMaybeSource
s without being interrupted by an error notification from one of them.Maybe.mergeDelayError
(@NonNull MaybeSource<? extends @NonNull T> source1, @NonNull MaybeSource<? extends @NonNull T> source2, @NonNull MaybeSource<? extends @NonNull T> source3) Flattens threeMaybeSource
into oneFlowable
, in a way that allows a subscriber to receive all successfully emitted items from all of the sourceMaybeSource
s without being interrupted by an error notification from one of them.Maybe.mergeDelayError
(@NonNull MaybeSource<? extends @NonNull T> source1, @NonNull MaybeSource<? extends @NonNull T> source2, @NonNull MaybeSource<? extends @NonNull T> source3, @NonNull MaybeSource<? extends @NonNull T> source4) Flattens fourMaybeSource
s into oneFlowable
, in a way that allows a subscriber to receive all successfully emitted items from all of the sourceMaybeSource
s without being interrupted by an error notification from one of them.Maybe.mergeDelayError
(@NonNull MaybeSource<? extends @NonNull T> source1, @NonNull MaybeSource<? extends @NonNull T> source2, @NonNull MaybeSource<? extends @NonNull T> source3, @NonNull MaybeSource<? extends @NonNull T> source4) Flattens fourMaybeSource
s into oneFlowable
, in a way that allows a subscriber to receive all successfully emitted items from all of the sourceMaybeSource
s without being interrupted by an error notification from one of them.Maybe.mergeDelayError
(@NonNull MaybeSource<? extends @NonNull T> source1, @NonNull MaybeSource<? extends @NonNull T> source2, @NonNull MaybeSource<? extends @NonNull T> source3, @NonNull MaybeSource<? extends @NonNull T> source4) Flattens fourMaybeSource
s into oneFlowable
, in a way that allows a subscriber to receive all successfully emitted items from all of the sourceMaybeSource
s without being interrupted by an error notification from one of them.Maybe.mergeDelayError
(@NonNull MaybeSource<? extends @NonNull T> source1, @NonNull MaybeSource<? extends @NonNull T> source2, @NonNull MaybeSource<? extends @NonNull T> source3, @NonNull MaybeSource<? extends @NonNull T> source4) Flattens fourMaybeSource
s into oneFlowable
, in a way that allows a subscriber to receive all successfully emitted items from all of the sourceMaybeSource
s without being interrupted by an error notification from one of them.Maybe.mergeDelayError
(@NonNull Iterable<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources) Flattens anIterable
sequence ofMaybeSource
s into oneFlowable
, in a way that allows a subscriber to receive all successfully emitted items from each of the sourceMaybeSource
s without being interrupted by an error notification from one of them.Maybe.mergeDelayError
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources) Flattens aPublisher
that emitsMaybeSource
s into oneFlowable
, in a way that allows a subscriber to receive all successfully emitted items from all of the sourceMaybeSource
s without being interrupted by an error notification from one of them or even the mainPublisher
.Maybe.mergeDelayError
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources, int maxConcurrency) Flattens aPublisher
that emitsMaybeSource
s into oneFlowable
, in a way that allows a subscriber to receive all successfully emitted items from all of the sourceMaybeSource
s without being interrupted by an error notification from one of them or even the mainPublisher
as well as limiting the total number of activeMaybeSource
s.static <@NonNull T>
@NonNull Observable<T> Observable.mergeDelayError
(@NonNull ObservableSource<? extends ObservableSource<? extends @NonNull T>> sources) Flattens anObservableSource
that emitsObservableSource
s into oneObservable
, in a way that allows anObserver
to receive all successfully emitted items from all of the emittedObservableSource
s without being interrupted by an error notification from one of them.static <@NonNull T>
@NonNull Observable<T> Observable.mergeDelayError
(@NonNull ObservableSource<? extends ObservableSource<? extends @NonNull T>> sources, int maxConcurrency) Flattens anObservableSource
that emitsObservableSource
s into oneObservable
, in a way that allows anObserver
to receive all successfully emitted items from all of the emittedObservableSource
s without being interrupted by an error notification from one of them, while limiting the number of concurrent subscriptions to theseObservableSource
s.static <@NonNull T>
@NonNull Observable<T> Observable.mergeDelayError
(@NonNull ObservableSource<? extends @NonNull T> source1, @NonNull ObservableSource<? extends @NonNull T> source2) Flattens twoObservableSource
s into oneObservable
, in a way that allows anObserver
to receive all successfully emitted items from each of theObservableSource
s without being interrupted by an error notification from one of them.static <@NonNull T>
@NonNull Observable<T> Observable.mergeDelayError
(@NonNull ObservableSource<? extends @NonNull T> source1, @NonNull ObservableSource<? extends @NonNull T> source2) Flattens twoObservableSource
s into oneObservable
, in a way that allows anObserver
to receive all successfully emitted items from each of theObservableSource
s without being interrupted by an error notification from one of them.static <@NonNull T>
@NonNull Observable<T> Observable.mergeDelayError
(@NonNull ObservableSource<? extends @NonNull T> source1, @NonNull ObservableSource<? extends @NonNull T> source2, @NonNull ObservableSource<? extends @NonNull T> source3) Flattens threeObservableSource
s into oneObservable
, in a way that allows anObserver
to receive all successfully emitted items from all of theObservableSource
s without being interrupted by an error notification from one of them.static <@NonNull T>
@NonNull Observable<T> Observable.mergeDelayError
(@NonNull ObservableSource<? extends @NonNull T> source1, @NonNull ObservableSource<? extends @NonNull T> source2, @NonNull ObservableSource<? extends @NonNull T> source3) Flattens threeObservableSource
s into oneObservable
, in a way that allows anObserver
to receive all successfully emitted items from all of theObservableSource
s without being interrupted by an error notification from one of them.static <@NonNull T>
@NonNull Observable<T> Observable.mergeDelayError
(@NonNull ObservableSource<? extends @NonNull T> source1, @NonNull ObservableSource<? extends @NonNull T> source2, @NonNull ObservableSource<? extends @NonNull T> source3) Flattens threeObservableSource
s into oneObservable
, in a way that allows anObserver
to receive all successfully emitted items from all of theObservableSource
s without being interrupted by an error notification from one of them.static <@NonNull T>
@NonNull Observable<T> Observable.mergeDelayError
(@NonNull ObservableSource<? extends @NonNull T> source1, @NonNull ObservableSource<? extends @NonNull T> source2, @NonNull ObservableSource<? extends @NonNull T> source3, @NonNull ObservableSource<? extends @NonNull T> source4) Flattens fourObservableSource
s into oneObservable
, in a way that allows anObserver
to receive all successfully emitted items from all of theObservableSource
s without being interrupted by an error notification from one of them.static <@NonNull T>
@NonNull Observable<T> Observable.mergeDelayError
(@NonNull ObservableSource<? extends @NonNull T> source1, @NonNull ObservableSource<? extends @NonNull T> source2, @NonNull ObservableSource<? extends @NonNull T> source3, @NonNull ObservableSource<? extends @NonNull T> source4) Flattens fourObservableSource
s into oneObservable
, in a way that allows anObserver
to receive all successfully emitted items from all of theObservableSource
s without being interrupted by an error notification from one of them.static <@NonNull T>
@NonNull Observable<T> Observable.mergeDelayError
(@NonNull ObservableSource<? extends @NonNull T> source1, @NonNull ObservableSource<? extends @NonNull T> source2, @NonNull ObservableSource<? extends @NonNull T> source3, @NonNull ObservableSource<? extends @NonNull T> source4) Flattens fourObservableSource
s into oneObservable
, in a way that allows anObserver
to receive all successfully emitted items from all of theObservableSource
s without being interrupted by an error notification from one of them.static <@NonNull T>
@NonNull Observable<T> Observable.mergeDelayError
(@NonNull ObservableSource<? extends @NonNull T> source1, @NonNull ObservableSource<? extends @NonNull T> source2, @NonNull ObservableSource<? extends @NonNull T> source3, @NonNull ObservableSource<? extends @NonNull T> source4) Flattens fourObservableSource
s into oneObservable
, in a way that allows anObserver
to receive all successfully emitted items from all of theObservableSource
s without being interrupted by an error notification from one of them.static <@NonNull T>
@NonNull Observable<T> Observable.mergeDelayError
(@NonNull Iterable<@NonNull ? extends ObservableSource<? extends @NonNull T>> sources) Flattens anIterable
ofObservableSource
s into oneObservable
, in a way that allows anObserver
to receive all successfully emitted items from each of the returnedObservableSource
s without being interrupted by an error notification from one of them.static <@NonNull T>
@NonNull Observable<T> Observable.mergeDelayError
(@NonNull Iterable<@NonNull ? extends ObservableSource<? extends @NonNull T>> sources, int maxConcurrency) Flattens anIterable
ofObservableSource
s into oneObservable
, in a way that allows anObserver
to receive all successfully emitted items from each of the returnedObservableSource
s without being interrupted by an error notification from one of them, while limiting the number of concurrent subscriptions to theseObservableSource
s.static <@NonNull T>
@NonNull Observable<T> Observable.mergeDelayError
(@NonNull Iterable<@NonNull ? extends ObservableSource<? extends @NonNull T>> sources, int maxConcurrency, int bufferSize) Flattens anIterable
ofObservableSource
s into oneObservable
, in a way that allows anObserver
to receive all successfully emitted items from each of the returnedObservableSource
s without being interrupted by an error notification from one of them, while limiting the number of concurrent subscriptions to theseObservableSource
s.Single.mergeDelayError
(@NonNull SingleSource<? extends @NonNull T> source1, @NonNull SingleSource<? extends @NonNull T> source2) Flattens twoSingleSource
s into oneFlowable
, without any transformation, delaying any error(s) until all sources succeed or fail.Single.mergeDelayError
(@NonNull SingleSource<? extends @NonNull T> source1, @NonNull SingleSource<? extends @NonNull T> source2) Flattens twoSingleSource
s into oneFlowable
, without any transformation, delaying any error(s) until all sources succeed or fail.Single.mergeDelayError
(@NonNull SingleSource<? extends @NonNull T> source1, @NonNull SingleSource<? extends @NonNull T> source2, @NonNull SingleSource<? extends @NonNull T> source3) Flattens twoSingleSource
s into oneFlowable
, without any transformation, delaying any error(s) until all sources succeed or fail.Single.mergeDelayError
(@NonNull SingleSource<? extends @NonNull T> source1, @NonNull SingleSource<? extends @NonNull T> source2, @NonNull SingleSource<? extends @NonNull T> source3) Flattens twoSingleSource
s into oneFlowable
, without any transformation, delaying any error(s) until all sources succeed or fail.Single.mergeDelayError
(@NonNull SingleSource<? extends @NonNull T> source1, @NonNull SingleSource<? extends @NonNull T> source2, @NonNull SingleSource<? extends @NonNull T> source3) Flattens twoSingleSource
s into oneFlowable
, without any transformation, delaying any error(s) until all sources succeed or fail.Single.mergeDelayError
(@NonNull SingleSource<? extends @NonNull T> source1, @NonNull SingleSource<? extends @NonNull T> source2, @NonNull SingleSource<? extends @NonNull T> source3, @NonNull SingleSource<? extends @NonNull T> source4) Flattens twoSingleSource
s into oneFlowable
, without any transformation, delaying any error(s) until all sources succeed or fail.Single.mergeDelayError
(@NonNull SingleSource<? extends @NonNull T> source1, @NonNull SingleSource<? extends @NonNull T> source2, @NonNull SingleSource<? extends @NonNull T> source3, @NonNull SingleSource<? extends @NonNull T> source4) Flattens twoSingleSource
s into oneFlowable
, without any transformation, delaying any error(s) until all sources succeed or fail.Single.mergeDelayError
(@NonNull SingleSource<? extends @NonNull T> source1, @NonNull SingleSource<? extends @NonNull T> source2, @NonNull SingleSource<? extends @NonNull T> source3, @NonNull SingleSource<? extends @NonNull T> source4) Flattens twoSingleSource
s into oneFlowable
, without any transformation, delaying any error(s) until all sources succeed or fail.Single.mergeDelayError
(@NonNull SingleSource<? extends @NonNull T> source1, @NonNull SingleSource<? extends @NonNull T> source2, @NonNull SingleSource<? extends @NonNull T> source3, @NonNull SingleSource<? extends @NonNull T> source4) Flattens twoSingleSource
s into oneFlowable
, without any transformation, delaying any error(s) until all sources succeed or fail.Single.mergeDelayError
(@NonNull Iterable<@NonNull ? extends SingleSource<? extends @NonNull T>> sources) Merges anIterable
sequence ofSingleSource
instances into oneFlowable
sequence, running allSingleSource
s at once and delaying any error(s) until all sources succeed or fail.Single.mergeDelayError
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends SingleSource<? extends @NonNull T>> sources) Merges a sequence ofSingleSource
instances emitted by aPublisher
into aFlowable
sequence, running allSingleSource
s at once and delaying any error(s) until all sources succeed or fail.final @NonNull Completable
Completable.mergeWith
(@NonNull CompletableSource other) Returns aCompletable
which subscribes to this and the otherCompletableSource
and completes when both of them complete or one emits an error.Flowable.mergeWith
(@NonNull CompletableSource other) Relays the items of thisFlowable
and completes only when the otherCompletableSource
completes as well.Flowable.mergeWith
(@NonNull MaybeSource<? extends @NonNull T> other) Merges the sequence of items of thisFlowable
with the success value of the otherMaybeSource
or waits for both to complete normally if theMaybeSource
is empty.Flowable.mergeWith
(@NonNull SingleSource<? extends @NonNull T> other) Merges the sequence of items of thisFlowable
with the success value of the otherSingleSource
.Flattens this and anotherPublisher
into a singlePublisher
, without any transformation.Maybe.mergeWith
(@NonNull MaybeSource<? extends @NonNull T> other) final @NonNull Observable
<T> Observable.mergeWith
(@NonNull CompletableSource other) Relays the items of the currentObservable
and completes only when the otherCompletableSource
completes as well.final @NonNull Observable
<T> Observable.mergeWith
(@NonNull MaybeSource<? extends @NonNull T> other) Merges the sequence of items of the currentObservable
with the success value of the otherMaybeSource
or waits both to complete normally if theMaybeSource
is empty.final @NonNull Observable
<T> Observable.mergeWith
(@NonNull ObservableSource<? extends @NonNull T> other) Flattens the currentObservable
and anotherObservableSource
into a singleObservable
sequence, without any transformation.final @NonNull Observable
<T> Observable.mergeWith
(@NonNull SingleSource<? extends @NonNull T> other) Merges the sequence of items of the currentObservable
with the success value of the otherSingleSource
.Single.mergeWith
(@NonNull SingleSource<? extends @NonNull T> other) long
Returns the 'current time' of the Scheduler in the specified time unit.long
Returns the 'current time' of the Worker in the specified time unit.final @NonNull Completable
Returns aCompletable
which emits the terminal events from the thread of the specifiedScheduler
.Signals the items and terminal signals of the currentFlowable
on the specifiedScheduler
, asynchronously with a bounded buffer ofFlowable.bufferSize()
slots.Signals the items and terminal signals of the currentFlowable
on the specifiedScheduler
, asynchronously with a bounded buffer and optionally delaysonError
notifications.Signals the items and terminal signals of the currentFlowable
on the specifiedScheduler
, asynchronously with a bounded buffer of configurable size and optionally delaysonError
notifications.Wraps aMaybe
to emit its item (or notify of its error) on a specifiedScheduler
, asynchronously.final @NonNull Observable
<T> Returns anObservable
to perform the currentObservable
's emissions and notifications on a specifiedScheduler
, asynchronously with an unbounded buffer withFlowable.bufferSize()
"island size".final @NonNull Observable
<T> Returns anObservable
to perform the currentObservable
's emissions and notifications on a specifiedScheduler
, asynchronously with an unbounded buffer withFlowable.bufferSize()
"island size" and optionally delaysonError
notifications.final @NonNull Observable
<T> Returns anObservable
to perform the currentObservable
's emissions and notifications on a specifiedScheduler
, asynchronously with an unbounded buffer of configurable "island size" and optionally delaysonError
notifications.Signals the success item or the terminal signals of the currentSingle
on the specifiedScheduler
, asynchronously.Filters the items emitted by the currentFlowable
, only emitting those of the specified type.Filters the items emitted by the currentMaybe
, only emitting its success value if that is an instance of the suppliedClass
.final <@NonNull U>
@NonNull Observable<U> Filters the items emitted by the currentObservable
, only emitting those of the specified type.Filters the items emitted by the currentSingle
, only emitting its success value if that is an instance of the suppliedClass
.Flowable.onBackpressureBuffer
(int capacity, boolean delayError, boolean unbounded, @NonNull Action onOverflow) Buffers an optionally unlimited number of items from the currentFlowable
and allows it to emit as fast it can while allowing the downstream to consume the items at its own place.Flowable.onBackpressureBuffer
(int capacity, boolean delayError, boolean unbounded, @NonNull Action onOverflow, @NonNull Consumer<? super @NonNull T> onDropped) Buffers an optionally unlimited number of items from the currentFlowable
and allows it to emit as fast it can while allowing the downstream to consume the items at its own place.Flowable.onBackpressureBuffer
(int capacity, boolean delayError, boolean unbounded, @NonNull Action onOverflow, @NonNull Consumer<? super @NonNull T> onDropped) Buffers an optionally unlimited number of items from the currentFlowable
and allows it to emit as fast it can while allowing the downstream to consume the items at its own place.Flowable.onBackpressureBuffer
(int capacity, @NonNull Action onOverflow) Buffers an limited number of items from the currentFlowable
and allows it to emit as fast it can while allowing the downstream to consume the items at its own place, however, the resultingFlowable
will signal aMissingBackpressureException
viaonError
as soon as the buffer's capacity is exceeded, dropping all undelivered items, canceling the flow and calling theonOverflow
action.Flowable.onBackpressureBuffer
(long capacity, @Nullable Action onOverflow, @NonNull BackpressureOverflowStrategy overflowStrategy) Buffers an optionally unlimited number of items from the currentFlowable
and allows it to emit as fast it can while allowing the downstream to consume the items at its own place.Flowable.onBackpressureBuffer
(long capacity, @Nullable Action onOverflow, @NonNull BackpressureOverflowStrategy overflowStrategy, @NonNull Consumer<? super @NonNull T> onDropped) Buffers an optionally unlimited number of items from the currentFlowable
and allows it to emit as fast it can while allowing the downstream to consume the items at its own place.Flowable.onBackpressureBuffer
(long capacity, @Nullable Action onOverflow, @NonNull BackpressureOverflowStrategy overflowStrategy, @NonNull Consumer<? super @NonNull T> onDropped) Buffers an optionally unlimited number of items from the currentFlowable
and allows it to emit as fast it can while allowing the downstream to consume the items at its own place.Flowable.onBackpressureDrop
(@NonNull Consumer<? super @NonNull T> onDrop) Drops items from the currentFlowable
if the downstream is not ready to receive new items (indicated by a lack ofSubscription.request(long)
calls from it) and calls the givenConsumer
with such dropped items.Flowable.onBackpressureLatest
(@NonNull Consumer<? super @NonNull T> onDropped) Drops all but the latest item emitted by the currentFlowable
if the downstream is not ready to receive new items (indicated by a lack ofSubscription.request(long)
calls from it) and emits this latest item when the downstream becomes ready.Flowable.onBackpressureReduce
(@NonNull BiFunction<@NonNull T, @NonNull T, @NonNull T> reducer) Reduces a sequence of two not emitted values via a function into a single value if the downstream is not ready to receive new items (indicated by a lack ofSubscription.request(long)
calls from it) and emits this latest item when the downstream becomes ready.Flowable.onBackpressureReduce
(@NonNull Supplier<@NonNull R> supplier, @NonNull BiFunction<@NonNull R, ? super @NonNull T, @NonNull R> reducer) Reduces upstream values into an aggregate value, provided by a supplier and combined via a reducer function, while the downstream is not ready to receive items, then emits this aggregate value when the downstream becomes ready.Flowable.onBackpressureReduce
(@NonNull Supplier<@NonNull R> supplier, @NonNull BiFunction<@NonNull R, ? super @NonNull T, @NonNull R> reducer) Reduces upstream values into an aggregate value, provided by a supplier and combined via a reducer function, while the downstream is not ready to receive items, then emits this aggregate value when the downstream becomes ready.void
Signal an exception.void
Called once if the deferred computation 'throws' an exception.void
Signal aThrowable
exception.void
Signal an exception.void
Notifies theMaybeObserver
that theMaybe
has experienced an error condition.void
Notifies theObserver
that theObservable
has experienced an error condition.void
Signal an exception.void
Notifies theSingleObserver
that theSingle
has experienced an error condition.final @NonNull Completable
Completable.onErrorComplete
(@NonNull Predicate<? super Throwable> predicate) Flowable.onErrorComplete
(@NonNull Predicate<? super Throwable> predicate) Returns aFlowable
instance that if the currentFlowable
emits an error and the predicate returnstrue
, it will emit anonComplete
and swallow the throwable.Maybe.onErrorComplete
(@NonNull Predicate<? super Throwable> predicate) Returns aMaybe
instance that if thisMaybe
emits an error and the predicate returnstrue
, it will emit anonComplete
and swallow the throwable.final @NonNull Observable
<T> Observable.onErrorComplete
(@NonNull Predicate<? super Throwable> predicate) Returns anObservable
instance that if the currentObservable
emits an error and the predicate returnstrue
, it will emit anonComplete
and swallow the throwable.Single.onErrorComplete
(@NonNull Predicate<? super Throwable> predicate) Returns aMaybe
instance that if thisSingle
emits an error and the predicate returnstrue
, it will emit anonComplete
and swallow the throwable.final @NonNull Completable
Completable.onErrorResumeNext
(@NonNull Function<? super Throwable, ? extends CompletableSource> fallbackSupplier) Returns aCompletable
instance that when encounters an error from thisCompletable
, calls the specifiedmapper
Function
that returns aCompletableSource
instance for it and resumes the execution with it.Flowable.onErrorResumeNext
(@NonNull Function<? super Throwable, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> fallbackSupplier) Resumes the flow with aPublisher
returned for the failureThrowable
of the currentFlowable
by a function instead of signaling the error viaonError
.Maybe.onErrorResumeNext
(@NonNull Function<? super Throwable, ? extends MaybeSource<? extends @NonNull T>> fallbackSupplier) Resumes the flow with aMaybeSource
returned for the failureThrowable
of the currentMaybe
by a function instead of signaling the error viaonError
.final @NonNull Observable
<T> Observable.onErrorResumeNext
(@NonNull Function<? super Throwable, ? extends ObservableSource<? extends @NonNull T>> fallbackSupplier) Resumes the flow with anObservableSource
returned for the failureThrowable
of the currentObservable
by a function instead of signaling the error viaonError
.Single.onErrorResumeNext
(@NonNull Function<? super Throwable, ? extends SingleSource<? extends @NonNull T>> fallbackSupplier) Resumes the flow with aSingleSource
returned for the failureThrowable
of the currentSingle
by a function instead of signaling the error viaonError
.final @NonNull Completable
Completable.onErrorResumeWith
(@NonNull CompletableSource fallback) Resumes the flow with the givenCompletableSource
when the currentCompletable
fails instead of signaling the error viaonError
.Flowable.onErrorResumeWith
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T> fallback) Resumes the flow with the givenPublisher
when the currentFlowable
fails instead of signaling the error viaonError
.Maybe.onErrorResumeWith
(@NonNull MaybeSource<? extends @NonNull T> fallback) Resumes the flow with the givenMaybeSource
when the currentMaybe
fails instead of signaling the error viaonError
.final @NonNull Observable
<T> Observable.onErrorResumeWith
(@NonNull ObservableSource<? extends @NonNull T> fallback) Resumes the flow with the givenObservableSource
when the currentObservable
fails instead of signaling the error viaonError
.Single.onErrorResumeWith
(@NonNull SingleSource<? extends @NonNull T> fallback) Resumes the flow with the givenSingleSource
when the currentSingle
fails instead of signaling the error viaonError
.Completable.onErrorReturn
(@NonNull Function<? super Throwable, ? extends @NonNull T> itemSupplier) Ends the flow with a success item returned by a function for theThrowable
error signaled by the currentCompletable
instead of signaling the error viaonError
.Ends the flow with a last item returned by a function for theThrowable
error signaled by the currentFlowable
instead of signaling the error viaonError
.Ends the flow with a success item returned by a function for theThrowable
error signaled by the currentMaybe
instead of signaling the error viaonError
.final @NonNull Observable
<T> Ends the flow with a last item returned by a function for theThrowable
error signaled by the currentObservable
instead of signaling the error viaonError
.Ends the flow with a success item returned by a function for theThrowable
error signaled by the currentSingle
instead of signaling the error viaonError
.Completable.onErrorReturnItem
(@NonNull T item) Ends the flow with the given success item when the currentCompletable
fails instead of signaling the error viaonError
.Flowable.onErrorReturnItem
(@NonNull T item) Ends the flow with the given last item when the currentFlowable
fails instead of signaling the error viaonError
.Maybe.onErrorReturnItem
(@NonNull T item) Ends the flow with the given success item when the currentMaybe
fails instead of signaling the error viaonError
.final @NonNull Observable
<T> Observable.onErrorReturnItem
(@NonNull T item) Ends the flow with the given last item when the currentObservable
fails instead of signaling the error viaonError
.Single.onErrorReturnItem
(@NonNull T item) Signals the specified value as success in case the currentSingle
signals an error.void
Signal a normal value.void
Provides theObserver
with a new item to observe.void
CompletableObserver.onSubscribe
(@NonNull Disposable d) Called once by theCompletable
to set aDisposable
on this instance which then can be used to cancel the subscription at any time.void
FlowableSubscriber.onSubscribe
(@NonNull org.reactivestreams.Subscription s) Implementors of this method should make sure everything that needs to be visible inSubscriber.onNext(Object)
is established before callingSubscription.request(long)
.void
MaybeObserver.onSubscribe
(@NonNull Disposable d) Provides theMaybeObserver
with the means of cancelling (disposing) the connection (channel) with theMaybe
in both synchronous (from withinonSubscribe(Disposable)
itself) and asynchronous manner.void
Observer.onSubscribe
(@NonNull Disposable d) Provides theObserver
with the means of cancelling (disposing) the connection (channel) with theObservable
in both synchronous (from withinObserver.onNext(Object)
) and asynchronous manner.void
SingleObserver.onSubscribe
(@NonNull Disposable d) Provides theSingleObserver
with the means of cancelling (disposing) the connection (channel) with the Single in both synchronous (from withinonSubscribe(Disposable)
itself) and asynchronous manner.void
Signal a success value.void
Notifies theMaybeObserver
with one item and that theMaybe
has finished sending push-based notifications.void
Signal a success value.void
Notifies theSingleObserver
with a single item and that theSingle
has finished sending push-based notifications.Flowable.publish
(@NonNull Function<? super Flowable<@NonNull T>, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> selector, int prefetch) Returns aFlowable
that emits the results of invoking a specified selector on items emitted by aConnectableFlowable
that shares a single subscription to the underlying sequence.Flowable.publish
(@NonNull Function<? super Flowable<@NonNull T>, @NonNull ? extends org.reactivestreams.Publisher<@NonNull R>> selector) Returns aFlowable
that emits the results of invoking a specified selector on items emitted by aConnectableFlowable
that shares a single subscription to the underlying sequence.final <@NonNull R>
@NonNull Observable<R> Observable.publish
(@NonNull Function<? super Observable<@NonNull T>, ? extends ObservableSource<@NonNull R>> selector) Returns anObservable
that emits the results of invoking a specified selector on items emitted by aConnectableObservable
that shares a single subscription to the currentObservable
sequence.Returns aMaybe
that applies a specified accumulator function to the first item emitted by the currentFlowable
, then feeds the result of that function along with the second item emitted by the currentFlowable
into the same function, and so on until all items have been emitted by the current and finiteFlowable
, and emits the final result from the final call to your function as its sole item.Flowable.reduce
(@NonNull R seed, @NonNull BiFunction<@NonNull R, ? super @NonNull T, @NonNull R> reducer) Returns aSingle
that applies a specified accumulator function to the first item emitted by the currentFlowable
and a specified seed value, then feeds the result of that function along with the second item emitted by the currentFlowable
into the same function, and so on until all items have been emitted by the current and finiteFlowable
, emitting the final result from the final call to your function as its sole item.Returns aMaybe
that applies a specified accumulator function to the first item emitted by the currentObservable
, then feeds the result of that function along with the second item emitted by the currentObservable
into the same function, and so on until all items have been emitted by the current and finiteObservable
, and emits the final result from the final call to your function as its sole item.Observable.reduce
(@NonNull R seed, @NonNull BiFunction<@NonNull R, ? super @NonNull T, @NonNull R> reducer) Returns aSingle
that applies a specified accumulator function to the first item emitted by the currentObservable
and a specified seed value, then feeds the result of that function along with the second item emitted by the currentObservable
into the same function, and so on until all items have been emitted by the current and finiteObservable
, emitting the final result from the final call to your function as its sole item.Flowable.reduceWith
(@NonNull Supplier<@NonNull R> seedSupplier, @NonNull BiFunction<@NonNull R, ? super @NonNull T, @NonNull R> reducer) Returns aSingle
that applies a specified accumulator function to the first item emitted by the currentFlowable
and a seed value derived from calling a specifiedseedSupplier
, then feeds the result of that function along with the second item emitted by the currentFlowable
into the same function, and so on until all items have been emitted by the current and finiteFlowable
, emitting the final result from the final call to your function as its sole item.Flowable.reduceWith
(@NonNull Supplier<@NonNull R> seedSupplier, @NonNull BiFunction<@NonNull R, ? super @NonNull T, @NonNull R> reducer) Returns aSingle
that applies a specified accumulator function to the first item emitted by the currentFlowable
and a seed value derived from calling a specifiedseedSupplier
, then feeds the result of that function along with the second item emitted by the currentFlowable
into the same function, and so on until all items have been emitted by the current and finiteFlowable
, emitting the final result from the final call to your function as its sole item.Observable.reduceWith
(@NonNull Supplier<@NonNull R> seedSupplier, @NonNull BiFunction<@NonNull R, ? super @NonNull T, @NonNull R> reducer) Returns aSingle
that applies a specified accumulator function to the first item emitted by the currentObservable
and a seed value derived from calling a specifiedseedSupplier
, then feeds the result of that function along with the second item emitted by the currentObservable
into the same function, and so on until all items have been emitted by the current and finiteObservable
, emitting the final result from the final call to your function as its sole item.Observable.reduceWith
(@NonNull Supplier<@NonNull R> seedSupplier, @NonNull BiFunction<@NonNull R, ? super @NonNull T, @NonNull R> reducer) Returns aSingle
that applies a specified accumulator function to the first item emitted by the currentObservable
and a seed value derived from calling a specifiedseedSupplier
, then feeds the result of that function along with the second item emitted by the currentObservable
into the same function, and so on until all items have been emitted by the current and finiteObservable
, emitting the final result from the final call to your function as its sole item.final @NonNull Completable
Completable.repeatUntil
(@NonNull BooleanSupplier stop) Returns aCompletable
that repeatedly subscribes to thisCompletable
so long as the given stopBooleanSupplier
returnsfalse
.Flowable.repeatUntil
(@NonNull BooleanSupplier stop) Returns aFlowable
that repeats the sequence of items emitted by the currentFlowable
until the provided stop function returnstrue
.Maybe.repeatUntil
(@NonNull BooleanSupplier stop) Returns aFlowable
that repeats the sequence of items emitted by the currentMaybe
until the provided stop function returnstrue
.final @NonNull Observable
<T> Observable.repeatUntil
(@NonNull BooleanSupplier stop) Returns anObservable
that repeats the sequence of items emitted by the currentObservable
until the provided stop function returnstrue
.Single.repeatUntil
(@NonNull BooleanSupplier stop) Re-subscribes to the currentSingle
until the givenBooleanSupplier
returnstrue
and emits the success items as aFlowable
sequence.final @NonNull Completable
Completable.repeatWhen
(@NonNull Function<? super Flowable<Object>, @NonNull ? extends org.reactivestreams.Publisher<@NonNull ?>> handler) Returns aCompletable
instance that repeats when thePublisher
returned by the handlerFunction
emits an item or completes when thisPublisher
emits anonComplete
event.Flowable.repeatWhen
(@NonNull Function<? super Flowable<Object>, @NonNull ? extends org.reactivestreams.Publisher<@NonNull ?>> handler) Returns aFlowable
that emits the same values as the currentFlowable
with the exception of anonComplete
.Maybe.repeatWhen
(@NonNull Function<? super Flowable<Object>, @NonNull ? extends org.reactivestreams.Publisher<@NonNull ?>> handler) Returns aFlowable
that emits the same values as the currentMaybe
with the exception of anonComplete
.final @NonNull Observable
<T> Observable.repeatWhen
(@NonNull Function<? super Observable<Object>, ? extends ObservableSource<?>> handler) Returns anObservable
that emits the same values as the currentObservable
with the exception of anonComplete
.Single.repeatWhen
(@NonNull Function<? super Flowable<Object>, @NonNull ? extends org.reactivestreams.Publisher<@NonNull ?>> handler) Re-subscribes to the currentSingle
if thePublisher
returned by the handler function signals a value in response to a value signaled through theFlowable
the handler receives.final @NonNull ConnectableFlowable
<T> Returns aConnectableFlowable
that shares a single subscription to the currentFlowable
and replays at mostbufferSize
items that were emitted during a specified time window.final @NonNull ConnectableFlowable
<T> Returns aConnectableFlowable
that shares a single subscription to the currentFlowable
and replays a maximum ofbufferSize
items that are emitted within a specified time window to lateSubscriber
s.final @NonNull ConnectableFlowable
<T> Returns aConnectableFlowable
that shares a single subscription to the currentFlowable
and replays a maximum ofbufferSize
items that are emitted within a specified time window to lateSubscriber
s.final @NonNull ConnectableFlowable
<T> Flowable.replay
(int bufferSize, long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean eagerTruncate) Returns aConnectableFlowable
that shares a single subscription to the currentFlowable
and replays a maximum ofbufferSize
items that are emitted within a specified time window to lateSubscriber
s.final @NonNull ConnectableFlowable
<T> Flowable.replay
(int bufferSize, long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean eagerTruncate) Returns aConnectableFlowable
that shares a single subscription to the currentFlowable
and replays a maximum ofbufferSize
items that are emitted within a specified time window to lateSubscriber
s.final @NonNull ConnectableFlowable
<T> Returns aConnectableFlowable
that shares a single subscription to the currentFlowable
and replays all items emitted by it within a specified time window to lateSubscriber
s.final @NonNull ConnectableFlowable
<T> Returns aConnectableFlowable
that shares a single subscription to the currentFlowable
and replays all items emitted by it within a specified time window to lateSubscriber
s.final @NonNull ConnectableFlowable
<T> Returns aConnectableFlowable
that shares a single subscription to the currentFlowable
and replays all items emitted by it within a specified time window to lateSubscriber
s.final @NonNull ConnectableFlowable
<T> Flowable.replay
(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean eagerTruncate) Returns aConnectableFlowable
that shares a single subscription to the currentFlowable
and replays all items emitted by it within a specified time window to lateSubscriber
s.final @NonNull ConnectableFlowable
<T> Flowable.replay
(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean eagerTruncate) Returns aConnectableFlowable
that shares a single subscription to the currentFlowable
and replays all items emitted by it within a specified time window to lateSubscriber
s.Flowable.replay
(@NonNull Function<? super Flowable<@NonNull T>, @NonNull ? extends org.reactivestreams.Publisher<@NonNull R>> selector) Returns aFlowable
that emits items that are the results of invoking a specified selector on the items emitted by aConnectableFlowable
that shares a single subscription to the currentFlowable
.Flowable.replay
(@NonNull Function<? super Flowable<@NonNull T>, @NonNull ? extends org.reactivestreams.Publisher<@NonNull R>> selector, int bufferSize) Returns aFlowable
that emits items that are the results of invoking a specified selector on items emitted by aConnectableFlowable
that shares a single subscription to the currentFlowable
, replayingbufferSize
notifications.Flowable.replay
(@NonNull Function<? super Flowable<@NonNull T>, @NonNull ? extends org.reactivestreams.Publisher<@NonNull R>> selector, int bufferSize, boolean eagerTruncate) Returns aFlowable
that emits items that are the results of invoking a specified selector on items emitted by aConnectableFlowable
that shares a single subscription to the currentFlowable
, replayingbufferSize
notifications.Flowable.replay
(@NonNull Function<? super Flowable<@NonNull T>, @NonNull ? extends org.reactivestreams.Publisher<@NonNull R>> selector, int bufferSize, long time, @NonNull TimeUnit unit) Returns aFlowable
that emits items that are the results of invoking a specified selector on items emitted by aConnectableFlowable
that shares a single subscription to the currentFlowable
, replaying no more thanbufferSize
items that were emitted within a specified time window.Flowable.replay
(@NonNull Function<? super Flowable<@NonNull T>, @NonNull ? extends org.reactivestreams.Publisher<@NonNull R>> selector, int bufferSize, long time, @NonNull TimeUnit unit) Returns aFlowable
that emits items that are the results of invoking a specified selector on items emitted by aConnectableFlowable
that shares a single subscription to the currentFlowable
, replaying no more thanbufferSize
items that were emitted within a specified time window.Flowable.replay
(@NonNull Function<? super Flowable<@NonNull T>, @NonNull ? extends org.reactivestreams.Publisher<@NonNull R>> selector, int bufferSize, long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Returns aFlowable
that emits items that are the results of invoking a specified selector on items emitted by aConnectableFlowable
that shares a single subscription to the currentFlowable
, replaying no more thanbufferSize
items that were emitted within a specified time window.Flowable.replay
(@NonNull Function<? super Flowable<@NonNull T>, @NonNull ? extends org.reactivestreams.Publisher<@NonNull R>> selector, int bufferSize, long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Returns aFlowable
that emits items that are the results of invoking a specified selector on items emitted by aConnectableFlowable
that shares a single subscription to the currentFlowable
, replaying no more thanbufferSize
items that were emitted within a specified time window.Flowable.replay
(@NonNull Function<? super Flowable<@NonNull T>, @NonNull ? extends org.reactivestreams.Publisher<@NonNull R>> selector, int bufferSize, long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Returns aFlowable
that emits items that are the results of invoking a specified selector on items emitted by aConnectableFlowable
that shares a single subscription to the currentFlowable
, replaying no more thanbufferSize
items that were emitted within a specified time window.Flowable.replay
(@NonNull Function<? super Flowable<@NonNull T>, @NonNull ? extends org.reactivestreams.Publisher<@NonNull R>> selector, int bufferSize, long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean eagerTruncate) Returns aFlowable
that emits items that are the results of invoking a specified selector on items emitted by aConnectableFlowable
that shares a single subscription to the currentFlowable
, replaying no more thanbufferSize
items that were emitted within a specified time window.Flowable.replay
(@NonNull Function<? super Flowable<@NonNull T>, @NonNull ? extends org.reactivestreams.Publisher<@NonNull R>> selector, int bufferSize, long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean eagerTruncate) Returns aFlowable
that emits items that are the results of invoking a specified selector on items emitted by aConnectableFlowable
that shares a single subscription to the currentFlowable
, replaying no more thanbufferSize
items that were emitted within a specified time window.Flowable.replay
(@NonNull Function<? super Flowable<@NonNull T>, @NonNull ? extends org.reactivestreams.Publisher<@NonNull R>> selector, int bufferSize, long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean eagerTruncate) Returns aFlowable
that emits items that are the results of invoking a specified selector on items emitted by aConnectableFlowable
that shares a single subscription to the currentFlowable
, replaying no more thanbufferSize
items that were emitted within a specified time window.Flowable.replay
(@NonNull Function<? super Flowable<@NonNull T>, @NonNull ? extends org.reactivestreams.Publisher<@NonNull R>> selector, long time, @NonNull TimeUnit unit) Returns aFlowable
that emits items that are the results of invoking a specified selector on items emitted by aConnectableFlowable
that shares a single subscription to the currentFlowable
, replaying all items that were emitted within a specified time window.Flowable.replay
(@NonNull Function<? super Flowable<@NonNull T>, @NonNull ? extends org.reactivestreams.Publisher<@NonNull R>> selector, long time, @NonNull TimeUnit unit) Returns aFlowable
that emits items that are the results of invoking a specified selector on items emitted by aConnectableFlowable
that shares a single subscription to the currentFlowable
, replaying all items that were emitted within a specified time window.Flowable.replay
(@NonNull Function<? super Flowable<@NonNull T>, @NonNull ? extends org.reactivestreams.Publisher<@NonNull R>> selector, long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Returns aFlowable
that emits items that are the results of invoking a specified selector on items emitted by aConnectableFlowable
that shares a single subscription to the currentFlowable
, replaying all items that were emitted within a specified time window.Flowable.replay
(@NonNull Function<? super Flowable<@NonNull T>, @NonNull ? extends org.reactivestreams.Publisher<@NonNull R>> selector, long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Returns aFlowable
that emits items that are the results of invoking a specified selector on items emitted by aConnectableFlowable
that shares a single subscription to the currentFlowable
, replaying all items that were emitted within a specified time window.Flowable.replay
(@NonNull Function<? super Flowable<@NonNull T>, @NonNull ? extends org.reactivestreams.Publisher<@NonNull R>> selector, long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Returns aFlowable
that emits items that are the results of invoking a specified selector on items emitted by aConnectableFlowable
that shares a single subscription to the currentFlowable
, replaying all items that were emitted within a specified time window.Flowable.replay
(@NonNull Function<? super Flowable<@NonNull T>, @NonNull ? extends org.reactivestreams.Publisher<@NonNull R>> selector, long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean eagerTruncate) Returns aFlowable
that emits items that are the results of invoking a specified selector on items emitted by aConnectableFlowable
that shares a single subscription to the currentFlowable
, replaying all items that were emitted within a specified time window.Flowable.replay
(@NonNull Function<? super Flowable<@NonNull T>, @NonNull ? extends org.reactivestreams.Publisher<@NonNull R>> selector, long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean eagerTruncate) Returns aFlowable
that emits items that are the results of invoking a specified selector on items emitted by aConnectableFlowable
that shares a single subscription to the currentFlowable
, replaying all items that were emitted within a specified time window.Flowable.replay
(@NonNull Function<? super Flowable<@NonNull T>, @NonNull ? extends org.reactivestreams.Publisher<@NonNull R>> selector, long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean eagerTruncate) Returns aFlowable
that emits items that are the results of invoking a specified selector on items emitted by aConnectableFlowable
that shares a single subscription to the currentFlowable
, replaying all items that were emitted within a specified time window.final @NonNull ConnectableObservable
<T> Returns aConnectableObservable
that shares a single subscription to the currentObservable
and replays at mostbufferSize
items that were emitted during a specified time window.final @NonNull ConnectableObservable
<T> Returns aConnectableObservable
that shares a single subscription to the currentObservable
and that replays a maximum ofbufferSize
items that are emitted within a specified time window.final @NonNull ConnectableObservable
<T> Returns aConnectableObservable
that shares a single subscription to the currentObservable
and that replays a maximum ofbufferSize
items that are emitted within a specified time window.final @NonNull ConnectableObservable
<T> Observable.replay
(int bufferSize, long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean eagerTruncate) Returns aConnectableObservable
that shares a single subscription to the currentObservable
and that replays a maximum ofbufferSize
items that are emitted within a specified time window.final @NonNull ConnectableObservable
<T> Observable.replay
(int bufferSize, long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean eagerTruncate) Returns aConnectableObservable
that shares a single subscription to the currentObservable
and that replays a maximum ofbufferSize
items that are emitted within a specified time window.final @NonNull ConnectableObservable
<T> Returns aConnectableObservable
that shares a single subscription to the currentObservable
and replays all items emitted by the currentObservable
within a specified time window.final @NonNull ConnectableObservable
<T> Returns aConnectableObservable
that shares a single subscription to the currentObservable
and replays all items emitted by the currentObservable
within a specified time window.final @NonNull ConnectableObservable
<T> Returns aConnectableObservable
that shares a single subscription to the currentObservable
and replays all items emitted by the currentObservable
within a specified time window.final @NonNull ConnectableObservable
<T> Observable.replay
(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean eagerTruncate) Returns aConnectableObservable
that shares a single subscription to the currentObservable
and replays all items emitted by the currentObservable
within a specified time window.final @NonNull ConnectableObservable
<T> Observable.replay
(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean eagerTruncate) Returns aConnectableObservable
that shares a single subscription to the currentObservable
and replays all items emitted by the currentObservable
within a specified time window.final <@NonNull R>
@NonNull Observable<R> Observable.replay
(@NonNull Function<? super Observable<@NonNull T>, ? extends ObservableSource<@NonNull R>> selector) Returns anObservable
that emits items that are the results of invoking a specified selector on the items emitted by aConnectableObservable
that shares a single subscription to the currentObservable
.final <@NonNull R>
@NonNull Observable<R> Observable.replay
(@NonNull Function<? super Observable<@NonNull T>, ? extends ObservableSource<@NonNull R>> selector, int bufferSize) Returns anObservable
that emits items that are the results of invoking a specified selector on items emitted by aConnectableObservable
that shares a single subscription to the currentObservable
, replayingbufferSize
notifications.final <@NonNull R>
@NonNull Observable<R> Observable.replay
(@NonNull Function<? super Observable<@NonNull T>, ? extends ObservableSource<@NonNull R>> selector, int bufferSize, boolean eagerTruncate) Returns anObservable
that emits items that are the results of invoking a specified selector on items emitted by aConnectableObservable
that shares a single subscription to the currentObservable
, replayingbufferSize
notifications.final <@NonNull R>
@NonNull Observable<R> Observable.replay
(@NonNull Function<? super Observable<@NonNull T>, ? extends ObservableSource<@NonNull R>> selector, int bufferSize, long time, @NonNull TimeUnit unit) Returns anObservable
that emits items that are the results of invoking a specified selector on items emitted by aConnectableObservable
that shares a single subscription to the currentObservable
, replaying no more thanbufferSize
items that were emitted within a specified time window.final <@NonNull R>
@NonNull Observable<R> Observable.replay
(@NonNull Function<? super Observable<@NonNull T>, ? extends ObservableSource<@NonNull R>> selector, int bufferSize, long time, @NonNull TimeUnit unit) Returns anObservable
that emits items that are the results of invoking a specified selector on items emitted by aConnectableObservable
that shares a single subscription to the currentObservable
, replaying no more thanbufferSize
items that were emitted within a specified time window.final <@NonNull R>
@NonNull Observable<R> Observable.replay
(@NonNull Function<? super Observable<@NonNull T>, ? extends ObservableSource<@NonNull R>> selector, int bufferSize, long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Returns anObservable
that emits items that are the results of invoking a specified selector on items emitted by aConnectableObservable
that shares a single subscription to the currentObservable
, replaying no more thanbufferSize
items that were emitted within a specified time window.final <@NonNull R>
@NonNull Observable<R> Observable.replay
(@NonNull Function<? super Observable<@NonNull T>, ? extends ObservableSource<@NonNull R>> selector, int bufferSize, long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Returns anObservable
that emits items that are the results of invoking a specified selector on items emitted by aConnectableObservable
that shares a single subscription to the currentObservable
, replaying no more thanbufferSize
items that were emitted within a specified time window.final <@NonNull R>
@NonNull Observable<R> Observable.replay
(@NonNull Function<? super Observable<@NonNull T>, ? extends ObservableSource<@NonNull R>> selector, int bufferSize, long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Returns anObservable
that emits items that are the results of invoking a specified selector on items emitted by aConnectableObservable
that shares a single subscription to the currentObservable
, replaying no more thanbufferSize
items that were emitted within a specified time window.final <@NonNull R>
@NonNull Observable<R> Observable.replay
(@NonNull Function<? super Observable<@NonNull T>, ? extends ObservableSource<@NonNull R>> selector, int bufferSize, long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean eagerTruncate) Returns anObservable
that emits items that are the results of invoking a specified selector on items emitted by aConnectableObservable
that shares a single subscription to the currentObservable
, replaying no more thanbufferSize
items that were emitted within a specified time window.final <@NonNull R>
@NonNull Observable<R> Observable.replay
(@NonNull Function<? super Observable<@NonNull T>, ? extends ObservableSource<@NonNull R>> selector, int bufferSize, long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean eagerTruncate) Returns anObservable
that emits items that are the results of invoking a specified selector on items emitted by aConnectableObservable
that shares a single subscription to the currentObservable
, replaying no more thanbufferSize
items that were emitted within a specified time window.final <@NonNull R>
@NonNull Observable<R> Observable.replay
(@NonNull Function<? super Observable<@NonNull T>, ? extends ObservableSource<@NonNull R>> selector, int bufferSize, long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean eagerTruncate) Returns anObservable
that emits items that are the results of invoking a specified selector on items emitted by aConnectableObservable
that shares a single subscription to the currentObservable
, replaying no more thanbufferSize
items that were emitted within a specified time window.final <@NonNull R>
@NonNull Observable<R> Observable.replay
(@NonNull Function<? super Observable<@NonNull T>, ? extends ObservableSource<@NonNull R>> selector, long time, @NonNull TimeUnit unit) Returns anObservable
that emits items that are the results of invoking a specified selector on items emitted by aConnectableObservable
that shares a single subscription to the currentObservable
, replaying all items that were emitted within a specified time window.final <@NonNull R>
@NonNull Observable<R> Observable.replay
(@NonNull Function<? super Observable<@NonNull T>, ? extends ObservableSource<@NonNull R>> selector, long time, @NonNull TimeUnit unit) Returns anObservable
that emits items that are the results of invoking a specified selector on items emitted by aConnectableObservable
that shares a single subscription to the currentObservable
, replaying all items that were emitted within a specified time window.final <@NonNull R>
@NonNull Observable<R> Observable.replay
(@NonNull Function<? super Observable<@NonNull T>, ? extends ObservableSource<@NonNull R>> selector, long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Returns anObservable
that emits items that are the results of invoking a specified selector on items emitted by aConnectableObservable
that shares a single subscription to the currentObservable
, replaying all items that were emitted within a specified time window.final <@NonNull R>
@NonNull Observable<R> Observable.replay
(@NonNull Function<? super Observable<@NonNull T>, ? extends ObservableSource<@NonNull R>> selector, long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Returns anObservable
that emits items that are the results of invoking a specified selector on items emitted by aConnectableObservable
that shares a single subscription to the currentObservable
, replaying all items that were emitted within a specified time window.final <@NonNull R>
@NonNull Observable<R> Observable.replay
(@NonNull Function<? super Observable<@NonNull T>, ? extends ObservableSource<@NonNull R>> selector, long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Returns anObservable
that emits items that are the results of invoking a specified selector on items emitted by aConnectableObservable
that shares a single subscription to the currentObservable
, replaying all items that were emitted within a specified time window.final <@NonNull R>
@NonNull Observable<R> Observable.replay
(@NonNull Function<? super Observable<@NonNull T>, ? extends ObservableSource<@NonNull R>> selector, long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean eagerTruncate) Returns anObservable
that emits items that are the results of invoking a specified selector on items emitted by aConnectableObservable
that shares a single subscription to the currentObservable
, replaying all items that were emitted within a specified time window.final <@NonNull R>
@NonNull Observable<R> Observable.replay
(@NonNull Function<? super Observable<@NonNull T>, ? extends ObservableSource<@NonNull R>> selector, long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean eagerTruncate) Returns anObservable
that emits items that are the results of invoking a specified selector on items emitted by aConnectableObservable
that shares a single subscription to the currentObservable
, replaying all items that were emitted within a specified time window.final <@NonNull R>
@NonNull Observable<R> Observable.replay
(@NonNull Function<? super Observable<@NonNull T>, ? extends ObservableSource<@NonNull R>> selector, long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean eagerTruncate) Returns anObservable
that emits items that are the results of invoking a specified selector on items emitted by aConnectableObservable
that shares a single subscription to the currentObservable
, replaying all items that were emitted within a specified time window.final @NonNull Completable
Returns aCompletable
that when thisCompletable
emits an error, retries at most times or until the predicate returnsfalse
, whichever happens first and emitting the last error.final @NonNull Completable
Completable.retry
(@NonNull BiPredicate<? super Integer, ? super Throwable> predicate) Returns aCompletable
that retries thisCompletable
in case of an error as long as thepredicate
returnstrue
.final @NonNull Completable
Returns aCompletable
that when thisCompletable
emits an error, calls the given predicate with the latestThrowable
to decide whether to resubscribe to the upstream or not.Retries at most times or until the predicate returnsfalse
, whichever happens first.Returns aFlowable
that mirrors the currentFlowable
, resubscribing to it if it callsonError
and the predicate returnstrue
for that specific exception and retry count.Retries the currentFlowable
if the predicate returnstrue
.Retries at mosttimes
or until the predicate returnsfalse
, whichever happens first.Maybe.retry
(@NonNull BiPredicate<? super Integer, ? super Throwable> predicate) Returns aMaybe
that mirrors the currentMaybe
, resubscribing to it if it callsonError
and the predicate returnstrue
for that specific exception and retry count.Retries the currentMaybe
if it fails and the predicate returnstrue
.final @NonNull Observable
<T> Retries at most times or until the predicate returnsfalse
, whichever happens first.final @NonNull Observable
<T> Observable.retry
(@NonNull BiPredicate<? super Integer, ? super Throwable> predicate) Returns anObservable
that mirrors the currentObservable
, resubscribing to it if it callsonError
and the predicate returnstrue
for that specific exception and retry count.final @NonNull Observable
<T> Retries the currentObservable
if the predicate returnstrue
.Repeatedly re-subscribe at most times or until the predicate returnsfalse
, whichever happens first if it fails with anonError
.Single.retry
(@NonNull BiPredicate<? super Integer, ? super Throwable> predicate) Re-subscribe to the currentSingle
if the given predicate returnstrue
when theSingle
fails with anonError
.Re-subscribe to the currentSingle
if the given predicate returnstrue
when theSingle
fails with anonError
.final @NonNull Completable
Completable.retryUntil
(@NonNull BooleanSupplier stop) Retries until the given stop function returnstrue
.Flowable.retryUntil
(@NonNull BooleanSupplier stop) Retries until the given stop function returnstrue
.Maybe.retryUntil
(@NonNull BooleanSupplier stop) Retries until the given stop function returnstrue
.final @NonNull Observable
<T> Observable.retryUntil
(@NonNull BooleanSupplier stop) Retries until the given stop function returnstrue
.Single.retryUntil
(@NonNull BooleanSupplier stop) Retries until the given stop function returnstrue
.final @NonNull Completable
Completable.retryWhen
(@NonNull Function<? super Flowable<Throwable>, @NonNull ? extends org.reactivestreams.Publisher<@NonNull ?>> handler) Returns aCompletable
which given aPublisher
and when thisCompletable
emits an error, delivers that error through aFlowable
and thePublisher
should signal a value indicating a retry in response or a terminal event indicating a termination.Flowable.retryWhen
(@NonNull Function<? super Flowable<Throwable>, @NonNull ? extends org.reactivestreams.Publisher<@NonNull ?>> handler) Returns aFlowable
that emits the same values as the currentFlowable
with the exception of anonError
.Maybe.retryWhen
(@NonNull Function<? super Flowable<Throwable>, @NonNull ? extends org.reactivestreams.Publisher<@NonNull ?>> handler) Returns aMaybe
that emits the same values as the currentMaybe
with the exception of anonError
.final @NonNull Observable
<T> Observable.retryWhen
(@NonNull Function<? super Observable<Throwable>, ? extends ObservableSource<?>> handler) Returns anObservable
that emits the same values as the currentObservable
with the exception of anonError
.Single.retryWhen
(@NonNull Function<? super Flowable<Throwable>, @NonNull ? extends org.reactivestreams.Publisher<@NonNull ?>> handler) Re-subscribes to the currentSingle
if and when thePublisher
returned by the handler function signals a value.final void
Completable.safeSubscribe
(@NonNull CompletableObserver observer) Wraps the givenCompletableObserver
, catches anyRuntimeException
s thrown by itsCompletableObserver.onSubscribe(Disposable)
,CompletableObserver.onError(Throwable)
orCompletableObserver.onComplete()
methods and routes those to the global error handler viaRxJavaPlugins.onError(Throwable)
.final void
Flowable.safeSubscribe
(@NonNull org.reactivestreams.Subscriber<? super @NonNull T> subscriber) Subscribes to the currentFlowable
and wraps the givenSubscriber
into aSafeSubscriber
(if not already aSafeSubscriber
) that deals with exceptions thrown by a misbehavingSubscriber
(that doesn't follow the Reactive Streams specification).final void
Maybe.safeSubscribe
(@NonNull MaybeObserver<? super @NonNull T> observer) Wraps the givenMaybeObserver
, catches anyRuntimeException
s thrown by itsMaybeObserver.onSubscribe(Disposable)
,MaybeObserver.onSuccess(Object)
,MaybeObserver.onError(Throwable)
orMaybeObserver.onComplete()
methods and routes those to the global error handler viaRxJavaPlugins.onError(Throwable)
.final void
Observable.safeSubscribe
(@NonNull Observer<? super @NonNull T> observer) Subscribes to the currentObservable
and wraps the givenObserver
into aSafeObserver
(if not already aSafeObserver
) that deals with exceptions thrown by a misbehavingObserver
(that doesn't follow the Reactive Streams specification).final void
Single.safeSubscribe
(@NonNull SingleObserver<? super @NonNull T> observer) Wraps the givenSingleObserver
, catches anyRuntimeException
s thrown by itsSingleObserver.onSubscribe(Disposable)
,SingleObserver.onSuccess(Object)
orSingleObserver.onError(Throwable)
methods* and routes those to the global error handler viaRxJavaPlugins.onError(Throwable)
.Returns aFlowable
that emits the most recently emitted item (if any) emitted by the currentFlowable
within periodic time intervals.Returns aFlowable
that emits the most recently emitted item (if any) emitted by the currentFlowable
within periodic time intervals and optionally emit the very last upstream item when the upstream completes.Returns aFlowable
that emits the most recently emitted item (if any) emitted by the currentFlowable
within periodic time intervals, where the intervals are defined on a particularScheduler
.Returns aFlowable
that emits the most recently emitted item (if any) emitted by the currentFlowable
within periodic time intervals, where the intervals are defined on a particularScheduler
.Flowable.sample
(long period, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean emitLast) Returns aFlowable
that emits the most recently emitted item (if any) emitted by the currentFlowable
within periodic time intervals, where the intervals are defined on a particularScheduler
and optionally emit the very last upstream item when the upstream completes.Flowable.sample
(long period, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean emitLast) Returns aFlowable
that emits the most recently emitted item (if any) emitted by the currentFlowable
within periodic time intervals, where the intervals are defined on a particularScheduler
and optionally emit the very last upstream item when the upstream completes.Flowable.sample
(long period, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean emitLast, @NonNull Consumer<? super @NonNull T> onDropped) Returns aFlowable
that emits the most recently emitted item (if any) emitted by the currentFlowable
within periodic time intervals, where the intervals are defined on a particularScheduler
and optionally emit the very last upstream item when the upstream completes.Flowable.sample
(long period, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean emitLast, @NonNull Consumer<? super @NonNull T> onDropped) Returns aFlowable
that emits the most recently emitted item (if any) emitted by the currentFlowable
within periodic time intervals, where the intervals are defined on a particularScheduler
and optionally emit the very last upstream item when the upstream completes.Flowable.sample
(long period, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean emitLast, @NonNull Consumer<? super @NonNull T> onDropped) Returns aFlowable
that emits the most recently emitted item (if any) emitted by the currentFlowable
within periodic time intervals, where the intervals are defined on a particularScheduler
and optionally emit the very last upstream item when the upstream completes.Returns aFlowable
that, when the specifiedsampler
Publisher
emits an item or completes, emits the most recently emitted item (if any) emitted by the currentFlowable
since the previous emission from thesampler
Publisher
.Returns aFlowable
that, when the specifiedsampler
Publisher
emits an item or completes, emits the most recently emitted item (if any) emitted by the currentFlowable
since the previous emission from thesampler
Publisher
and optionally emit the very last upstream item when the upstream or otherPublisher
complete.final @NonNull Observable
<T> Returns anObservable
that emits the most recently emitted item (if any) emitted by the currentObservable
within periodic time intervals.final @NonNull Observable
<T> Returns anObservable
that emits the most recently emitted item (if any) emitted by the currentObservable
within periodic time intervals and optionally emit the very last upstream item when the upstream completes.final @NonNull Observable
<T> Returns anObservable
that emits the most recently emitted item (if any) emitted by the currentObservable
within periodic time intervals, where the intervals are defined on a particularScheduler
.final @NonNull Observable
<T> Returns anObservable
that emits the most recently emitted item (if any) emitted by the currentObservable
within periodic time intervals, where the intervals are defined on a particularScheduler
.final @NonNull Observable
<T> Observable.sample
(long period, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean emitLast) Returns anObservable
that emits the most recently emitted item (if any) emitted by the currentObservable
within periodic time intervals, where the intervals are defined on a particularScheduler
and optionally emit the very last upstream item when the upstream completes.final @NonNull Observable
<T> Observable.sample
(long period, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean emitLast) Returns anObservable
that emits the most recently emitted item (if any) emitted by the currentObservable
within periodic time intervals, where the intervals are defined on a particularScheduler
and optionally emit the very last upstream item when the upstream completes.final @NonNull Observable
<T> Observable.sample
(long period, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean emitLast, @NonNull Consumer<? super @NonNull T> onDropped) Returns anObservable
that emits the most recently emitted item (if any) emitted by the currentObservable
within periodic time intervals, where the intervals are defined on a particularScheduler
.final @NonNull Observable
<T> Observable.sample
(long period, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean emitLast, @NonNull Consumer<? super @NonNull T> onDropped) Returns anObservable
that emits the most recently emitted item (if any) emitted by the currentObservable
within periodic time intervals, where the intervals are defined on a particularScheduler
.final @NonNull Observable
<T> Observable.sample
(long period, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean emitLast, @NonNull Consumer<? super @NonNull T> onDropped) Returns anObservable
that emits the most recently emitted item (if any) emitted by the currentObservable
within periodic time intervals, where the intervals are defined on a particularScheduler
.final <@NonNull U>
@NonNull Observable<T> Observable.sample
(@NonNull ObservableSource<@NonNull U> sampler) Returns anObservable
that, when the specifiedsampler
ObservableSource
emits an item or completes, emits the most recently emitted item (if any) emitted by the currentObservable
since the previous emission from thesampler
ObservableSource
.final <@NonNull U>
@NonNull Observable<T> Observable.sample
(@NonNull ObservableSource<@NonNull U> sampler, boolean emitLast) Returns anObservable
that, when the specifiedsampler
ObservableSource
emits an item or completes, emits the most recently emitted item (if any) emitted by the currentObservable
since the previous emission from thesampler
ObservableSource
and optionally emit the very last upstream item when the upstream or otherObservableSource
complete.Returns aFlowable
that emits the first value emitted by the currentFlowable
, then emits one value for each subsequent value emitted by the currentFlowable
.Flowable.scan
(@NonNull R initialValue, @NonNull BiFunction<@NonNull R, ? super @NonNull T, @NonNull R> accumulator) Returns aFlowable
that emits the provided initial (seed) value, then emits one value for each value emitted by the currentFlowable
.final @NonNull Observable
<T> Returns anObservable
that emits the first value emitted by the currentObservable
, then emits one value for each subsequent value emitted by the currentObservable
.final <@NonNull R>
@NonNull Observable<R> Observable.scan
(@NonNull R initialValue, @NonNull BiFunction<@NonNull R, ? super @NonNull T, @NonNull R> accumulator) Returns anObservable
that emits the provided initial (seed) value, then emits one value for each value emitted by the currentObservable
.final <@NonNull R>
@NonNull Observable<R> Observable.scan
(@NonNull R initialValue, @NonNull BiFunction<@NonNull R, ? super @NonNull T, @NonNull R> accumulator) Returns anObservable
that emits the provided initial (seed) value, then emits one value for each value emitted by the currentObservable
.Flowable.scanWith
(@NonNull Supplier<@NonNull R> seedSupplier, @NonNull BiFunction<@NonNull R, ? super @NonNull T, @NonNull R> accumulator) Returns aFlowable
that emits the provided initial (seed) value, then emits one value for each value emitted by the currentFlowable
.Flowable.scanWith
(@NonNull Supplier<@NonNull R> seedSupplier, @NonNull BiFunction<@NonNull R, ? super @NonNull T, @NonNull R> accumulator) Returns aFlowable
that emits the provided initial (seed) value, then emits one value for each value emitted by the currentFlowable
.final <@NonNull R>
@NonNull Observable<R> Observable.scanWith
(@NonNull Supplier<@NonNull R> seedSupplier, @NonNull BiFunction<@NonNull R, ? super @NonNull T, @NonNull R> accumulator) Returns anObservable
that emits the provided initial (seed) value, then emits one value for each value emitted by the currentObservable
.final <@NonNull R>
@NonNull Observable<R> Observable.scanWith
(@NonNull Supplier<@NonNull R> seedSupplier, @NonNull BiFunction<@NonNull R, ? super @NonNull T, @NonNull R> accumulator) Returns anObservable
that emits the provided initial (seed) value, then emits one value for each value emitted by the currentObservable
.Schedules a Runnable for execution without any time delay.abstract @NonNull Disposable
Schedules an Runnable for execution at some point in the future specified by a time delay relative to the current time.abstract @NonNull Disposable
Schedules an Runnable for execution at some point in the future specified by a time delay relative to the current time.Scheduler.scheduleDirect
(@NonNull Runnable run) Schedules the given task on this Scheduler without any time delay.Scheduler.scheduleDirect
(@NonNull Runnable run, long delay, @NonNull TimeUnit unit) Schedules the execution of the given task with the given time delay.Scheduler.scheduleDirect
(@NonNull Runnable run, long delay, @NonNull TimeUnit unit) Schedules the execution of the given task with the given time delay.Scheduler.Worker.schedulePeriodically
(@NonNull Runnable run, long initialDelay, long period, @NonNull TimeUnit unit) Schedules a periodic execution of the given task with the given initial time delay and repeat period.Scheduler.Worker.schedulePeriodically
(@NonNull Runnable run, long initialDelay, long period, @NonNull TimeUnit unit) Schedules a periodic execution of the given task with the given initial time delay and repeat period.Scheduler.schedulePeriodicallyDirect
(@NonNull Runnable run, long initialDelay, long period, @NonNull TimeUnit unit) Schedules a periodic execution of the given task with the given initial time delay and repeat period.Scheduler.schedulePeriodicallyDirect
(@NonNull Runnable run, long initialDelay, long period, @NonNull TimeUnit unit) Schedules a periodic execution of the given task with the given initial time delay and repeat period.Completable.sequenceEqual
(@NonNull CompletableSource source1, @NonNull CompletableSource source2) Completable.sequenceEqual
(@NonNull CompletableSource source1, @NonNull CompletableSource source2) Flowable.sequenceEqual
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source2) Flowable.sequenceEqual
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source2) Flowable.sequenceEqual
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source2, int bufferSize) Flowable.sequenceEqual
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> source2, int bufferSize) 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) 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) 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) 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) 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) 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) Maybe.sequenceEqual
(@NonNull MaybeSource<? extends @NonNull T> source1, @NonNull MaybeSource<? extends @NonNull T> source2) Returns aSingle
that emits aBoolean
value that indicates whether twoMaybeSource
sequences are the same by comparing the items emitted by eachMaybeSource
pairwise.Maybe.sequenceEqual
(@NonNull MaybeSource<? extends @NonNull T> source1, @NonNull MaybeSource<? extends @NonNull T> source2) Returns aSingle
that emits aBoolean
value that indicates whether twoMaybeSource
sequences are the same by comparing the items emitted by eachMaybeSource
pairwise.Maybe.sequenceEqual
(@NonNull MaybeSource<? extends @NonNull T> source1, @NonNull MaybeSource<? extends @NonNull T> source2, @NonNull BiPredicate<? super @NonNull T, ? super @NonNull T> isEqual) Returns aSingle
that emits aBoolean
value that indicates whether twoMaybeSource
s are the same by comparing the items emitted by eachMaybeSource
pairwise based on the results of a specified equality function.Maybe.sequenceEqual
(@NonNull MaybeSource<? extends @NonNull T> source1, @NonNull MaybeSource<? extends @NonNull T> source2, @NonNull BiPredicate<? super @NonNull T, ? super @NonNull T> isEqual) Returns aSingle
that emits aBoolean
value that indicates whether twoMaybeSource
s are the same by comparing the items emitted by eachMaybeSource
pairwise based on the results of a specified equality function.Maybe.sequenceEqual
(@NonNull MaybeSource<? extends @NonNull T> source1, @NonNull MaybeSource<? extends @NonNull T> source2, @NonNull BiPredicate<? super @NonNull T, ? super @NonNull T> isEqual) Returns aSingle
that emits aBoolean
value that indicates whether twoMaybeSource
s are the same by comparing the items emitted by eachMaybeSource
pairwise based on the results of a specified equality function.Observable.sequenceEqual
(@NonNull ObservableSource<? extends @NonNull T> source1, @NonNull ObservableSource<? extends @NonNull T> source2) Returns aSingle
that emits aBoolean
value that indicates whether twoObservableSource
sequences are the same by comparing the items emitted by eachObservableSource
pairwise.Observable.sequenceEqual
(@NonNull ObservableSource<? extends @NonNull T> source1, @NonNull ObservableSource<? extends @NonNull T> source2) Returns aSingle
that emits aBoolean
value that indicates whether twoObservableSource
sequences are the same by comparing the items emitted by eachObservableSource
pairwise.Observable.sequenceEqual
(@NonNull ObservableSource<? extends @NonNull T> source1, @NonNull ObservableSource<? extends @NonNull T> source2, int bufferSize) Returns aSingle
that emits aBoolean
value that indicates whether twoObservableSource
sequences are the same by comparing the items emitted by eachObservableSource
pairwise.Observable.sequenceEqual
(@NonNull ObservableSource<? extends @NonNull T> source1, @NonNull ObservableSource<? extends @NonNull T> source2, int bufferSize) Returns aSingle
that emits aBoolean
value that indicates whether twoObservableSource
sequences are the same by comparing the items emitted by eachObservableSource
pairwise.Observable.sequenceEqual
(@NonNull ObservableSource<? extends @NonNull T> source1, @NonNull ObservableSource<? extends @NonNull T> source2, @NonNull BiPredicate<? super @NonNull T, ? super @NonNull T> isEqual) Returns aSingle
that emits aBoolean
value that indicates whether twoObservableSource
sequences are the same by comparing the items emitted by eachObservableSource
pairwise based on the results of a specified equality function.Observable.sequenceEqual
(@NonNull ObservableSource<? extends @NonNull T> source1, @NonNull ObservableSource<? extends @NonNull T> source2, @NonNull BiPredicate<? super @NonNull T, ? super @NonNull T> isEqual) Returns aSingle
that emits aBoolean
value that indicates whether twoObservableSource
sequences are the same by comparing the items emitted by eachObservableSource
pairwise based on the results of a specified equality function.Observable.sequenceEqual
(@NonNull ObservableSource<? extends @NonNull T> source1, @NonNull ObservableSource<? extends @NonNull T> source2, @NonNull BiPredicate<? super @NonNull T, ? super @NonNull T> isEqual) Returns aSingle
that emits aBoolean
value that indicates whether twoObservableSource
sequences are the same by comparing the items emitted by eachObservableSource
pairwise based on the results of a specified equality function.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 aSingle
that emits aBoolean
value that indicates whether twoObservableSource
sequences are the same by comparing the items emitted by eachObservableSource
pairwise based on the results of a specified equality function.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 aSingle
that emits aBoolean
value that indicates whether twoObservableSource
sequences are the same by comparing the items emitted by eachObservableSource
pairwise based on the results of a specified equality function.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 aSingle
that emits aBoolean
value that indicates whether twoObservableSource
sequences are the same by comparing the items emitted by eachObservableSource
pairwise based on the results of a specified equality function.Single.sequenceEqual
(@NonNull SingleSource<? extends @NonNull T> source1, @NonNull SingleSource<? extends @NonNull T> source2) Compares twoSingleSource
s and emitstrue
if they emit the same value (compared viaObject.equals(Object)
).Single.sequenceEqual
(@NonNull SingleSource<? extends @NonNull T> source1, @NonNull SingleSource<? extends @NonNull T> source2) Compares twoSingleSource
s and emitstrue
if they emit the same value (compared viaObject.equals(Object)
).Returns aSingle
that emits the single item emitted by the currentFlowable
if it emits only a single item, or a default item if the currentFlowable
emits no items.Returns aSingle
that emits the single item emitted by the currentObservable
, if the currentObservable
emits only a single item, or a default item if the currentObservable
emits no items.Returns aFlowable
that skips values emitted by the currentFlowable
before a specified time window elapses.Returns aFlowable
that skips values emitted by the currentFlowable
before a specified time window on a specifiedScheduler
elapses.Returns aFlowable
that skips values emitted by the currentFlowable
before a specified time window on a specifiedScheduler
elapses.final @NonNull Observable
<T> Returns anObservable
that skips values emitted by the currentObservable
before a specified time window elapses.final @NonNull Observable
<T> Returns anObservable
that skips values emitted by the currentObservable
before a specified time window on a specifiedScheduler
elapses.final @NonNull Observable
<T> Returns anObservable
that skips values emitted by the currentObservable
before a specified time window on a specifiedScheduler
elapses.Returns aFlowable
that drops items emitted by the currentFlowable
during a specified time window before the source completes.Returns aFlowable
that drops items emitted by the currentFlowable
during a specified time window before the source completes.Returns aFlowable
that drops items emitted by the currentFlowable
during a specified time window (defined on a specified scheduler) before the source completes.Returns aFlowable
that drops items emitted by the currentFlowable
during a specified time window (defined on a specified scheduler) before the source completes.Flowable.skipLast
(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean delayError) Returns aFlowable
that drops items emitted by the currentFlowable
during a specified time window (defined on a specified scheduler) before the source completes.Flowable.skipLast
(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean delayError) Returns aFlowable
that drops items emitted by the currentFlowable
during a specified time window (defined on a specified scheduler) before the source completes.Flowable.skipLast
(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean delayError, int bufferSize) Returns aFlowable
that drops items emitted by the currentFlowable
during a specified time window (defined on a specified scheduler) before the source completes.Flowable.skipLast
(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean delayError, int bufferSize) Returns aFlowable
that drops items emitted by the currentFlowable
during a specified time window (defined on a specified scheduler) before the source completes.final @NonNull Observable
<T> Returns anObservable
that drops items emitted by the currentObservable
during a specified time window before the source completes.final @NonNull Observable
<T> Returns anObservable
that drops items emitted by the currentObservable
during a specified time window before the source completes.final @NonNull Observable
<T> Returns anObservable
that drops items emitted by the currentObservable
during a specified time window (defined on a specified scheduler) before the source completes.final @NonNull Observable
<T> Returns anObservable
that drops items emitted by the currentObservable
during a specified time window (defined on a specified scheduler) before the source completes.final @NonNull Observable
<T> Observable.skipLast
(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean delayError) Returns anObservable
that drops items emitted by the currentObservable
during a specified time window (defined on a specified scheduler) before the source completes.final @NonNull Observable
<T> Observable.skipLast
(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean delayError) Returns anObservable
that drops items emitted by the currentObservable
during a specified time window (defined on a specified scheduler) before the source completes.final @NonNull Observable
<T> Observable.skipLast
(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean delayError, int bufferSize) Returns anObservable
that drops items emitted by the currentObservable
during a specified time window (defined on a specified scheduler) before the source completes.final @NonNull Observable
<T> Observable.skipLast
(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean delayError, int bufferSize) Returns anObservable
that drops items emitted by the currentObservable
during a specified time window (defined on a specified scheduler) before the source completes.Returns aFlowable
that skips items emitted by the currentFlowable
until a secondPublisher
emits an item.final <@NonNull U>
@NonNull Observable<T> Observable.skipUntil
(@NonNull ObservableSource<@NonNull U> other) Returns anObservable
that skips items emitted by the currentObservable
until a secondObservableSource
emits an item.Returns aFlowable
that skips all items emitted by the currentFlowable
as long as a specified condition holdstrue
, but emits all further source items as soon as the condition becomesfalse
.final @NonNull Observable
<T> Returns anObservable
that skips all items emitted by the currentObservable
as long as a specified condition holdstrue
, but emits all further source items as soon as the condition becomesfalse
.Returns aFlowable
that emits the events emitted by sourcePublisher
, in a sorted order based on a specified comparison function.final @NonNull Observable
<T> Observable.sorted
(@NonNull Comparator<? super @NonNull T> comparator) Returns anObservable
that emits the events emitted by the currentObservable
, in a sorted order based on a specified comparison function.final @NonNull Completable
Completable.startWith
(@NonNull CompletableSource other) Returns aCompletable
which first runs the otherCompletableSource
then the currentCompletable
if the other completed normally.Completable.startWith
(@NonNull MaybeSource<@NonNull T> other) Returns aFlowable
which first runs the otherMaybeSource
then the currentCompletable
if the other succeeded or completed normally.final <@NonNull T>
@NonNull Observable<T> Completable.startWith
(@NonNull ObservableSource<@NonNull T> other) Returns anObservable
which first delivers the events of the otherObservableSource
then runs the currentCompletable
.Completable.startWith
(@NonNull SingleSource<@NonNull T> other) Returns aFlowable
which first runs the otherSingleSource
then the currentCompletable
if the other succeeded normally.Returns aFlowable
which first delivers the events of the otherPublisher
then runs the currentCompletable
.Flowable.startWith
(@NonNull CompletableSource other) Returns aFlowable
which first runs the otherCompletableSource
then the currentFlowable
if the other completed normally.Flowable.startWith
(@NonNull MaybeSource<@NonNull T> other) Returns aFlowable
which first runs the otherMaybeSource
then the currentFlowable
if the other succeeded or completed normally.Flowable.startWith
(@NonNull SingleSource<@NonNull T> other) Returns aFlowable
which first runs the otherSingleSource
then the currentFlowable
if the other succeeded normally.Returns aFlowable
that emits the items in a specifiedPublisher
before it begins to emit items emitted by the currentFlowable
.Maybe.startWith
(@NonNull CompletableSource other) Returns aFlowable
which first runs the otherCompletableSource
then the currentMaybe
if the other completed normally.Maybe.startWith
(@NonNull MaybeSource<@NonNull T> other) Returns aFlowable
which first runs the otherMaybeSource
then the currentMaybe
if the other succeeded or completed normally.final @NonNull Observable
<T> Maybe.startWith
(@NonNull ObservableSource<@NonNull T> other) Returns anObservable
which first delivers the events of the otherObservableSource
then runs the currentMaybe
.Maybe.startWith
(@NonNull SingleSource<@NonNull T> other) Returns aFlowable
which first runs the otherSingleSource
then the currentMaybe
if the other succeeded normally.Returns aFlowable
which first delivers the events of the otherPublisher
then runs the currentMaybe
.final @NonNull Observable
<T> Observable.startWith
(@NonNull CompletableSource other) Returns anObservable
which first runs the otherCompletableSource
then the currentObservable
if the other completed normally.final @NonNull Observable
<T> Observable.startWith
(@NonNull MaybeSource<@NonNull T> other) Returns anObservable
which first runs the otherMaybeSource
then the currentObservable
if the other succeeded or completed normally.final @NonNull Observable
<T> Observable.startWith
(@NonNull ObservableSource<? extends @NonNull T> other) Returns anObservable
that emits the items in a specifiedObservableSource
before it begins to emit items emitted by the currentObservable
.final @NonNull Observable
<T> Observable.startWith
(@NonNull SingleSource<@NonNull T> other) Returns anObservable
which first runs the otherSingleSource
then the currentObservable
if the other succeeded normally.Single.startWith
(@NonNull CompletableSource other) Returns aFlowable
which first runs the otherCompletableSource
then the currentSingle
if the other completed normally.Single.startWith
(@NonNull MaybeSource<@NonNull T> other) Returns aFlowable
which first runs the otherMaybeSource
then the currentSingle
if the other succeeded or completed normally.final @NonNull Observable
<T> Single.startWith
(@NonNull ObservableSource<@NonNull T> other) Returns anObservable
which first delivers the events of the otherObservableSource
then runs the currentSingle
.Single.startWith
(@NonNull SingleSource<@NonNull T> other) Returns aFlowable
which first runs the otherSingleSource
then the currentSingle
if the other succeeded normally.Returns aFlowable
which first delivers the events of the otherPublisher
then runs the currentSingle
.Flowable.startWithArray
(@NonNull T... items) Returns aFlowable
that emits the specified items before it begins to emit items emitted by the currentFlowable
.final @NonNull Observable
<T> Observable.startWithArray
(@NonNull T... items) Returns anObservable
that emits the specified items before it begins to emit items emitted by the currentObservable
.Flowable.startWithItem
(@NonNull T item) Returns aFlowable
that emits a specified item before it begins to emit items emitted by the currentFlowable
.final @NonNull Observable
<T> Observable.startWithItem
(@NonNull T item) Returns anObservable
that emits a specified item before it begins to emit items emitted by the currentObservable
.Flowable.startWithIterable
(@NonNull Iterable<? extends @NonNull T> items) Returns aFlowable
that emits the items in a specifiedIterable
before it begins to emit items emitted by the currentFlowable
.final @NonNull Observable
<T> Observable.startWithIterable
(@NonNull Iterable<? extends @NonNull T> items) Returns anObservable
that emits the items in a specifiedIterable
before it begins to emit items emitted by the currentObservable
.final void
Completable.subscribe
(@NonNull CompletableObserver observer) final @NonNull Disposable
final @NonNull Disposable
Subscribes to thisCompletable
and calls back either theonError
oronComplete
functions.final @NonNull Disposable
Subscribes to thisCompletable
and calls back either theonError
oronComplete
functions.final @NonNull Disposable
Completable.subscribe
(@NonNull Action onComplete, @NonNull Consumer<? super Throwable> onError, @NonNull DisposableContainer container) Wraps the given onXXX callbacks into aDisposable
CompletableObserver
, adds it to the givenDisposableContainer
and ensures, that if the upstream terminates or this particularDisposable
is disposed, theCompletableObserver
is removed from the given composite.final @NonNull Disposable
Completable.subscribe
(@NonNull Action onComplete, @NonNull Consumer<? super Throwable> onError, @NonNull DisposableContainer container) Wraps the given onXXX callbacks into aDisposable
CompletableObserver
, adds it to the givenDisposableContainer
and ensures, that if the upstream terminates or this particularDisposable
is disposed, theCompletableObserver
is removed from the given composite.final @NonNull Disposable
Completable.subscribe
(@NonNull Action onComplete, @NonNull Consumer<? super Throwable> onError, @NonNull DisposableContainer container) Wraps the given onXXX callbacks into aDisposable
CompletableObserver
, adds it to the givenDisposableContainer
and ensures, that if the upstream terminates or this particularDisposable
is disposed, theCompletableObserver
is removed from the given composite.void
CompletableOnSubscribe.subscribe
(@NonNull CompletableEmitter emitter) Called for eachCompletableObserver
that subscribes.void
CompletableSource.subscribe
(@NonNull CompletableObserver observer) Subscribes the givenCompletableObserver
to thisCompletableSource
instance.final void
Flowable.subscribe
(@NonNull FlowableSubscriber<? super @NonNull T> subscriber) Establish a connection between thisFlowable
and the givenFlowableSubscriber
and start streaming events based on the demand of theFlowableSubscriber
.final @NonNull Disposable
Subscribes to the currentFlowable
and provides a callback to handle the items it emits.final @NonNull Disposable
Flowable.subscribe
(@NonNull Consumer<? super @NonNull T> onNext, @NonNull Consumer<? super Throwable> onError) Subscribes to the currentFlowable
and provides callbacks to handle the items it emits and any error notification it issues.final @NonNull Disposable
Flowable.subscribe
(@NonNull Consumer<? super @NonNull T> onNext, @NonNull Consumer<? super Throwable> onError) Subscribes to the currentFlowable
and provides callbacks to handle the items it emits and any error notification it issues.final @NonNull Disposable
Flowable.subscribe
(@NonNull Consumer<? super @NonNull T> onNext, @NonNull Consumer<? super Throwable> onError, @NonNull Action onComplete) Subscribes to the currentFlowable
and provides callbacks to handle the items it emits and any error or completion notification it issues.final @NonNull Disposable
Flowable.subscribe
(@NonNull Consumer<? super @NonNull T> onNext, @NonNull Consumer<? super Throwable> onError, @NonNull Action onComplete) Subscribes to the currentFlowable
and provides callbacks to handle the items it emits and any error or completion notification it issues.final @NonNull Disposable
Flowable.subscribe
(@NonNull Consumer<? super @NonNull T> onNext, @NonNull Consumer<? super Throwable> onError, @NonNull Action onComplete) Subscribes to the currentFlowable
and provides callbacks to handle the items it emits and any error or completion notification it issues.final @NonNull Disposable
Flowable.subscribe
(@NonNull Consumer<? super @NonNull T> onNext, @NonNull Consumer<? super Throwable> onError, @NonNull Action onComplete, @NonNull DisposableContainer container) Wraps the given onXXX callbacks into aDisposable
Subscriber
, adds it to the givenDisposableContainer
and ensures, that if the upstream terminates or this particularDisposable
is disposed, theSubscriber
is removed from the given container.final @NonNull Disposable
Flowable.subscribe
(@NonNull Consumer<? super @NonNull T> onNext, @NonNull Consumer<? super Throwable> onError, @NonNull Action onComplete, @NonNull DisposableContainer container) Wraps the given onXXX callbacks into aDisposable
Subscriber
, adds it to the givenDisposableContainer
and ensures, that if the upstream terminates or this particularDisposable
is disposed, theSubscriber
is removed from the given container.final @NonNull Disposable
Flowable.subscribe
(@NonNull Consumer<? super @NonNull T> onNext, @NonNull Consumer<? super Throwable> onError, @NonNull Action onComplete, @NonNull DisposableContainer container) Wraps the given onXXX callbacks into aDisposable
Subscriber
, adds it to the givenDisposableContainer
and ensures, that if the upstream terminates or this particularDisposable
is disposed, theSubscriber
is removed from the given container.final @NonNull Disposable
Flowable.subscribe
(@NonNull Consumer<? super @NonNull T> onNext, @NonNull Consumer<? super Throwable> onError, @NonNull Action onComplete, @NonNull DisposableContainer container) Wraps the given onXXX callbacks into aDisposable
Subscriber
, adds it to the givenDisposableContainer
and ensures, that if the upstream terminates or this particularDisposable
is disposed, theSubscriber
is removed from the given container.final void
void
FlowableOnSubscribe.subscribe
(@NonNull FlowableEmitter<@NonNull T> emitter) Called for eachSubscriber
that subscribes.final void
Maybe.subscribe
(@NonNull MaybeObserver<? super @NonNull T> observer) final @NonNull Disposable
Subscribes to aMaybe
and provides a callback to handle the items it emits.final @NonNull Disposable
Maybe.subscribe
(@NonNull Consumer<? super @NonNull T> onSuccess, @NonNull Consumer<? super Throwable> onError) Subscribes to aMaybe
and provides callbacks to handle the items it emits and any error notification it issues.final @NonNull Disposable
Maybe.subscribe
(@NonNull Consumer<? super @NonNull T> onSuccess, @NonNull Consumer<? super Throwable> onError) Subscribes to aMaybe
and provides callbacks to handle the items it emits and any error notification it issues.final @NonNull Disposable
Maybe.subscribe
(@NonNull Consumer<? super @NonNull T> onSuccess, @NonNull Consumer<? super Throwable> onError, @NonNull Action onComplete) Subscribes to aMaybe
and provides callbacks to handle the items it emits and any error or completion notification it issues.final @NonNull Disposable
Maybe.subscribe
(@NonNull Consumer<? super @NonNull T> onSuccess, @NonNull Consumer<? super Throwable> onError, @NonNull Action onComplete) Subscribes to aMaybe
and provides callbacks to handle the items it emits and any error or completion notification it issues.final @NonNull Disposable
Maybe.subscribe
(@NonNull Consumer<? super @NonNull T> onSuccess, @NonNull Consumer<? super Throwable> onError, @NonNull Action onComplete) Subscribes to aMaybe
and provides callbacks to handle the items it emits and any error or completion notification it issues.final @NonNull Disposable
Maybe.subscribe
(@NonNull Consumer<? super @NonNull T> onSuccess, @NonNull Consumer<? super Throwable> onError, @NonNull Action onComplete, @NonNull DisposableContainer container) Wraps the given onXXX callbacks into aDisposable
MaybeObserver
, adds it to the givenDisposableContainer
and ensures, that if the upstream terminates or this particularDisposable
is disposed, theMaybeObserver
is removed from the given composite.final @NonNull Disposable
Maybe.subscribe
(@NonNull Consumer<? super @NonNull T> onSuccess, @NonNull Consumer<? super Throwable> onError, @NonNull Action onComplete, @NonNull DisposableContainer container) Wraps the given onXXX callbacks into aDisposable
MaybeObserver
, adds it to the givenDisposableContainer
and ensures, that if the upstream terminates or this particularDisposable
is disposed, theMaybeObserver
is removed from the given composite.final @NonNull Disposable
Maybe.subscribe
(@NonNull Consumer<? super @NonNull T> onSuccess, @NonNull Consumer<? super Throwable> onError, @NonNull Action onComplete, @NonNull DisposableContainer container) Wraps the given onXXX callbacks into aDisposable
MaybeObserver
, adds it to the givenDisposableContainer
and ensures, that if the upstream terminates or this particularDisposable
is disposed, theMaybeObserver
is removed from the given composite.final @NonNull Disposable
Maybe.subscribe
(@NonNull Consumer<? super @NonNull T> onSuccess, @NonNull Consumer<? super Throwable> onError, @NonNull Action onComplete, @NonNull DisposableContainer container) Wraps the given onXXX callbacks into aDisposable
MaybeObserver
, adds it to the givenDisposableContainer
and ensures, that if the upstream terminates or this particularDisposable
is disposed, theMaybeObserver
is removed from the given composite.void
MaybeOnSubscribe.subscribe
(@NonNull MaybeEmitter<@NonNull T> emitter) Called for eachMaybeObserver
that subscribes.void
MaybeSource.subscribe
(@NonNull MaybeObserver<? super @NonNull T> observer) Subscribes the givenMaybeObserver
to thisMaybeSource
instance.final void
final @NonNull Disposable
Subscribes to the currentObservable
and provides a callback to handle the items it emits.final @NonNull Disposable
Observable.subscribe
(@NonNull Consumer<? super @NonNull T> onNext, @NonNull Consumer<? super Throwable> onError) Subscribes to the currentObservable
and provides callbacks to handle the items it emits and any error notification it signals.final @NonNull Disposable
Observable.subscribe
(@NonNull Consumer<? super @NonNull T> onNext, @NonNull Consumer<? super Throwable> onError) Subscribes to the currentObservable
and provides callbacks to handle the items it emits and any error notification it signals.final @NonNull Disposable
Observable.subscribe
(@NonNull Consumer<? super @NonNull T> onNext, @NonNull Consumer<? super Throwable> onError, @NonNull Action onComplete) Subscribes to the currentObservable
and provides callbacks to handle the items it emits and any error or completion notification it signals.final @NonNull Disposable
Observable.subscribe
(@NonNull Consumer<? super @NonNull T> onNext, @NonNull Consumer<? super Throwable> onError, @NonNull Action onComplete) Subscribes to the currentObservable
and provides callbacks to handle the items it emits and any error or completion notification it signals.final @NonNull Disposable
Observable.subscribe
(@NonNull Consumer<? super @NonNull T> onNext, @NonNull Consumer<? super Throwable> onError, @NonNull Action onComplete) Subscribes to the currentObservable
and provides callbacks to handle the items it emits and any error or completion notification it signals.final @NonNull Disposable
Observable.subscribe
(@NonNull Consumer<? super @NonNull T> onNext, @NonNull Consumer<? super Throwable> onError, @NonNull Action onComplete, @NonNull DisposableContainer container) Wraps the given onXXX callbacks into aDisposable
Observer
, adds it to the givenDisposableContainer
and ensures, that if the upstream terminates or this particularDisposable
is disposed, theObserver
is removed from the given container.final @NonNull Disposable
Observable.subscribe
(@NonNull Consumer<? super @NonNull T> onNext, @NonNull Consumer<? super Throwable> onError, @NonNull Action onComplete, @NonNull DisposableContainer container) Wraps the given onXXX callbacks into aDisposable
Observer
, adds it to the givenDisposableContainer
and ensures, that if the upstream terminates or this particularDisposable
is disposed, theObserver
is removed from the given container.final @NonNull Disposable
Observable.subscribe
(@NonNull Consumer<? super @NonNull T> onNext, @NonNull Consumer<? super Throwable> onError, @NonNull Action onComplete, @NonNull DisposableContainer container) Wraps the given onXXX callbacks into aDisposable
Observer
, adds it to the givenDisposableContainer
and ensures, that if the upstream terminates or this particularDisposable
is disposed, theObserver
is removed from the given container.final @NonNull Disposable
Observable.subscribe
(@NonNull Consumer<? super @NonNull T> onNext, @NonNull Consumer<? super Throwable> onError, @NonNull Action onComplete, @NonNull DisposableContainer container) Wraps the given onXXX callbacks into aDisposable
Observer
, adds it to the givenDisposableContainer
and ensures, that if the upstream terminates or this particularDisposable
is disposed, theObserver
is removed from the given container.void
ObservableOnSubscribe.subscribe
(@NonNull ObservableEmitter<@NonNull T> emitter) Called for eachObserver
that subscribes.void
Subscribes the givenObserver
to thisObservableSource
instance.final void
Single.subscribe
(@NonNull SingleObserver<? super @NonNull T> observer) final @NonNull Disposable
Single.subscribe
(@NonNull BiConsumer<@Nullable ? super @NonNull T, @Nullable ? super Throwable> onCallback) Subscribes to aSingle
and provides a composite callback to handle the item it emits or any error notification it issues.final @NonNull Disposable
Subscribes to aSingle
and provides a callback to handle the item it emits.final @NonNull Disposable
Single.subscribe
(@NonNull Consumer<? super @NonNull T> onSuccess, @NonNull Consumer<? super Throwable> onError) Subscribes to aSingle
and provides callbacks to handle the item it emits or any error notification it issues.final @NonNull Disposable
Single.subscribe
(@NonNull Consumer<? super @NonNull T> onSuccess, @NonNull Consumer<? super Throwable> onError) Subscribes to aSingle
and provides callbacks to handle the item it emits or any error notification it issues.final @NonNull Disposable
Single.subscribe
(@NonNull Consumer<? super @NonNull T> onSuccess, @NonNull Consumer<? super Throwable> onError, @NonNull DisposableContainer container) Wraps the given onXXX callbacks into aDisposable
SingleObserver
, adds it to the givenDisposableContainer
and ensures, that if the upstream terminates or this particularDisposable
is disposed, theSingleObserver
is removed from the given container.final @NonNull Disposable
Single.subscribe
(@NonNull Consumer<? super @NonNull T> onSuccess, @NonNull Consumer<? super Throwable> onError, @NonNull DisposableContainer container) Wraps the given onXXX callbacks into aDisposable
SingleObserver
, adds it to the givenDisposableContainer
and ensures, that if the upstream terminates or this particularDisposable
is disposed, theSingleObserver
is removed from the given container.final @NonNull Disposable
Single.subscribe
(@NonNull Consumer<? super @NonNull T> onSuccess, @NonNull Consumer<? super Throwable> onError, @NonNull DisposableContainer container) Wraps the given onXXX callbacks into aDisposable
SingleObserver
, adds it to the givenDisposableContainer
and ensures, that if the upstream terminates or this particularDisposable
is disposed, theSingleObserver
is removed from the given container.void
SingleOnSubscribe.subscribe
(@NonNull SingleEmitter<@NonNull T> emitter) Called for eachSingleObserver
that subscribes.void
SingleSource.subscribe
(@NonNull SingleObserver<? super @NonNull T> observer) Subscribes the givenSingleObserver
to thisSingleSource
instance.protected abstract void
Completable.subscribeActual
(@NonNull CompletableObserver observer) Implement this method to handle the incomingCompletableObserver
s and perform the business logic in your operator.protected abstract void
Flowable.subscribeActual
(@NonNull org.reactivestreams.Subscriber<? super @NonNull T> subscriber) Operator implementations (both source and intermediate) should implement this method that performs the necessary business logic and handles the incomingSubscriber
s.protected abstract void
Maybe.subscribeActual
(@NonNull MaybeObserver<? super @NonNull T> observer) Implement this method in subclasses to handle the incomingMaybeObserver
s.protected abstract void
Observable.subscribeActual
(@NonNull Observer<? super @NonNull T> observer) Operator implementations (both source and intermediate) should implement this method that performs the necessary business logic and handles the incomingObserver
s.protected abstract void
Single.subscribeActual
(@NonNull SingleObserver<? super @NonNull T> observer) Implement this method in subclasses to handle the incomingSingleObserver
s.final @NonNull Completable
Completable.subscribeOn
(@NonNull Scheduler scheduler) Returns aCompletable
which subscribes the downstream subscriber on the specified scheduler, making sure the subscription side-effects happen on that specific thread of theScheduler
.Flowable.subscribeOn
(@NonNull Scheduler scheduler) Flowable.subscribeOn
(@NonNull Scheduler scheduler, boolean requestOn) Asynchronously subscribesSubscriber
s to the currentFlowable
on the specifiedScheduler
optionally reroutes requests from other threads to the sameScheduler
thread.Maybe.subscribeOn
(@NonNull Scheduler scheduler) Asynchronously subscribes subscribers to thisMaybe
on the specifiedScheduler
.final @NonNull Observable
<T> Observable.subscribeOn
(@NonNull Scheduler scheduler) Single.subscribeOn
(@NonNull Scheduler scheduler) Flowable.switchIfEmpty
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T> other) Returns aFlowable
that emits the items emitted by the currentFlowable
or the items of an alternatePublisher
if the currentFlowable
is empty.Maybe.switchIfEmpty
(@NonNull MaybeSource<? extends @NonNull T> other) Returns aMaybe
that emits the items emitted by the currentMaybe
or the items of an alternateMaybeSource
if the currentMaybe
is empty.Maybe.switchIfEmpty
(@NonNull SingleSource<? extends @NonNull T> other) Returns aSingle
that emits the items emitted by the currentMaybe
or the item of an alternateSingleSource
if the currentMaybe
is empty.final @NonNull Observable
<T> Observable.switchIfEmpty
(@NonNull ObservableSource<? extends @NonNull T> other) Returns anObservable
that emits the items emitted by the currentObservable
or the items of an alternateObservableSource
if the currentObservable
is empty.Flowable.switchMap
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper) Returns a newFlowable
by applying a function that you supply to each item emitted by the currentFlowable
that returns aPublisher
, and then emitting the items emitted by the most recently emitted of thesePublisher
s.Flowable.switchMap
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper, int bufferSize) Returns a newFlowable
by applying a function that you supply to each item emitted by the currentFlowable
that returns aPublisher
, and then emitting the items emitted by the most recently emitted of thesePublisher
s.final <@NonNull R>
@NonNull Observable<R> Observable.switchMap
(@NonNull Function<? super @NonNull T, ? extends ObservableSource<? extends @NonNull R>> mapper) Returns a newObservable
by applying a function that you supply to each item emitted by the currentObservable
that returns anObservableSource
, and then emitting the items emitted by the most recently emitted of theseObservableSource
s.final <@NonNull R>
@NonNull Observable<R> Observable.switchMap
(@NonNull Function<? super @NonNull T, ? extends ObservableSource<? extends @NonNull R>> mapper, int bufferSize) Returns a newObservable
by applying a function that you supply to each item emitted by the currentObservable
that returns anObservableSource
, and then emitting the items emitted by the most recently emitted of theseObservableSource
s.final @NonNull Completable
Flowable.switchMapCompletable
(@NonNull Function<? super @NonNull T, ? extends CompletableSource> mapper) Maps the upstream values intoCompletableSource
s, subscribes to the newer one while disposing the subscription to the previousCompletableSource
, thus keeping at most one activeCompletableSource
running.final @NonNull Completable
Observable.switchMapCompletable
(@NonNull Function<? super @NonNull T, ? extends CompletableSource> mapper) Maps the items of the currentObservable
intoCompletableSource
s, subscribes to the newer one while disposing the subscription to the previousCompletableSource
, thus keeping at most one activeCompletableSource
running.final @NonNull Completable
Flowable.switchMapCompletableDelayError
(@NonNull Function<? super @NonNull T, ? extends CompletableSource> mapper) Maps the upstream values intoCompletableSource
s, subscribes to the newer one while disposing the subscription to the previousCompletableSource
, thus keeping at most one activeCompletableSource
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 intoCompletableSource
s, subscribes to the newer one while disposing the subscription to the previousCompletableSource
, thus keeping at most one activeCompletableSource
running and delaying any main or inner errors until all of them terminate.Flowable.switchMapDelayError
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper) Returns a newFlowable
by applying a function that you supply to each item emitted by the currentFlowable
that returns aPublisher
, and then emitting the items emitted by the most recently emitted of thesePublisher
s and delays any error until allPublisher
s terminate.Flowable.switchMapDelayError
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper, int bufferSize) Returns a newFlowable
by applying a function that you supply to each item emitted by the currentFlowable
that returns aPublisher
, and then emitting the items emitted by the most recently emitted of thesePublisher
s and delays any error until allPublisher
s terminate.final <@NonNull R>
@NonNull Observable<R> Observable.switchMapDelayError
(@NonNull Function<? super @NonNull T, ? extends ObservableSource<? extends @NonNull R>> mapper) Returns a newObservable
by applying a function that you supply to each item emitted by the currentObservable
that returns anObservableSource
, and then emitting the items emitted by the most recently emitted of theseObservableSource
s and delays any error until allObservableSource
s terminate.final <@NonNull R>
@NonNull Observable<R> Observable.switchMapDelayError
(@NonNull Function<? super @NonNull T, ? extends ObservableSource<? extends @NonNull R>> mapper, int bufferSize) Returns a newObservable
by applying a function that you supply to each item emitted by the currentObservable
that returns anObservableSource
, and then emitting the items emitted by the most recently emitted of theseObservableSource
s and delays any error until allObservableSource
s terminate.Flowable.switchMapMaybe
(@NonNull Function<? super @NonNull T, ? extends MaybeSource<? extends @NonNull R>> mapper) Maps the upstream items intoMaybeSource
s and switches (subscribes) to the newer ones while disposing the older ones (and ignoring their signals) and emits the latest success value of the current one if available while failing immediately if thisFlowable
or any of the active innerMaybeSource
s fail.final <@NonNull R>
@NonNull Observable<R> Observable.switchMapMaybe
(@NonNull Function<? super @NonNull T, ? extends MaybeSource<? extends @NonNull R>> mapper) Maps the items of the currentObservable
intoMaybeSource
s and switches (subscribes) to the newer ones while disposing the older ones (and ignoring their signals) and emits the latest success value of the current one if available while failing immediately if the currentObservable
or any of the active innerMaybeSource
s fail.Flowable.switchMapMaybeDelayError
(@NonNull Function<? super @NonNull T, ? extends MaybeSource<? extends @NonNull R>> mapper) Maps the upstream items intoMaybeSource
s and switches (subscribes) to the newer ones while disposing the older ones (and ignoring their signals) and emits the latest success value of the current one if available, delaying errors from thisFlowable
or the innerMaybeSource
s until all terminate.final <@NonNull R>
@NonNull Observable<R> Observable.switchMapMaybeDelayError
(@NonNull Function<? super @NonNull T, ? extends MaybeSource<? extends @NonNull R>> mapper) Maps the upstream items intoMaybeSource
s and switches (subscribes) to the newer ones while disposing the older ones (and ignoring their signals) and emits the latest success value of the current one if available, delaying errors from the currentObservable
or the innerMaybeSource
s until all terminate.Flowable.switchMapSingle
(@NonNull Function<? super @NonNull T, ? extends SingleSource<? extends @NonNull R>> mapper) Maps the upstream items intoSingleSource
s and switches (subscribes) to the newer ones while disposing the older ones (and ignoring their signals) and emits the latest success value of the current one while failing immediately if thisFlowable
or any of the active innerSingleSource
s fail.final <@NonNull R>
@NonNull Observable<R> Observable.switchMapSingle
(@NonNull Function<? super @NonNull T, ? extends SingleSource<? extends @NonNull R>> mapper) Returns a newObservable
by applying a function that you supply to each item emitted by the currentObservable
that returns aSingleSource
, and then emitting the item emitted by the most recently emitted of theseSingleSource
s.Flowable.switchMapSingleDelayError
(@NonNull Function<? super @NonNull T, ? extends SingleSource<? extends @NonNull R>> mapper) Maps the upstream items intoSingleSource
s and switches (subscribes) to the newer ones while disposing the older ones (and ignoring their signals) and emits the latest success value of the current one, delaying errors from thisFlowable
or the innerSingleSource
s until all terminate.final <@NonNull R>
@NonNull Observable<R> Observable.switchMapSingleDelayError
(@NonNull Function<? super @NonNull T, ? extends SingleSource<? extends @NonNull R>> mapper) Returns a newObservable
by applying a function that you supply to each item emitted by the currentObservable
that returns aSingleSource
, and then emitting the item emitted by the most recently emitted of theseSingleSource
s and delays any error until allSingleSource
s terminate.static @NonNull Completable
Completable.switchOnNext
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends CompletableSource> sources) Switches betweenCompletableSource
s emitted by the sourcePublisher
whenever a newCompletableSource
is emitted, disposing the previously runningCompletableSource
, exposing the setup as aCompletable
sequence.Flowable.switchOnNext
(@NonNull org.reactivestreams.Publisher<? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources, int bufferSize) Converts aPublisher
that emitsPublisher
s into aPublisher
that emits the items emitted by the most recently emitted of thosePublisher
s.Flowable.switchOnNext
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources) Converts aPublisher
that emitsPublisher
s into aPublisher
that emits the items emitted by the most recently emitted of thosePublisher
s.Maybe.switchOnNext
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources) Switches betweenMaybeSource
s emitted by the sourcePublisher
whenever a newMaybeSource
is emitted, disposing the previously runningMaybeSource
, exposing the success items as aFlowable
sequence.static <@NonNull T>
@NonNull Observable<T> Observable.switchOnNext
(@NonNull ObservableSource<? extends ObservableSource<? extends @NonNull T>> sources) Converts anObservableSource
that emitsObservableSource
s into anObservable
that emits the items emitted by the most recently emitted of thoseObservableSource
s.static <@NonNull T>
@NonNull Observable<T> Observable.switchOnNext
(@NonNull ObservableSource<? extends ObservableSource<? extends @NonNull T>> sources, int bufferSize) Converts anObservableSource
that emitsObservableSource
s into anObservable
that emits the items emitted by the most recently emitted of thoseObservableSource
s.Single.switchOnNext
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends SingleSource<? extends @NonNull T>> sources) Switches betweenSingleSource
s emitted by the sourcePublisher
whenever a newSingleSource
is emitted, disposing the previously runningSingleSource
, exposing the success items as aFlowable
sequence.static @NonNull Completable
Completable.switchOnNextDelayError
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends CompletableSource> sources) Switches betweenCompletableSource
s emitted by the sourcePublisher
whenever a newCompletableSource
is emitted, disposing the previously runningCompletableSource
, exposing the setup as aCompletable
sequence and delaying all errors from all of them until all terminate.Flowable.switchOnNextDelayError
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources) Converts aPublisher
that emitsPublisher
s into aPublisher
that emits the items emitted by the most recently emitted of thosePublisher
s and delays any exception until allPublisher
s terminate.Flowable.switchOnNextDelayError
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources, int prefetch) Converts aPublisher
that emitsPublisher
s into aPublisher
that emits the items emitted by the most recently emitted of thosePublisher
s and delays any exception until allPublisher
s terminate.Maybe.switchOnNextDelayError
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources) Switches betweenMaybeSource
s emitted by the sourcePublisher
whenever a newMaybeSource
is emitted, disposing the previously runningMaybeSource
, exposing the success items as aFlowable
sequence and delaying all errors from all of them until all terminate.static <@NonNull T>
@NonNull Observable<T> Observable.switchOnNextDelayError
(@NonNull ObservableSource<? extends ObservableSource<? extends @NonNull T>> sources) Converts anObservableSource
that emitsObservableSource
s into anObservable
that emits the items emitted by the most recently emitted of thoseObservableSource
s and delays any exception until allObservableSource
s terminate.static <@NonNull T>
@NonNull Observable<T> Observable.switchOnNextDelayError
(@NonNull ObservableSource<? extends ObservableSource<? extends @NonNull T>> sources, int bufferSize) Converts anObservableSource
that emitsObservableSource
s into anObservable
that emits the items emitted by the most recently emitted of thoseObservableSource
s and delays any exception until allObservableSource
s terminate.Single.switchOnNextDelayError
(@NonNull org.reactivestreams.Publisher<@NonNull ? extends SingleSource<? extends @NonNull T>> sources) Switches betweenSingleSource
s emitted by the sourcePublisher
whenever a newSingleSource
is emitted, disposing the previously runningSingleSource
, exposing the success items as aFlowable
sequence and delaying all errors from all of them until all terminate.Returns aFlowable
that emits those items emitted by sourcePublisher
before a specified time runs out.Returns aFlowable
that emits those items emitted by sourcePublisher
before a specified time (on a specifiedScheduler
) runs out.Returns aFlowable
that emits those items emitted by sourcePublisher
before a specified time (on a specifiedScheduler
) runs out.final @NonNull Observable
<T> Returns anObservable
that emits those items emitted by the currentObservable
before a specified time runs out.final @NonNull Observable
<T> Returns anObservable
that emits those items emitted by the currentObservable
before a specified time (on a specifiedScheduler
) runs out.final @NonNull Observable
<T> Returns anObservable
that emits those items emitted by the currentObservable
before a specified time (on a specifiedScheduler
) runs out.Returns aFlowable
that emits at most a specified number of items from the currentFlowable
that were emitted in a specified window of time before the currentFlowable
completed.Returns aFlowable
that emits at most a specified number of items from the currentFlowable
that were emitted in a specified window of time before the currentFlowable
completed, where the timing information is provided by a givenScheduler
.Returns aFlowable
that emits at most a specified number of items from the currentFlowable
that were emitted in a specified window of time before the currentFlowable
completed, where the timing information is provided by a givenScheduler
.Flowable.takeLast
(long count, long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean delayError, int bufferSize) Returns aFlowable
that emits at most a specified number of items from the currentFlowable
that were emitted in a specified window of time before the currentFlowable
completed, where the timing information is provided by a givenScheduler
.Flowable.takeLast
(long count, long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean delayError, int bufferSize) Returns aFlowable
that emits at most a specified number of items from the currentFlowable
that were emitted in a specified window of time before the currentFlowable
completed, where the timing information is provided by a givenScheduler
.Returns aFlowable
that emits the items from the currentFlowable
that were emitted in a specified window of time before the currentFlowable
completed.Returns aFlowable
that emits the items from the currentFlowable
that were emitted in a specified window of time before the currentFlowable
completed.Returns aFlowable
that emits the items from the currentFlowable
that were emitted in a specified window of time before the currentFlowable
completed, where the timing information is provided by a specifiedScheduler
.Returns aFlowable
that emits the items from the currentFlowable
that were emitted in a specified window of time before the currentFlowable
completed, where the timing information is provided by a specifiedScheduler
.Flowable.takeLast
(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean delayError) Returns aFlowable
that emits the items from the currentFlowable
that were emitted in a specified window of time before the currentFlowable
completed, where the timing information is provided by a specifiedScheduler
.Flowable.takeLast
(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean delayError) Returns aFlowable
that emits the items from the currentFlowable
that were emitted in a specified window of time before the currentFlowable
completed, where the timing information is provided by a specifiedScheduler
.Flowable.takeLast
(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean delayError, int bufferSize) Returns aFlowable
that emits the items from the currentFlowable
that were emitted in a specified window of time before the currentFlowable
completed, where the timing information is provided by a specifiedScheduler
.Flowable.takeLast
(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean delayError, int bufferSize) Returns aFlowable
that emits the items from the currentFlowable
that were emitted in a specified window of time before the currentFlowable
completed, where the timing information is provided by a specifiedScheduler
.final @NonNull Observable
<T> Returns anObservable
that emits at most a specified number of items from the currentObservable
that were emitted in a specified window of time before the currentObservable
completed.final @NonNull Observable
<T> Returns anObservable
that emits at most a specified number of items from the currentObservable
that were emitted in a specified window of time before the currentObservable
completed, where the timing information is provided by a givenScheduler
.final @NonNull Observable
<T> Returns anObservable
that emits at most a specified number of items from the currentObservable
that were emitted in a specified window of time before the currentObservable
completed, where the timing information is provided by a givenScheduler
.final @NonNull Observable
<T> Observable.takeLast
(long count, long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean delayError, int bufferSize) Returns anObservable
that emits at most a specified number of items from the currentObservable
that were emitted in a specified window of time before the currentObservable
completed, where the timing information is provided by a givenScheduler
.final @NonNull Observable
<T> Observable.takeLast
(long count, long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean delayError, int bufferSize) Returns anObservable
that emits at most a specified number of items from the currentObservable
that were emitted in a specified window of time before the currentObservable
completed, where the timing information is provided by a givenScheduler
.final @NonNull Observable
<T> Returns anObservable
that emits the items from the currentObservable
that were emitted in a specified window of time before the currentObservable
completed.final @NonNull Observable
<T> Returns anObservable
that emits the items from the currentObservable
that were emitted in a specified window of time before the currentObservable
completed.final @NonNull Observable
<T> Returns anObservable
that emits the items from the currentObservable
that were emitted in a specified window of time before the currentObservable
completed, where the timing information is provided by a specifiedScheduler
.final @NonNull Observable
<T> Returns anObservable
that emits the items from the currentObservable
that were emitted in a specified window of time before the currentObservable
completed, where the timing information is provided by a specifiedScheduler
.final @NonNull Observable
<T> Observable.takeLast
(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean delayError) Returns anObservable
that emits the items from the currentObservable
that were emitted in a specified window of time before the currentObservable
completed, where the timing information is provided by a specifiedScheduler
.final @NonNull Observable
<T> Observable.takeLast
(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean delayError) Returns anObservable
that emits the items from the currentObservable
that were emitted in a specified window of time before the currentObservable
completed, where the timing information is provided by a specifiedScheduler
.final @NonNull Observable
<T> Observable.takeLast
(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean delayError, int bufferSize) Returns anObservable
that emits the items from the currentObservable
that were emitted in a specified window of time before the currentObservable
completed, where the timing information is provided by a specifiedScheduler
.final @NonNull Observable
<T> Observable.takeLast
(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean delayError, int bufferSize) Returns anObservable
that emits the items from the currentObservable
that were emitted in a specified window of time before the currentObservable
completed, where the timing information is provided by a specifiedScheduler
.final @NonNull Completable
Completable.takeUntil
(@NonNull CompletableSource other) Terminates the downstream if this or the otherCompletable
terminates (wins the termination race) while disposing the connection to the losing source.Returns aFlowable
that emits items emitted by the currentFlowable
, checks the specified predicate for each item, and then completes when the condition is satisfied.Returns aFlowable
that emits the items emitted by the currentFlowable
until a secondPublisher
emits an item or completes.Maybe.takeUntil
(@NonNull MaybeSource<@NonNull U> other) Returns aMaybe
that emits the items emitted by the currentMaybe
until a secondMaybeSource
emits an item.Returns aMaybe
that emits the item emitted by the currentMaybe
until a secondPublisher
emits an item.final <@NonNull U>
@NonNull Observable<T> Observable.takeUntil
(@NonNull ObservableSource<@NonNull U> other) Returns anObservable
that emits the items emitted by the currentObservable
until a secondObservableSource
emits an item or completes.final @NonNull Observable
<T> Returns anObservable
that emits items emitted by the currentObservable
, checks the specified predicate for each item, and then completes when the condition is satisfied.Single.takeUntil
(@NonNull CompletableSource other) Returns aSingle
that emits the item emitted by the currentSingle
until aCompletableSource
terminates.Single.takeUntil
(@NonNull SingleSource<? extends @NonNull E> other) Returns aSingle
that emits the item emitted by the currentSingle
until a secondSingle
emits an item.Returns aSingle
that emits the item emitted by the currentSingle
until aPublisher
emits an item or completes.Returns aFlowable
that emits items emitted by the currentFlowable
so long as each item satisfied a specified condition, and then completes as soon as this condition is not satisfied.final @NonNull Observable
<T> Returns anObservable
that emits items emitted by the currentObservable
so long as each item satisfied a specified condition, and then completes as soon as this condition is not satisfied.Flowable.throttleFirst
(long windowDuration, @NonNull TimeUnit unit) Returns aFlowable
that emits only the first item emitted by the currentFlowable
during sequential time windows of a specified duration.Flowable.throttleFirst
(long skipDuration, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Returns aFlowable
that emits only the first item emitted by the currentFlowable
during sequential time windows of a specified duration, where the windows are managed by a specifiedScheduler
.Flowable.throttleFirst
(long skipDuration, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Returns aFlowable
that emits only the first item emitted by the currentFlowable
during sequential time windows of a specified duration, where the windows are managed by a specifiedScheduler
.Flowable.throttleFirst
(long skipDuration, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, @NonNull Consumer<? super @NonNull T> onDropped) Returns aFlowable
that emits only the first item emitted by the currentFlowable
during sequential time windows of a specified duration, where the windows are managed by a specifiedScheduler
.Flowable.throttleFirst
(long skipDuration, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, @NonNull Consumer<? super @NonNull T> onDropped) Returns aFlowable
that emits only the first item emitted by the currentFlowable
during sequential time windows of a specified duration, where the windows are managed by a specifiedScheduler
.Flowable.throttleFirst
(long skipDuration, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, @NonNull Consumer<? super @NonNull T> onDropped) Returns aFlowable
that emits only the first item emitted by the currentFlowable
during sequential time windows of a specified duration, where the windows are managed by a specifiedScheduler
.final @NonNull Observable
<T> Observable.throttleFirst
(long windowDuration, @NonNull TimeUnit unit) Returns anObservable
that emits only the first item emitted by the currentObservable
during sequential time windows of a specified duration.final @NonNull Observable
<T> Observable.throttleFirst
(long skipDuration, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Returns anObservable
that emits only the first item emitted by the currentObservable
during sequential time windows of a specified duration, where the windows are managed by a specifiedScheduler
.final @NonNull Observable
<T> Observable.throttleFirst
(long skipDuration, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Returns anObservable
that emits only the first item emitted by the currentObservable
during sequential time windows of a specified duration, where the windows are managed by a specifiedScheduler
.final @NonNull Observable
<T> Observable.throttleFirst
(long skipDuration, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, @NonNull Consumer<? super @NonNull T> onDropped) Returns anObservable
that emits only the first item emitted by the currentObservable
during sequential time windows of a specified duration, where the windows are managed by a specifiedScheduler
.final @NonNull Observable
<T> Observable.throttleFirst
(long skipDuration, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, @NonNull Consumer<? super @NonNull T> onDropped) Returns anObservable
that emits only the first item emitted by the currentObservable
during sequential time windows of a specified duration, where the windows are managed by a specifiedScheduler
.final @NonNull Observable
<T> Observable.throttleFirst
(long skipDuration, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, @NonNull Consumer<? super @NonNull T> onDropped) Returns anObservable
that emits only the first item emitted by the currentObservable
during sequential time windows of a specified duration, where the windows are managed by a specifiedScheduler
.Flowable.throttleLast
(long intervalDuration, @NonNull TimeUnit unit) Returns aFlowable
that emits only the last item emitted by the currentFlowable
during sequential time windows of a specified duration.Flowable.throttleLast
(long intervalDuration, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Returns aFlowable
that emits only the last item emitted by the currentFlowable
during sequential time windows of a specified duration, where the duration is governed by a specifiedScheduler
.Flowable.throttleLast
(long intervalDuration, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Returns aFlowable
that emits only the last item emitted by the currentFlowable
during sequential time windows of a specified duration, where the duration is governed by a specifiedScheduler
.Flowable.throttleLast
(long intervalDuration, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, @NonNull Consumer<? super @NonNull T> onDropped) Returns aFlowable
that emits only the last item emitted by the currentFlowable
during sequential time windows of a specified duration, where the duration is governed by a specifiedScheduler
.Flowable.throttleLast
(long intervalDuration, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, @NonNull Consumer<? super @NonNull T> onDropped) Returns aFlowable
that emits only the last item emitted by the currentFlowable
during sequential time windows of a specified duration, where the duration is governed by a specifiedScheduler
.Flowable.throttleLast
(long intervalDuration, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, @NonNull Consumer<? super @NonNull T> onDropped) Returns aFlowable
that emits only the last item emitted by the currentFlowable
during sequential time windows of a specified duration, where the duration is governed by a specifiedScheduler
.final @NonNull Observable
<T> Observable.throttleLast
(long intervalDuration, @NonNull TimeUnit unit) Returns anObservable
that emits only the last item emitted by the currentObservable
during sequential time windows of a specified duration.final @NonNull Observable
<T> Observable.throttleLast
(long intervalDuration, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Returns anObservable
that emits only the last item emitted by the currentObservable
during sequential time windows of a specified duration, where the duration is governed by a specifiedScheduler
.final @NonNull Observable
<T> Observable.throttleLast
(long intervalDuration, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Returns anObservable
that emits only the last item emitted by the currentObservable
during sequential time windows of a specified duration, where the duration is governed by a specifiedScheduler
.final @NonNull Observable
<T> Observable.throttleLast
(long intervalDuration, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, @NonNull Consumer<? super @NonNull T> onDropped) Returns anObservable
that emits only the last item emitted by the currentObservable
during sequential time windows of a specified duration, where the duration is governed by a specifiedScheduler
.final @NonNull Observable
<T> Observable.throttleLast
(long intervalDuration, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, @NonNull Consumer<? super @NonNull T> onDropped) Returns anObservable
that emits only the last item emitted by the currentObservable
during sequential time windows of a specified duration, where the duration is governed by a specifiedScheduler
.final @NonNull Observable
<T> Observable.throttleLast
(long intervalDuration, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, @NonNull Consumer<? super @NonNull T> onDropped) Returns anObservable
that emits only the last item emitted by the currentObservable
during sequential time windows of a specified duration, where the duration is governed by a specifiedScheduler
.Flowable.throttleLatest
(long timeout, @NonNull TimeUnit unit) Throttles items from the upstreamFlowable
by first emitting the next item from upstream, then periodically emitting the latest item (if any) when the specified timeout elapses between them.Flowable.throttleLatest
(long timeout, @NonNull TimeUnit unit, boolean emitLast) Throttles items from the upstreamFlowable
by first emitting the next item from upstream, then periodically emitting the latest item (if any) when the specified timeout elapses between them.Flowable.throttleLatest
(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Throttles items from the upstreamFlowable
by first emitting the next item from upstream, then periodically emitting the latest item (if any) when the specified timeout elapses between them.Flowable.throttleLatest
(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Throttles items from the upstreamFlowable
by first emitting the next item from upstream, then periodically emitting the latest item (if any) when the specified timeout elapses between them.Flowable.throttleLatest
(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean emitLast) Throttles items from the upstreamFlowable
by first emitting the next item from upstream, then periodically emitting the latest item (if any) when the specified timeout elapses between them.Flowable.throttleLatest
(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean emitLast) Throttles items from the upstreamFlowable
by first emitting the next item from upstream, then periodically emitting the latest item (if any) when the specified timeout elapses between them.Flowable.throttleLatest
(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean emitLast, @NonNull Consumer<? super @NonNull T> onDropped) Throttles items from the upstreamFlowable
by first emitting the next item from upstream, then periodically emitting the latest item (if any) when the specified timeout elapses between them, invoking the consumer for any dropped item.Flowable.throttleLatest
(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean emitLast, @NonNull Consumer<? super @NonNull T> onDropped) Throttles items from the upstreamFlowable
by first emitting the next item from upstream, then periodically emitting the latest item (if any) when the specified timeout elapses between them, invoking the consumer for any dropped item.Flowable.throttleLatest
(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean emitLast, @NonNull Consumer<? super @NonNull T> onDropped) Throttles items from the upstreamFlowable
by first emitting the next item from upstream, then periodically emitting the latest item (if any) when the specified timeout elapses between them, invoking the consumer for any dropped item.final @NonNull Observable
<T> Observable.throttleLatest
(long timeout, @NonNull TimeUnit unit) Throttles items from the currentObservable
by first emitting the next item from upstream, then periodically emitting the latest item (if any) when the specified timeout elapses between them.final @NonNull Observable
<T> Observable.throttleLatest
(long timeout, @NonNull TimeUnit unit, boolean emitLast) Throttles items from the currentObservable
by first emitting the next item from upstream, then periodically emitting the latest item (if any) when the specified timeout elapses between them.final @NonNull Observable
<T> Observable.throttleLatest
(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Throttles items from the currentObservable
by first emitting the next item from upstream, then periodically emitting the latest item (if any) when the specified timeout elapses between them.final @NonNull Observable
<T> Observable.throttleLatest
(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Throttles items from the currentObservable
by first emitting the next item from upstream, then periodically emitting the latest item (if any) when the specified timeout elapses between them.final @NonNull Observable
<T> Observable.throttleLatest
(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean emitLast) Throttles items from the currentObservable
by first emitting the next item from upstream, then periodically emitting the latest item (if any) when the specified timeout elapses between them.final @NonNull Observable
<T> Observable.throttleLatest
(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean emitLast) Throttles items from the currentObservable
by first emitting the next item from upstream, then periodically emitting the latest item (if any) when the specified timeout elapses between them.final @NonNull Observable
<T> Observable.throttleLatest
(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean emitLast, @NonNull Consumer<? super @NonNull T> onDropped) Throttles items from the currentObservable
by first emitting the next item from upstream, then periodically emitting the latest item (if any) when the specified timeout elapses between them, invoking the consumer for any dropped item.final @NonNull Observable
<T> Observable.throttleLatest
(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean emitLast, @NonNull Consumer<? super @NonNull T> onDropped) Throttles items from the currentObservable
by first emitting the next item from upstream, then periodically emitting the latest item (if any) when the specified timeout elapses between them, invoking the consumer for any dropped item.final @NonNull Observable
<T> Observable.throttleLatest
(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean emitLast, @NonNull Consumer<? super @NonNull T> onDropped) Throttles items from the currentObservable
by first emitting the next item from upstream, then periodically emitting the latest item (if any) when the specified timeout elapses between them, invoking the consumer for any dropped item.Flowable.throttleWithTimeout
(long timeout, @NonNull TimeUnit unit) Returns aFlowable
that mirrors the currentFlowable
, except that it drops items emitted by the currentFlowable
that are followed by newer items before a timeout value expires.Flowable.throttleWithTimeout
(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Returns aFlowable
that mirrors the currentFlowable
, except that it drops items emitted by the currentFlowable
that are followed by newer items before a timeout value expires on a specifiedScheduler
.Flowable.throttleWithTimeout
(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Returns aFlowable
that mirrors the currentFlowable
, except that it drops items emitted by the currentFlowable
that are followed by newer items before a timeout value expires on a specifiedScheduler
.Flowable.throttleWithTimeout
(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, @NonNull Consumer<? super @NonNull T> onDropped) Returns aFlowable
that mirrors the currentFlowable
, except that it drops items emitted by the currentFlowable
that are followed by newer items before a timeout value expires on a specifiedScheduler
.Flowable.throttleWithTimeout
(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, @NonNull Consumer<? super @NonNull T> onDropped) Returns aFlowable
that mirrors the currentFlowable
, except that it drops items emitted by the currentFlowable
that are followed by newer items before a timeout value expires on a specifiedScheduler
.Flowable.throttleWithTimeout
(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, @NonNull Consumer<? super @NonNull T> onDropped) Returns aFlowable
that mirrors the currentFlowable
, except that it drops items emitted by the currentFlowable
that are followed by newer items before a timeout value expires on a specifiedScheduler
.final @NonNull Observable
<T> Observable.throttleWithTimeout
(long timeout, @NonNull TimeUnit unit) Returns anObservable
that mirrors the currentObservable
, except that it drops items emitted by the currentObservable
that are followed by newer items before a timeout value expires.final @NonNull Observable
<T> Observable.throttleWithTimeout
(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Returns anObservable
that mirrors the currentObservable
, except that it drops items emitted by the currentObservable
that are followed by newer items before a timeout value expires on a specifiedScheduler
.final @NonNull Observable
<T> Observable.throttleWithTimeout
(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Returns anObservable
that mirrors the currentObservable
, except that it drops items emitted by the currentObservable
that are followed by newer items before a timeout value expires on a specifiedScheduler
.final @NonNull Observable
<T> Observable.throttleWithTimeout
(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, @NonNull Consumer<? super @NonNull T> onDropped) Returns anObservable
that mirrors the currentObservable
, except that it drops items emitted by the currentObservable
that are followed by newer items before a timeout value expires on a specifiedScheduler
.final @NonNull Observable
<T> Observable.throttleWithTimeout
(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, @NonNull Consumer<? super @NonNull T> onDropped) Returns anObservable
that mirrors the currentObservable
, except that it drops items emitted by the currentObservable
that are followed by newer items before a timeout value expires on a specifiedScheduler
.final @NonNull Observable
<T> Observable.throttleWithTimeout
(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, @NonNull Consumer<? super @NonNull T> onDropped) Returns anObservable
that mirrors the currentObservable
, except that it drops items emitted by the currentObservable
that are followed by newer items before a timeout value expires on a specifiedScheduler
.Flowable.timeInterval
(@NonNull Scheduler scheduler) Returns aFlowable
that emits records of the time interval between consecutive items emitted by the currentFlowable
, where this interval is computed on a specifiedScheduler
.Flowable.timeInterval
(@NonNull TimeUnit unit) Returns aFlowable
that emits records of the time interval between consecutive items emitted by the currentFlowable
.Flowable.timeInterval
(@NonNull TimeUnit unit, @NonNull Scheduler scheduler) Returns aFlowable
that emits records of the time interval between consecutive items emitted by the currentFlowable
, where this interval is computed on a specifiedScheduler
.Flowable.timeInterval
(@NonNull TimeUnit unit, @NonNull Scheduler scheduler) Returns aFlowable
that emits records of the time interval between consecutive items emitted by the currentFlowable
, where this interval is computed on a specifiedScheduler
.Maybe.timeInterval
(@NonNull Scheduler scheduler) Measures the time (in milliseconds) between the subscription and success item emission of the currentMaybe
and signals it as a tuple (Timed
) success value.Maybe.timeInterval
(@NonNull TimeUnit unit) Measures the time between the subscription and success item emission of the currentMaybe
and signals it as a tuple (Timed
) success value.Maybe.timeInterval
(@NonNull TimeUnit unit, @NonNull Scheduler scheduler) Measures the time between the subscription and success item emission of the currentMaybe
and signals it as a tuple (Timed
) success value.Maybe.timeInterval
(@NonNull TimeUnit unit, @NonNull Scheduler scheduler) Measures the time between the subscription and success item emission of the currentMaybe
and signals it as a tuple (Timed
) success value.final @NonNull Observable
<Timed<T>> Observable.timeInterval
(@NonNull Scheduler scheduler) Returns anObservable
that emits records of the time interval between consecutive items emitted by the currentObservable
, where this interval is computed on a specifiedScheduler
.final @NonNull Observable
<Timed<T>> Observable.timeInterval
(@NonNull TimeUnit unit) Returns anObservable
that emits records of the time interval between consecutive items emitted by the currentObservable
.final @NonNull Observable
<Timed<T>> Observable.timeInterval
(@NonNull TimeUnit unit, @NonNull Scheduler scheduler) Returns anObservable
that emits records of the time interval between consecutive items emitted by the currentObservable
, where this interval is computed on a specifiedScheduler
.final @NonNull Observable
<Timed<T>> Observable.timeInterval
(@NonNull TimeUnit unit, @NonNull Scheduler scheduler) Returns anObservable
that emits records of the time interval between consecutive items emitted by the currentObservable
, where this interval is computed on a specifiedScheduler
.Single.timeInterval
(@NonNull Scheduler scheduler) Measures the time (in milliseconds) between the subscription and success item emission of the currentSingle
and signals it as a tuple (Timed
) success value.Single.timeInterval
(@NonNull TimeUnit unit) Measures the time between the subscription and success item emission of the currentSingle
and signals it as a tuple (Timed
) success value.Single.timeInterval
(@NonNull TimeUnit unit, @NonNull Scheduler scheduler) Measures the time between the subscription and success item emission of the currentSingle
and signals it as a tuple (Timed
) success value.Single.timeInterval
(@NonNull TimeUnit unit, @NonNull Scheduler scheduler) Measures the time between the subscription and success item emission of the currentSingle
and signals it as a tuple (Timed
) success value.final @NonNull Completable
Returns aCompletabl
e that runs thisCompletable
and emits aTimeoutException
in case thisCompletable
doesn't complete within the given time.final @NonNull Completable
Completable.timeout
(long timeout, @NonNull TimeUnit unit, @NonNull CompletableSource fallback) Returns aCompletable
that runs thisCompletable
and switches to the otherCompletableSource
in case thisCompletable
doesn't complete within the given time.final @NonNull Completable
Completable.timeout
(long timeout, @NonNull TimeUnit unit, @NonNull CompletableSource fallback) Returns aCompletable
that runs thisCompletable
and switches to the otherCompletableSource
in case thisCompletable
doesn't complete within the given time.final @NonNull Completable
Returns aCompletable
that runs thisCompletable
and emits aTimeoutException
in case thisCompletable
doesn't complete within the given time while "waiting" on the specifiedScheduler
.final @NonNull Completable
Returns aCompletable
that runs thisCompletable
and emits aTimeoutException
in case thisCompletable
doesn't complete within the given time while "waiting" on the specifiedScheduler
.final @NonNull Completable
Completable.timeout
(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, @NonNull CompletableSource fallback) Returns aCompletable
that runs thisCompletable
and switches to the otherCompletableSource
in case thisCompletable
doesn't complete within the given time while "waiting" on the specifiedScheduler
.final @NonNull Completable
Completable.timeout
(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, @NonNull CompletableSource fallback) Returns aCompletable
that runs thisCompletable
and switches to the otherCompletableSource
in case thisCompletable
doesn't complete within the given time while "waiting" on the specifiedScheduler
.final @NonNull Completable
Completable.timeout
(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, @NonNull CompletableSource fallback) Returns aCompletable
that runs thisCompletable
and switches to the otherCompletableSource
in case thisCompletable
doesn't complete within the given time while "waiting" on the specifiedScheduler
.Returns aFlowable
that mirrors the currentFlowable
but applies a timeout policy for each emitted item.Returns aFlowable
that mirrors the currentFlowable
but applies a timeout policy for each emitted item, where this policy is governed by a specifiedScheduler
.Returns aFlowable
that mirrors the currentFlowable
but applies a timeout policy for each emitted item, where this policy is governed by a specifiedScheduler
.Flowable.timeout
(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> fallback) Returns aFlowable
that mirrors the currentFlowable
but applies a timeout policy for each emitted item using a specifiedScheduler
.Flowable.timeout
(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> fallback) Returns aFlowable
that mirrors the currentFlowable
but applies a timeout policy for each emitted item using a specifiedScheduler
.Flowable.timeout
(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> fallback) Returns aFlowable
that mirrors the currentFlowable
but applies a timeout policy for each emitted item using a specifiedScheduler
.Flowable.timeout
(long timeout, @NonNull TimeUnit unit, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> fallback) Returns aFlowable
that mirrors the currentFlowable
but applies a timeout policy for each emitted item.Flowable.timeout
(long timeout, @NonNull TimeUnit unit, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> fallback) Returns aFlowable
that mirrors the currentFlowable
but applies a timeout policy for each emitted item.Flowable.timeout
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<@NonNull V>> itemTimeoutIndicator) Returns aFlowable
that mirrors the currentFlowable
, but notifiesSubscriber
s of aTimeoutException
if an item emitted by the currentFlowable
doesn't arrive within a window of time after the emission of the previous item, where that period of time is measured by aPublisher
that is a function of the previous item.Flowable.timeout
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<@NonNull V>> itemTimeoutIndicator, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> fallback) Returns aFlowable
that mirrors the currentFlowable
, but that switches to a fallbackPublisher
if an item emitted by the currentFlowable
doesn't arrive within a window of time after the emission of the previous item, where that period of time is measured by aPublisher
that is a function of the previous item.Flowable.timeout
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<@NonNull V>> itemTimeoutIndicator, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> fallback) Returns aFlowable
that mirrors the currentFlowable
, but that switches to a fallbackPublisher
if an item emitted by the currentFlowable
doesn't arrive within a window of time after the emission of the previous item, where that period of time is measured by aPublisher
that is a function of the previous item.Flowable.timeout
(@NonNull org.reactivestreams.Publisher<@NonNull U> firstTimeoutIndicator, @NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<@NonNull V>> itemTimeoutIndicator) Returns aFlowable
that mirrors the currentFlowable
, but notifiesSubscriber
s of aTimeoutException
if either the first item emitted by the currentFlowable
or any subsequent item doesn't arrive within time windows defined by otherPublisher
s.Flowable.timeout
(@NonNull org.reactivestreams.Publisher<@NonNull U> firstTimeoutIndicator, @NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<@NonNull V>> itemTimeoutIndicator) Returns aFlowable
that mirrors the currentFlowable
, but notifiesSubscriber
s of aTimeoutException
if either the first item emitted by the currentFlowable
or any subsequent item doesn't arrive within time windows defined by otherPublisher
s.Flowable.timeout
(@NonNull org.reactivestreams.Publisher<@NonNull U> firstTimeoutIndicator, @NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<@NonNull V>> itemTimeoutIndicator, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> fallback) Returns aFlowable
that mirrors the currentFlowable
, but switches to a fallbackPublisher
if either the first item emitted by the currentFlowable
or any subsequent item doesn't arrive within time windows defined by otherPublisher
s.Flowable.timeout
(@NonNull org.reactivestreams.Publisher<@NonNull U> firstTimeoutIndicator, @NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<@NonNull V>> itemTimeoutIndicator, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> fallback) Returns aFlowable
that mirrors the currentFlowable
, but switches to a fallbackPublisher
if either the first item emitted by the currentFlowable
or any subsequent item doesn't arrive within time windows defined by otherPublisher
s.Flowable.timeout
(@NonNull org.reactivestreams.Publisher<@NonNull U> firstTimeoutIndicator, @NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<@NonNull V>> itemTimeoutIndicator, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> fallback) Returns aFlowable
that mirrors the currentFlowable
, but switches to a fallbackPublisher
if either the first item emitted by the currentFlowable
or any subsequent item doesn't arrive within time windows defined by otherPublisher
s.Returns aMaybe
that mirrors the currentMaybe
but applies a timeout policy for each emitted item.Maybe.timeout
(long timeout, @NonNull TimeUnit unit, @NonNull MaybeSource<? extends @NonNull T> fallback) Returns aMaybe
that mirrors the currentMaybe
but applies a timeout policy for each emitted item.Maybe.timeout
(long timeout, @NonNull TimeUnit unit, @NonNull MaybeSource<? extends @NonNull T> fallback) Returns aMaybe
that mirrors the currentMaybe
but applies a timeout policy for each emitted item.Returns aMaybe
that mirrors the currentMaybe
but applies a timeout policy for each emitted item, where this policy is governed on a specifiedScheduler
.Returns aMaybe
that mirrors the currentMaybe
but applies a timeout policy for each emitted item, where this policy is governed on a specifiedScheduler
.Maybe.timeout
(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, @NonNull MaybeSource<? extends @NonNull T> fallback) Returns aMaybe
that mirrors the currentMaybe
but applies a timeout policy for each emitted item using a specifiedScheduler
.Maybe.timeout
(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, @NonNull MaybeSource<? extends @NonNull T> fallback) Returns aMaybe
that mirrors the currentMaybe
but applies a timeout policy for each emitted item using a specifiedScheduler
.Maybe.timeout
(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, @NonNull MaybeSource<? extends @NonNull T> fallback) Returns aMaybe
that mirrors the currentMaybe
but applies a timeout policy for each emitted item using a specifiedScheduler
.Maybe.timeout
(@NonNull MaybeSource<@NonNull U> timeoutIndicator) If the currentMaybe
didn't signal an event before thetimeoutIndicator
MaybeSource
signals, aTimeoutException
is signaled instead.Maybe.timeout
(@NonNull MaybeSource<@NonNull U> timeoutIndicator, @NonNull MaybeSource<? extends @NonNull T> fallback) If the currentMaybe
didn't signal an event before thetimeoutIndicator
MaybeSource
signals, the currentMaybe
is disposed and thefallback
MaybeSource
subscribed to as a continuation.Maybe.timeout
(@NonNull MaybeSource<@NonNull U> timeoutIndicator, @NonNull MaybeSource<? extends @NonNull T> fallback) If the currentMaybe
didn't signal an event before thetimeoutIndicator
MaybeSource
signals, the currentMaybe
is disposed and thefallback
MaybeSource
subscribed to as a continuation.If the currentMaybe
source didn't signal an event before thetimeoutIndicator
Publisher
signals, aTimeoutException
is signaled instead.Maybe.timeout
(@NonNull org.reactivestreams.Publisher<@NonNull U> timeoutIndicator, @NonNull MaybeSource<? extends @NonNull T> fallback) If the currentMaybe
didn't signal an event before thetimeoutIndicator
Publisher
signals, the currentMaybe
is disposed and thefallback
MaybeSource
subscribed to as a continuation.Maybe.timeout
(@NonNull org.reactivestreams.Publisher<@NonNull U> timeoutIndicator, @NonNull MaybeSource<? extends @NonNull T> fallback) If the currentMaybe
didn't signal an event before thetimeoutIndicator
Publisher
signals, the currentMaybe
is disposed and thefallback
MaybeSource
subscribed to as a continuation.final @NonNull Observable
<T> Returns anObservable
that mirrors the currentObservable
but applies a timeout policy for each emitted item.final @NonNull Observable
<T> Observable.timeout
(long timeout, @NonNull TimeUnit unit, @NonNull ObservableSource<? extends @NonNull T> fallback) Returns anObservable
that mirrors the currentObservable
but applies a timeout policy for each emitted item.final @NonNull Observable
<T> Observable.timeout
(long timeout, @NonNull TimeUnit unit, @NonNull ObservableSource<? extends @NonNull T> fallback) Returns anObservable
that mirrors the currentObservable
but applies a timeout policy for each emitted item.final @NonNull Observable
<T> Returns anObservable
that mirrors the currentObservable
but applies a timeout policy for each emitted item, where this policy is governed on a specifiedScheduler
.final @NonNull Observable
<T> Returns anObservable
that mirrors the currentObservable
but applies a timeout policy for each emitted item, where this policy is governed on a specifiedScheduler
.final @NonNull Observable
<T> Observable.timeout
(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, @NonNull ObservableSource<? extends @NonNull T> fallback) Returns anObservable
that mirrors the currentObservable
but applies a timeout policy for each emitted item using a specifiedScheduler
.final @NonNull Observable
<T> Observable.timeout
(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, @NonNull ObservableSource<? extends @NonNull T> fallback) Returns anObservable
that mirrors the currentObservable
but applies a timeout policy for each emitted item using a specifiedScheduler
.final @NonNull Observable
<T> Observable.timeout
(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, @NonNull ObservableSource<? extends @NonNull T> fallback) Returns anObservable
that mirrors the currentObservable
but applies a timeout policy for each emitted item using a specifiedScheduler
.final <@NonNull U,
@NonNull V>
@NonNull Observable<T> Observable.timeout
(@NonNull ObservableSource<@NonNull U> firstTimeoutIndicator, @NonNull Function<? super @NonNull T, ? extends ObservableSource<@NonNull V>> itemTimeoutIndicator) Returns anObservable
that mirrors the currentObservable
, but notifies observers of aTimeoutException
if either the first item emitted by the currentObservable
or any subsequent item doesn't arrive within time windows defined by indicatorObservableSource
s.final <@NonNull U,
@NonNull V>
@NonNull Observable<T> Observable.timeout
(@NonNull ObservableSource<@NonNull U> firstTimeoutIndicator, @NonNull Function<? super @NonNull T, ? extends ObservableSource<@NonNull V>> itemTimeoutIndicator) Returns anObservable
that mirrors the currentObservable
, but notifies observers of aTimeoutException
if either the first item emitted by the currentObservable
or any subsequent item doesn't arrive within time windows defined by indicatorObservableSource
s.final <@NonNull U,
@NonNull V>
@NonNull Observable<T> Observable.timeout
(@NonNull ObservableSource<@NonNull U> firstTimeoutIndicator, @NonNull Function<? super @NonNull T, ? extends ObservableSource<@NonNull V>> itemTimeoutIndicator, @NonNull ObservableSource<? extends @NonNull T> fallback) Returns anObservable
that mirrors the currentObservable
, but switches to a fallbackObservableSource
if either the first item emitted by the currentObservable
or any subsequent item doesn't arrive within time windows defined by indicatorObservableSource
s.final <@NonNull U,
@NonNull V>
@NonNull Observable<T> Observable.timeout
(@NonNull ObservableSource<@NonNull U> firstTimeoutIndicator, @NonNull Function<? super @NonNull T, ? extends ObservableSource<@NonNull V>> itemTimeoutIndicator, @NonNull ObservableSource<? extends @NonNull T> fallback) Returns anObservable
that mirrors the currentObservable
, but switches to a fallbackObservableSource
if either the first item emitted by the currentObservable
or any subsequent item doesn't arrive within time windows defined by indicatorObservableSource
s.final <@NonNull U,
@NonNull V>
@NonNull Observable<T> Observable.timeout
(@NonNull ObservableSource<@NonNull U> firstTimeoutIndicator, @NonNull Function<? super @NonNull T, ? extends ObservableSource<@NonNull V>> itemTimeoutIndicator, @NonNull ObservableSource<? extends @NonNull T> fallback) Returns anObservable
that mirrors the currentObservable
, but switches to a fallbackObservableSource
if either the first item emitted by the currentObservable
or any subsequent item doesn't arrive within time windows defined by indicatorObservableSource
s.final <@NonNull V>
@NonNull Observable<T> Observable.timeout
(@NonNull Function<? super @NonNull T, ? extends ObservableSource<@NonNull V>> itemTimeoutIndicator) Returns anObservable
that mirrors the currentObservable
, but notifies observers of aTimeoutException
if an item emitted by the currentObservable
doesn't arrive within a window of time after the emission of the previous item, where that period of time is measured by anObservableSource
that is a function of the previous item.final <@NonNull V>
@NonNull Observable<T> Observable.timeout
(@NonNull Function<? super @NonNull T, ? extends ObservableSource<@NonNull V>> itemTimeoutIndicator, @NonNull ObservableSource<? extends @NonNull T> fallback) Returns anObservable
that mirrors the currentObservable
, but that switches to a fallbackObservableSource
if an item emitted by the currentObservable
doesn't arrive within a window of time after the emission of the previous item, where that period of time is measured by anObservableSource
that is a function of the previous item.final <@NonNull V>
@NonNull Observable<T> Observable.timeout
(@NonNull Function<? super @NonNull T, ? extends ObservableSource<@NonNull V>> itemTimeoutIndicator, @NonNull ObservableSource<? extends @NonNull T> fallback) Returns anObservable
that mirrors the currentObservable
, but that switches to a fallbackObservableSource
if an item emitted by the currentObservable
doesn't arrive within a window of time after the emission of the previous item, where that period of time is measured by anObservableSource
that is a function of the previous item.Signals aTimeoutException
if the currentSingle
doesn't signal a success value within the specified timeout window.Signals aTimeoutException
if the currentSingle
doesn't signal a success value within the specified timeout window.Signals aTimeoutException
if the currentSingle
doesn't signal a success value within the specified timeout window.Single.timeout
(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, @NonNull SingleSource<? extends @NonNull T> fallback) Runs the currentSingle
and if it doesn't signal within the specified timeout window, it is disposed and the otherSingleSource
subscribed to.Single.timeout
(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, @NonNull SingleSource<? extends @NonNull T> fallback) Runs the currentSingle
and if it doesn't signal within the specified timeout window, it is disposed and the otherSingleSource
subscribed to.Single.timeout
(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, @NonNull SingleSource<? extends @NonNull T> fallback) Runs the currentSingle
and if it doesn't signal within the specified timeout window, it is disposed and the otherSingleSource
subscribed to.Single.timeout
(long timeout, @NonNull TimeUnit unit, @NonNull SingleSource<? extends @NonNull T> fallback) Runs the currentSingle
and if it doesn't signal within the specified timeout window, it is disposed and the otherSingleSource
subscribed to.Single.timeout
(long timeout, @NonNull TimeUnit unit, @NonNull SingleSource<? extends @NonNull T> fallback) Runs the currentSingle
and if it doesn't signal within the specified timeout window, it is disposed and the otherSingleSource
subscribed to.private @NonNull Observable
<T> Observable.timeout0
(long timeout, @NonNull TimeUnit unit, @Nullable ObservableSource<? extends @NonNull T> fallback, @NonNull Scheduler scheduler) private @NonNull Observable
<T> Observable.timeout0
(long timeout, @NonNull TimeUnit unit, @Nullable ObservableSource<? extends @NonNull T> fallback, @NonNull Scheduler scheduler) private <U,
V> @NonNull Observable <T> Observable.timeout0
(@NonNull ObservableSource<U> firstTimeoutIndicator, @NonNull Function<? super @NonNull T, ? extends ObservableSource<V>> itemTimeoutIndicator, @Nullable ObservableSource<? extends @NonNull T> fallback) private <U,
V> @NonNull Observable <T> Observable.timeout0
(@NonNull ObservableSource<U> firstTimeoutIndicator, @NonNull Function<? super @NonNull T, ? extends ObservableSource<V>> itemTimeoutIndicator, @Nullable ObservableSource<? extends @NonNull T> fallback) static @NonNull Completable
Returns aCompletable
instance that fires itsonComplete
event after the given delay elapsed.static @NonNull Completable
Returns aCompletable
instance that fires itsonComplete
event after the given delay elapsed by using the suppliedScheduler
.static @NonNull Completable
Returns aCompletable
instance that fires itsonComplete
event after the given delay elapsed by using the suppliedScheduler
.Returns aFlowable
that emits0L
after a specified delay, and then completes.Returns aFlowable
that emits0L
after a specified delay, on a specifiedScheduler
, and then completes.Returns aFlowable
that emits0L
after a specified delay, on a specifiedScheduler
, and then completes.Returns aMaybe
that emits0L
after a specified delay.static @NonNull Observable
<Long> Returns anObservable
that emits0L
after a specified delay, and then completes.static @NonNull Observable
<Long> Returns anObservable
that emits0L
after a specified delay, on a specifiedScheduler
, and then completes.static @NonNull Observable
<Long> Returns anObservable
that emits0L
after a specified delay, on a specifiedScheduler
, and then completes.Signals success with 0L value after the given delay when aSingleObserver
subscribes.Signals success with 0L value on the specifiedScheduler
after the given delay when aSingleObserver
subscribes.Signals success with 0L value on the specifiedScheduler
after the given delay when aSingleObserver
subscribes.final @NonNull Observable
<Timed<T>> final @NonNull Observable
<Timed<T>> Returns anObservable
that emits each item emitted by the currentObservable
, wrapped in aTimed
object.final @NonNull Observable
<Timed<T>> final @NonNull Observable
<Timed<T>> final <R> R
Completable.to
(@NonNull CompletableConverter<? extends R> converter) Calls the specifiedCompletableConverter
function during assembly time and returns its resulting value.final <@NonNull R>
RCalls the specified converter function during assembly time and returns its resulting value.final <R> R
Maybe.to
(@NonNull MaybeConverter<@NonNull T, ? extends R> converter) Calls the specified converter function during assembly time and returns its resulting value.final <@NonNull R>
RCalls the specified converter function during assembly time and returns its resulting value.final <R> R
Single.to
(@NonNull SingleConverter<@NonNull T, ? extends R> converter) Calls the specified converter function during assembly time and returns its resulting value.Observable.toFlowable
(@NonNull BackpressureStrategy strategy) Converts the currentObservable
into aFlowable
by applying the specified backpressure strategy.Returns aSingle
that emits a single item, a list composed of all the items emitted by the finite sourcePublisher
.Returns aSingle
that emits a single item, aCollection
(subclass) composed of all the items emitted by the finite upstreamObservable
.Flowable.toMap
(@NonNull Function<? super @NonNull T, ? extends @NonNull K> keySelector, @NonNull Function<? super @NonNull T, ? extends @NonNull V> valueSelector) Flowable.toMap
(@NonNull Function<? super @NonNull T, ? extends @NonNull K> keySelector, @NonNull Function<? super @NonNull T, ? extends @NonNull V> valueSelector) Flowable.toMap
(@NonNull Function<? super @NonNull T, ? extends @NonNull K> keySelector, @NonNull Function<? super @NonNull T, ? extends @NonNull V> valueSelector, @NonNull Supplier<? extends Map<@NonNull K, @NonNull V>> mapSupplier) Flowable.toMap
(@NonNull Function<? super @NonNull T, ? extends @NonNull K> keySelector, @NonNull Function<? super @NonNull T, ? extends @NonNull V> valueSelector, @NonNull Supplier<? extends Map<@NonNull K, @NonNull V>> mapSupplier) Flowable.toMap
(@NonNull Function<? super @NonNull T, ? extends @NonNull K> keySelector, @NonNull Function<? super @NonNull T, ? extends @NonNull V> valueSelector, @NonNull Supplier<? extends Map<@NonNull K, @NonNull V>> mapSupplier) Observable.toMap
(@NonNull Function<? super @NonNull T, ? extends @NonNull K> keySelector, @NonNull Function<? super @NonNull T, ? extends @NonNull V> valueSelector) Observable.toMap
(@NonNull Function<? super @NonNull T, ? extends @NonNull K> keySelector, @NonNull Function<? super @NonNull T, ? extends @NonNull V> valueSelector) Observable.toMap
(@NonNull Function<? super @NonNull T, ? extends @NonNull K> keySelector, @NonNull Function<? super @NonNull T, ? extends @NonNull V> valueSelector, @NonNull Supplier<? extends Map<@NonNull K, @NonNull V>> mapSupplier) Observable.toMap
(@NonNull Function<? super @NonNull T, ? extends @NonNull K> keySelector, @NonNull Function<? super @NonNull T, ? extends @NonNull V> valueSelector, @NonNull Supplier<? extends Map<@NonNull K, @NonNull V>> mapSupplier) Observable.toMap
(@NonNull Function<? super @NonNull T, ? extends @NonNull K> keySelector, @NonNull Function<? super @NonNull T, ? extends @NonNull V> valueSelector, @NonNull Supplier<? extends Map<@NonNull K, @NonNull V>> mapSupplier) Flowable.toMultimap
(@NonNull Function<? super @NonNull T, ? extends @NonNull K> keySelector, @NonNull Function<? super @NonNull T, ? extends @NonNull V> valueSelector) Flowable.toMultimap
(@NonNull Function<? super @NonNull T, ? extends @NonNull K> keySelector, @NonNull Function<? super @NonNull T, ? extends @NonNull V> valueSelector) Flowable.toMultimap
(@NonNull Function<? super @NonNull T, ? extends @NonNull K> keySelector, @NonNull Function<? super @NonNull T, ? extends @NonNull V> valueSelector, @NonNull Supplier<? extends Map<@NonNull K, Collection<@NonNull V>>> mapSupplier, @NonNull Function<? super @NonNull K, ? extends Collection<? super @NonNull V>> collectionFactory) Flowable.toMultimap
(@NonNull Function<? super @NonNull T, ? extends @NonNull K> keySelector, @NonNull Function<? super @NonNull T, ? extends @NonNull V> valueSelector, @NonNull Supplier<? extends Map<@NonNull K, Collection<@NonNull V>>> mapSupplier, @NonNull Function<? super @NonNull K, ? extends Collection<? super @NonNull V>> collectionFactory) Flowable.toMultimap
(@NonNull Function<? super @NonNull T, ? extends @NonNull K> keySelector, @NonNull Function<? super @NonNull T, ? extends @NonNull V> valueSelector, @NonNull Supplier<? extends Map<@NonNull K, Collection<@NonNull V>>> mapSupplier, @NonNull Function<? super @NonNull K, ? extends Collection<? super @NonNull V>> collectionFactory) Flowable.toMultimap
(@NonNull Function<? super @NonNull T, ? extends @NonNull K> keySelector, @NonNull Function<? super @NonNull T, ? extends @NonNull V> valueSelector, @NonNull Supplier<? extends Map<@NonNull K, Collection<@NonNull V>>> mapSupplier, @NonNull Function<? super @NonNull K, ? extends Collection<? super @NonNull V>> collectionFactory) Flowable.toMultimap
(@NonNull Function<? super @NonNull T, ? extends @NonNull K> keySelector, @NonNull Function<? super @NonNull T, ? extends @NonNull V> valueSelector, @NonNull Supplier<Map<@NonNull K, Collection<@NonNull V>>> mapSupplier) Flowable.toMultimap
(@NonNull Function<? super @NonNull T, ? extends @NonNull K> keySelector, @NonNull Function<? super @NonNull T, ? extends @NonNull V> valueSelector, @NonNull Supplier<Map<@NonNull K, Collection<@NonNull V>>> mapSupplier) Flowable.toMultimap
(@NonNull Function<? super @NonNull T, ? extends @NonNull K> keySelector, @NonNull Function<? super @NonNull T, ? extends @NonNull V> valueSelector, @NonNull Supplier<Map<@NonNull K, Collection<@NonNull V>>> mapSupplier) Observable.toMultimap
(@NonNull Function<? super @NonNull T, ? extends @NonNull K> keySelector, @NonNull Function<? super @NonNull T, ? extends @NonNull V> valueSelector, @NonNull Supplier<? extends Map<@NonNull K, Collection<@NonNull V>>> mapSupplier, @NonNull Function<? super @NonNull K, ? extends Collection<? super @NonNull V>> collectionFactory) Returns aSingle
that emits a singleMap
(subclass), returned by a specifiedmapFactory
function, that contains a customCollection
of values, extracted by a specifiedvalueSelector
function from items emitted by the current and finiteObservable
, and keyed by thekeySelector
function.Observable.toMultimap
(@NonNull Function<? super @NonNull T, ? extends @NonNull K> keySelector, @NonNull Function<? super @NonNull T, ? extends @NonNull V> valueSelector, @NonNull Supplier<? extends Map<@NonNull K, Collection<@NonNull V>>> mapSupplier, @NonNull Function<? super @NonNull K, ? extends Collection<? super @NonNull V>> collectionFactory) Returns aSingle
that emits a singleMap
(subclass), returned by a specifiedmapFactory
function, that contains a customCollection
of values, extracted by a specifiedvalueSelector
function from items emitted by the current and finiteObservable
, and keyed by thekeySelector
function.Observable.toMultimap
(@NonNull Function<? super @NonNull T, ? extends @NonNull K> keySelector, @NonNull Function<? super @NonNull T, ? extends @NonNull V> valueSelector, @NonNull Supplier<? extends Map<@NonNull K, Collection<@NonNull V>>> mapSupplier, @NonNull Function<? super @NonNull K, ? extends Collection<? super @NonNull V>> collectionFactory) Returns aSingle
that emits a singleMap
(subclass), returned by a specifiedmapFactory
function, that contains a customCollection
of values, extracted by a specifiedvalueSelector
function from items emitted by the current and finiteObservable
, and keyed by thekeySelector
function.Observable.toMultimap
(@NonNull Function<? super @NonNull T, ? extends @NonNull K> keySelector, @NonNull Function<? super @NonNull T, ? extends @NonNull V> valueSelector, @NonNull Supplier<? extends Map<@NonNull K, Collection<@NonNull V>>> mapSupplier, @NonNull Function<? super @NonNull K, ? extends Collection<? super @NonNull V>> collectionFactory) Returns aSingle
that emits a singleMap
(subclass), returned by a specifiedmapFactory
function, that contains a customCollection
of values, extracted by a specifiedvalueSelector
function from items emitted by the current and finiteObservable
, and keyed by thekeySelector
function.Observable.toMultimap
(@NonNull Function<? super @NonNull T, ? extends @NonNull K> keySelector, @NonNull Function<? super @NonNull T, ? extends @NonNull V> valueSelector, @NonNull Supplier<Map<@NonNull K, Collection<@NonNull V>>> mapSupplier) Observable.toMultimap
(@NonNull Function<? super @NonNull T, ? extends @NonNull K> keySelector, @NonNull Function<? super @NonNull T, ? extends @NonNull V> valueSelector, @NonNull Supplier<Map<@NonNull K, Collection<@NonNull V>>> mapSupplier) Observable.toMultimap
(@NonNull Function<? super @NonNull T, ? extends @NonNull K> keySelector, @NonNull Function<? super @NonNull T, ? extends @NonNull V> valueSelector, @NonNull Supplier<Map<@NonNull K, Collection<@NonNull V>>> mapSupplier) Observable.toMultimap
(@NonNull Function<? super @NonNull T, ? extends @NonNull K> keySelector, Function<? super @NonNull T, ? extends @NonNull V> valueSelector) Flowable.toSortedList
(@NonNull Comparator<? super @NonNull T> comparator) Flowable.toSortedList
(@NonNull Comparator<? super @NonNull T> comparator, int capacityHint) Observable.toSortedList
(@NonNull Comparator<? super @NonNull T> comparator) Observable.toSortedList
(@NonNull Comparator<? super @NonNull T> comparator, int capacityHint) boolean
CompletableEmitter.tryOnError
(@NonNull Throwable t) Attempts to emit the specifiedThrowable
error if the downstream hasn't cancelled the sequence or is otherwise terminated, returning false if the emission is not allowed to happen due to lifecycle restrictions.boolean
FlowableEmitter.tryOnError
(@NonNull Throwable t) Attempts to emit the specifiedThrowable
error if the downstream hasn't cancelled the sequence or is otherwise terminated, returning false if the emission is not allowed to happen due to lifecycle restrictions.boolean
MaybeEmitter.tryOnError
(@NonNull Throwable t) Attempts to emit the specifiedThrowable
error if the downstream hasn't cancelled the sequence or is otherwise terminated, returning false if the emission is not allowed to happen due to lifecycle restrictions.boolean
ObservableEmitter.tryOnError
(@NonNull Throwable t) Attempts to emit the specifiedThrowable
error if the downstream hasn't cancelled the sequence or is otherwise terminated, returning false if the emission is not allowed to happen due to lifecycle restrictions.boolean
SingleEmitter.tryOnError
(@NonNull Throwable t) Attempts to emit the specifiedThrowable
error if the downstream hasn't cancelled the sequence or is otherwise terminated, returning false if the emission is not allowed to happen due to lifecycle restrictions.static @NonNull Completable
Completable.unsafeCreate
(@NonNull CompletableSource onSubscribe) Constructs aCompletable
instance by wrapping the given source callback without any safeguards; you should manage the lifecycle and response to downstream disposal.Flowable.unsafeCreate
(@NonNull org.reactivestreams.Publisher<@NonNull T> onSubscribe) Create aFlowable
by wrapping aPublisher
which has to be implemented according to the Reactive Streams specification by handling backpressure and cancellation correctly; no safeguards are provided by theFlowable
itself.Maybe.unsafeCreate
(@NonNull MaybeSource<@NonNull T> onSubscribe) Advanced use only: creates aMaybe
instance without any safeguards by using a callback that is called with aMaybeObserver
.static <@NonNull T>
@NonNull Observable<T> Observable.unsafeCreate
(@NonNull ObservableSource<@NonNull T> onSubscribe) Create anObservable
by wrapping anObservableSource
which has to be implemented according to theObservable
specification derived from the Reactive Streams specification by handling disposal correctly; no safeguards are provided by theObservable
itself.Single.unsafeCreate
(@NonNull SingleSource<@NonNull T> onSubscribe) Advanced use only: creates aSingle
instance without any safeguards by using a callback that is called with aSingleObserver
.final @NonNull Completable
Completable.unsubscribeOn
(@NonNull Scheduler scheduler) Returns aCompletable
which makes sure when an observer disposes the subscription, thedispose()
method is called on the specifiedScheduler
.Flowable.unsubscribeOn
(@NonNull Scheduler scheduler) Cancels the currentFlowable
asynchronously by invokingSubscription.cancel()
on the specifiedScheduler
.Maybe.unsubscribeOn
(@NonNull Scheduler scheduler) Returns aMaybe
which makes sure when aMaybeObserver
disposes theDisposable
, that call is propagated up on the specifiedScheduler
.final @NonNull Observable
<T> Observable.unsubscribeOn
(@NonNull Scheduler scheduler) Single.unsubscribeOn
(@NonNull Scheduler scheduler) Returns aSingle
which makes sure when aSingleObserver
disposes theDisposable
, that call is propagated up on the specifiedScheduler
.static <@NonNull R>
@NonNull CompletableCompletable.using
(@NonNull Supplier<@NonNull R> resourceSupplier, @NonNull Function<? super @NonNull R, ? extends CompletableSource> sourceSupplier, @NonNull Consumer<? super @NonNull R> resourceCleanup) Returns aCompletable
instance which manages a resource along with a customCompletableSource
instance while the subscription is active.static <@NonNull R>
@NonNull CompletableCompletable.using
(@NonNull Supplier<@NonNull R> resourceSupplier, @NonNull Function<? super @NonNull R, ? extends CompletableSource> sourceSupplier, @NonNull Consumer<? super @NonNull R> resourceCleanup) Returns aCompletable
instance which manages a resource along with a customCompletableSource
instance while the subscription is active.static <@NonNull R>
@NonNull CompletableCompletable.using
(@NonNull Supplier<@NonNull R> resourceSupplier, @NonNull Function<? super @NonNull R, ? extends CompletableSource> sourceSupplier, @NonNull Consumer<? super @NonNull R> resourceCleanup) Returns aCompletable
instance which manages a resource along with a customCompletableSource
instance while the subscription is active.static <@NonNull R>
@NonNull CompletableCompletable.using
(@NonNull Supplier<@NonNull R> resourceSupplier, @NonNull Function<? super @NonNull R, ? extends CompletableSource> sourceSupplier, @NonNull Consumer<? super @NonNull R> resourceCleanup, boolean eager) Returns aCompletable
instance which manages a resource along with a customCompletableSource
instance while the subscription is active and performs eager or lazy resource disposition.static <@NonNull R>
@NonNull CompletableCompletable.using
(@NonNull Supplier<@NonNull R> resourceSupplier, @NonNull Function<? super @NonNull R, ? extends CompletableSource> sourceSupplier, @NonNull Consumer<? super @NonNull R> resourceCleanup, boolean eager) Returns aCompletable
instance which manages a resource along with a customCompletableSource
instance while the subscription is active and performs eager or lazy resource disposition.static <@NonNull R>
@NonNull CompletableCompletable.using
(@NonNull Supplier<@NonNull R> resourceSupplier, @NonNull Function<? super @NonNull R, ? extends CompletableSource> sourceSupplier, @NonNull Consumer<? super @NonNull R> resourceCleanup, boolean eager) Returns aCompletable
instance which manages a resource along with a customCompletableSource
instance while the subscription is active and performs eager or lazy resource disposition.Flowable.using
(@NonNull Supplier<? extends @NonNull D> resourceSupplier, @NonNull Function<? super @NonNull D, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sourceSupplier, @NonNull Consumer<? super @NonNull D> resourceCleanup) Constructs aFlowable
that creates a dependent resource object, aPublisher
with that resource and calls the providedresourceDisposer
function if this inner source terminates or the downstream cancels the flow.Flowable.using
(@NonNull Supplier<? extends @NonNull D> resourceSupplier, @NonNull Function<? super @NonNull D, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sourceSupplier, @NonNull Consumer<? super @NonNull D> resourceCleanup) Constructs aFlowable
that creates a dependent resource object, aPublisher
with that resource and calls the providedresourceDisposer
function if this inner source terminates or the downstream cancels the flow.Flowable.using
(@NonNull Supplier<? extends @NonNull D> resourceSupplier, @NonNull Function<? super @NonNull D, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sourceSupplier, @NonNull Consumer<? super @NonNull D> resourceCleanup) Constructs aFlowable
that creates a dependent resource object, aPublisher
with that resource and calls the providedresourceDisposer
function if this inner source terminates or the downstream cancels the flow.Flowable.using
(@NonNull Supplier<? extends @NonNull D> resourceSupplier, @NonNull Function<? super @NonNull D, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sourceSupplier, @NonNull Consumer<? super @NonNull D> resourceCleanup, boolean eager) Constructs aFlowable
that creates a dependent resource object, aPublisher
with that resource and calls the providedresourceDisposer
function if this inner source terminates or the downstream disposes the flow; doing it before these end-states have been reached ifeager == true
, after otherwise.Flowable.using
(@NonNull Supplier<? extends @NonNull D> resourceSupplier, @NonNull Function<? super @NonNull D, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sourceSupplier, @NonNull Consumer<? super @NonNull D> resourceCleanup, boolean eager) Constructs aFlowable
that creates a dependent resource object, aPublisher
with that resource and calls the providedresourceDisposer
function if this inner source terminates or the downstream disposes the flow; doing it before these end-states have been reached ifeager == true
, after otherwise.Flowable.using
(@NonNull Supplier<? extends @NonNull D> resourceSupplier, @NonNull Function<? super @NonNull D, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sourceSupplier, @NonNull Consumer<? super @NonNull D> resourceCleanup, boolean eager) Constructs aFlowable
that creates a dependent resource object, aPublisher
with that resource and calls the providedresourceDisposer
function if this inner source terminates or the downstream disposes the flow; doing it before these end-states have been reached ifeager == true
, after otherwise.Maybe.using
(@NonNull Supplier<? extends @NonNull D> resourceSupplier, @NonNull Function<? super @NonNull D, ? extends MaybeSource<? extends @NonNull T>> sourceSupplier, @NonNull Consumer<? super @NonNull D> resourceCleanup) Constructs aMaybe
that creates a dependent resource object which is disposed of when the generatedMaybeSource
terminates or the downstream calls dispose().Maybe.using
(@NonNull Supplier<? extends @NonNull D> resourceSupplier, @NonNull Function<? super @NonNull D, ? extends MaybeSource<? extends @NonNull T>> sourceSupplier, @NonNull Consumer<? super @NonNull D> resourceCleanup) Constructs aMaybe
that creates a dependent resource object which is disposed of when the generatedMaybeSource
terminates or the downstream calls dispose().Maybe.using
(@NonNull Supplier<? extends @NonNull D> resourceSupplier, @NonNull Function<? super @NonNull D, ? extends MaybeSource<? extends @NonNull T>> sourceSupplier, @NonNull Consumer<? super @NonNull D> resourceCleanup) Constructs aMaybe
that creates a dependent resource object which is disposed of when the generatedMaybeSource
terminates or the downstream calls dispose().Maybe.using
(@NonNull Supplier<? extends @NonNull D> resourceSupplier, @NonNull Function<? super @NonNull D, ? extends MaybeSource<? extends @NonNull T>> sourceSupplier, @NonNull Consumer<? super @NonNull D> resourceCleanup, boolean eager) Constructs aMaybe
that creates a dependent resource object which is disposed first ({code eager == true}) when the generatedMaybeSource
terminates or the downstream disposes; or after ({code eager == false}).Maybe.using
(@NonNull Supplier<? extends @NonNull D> resourceSupplier, @NonNull Function<? super @NonNull D, ? extends MaybeSource<? extends @NonNull T>> sourceSupplier, @NonNull Consumer<? super @NonNull D> resourceCleanup, boolean eager) Constructs aMaybe
that creates a dependent resource object which is disposed first ({code eager == true}) when the generatedMaybeSource
terminates or the downstream disposes; or after ({code eager == false}).Maybe.using
(@NonNull Supplier<? extends @NonNull D> resourceSupplier, @NonNull Function<? super @NonNull D, ? extends MaybeSource<? extends @NonNull T>> sourceSupplier, @NonNull Consumer<? super @NonNull D> resourceCleanup, boolean eager) Constructs aMaybe
that creates a dependent resource object which is disposed first ({code eager == true}) when the generatedMaybeSource
terminates or the downstream disposes; or after ({code eager == false}).static <@NonNull T,
@NonNull D>
@NonNull Observable<T> Observable.using
(@NonNull Supplier<? extends @NonNull D> resourceSupplier, @NonNull Function<? super @NonNull D, ? extends ObservableSource<? extends @NonNull T>> sourceSupplier, @NonNull Consumer<? super @NonNull D> resourceCleanup) Constructs anObservable
that creates a dependent resource object, anObservableSource
with that resource and calls the providedresourceDisposer
function if this inner source terminates or the downstream disposes the flow.static <@NonNull T,
@NonNull D>
@NonNull Observable<T> Observable.using
(@NonNull Supplier<? extends @NonNull D> resourceSupplier, @NonNull Function<? super @NonNull D, ? extends ObservableSource<? extends @NonNull T>> sourceSupplier, @NonNull Consumer<? super @NonNull D> resourceCleanup) Constructs anObservable
that creates a dependent resource object, anObservableSource
with that resource and calls the providedresourceDisposer
function if this inner source terminates or the downstream disposes the flow.static <@NonNull T,
@NonNull D>
@NonNull Observable<T> Observable.using
(@NonNull Supplier<? extends @NonNull D> resourceSupplier, @NonNull Function<? super @NonNull D, ? extends ObservableSource<? extends @NonNull T>> sourceSupplier, @NonNull Consumer<? super @NonNull D> resourceCleanup) Constructs anObservable
that creates a dependent resource object, anObservableSource
with that resource and calls the providedresourceDisposer
function if this inner source terminates or the downstream disposes the flow.static <@NonNull T,
@NonNull D>
@NonNull Observable<T> Observable.using
(@NonNull Supplier<? extends @NonNull D> resourceSupplier, @NonNull Function<? super @NonNull D, ? extends ObservableSource<? extends @NonNull T>> sourceSupplier, @NonNull Consumer<? super @NonNull D> resourceCleanup, boolean eager) Constructs anObservable
that creates a dependent resource object, anObservableSource
with that resource and calls the provideddisposer
function if this inner source terminates or the downstream disposes the flow; doing it before these end-states have been reached ifeager == true
, after otherwise.static <@NonNull T,
@NonNull D>
@NonNull Observable<T> Observable.using
(@NonNull Supplier<? extends @NonNull D> resourceSupplier, @NonNull Function<? super @NonNull D, ? extends ObservableSource<? extends @NonNull T>> sourceSupplier, @NonNull Consumer<? super @NonNull D> resourceCleanup, boolean eager) Constructs anObservable
that creates a dependent resource object, anObservableSource
with that resource and calls the provideddisposer
function if this inner source terminates or the downstream disposes the flow; doing it before these end-states have been reached ifeager == true
, after otherwise.static <@NonNull T,
@NonNull D>
@NonNull Observable<T> Observable.using
(@NonNull Supplier<? extends @NonNull D> resourceSupplier, @NonNull Function<? super @NonNull D, ? extends ObservableSource<? extends @NonNull T>> sourceSupplier, @NonNull Consumer<? super @NonNull D> resourceCleanup, boolean eager) Constructs anObservable
that creates a dependent resource object, anObservableSource
with that resource and calls the provideddisposer
function if this inner source terminates or the downstream disposes the flow; doing it before these end-states have been reached ifeager == true
, after otherwise.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 aSingleSource
instance generated from that resource (similar to a try-with-resources).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 aSingleSource
instance generated from that resource (similar to a try-with-resources).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 aSingleSource
instance generated from that resource (similar to a try-with-resources).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 aSingleSource
instance generated from that resource (similar to a try-with-resources).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 aSingleSource
instance generated from that resource (similar to a try-with-resources).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 aSingleSource
instance generated from that resource (similar to a try-with-resources).<S extends Scheduler & Disposable>
SScheduler.when
(@NonNull Function<Flowable<Flowable<Completable>>, Completable> combine) Allows the use of operators for controlling the timing around when actions scheduled on workers are actually done.Returns aFlowable
that emits windows of items it collects from the currentFlowable
.Returns aFlowable
that emits windows of items it collects from the currentFlowable
.Returns aFlowable
that emits windows of items it collects from the currentFlowable
.Flowable.window
(long timespan, long timeskip, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, int bufferSize) Returns aFlowable
that emits windows of items it collects from the currentFlowable
.Flowable.window
(long timespan, long timeskip, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, int bufferSize) Returns aFlowable
that emits windows of items it collects from the currentFlowable
.Returns aFlowable
that emits windows of items it collects from the currentFlowable
.Returns aFlowable
that emits windows of items it collects from the currentFlowable
.Returns aFlowable
that emits windows of items it collects from the currentFlowable
.Returns aFlowable
that emits windows of items it collects from the currentFlowable
.Returns aFlowable
that emits windows of items it collects from the currentFlowable
.Returns aFlowable
that emits windows of items it collects from the currentFlowable
.Returns aFlowable
that emits windows of items it collects from the currentFlowable
.Flowable.window
(long timespan, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, long count, boolean restart) Returns aFlowable
that emits windows of items it collects from the currentFlowable
.Flowable.window
(long timespan, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, long count, boolean restart) Returns aFlowable
that emits windows of items it collects from the currentFlowable
.Flowable.window
(long timespan, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, long count, boolean restart, int bufferSize) Returns aFlowable
that emits windows of items it collects from the currentFlowable
.Flowable.window
(long timespan, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, long count, boolean restart, int bufferSize) Returns aFlowable
that emits windows of items it collects from the currentFlowable
.Returns aFlowable
that emits non-overlapping windows of items it collects from the currentFlowable
where the boundary of each window is determined by the items emitted from a specified boundary-governingPublisher
.Flowable.window
(@NonNull org.reactivestreams.Publisher<@NonNull B> boundaryIndicator, int bufferSize) Returns aFlowable
that emits non-overlapping windows of items it collects from the currentFlowable
where the boundary of each window is determined by the items emitted from a specified boundary-governingPublisher
.Flowable.window
(@NonNull org.reactivestreams.Publisher<@NonNull U> openingIndicator, @NonNull Function<? super @NonNull U, @NonNull ? extends org.reactivestreams.Publisher<@NonNull V>> closingIndicator) Returns aFlowable
that emits windows of items it collects from the currentFlowable
.Flowable.window
(@NonNull org.reactivestreams.Publisher<@NonNull U> openingIndicator, @NonNull Function<? super @NonNull U, @NonNull ? extends org.reactivestreams.Publisher<@NonNull V>> closingIndicator) Returns aFlowable
that emits windows of items it collects from the currentFlowable
.Flowable.window
(@NonNull org.reactivestreams.Publisher<@NonNull U> openingIndicator, @NonNull Function<? super @NonNull U, @NonNull ? extends org.reactivestreams.Publisher<@NonNull V>> closingIndicator, int bufferSize) Returns aFlowable
that emits windows of items it collects from the currentFlowable
.Flowable.window
(@NonNull org.reactivestreams.Publisher<@NonNull U> openingIndicator, @NonNull Function<? super @NonNull U, @NonNull ? extends org.reactivestreams.Publisher<@NonNull V>> closingIndicator, int bufferSize) Returns aFlowable
that emits windows of items it collects from the currentFlowable
.final @NonNull Observable
<Observable<T>> Returns anObservable
that emits windows of items it collects from the currentObservable
.final @NonNull Observable
<Observable<T>> Observable.window
(long timespan, long timeskip, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Returns anObservable
that emits windows of items it collects from the currentObservable
.final @NonNull Observable
<Observable<T>> Observable.window
(long timespan, long timeskip, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Returns anObservable
that emits windows of items it collects from the currentObservable
.final @NonNull Observable
<Observable<T>> Observable.window
(long timespan, long timeskip, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, int bufferSize) Returns anObservable
that emits windows of items it collects from the currentObservable
.final @NonNull Observable
<Observable<T>> Observable.window
(long timespan, long timeskip, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, int bufferSize) Returns anObservable
that emits windows of items it collects from the currentObservable
.final @NonNull Observable
<Observable<T>> Returns anObservable
that emits windows of items it collects from the currentObservable
.final @NonNull Observable
<Observable<T>> Returns anObservable
that emits windows of items it collects from the currentObservable
.final @NonNull Observable
<Observable<T>> Returns anObservable
that emits windows of items it collects from the currentObservable
.final @NonNull Observable
<Observable<T>> Returns anObservable
that emits windows of items it collects from the currentObservable
.final @NonNull Observable
<Observable<T>> Returns anObservable
that emits windows of items it collects from the currentObservable
.final @NonNull Observable
<Observable<T>> Returns anObservable
that emits windows of items it collects from the currentObservable
.final @NonNull Observable
<Observable<T>> Returns anObservable
that emits windows of items it collects from the currentObservable
.final @NonNull Observable
<Observable<T>> Observable.window
(long timespan, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, long count, boolean restart) Returns anObservable
that emits windows of items it collects from the currentObservable
.final @NonNull Observable
<Observable<T>> Observable.window
(long timespan, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, long count, boolean restart) Returns anObservable
that emits windows of items it collects from the currentObservable
.final @NonNull Observable
<Observable<T>> Observable.window
(long timespan, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, long count, boolean restart, int bufferSize) Returns anObservable
that emits windows of items it collects from the currentObservable
.final @NonNull Observable
<Observable<T>> Observable.window
(long timespan, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, long count, boolean restart, int bufferSize) Returns anObservable
that emits windows of items it collects from the currentObservable
.final <@NonNull B>
@NonNull Observable<Observable<T>> Observable.window
(@NonNull ObservableSource<@NonNull B> boundaryIndicator) Returns anObservable
that emits non-overlapping windows of items it collects from the currentObservable
where the boundary of each window is determined by the items emitted from a specified boundary-governingObservableSource
.final <@NonNull B>
@NonNull Observable<Observable<T>> Observable.window
(@NonNull ObservableSource<@NonNull B> boundaryIndicator, int bufferSize) Returns anObservable
that emits non-overlapping windows of items it collects from the currentObservable
where the boundary of each window is determined by the items emitted from a specified boundary-governingObservableSource
.final <@NonNull U,
@NonNull V>
@NonNull Observable<Observable<T>> Observable.window
(@NonNull ObservableSource<@NonNull U> openingIndicator, @NonNull Function<? super @NonNull U, ? extends ObservableSource<@NonNull V>> closingIndicator) Returns anObservable
that emits windows of items it collects from the currentObservable
.final <@NonNull U,
@NonNull V>
@NonNull Observable<Observable<T>> Observable.window
(@NonNull ObservableSource<@NonNull U> openingIndicator, @NonNull Function<? super @NonNull U, ? extends ObservableSource<@NonNull V>> closingIndicator) Returns anObservable
that emits windows of items it collects from the currentObservable
.final <@NonNull U,
@NonNull V>
@NonNull Observable<Observable<T>> Observable.window
(@NonNull ObservableSource<@NonNull U> openingIndicator, @NonNull Function<? super @NonNull U, ? extends ObservableSource<@NonNull V>> closingIndicator, int bufferSize) Returns anObservable
that emits windows of items it collects from the currentObservable
.final <@NonNull U,
@NonNull V>
@NonNull Observable<Observable<T>> Observable.window
(@NonNull ObservableSource<@NonNull U> openingIndicator, @NonNull Function<? super @NonNull U, ? extends ObservableSource<@NonNull V>> closingIndicator, int bufferSize) Returns anObservable
that emits windows of items it collects from the currentObservable
.Flowable.withLatestFrom
(@NonNull Iterable<@NonNull ? extends org.reactivestreams.Publisher<@NonNull ?>> others, @NonNull Function<? super Object[], @NonNull R> combiner) Combines the value emission from the currentFlowable
with the latest emissions from the otherPublisher
s via a function to produce the output item.Flowable.withLatestFrom
(@NonNull Iterable<@NonNull ? extends org.reactivestreams.Publisher<@NonNull ?>> others, @NonNull Function<? super Object[], @NonNull R> combiner) Combines the value emission from the currentFlowable
with the latest emissions from the otherPublisher
s via a function to produce the output item.Flowable.withLatestFrom
(@NonNull org.reactivestreams.Publisher<? extends @NonNull U> other, @NonNull BiFunction<? super @NonNull T, ? super @NonNull U, ? extends @NonNull R> combiner) Merges the specifiedPublisher
into the currentFlowable
sequence by using theresultSelector
function only when the currentFlowable
(this instance) emits an item.Flowable.withLatestFrom
(@NonNull org.reactivestreams.Publisher<? extends @NonNull U> other, @NonNull BiFunction<? super @NonNull T, ? super @NonNull U, ? extends @NonNull R> combiner) Merges the specifiedPublisher
into the currentFlowable
sequence by using theresultSelector
function only when the currentFlowable
(this instance) emits an item.Flowable.withLatestFrom
(@NonNull org.reactivestreams.Publisher<@NonNull ?>[] others, @NonNull Function<? super Object[], @NonNull R> combiner) Combines the value emission from the currentFlowable
with the latest emissions from the otherPublisher
s via a function to produce the output item.Flowable.withLatestFrom
(@NonNull org.reactivestreams.Publisher<@NonNull ?>[] others, @NonNull Function<? super Object[], @NonNull R> combiner) Combines the value emission from the currentFlowable
with the latest emissions from the otherPublisher
s via a function to produce the output item.Flowable.withLatestFrom
(@NonNull org.reactivestreams.Publisher<@NonNull T1> source1, @NonNull org.reactivestreams.Publisher<@NonNull T2> source2, @NonNull Function3<? super @NonNull T, ? super @NonNull T1, ? super @NonNull T2, @NonNull R> combiner) Combines the value emission from the currentFlowable
with the latest emissions from the otherPublisher
s via a function to produce the output item.Flowable.withLatestFrom
(@NonNull org.reactivestreams.Publisher<@NonNull T1> source1, @NonNull org.reactivestreams.Publisher<@NonNull T2> source2, @NonNull Function3<? super @NonNull T, ? super @NonNull T1, ? super @NonNull T2, @NonNull R> combiner) Combines the value emission from the currentFlowable
with the latest emissions from the otherPublisher
s via a function to produce the output item.Flowable.withLatestFrom
(@NonNull org.reactivestreams.Publisher<@NonNull T1> source1, @NonNull org.reactivestreams.Publisher<@NonNull T2> source2, @NonNull Function3<? super @NonNull T, ? super @NonNull T1, ? super @NonNull T2, @NonNull R> combiner) Combines the value emission from the currentFlowable
with the latest emissions from the otherPublisher
s via a function to produce the output item.Flowable.withLatestFrom
(@NonNull org.reactivestreams.Publisher<@NonNull T1> source1, @NonNull org.reactivestreams.Publisher<@NonNull T2> source2, @NonNull org.reactivestreams.Publisher<@NonNull T3> source3, @NonNull Function4<? super @NonNull T, ? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, @NonNull R> combiner) Combines the value emission from the currentFlowable
with the latest emissions from the otherPublisher
s via a function to produce the output item.Flowable.withLatestFrom
(@NonNull org.reactivestreams.Publisher<@NonNull T1> source1, @NonNull org.reactivestreams.Publisher<@NonNull T2> source2, @NonNull org.reactivestreams.Publisher<@NonNull T3> source3, @NonNull Function4<? super @NonNull T, ? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, @NonNull R> combiner) Combines the value emission from the currentFlowable
with the latest emissions from the otherPublisher
s via a function to produce the output item.Flowable.withLatestFrom
(@NonNull org.reactivestreams.Publisher<@NonNull T1> source1, @NonNull org.reactivestreams.Publisher<@NonNull T2> source2, @NonNull org.reactivestreams.Publisher<@NonNull T3> source3, @NonNull Function4<? super @NonNull T, ? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, @NonNull R> combiner) Combines the value emission from the currentFlowable
with the latest emissions from the otherPublisher
s via a function to produce the output item.Flowable.withLatestFrom
(@NonNull org.reactivestreams.Publisher<@NonNull T1> source1, @NonNull org.reactivestreams.Publisher<@NonNull T2> source2, @NonNull org.reactivestreams.Publisher<@NonNull T3> source3, @NonNull Function4<? super @NonNull T, ? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, @NonNull R> combiner) Combines the value emission from the currentFlowable
with the latest emissions from the otherPublisher
s via a function to produce the output item.Flowable.withLatestFrom
(@NonNull org.reactivestreams.Publisher<@NonNull T1> source1, @NonNull org.reactivestreams.Publisher<@NonNull T2> source2, @NonNull org.reactivestreams.Publisher<@NonNull T3> source3, @NonNull org.reactivestreams.Publisher<@NonNull T4> source4, @NonNull Function5<? super @NonNull T, ? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, ? super @NonNull T4, @NonNull R> combiner) Combines the value emission from the currentFlowable
with the latest emissions from the otherPublisher
s via a function to produce the output item.Flowable.withLatestFrom
(@NonNull org.reactivestreams.Publisher<@NonNull T1> source1, @NonNull org.reactivestreams.Publisher<@NonNull T2> source2, @NonNull org.reactivestreams.Publisher<@NonNull T3> source3, @NonNull org.reactivestreams.Publisher<@NonNull T4> source4, @NonNull Function5<? super @NonNull T, ? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, ? super @NonNull T4, @NonNull R> combiner) Combines the value emission from the currentFlowable
with the latest emissions from the otherPublisher
s via a function to produce the output item.Flowable.withLatestFrom
(@NonNull org.reactivestreams.Publisher<@NonNull T1> source1, @NonNull org.reactivestreams.Publisher<@NonNull T2> source2, @NonNull org.reactivestreams.Publisher<@NonNull T3> source3, @NonNull org.reactivestreams.Publisher<@NonNull T4> source4, @NonNull Function5<? super @NonNull T, ? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, ? super @NonNull T4, @NonNull R> combiner) Combines the value emission from the currentFlowable
with the latest emissions from the otherPublisher
s via a function to produce the output item.Flowable.withLatestFrom
(@NonNull org.reactivestreams.Publisher<@NonNull T1> source1, @NonNull org.reactivestreams.Publisher<@NonNull T2> source2, @NonNull org.reactivestreams.Publisher<@NonNull T3> source3, @NonNull org.reactivestreams.Publisher<@NonNull T4> source4, @NonNull Function5<? super @NonNull T, ? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, ? super @NonNull T4, @NonNull R> combiner) Combines the value emission from the currentFlowable
with the latest emissions from the otherPublisher
s via a function to produce the output item.Flowable.withLatestFrom
(@NonNull org.reactivestreams.Publisher<@NonNull T1> source1, @NonNull org.reactivestreams.Publisher<@NonNull T2> source2, @NonNull org.reactivestreams.Publisher<@NonNull T3> source3, @NonNull org.reactivestreams.Publisher<@NonNull T4> source4, @NonNull Function5<? super @NonNull T, ? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, ? super @NonNull T4, @NonNull R> combiner) Combines the value emission from the currentFlowable
with the latest emissions from the otherPublisher
s via a function to produce the output item.final <@NonNull R>
@NonNull Observable<R> Observable.withLatestFrom
(@NonNull ObservableSource<?>[] others, @NonNull Function<? super Object[], @NonNull R> combiner) Combines the value emission from the currentObservable
with the latest emissions from the otherObservableSource
s via a function to produce the output item.final <@NonNull R>
@NonNull Observable<R> Observable.withLatestFrom
(@NonNull ObservableSource<?>[] others, @NonNull Function<? super Object[], @NonNull R> combiner) Combines the value emission from the currentObservable
with the latest emissions from the otherObservableSource
s via a function to produce the output item.final <@NonNull U,
@NonNull R>
@NonNull Observable<R> Observable.withLatestFrom
(@NonNull ObservableSource<? extends @NonNull U> other, @NonNull BiFunction<? super @NonNull T, ? super @NonNull U, ? extends @NonNull R> combiner) Merges the specifiedObservableSource
into the currentObservable
sequence by using theresultSelector
function only when the currentObservable
emits an item.final <@NonNull U,
@NonNull R>
@NonNull Observable<R> Observable.withLatestFrom
(@NonNull ObservableSource<? extends @NonNull U> other, @NonNull BiFunction<? super @NonNull T, ? super @NonNull U, ? extends @NonNull R> combiner) Merges the specifiedObservableSource
into the currentObservable
sequence by using theresultSelector
function only when the currentObservable
emits an item.Observable.withLatestFrom
(@NonNull ObservableSource<@NonNull T1> source1, @NonNull ObservableSource<@NonNull T2> source2, @NonNull ObservableSource<@NonNull T3> source3, @NonNull ObservableSource<@NonNull T4> source4, @NonNull Function5<? super @NonNull T, ? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, ? super @NonNull T4, @NonNull R> combiner) Combines the value emission from the currentObservable
with the latest emissions from the otherObservableSource
s via a function to produce the output item.Observable.withLatestFrom
(@NonNull ObservableSource<@NonNull T1> source1, @NonNull ObservableSource<@NonNull T2> source2, @NonNull ObservableSource<@NonNull T3> source3, @NonNull ObservableSource<@NonNull T4> source4, @NonNull Function5<? super @NonNull T, ? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, ? super @NonNull T4, @NonNull R> combiner) Combines the value emission from the currentObservable
with the latest emissions from the otherObservableSource
s via a function to produce the output item.Observable.withLatestFrom
(@NonNull ObservableSource<@NonNull T1> source1, @NonNull ObservableSource<@NonNull T2> source2, @NonNull ObservableSource<@NonNull T3> source3, @NonNull ObservableSource<@NonNull T4> source4, @NonNull Function5<? super @NonNull T, ? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, ? super @NonNull T4, @NonNull R> combiner) Combines the value emission from the currentObservable
with the latest emissions from the otherObservableSource
s via a function to produce the output item.Observable.withLatestFrom
(@NonNull ObservableSource<@NonNull T1> source1, @NonNull ObservableSource<@NonNull T2> source2, @NonNull ObservableSource<@NonNull T3> source3, @NonNull ObservableSource<@NonNull T4> source4, @NonNull Function5<? super @NonNull T, ? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, ? super @NonNull T4, @NonNull R> combiner) Combines the value emission from the currentObservable
with the latest emissions from the otherObservableSource
s via a function to produce the output item.Observable.withLatestFrom
(@NonNull ObservableSource<@NonNull T1> source1, @NonNull ObservableSource<@NonNull T2> source2, @NonNull ObservableSource<@NonNull T3> source3, @NonNull ObservableSource<@NonNull T4> source4, @NonNull Function5<? super @NonNull T, ? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, ? super @NonNull T4, @NonNull R> combiner) Combines the value emission from the currentObservable
with the latest emissions from the otherObservableSource
s via a function to produce the output item.Observable.withLatestFrom
(@NonNull ObservableSource<@NonNull T1> source1, @NonNull ObservableSource<@NonNull T2> source2, @NonNull ObservableSource<@NonNull T3> source3, @NonNull Function4<? super @NonNull T, ? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, @NonNull R> combiner) Combines the value emission from the currentObservable
with the latest emissions from the otherObservableSource
s via a function to produce the output item.Observable.withLatestFrom
(@NonNull ObservableSource<@NonNull T1> source1, @NonNull ObservableSource<@NonNull T2> source2, @NonNull ObservableSource<@NonNull T3> source3, @NonNull Function4<? super @NonNull T, ? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, @NonNull R> combiner) Combines the value emission from the currentObservable
with the latest emissions from the otherObservableSource
s via a function to produce the output item.Observable.withLatestFrom
(@NonNull ObservableSource<@NonNull T1> source1, @NonNull ObservableSource<@NonNull T2> source2, @NonNull ObservableSource<@NonNull T3> source3, @NonNull Function4<? super @NonNull T, ? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, @NonNull R> combiner) Combines the value emission from the currentObservable
with the latest emissions from the otherObservableSource
s via a function to produce the output item.Observable.withLatestFrom
(@NonNull ObservableSource<@NonNull T1> source1, @NonNull ObservableSource<@NonNull T2> source2, @NonNull ObservableSource<@NonNull T3> source3, @NonNull Function4<? super @NonNull T, ? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, @NonNull R> combiner) Combines the value emission from the currentObservable
with the latest emissions from the otherObservableSource
s via a function to produce the output item.final <@NonNull T1,
@NonNull T2, @NonNull R>
@NonNull Observable<R> Observable.withLatestFrom
(@NonNull ObservableSource<@NonNull T1> source1, @NonNull ObservableSource<@NonNull T2> source2, @NonNull Function3<? super @NonNull T, ? super @NonNull T1, ? super @NonNull T2, @NonNull R> combiner) Combines the value emission from the currentObservable
with the latest emissions from the otherObservableSource
s via a function to produce the output item.final <@NonNull T1,
@NonNull T2, @NonNull R>
@NonNull Observable<R> Observable.withLatestFrom
(@NonNull ObservableSource<@NonNull T1> source1, @NonNull ObservableSource<@NonNull T2> source2, @NonNull Function3<? super @NonNull T, ? super @NonNull T1, ? super @NonNull T2, @NonNull R> combiner) Combines the value emission from the currentObservable
with the latest emissions from the otherObservableSource
s via a function to produce the output item.final <@NonNull T1,
@NonNull T2, @NonNull R>
@NonNull Observable<R> Observable.withLatestFrom
(@NonNull ObservableSource<@NonNull T1> source1, @NonNull ObservableSource<@NonNull T2> source2, @NonNull Function3<? super @NonNull T, ? super @NonNull T1, ? super @NonNull T2, @NonNull R> combiner) Combines the value emission from the currentObservable
with the latest emissions from the otherObservableSource
s via a function to produce the output item.final <@NonNull R>
@NonNull Observable<R> Observable.withLatestFrom
(@NonNull Iterable<@NonNull ? extends ObservableSource<?>> others, @NonNull Function<? super Object[], @NonNull R> combiner) Combines the value emission from the currentObservable
with the latest emissions from the otherObservableSource
s via a function to produce the output item.final <@NonNull R>
@NonNull Observable<R> Observable.withLatestFrom
(@NonNull Iterable<@NonNull ? extends ObservableSource<?>> others, @NonNull Function<? super Object[], @NonNull R> combiner) Combines the value emission from the currentObservable
with the latest emissions from the otherObservableSource
s via a function to produce the output item.static @NonNull Completable
Completable.wrap
(@NonNull CompletableSource source) Maybe.wrap
(@NonNull MaybeSource<@NonNull T> source) static <@NonNull T>
@NonNull Observable<T> Observable.wrap
(@NonNull ObservableSource<@NonNull T> source) Single.wrap
(@NonNull SingleSource<@NonNull T> source) Flowable.zip
(@NonNull Iterable<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources, @NonNull Function<? super Object[], ? extends @NonNull R> zipper) Returns aFlowable
that emits the results of a specified combiner function applied to combinations of items emitted, in sequence, by anIterable
of otherPublisher
s.Flowable.zip
(@NonNull Iterable<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources, @NonNull Function<? super Object[], ? extends @NonNull R> zipper) Returns aFlowable
that emits the results of a specified combiner function applied to combinations of items emitted, in sequence, by anIterable
of otherPublisher
s.Flowable.zip
(@NonNull Iterable<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources, @NonNull Function<? super Object[], ? extends @NonNull R> zipper, boolean delayError, int bufferSize) Returns aFlowable
that emits the results of a specified combiner function applied to combinations of items emitted, in sequence, by anIterable
of otherPublisher
s.Flowable.zip
(@NonNull Iterable<@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull T>> sources, @NonNull Function<? super Object[], ? extends @NonNull R> zipper, boolean delayError, int bufferSize) Returns aFlowable
that emits the results of a specified combiner function applied to combinations of items emitted, in sequence, by anIterable
of otherPublisher
s.Flowable.zip
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull BiFunction<? super @NonNull T1, ? super @NonNull T2, ? extends @NonNull R> zipper) Returns aFlowable
that emits the results of a specified combiner function applied to combinations of two items emitted, in sequence, by two otherPublisher
s.Flowable.zip
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull BiFunction<? super @NonNull T1, ? super @NonNull T2, ? extends @NonNull R> zipper) Returns aFlowable
that emits the results of a specified combiner function applied to combinations of two items emitted, in sequence, by two otherPublisher
s.Flowable.zip
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull BiFunction<? super @NonNull T1, ? super @NonNull T2, ? extends @NonNull R> zipper) Returns aFlowable
that emits the results of a specified combiner function applied to combinations of two items emitted, in sequence, by two otherPublisher
s.Flowable.zip
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull BiFunction<? super @NonNull T1, ? super @NonNull T2, ? extends @NonNull R> zipper, boolean delayError) Returns aFlowable
that emits the results of a specified combiner function applied to combinations of two items emitted, in sequence, by two otherPublisher
s.Flowable.zip
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull BiFunction<? super @NonNull T1, ? super @NonNull T2, ? extends @NonNull R> zipper, boolean delayError) Returns aFlowable
that emits the results of a specified combiner function applied to combinations of two items emitted, in sequence, by two otherPublisher
s.Flowable.zip
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull BiFunction<? super @NonNull T1, ? super @NonNull T2, ? extends @NonNull R> zipper, boolean delayError) Returns aFlowable
that emits the results of a specified combiner function applied to combinations of two items emitted, in sequence, by two otherPublisher
s.Flowable.zip
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull BiFunction<? super @NonNull T1, ? super @NonNull T2, ? extends @NonNull R> zipper, boolean delayError, int bufferSize) Returns aFlowable
that emits the results of a specified combiner function applied to combinations of two items emitted, in sequence, by two otherPublisher
s.Flowable.zip
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull BiFunction<? super @NonNull T1, ? super @NonNull T2, ? extends @NonNull R> zipper, boolean delayError, int bufferSize) Returns aFlowable
that emits the results of a specified combiner function applied to combinations of two items emitted, in sequence, by two otherPublisher
s.Flowable.zip
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull BiFunction<? super @NonNull T1, ? super @NonNull T2, ? extends @NonNull R> zipper, boolean delayError, int bufferSize) Returns aFlowable
that emits the results of a specified combiner function applied to combinations of two items emitted, in sequence, by two otherPublisher
s.Flowable.zip
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull Function3<? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, ? extends @NonNull R> zipper) Returns aFlowable
that emits the results of a specified combiner function applied to combinations of three items emitted, in sequence, by three otherPublisher
s.Flowable.zip
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull Function3<? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, ? extends @NonNull R> zipper) Returns aFlowable
that emits the results of a specified combiner function applied to combinations of three items emitted, in sequence, by three otherPublisher
s.Flowable.zip
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull Function3<? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, ? extends @NonNull R> zipper) Returns aFlowable
that emits the results of a specified combiner function applied to combinations of three items emitted, in sequence, by three otherPublisher
s.Flowable.zip
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull Function3<? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, ? extends @NonNull R> zipper) Returns aFlowable
that emits the results of a specified combiner function applied to combinations of three items emitted, in sequence, by three otherPublisher
s.Flowable.zip
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull Function4<? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, ? super @NonNull T4, ? extends @NonNull R> zipper) Returns aFlowable
that emits the results of a specified combiner function applied to combinations of four items emitted, in sequence, by four otherPublisher
s.Flowable.zip
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull Function4<? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, ? super @NonNull T4, ? extends @NonNull R> zipper) Returns aFlowable
that emits the results of a specified combiner function applied to combinations of four items emitted, in sequence, by four otherPublisher
s.Flowable.zip
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull Function4<? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, ? super @NonNull T4, ? extends @NonNull R> zipper) Returns aFlowable
that emits the results of a specified combiner function applied to combinations of four items emitted, in sequence, by four otherPublisher
s.Flowable.zip
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull Function4<? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, ? super @NonNull T4, ? extends @NonNull R> zipper) Returns aFlowable
that emits the results of a specified combiner function applied to combinations of four items emitted, in sequence, by four otherPublisher
s.Flowable.zip
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull Function4<? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, ? super @NonNull T4, ? extends @NonNull R> zipper) Returns aFlowable
that emits the results of a specified combiner function applied to combinations of four items emitted, in sequence, by four otherPublisher
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull R>
@NonNull Flowable<R> Flowable.zip
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull org.reactivestreams.Publisher<? 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 aFlowable
that emits the results of a specified combiner function applied to combinations of five items emitted, in sequence, by five otherPublisher
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull R>
@NonNull Flowable<R> Flowable.zip
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull org.reactivestreams.Publisher<? 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 aFlowable
that emits the results of a specified combiner function applied to combinations of five items emitted, in sequence, by five otherPublisher
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull R>
@NonNull Flowable<R> Flowable.zip
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull org.reactivestreams.Publisher<? 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 aFlowable
that emits the results of a specified combiner function applied to combinations of five items emitted, in sequence, by five otherPublisher
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull R>
@NonNull Flowable<R> Flowable.zip
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull org.reactivestreams.Publisher<? 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 aFlowable
that emits the results of a specified combiner function applied to combinations of five items emitted, in sequence, by five otherPublisher
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull R>
@NonNull Flowable<R> Flowable.zip
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull org.reactivestreams.Publisher<? 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 aFlowable
that emits the results of a specified combiner function applied to combinations of five items emitted, in sequence, by five otherPublisher
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull R>
@NonNull Flowable<R> Flowable.zip
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull org.reactivestreams.Publisher<? 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 aFlowable
that emits the results of a specified combiner function applied to combinations of five items emitted, in sequence, by five otherPublisher
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull R>
@NonNull Flowable<R> Flowable.zip
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull org.reactivestreams.Publisher<? extends @NonNull T5> source5, @NonNull org.reactivestreams.Publisher<? 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 aFlowable
that emits the results of a specified combiner function applied to combinations of six items emitted, in sequence, by six otherPublisher
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull R>
@NonNull Flowable<R> Flowable.zip
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull org.reactivestreams.Publisher<? extends @NonNull T5> source5, @NonNull org.reactivestreams.Publisher<? 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 aFlowable
that emits the results of a specified combiner function applied to combinations of six items emitted, in sequence, by six otherPublisher
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull R>
@NonNull Flowable<R> Flowable.zip
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull org.reactivestreams.Publisher<? extends @NonNull T5> source5, @NonNull org.reactivestreams.Publisher<? 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 aFlowable
that emits the results of a specified combiner function applied to combinations of six items emitted, in sequence, by six otherPublisher
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull R>
@NonNull Flowable<R> Flowable.zip
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull org.reactivestreams.Publisher<? extends @NonNull T5> source5, @NonNull org.reactivestreams.Publisher<? 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 aFlowable
that emits the results of a specified combiner function applied to combinations of six items emitted, in sequence, by six otherPublisher
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull R>
@NonNull Flowable<R> Flowable.zip
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull org.reactivestreams.Publisher<? extends @NonNull T5> source5, @NonNull org.reactivestreams.Publisher<? 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 aFlowable
that emits the results of a specified combiner function applied to combinations of six items emitted, in sequence, by six otherPublisher
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull R>
@NonNull Flowable<R> Flowable.zip
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull org.reactivestreams.Publisher<? extends @NonNull T5> source5, @NonNull org.reactivestreams.Publisher<? 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 aFlowable
that emits the results of a specified combiner function applied to combinations of six items emitted, in sequence, by six otherPublisher
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull R>
@NonNull Flowable<R> Flowable.zip
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull org.reactivestreams.Publisher<? extends @NonNull T5> source5, @NonNull org.reactivestreams.Publisher<? 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 aFlowable
that emits the results of a specified combiner function applied to combinations of six items emitted, in sequence, by six otherPublisher
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull R>
@NonNull Flowable<R> Flowable.zip
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull org.reactivestreams.Publisher<? extends @NonNull T5> source5, @NonNull org.reactivestreams.Publisher<? extends @NonNull T6> source6, @NonNull org.reactivestreams.Publisher<? 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 aFlowable
that emits the results of a specified combiner function applied to combinations of seven items emitted, in sequence, by seven otherPublisher
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull R>
@NonNull Flowable<R> Flowable.zip
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull org.reactivestreams.Publisher<? extends @NonNull T5> source5, @NonNull org.reactivestreams.Publisher<? extends @NonNull T6> source6, @NonNull org.reactivestreams.Publisher<? 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 aFlowable
that emits the results of a specified combiner function applied to combinations of seven items emitted, in sequence, by seven otherPublisher
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull R>
@NonNull Flowable<R> Flowable.zip
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull org.reactivestreams.Publisher<? extends @NonNull T5> source5, @NonNull org.reactivestreams.Publisher<? extends @NonNull T6> source6, @NonNull org.reactivestreams.Publisher<? 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 aFlowable
that emits the results of a specified combiner function applied to combinations of seven items emitted, in sequence, by seven otherPublisher
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull R>
@NonNull Flowable<R> Flowable.zip
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull org.reactivestreams.Publisher<? extends @NonNull T5> source5, @NonNull org.reactivestreams.Publisher<? extends @NonNull T6> source6, @NonNull org.reactivestreams.Publisher<? 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 aFlowable
that emits the results of a specified combiner function applied to combinations of seven items emitted, in sequence, by seven otherPublisher
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull R>
@NonNull Flowable<R> Flowable.zip
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull org.reactivestreams.Publisher<? extends @NonNull T5> source5, @NonNull org.reactivestreams.Publisher<? extends @NonNull T6> source6, @NonNull org.reactivestreams.Publisher<? 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 aFlowable
that emits the results of a specified combiner function applied to combinations of seven items emitted, in sequence, by seven otherPublisher
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull R>
@NonNull Flowable<R> Flowable.zip
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull org.reactivestreams.Publisher<? extends @NonNull T5> source5, @NonNull org.reactivestreams.Publisher<? extends @NonNull T6> source6, @NonNull org.reactivestreams.Publisher<? 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 aFlowable
that emits the results of a specified combiner function applied to combinations of seven items emitted, in sequence, by seven otherPublisher
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull R>
@NonNull Flowable<R> Flowable.zip
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull org.reactivestreams.Publisher<? extends @NonNull T5> source5, @NonNull org.reactivestreams.Publisher<? extends @NonNull T6> source6, @NonNull org.reactivestreams.Publisher<? 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 aFlowable
that emits the results of a specified combiner function applied to combinations of seven items emitted, in sequence, by seven otherPublisher
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull R>
@NonNull Flowable<R> Flowable.zip
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull org.reactivestreams.Publisher<? extends @NonNull T5> source5, @NonNull org.reactivestreams.Publisher<? extends @NonNull T6> source6, @NonNull org.reactivestreams.Publisher<? 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 aFlowable
that emits the results of a specified combiner function applied to combinations of seven items emitted, in sequence, by seven otherPublisher
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull R>
@NonNull Flowable<R> Flowable.zip
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull org.reactivestreams.Publisher<? extends @NonNull T5> source5, @NonNull org.reactivestreams.Publisher<? extends @NonNull T6> source6, @NonNull org.reactivestreams.Publisher<? extends @NonNull T7> source7, @NonNull org.reactivestreams.Publisher<? 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 aFlowable
that emits the results of a specified combiner function applied to combinations of eight items emitted, in sequence, by eight otherPublisher
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull R>
@NonNull Flowable<R> Flowable.zip
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull org.reactivestreams.Publisher<? extends @NonNull T5> source5, @NonNull org.reactivestreams.Publisher<? extends @NonNull T6> source6, @NonNull org.reactivestreams.Publisher<? extends @NonNull T7> source7, @NonNull org.reactivestreams.Publisher<? 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 aFlowable
that emits the results of a specified combiner function applied to combinations of eight items emitted, in sequence, by eight otherPublisher
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull R>
@NonNull Flowable<R> Flowable.zip
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull org.reactivestreams.Publisher<? extends @NonNull T5> source5, @NonNull org.reactivestreams.Publisher<? extends @NonNull T6> source6, @NonNull org.reactivestreams.Publisher<? extends @NonNull T7> source7, @NonNull org.reactivestreams.Publisher<? 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 aFlowable
that emits the results of a specified combiner function applied to combinations of eight items emitted, in sequence, by eight otherPublisher
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull R>
@NonNull Flowable<R> Flowable.zip
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull org.reactivestreams.Publisher<? extends @NonNull T5> source5, @NonNull org.reactivestreams.Publisher<? extends @NonNull T6> source6, @NonNull org.reactivestreams.Publisher<? extends @NonNull T7> source7, @NonNull org.reactivestreams.Publisher<? 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 aFlowable
that emits the results of a specified combiner function applied to combinations of eight items emitted, in sequence, by eight otherPublisher
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull R>
@NonNull Flowable<R> Flowable.zip
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull org.reactivestreams.Publisher<? extends @NonNull T5> source5, @NonNull org.reactivestreams.Publisher<? extends @NonNull T6> source6, @NonNull org.reactivestreams.Publisher<? extends @NonNull T7> source7, @NonNull org.reactivestreams.Publisher<? 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 aFlowable
that emits the results of a specified combiner function applied to combinations of eight items emitted, in sequence, by eight otherPublisher
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull R>
@NonNull Flowable<R> Flowable.zip
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull org.reactivestreams.Publisher<? extends @NonNull T5> source5, @NonNull org.reactivestreams.Publisher<? extends @NonNull T6> source6, @NonNull org.reactivestreams.Publisher<? extends @NonNull T7> source7, @NonNull org.reactivestreams.Publisher<? 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 aFlowable
that emits the results of a specified combiner function applied to combinations of eight items emitted, in sequence, by eight otherPublisher
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull R>
@NonNull Flowable<R> Flowable.zip
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull org.reactivestreams.Publisher<? extends @NonNull T5> source5, @NonNull org.reactivestreams.Publisher<? extends @NonNull T6> source6, @NonNull org.reactivestreams.Publisher<? extends @NonNull T7> source7, @NonNull org.reactivestreams.Publisher<? 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 aFlowable
that emits the results of a specified combiner function applied to combinations of eight items emitted, in sequence, by eight otherPublisher
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull R>
@NonNull Flowable<R> Flowable.zip
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull org.reactivestreams.Publisher<? extends @NonNull T5> source5, @NonNull org.reactivestreams.Publisher<? extends @NonNull T6> source6, @NonNull org.reactivestreams.Publisher<? extends @NonNull T7> source7, @NonNull org.reactivestreams.Publisher<? 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 aFlowable
that emits the results of a specified combiner function applied to combinations of eight items emitted, in sequence, by eight otherPublisher
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull R>
@NonNull Flowable<R> Flowable.zip
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull org.reactivestreams.Publisher<? extends @NonNull T5> source5, @NonNull org.reactivestreams.Publisher<? extends @NonNull T6> source6, @NonNull org.reactivestreams.Publisher<? extends @NonNull T7> source7, @NonNull org.reactivestreams.Publisher<? 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 aFlowable
that emits the results of a specified combiner function applied to combinations of eight items emitted, in sequence, by eight otherPublisher
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull T9, @NonNull R>
@NonNull Flowable<R> Flowable.zip
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull org.reactivestreams.Publisher<? extends @NonNull T5> source5, @NonNull org.reactivestreams.Publisher<? extends @NonNull T6> source6, @NonNull org.reactivestreams.Publisher<? extends @NonNull T7> source7, @NonNull org.reactivestreams.Publisher<? extends @NonNull T8> source8, @NonNull org.reactivestreams.Publisher<? 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 aFlowable
that emits the results of a specified combiner function applied to combinations of nine items emitted, in sequence, by nine otherPublisher
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull T9, @NonNull R>
@NonNull Flowable<R> Flowable.zip
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull org.reactivestreams.Publisher<? extends @NonNull T5> source5, @NonNull org.reactivestreams.Publisher<? extends @NonNull T6> source6, @NonNull org.reactivestreams.Publisher<? extends @NonNull T7> source7, @NonNull org.reactivestreams.Publisher<? extends @NonNull T8> source8, @NonNull org.reactivestreams.Publisher<? 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 aFlowable
that emits the results of a specified combiner function applied to combinations of nine items emitted, in sequence, by nine otherPublisher
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull T9, @NonNull R>
@NonNull Flowable<R> Flowable.zip
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull org.reactivestreams.Publisher<? extends @NonNull T5> source5, @NonNull org.reactivestreams.Publisher<? extends @NonNull T6> source6, @NonNull org.reactivestreams.Publisher<? extends @NonNull T7> source7, @NonNull org.reactivestreams.Publisher<? extends @NonNull T8> source8, @NonNull org.reactivestreams.Publisher<? 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 aFlowable
that emits the results of a specified combiner function applied to combinations of nine items emitted, in sequence, by nine otherPublisher
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull T9, @NonNull R>
@NonNull Flowable<R> Flowable.zip
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull org.reactivestreams.Publisher<? extends @NonNull T5> source5, @NonNull org.reactivestreams.Publisher<? extends @NonNull T6> source6, @NonNull org.reactivestreams.Publisher<? extends @NonNull T7> source7, @NonNull org.reactivestreams.Publisher<? extends @NonNull T8> source8, @NonNull org.reactivestreams.Publisher<? 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 aFlowable
that emits the results of a specified combiner function applied to combinations of nine items emitted, in sequence, by nine otherPublisher
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull T9, @NonNull R>
@NonNull Flowable<R> Flowable.zip
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull org.reactivestreams.Publisher<? extends @NonNull T5> source5, @NonNull org.reactivestreams.Publisher<? extends @NonNull T6> source6, @NonNull org.reactivestreams.Publisher<? extends @NonNull T7> source7, @NonNull org.reactivestreams.Publisher<? extends @NonNull T8> source8, @NonNull org.reactivestreams.Publisher<? 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 aFlowable
that emits the results of a specified combiner function applied to combinations of nine items emitted, in sequence, by nine otherPublisher
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull T9, @NonNull R>
@NonNull Flowable<R> Flowable.zip
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull org.reactivestreams.Publisher<? extends @NonNull T5> source5, @NonNull org.reactivestreams.Publisher<? extends @NonNull T6> source6, @NonNull org.reactivestreams.Publisher<? extends @NonNull T7> source7, @NonNull org.reactivestreams.Publisher<? extends @NonNull T8> source8, @NonNull org.reactivestreams.Publisher<? 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 aFlowable
that emits the results of a specified combiner function applied to combinations of nine items emitted, in sequence, by nine otherPublisher
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull T9, @NonNull R>
@NonNull Flowable<R> Flowable.zip
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull org.reactivestreams.Publisher<? extends @NonNull T5> source5, @NonNull org.reactivestreams.Publisher<? extends @NonNull T6> source6, @NonNull org.reactivestreams.Publisher<? extends @NonNull T7> source7, @NonNull org.reactivestreams.Publisher<? extends @NonNull T8> source8, @NonNull org.reactivestreams.Publisher<? 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 aFlowable
that emits the results of a specified combiner function applied to combinations of nine items emitted, in sequence, by nine otherPublisher
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull T9, @NonNull R>
@NonNull Flowable<R> Flowable.zip
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull org.reactivestreams.Publisher<? extends @NonNull T5> source5, @NonNull org.reactivestreams.Publisher<? extends @NonNull T6> source6, @NonNull org.reactivestreams.Publisher<? extends @NonNull T7> source7, @NonNull org.reactivestreams.Publisher<? extends @NonNull T8> source8, @NonNull org.reactivestreams.Publisher<? 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 aFlowable
that emits the results of a specified combiner function applied to combinations of nine items emitted, in sequence, by nine otherPublisher
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull T9, @NonNull R>
@NonNull Flowable<R> Flowable.zip
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull org.reactivestreams.Publisher<? extends @NonNull T5> source5, @NonNull org.reactivestreams.Publisher<? extends @NonNull T6> source6, @NonNull org.reactivestreams.Publisher<? extends @NonNull T7> source7, @NonNull org.reactivestreams.Publisher<? extends @NonNull T8> source8, @NonNull org.reactivestreams.Publisher<? 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 aFlowable
that emits the results of a specified combiner function applied to combinations of nine items emitted, in sequence, by nine otherPublisher
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull T9, @NonNull R>
@NonNull Flowable<R> Flowable.zip
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T1> source1, @NonNull org.reactivestreams.Publisher<? extends @NonNull T2> source2, @NonNull org.reactivestreams.Publisher<? extends @NonNull T3> source3, @NonNull org.reactivestreams.Publisher<? extends @NonNull T4> source4, @NonNull org.reactivestreams.Publisher<? extends @NonNull T5> source5, @NonNull org.reactivestreams.Publisher<? extends @NonNull T6> source6, @NonNull org.reactivestreams.Publisher<? extends @NonNull T7> source7, @NonNull org.reactivestreams.Publisher<? extends @NonNull T8> source8, @NonNull org.reactivestreams.Publisher<? 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 aFlowable
that emits the results of a specified combiner function applied to combinations of nine items emitted, in sequence, by nine otherPublisher
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull T9, @NonNull R>
@NonNull Maybe<R> Maybe.zip
(@NonNull MaybeSource<? extends @NonNull T1> source1, @NonNull MaybeSource<? extends @NonNull T2> source2, @NonNull MaybeSource<? extends @NonNull T3> source3, @NonNull MaybeSource<? extends @NonNull T4> source4, @NonNull MaybeSource<? extends @NonNull T5> source5, @NonNull MaybeSource<? extends @NonNull T6> source6, @NonNull MaybeSource<? extends @NonNull T7> source7, @NonNull MaybeSource<? extends @NonNull T8> source8, @NonNull MaybeSource<? 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 aMaybe
that emits the results of a specified combiner function applied to combinations of nine items emitted, in sequence, by nine otherMaybeSource
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull T9, @NonNull R>
@NonNull Maybe<R> Maybe.zip
(@NonNull MaybeSource<? extends @NonNull T1> source1, @NonNull MaybeSource<? extends @NonNull T2> source2, @NonNull MaybeSource<? extends @NonNull T3> source3, @NonNull MaybeSource<? extends @NonNull T4> source4, @NonNull MaybeSource<? extends @NonNull T5> source5, @NonNull MaybeSource<? extends @NonNull T6> source6, @NonNull MaybeSource<? extends @NonNull T7> source7, @NonNull MaybeSource<? extends @NonNull T8> source8, @NonNull MaybeSource<? 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 aMaybe
that emits the results of a specified combiner function applied to combinations of nine items emitted, in sequence, by nine otherMaybeSource
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull T9, @NonNull R>
@NonNull Maybe<R> Maybe.zip
(@NonNull MaybeSource<? extends @NonNull T1> source1, @NonNull MaybeSource<? extends @NonNull T2> source2, @NonNull MaybeSource<? extends @NonNull T3> source3, @NonNull MaybeSource<? extends @NonNull T4> source4, @NonNull MaybeSource<? extends @NonNull T5> source5, @NonNull MaybeSource<? extends @NonNull T6> source6, @NonNull MaybeSource<? extends @NonNull T7> source7, @NonNull MaybeSource<? extends @NonNull T8> source8, @NonNull MaybeSource<? 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 aMaybe
that emits the results of a specified combiner function applied to combinations of nine items emitted, in sequence, by nine otherMaybeSource
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull T9, @NonNull R>
@NonNull Maybe<R> Maybe.zip
(@NonNull MaybeSource<? extends @NonNull T1> source1, @NonNull MaybeSource<? extends @NonNull T2> source2, @NonNull MaybeSource<? extends @NonNull T3> source3, @NonNull MaybeSource<? extends @NonNull T4> source4, @NonNull MaybeSource<? extends @NonNull T5> source5, @NonNull MaybeSource<? extends @NonNull T6> source6, @NonNull MaybeSource<? extends @NonNull T7> source7, @NonNull MaybeSource<? extends @NonNull T8> source8, @NonNull MaybeSource<? 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 aMaybe
that emits the results of a specified combiner function applied to combinations of nine items emitted, in sequence, by nine otherMaybeSource
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull T9, @NonNull R>
@NonNull Maybe<R> Maybe.zip
(@NonNull MaybeSource<? extends @NonNull T1> source1, @NonNull MaybeSource<? extends @NonNull T2> source2, @NonNull MaybeSource<? extends @NonNull T3> source3, @NonNull MaybeSource<? extends @NonNull T4> source4, @NonNull MaybeSource<? extends @NonNull T5> source5, @NonNull MaybeSource<? extends @NonNull T6> source6, @NonNull MaybeSource<? extends @NonNull T7> source7, @NonNull MaybeSource<? extends @NonNull T8> source8, @NonNull MaybeSource<? 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 aMaybe
that emits the results of a specified combiner function applied to combinations of nine items emitted, in sequence, by nine otherMaybeSource
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull T9, @NonNull R>
@NonNull Maybe<R> Maybe.zip
(@NonNull MaybeSource<? extends @NonNull T1> source1, @NonNull MaybeSource<? extends @NonNull T2> source2, @NonNull MaybeSource<? extends @NonNull T3> source3, @NonNull MaybeSource<? extends @NonNull T4> source4, @NonNull MaybeSource<? extends @NonNull T5> source5, @NonNull MaybeSource<? extends @NonNull T6> source6, @NonNull MaybeSource<? extends @NonNull T7> source7, @NonNull MaybeSource<? extends @NonNull T8> source8, @NonNull MaybeSource<? 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 aMaybe
that emits the results of a specified combiner function applied to combinations of nine items emitted, in sequence, by nine otherMaybeSource
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull T9, @NonNull R>
@NonNull Maybe<R> Maybe.zip
(@NonNull MaybeSource<? extends @NonNull T1> source1, @NonNull MaybeSource<? extends @NonNull T2> source2, @NonNull MaybeSource<? extends @NonNull T3> source3, @NonNull MaybeSource<? extends @NonNull T4> source4, @NonNull MaybeSource<? extends @NonNull T5> source5, @NonNull MaybeSource<? extends @NonNull T6> source6, @NonNull MaybeSource<? extends @NonNull T7> source7, @NonNull MaybeSource<? extends @NonNull T8> source8, @NonNull MaybeSource<? 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 aMaybe
that emits the results of a specified combiner function applied to combinations of nine items emitted, in sequence, by nine otherMaybeSource
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull T9, @NonNull R>
@NonNull Maybe<R> Maybe.zip
(@NonNull MaybeSource<? extends @NonNull T1> source1, @NonNull MaybeSource<? extends @NonNull T2> source2, @NonNull MaybeSource<? extends @NonNull T3> source3, @NonNull MaybeSource<? extends @NonNull T4> source4, @NonNull MaybeSource<? extends @NonNull T5> source5, @NonNull MaybeSource<? extends @NonNull T6> source6, @NonNull MaybeSource<? extends @NonNull T7> source7, @NonNull MaybeSource<? extends @NonNull T8> source8, @NonNull MaybeSource<? 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 aMaybe
that emits the results of a specified combiner function applied to combinations of nine items emitted, in sequence, by nine otherMaybeSource
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull T9, @NonNull R>
@NonNull Maybe<R> Maybe.zip
(@NonNull MaybeSource<? extends @NonNull T1> source1, @NonNull MaybeSource<? extends @NonNull T2> source2, @NonNull MaybeSource<? extends @NonNull T3> source3, @NonNull MaybeSource<? extends @NonNull T4> source4, @NonNull MaybeSource<? extends @NonNull T5> source5, @NonNull MaybeSource<? extends @NonNull T6> source6, @NonNull MaybeSource<? extends @NonNull T7> source7, @NonNull MaybeSource<? extends @NonNull T8> source8, @NonNull MaybeSource<? 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 aMaybe
that emits the results of a specified combiner function applied to combinations of nine items emitted, in sequence, by nine otherMaybeSource
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull T9, @NonNull R>
@NonNull Maybe<R> Maybe.zip
(@NonNull MaybeSource<? extends @NonNull T1> source1, @NonNull MaybeSource<? extends @NonNull T2> source2, @NonNull MaybeSource<? extends @NonNull T3> source3, @NonNull MaybeSource<? extends @NonNull T4> source4, @NonNull MaybeSource<? extends @NonNull T5> source5, @NonNull MaybeSource<? extends @NonNull T6> source6, @NonNull MaybeSource<? extends @NonNull T7> source7, @NonNull MaybeSource<? extends @NonNull T8> source8, @NonNull MaybeSource<? 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 aMaybe
that emits the results of a specified combiner function applied to combinations of nine items emitted, in sequence, by nine otherMaybeSource
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull R>
@NonNull Maybe<R> Maybe.zip
(@NonNull MaybeSource<? extends @NonNull T1> source1, @NonNull MaybeSource<? extends @NonNull T2> source2, @NonNull MaybeSource<? extends @NonNull T3> source3, @NonNull MaybeSource<? extends @NonNull T4> source4, @NonNull MaybeSource<? extends @NonNull T5> source5, @NonNull MaybeSource<? extends @NonNull T6> source6, @NonNull MaybeSource<? extends @NonNull T7> source7, @NonNull MaybeSource<? 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 aMaybe
that emits the results of a specified combiner function applied to combinations of eight items emitted, in sequence, by eight otherMaybeSource
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull R>
@NonNull Maybe<R> Maybe.zip
(@NonNull MaybeSource<? extends @NonNull T1> source1, @NonNull MaybeSource<? extends @NonNull T2> source2, @NonNull MaybeSource<? extends @NonNull T3> source3, @NonNull MaybeSource<? extends @NonNull T4> source4, @NonNull MaybeSource<? extends @NonNull T5> source5, @NonNull MaybeSource<? extends @NonNull T6> source6, @NonNull MaybeSource<? extends @NonNull T7> source7, @NonNull MaybeSource<? 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 aMaybe
that emits the results of a specified combiner function applied to combinations of eight items emitted, in sequence, by eight otherMaybeSource
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull R>
@NonNull Maybe<R> Maybe.zip
(@NonNull MaybeSource<? extends @NonNull T1> source1, @NonNull MaybeSource<? extends @NonNull T2> source2, @NonNull MaybeSource<? extends @NonNull T3> source3, @NonNull MaybeSource<? extends @NonNull T4> source4, @NonNull MaybeSource<? extends @NonNull T5> source5, @NonNull MaybeSource<? extends @NonNull T6> source6, @NonNull MaybeSource<? extends @NonNull T7> source7, @NonNull MaybeSource<? 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 aMaybe
that emits the results of a specified combiner function applied to combinations of eight items emitted, in sequence, by eight otherMaybeSource
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull R>
@NonNull Maybe<R> Maybe.zip
(@NonNull MaybeSource<? extends @NonNull T1> source1, @NonNull MaybeSource<? extends @NonNull T2> source2, @NonNull MaybeSource<? extends @NonNull T3> source3, @NonNull MaybeSource<? extends @NonNull T4> source4, @NonNull MaybeSource<? extends @NonNull T5> source5, @NonNull MaybeSource<? extends @NonNull T6> source6, @NonNull MaybeSource<? extends @NonNull T7> source7, @NonNull MaybeSource<? 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 aMaybe
that emits the results of a specified combiner function applied to combinations of eight items emitted, in sequence, by eight otherMaybeSource
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull R>
@NonNull Maybe<R> Maybe.zip
(@NonNull MaybeSource<? extends @NonNull T1> source1, @NonNull MaybeSource<? extends @NonNull T2> source2, @NonNull MaybeSource<? extends @NonNull T3> source3, @NonNull MaybeSource<? extends @NonNull T4> source4, @NonNull MaybeSource<? extends @NonNull T5> source5, @NonNull MaybeSource<? extends @NonNull T6> source6, @NonNull MaybeSource<? extends @NonNull T7> source7, @NonNull MaybeSource<? 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 aMaybe
that emits the results of a specified combiner function applied to combinations of eight items emitted, in sequence, by eight otherMaybeSource
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull R>
@NonNull Maybe<R> Maybe.zip
(@NonNull MaybeSource<? extends @NonNull T1> source1, @NonNull MaybeSource<? extends @NonNull T2> source2, @NonNull MaybeSource<? extends @NonNull T3> source3, @NonNull MaybeSource<? extends @NonNull T4> source4, @NonNull MaybeSource<? extends @NonNull T5> source5, @NonNull MaybeSource<? extends @NonNull T6> source6, @NonNull MaybeSource<? extends @NonNull T7> source7, @NonNull MaybeSource<? 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 aMaybe
that emits the results of a specified combiner function applied to combinations of eight items emitted, in sequence, by eight otherMaybeSource
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull R>
@NonNull Maybe<R> Maybe.zip
(@NonNull MaybeSource<? extends @NonNull T1> source1, @NonNull MaybeSource<? extends @NonNull T2> source2, @NonNull MaybeSource<? extends @NonNull T3> source3, @NonNull MaybeSource<? extends @NonNull T4> source4, @NonNull MaybeSource<? extends @NonNull T5> source5, @NonNull MaybeSource<? extends @NonNull T6> source6, @NonNull MaybeSource<? extends @NonNull T7> source7, @NonNull MaybeSource<? 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 aMaybe
that emits the results of a specified combiner function applied to combinations of eight items emitted, in sequence, by eight otherMaybeSource
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull R>
@NonNull Maybe<R> Maybe.zip
(@NonNull MaybeSource<? extends @NonNull T1> source1, @NonNull MaybeSource<? extends @NonNull T2> source2, @NonNull MaybeSource<? extends @NonNull T3> source3, @NonNull MaybeSource<? extends @NonNull T4> source4, @NonNull MaybeSource<? extends @NonNull T5> source5, @NonNull MaybeSource<? extends @NonNull T6> source6, @NonNull MaybeSource<? extends @NonNull T7> source7, @NonNull MaybeSource<? 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 aMaybe
that emits the results of a specified combiner function applied to combinations of eight items emitted, in sequence, by eight otherMaybeSource
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull R>
@NonNull Maybe<R> Maybe.zip
(@NonNull MaybeSource<? extends @NonNull T1> source1, @NonNull MaybeSource<? extends @NonNull T2> source2, @NonNull MaybeSource<? extends @NonNull T3> source3, @NonNull MaybeSource<? extends @NonNull T4> source4, @NonNull MaybeSource<? extends @NonNull T5> source5, @NonNull MaybeSource<? extends @NonNull T6> source6, @NonNull MaybeSource<? extends @NonNull T7> source7, @NonNull MaybeSource<? 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 aMaybe
that emits the results of a specified combiner function applied to combinations of eight items emitted, in sequence, by eight otherMaybeSource
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull R>
@NonNull Maybe<R> Maybe.zip
(@NonNull MaybeSource<? extends @NonNull T1> source1, @NonNull MaybeSource<? extends @NonNull T2> source2, @NonNull MaybeSource<? extends @NonNull T3> source3, @NonNull MaybeSource<? extends @NonNull T4> source4, @NonNull MaybeSource<? extends @NonNull T5> source5, @NonNull MaybeSource<? extends @NonNull T6> source6, @NonNull MaybeSource<? 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 aMaybe
that emits the results of a specified combiner function applied to combinations of seven items emitted, in sequence, by seven otherMaybeSource
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull R>
@NonNull Maybe<R> Maybe.zip
(@NonNull MaybeSource<? extends @NonNull T1> source1, @NonNull MaybeSource<? extends @NonNull T2> source2, @NonNull MaybeSource<? extends @NonNull T3> source3, @NonNull MaybeSource<? extends @NonNull T4> source4, @NonNull MaybeSource<? extends @NonNull T5> source5, @NonNull MaybeSource<? extends @NonNull T6> source6, @NonNull MaybeSource<? 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 aMaybe
that emits the results of a specified combiner function applied to combinations of seven items emitted, in sequence, by seven otherMaybeSource
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull R>
@NonNull Maybe<R> Maybe.zip
(@NonNull MaybeSource<? extends @NonNull T1> source1, @NonNull MaybeSource<? extends @NonNull T2> source2, @NonNull MaybeSource<? extends @NonNull T3> source3, @NonNull MaybeSource<? extends @NonNull T4> source4, @NonNull MaybeSource<? extends @NonNull T5> source5, @NonNull MaybeSource<? extends @NonNull T6> source6, @NonNull MaybeSource<? 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 aMaybe
that emits the results of a specified combiner function applied to combinations of seven items emitted, in sequence, by seven otherMaybeSource
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull R>
@NonNull Maybe<R> Maybe.zip
(@NonNull MaybeSource<? extends @NonNull T1> source1, @NonNull MaybeSource<? extends @NonNull T2> source2, @NonNull MaybeSource<? extends @NonNull T3> source3, @NonNull MaybeSource<? extends @NonNull T4> source4, @NonNull MaybeSource<? extends @NonNull T5> source5, @NonNull MaybeSource<? extends @NonNull T6> source6, @NonNull MaybeSource<? 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 aMaybe
that emits the results of a specified combiner function applied to combinations of seven items emitted, in sequence, by seven otherMaybeSource
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull R>
@NonNull Maybe<R> Maybe.zip
(@NonNull MaybeSource<? extends @NonNull T1> source1, @NonNull MaybeSource<? extends @NonNull T2> source2, @NonNull MaybeSource<? extends @NonNull T3> source3, @NonNull MaybeSource<? extends @NonNull T4> source4, @NonNull MaybeSource<? extends @NonNull T5> source5, @NonNull MaybeSource<? extends @NonNull T6> source6, @NonNull MaybeSource<? 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 aMaybe
that emits the results of a specified combiner function applied to combinations of seven items emitted, in sequence, by seven otherMaybeSource
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull R>
@NonNull Maybe<R> Maybe.zip
(@NonNull MaybeSource<? extends @NonNull T1> source1, @NonNull MaybeSource<? extends @NonNull T2> source2, @NonNull MaybeSource<? extends @NonNull T3> source3, @NonNull MaybeSource<? extends @NonNull T4> source4, @NonNull MaybeSource<? extends @NonNull T5> source5, @NonNull MaybeSource<? extends @NonNull T6> source6, @NonNull MaybeSource<? 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 aMaybe
that emits the results of a specified combiner function applied to combinations of seven items emitted, in sequence, by seven otherMaybeSource
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull R>
@NonNull Maybe<R> Maybe.zip
(@NonNull MaybeSource<? extends @NonNull T1> source1, @NonNull MaybeSource<? extends @NonNull T2> source2, @NonNull MaybeSource<? extends @NonNull T3> source3, @NonNull MaybeSource<? extends @NonNull T4> source4, @NonNull MaybeSource<? extends @NonNull T5> source5, @NonNull MaybeSource<? extends @NonNull T6> source6, @NonNull MaybeSource<? 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 aMaybe
that emits the results of a specified combiner function applied to combinations of seven items emitted, in sequence, by seven otherMaybeSource
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull R>
@NonNull Maybe<R> Maybe.zip
(@NonNull MaybeSource<? extends @NonNull T1> source1, @NonNull MaybeSource<? extends @NonNull T2> source2, @NonNull MaybeSource<? extends @NonNull T3> source3, @NonNull MaybeSource<? extends @NonNull T4> source4, @NonNull MaybeSource<? extends @NonNull T5> source5, @NonNull MaybeSource<? extends @NonNull T6> source6, @NonNull MaybeSource<? 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 aMaybe
that emits the results of a specified combiner function applied to combinations of seven items emitted, in sequence, by seven otherMaybeSource
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull R>
@NonNull Maybe<R> Maybe.zip
(@NonNull MaybeSource<? extends @NonNull T1> source1, @NonNull MaybeSource<? extends @NonNull T2> source2, @NonNull MaybeSource<? extends @NonNull T3> source3, @NonNull MaybeSource<? extends @NonNull T4> source4, @NonNull MaybeSource<? extends @NonNull T5> source5, @NonNull MaybeSource<? 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 aMaybe
that emits the results of a specified combiner function applied to combinations of six items emitted, in sequence, by six otherMaybeSource
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull R>
@NonNull Maybe<R> Maybe.zip
(@NonNull MaybeSource<? extends @NonNull T1> source1, @NonNull MaybeSource<? extends @NonNull T2> source2, @NonNull MaybeSource<? extends @NonNull T3> source3, @NonNull MaybeSource<? extends @NonNull T4> source4, @NonNull MaybeSource<? extends @NonNull T5> source5, @NonNull MaybeSource<? 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 aMaybe
that emits the results of a specified combiner function applied to combinations of six items emitted, in sequence, by six otherMaybeSource
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull R>
@NonNull Maybe<R> Maybe.zip
(@NonNull MaybeSource<? extends @NonNull T1> source1, @NonNull MaybeSource<? extends @NonNull T2> source2, @NonNull MaybeSource<? extends @NonNull T3> source3, @NonNull MaybeSource<? extends @NonNull T4> source4, @NonNull MaybeSource<? extends @NonNull T5> source5, @NonNull MaybeSource<? 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 aMaybe
that emits the results of a specified combiner function applied to combinations of six items emitted, in sequence, by six otherMaybeSource
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull R>
@NonNull Maybe<R> Maybe.zip
(@NonNull MaybeSource<? extends @NonNull T1> source1, @NonNull MaybeSource<? extends @NonNull T2> source2, @NonNull MaybeSource<? extends @NonNull T3> source3, @NonNull MaybeSource<? extends @NonNull T4> source4, @NonNull MaybeSource<? extends @NonNull T5> source5, @NonNull MaybeSource<? 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 aMaybe
that emits the results of a specified combiner function applied to combinations of six items emitted, in sequence, by six otherMaybeSource
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull R>
@NonNull Maybe<R> Maybe.zip
(@NonNull MaybeSource<? extends @NonNull T1> source1, @NonNull MaybeSource<? extends @NonNull T2> source2, @NonNull MaybeSource<? extends @NonNull T3> source3, @NonNull MaybeSource<? extends @NonNull T4> source4, @NonNull MaybeSource<? extends @NonNull T5> source5, @NonNull MaybeSource<? 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 aMaybe
that emits the results of a specified combiner function applied to combinations of six items emitted, in sequence, by six otherMaybeSource
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull R>
@NonNull Maybe<R> Maybe.zip
(@NonNull MaybeSource<? extends @NonNull T1> source1, @NonNull MaybeSource<? extends @NonNull T2> source2, @NonNull MaybeSource<? extends @NonNull T3> source3, @NonNull MaybeSource<? extends @NonNull T4> source4, @NonNull MaybeSource<? extends @NonNull T5> source5, @NonNull MaybeSource<? 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 aMaybe
that emits the results of a specified combiner function applied to combinations of six items emitted, in sequence, by six otherMaybeSource
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull R>
@NonNull Maybe<R> Maybe.zip
(@NonNull MaybeSource<? extends @NonNull T1> source1, @NonNull MaybeSource<? extends @NonNull T2> source2, @NonNull MaybeSource<? extends @NonNull T3> source3, @NonNull MaybeSource<? extends @NonNull T4> source4, @NonNull MaybeSource<? extends @NonNull T5> source5, @NonNull MaybeSource<? 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 aMaybe
that emits the results of a specified combiner function applied to combinations of six items emitted, in sequence, by six otherMaybeSource
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull R>
@NonNull Maybe<R> Maybe.zip
(@NonNull MaybeSource<? extends @NonNull T1> source1, @NonNull MaybeSource<? extends @NonNull T2> source2, @NonNull MaybeSource<? extends @NonNull T3> source3, @NonNull MaybeSource<? extends @NonNull T4> source4, @NonNull MaybeSource<? 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 aMaybe
that emits the results of a specified combiner function applied to combinations of five items emitted, in sequence, by five otherMaybeSource
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull R>
@NonNull Maybe<R> Maybe.zip
(@NonNull MaybeSource<? extends @NonNull T1> source1, @NonNull MaybeSource<? extends @NonNull T2> source2, @NonNull MaybeSource<? extends @NonNull T3> source3, @NonNull MaybeSource<? extends @NonNull T4> source4, @NonNull MaybeSource<? 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 aMaybe
that emits the results of a specified combiner function applied to combinations of five items emitted, in sequence, by five otherMaybeSource
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull R>
@NonNull Maybe<R> Maybe.zip
(@NonNull MaybeSource<? extends @NonNull T1> source1, @NonNull MaybeSource<? extends @NonNull T2> source2, @NonNull MaybeSource<? extends @NonNull T3> source3, @NonNull MaybeSource<? extends @NonNull T4> source4, @NonNull MaybeSource<? 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 aMaybe
that emits the results of a specified combiner function applied to combinations of five items emitted, in sequence, by five otherMaybeSource
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull R>
@NonNull Maybe<R> Maybe.zip
(@NonNull MaybeSource<? extends @NonNull T1> source1, @NonNull MaybeSource<? extends @NonNull T2> source2, @NonNull MaybeSource<? extends @NonNull T3> source3, @NonNull MaybeSource<? extends @NonNull T4> source4, @NonNull MaybeSource<? 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 aMaybe
that emits the results of a specified combiner function applied to combinations of five items emitted, in sequence, by five otherMaybeSource
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull R>
@NonNull Maybe<R> Maybe.zip
(@NonNull MaybeSource<? extends @NonNull T1> source1, @NonNull MaybeSource<? extends @NonNull T2> source2, @NonNull MaybeSource<? extends @NonNull T3> source3, @NonNull MaybeSource<? extends @NonNull T4> source4, @NonNull MaybeSource<? 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 aMaybe
that emits the results of a specified combiner function applied to combinations of five items emitted, in sequence, by five otherMaybeSource
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull R>
@NonNull Maybe<R> Maybe.zip
(@NonNull MaybeSource<? extends @NonNull T1> source1, @NonNull MaybeSource<? extends @NonNull T2> source2, @NonNull MaybeSource<? extends @NonNull T3> source3, @NonNull MaybeSource<? extends @NonNull T4> source4, @NonNull MaybeSource<? 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 aMaybe
that emits the results of a specified combiner function applied to combinations of five items emitted, in sequence, by five otherMaybeSource
s.Maybe.zip
(@NonNull MaybeSource<? extends @NonNull T1> source1, @NonNull MaybeSource<? extends @NonNull T2> source2, @NonNull MaybeSource<? extends @NonNull T3> source3, @NonNull MaybeSource<? extends @NonNull T4> source4, @NonNull Function4<? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, ? super @NonNull T4, ? extends @NonNull R> zipper) Returns aMaybe
that emits the results of a specified combiner function applied to combinations of four items emitted, in sequence, by four otherMaybeSource
s.Maybe.zip
(@NonNull MaybeSource<? extends @NonNull T1> source1, @NonNull MaybeSource<? extends @NonNull T2> source2, @NonNull MaybeSource<? extends @NonNull T3> source3, @NonNull MaybeSource<? extends @NonNull T4> source4, @NonNull Function4<? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, ? super @NonNull T4, ? extends @NonNull R> zipper) Returns aMaybe
that emits the results of a specified combiner function applied to combinations of four items emitted, in sequence, by four otherMaybeSource
s.Maybe.zip
(@NonNull MaybeSource<? extends @NonNull T1> source1, @NonNull MaybeSource<? extends @NonNull T2> source2, @NonNull MaybeSource<? extends @NonNull T3> source3, @NonNull MaybeSource<? extends @NonNull T4> source4, @NonNull Function4<? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, ? super @NonNull T4, ? extends @NonNull R> zipper) Returns aMaybe
that emits the results of a specified combiner function applied to combinations of four items emitted, in sequence, by four otherMaybeSource
s.Maybe.zip
(@NonNull MaybeSource<? extends @NonNull T1> source1, @NonNull MaybeSource<? extends @NonNull T2> source2, @NonNull MaybeSource<? extends @NonNull T3> source3, @NonNull MaybeSource<? extends @NonNull T4> source4, @NonNull Function4<? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, ? super @NonNull T4, ? extends @NonNull R> zipper) Returns aMaybe
that emits the results of a specified combiner function applied to combinations of four items emitted, in sequence, by four otherMaybeSource
s.Maybe.zip
(@NonNull MaybeSource<? extends @NonNull T1> source1, @NonNull MaybeSource<? extends @NonNull T2> source2, @NonNull MaybeSource<? extends @NonNull T3> source3, @NonNull MaybeSource<? extends @NonNull T4> source4, @NonNull Function4<? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, ? super @NonNull T4, ? extends @NonNull R> zipper) Returns aMaybe
that emits the results of a specified combiner function applied to combinations of four items emitted, in sequence, by four otherMaybeSource
s.Maybe.zip
(@NonNull MaybeSource<? extends @NonNull T1> source1, @NonNull MaybeSource<? extends @NonNull T2> source2, @NonNull MaybeSource<? extends @NonNull T3> source3, @NonNull Function3<? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, ? extends @NonNull R> zipper) Returns aMaybe
that emits the results of a specified combiner function applied to combinations of three items emitted, in sequence, by three otherMaybeSource
s.Maybe.zip
(@NonNull MaybeSource<? extends @NonNull T1> source1, @NonNull MaybeSource<? extends @NonNull T2> source2, @NonNull MaybeSource<? extends @NonNull T3> source3, @NonNull Function3<? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, ? extends @NonNull R> zipper) Returns aMaybe
that emits the results of a specified combiner function applied to combinations of three items emitted, in sequence, by three otherMaybeSource
s.Maybe.zip
(@NonNull MaybeSource<? extends @NonNull T1> source1, @NonNull MaybeSource<? extends @NonNull T2> source2, @NonNull MaybeSource<? extends @NonNull T3> source3, @NonNull Function3<? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, ? extends @NonNull R> zipper) Returns aMaybe
that emits the results of a specified combiner function applied to combinations of three items emitted, in sequence, by three otherMaybeSource
s.Maybe.zip
(@NonNull MaybeSource<? extends @NonNull T1> source1, @NonNull MaybeSource<? extends @NonNull T2> source2, @NonNull MaybeSource<? extends @NonNull T3> source3, @NonNull Function3<? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, ? extends @NonNull R> zipper) Returns aMaybe
that emits the results of a specified combiner function applied to combinations of three items emitted, in sequence, by three otherMaybeSource
s.Maybe.zip
(@NonNull MaybeSource<? extends @NonNull T1> source1, @NonNull MaybeSource<? extends @NonNull T2> source2, @NonNull BiFunction<? super @NonNull T1, ? super @NonNull T2, ? extends @NonNull R> zipper) Returns aMaybe
that emits the results of a specified combiner function applied to combinations of two items emitted, in sequence, by two otherMaybeSource
s.Maybe.zip
(@NonNull MaybeSource<? extends @NonNull T1> source1, @NonNull MaybeSource<? extends @NonNull T2> source2, @NonNull BiFunction<? super @NonNull T1, ? super @NonNull T2, ? extends @NonNull R> zipper) Returns aMaybe
that emits the results of a specified combiner function applied to combinations of two items emitted, in sequence, by two otherMaybeSource
s.Maybe.zip
(@NonNull MaybeSource<? extends @NonNull T1> source1, @NonNull MaybeSource<? extends @NonNull T2> source2, @NonNull BiFunction<? super @NonNull T1, ? super @NonNull T2, ? extends @NonNull R> zipper) Returns aMaybe
that emits the results of a specified combiner function applied to combinations of two items emitted, in sequence, by two otherMaybeSource
s.Maybe.zip
(@NonNull Iterable<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources, @NonNull Function<? super Object[], ? extends @NonNull R> zipper) Returns aMaybe
that emits the results of a specified combiner function applied to combinations of items emitted, in sequence, by anIterable
of otherMaybeSource
s.Maybe.zip
(@NonNull Iterable<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources, @NonNull Function<? super Object[], ? extends @NonNull R> zipper) Returns aMaybe
that emits the results of a specified combiner function applied to combinations of items emitted, in sequence, by anIterable
of otherMaybeSource
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull T9, @NonNull R>
@NonNull Observable<R> Observable.zip
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull ObservableSource<? extends @NonNull T5> source5, @NonNull ObservableSource<? extends @NonNull T6> source6, @NonNull ObservableSource<? extends @NonNull T7> source7, @NonNull ObservableSource<? extends @NonNull T8> source8, @NonNull ObservableSource<? 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 anObservable
that emits the results of a specified combiner function applied to combinations of nine items emitted, in sequence, by nine otherObservableSource
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull T9, @NonNull R>
@NonNull Observable<R> Observable.zip
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull ObservableSource<? extends @NonNull T5> source5, @NonNull ObservableSource<? extends @NonNull T6> source6, @NonNull ObservableSource<? extends @NonNull T7> source7, @NonNull ObservableSource<? extends @NonNull T8> source8, @NonNull ObservableSource<? 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 anObservable
that emits the results of a specified combiner function applied to combinations of nine items emitted, in sequence, by nine otherObservableSource
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull T9, @NonNull R>
@NonNull Observable<R> Observable.zip
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull ObservableSource<? extends @NonNull T5> source5, @NonNull ObservableSource<? extends @NonNull T6> source6, @NonNull ObservableSource<? extends @NonNull T7> source7, @NonNull ObservableSource<? extends @NonNull T8> source8, @NonNull ObservableSource<? 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 anObservable
that emits the results of a specified combiner function applied to combinations of nine items emitted, in sequence, by nine otherObservableSource
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull T9, @NonNull R>
@NonNull Observable<R> Observable.zip
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull ObservableSource<? extends @NonNull T5> source5, @NonNull ObservableSource<? extends @NonNull T6> source6, @NonNull ObservableSource<? extends @NonNull T7> source7, @NonNull ObservableSource<? extends @NonNull T8> source8, @NonNull ObservableSource<? 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 anObservable
that emits the results of a specified combiner function applied to combinations of nine items emitted, in sequence, by nine otherObservableSource
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull T9, @NonNull R>
@NonNull Observable<R> Observable.zip
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull ObservableSource<? extends @NonNull T5> source5, @NonNull ObservableSource<? extends @NonNull T6> source6, @NonNull ObservableSource<? extends @NonNull T7> source7, @NonNull ObservableSource<? extends @NonNull T8> source8, @NonNull ObservableSource<? 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 anObservable
that emits the results of a specified combiner function applied to combinations of nine items emitted, in sequence, by nine otherObservableSource
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull T9, @NonNull R>
@NonNull Observable<R> Observable.zip
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull ObservableSource<? extends @NonNull T5> source5, @NonNull ObservableSource<? extends @NonNull T6> source6, @NonNull ObservableSource<? extends @NonNull T7> source7, @NonNull ObservableSource<? extends @NonNull T8> source8, @NonNull ObservableSource<? 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 anObservable
that emits the results of a specified combiner function applied to combinations of nine items emitted, in sequence, by nine otherObservableSource
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull T9, @NonNull R>
@NonNull Observable<R> Observable.zip
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull ObservableSource<? extends @NonNull T5> source5, @NonNull ObservableSource<? extends @NonNull T6> source6, @NonNull ObservableSource<? extends @NonNull T7> source7, @NonNull ObservableSource<? extends @NonNull T8> source8, @NonNull ObservableSource<? 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 anObservable
that emits the results of a specified combiner function applied to combinations of nine items emitted, in sequence, by nine otherObservableSource
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull T9, @NonNull R>
@NonNull Observable<R> Observable.zip
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull ObservableSource<? extends @NonNull T5> source5, @NonNull ObservableSource<? extends @NonNull T6> source6, @NonNull ObservableSource<? extends @NonNull T7> source7, @NonNull ObservableSource<? extends @NonNull T8> source8, @NonNull ObservableSource<? 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 anObservable
that emits the results of a specified combiner function applied to combinations of nine items emitted, in sequence, by nine otherObservableSource
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull T9, @NonNull R>
@NonNull Observable<R> Observable.zip
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull ObservableSource<? extends @NonNull T5> source5, @NonNull ObservableSource<? extends @NonNull T6> source6, @NonNull ObservableSource<? extends @NonNull T7> source7, @NonNull ObservableSource<? extends @NonNull T8> source8, @NonNull ObservableSource<? 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 anObservable
that emits the results of a specified combiner function applied to combinations of nine items emitted, in sequence, by nine otherObservableSource
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull T9, @NonNull R>
@NonNull Observable<R> Observable.zip
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull ObservableSource<? extends @NonNull T5> source5, @NonNull ObservableSource<? extends @NonNull T6> source6, @NonNull ObservableSource<? extends @NonNull T7> source7, @NonNull ObservableSource<? extends @NonNull T8> source8, @NonNull ObservableSource<? 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 anObservable
that emits the results of a specified combiner function applied to combinations of nine items emitted, in sequence, by nine otherObservableSource
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull R>
@NonNull Observable<R> Observable.zip
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull ObservableSource<? extends @NonNull T5> source5, @NonNull ObservableSource<? extends @NonNull T6> source6, @NonNull ObservableSource<? extends @NonNull T7> source7, @NonNull ObservableSource<? 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 anObservable
that emits the results of a specified combiner function applied to combinations of eight items emitted, in sequence, by eight otherObservableSource
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull R>
@NonNull Observable<R> Observable.zip
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull ObservableSource<? extends @NonNull T5> source5, @NonNull ObservableSource<? extends @NonNull T6> source6, @NonNull ObservableSource<? extends @NonNull T7> source7, @NonNull ObservableSource<? 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 anObservable
that emits the results of a specified combiner function applied to combinations of eight items emitted, in sequence, by eight otherObservableSource
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull R>
@NonNull Observable<R> Observable.zip
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull ObservableSource<? extends @NonNull T5> source5, @NonNull ObservableSource<? extends @NonNull T6> source6, @NonNull ObservableSource<? extends @NonNull T7> source7, @NonNull ObservableSource<? 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 anObservable
that emits the results of a specified combiner function applied to combinations of eight items emitted, in sequence, by eight otherObservableSource
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull R>
@NonNull Observable<R> Observable.zip
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull ObservableSource<? extends @NonNull T5> source5, @NonNull ObservableSource<? extends @NonNull T6> source6, @NonNull ObservableSource<? extends @NonNull T7> source7, @NonNull ObservableSource<? 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 anObservable
that emits the results of a specified combiner function applied to combinations of eight items emitted, in sequence, by eight otherObservableSource
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull R>
@NonNull Observable<R> Observable.zip
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull ObservableSource<? extends @NonNull T5> source5, @NonNull ObservableSource<? extends @NonNull T6> source6, @NonNull ObservableSource<? extends @NonNull T7> source7, @NonNull ObservableSource<? 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 anObservable
that emits the results of a specified combiner function applied to combinations of eight items emitted, in sequence, by eight otherObservableSource
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull R>
@NonNull Observable<R> Observable.zip
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull ObservableSource<? extends @NonNull T5> source5, @NonNull ObservableSource<? extends @NonNull T6> source6, @NonNull ObservableSource<? extends @NonNull T7> source7, @NonNull ObservableSource<? 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 anObservable
that emits the results of a specified combiner function applied to combinations of eight items emitted, in sequence, by eight otherObservableSource
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull R>
@NonNull Observable<R> Observable.zip
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull ObservableSource<? extends @NonNull T5> source5, @NonNull ObservableSource<? extends @NonNull T6> source6, @NonNull ObservableSource<? extends @NonNull T7> source7, @NonNull ObservableSource<? 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 anObservable
that emits the results of a specified combiner function applied to combinations of eight items emitted, in sequence, by eight otherObservableSource
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull R>
@NonNull Observable<R> Observable.zip
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull ObservableSource<? extends @NonNull T5> source5, @NonNull ObservableSource<? extends @NonNull T6> source6, @NonNull ObservableSource<? extends @NonNull T7> source7, @NonNull ObservableSource<? 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 anObservable
that emits the results of a specified combiner function applied to combinations of eight items emitted, in sequence, by eight otherObservableSource
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull R>
@NonNull Observable<R> Observable.zip
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull ObservableSource<? extends @NonNull T5> source5, @NonNull ObservableSource<? extends @NonNull T6> source6, @NonNull ObservableSource<? extends @NonNull T7> source7, @NonNull ObservableSource<? 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 anObservable
that emits the results of a specified combiner function applied to combinations of eight items emitted, in sequence, by eight otherObservableSource
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull R>
@NonNull Observable<R> Observable.zip
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull ObservableSource<? extends @NonNull T5> source5, @NonNull ObservableSource<? extends @NonNull T6> source6, @NonNull ObservableSource<? 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 anObservable
that emits the results of a specified combiner function applied to combinations of seven items emitted, in sequence, by seven otherObservableSource
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull R>
@NonNull Observable<R> Observable.zip
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull ObservableSource<? extends @NonNull T5> source5, @NonNull ObservableSource<? extends @NonNull T6> source6, @NonNull ObservableSource<? 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 anObservable
that emits the results of a specified combiner function applied to combinations of seven items emitted, in sequence, by seven otherObservableSource
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull R>
@NonNull Observable<R> Observable.zip
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull ObservableSource<? extends @NonNull T5> source5, @NonNull ObservableSource<? extends @NonNull T6> source6, @NonNull ObservableSource<? 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 anObservable
that emits the results of a specified combiner function applied to combinations of seven items emitted, in sequence, by seven otherObservableSource
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull R>
@NonNull Observable<R> Observable.zip
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull ObservableSource<? extends @NonNull T5> source5, @NonNull ObservableSource<? extends @NonNull T6> source6, @NonNull ObservableSource<? 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 anObservable
that emits the results of a specified combiner function applied to combinations of seven items emitted, in sequence, by seven otherObservableSource
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull R>
@NonNull Observable<R> Observable.zip
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull ObservableSource<? extends @NonNull T5> source5, @NonNull ObservableSource<? extends @NonNull T6> source6, @NonNull ObservableSource<? 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 anObservable
that emits the results of a specified combiner function applied to combinations of seven items emitted, in sequence, by seven otherObservableSource
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull R>
@NonNull Observable<R> Observable.zip
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull ObservableSource<? extends @NonNull T5> source5, @NonNull ObservableSource<? extends @NonNull T6> source6, @NonNull ObservableSource<? 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 anObservable
that emits the results of a specified combiner function applied to combinations of seven items emitted, in sequence, by seven otherObservableSource
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull R>
@NonNull Observable<R> Observable.zip
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull ObservableSource<? extends @NonNull T5> source5, @NonNull ObservableSource<? extends @NonNull T6> source6, @NonNull ObservableSource<? 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 anObservable
that emits the results of a specified combiner function applied to combinations of seven items emitted, in sequence, by seven otherObservableSource
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull R>
@NonNull Observable<R> Observable.zip
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull ObservableSource<? extends @NonNull T5> source5, @NonNull ObservableSource<? extends @NonNull T6> source6, @NonNull ObservableSource<? 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 anObservable
that emits the results of a specified combiner function applied to combinations of seven items emitted, in sequence, by seven otherObservableSource
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull R>
@NonNull Observable<R> Observable.zip
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull ObservableSource<? extends @NonNull T5> source5, @NonNull ObservableSource<? 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 anObservable
that emits the results of a specified combiner function applied to combinations of six items emitted, in sequence, by six otherObservableSource
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull R>
@NonNull Observable<R> Observable.zip
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull ObservableSource<? extends @NonNull T5> source5, @NonNull ObservableSource<? 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 anObservable
that emits the results of a specified combiner function applied to combinations of six items emitted, in sequence, by six otherObservableSource
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull R>
@NonNull Observable<R> Observable.zip
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull ObservableSource<? extends @NonNull T5> source5, @NonNull ObservableSource<? 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 anObservable
that emits the results of a specified combiner function applied to combinations of six items emitted, in sequence, by six otherObservableSource
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull R>
@NonNull Observable<R> Observable.zip
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull ObservableSource<? extends @NonNull T5> source5, @NonNull ObservableSource<? 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 anObservable
that emits the results of a specified combiner function applied to combinations of six items emitted, in sequence, by six otherObservableSource
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull R>
@NonNull Observable<R> Observable.zip
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull ObservableSource<? extends @NonNull T5> source5, @NonNull ObservableSource<? 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 anObservable
that emits the results of a specified combiner function applied to combinations of six items emitted, in sequence, by six otherObservableSource
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull R>
@NonNull Observable<R> Observable.zip
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull ObservableSource<? extends @NonNull T5> source5, @NonNull ObservableSource<? 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 anObservable
that emits the results of a specified combiner function applied to combinations of six items emitted, in sequence, by six otherObservableSource
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull R>
@NonNull Observable<R> Observable.zip
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull ObservableSource<? extends @NonNull T5> source5, @NonNull ObservableSource<? 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 anObservable
that emits the results of a specified combiner function applied to combinations of six items emitted, in sequence, by six otherObservableSource
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull R>
@NonNull Observable<R> Observable.zip
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull ObservableSource<? 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 anObservable
that emits the results of a specified combiner function applied to combinations of five items emitted, in sequence, by five otherObservableSource
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull R>
@NonNull Observable<R> Observable.zip
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull ObservableSource<? 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 anObservable
that emits the results of a specified combiner function applied to combinations of five items emitted, in sequence, by five otherObservableSource
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull R>
@NonNull Observable<R> Observable.zip
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull ObservableSource<? 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 anObservable
that emits the results of a specified combiner function applied to combinations of five items emitted, in sequence, by five otherObservableSource
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull R>
@NonNull Observable<R> Observable.zip
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull ObservableSource<? 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 anObservable
that emits the results of a specified combiner function applied to combinations of five items emitted, in sequence, by five otherObservableSource
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull R>
@NonNull Observable<R> Observable.zip
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull ObservableSource<? 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 anObservable
that emits the results of a specified combiner function applied to combinations of five items emitted, in sequence, by five otherObservableSource
s.static <@NonNull T1,
@NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull R>
@NonNull Observable<R> Observable.zip
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull ObservableSource<? 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 anObservable
that emits the results of a specified combiner function applied to combinations of five items emitted, in sequence, by five otherObservableSource
s.Observable.zip
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull Function4<? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, ? super @NonNull T4, ? extends @NonNull R> zipper) Returns anObservable
that emits the results of a specified combiner function applied to combinations of four items emitted, in sequence, by four otherObservableSource
s.Observable.zip
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull Function4<? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, ? super @NonNull T4, ? extends @NonNull R> zipper) Returns anObservable
that emits the results of a specified combiner function applied to combinations of four items emitted, in sequence, by four otherObservableSource
s.Observable.zip
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull Function4<? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, ? super @NonNull T4, ? extends @NonNull R> zipper) Returns anObservable
that emits the results of a specified combiner function applied to combinations of four items emitted, in sequence, by four otherObservableSource
s.Observable.zip
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull Function4<? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, ? super @NonNull T4, ? extends @NonNull R> zipper) Returns anObservable
that emits the results of a specified combiner function applied to combinations of four items emitted, in sequence, by four otherObservableSource
s.Observable.zip
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull Function4<? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, ? super @NonNull T4, ? extends @NonNull R> zipper) Returns anObservable
that emits the results of a specified combiner function applied to combinations of four items emitted, in sequence, by four otherObservableSource
s.Observable.zip
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull Function3<? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, ? extends @NonNull R> zipper) Returns anObservable
that emits the results of a specified combiner function applied to combinations of three items emitted, in sequence, by three otherObservableSource
s.Observable.zip
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull Function3<? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, ? extends @NonNull R> zipper) Returns anObservable
that emits the results of a specified combiner function applied to combinations of three items emitted, in sequence, by three otherObservableSource
s.Observable.zip
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull Function3<? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, ? extends @NonNull R> zipper) Returns anObservable
that emits the results of a specified combiner function applied to combinations of three items emitted, in sequence, by three otherObservableSource
s.Observable.zip
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull Function3<? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, ? extends @NonNull R> zipper) Returns anObservable
that emits the results of a specified combiner function applied to combinations of three items emitted, in sequence, by three otherObservableSource
s.static <@NonNull T1,
@NonNull T2, @NonNull R>
@NonNull Observable<R> Observable.zip
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull BiFunction<? super @NonNull T1, ? super @NonNull T2, ? extends @NonNull R> zipper) Returns anObservable
that emits the results of a specified combiner function applied to combinations of two items emitted, in sequence, by two otherObservableSource
s.static <@NonNull T1,
@NonNull T2, @NonNull R>
@NonNull Observable<R> Observable.zip
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull BiFunction<? super @NonNull T1, ? super @NonNull T2, ? extends @NonNull R> zipper) Returns anObservable
that emits the results of a specified combiner function applied to combinations of two items emitted, in sequence, by two otherObservableSource
s.static <@NonNull T1,
@NonNull T2, @NonNull R>
@NonNull Observable<R> Observable.zip
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull BiFunction<? super @NonNull T1, ? super @NonNull T2, ? extends @NonNull R> zipper) Returns anObservable
that emits the results of a specified combiner function applied to combinations of two items emitted, in sequence, by two otherObservableSource
s.static <@NonNull T1,
@NonNull T2, @NonNull R>
@NonNull Observable<R> Observable.zip
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull BiFunction<? super @NonNull T1, ? super @NonNull T2, ? extends @NonNull R> zipper, boolean delayError) Returns anObservable
that emits the results of a specified combiner function applied to combinations of two items emitted, in sequence, by two otherObservableSource
s.static <@NonNull T1,
@NonNull T2, @NonNull R>
@NonNull Observable<R> Observable.zip
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull BiFunction<? super @NonNull T1, ? super @NonNull T2, ? extends @NonNull R> zipper, boolean delayError) Returns anObservable
that emits the results of a specified combiner function applied to combinations of two items emitted, in sequence, by two otherObservableSource
s.static <@NonNull T1,
@NonNull T2, @NonNull R>
@NonNull Observable<R> Observable.zip
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull BiFunction<? super @NonNull T1, ? super @NonNull T2, ? extends @NonNull R> zipper, boolean delayError) Returns anObservable
that emits the results of a specified combiner function applied to combinations of two items emitted, in sequence, by two otherObservableSource
s.static <@NonNull T1,
@NonNull T2, @NonNull R>
@NonNull Observable<R> Observable.zip
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull BiFunction<? super @NonNull T1, ? super @NonNull T2, ? extends @NonNull R> zipper, boolean delayError, int bufferSize) Returns anObservable
that emits the results of a specified combiner function applied to combinations of two items emitted, in sequence, by two otherObservableSource
s.static <@NonNull T1,
@NonNull T2, @NonNull R>
@NonNull Observable<R> Observable.zip
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull BiFunction<? super @NonNull T1, ? super @NonNull T2, ? extends @NonNull R> zipper, boolean delayError, int bufferSize) Returns anObservable
that emits the results of a specified combiner function applied to combinations of two items emitted, in sequence, by two otherObservableSource
s.static <@NonNull T1,
@NonNull T2, @NonNull R>
@NonNull Observable<R> Observable.zip
(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull BiFunction<? super @NonNull T1, ? super @NonNull T2, ? extends @NonNull R> zipper, boolean delayError, int bufferSize) Returns anObservable
that emits the results of a specified combiner function applied to combinations of two items emitted, in sequence, by two otherObservableSource
s.static <@NonNull T,
@NonNull R>
@NonNull Observable<R> Observable.zip
(@NonNull Iterable<@NonNull ? extends ObservableSource<? extends @NonNull T>> sources, @NonNull Function<? super Object[], ? extends @NonNull R> zipper) Returns anObservable
that emits the results of a specified combiner function applied to combinations of items emitted, in sequence, by anIterable
of otherObservableSource
s.static <@NonNull T,
@NonNull R>
@NonNull Observable<R> Observable.zip
(@NonNull Iterable<@NonNull ? extends ObservableSource<? extends @NonNull T>> sources, @NonNull Function<? super Object[], ? extends @NonNull R> zipper) Returns anObservable
that emits the results of a specified combiner function applied to combinations of items emitted, in sequence, by anIterable
of otherObservableSource
s.static <@NonNull T,
@NonNull R>
@NonNull Observable<R> Observable.zip
(@NonNull Iterable<@NonNull ? extends ObservableSource<? extends @NonNull T>> sources, @NonNull Function<? super Object[], ? extends @NonNull R> zipper, boolean delayError, int bufferSize) Returns anObservable
that emits the results of a specified combiner function applied to combinations of items emitted, in sequence, by anIterable
of otherObservableSource
s.static <@NonNull T,
@NonNull R>
@NonNull Observable<R> Observable.zip
(@NonNull Iterable<@NonNull ? extends ObservableSource<? extends @NonNull T>> sources, @NonNull Function<? super Object[], ? extends @NonNull R> zipper, boolean delayError, int bufferSize) Returns anObservable
that emits the results of a specified combiner function applied to combinations of items emitted, in sequence, by anIterable
of otherObservableSource
s.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 aSingle
that emits the results of a specified combiner function applied to nine items emitted by nine otherSingleSource
s.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 aSingle
that emits the results of a specified combiner function applied to nine items emitted by nine otherSingleSource
s.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 aSingle
that emits the results of a specified combiner function applied to nine items emitted by nine otherSingleSource
s.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 aSingle
that emits the results of a specified combiner function applied to nine items emitted by nine otherSingleSource
s.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 aSingle
that emits the results of a specified combiner function applied to nine items emitted by nine otherSingleSource
s.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 aSingle
that emits the results of a specified combiner function applied to nine items emitted by nine otherSingleSource
s.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 aSingle
that emits the results of a specified combiner function applied to nine items emitted by nine otherSingleSource
s.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 aSingle
that emits the results of a specified combiner function applied to nine items emitted by nine otherSingleSource
s.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 aSingle
that emits the results of a specified combiner function applied to nine items emitted by nine otherSingleSource
s.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 aSingle
that emits the results of a specified combiner function applied to nine items emitted by nine otherSingleSource
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 aSingle
that emits the results of a specified combiner function applied to eight items emitted by eight otherSingleSource
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 aSingle
that emits the results of a specified combiner function applied to eight items emitted by eight otherSingleSource
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 aSingle
that emits the results of a specified combiner function applied to eight items emitted by eight otherSingleSource
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 aSingle
that emits the results of a specified combiner function applied to eight items emitted by eight otherSingleSource
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 aSingle
that emits the results of a specified combiner function applied to eight items emitted by eight otherSingleSource
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 aSingle
that emits the results of a specified combiner function applied to eight items emitted by eight otherSingleSource
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 aSingle
that emits the results of a specified combiner function applied to eight items emitted by eight otherSingleSource
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 aSingle
that emits the results of a specified combiner function applied to eight items emitted by eight otherSingleSource
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 aSingle
that emits the results of a specified combiner function applied to eight items emitted by eight otherSingleSource
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 aSingle
that emits the results of a specified combiner function applied to seven items emitted by seven otherSingleSource
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 aSingle
that emits the results of a specified combiner function applied to seven items emitted by seven otherSingleSource
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 aSingle
that emits the results of a specified combiner function applied to seven items emitted by seven otherSingleSource
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 aSingle
that emits the results of a specified combiner function applied to seven items emitted by seven otherSingleSource
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 aSingle
that emits the results of a specified combiner function applied to seven items emitted by seven otherSingleSource
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 aSingle
that emits the results of a specified combiner function applied to seven items emitted by seven otherSingleSource
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 aSingle
that emits the results of a specified combiner function applied to seven items emitted by seven otherSingleSource
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 aSingle
that emits the results of a specified combiner function applied to seven items emitted by seven otherSingleSource
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 aSingle
that emits the results of a specified combiner function applied to six items emitted by six otherSingleSource
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 aSingle
that emits the results of a specified combiner function applied to six items emitted by six otherSingleSource
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 aSingle
that emits the results of a specified combiner function applied to six items emitted by six otherSingleSource
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 aSingle
that emits the results of a specified combiner function applied to six items emitted by six otherSingleSource
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 aSingle
that emits the results of a specified combiner function applied to six items emitted by six otherSingleSource
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 aSingle
that emits the results of a specified combiner function applied to six items emitted by six otherSingleSource
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 aSingle
that emits the results of a specified combiner function applied to six items emitted by six otherSingleSource
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 aSingle
that emits the results of a specified combiner function applied to five items emitted by five otherSingleSource
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 aSingle
that emits the results of a specified combiner function applied to five items emitted by five otherSingleSource
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 aSingle
that emits the results of a specified combiner function applied to five items emitted by five otherSingleSource
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 aSingle
that emits the results of a specified combiner function applied to five items emitted by five otherSingleSource
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 aSingle
that emits the results of a specified combiner function applied to five items emitted by five otherSingleSource
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 aSingle
that emits the results of a specified combiner function applied to five items emitted by five otherSingleSource
s.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 aSingle
that emits the results of a specified combiner function applied to four items emitted by four otherSingleSource
s.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 aSingle
that emits the results of a specified combiner function applied to four items emitted by four otherSingleSource
s.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 aSingle
that emits the results of a specified combiner function applied to four items emitted by four otherSingleSource
s.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 aSingle
that emits the results of a specified combiner function applied to four items emitted by four otherSingleSource
s.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 aSingle
that emits the results of a specified combiner function applied to four items emitted by four otherSingleSource
s.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 aSingle
that emits the results of a specified combiner function applied to three items emitted by three otherSingleSource
s.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 aSingle
that emits the results of a specified combiner function applied to three items emitted by three otherSingleSource
s.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 aSingle
that emits the results of a specified combiner function applied to three items emitted by three otherSingleSource
s.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 aSingle
that emits the results of a specified combiner function applied to three items emitted by three otherSingleSource
s.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 aSingle
that emits the results of a specified combiner function applied to two items emitted by two otherSingleSource
s.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 aSingle
that emits the results of a specified combiner function applied to two items emitted by two otherSingleSource
s.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 aSingle
that emits the results of a specified combiner function applied to two items emitted by two otherSingleSource
s.Single.zip
(@NonNull Iterable<@NonNull ? extends SingleSource<? extends @NonNull T>> sources, @NonNull Function<? super Object[], ? extends @NonNull R> zipper) Waits until allSingleSource
sources provided by theIterable
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.Single.zip
(@NonNull Iterable<@NonNull ? extends SingleSource<? extends @NonNull T>> sources, @NonNull Function<? super Object[], ? extends @NonNull R> zipper) Waits until allSingleSource
sources provided by theIterable
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.Flowable.zipArray
(@NonNull Function<? super Object[], ? extends @NonNull R> zipper, boolean delayError, int bufferSize, @NonNull org.reactivestreams.Publisher<? extends @NonNull T>... sources) Returns aFlowable
that emits the results of a specified combiner function applied to combinations of items emitted, in sequence, by an array of otherPublisher
s.Flowable.zipArray
(@NonNull Function<? super Object[], ? extends @NonNull R> zipper, boolean delayError, int bufferSize, @NonNull org.reactivestreams.Publisher<? extends @NonNull T>... sources) Returns aFlowable
that emits the results of a specified combiner function applied to combinations of items emitted, in sequence, by an array of otherPublisher
s.Maybe.zipArray
(@NonNull Function<? super Object[], ? extends @NonNull R> zipper, @NonNull MaybeSource<? extends @NonNull T>... sources) Returns aMaybe
that emits the results of a specified combiner function applied to combinations of items emitted, in sequence, by an array of otherMaybeSource
s.Maybe.zipArray
(@NonNull Function<? super Object[], ? extends @NonNull R> zipper, @NonNull MaybeSource<? extends @NonNull T>... sources) Returns aMaybe
that emits the results of a specified combiner function applied to combinations of items emitted, in sequence, by an array of otherMaybeSource
s.static <@NonNull T,
@NonNull R>
@NonNull Observable<R> Observable.zipArray
(@NonNull Function<? super Object[], ? extends @NonNull R> zipper, boolean delayError, int bufferSize, @NonNull ObservableSource<? extends @NonNull T>... sources) Returns anObservable
that emits the results of a specified combiner function applied to combinations of items emitted, in sequence, by an array of otherObservableSource
s.static <@NonNull T,
@NonNull R>
@NonNull Observable<R> Observable.zipArray
(@NonNull Function<? super Object[], ? extends @NonNull R> zipper, boolean delayError, int bufferSize, @NonNull ObservableSource<? extends @NonNull T>... sources) Returns anObservable
that emits the results of a specified combiner function applied to combinations of items emitted, in sequence, by an array of otherObservableSource
s.Single.zipArray
(@NonNull Function<? super Object[], ? extends @NonNull R> zipper, @NonNull SingleSource<? extends @NonNull T>... sources) Waits until allSingleSource
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.Single.zipArray
(@NonNull Function<? super Object[], ? extends @NonNull R> zipper, @NonNull SingleSource<? extends @NonNull T>... sources) Waits until allSingleSource
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.Flowable.zipWith
(@NonNull Iterable<@NonNull U> other, @NonNull BiFunction<? super @NonNull T, ? super @NonNull U, ? extends @NonNull R> zipper) Returns aFlowable
that emits items that are the result of applying a specified function to pairs of values, one each from the currentFlowable
and a specifiedIterable
sequence.Flowable.zipWith
(@NonNull Iterable<@NonNull U> other, @NonNull BiFunction<? super @NonNull T, ? super @NonNull U, ? extends @NonNull R> zipper) Returns aFlowable
that emits items that are the result of applying a specified function to pairs of values, one each from the currentFlowable
and a specifiedIterable
sequence.Flowable.zipWith
(@NonNull org.reactivestreams.Publisher<? extends @NonNull U> other, @NonNull BiFunction<? super @NonNull T, ? super @NonNull U, ? extends @NonNull R> zipper) Returns aFlowable
that emits items that are the result of applying a specified function to pairs of values, one each from the currentFlowable
and another specifiedPublisher
.Flowable.zipWith
(@NonNull org.reactivestreams.Publisher<? extends @NonNull U> other, @NonNull BiFunction<? super @NonNull T, ? super @NonNull U, ? extends @NonNull R> zipper) Returns aFlowable
that emits items that are the result of applying a specified function to pairs of values, one each from the currentFlowable
and another specifiedPublisher
.Flowable.zipWith
(@NonNull org.reactivestreams.Publisher<? extends @NonNull U> other, @NonNull BiFunction<? super @NonNull T, ? super @NonNull U, ? extends @NonNull R> zipper, boolean delayError) Returns aFlowable
that emits items that are the result of applying a specified function to pairs of values, one each from the currentFlowable
and another specifiedPublisher
.Flowable.zipWith
(@NonNull org.reactivestreams.Publisher<? extends @NonNull U> other, @NonNull BiFunction<? super @NonNull T, ? super @NonNull U, ? extends @NonNull R> zipper, boolean delayError) Returns aFlowable
that emits items that are the result of applying a specified function to pairs of values, one each from the currentFlowable
and another specifiedPublisher
.Flowable.zipWith
(@NonNull org.reactivestreams.Publisher<? extends @NonNull U> other, @NonNull BiFunction<? super @NonNull T, ? super @NonNull U, ? extends @NonNull R> zipper, boolean delayError, int bufferSize) Returns aFlowable
that emits items that are the result of applying a specified function to pairs of values, one each from the currentFlowable
and another specifiedPublisher
.Flowable.zipWith
(@NonNull org.reactivestreams.Publisher<? extends @NonNull U> other, @NonNull BiFunction<? super @NonNull T, ? super @NonNull U, ? extends @NonNull R> zipper, boolean delayError, int bufferSize) Returns aFlowable
that emits items that are the result of applying a specified function to pairs of values, one each from the currentFlowable
and another specifiedPublisher
.Maybe.zipWith
(@NonNull MaybeSource<? extends @NonNull U> other, @NonNull BiFunction<? super @NonNull T, ? super @NonNull U, ? extends @NonNull R> zipper) Waits until this and the otherMaybeSource
signal a success value then applies the givenBiFunction
to those values and emits theBiFunction
's resulting value to downstream.Maybe.zipWith
(@NonNull MaybeSource<? extends @NonNull U> other, @NonNull BiFunction<? super @NonNull T, ? super @NonNull U, ? extends @NonNull R> zipper) Waits until this and the otherMaybeSource
signal a success value then applies the givenBiFunction
to those values and emits theBiFunction
's resulting value to downstream.final <@NonNull U,
@NonNull R>
@NonNull Observable<R> Observable.zipWith
(@NonNull ObservableSource<? extends @NonNull U> other, @NonNull BiFunction<? super @NonNull T, ? super @NonNull U, ? extends @NonNull R> zipper) Returns anObservable
that emits items that are the result of applying a specified function to pairs of values, one each from the currentObservable
and another specifiedObservableSource
.final <@NonNull U,
@NonNull R>
@NonNull Observable<R> Observable.zipWith
(@NonNull ObservableSource<? extends @NonNull U> other, @NonNull BiFunction<? super @NonNull T, ? super @NonNull U, ? extends @NonNull R> zipper) Returns anObservable
that emits items that are the result of applying a specified function to pairs of values, one each from the currentObservable
and another specifiedObservableSource
.final <@NonNull U,
@NonNull R>
@NonNull Observable<R> Observable.zipWith
(@NonNull ObservableSource<? extends @NonNull U> other, @NonNull BiFunction<? super @NonNull T, ? super @NonNull U, ? extends @NonNull R> zipper, boolean delayError) Returns anObservable
that emits items that are the result of applying a specified function to pairs of values, one each from the currentObservable
and another specifiedObservableSource
.final <@NonNull U,
@NonNull R>
@NonNull Observable<R> Observable.zipWith
(@NonNull ObservableSource<? extends @NonNull U> other, @NonNull BiFunction<? super @NonNull T, ? super @NonNull U, ? extends @NonNull R> zipper, boolean delayError) Returns anObservable
that emits items that are the result of applying a specified function to pairs of values, one each from the currentObservable
and another specifiedObservableSource
.final <@NonNull U,
@NonNull R>
@NonNull Observable<R> Observable.zipWith
(@NonNull ObservableSource<? extends @NonNull U> other, @NonNull BiFunction<? super @NonNull T, ? super @NonNull U, ? extends @NonNull R> zipper, boolean delayError, int bufferSize) Returns anObservable
that emits items that are the result of applying a specified function to pairs of values, one each from the currentObservable
and another specifiedObservableSource
.final <@NonNull U,
@NonNull R>
@NonNull Observable<R> Observable.zipWith
(@NonNull ObservableSource<? extends @NonNull U> other, @NonNull BiFunction<? super @NonNull T, ? super @NonNull U, ? extends @NonNull R> zipper, boolean delayError, int bufferSize) Returns anObservable
that emits items that are the result of applying a specified function to pairs of values, one each from the currentObservable
and another specifiedObservableSource
.final <@NonNull U,
@NonNull R>
@NonNull Observable<R> Observable.zipWith
(@NonNull Iterable<@NonNull U> other, @NonNull BiFunction<? super @NonNull T, ? super @NonNull U, ? extends @NonNull R> zipper) Returns anObservable
that emits items that are the result of applying a specified function to pairs of values, one each from the currentObservable
and a specifiedIterable
sequence.final <@NonNull U,
@NonNull R>
@NonNull Observable<R> Observable.zipWith
(@NonNull Iterable<@NonNull U> other, @NonNull BiFunction<? super @NonNull T, ? super @NonNull U, ? extends @NonNull R> zipper) Returns anObservable
that emits items that are the result of applying a specified function to pairs of values, one each from the currentObservable
and a specifiedIterable
sequence.Single.zipWith
(@NonNull SingleSource<@NonNull U> other, @NonNull BiFunction<? super @NonNull T, ? super @NonNull U, ? extends @NonNull R> zipper) Returns aSingle
that emits the result of applying a specified function to the pair of items emitted by the currentSingle
and another specifiedSingleSource
.Single.zipWith
(@NonNull SingleSource<@NonNull U> other, @NonNull BiFunction<? super @NonNull T, ? super @NonNull U, ? extends @NonNull R> zipper) Returns aSingle
that emits the result of applying a specified function to the pair of items emitted by the currentSingle
and another specifiedSingleSource
.Constructor parameters in io.reactivex.rxjava3.core with annotations of type NonNullModifierConstructorDescription(package private)
DisposeTask
(@NonNull Runnable decoratedRun, @NonNull Scheduler.Worker w) (package private)
DisposeTask
(@NonNull Runnable decoratedRun, @NonNull Scheduler.Worker w) (package private)
PeriodicDirectTask
(@NonNull Runnable run, @NonNull Scheduler.Worker worker) (package private)
PeriodicDirectTask
(@NonNull Runnable run, @NonNull Scheduler.Worker worker) (package private)
PeriodicTask
(long firstStartInNanoseconds, @NonNull Runnable decoratedRun, long firstNowNanoseconds, @NonNull SequentialDisposable sd, long periodInNanoseconds) (package private)
PeriodicTask
(long firstStartInNanoseconds, @NonNull Runnable decoratedRun, long firstNowNanoseconds, @NonNull SequentialDisposable sd, long periodInNanoseconds) -
Uses of NonNull in io.reactivex.rxjava3.disposables
Methods in io.reactivex.rxjava3.disposables with annotations of type NonNullModifier and TypeMethodDescriptionstatic @NonNull Disposable
Disposable.disposed()
Returns a shared, disposedDisposable
instance.static @NonNull Disposable
Disposable.empty()
Returns a new, non-disposedDisposable
instance.static @NonNull Disposable
Disposable.fromAction
(@NonNull Action action) Construct aDisposable
by wrapping aAction
that is executed exactly once when theDisposable
is disposed.static @NonNull Disposable
Disposable.fromAutoCloseable
(@NonNull AutoCloseable autoCloseable) Construct aDisposable
by wrapping anAutoCloseable
that is closed exactly once when theDisposable
is disposed.static @NonNull Disposable
Disposable.fromFuture
(@NonNull Future<?> future) Construct aDisposable
by wrapping aFuture
that is cancelled exactly once when theDisposable
is disposed.static @NonNull Disposable
Disposable.fromFuture
(@NonNull Future<?> future, boolean allowInterrupt) Construct aDisposable
by wrapping aFuture
that is cancelled exactly once when theDisposable
is disposed.static @NonNull Disposable
Disposable.fromRunnable
(@NonNull Runnable run) Construct aDisposable
by wrapping aRunnable
that is executed exactly once when theDisposable
is disposed.static @NonNull Disposable
Disposable.fromSubscription
(@NonNull org.reactivestreams.Subscription subscription) Construct aDisposable
by wrapping aSubscription
that is cancelled exactly once when theDisposable
is disposed.static @NonNull AutoCloseable
Disposable.toAutoCloseable
(@NonNull Disposable disposable) Construct anAutoCloseable
by wrapping aDisposable
that is disposed when the returnedAutoCloseable
is closed.Method parameters in io.reactivex.rxjava3.disposables with annotations of type NonNullModifier and TypeMethodDescriptionboolean
CompositeDisposable.add
(@NonNull Disposable disposable) Adds aDisposable
to this container or disposes it if the container has been disposed.boolean
CompositeDisposable.addAll
(@NonNull Disposable... disposables) Atomically adds the given array ofDisposable
s to the container or disposes them all if the container has been disposed.boolean
CompositeDisposable.delete
(@NonNull Disposable disposable) Removes (but does not dispose) the givenDisposable
if it is part of this container.static @NonNull Disposable
Disposable.fromAction
(@NonNull Action action) Construct aDisposable
by wrapping aAction
that is executed exactly once when theDisposable
is disposed.static @NonNull Disposable
Disposable.fromAutoCloseable
(@NonNull AutoCloseable autoCloseable) Construct aDisposable
by wrapping anAutoCloseable
that is closed exactly once when theDisposable
is disposed.static @NonNull Disposable
Disposable.fromFuture
(@NonNull Future<?> future) Construct aDisposable
by wrapping aFuture
that is cancelled exactly once when theDisposable
is disposed.static @NonNull Disposable
Disposable.fromFuture
(@NonNull Future<?> future, boolean allowInterrupt) Construct aDisposable
by wrapping aFuture
that is cancelled exactly once when theDisposable
is disposed.static @NonNull Disposable
Disposable.fromRunnable
(@NonNull Runnable run) Construct aDisposable
by wrapping aRunnable
that is executed exactly once when theDisposable
is disposed.static @NonNull Disposable
Disposable.fromSubscription
(@NonNull org.reactivestreams.Subscription subscription) Construct aDisposable
by wrapping aSubscription
that is cancelled exactly once when theDisposable
is disposed.protected void
ActionDisposable.onDisposed
(@NonNull Action value) protected void
AutoCloseableDisposable.onDisposed
(@NonNull AutoCloseable value) protected abstract void
ReferenceDisposable.onDisposed
(T value) protected void
RunnableDisposable.onDisposed
(@NonNull Runnable value) protected void
SubscriptionDisposable.onDisposed
(@NonNull org.reactivestreams.Subscription value) boolean
CompositeDisposable.remove
(@NonNull Disposable disposable) Removes and disposes the givenDisposable
if it is part of this container.static @NonNull AutoCloseable
Disposable.toAutoCloseable
(@NonNull Disposable disposable) Construct anAutoCloseable
by wrapping aDisposable
that is disposed when the returnedAutoCloseable
is closed.Constructor parameters in io.reactivex.rxjava3.disposables with annotations of type NonNullModifierConstructorDescriptionCompositeDisposable
(@NonNull Disposable... disposables) Creates aCompositeDisposable
with the given array of initialDisposable
elements.CompositeDisposable
(@NonNull Iterable<? extends Disposable> disposables) -
Uses of NonNull in io.reactivex.rxjava3.exceptions
Methods in io.reactivex.rxjava3.exceptions with annotations of type NonNullModifier and TypeMethodDescriptionCompositeException.getCause()
CompositeException.getExceptions()
Retrieves the list of exceptions that make up theCompositeException
.CompositeException.getMessage()
static @NonNull RuntimeException
Convenience method to throw aRuntimeException
andError
directly or wrap any other exception type into aRuntimeException
.Method parameters in io.reactivex.rxjava3.exceptions with annotations of type NonNullModifier and TypeMethodDescriptionstatic @NonNull RuntimeException
Convenience method to throw aRuntimeException
andError
directly or wrap any other exception type into aRuntimeException
.static void
Exceptions.throwIfFatal
(@NonNull Throwable t) Throws a particularThrowable
only if it belongs to a set of "fatal" error varieties.Constructor parameters in io.reactivex.rxjava3.exceptions with annotations of type NonNullModifierConstructorDescriptionCompositeException
(@NonNull Iterable<? extends Throwable> errors) Constructs a CompositeException with the given array of Throwables as the list of suppressed exceptions.CompositeException
(@NonNull Throwable... exceptions) Constructs a CompositeException with the given array of Throwables as the list of suppressed exceptions.Wraps theThrowable
before it is signalled to theRxJavaPlugins.onError()
handler asOnErrorNotImplementedException
.OnErrorNotImplementedException
(String message, @NonNull Throwable e) Customizes theThrowable
with a custom message and wraps it before it is signalled to theRxJavaPlugins.onError()
handler asOnErrorNotImplementedException
. -
Uses of NonNull in io.reactivex.rxjava3.flowables
Methods in io.reactivex.rxjava3.flowables with annotations of type NonNullModifier and TypeMethodDescriptionConnectableFlowable.autoConnect()
Returns aFlowable
that automatically connects (at most once) to thisConnectableFlowable
when the firstSubscriber
subscribes.ConnectableFlowable.autoConnect
(int numberOfSubscribers) Returns aFlowable
that automatically connects (at most once) to thisConnectableFlowable
when the specified number ofSubscriber
s subscribe to it.ConnectableFlowable.autoConnect
(int numberOfSubscribers, @NonNull Consumer<? super Disposable> connection) Returns aFlowable
that automatically connects (at most once) to thisConnectableFlowable
when the specified number ofSubscriber
s subscribe to it and calls the specified callback with theDisposable
associated with the established connection.final @NonNull Disposable
ConnectableFlowable.connect()
Instructs theConnectableFlowable
to begin emitting the items from its underlyingFlowable
to itsSubscriber
s.ConnectableFlowable.refCount()
Returns aFlowable
that stays connected to thisConnectableFlowable
as long as there is at least one subscription to thisConnectableFlowable
.ConnectableFlowable.refCount
(int subscriberCount) Connects to the upstreamConnectableFlowable
if the number of subscribed subscriber reaches the specified count and disconnect if all subscribers have unsubscribed.Connects to the upstreamConnectableFlowable
if the number of subscribed subscriber reaches the specified count and disconnect after the specified timeout if all subscribers have unsubscribed.ConnectableFlowable.refCount
(int subscriberCount, long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Connects to the upstreamConnectableFlowable
if the number of subscribed subscriber reaches the specified count and disconnect after the specified timeout if all subscribers have unsubscribed.Connects to the upstreamConnectableFlowable
if the number of subscribed subscriber reaches 1 and disconnect after the specified timeout if all subscribers have unsubscribed.Connects to the upstreamConnectableFlowable
if the number of subscribed subscriber reaches 1 and disconnect after the specified timeout if all subscribers have unsubscribed.Method parameters in io.reactivex.rxjava3.flowables with annotations of type NonNullModifier and TypeMethodDescriptionConnectableFlowable.autoConnect
(int numberOfSubscribers, @NonNull Consumer<? super Disposable> connection) Returns aFlowable
that automatically connects (at most once) to thisConnectableFlowable
when the specified number ofSubscriber
s subscribe to it and calls the specified callback with theDisposable
associated with the established connection.abstract void
ConnectableFlowable.connect
(@NonNull Consumer<? super Disposable> connection) Instructs theConnectableFlowable
to begin emitting the items from its underlyingFlowable
to itsSubscriber
s.Connects to the upstreamConnectableFlowable
if the number of subscribed subscriber reaches the specified count and disconnect after the specified timeout if all subscribers have unsubscribed.ConnectableFlowable.refCount
(int subscriberCount, long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Connects to the upstreamConnectableFlowable
if the number of subscribed subscriber reaches the specified count and disconnect after the specified timeout if all subscribers have unsubscribed.ConnectableFlowable.refCount
(int subscriberCount, long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Connects to the upstreamConnectableFlowable
if the number of subscribed subscriber reaches the specified count and disconnect after the specified timeout if all subscribers have unsubscribed.Connects to the upstreamConnectableFlowable
if the number of subscribed subscriber reaches 1 and disconnect after the specified timeout if all subscribers have unsubscribed.Connects to the upstreamConnectableFlowable
if the number of subscribed subscriber reaches 1 and disconnect after the specified timeout if all subscribers have unsubscribed.Connects to the upstreamConnectableFlowable
if the number of subscribed subscriber reaches 1 and disconnect after the specified timeout if all subscribers have unsubscribed. -
Uses of NonNull in io.reactivex.rxjava3.functions
Method parameters in io.reactivex.rxjava3.functions with annotations of type NonNull -
Uses of NonNull in io.reactivex.rxjava3.internal.functions
Methods in io.reactivex.rxjava3.internal.functions with annotations of type NonNullModifier and TypeMethodDescriptionFunctions.alwaysFalse()
Functions.alwaysTrue()
Functions.castFunction
(@NonNull Class<U> target) Returns a function that cast the incoming values via a Class object.Functions.futureAction
(@NonNull Future<?> future) Wraps the blocking get call of the Future into an Action.Functions.identity()
Returns an identity function that simply returns its argument.Functions.justCallable
(T value) Returns a Callable that returns the given value.Functions.justFunction
(U value) Returns a Function that ignores its parameter and returns the given value.Functions.justSupplier
(T value) Returns a Supplier that returns the given value.Functions.nullSupplier()
Functions.toFunction
(@NonNull BiFunction<? super T1, ? super T2, ? extends R> f) Functions.toFunction
(@NonNull Function3<T1, T2, T3, R> f) Functions.toFunction
(@NonNull Function4<T1, T2, T3, T4, R> f) Functions.toFunction
(@NonNull Function5<T1, T2, T3, T4, T5, R> f) Functions.toFunction
(@NonNull Function6<T1, T2, T3, T4, T5, T6, R> f) Functions.toFunction
(@NonNull Function7<T1, T2, T3, T4, T5, T6, T7, R> f) Functions.toFunction
(@NonNull Function8<T1, T2, T3, T4, T5, T6, T7, T8, R> f) Functions.toFunction
(@NonNull Function9<T1, T2, T3, T4, T5, T6, T7, T8, T9, R> f) Method parameters in io.reactivex.rxjava3.internal.functions with annotations of type NonNullModifier and TypeMethodDescriptionFunctions.castFunction
(@NonNull Class<U> target) Returns a function that cast the incoming values via a Class object.Functions.futureAction
(@NonNull Future<?> future) Wraps the blocking get call of the Future into an Action.Functions.justCallable
(T value) Returns a Callable that returns the given value.Functions.justFunction
(U value) Returns a Function that ignores its parameter and returns the given value.Functions.justSupplier
(T value) Returns a Supplier that returns the given value.Functions.toFunction
(@NonNull BiFunction<? super T1, ? super T2, ? extends R> f) Functions.toFunction
(@NonNull Function3<T1, T2, T3, R> f) Functions.toFunction
(@NonNull Function4<T1, T2, T3, T4, R> f) Functions.toFunction
(@NonNull Function5<T1, T2, T3, T4, T5, R> f) Functions.toFunction
(@NonNull Function6<T1, T2, T3, T4, T5, T6, R> f) Functions.toFunction
(@NonNull Function7<T1, T2, T3, T4, T5, T6, T7, R> f) Functions.toFunction
(@NonNull Function8<T1, T2, T3, T4, T5, T6, T7, T8, R> f) Functions.toFunction
(@NonNull Function9<T1, T2, T3, T4, T5, T6, T7, T8, T9, R> f) -
Uses of NonNull in io.reactivex.rxjava3.internal.fuseable
Methods in io.reactivex.rxjava3.internal.fuseable with annotations of type NonNullModifier and TypeMethodDescriptionFuseToFlowable.fuseToFlowable()
Returns a (direct) Flowable for the operator.FuseToMaybe.fuseToMaybe()
Returns a (direct) Maybe for the operator.FuseToObservable.fuseToObservable()
Returns a (direct) Observable for the operator.HasUpstreamCompletableSource.source()
Returns the upstream source of this Completable.HasUpstreamMaybeSource.source()
Returns the upstream source of this Maybe.HasUpstreamObservableSource.source()
Returns the upstream source of this Observable.HasUpstreamPublisher.source()
Returns the source Publisher.HasUpstreamSingleSource.source()
Returns the upstream source of this Single.Method parameters in io.reactivex.rxjava3.internal.fuseable with annotations of type NonNull -
Uses of NonNull in io.reactivex.rxjava3.internal.jdk8
Method parameters in io.reactivex.rxjava3.internal.jdk8 with annotations of type NonNullModifier and TypeMethodDescriptionboolean
boolean
boolean
boolean
boolean
boolean
void
void
void
void
void
CompletionStageConsumer.onSubscribe
(@NonNull Disposable d) void
FlowableCollectWithCollector.CollectorSubscriber.onSubscribe
(@NonNull org.reactivestreams.Subscription s) void
FlowableCollectWithCollectorSingle.CollectorSingleObserver.onSubscribe
(@NonNull org.reactivestreams.Subscription s) void
FlowableFlatMapStream.FlatMapStreamSubscriber.onSubscribe
(@NonNull org.reactivestreams.Subscription s) final void
FlowableStageSubscriber.onSubscribe
(@NonNull org.reactivestreams.Subscription s) void
MaybeFlattenStreamAsFlowable.FlattenStreamMultiObserver.onSubscribe
(@NonNull Disposable d) void
MaybeFlattenStreamAsObservable.FlattenStreamMultiObserver.onSubscribe
(@NonNull Disposable d) void
ObservableCollectWithCollector.CollectorObserver.onSubscribe
(@NonNull Disposable d) void
ObservableCollectWithCollectorSingle.CollectorSingleObserver.onSubscribe
(@NonNull Disposable d) void
ObservableFlatMapStream.FlatMapStreamObserver.onSubscribe
(@NonNull Disposable d) final void
ObservableStageObserver.onSubscribe
(@NonNull Disposable d) void
void
void
protected void
FlowableCollectWithCollector.subscribeActual
(@NonNull org.reactivestreams.Subscriber<? super R> s) protected void
FlowableCollectWithCollectorSingle.subscribeActual
(@NonNull SingleObserver<? super R> observer) protected void
MaybeFlattenStreamAsFlowable.subscribeActual
(@NonNull org.reactivestreams.Subscriber<? super R> s) protected void
MaybeFlattenStreamAsObservable.subscribeActual
(@NonNull Observer<? super R> s) protected void
ObservableCollectWithCollector.subscribeActual
(@NonNull Observer<? super R> observer) protected void
ObservableCollectWithCollectorSingle.subscribeActual
(@NonNull SingleObserver<? super R> observer) protected void
SingleFlattenStreamAsFlowable.subscribeActual
(@NonNull org.reactivestreams.Subscriber<? super R> s) protected void
SingleFlattenStreamAsObservable.subscribeActual
(@NonNull Observer<? super R> s) -
Uses of NonNull in io.reactivex.rxjava3.internal.observers
Method parameters in io.reactivex.rxjava3.internal.observers with annotations of type NonNullModifier and TypeMethodDescriptionvoid
void
void
void
void
BlockingDisposableMultiObserver.onSubscribe
(@NonNull Disposable d) void
SafeCompletableObserver.onSubscribe
(@NonNull Disposable d) void
SafeMaybeObserver.onSubscribe
(@NonNull Disposable d) void
SafeSingleObserver.onSubscribe
(@NonNull Disposable d) void
void
void
-
Uses of NonNull in io.reactivex.rxjava3.internal.operators.flowable
Method parameters in io.reactivex.rxjava3.internal.operators.flowable with annotations of type NonNullModifier and TypeMethodDescriptionprotected void
FlowableOnBackpressureReduce.subscribeActual
(@NonNull org.reactivestreams.Subscriber<? super T> s) protected void
FlowableOnBackpressureReduceWith.subscribeActual
(@NonNull org.reactivestreams.Subscriber<? super R> s) Constructor parameters in io.reactivex.rxjava3.internal.operators.flowable with annotations of type NonNullModifierConstructorDescription(package private)
BackpressureReduceSubscriber
(@NonNull org.reactivestreams.Subscriber<? super T> downstream, @NonNull BiFunction<T, T, T> reducer) (package private)
BackpressureReduceSubscriber
(@NonNull org.reactivestreams.Subscriber<? super T> downstream, @NonNull BiFunction<T, T, T> reducer) (package private)
BackpressureReduceWithSubscriber
(@NonNull org.reactivestreams.Subscriber<? super R> downstream, @NonNull Supplier<R> supplier, @NonNull BiFunction<R, ? super T, R> reducer) (package private)
BackpressureReduceWithSubscriber
(@NonNull org.reactivestreams.Subscriber<? super R> downstream, @NonNull Supplier<R> supplier, @NonNull BiFunction<R, ? super T, R> reducer) (package private)
BackpressureReduceWithSubscriber
(@NonNull org.reactivestreams.Subscriber<? super R> downstream, @NonNull Supplier<R> supplier, @NonNull BiFunction<R, ? super T, R> reducer) FlowableCombineLatest
(@NonNull Iterable<? extends org.reactivestreams.Publisher<? extends T>> iterable, @NonNull Function<? super Object[], ? extends R> combiner, int bufferSize, boolean delayErrors) FlowableCombineLatest
(@NonNull Iterable<? extends org.reactivestreams.Publisher<? extends T>> iterable, @NonNull Function<? super Object[], ? extends R> combiner, int bufferSize, boolean delayErrors) FlowableCombineLatest
(@NonNull org.reactivestreams.Publisher<? extends T>[] array, @NonNull Function<? super Object[], ? extends R> combiner, int bufferSize, boolean delayErrors) FlowableCombineLatest
(@NonNull org.reactivestreams.Publisher<? extends T>[] array, @NonNull Function<? super Object[], ? extends R> combiner, int bufferSize, boolean delayErrors) FlowableOnBackpressureReduce
(@NonNull Flowable<T> source, @NonNull BiFunction<T, T, T> reducer) FlowableOnBackpressureReduce
(@NonNull Flowable<T> source, @NonNull BiFunction<T, T, T> reducer) FlowableOnBackpressureReduceWith
(@NonNull Flowable<T> source, @NonNull Supplier<R> supplier, @NonNull BiFunction<R, ? super T, R> reducer) FlowableOnBackpressureReduceWith
(@NonNull Flowable<T> source, @NonNull Supplier<R> supplier, @NonNull BiFunction<R, ? super T, R> reducer) FlowableOnBackpressureReduceWith
(@NonNull Flowable<T> source, @NonNull Supplier<R> supplier, @NonNull BiFunction<R, ? super T, R> reducer) FlowableWithLatestFromMany
(@NonNull Flowable<T> source, @NonNull Iterable<? extends org.reactivestreams.Publisher<?>> otherIterable, @NonNull Function<? super Object[], R> combiner) FlowableWithLatestFromMany
(@NonNull Flowable<T> source, @NonNull Iterable<? extends org.reactivestreams.Publisher<?>> otherIterable, @NonNull Function<? super Object[], R> combiner) FlowableWithLatestFromMany
(@NonNull Flowable<T> source, @NonNull Iterable<? extends org.reactivestreams.Publisher<?>> otherIterable, @NonNull Function<? super Object[], R> combiner) FlowableWithLatestFromMany
(@NonNull Flowable<T> source, @NonNull org.reactivestreams.Publisher<?>[] otherArray, Function<? super Object[], R> combiner) FlowableWithLatestFromMany
(@NonNull Flowable<T> source, @NonNull org.reactivestreams.Publisher<?>[] otherArray, Function<? super Object[], R> combiner) -
Uses of NonNull in io.reactivex.rxjava3.internal.operators.maybe
Method parameters in io.reactivex.rxjava3.internal.operators.maybe with annotations of type NonNullModifier and TypeMethodDescriptionvoid
void
void
MaybeDoOnLifecycle.MaybeLifecycleObserver.onSubscribe
(@NonNull Disposable d) void
MaybeTimeInterval.TimeIntervalMaybeObserver.onSubscribe
(@NonNull Disposable d) void
void
protected void
MaybeTimeInterval.subscribeActual
(@NonNull MaybeObserver<? super @NonNull Timed<T>> observer) -
Uses of NonNull in io.reactivex.rxjava3.internal.operators.observable
Fields in io.reactivex.rxjava3.internal.operators.observable with annotations of type NonNullConstructor parameters in io.reactivex.rxjava3.internal.operators.observable with annotations of type NonNullModifierConstructorDescriptionObservableWithLatestFromMany
(@NonNull ObservableSource<T> source, @NonNull ObservableSource<?>[] otherArray, @NonNull Function<? super Object[], R> combiner) ObservableWithLatestFromMany
(@NonNull ObservableSource<T> source, @NonNull ObservableSource<?>[] otherArray, @NonNull Function<? super Object[], R> combiner) ObservableWithLatestFromMany
(@NonNull ObservableSource<T> source, @NonNull ObservableSource<?>[] otherArray, @NonNull Function<? super Object[], R> combiner) ObservableWithLatestFromMany
(@NonNull ObservableSource<T> source, @NonNull Iterable<? extends ObservableSource<?>> otherIterable, @NonNull Function<? super Object[], R> combiner) ObservableWithLatestFromMany
(@NonNull ObservableSource<T> source, @NonNull Iterable<? extends ObservableSource<?>> otherIterable, @NonNull Function<? super Object[], R> combiner) ObservableWithLatestFromMany
(@NonNull ObservableSource<T> source, @NonNull Iterable<? extends ObservableSource<?>> otherIterable, @NonNull Function<? super Object[], R> combiner) -
Uses of NonNull in io.reactivex.rxjava3.internal.operators.single
Method parameters in io.reactivex.rxjava3.internal.operators.single with annotations of type NonNullModifier and TypeMethodDescriptionvoid
void
void
SingleDoOnLifecycle.SingleLifecycleObserver.onSubscribe
(@NonNull Disposable d) void
SingleTimeInterval.TimeIntervalSingleObserver.onSubscribe
(@NonNull Disposable d) void
void
protected void
SingleTimeInterval.subscribeActual
(@NonNull SingleObserver<? super @NonNull Timed<T>> observer) -
Uses of NonNull in io.reactivex.rxjava3.internal.schedulers
Fields in io.reactivex.rxjava3.internal.schedulers with annotations of type NonNullMethods in io.reactivex.rxjava3.internal.schedulers with annotations of type NonNullModifier and TypeMethodDescriptionComputationScheduler.createWorker()
ExecutorScheduler.createWorker()
ImmediateThinScheduler.createWorker()
IoScheduler.createWorker()
NewThreadScheduler.createWorker()
SchedulerWhen.createWorker()
SingleScheduler.createWorker()
TrampolineScheduler.createWorker()
ComputationScheduler.EventLoopWorker.schedule
(@NonNull Runnable action, long delayTime, @NonNull TimeUnit unit) ExecutorScheduler.ExecutorWorker.schedule
(@NonNull Runnable run, long delay, @NonNull TimeUnit unit) ImmediateThinScheduler.ImmediateThinWorker.schedule
(@NonNull Runnable run, long delay, @NonNull TimeUnit unit) IoScheduler.EventLoopWorker.schedule
(@NonNull Runnable action, long delayTime, @NonNull TimeUnit unit) SchedulerWhen.QueueWorker.schedule
(@NonNull Runnable action, long delayTime, @NonNull TimeUnit unit) TrampolineScheduler.TrampolineWorker.schedule
(@NonNull Runnable action, long delayTime, @NonNull TimeUnit unit) NewThreadWorker.scheduleActual
(Runnable run, long delayTime, @NonNull TimeUnit unit, @Nullable DisposableContainer parent) Wraps and returns the given runnable into a ScheduledRunnable and schedules it on the underlying ScheduledExecutorService.ComputationScheduler.scheduleDirect
(@NonNull Runnable run, long delay, TimeUnit unit) ExecutorScheduler.scheduleDirect
(@NonNull Runnable run) ExecutorScheduler.scheduleDirect
(@NonNull Runnable run, long delay, TimeUnit unit) ImmediateThinScheduler.scheduleDirect
(@NonNull Runnable run) ImmediateThinScheduler.scheduleDirect
(@NonNull Runnable run, long delay, TimeUnit unit) SingleScheduler.scheduleDirect
(@NonNull Runnable run, long delay, TimeUnit unit) TrampolineScheduler.scheduleDirect
(@NonNull Runnable run) TrampolineScheduler.scheduleDirect
(@NonNull Runnable run, long delay, TimeUnit unit) ImmediateThinScheduler.ImmediateThinWorker.schedulePeriodically
(@NonNull Runnable run, long initialDelay, long period, TimeUnit unit) ComputationScheduler.schedulePeriodicallyDirect
(@NonNull Runnable run, long initialDelay, long period, TimeUnit unit) ExecutorScheduler.schedulePeriodicallyDirect
(@NonNull Runnable run, long initialDelay, long period, TimeUnit unit) ImmediateThinScheduler.schedulePeriodicallyDirect
(@NonNull Runnable run, long initialDelay, long period, TimeUnit unit) SingleScheduler.schedulePeriodicallyDirect
(@NonNull Runnable run, long initialDelay, long period, TimeUnit unit) Method parameters in io.reactivex.rxjava3.internal.schedulers with annotations of type NonNullModifier and TypeMethodDescriptionvoid
SchedulerMultiWorkerSupport.createWorkers
(int number, @NonNull SchedulerMultiWorkerSupport.WorkerCallback callback) Creates the given number ofScheduler.Worker
instances that are possibly backed by distinct threads and calls the specifiedConsumer
with them.void
SchedulerMultiWorkerSupport.WorkerCallback.onWorker
(int index, Scheduler.Worker worker) Called with the Worker index and instance.ComputationScheduler.EventLoopWorker.schedule
(@NonNull Runnable action, long delayTime, @NonNull TimeUnit unit) ComputationScheduler.EventLoopWorker.schedule
(@NonNull Runnable action, long delayTime, @NonNull TimeUnit unit) ExecutorScheduler.ExecutorWorker.schedule
(@NonNull Runnable run, long delay, @NonNull TimeUnit unit) ExecutorScheduler.ExecutorWorker.schedule
(@NonNull Runnable run, long delay, @NonNull TimeUnit unit) ImmediateThinScheduler.ImmediateThinWorker.schedule
(@NonNull Runnable run, long delay, @NonNull TimeUnit unit) ImmediateThinScheduler.ImmediateThinWorker.schedule
(@NonNull Runnable run, long delay, @NonNull TimeUnit unit) IoScheduler.EventLoopWorker.schedule
(@NonNull Runnable action, long delayTime, @NonNull TimeUnit unit) IoScheduler.EventLoopWorker.schedule
(@NonNull Runnable action, long delayTime, @NonNull TimeUnit unit) SchedulerWhen.QueueWorker.schedule
(@NonNull Runnable action, long delayTime, @NonNull TimeUnit unit) SchedulerWhen.QueueWorker.schedule
(@NonNull Runnable action, long delayTime, @NonNull TimeUnit unit) TrampolineScheduler.TrampolineWorker.schedule
(@NonNull Runnable action, long delayTime, @NonNull TimeUnit unit) TrampolineScheduler.TrampolineWorker.schedule
(@NonNull Runnable action, long delayTime, @NonNull TimeUnit unit) NewThreadWorker.scheduleActual
(Runnable run, long delayTime, @NonNull TimeUnit unit, @Nullable DisposableContainer parent) Wraps and returns the given runnable into a ScheduledRunnable and schedules it on the underlying ScheduledExecutorService.ComputationScheduler.scheduleDirect
(@NonNull Runnable run, long delay, TimeUnit unit) ExecutorScheduler.scheduleDirect
(@NonNull Runnable run) ExecutorScheduler.scheduleDirect
(@NonNull Runnable run, long delay, TimeUnit unit) ImmediateThinScheduler.scheduleDirect
(@NonNull Runnable run) ImmediateThinScheduler.scheduleDirect
(@NonNull Runnable run, long delay, TimeUnit unit) SingleScheduler.scheduleDirect
(@NonNull Runnable run, long delay, TimeUnit unit) TrampolineScheduler.scheduleDirect
(@NonNull Runnable run) TrampolineScheduler.scheduleDirect
(@NonNull Runnable run, long delay, TimeUnit unit) ImmediateThinScheduler.ImmediateThinWorker.schedulePeriodically
(@NonNull Runnable run, long initialDelay, long period, TimeUnit unit) ComputationScheduler.schedulePeriodicallyDirect
(@NonNull Runnable run, long initialDelay, long period, TimeUnit unit) ExecutorScheduler.schedulePeriodicallyDirect
(@NonNull Runnable run, long initialDelay, long period, TimeUnit unit) ImmediateThinScheduler.schedulePeriodicallyDirect
(@NonNull Runnable run, long initialDelay, long period, TimeUnit unit) SingleScheduler.schedulePeriodicallyDirect
(@NonNull Runnable run, long initialDelay, long period, TimeUnit unit) Constructor parameters in io.reactivex.rxjava3.internal.schedulers with annotations of type NonNullModifierConstructorDescriptionExecutorScheduler
(@NonNull Executor executor, boolean interruptibleWorker, boolean fair) -
Uses of NonNull in io.reactivex.rxjava3.internal.subscribers
Method parameters in io.reactivex.rxjava3.internal.subscribers with annotations of type NonNull -
Uses of NonNull in io.reactivex.rxjava3.internal.util
Method parameters in io.reactivex.rxjava3.internal.util with annotations of type NonNullModifier and TypeMethodDescriptionstatic long
BackpressureHelper.add
(@NonNull AtomicLong requested, long n) Atomically adds the positive value n to the requested value in theAtomicLong
and caps the result atLong.MAX_VALUE
and returns the previous value.boolean
VolatileSizeArrayList.addAll
(int index, @NonNull Collection<? extends T> c) boolean
VolatileSizeArrayList.addAll
(@NonNull Collection<? extends T> c) static long
BackpressureHelper.addCancel
(@NonNull AtomicLong requested, long n) Atomically adds the positive value n to the requested value in theAtomicLong
and caps the result atLong.MAX_VALUE
and returns the previous value and considersLong.MIN_VALUE
as a cancel indication (no addition then).boolean
VolatileSizeArrayList.containsAll
(@NonNull Collection<?> c) static long
BackpressureHelper.produced
(@NonNull AtomicLong requested, long n) Atomically subtract the given number (positive, not validated) from the target field unless it containsLong.MAX_VALUE
.static long
BackpressureHelper.producedCancel
(@NonNull AtomicLong requested, long n) Atomically subtract the given number (positive, not validated) from the target field if it doesn't containLong.MIN_VALUE
(indicating some cancelled state) orLong.MAX_VALUE
(unbounded mode).boolean
VolatileSizeArrayList.removeAll
(@NonNull Collection<?> c) boolean
VolatileSizeArrayList.retainAll
(@NonNull Collection<?> c) <E> E[]
VolatileSizeArrayList.toArray
(E[] a) -
Uses of NonNull in io.reactivex.rxjava3.observables
Methods in io.reactivex.rxjava3.observables with annotations of type NonNullModifier and TypeMethodDescriptionConnectableObservable.autoConnect()
Returns anObservable
that automatically connects (at most once) to thisConnectableObservable
when the firstObserver
subscribes.ConnectableObservable.autoConnect
(int numberOfObservers) Returns anObservable
that automatically connects (at most once) to thisConnectableObservable
when the specified number ofObserver
s subscribe to it.ConnectableObservable.autoConnect
(int numberOfObservers, @NonNull Consumer<? super Disposable> connection) Returns anObservable
that automatically connects (at most once) to thisConnectableObservable
when the specified number ofObserver
s subscribe to it and calls the specified callback with theDisposable
associated with the established connection.final @NonNull Disposable
ConnectableObservable.connect()
Instructs theConnectableObservable
to begin emitting the items from its underlyingObservable
to itsObserver
s.ConnectableObservable.refCount()
Returns anObservable
that stays connected to thisConnectableObservable
as long as there is at least one subscription to thisConnectableObservable
.final @NonNull Observable
<T> ConnectableObservable.refCount
(int observerCount) Connects to the upstreamConnectableObservable
if the number of subscribed observers reaches the specified count and disconnect if allObserver
s have unsubscribed.final @NonNull Observable
<T> Connects to the upstreamConnectableObservable
if the number of subscribed observers reaches the specified count and disconnect after the specified timeout if allObserver
s have unsubscribed.final @NonNull Observable
<T> ConnectableObservable.refCount
(int observerCount, long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Connects to the upstreamConnectableObservable
if the number of subscribed observers reaches the specified count and disconnect after the specified timeout if allObserver
s have unsubscribed.final @NonNull Observable
<T> Connects to the upstreamConnectableObservable
if the number of subscribed observers reaches 1 and disconnect after the specified timeout if allObserver
s have unsubscribed.final @NonNull Observable
<T> Connects to the upstreamConnectableObservable
if the number of subscribed observers reaches 1 and disconnect after the specified timeout if allObserver
s have unsubscribed.Method parameters in io.reactivex.rxjava3.observables with annotations of type NonNullModifier and TypeMethodDescriptionConnectableObservable.autoConnect
(int numberOfObservers, @NonNull Consumer<? super Disposable> connection) Returns anObservable
that automatically connects (at most once) to thisConnectableObservable
when the specified number ofObserver
s subscribe to it and calls the specified callback with theDisposable
associated with the established connection.abstract void
ConnectableObservable.connect
(@NonNull Consumer<? super Disposable> connection) Instructs theConnectableObservable
to begin emitting the items from its underlyingObservable
to itsObserver
s.final @NonNull Observable
<T> Connects to the upstreamConnectableObservable
if the number of subscribed observers reaches the specified count and disconnect after the specified timeout if allObserver
s have unsubscribed.final @NonNull Observable
<T> ConnectableObservable.refCount
(int observerCount, long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Connects to the upstreamConnectableObservable
if the number of subscribed observers reaches the specified count and disconnect after the specified timeout if allObserver
s have unsubscribed.final @NonNull Observable
<T> ConnectableObservable.refCount
(int observerCount, long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Connects to the upstreamConnectableObservable
if the number of subscribed observers reaches the specified count and disconnect after the specified timeout if allObserver
s have unsubscribed.final @NonNull Observable
<T> Connects to the upstreamConnectableObservable
if the number of subscribed observers reaches 1 and disconnect after the specified timeout if allObserver
s have unsubscribed.final @NonNull Observable
<T> Connects to the upstreamConnectableObservable
if the number of subscribed observers reaches 1 and disconnect after the specified timeout if allObserver
s have unsubscribed.final @NonNull Observable
<T> Connects to the upstreamConnectableObservable
if the number of subscribed observers reaches 1 and disconnect after the specified timeout if allObserver
s have unsubscribed. -
Uses of NonNull in io.reactivex.rxjava3.observers
Methods in io.reactivex.rxjava3.observers with annotations of type NonNullModifier and TypeMethodDescriptionfinal U
BaseTestConsumer.assertComplete()
Assert that thisTestObserver
/TestSubscriber
received exactly oneonComplete
event.final U
BaseTestConsumer.assertEmpty()
Assert that theTestObserver
/TestSubscriber
has received aDisposable
/Subscription
viaonSubscribe
but no other events.final U
BaseTestConsumer.assertError
(@NonNull Predicate<Throwable> errorPredicate) Asserts that thisTestObserver
/TestSubscriber
received exactly oneonError
event for which the provided predicate returnstrue
.private U
BaseTestConsumer.assertError
(@NonNull Predicate<Throwable> errorPredicate, boolean exact) final U
BaseTestConsumer.assertError
(@NonNull Class<? extends Throwable> errorClass) Asserts that thisTestObserver
/TestSubscriber
received exactly oneonError
event which is an instance of the specifiederrorClass
Class
.final U
BaseTestConsumer.assertError
(@NonNull Throwable error) Assert that thisTestObserver
/TestSubscriber
received exactly the specifiedonError
event value.final U
BaseTestConsumer.assertFailure
(@NonNull Class<? extends Throwable> error, T... values) Assert that the upstream signaled the specified values in order and then failed with a specific class or subclass ofThrowable
.final U
BaseTestConsumer.assertNoErrors()
Assert that thisTestObserver
/TestSubscriber
has not received anonError
event.final U
BaseTestConsumer.assertNotComplete()
Assert that thisTestObserver
/TestSubscriber
has not received anonComplete
event.final U
BaseTestConsumer.assertNoValues()
Assert that thisTestObserver
/TestSubscriber
has not received anyonNext
events.final U
BaseTestConsumer.assertResult
(T... values) Assert that the upstream signaled the specified values in order and completed normally.protected abstract U
BaseTestConsumer.assertSubscribed()
Assert that theonSubscribe
method was called exactly once.protected final @NonNull TestObserver
<T> TestObserver.assertSubscribed()
Assert that theTestObserver.onSubscribe(Disposable)
method was called exactly once.final U
BaseTestConsumer.assertValue
(@NonNull Predicate<T> valuePredicate) Asserts that thisTestObserver
/TestSubscriber
received exactly oneonNext
value for which the provided predicate returnstrue
.final U
BaseTestConsumer.assertValue
(T value) Assert that thisTestObserver
/TestSubscriber
received exactly oneonNext
value which is equal to the given value with respect toObjects.equals(Object, Object)
.final U
BaseTestConsumer.assertValueAt
(int index, @NonNull Predicate<T> valuePredicate) Asserts that thisTestObserver
/TestSubscriber
received anonNext
value at the given index for the provided predicate returnstrue
.final U
BaseTestConsumer.assertValueAt
(int index, T value) Asserts that thisTestObserver
/TestSubscriber
received anonNext
value at the given index which is equal to the given value with respect tonull
-safeObjects.equals(Object, Object)
.final U
BaseTestConsumer.assertValueCount
(int count) Assert that thisTestObserver
/TestSubscriber
received the specified numberonNext
events.final U
BaseTestConsumer.assertValues
(T... values) Assert that theTestObserver
/TestSubscriber
received only the specified values in the specified order.final U
BaseTestConsumer.assertValueSequence
(@NonNull Iterable<? extends T> sequence) Assert that theTestObserver
/TestSubscriber
received only the specified sequence of values in the same order.final U
BaseTestConsumer.assertValuesOnly
(T... values) Assert that theTestObserver
/TestSubscriber
received only the specified values in the specified order without terminating.final U
BaseTestConsumer.await()
Awaits until thisTestObserver
/TestSubscriber
receives anonError
oronComplete
events.final U
BaseTestConsumer.awaitCount
(int atLeast) Await until theTestObserver
/TestSubscriber
receives the given number of items or terminates by sleeping 10 milliseconds at a time up to 5000 milliseconds of timeout.final U
Awaits until the internal latch is counted down.static <T> @NonNull TestObserver
<T> TestObserver.create()
Constructs a non-forwardingTestObserver
.static <T> @NonNull TestObserver
<T> Constructs a forwardingTestObserver
.protected final @NonNull AssertionError
Fail with the given message and add the sequence of errors as suppressed ones.BaseTestConsumer.valueAndClass
(@Nullable Object o) Appends the class name to a non-null
value or returns"null"
.BaseTestConsumer.values()
Returns a shared list of receivedonNext
values or the singleonSuccess
value.final U
BaseTestConsumer.withTag
(@Nullable CharSequence tag) Set the tag displayed along with an assertion failure's other state information.Method parameters in io.reactivex.rxjava3.observers with annotations of type NonNullModifier and TypeMethodDescriptionfinal void
ResourceCompletableObserver.add
(@NonNull Disposable resource) Adds a resource to thisResourceCompletableObserver
.final void
ResourceMaybeObserver.add
(@NonNull Disposable resource) Adds a resource to thisResourceMaybeObserver
.final void
ResourceObserver.add
(@NonNull Disposable resource) Adds a resource to thisResourceObserver
.final void
ResourceSingleObserver.add
(@NonNull Disposable resource) Adds a resource to thisResourceSingleObserver
.final U
BaseTestConsumer.assertError
(@NonNull Predicate<Throwable> errorPredicate) Asserts that thisTestObserver
/TestSubscriber
received exactly oneonError
event for which the provided predicate returnstrue
.private U
BaseTestConsumer.assertError
(@NonNull Predicate<Throwable> errorPredicate, boolean exact) final U
BaseTestConsumer.assertError
(@NonNull Class<? extends Throwable> errorClass) Asserts that thisTestObserver
/TestSubscriber
received exactly oneonError
event which is an instance of the specifiederrorClass
Class
.final U
BaseTestConsumer.assertError
(@NonNull Throwable error) Assert that thisTestObserver
/TestSubscriber
received exactly the specifiedonError
event value.final U
BaseTestConsumer.assertFailure
(@NonNull Class<? extends Throwable> error, T... values) Assert that the upstream signaled the specified values in order and then failed with a specific class or subclass ofThrowable
.final U
BaseTestConsumer.assertFailure
(@NonNull Class<? extends Throwable> error, T... values) Assert that the upstream signaled the specified values in order and then failed with a specific class or subclass ofThrowable
.final U
BaseTestConsumer.assertResult
(T... values) Assert that the upstream signaled the specified values in order and completed normally.final U
BaseTestConsumer.assertValue
(@NonNull Predicate<T> valuePredicate) Asserts that thisTestObserver
/TestSubscriber
received exactly oneonNext
value for which the provided predicate returnstrue
.final U
BaseTestConsumer.assertValue
(T value) Assert that thisTestObserver
/TestSubscriber
received exactly oneonNext
value which is equal to the given value with respect toObjects.equals(Object, Object)
.final U
BaseTestConsumer.assertValueAt
(int index, @NonNull Predicate<T> valuePredicate) Asserts that thisTestObserver
/TestSubscriber
received anonNext
value at the given index for the provided predicate returnstrue
.final U
BaseTestConsumer.assertValueAt
(int index, T value) Asserts that thisTestObserver
/TestSubscriber
received anonNext
value at the given index which is equal to the given value with respect tonull
-safeObjects.equals(Object, Object)
.final U
BaseTestConsumer.assertValues
(T... values) Assert that theTestObserver
/TestSubscriber
received only the specified values in the specified order.final U
BaseTestConsumer.assertValueSequence
(@NonNull Iterable<? extends T> sequence) Assert that theTestObserver
/TestSubscriber
received only the specified sequence of values in the same order.final U
BaseTestConsumer.assertValuesOnly
(T... values) Assert that theTestObserver
/TestSubscriber
received only the specified values in the specified order without terminating.final boolean
Awaits the specified amount of time or until thisTestObserver
/TestSubscriber
receives anonError
oronComplete
events, whichever happens first.final U
Awaits until the internal latch is counted down.static <T> @NonNull TestObserver
<T> Constructs a forwardingTestObserver
.protected final @NonNull AssertionError
Fail with the given message and add the sequence of errors as suppressed ones.void
void
void
void
void
void
final void
DefaultObserver.onSubscribe
(@NonNull Disposable d) final void
DisposableCompletableObserver.onSubscribe
(@NonNull Disposable d) final void
DisposableMaybeObserver.onSubscribe
(@NonNull Disposable d) final void
DisposableObserver.onSubscribe
(@NonNull Disposable d) final void
DisposableSingleObserver.onSubscribe
(@NonNull Disposable d) final void
ResourceCompletableObserver.onSubscribe
(@NonNull Disposable d) final void
ResourceMaybeObserver.onSubscribe
(@NonNull Disposable d) final void
ResourceSingleObserver.onSubscribe
(@NonNull Disposable d) void
SafeObserver.onSubscribe
(@NonNull Disposable d) void
SerializedObserver.onSubscribe
(@NonNull Disposable d) void
TestObserver.onSubscribe
(@NonNull Disposable d) void
Constructor parameters in io.reactivex.rxjava3.observers with annotations of type NonNullModifierConstructorDescriptionSafeObserver
(@NonNull Observer<? super T> downstream) Constructs aSafeObserver
by wrapping the given actualObserver
.SerializedObserver
(@NonNull Observer<? super T> downstream) Construct aSerializedObserver
by wrapping the given actualObserver
.SerializedObserver
(@NonNull Observer<? super T> actual, boolean delayError) Construct a SerializedObserver by wrapping the given actualObserver
and optionally delaying the errors till all regular values have been emitted from the internal buffer.TestObserver
(@NonNull Observer<? super T> downstream) Constructs a forwardingTestObserver
. -
Uses of NonNull in io.reactivex.rxjava3.operators
Method parameters in io.reactivex.rxjava3.operators with annotations of type NonNullModifier and TypeMethodDescriptionboolean
Atomically enqueue a single value.boolean
Atomically enqueue two values.boolean
Atomically enqueue two values.boolean
Conditionally takes the value. -
Uses of NonNull in io.reactivex.rxjava3.parallel
Methods in io.reactivex.rxjava3.parallel with annotations of type NonNullModifier and TypeMethodDescriptionParallelFlowableConverter.apply
(@NonNull ParallelFlowable<T> upstream) Applies a function to the upstream ParallelFlowable and returns a converted value of typeR
.ParallelTransformer.apply
(@NonNull ParallelFlowable<@NonNull Upstream> upstream) Applies a function to the upstream ParallelFlowable and returns a ParallelFlowable with optionally different element type.final <@NonNull C>
@NonNull ParallelFlowable<C> ParallelFlowable.collect
(@NonNull Supplier<? extends @NonNull C> collectionSupplier, @NonNull BiConsumer<? super @NonNull C, ? super @NonNull T> collector) Collect the elements in each rail into a collection supplied via acollectionSupplier
and collected into with a collector action, emitting the collection at the end.final <@NonNull U>
@NonNull ParallelFlowable<U> Allows composing operators, in assembly time, on top of thisParallelFlowable
and returns anotherParallelFlowable
with composed features.final <@NonNull R>
@NonNull ParallelFlowable<R> ParallelFlowable.concatMap
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper) Generates and concatenatesPublisher
s on each 'rail', signalling errors immediately and generating 2 publishers upfront.final <@NonNull R>
@NonNull ParallelFlowable<R> ParallelFlowable.concatMap
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper, int prefetch) Generates and concatenatesPublisher
s on each 'rail', signalling errors immediately and using the given prefetch amount for generatingPublisher
s upfront.final <@NonNull R>
@NonNull ParallelFlowable<R> ParallelFlowable.concatMapDelayError
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper, boolean tillTheEnd) Generates and concatenatesPublisher
s on each 'rail', optionally delaying errors and generating 2 publishers upfront.final <@NonNull R>
@NonNull ParallelFlowable<R> ParallelFlowable.concatMapDelayError
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper, int prefetch, boolean tillTheEnd) Generates and concatenatesPublisher
s on each 'rail', optionally delaying errors and using the given prefetch amount for generatingPublisher
s upfront.final @NonNull ParallelFlowable
<T> ParallelFlowable.doAfterNext
(@NonNull Consumer<? super @NonNull T> onAfterNext) Call the specified consumer with the current element passing through any 'rail' after it has been delivered to downstream within the rail.final @NonNull ParallelFlowable
<T> ParallelFlowable.doAfterTerminated
(@NonNull Action onAfterTerminate) Run the specifiedAction
when a 'rail' completes or signals an error.final @NonNull ParallelFlowable
<T> ParallelFlowable.doOnCancel
(@NonNull Action onCancel) Run the specifiedAction
when a 'rail' receives a cancellation.final @NonNull ParallelFlowable
<T> ParallelFlowable.doOnComplete
(@NonNull Action onComplete) Run the specifiedAction
when a 'rail' completes.final @NonNull ParallelFlowable
<T> Call the specified consumer with the exception passing through any 'rail'.final @NonNull ParallelFlowable
<T> Call the specified consumer with the current element passing through any 'rail'.final @NonNull ParallelFlowable
<T> ParallelFlowable.doOnNext
(@NonNull Consumer<? super @NonNull T> onNext, @NonNull BiFunction<? super Long, ? super Throwable, ParallelFailureHandling> errorHandler) Call the specified consumer with the current element passing through any 'rail' and handles errors based on the returned value by the handler function.final @NonNull ParallelFlowable
<T> ParallelFlowable.doOnNext
(@NonNull Consumer<? super @NonNull T> onNext, @NonNull ParallelFailureHandling errorHandler) Call the specified consumer with the current element passing through any 'rail' and handles errors based on the givenParallelFailureHandling
enumeration value.final @NonNull ParallelFlowable
<T> ParallelFlowable.doOnRequest
(@NonNull LongConsumer onRequest) Call the specified consumer with the request amount if any rail receives a request.final @NonNull ParallelFlowable
<T> ParallelFlowable.doOnSubscribe
(@NonNull Consumer<? super org.reactivestreams.Subscription> onSubscribe) Call the specified callback when a 'rail' receives aSubscription
from its upstream.final @NonNull ParallelFlowable
<T> Filters the source values on each 'rail'.final @NonNull ParallelFlowable
<T> ParallelFlowable.filter
(@NonNull Predicate<? super @NonNull T> predicate, @NonNull BiFunction<? super Long, ? super Throwable, ParallelFailureHandling> errorHandler) Filters the source values on each 'rail' and handles errors based on the returned value by the handler function.final @NonNull ParallelFlowable
<T> ParallelFlowable.filter
(@NonNull Predicate<? super @NonNull T> predicate, @NonNull ParallelFailureHandling errorHandler) Filters the source values on each 'rail' and handles errors based on the givenParallelFailureHandling
enumeration value.final <@NonNull R>
@NonNull ParallelFlowable<R> ParallelFlowable.flatMap
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper) Generates and flattensPublisher
s on each 'rail'.final <@NonNull R>
@NonNull ParallelFlowable<R> ParallelFlowable.flatMap
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper, boolean delayError) Generates and flattensPublisher
s on each 'rail', optionally delaying errors.final <@NonNull R>
@NonNull ParallelFlowable<R> ParallelFlowable.flatMap
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper, boolean delayError, int maxConcurrency) Generates and flattensPublisher
s on each 'rail', optionally delaying errors and having a total number of simultaneous subscriptions to the innerPublisher
s.final <@NonNull R>
@NonNull ParallelFlowable<R> ParallelFlowable.flatMap
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper, boolean delayError, int maxConcurrency, int prefetch) Generates and flattensPublisher
s on each 'rail', optionally delaying errors, having a total number of simultaneous subscriptions to the innerPublisher
s and using the given prefetch amount for the innerPublisher
s.final <@NonNull U>
@NonNull ParallelFlowable<U> ParallelFlowable.flatMapIterable
(@NonNull Function<? super @NonNull T, @NonNull ? extends Iterable<? extends @NonNull U>> mapper) Returns aParallelFlowable
that merges each item emitted by the source on each rail with the values in anIterable
corresponding to that item that is generated by a selector.final <@NonNull U>
@NonNull ParallelFlowable<U> ParallelFlowable.flatMapIterable
(@NonNull Function<? super @NonNull T, @NonNull ? extends Iterable<? extends @NonNull U>> mapper, int bufferSize) Returns aParallelFlowable
that merges each item emitted by the sourceParallelFlowable
with the values in anIterable
corresponding to that item that is generated by a selector.final <@NonNull R>
@NonNull ParallelFlowable<R> ParallelFlowable.flatMapStream
(@NonNull Function<? super @NonNull T, @NonNull ? extends Stream<? extends @NonNull R>> mapper) Maps each upstream item on each rail into aStream
and emits theStream
's items to the downstream in a sequential fashion.final <@NonNull R>
@NonNull ParallelFlowable<R> ParallelFlowable.flatMapStream
(@NonNull Function<? super @NonNull T, @NonNull ? extends Stream<? extends @NonNull R>> mapper, int prefetch) Maps each upstream item of each rail into aStream
and emits theStream
's items to the downstream in a sequential fashion.static <@NonNull T>
@NonNull ParallelFlowable<T> Take aPublisher
and prepare to consume it on multiple 'rails' (number of CPUs) in a round-robin fashion.static <@NonNull T>
@NonNull ParallelFlowable<T> ParallelFlowable.from
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T> source, int parallelism) Take aPublisher
and prepare to consume it on parallelism number of 'rails' in a round-robin fashion.static <@NonNull T>
@NonNull ParallelFlowable<T> ParallelFlowable.from
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T> source, int parallelism, int prefetch) Take aPublisher
and prepare to consume it on parallelism number of 'rails' , possibly ordered and round-robin fashion and use custom prefetch amount and queue for dealing with the sourcePublisher
's values.static <@NonNull T>
@NonNull ParallelFlowable<T> Wraps multiplePublisher
s into aParallelFlowable
which runs them in parallel and unordered.final <@NonNull R>
@NonNull ParallelFlowable<R> Maps the source values on each 'rail' to another value.final <@NonNull R>
@NonNull ParallelFlowable<R> ParallelFlowable.map
(@NonNull Function<? super @NonNull T, ? extends @NonNull R> mapper, @NonNull BiFunction<? super Long, ? super Throwable, ParallelFailureHandling> errorHandler) Maps the source values on each 'rail' to another value and handles errors based on the returned value by the handler function.final <@NonNull R>
@NonNull ParallelFlowable<R> ParallelFlowable.map
(@NonNull Function<? super @NonNull T, ? extends @NonNull R> mapper, @NonNull ParallelFailureHandling errorHandler) Maps the source values on each 'rail' to another value and handles errors based on the givenParallelFailureHandling
enumeration value.final <@NonNull R>
@NonNull ParallelFlowable<R> ParallelFlowable.mapOptional
(@NonNull Function<? super @NonNull T, @NonNull Optional<? extends @NonNull R>> mapper) Maps the source values on each 'rail' to an optional and emits its value if any.final <@NonNull R>
@NonNull ParallelFlowable<R> ParallelFlowable.mapOptional
(@NonNull Function<? super @NonNull T, @NonNull Optional<? extends @NonNull R>> mapper, @NonNull BiFunction<? super Long, ? super Throwable, ParallelFailureHandling> errorHandler) Maps the source values on each 'rail' to an optional and emits its value if any and handles errors based on the returned value by the handler function.final <@NonNull R>
@NonNull ParallelFlowable<R> ParallelFlowable.mapOptional
(@NonNull Function<? super @NonNull T, @NonNull Optional<? extends @NonNull R>> mapper, @NonNull ParallelFailureHandling errorHandler) Maps the source values on each 'rail' to an optional and emits its value if any and handles errors based on the givenParallelFailureHandling
enumeration value.Reduces all values within a 'rail' and across 'rails' with a reducer function into oneFlowable
sequence.final <@NonNull R>
@NonNull ParallelFlowable<R> ParallelFlowable.reduce
(@NonNull Supplier<@NonNull R> initialSupplier, @NonNull BiFunction<@NonNull R, ? super @NonNull T, @NonNull R> reducer) Reduces all values within a 'rail' to a single value (with a possibly different type) via a reducer function that is initialized on each rail from aninitialSupplier
value.final @NonNull ParallelFlowable
<T> Specifies where each 'rail' will observe its incoming values, specified via aScheduler
, with no work-stealing and default prefetch amount.final @NonNull ParallelFlowable
<T> Specifies where each 'rail' will observe its incoming values, specified via aScheduler
, with possibly work-stealing and a given prefetch amount.ParallelFlowable.sequential()
Merges the values from each 'rail' in a round-robin or same-order fashion and exposes it as a regularFlowable
sequence, running with a default prefetch value for the rails.ParallelFlowable.sequential
(int prefetch) Merges the values from each 'rail' in a round-robin or same-order fashion and exposes it as a regularFlowable
sequence, running with a give prefetch value for the rails.ParallelFlowable.sequentialDelayError()
Merges the values from each 'rail' in a round-robin or same-order fashion and exposes it as a regularFlowable
sequence, running with a default prefetch value for the rails and delaying errors from all rails till all terminate.ParallelFlowable.sequentialDelayError
(int prefetch) Merges the values from each 'rail' in a round-robin or same-order fashion and exposes it as a regularFlowable
sequence, running with a give prefetch value for the rails and delaying errors from all rails till all terminate.ParallelFlowable.sorted
(@NonNull Comparator<? super @NonNull T> comparator) Sorts the 'rails' of thisParallelFlowable
and returns aFlowable
that sequentially picks the smallest next value from the rails.ParallelFlowable.sorted
(@NonNull Comparator<? super @NonNull T> comparator, int capacityHint) Sorts the 'rails' of thisParallelFlowable
and returns aFlowable
that sequentially picks the smallest next value from the rails.final <@NonNull R>
RCalls the specified converter function during assembly time and returns its resulting value.ParallelFlowable.toSortedList
(@NonNull Comparator<? super @NonNull T> comparator) ParallelFlowable.toSortedList
(@NonNull Comparator<? super @NonNull T> comparator, int capacityHint) Method parameters in io.reactivex.rxjava3.parallel with annotations of type NonNullModifier and TypeMethodDescriptionParallelFlowableConverter.apply
(@NonNull ParallelFlowable<T> upstream) Applies a function to the upstream ParallelFlowable and returns a converted value of typeR
.ParallelTransformer.apply
(@NonNull ParallelFlowable<@NonNull Upstream> upstream) Applies a function to the upstream ParallelFlowable and returns a ParallelFlowable with optionally different element type.final <@NonNull C>
@NonNull ParallelFlowable<C> ParallelFlowable.collect
(@NonNull Supplier<? extends @NonNull C> collectionSupplier, @NonNull BiConsumer<? super @NonNull C, ? super @NonNull T> collector) Collect the elements in each rail into a collection supplied via acollectionSupplier
and collected into with a collector action, emitting the collection at the end.final <@NonNull C>
@NonNull ParallelFlowable<C> ParallelFlowable.collect
(@NonNull Supplier<? extends @NonNull C> collectionSupplier, @NonNull BiConsumer<? super @NonNull C, ? super @NonNull T> collector) Collect the elements in each rail into a collection supplied via acollectionSupplier
and collected into with a collector action, emitting the collection at the end.final <@NonNull U>
@NonNull ParallelFlowable<U> Allows composing operators, in assembly time, on top of thisParallelFlowable
and returns anotherParallelFlowable
with composed features.final <@NonNull R>
@NonNull ParallelFlowable<R> ParallelFlowable.concatMap
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper) Generates and concatenatesPublisher
s on each 'rail', signalling errors immediately and generating 2 publishers upfront.final <@NonNull R>
@NonNull ParallelFlowable<R> ParallelFlowable.concatMap
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper, int prefetch) Generates and concatenatesPublisher
s on each 'rail', signalling errors immediately and using the given prefetch amount for generatingPublisher
s upfront.final <@NonNull R>
@NonNull ParallelFlowable<R> ParallelFlowable.concatMapDelayError
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper, boolean tillTheEnd) Generates and concatenatesPublisher
s on each 'rail', optionally delaying errors and generating 2 publishers upfront.final <@NonNull R>
@NonNull ParallelFlowable<R> ParallelFlowable.concatMapDelayError
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper, int prefetch, boolean tillTheEnd) Generates and concatenatesPublisher
s on each 'rail', optionally delaying errors and using the given prefetch amount for generatingPublisher
s upfront.final @NonNull ParallelFlowable
<T> ParallelFlowable.doAfterNext
(@NonNull Consumer<? super @NonNull T> onAfterNext) Call the specified consumer with the current element passing through any 'rail' after it has been delivered to downstream within the rail.final @NonNull ParallelFlowable
<T> ParallelFlowable.doAfterTerminated
(@NonNull Action onAfterTerminate) Run the specifiedAction
when a 'rail' completes or signals an error.final @NonNull ParallelFlowable
<T> ParallelFlowable.doOnCancel
(@NonNull Action onCancel) Run the specifiedAction
when a 'rail' receives a cancellation.final @NonNull ParallelFlowable
<T> ParallelFlowable.doOnComplete
(@NonNull Action onComplete) Run the specifiedAction
when a 'rail' completes.final @NonNull ParallelFlowable
<T> Call the specified consumer with the exception passing through any 'rail'.final @NonNull ParallelFlowable
<T> Call the specified consumer with the current element passing through any 'rail'.final @NonNull ParallelFlowable
<T> ParallelFlowable.doOnNext
(@NonNull Consumer<? super @NonNull T> onNext, @NonNull BiFunction<? super Long, ? super Throwable, ParallelFailureHandling> errorHandler) Call the specified consumer with the current element passing through any 'rail' and handles errors based on the returned value by the handler function.final @NonNull ParallelFlowable
<T> ParallelFlowable.doOnNext
(@NonNull Consumer<? super @NonNull T> onNext, @NonNull BiFunction<? super Long, ? super Throwable, ParallelFailureHandling> errorHandler) Call the specified consumer with the current element passing through any 'rail' and handles errors based on the returned value by the handler function.final @NonNull ParallelFlowable
<T> ParallelFlowable.doOnNext
(@NonNull Consumer<? super @NonNull T> onNext, @NonNull ParallelFailureHandling errorHandler) Call the specified consumer with the current element passing through any 'rail' and handles errors based on the givenParallelFailureHandling
enumeration value.final @NonNull ParallelFlowable
<T> ParallelFlowable.doOnNext
(@NonNull Consumer<? super @NonNull T> onNext, @NonNull ParallelFailureHandling errorHandler) Call the specified consumer with the current element passing through any 'rail' and handles errors based on the givenParallelFailureHandling
enumeration value.final @NonNull ParallelFlowable
<T> ParallelFlowable.doOnRequest
(@NonNull LongConsumer onRequest) Call the specified consumer with the request amount if any rail receives a request.final @NonNull ParallelFlowable
<T> ParallelFlowable.doOnSubscribe
(@NonNull Consumer<? super org.reactivestreams.Subscription> onSubscribe) Call the specified callback when a 'rail' receives aSubscription
from its upstream.final @NonNull ParallelFlowable
<T> Filters the source values on each 'rail'.final @NonNull ParallelFlowable
<T> ParallelFlowable.filter
(@NonNull Predicate<? super @NonNull T> predicate, @NonNull BiFunction<? super Long, ? super Throwable, ParallelFailureHandling> errorHandler) Filters the source values on each 'rail' and handles errors based on the returned value by the handler function.final @NonNull ParallelFlowable
<T> ParallelFlowable.filter
(@NonNull Predicate<? super @NonNull T> predicate, @NonNull BiFunction<? super Long, ? super Throwable, ParallelFailureHandling> errorHandler) Filters the source values on each 'rail' and handles errors based on the returned value by the handler function.final @NonNull ParallelFlowable
<T> ParallelFlowable.filter
(@NonNull Predicate<? super @NonNull T> predicate, @NonNull ParallelFailureHandling errorHandler) Filters the source values on each 'rail' and handles errors based on the givenParallelFailureHandling
enumeration value.final @NonNull ParallelFlowable
<T> ParallelFlowable.filter
(@NonNull Predicate<? super @NonNull T> predicate, @NonNull ParallelFailureHandling errorHandler) Filters the source values on each 'rail' and handles errors based on the givenParallelFailureHandling
enumeration value.final <@NonNull R>
@NonNull ParallelFlowable<R> ParallelFlowable.flatMap
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper) Generates and flattensPublisher
s on each 'rail'.final <@NonNull R>
@NonNull ParallelFlowable<R> ParallelFlowable.flatMap
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper, boolean delayError) Generates and flattensPublisher
s on each 'rail', optionally delaying errors.final <@NonNull R>
@NonNull ParallelFlowable<R> ParallelFlowable.flatMap
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper, boolean delayError, int maxConcurrency) Generates and flattensPublisher
s on each 'rail', optionally delaying errors and having a total number of simultaneous subscriptions to the innerPublisher
s.final <@NonNull R>
@NonNull ParallelFlowable<R> ParallelFlowable.flatMap
(@NonNull Function<? super @NonNull T, @NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper, boolean delayError, int maxConcurrency, int prefetch) Generates and flattensPublisher
s on each 'rail', optionally delaying errors, having a total number of simultaneous subscriptions to the innerPublisher
s and using the given prefetch amount for the innerPublisher
s.final <@NonNull U>
@NonNull ParallelFlowable<U> ParallelFlowable.flatMapIterable
(@NonNull Function<? super @NonNull T, @NonNull ? extends Iterable<? extends @NonNull U>> mapper) Returns aParallelFlowable
that merges each item emitted by the source on each rail with the values in anIterable
corresponding to that item that is generated by a selector.final <@NonNull U>
@NonNull ParallelFlowable<U> ParallelFlowable.flatMapIterable
(@NonNull Function<? super @NonNull T, @NonNull ? extends Iterable<? extends @NonNull U>> mapper, int bufferSize) Returns aParallelFlowable
that merges each item emitted by the sourceParallelFlowable
with the values in anIterable
corresponding to that item that is generated by a selector.final <@NonNull R>
@NonNull ParallelFlowable<R> ParallelFlowable.flatMapStream
(@NonNull Function<? super @NonNull T, @NonNull ? extends Stream<? extends @NonNull R>> mapper) Maps each upstream item on each rail into aStream
and emits theStream
's items to the downstream in a sequential fashion.final <@NonNull R>
@NonNull ParallelFlowable<R> ParallelFlowable.flatMapStream
(@NonNull Function<? super @NonNull T, @NonNull ? extends Stream<? extends @NonNull R>> mapper, int prefetch) Maps each upstream item of each rail into aStream
and emits theStream
's items to the downstream in a sequential fashion.static <@NonNull T>
@NonNull ParallelFlowable<T> Take aPublisher
and prepare to consume it on multiple 'rails' (number of CPUs) in a round-robin fashion.static <@NonNull T>
@NonNull ParallelFlowable<T> ParallelFlowable.from
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T> source, int parallelism) Take aPublisher
and prepare to consume it on parallelism number of 'rails' in a round-robin fashion.static <@NonNull T>
@NonNull ParallelFlowable<T> ParallelFlowable.from
(@NonNull org.reactivestreams.Publisher<? extends @NonNull T> source, int parallelism, int prefetch) Take aPublisher
and prepare to consume it on parallelism number of 'rails' , possibly ordered and round-robin fashion and use custom prefetch amount and queue for dealing with the sourcePublisher
's values.static <@NonNull T>
@NonNull ParallelFlowable<T> Wraps multiplePublisher
s into aParallelFlowable
which runs them in parallel and unordered.final <@NonNull R>
@NonNull ParallelFlowable<R> Maps the source values on each 'rail' to another value.final <@NonNull R>
@NonNull ParallelFlowable<R> ParallelFlowable.map
(@NonNull Function<? super @NonNull T, ? extends @NonNull R> mapper, @NonNull BiFunction<? super Long, ? super Throwable, ParallelFailureHandling> errorHandler) Maps the source values on each 'rail' to another value and handles errors based on the returned value by the handler function.final <@NonNull R>
@NonNull ParallelFlowable<R> ParallelFlowable.map
(@NonNull Function<? super @NonNull T, ? extends @NonNull R> mapper, @NonNull BiFunction<? super Long, ? super Throwable, ParallelFailureHandling> errorHandler) Maps the source values on each 'rail' to another value and handles errors based on the returned value by the handler function.final <@NonNull R>
@NonNull ParallelFlowable<R> ParallelFlowable.map
(@NonNull Function<? super @NonNull T, ? extends @NonNull R> mapper, @NonNull ParallelFailureHandling errorHandler) Maps the source values on each 'rail' to another value and handles errors based on the givenParallelFailureHandling
enumeration value.final <@NonNull R>
@NonNull ParallelFlowable<R> ParallelFlowable.map
(@NonNull Function<? super @NonNull T, ? extends @NonNull R> mapper, @NonNull ParallelFailureHandling errorHandler) Maps the source values on each 'rail' to another value and handles errors based on the givenParallelFailureHandling
enumeration value.final <@NonNull R>
@NonNull ParallelFlowable<R> ParallelFlowable.mapOptional
(@NonNull Function<? super @NonNull T, @NonNull Optional<? extends @NonNull R>> mapper) Maps the source values on each 'rail' to an optional and emits its value if any.final <@NonNull R>
@NonNull ParallelFlowable<R> ParallelFlowable.mapOptional
(@NonNull Function<? super @NonNull T, @NonNull Optional<? extends @NonNull R>> mapper, @NonNull BiFunction<? super Long, ? super Throwable, ParallelFailureHandling> errorHandler) Maps the source values on each 'rail' to an optional and emits its value if any and handles errors based on the returned value by the handler function.final <@NonNull R>
@NonNull ParallelFlowable<R> ParallelFlowable.mapOptional
(@NonNull Function<? super @NonNull T, @NonNull Optional<? extends @NonNull R>> mapper, @NonNull BiFunction<? super Long, ? super Throwable, ParallelFailureHandling> errorHandler) Maps the source values on each 'rail' to an optional and emits its value if any and handles errors based on the returned value by the handler function.final <@NonNull R>
@NonNull ParallelFlowable<R> ParallelFlowable.mapOptional
(@NonNull Function<? super @NonNull T, @NonNull Optional<? extends @NonNull R>> mapper, @NonNull ParallelFailureHandling errorHandler) Maps the source values on each 'rail' to an optional and emits its value if any and handles errors based on the givenParallelFailureHandling
enumeration value.final <@NonNull R>
@NonNull ParallelFlowable<R> ParallelFlowable.mapOptional
(@NonNull Function<? super @NonNull T, @NonNull Optional<? extends @NonNull R>> mapper, @NonNull ParallelFailureHandling errorHandler) Maps the source values on each 'rail' to an optional and emits its value if any and handles errors based on the givenParallelFailureHandling
enumeration value.Reduces all values within a 'rail' and across 'rails' with a reducer function into oneFlowable
sequence.final <@NonNull R>
@NonNull ParallelFlowable<R> ParallelFlowable.reduce
(@NonNull Supplier<@NonNull R> initialSupplier, @NonNull BiFunction<@NonNull R, ? super @NonNull T, @NonNull R> reducer) Reduces all values within a 'rail' to a single value (with a possibly different type) via a reducer function that is initialized on each rail from aninitialSupplier
value.final <@NonNull R>
@NonNull ParallelFlowable<R> ParallelFlowable.reduce
(@NonNull Supplier<@NonNull R> initialSupplier, @NonNull BiFunction<@NonNull R, ? super @NonNull T, @NonNull R> reducer) Reduces all values within a 'rail' to a single value (with a possibly different type) via a reducer function that is initialized on each rail from aninitialSupplier
value.final @NonNull ParallelFlowable
<T> Specifies where each 'rail' will observe its incoming values, specified via aScheduler
, with no work-stealing and default prefetch amount.final @NonNull ParallelFlowable
<T> Specifies where each 'rail' will observe its incoming values, specified via aScheduler
, with possibly work-stealing and a given prefetch amount.ParallelFlowable.sorted
(@NonNull Comparator<? super @NonNull T> comparator) Sorts the 'rails' of thisParallelFlowable
and returns aFlowable
that sequentially picks the smallest next value from the rails.ParallelFlowable.sorted
(@NonNull Comparator<? super @NonNull T> comparator, int capacityHint) Sorts the 'rails' of thisParallelFlowable
and returns aFlowable
that sequentially picks the smallest next value from the rails.abstract void
ParallelFlowable.subscribe
(@NonNull org.reactivestreams.Subscriber<? super @NonNull T>[] subscribers) Subscribes an array ofSubscriber
s to thisParallelFlowable
and triggers the execution chain for all 'rails'.final <@NonNull R>
RCalls the specified converter function during assembly time and returns its resulting value.ParallelFlowable.toSortedList
(@NonNull Comparator<? super @NonNull T> comparator) ParallelFlowable.toSortedList
(@NonNull Comparator<? super @NonNull T> comparator, int capacityHint) protected final boolean
Validates the number of subscribers and returnstrue
if their number matches the parallelism level of thisParallelFlowable
. -
Uses of NonNull in io.reactivex.rxjava3.plugins
Methods in io.reactivex.rxjava3.plugins with annotations of type NonNullModifier and TypeMethodDescriptionRxJavaPlugins.apply
(@NonNull BiFunction<@NonNull T, @NonNull U, @NonNull R> f, @NonNull T t, @NonNull U u) Wraps the call to the function in try-catch and propagates thrown checked exceptions as RuntimeException.Wraps the call to the function in try-catch and propagates thrown checked exceptions as RuntimeException.RxJavaPlugins.applyRequireNonNull
(@NonNull Function<? super Supplier<Scheduler>, ? extends Scheduler> f, Supplier<Scheduler> s) Wraps the call to the Scheduler creation function in try-catch and propagates thrown checked exceptions as RuntimeException and enforces that result is not null.RxJavaPlugins.callRequireNonNull
(@NonNull Supplier<Scheduler> s) Wraps the call to the Scheduler creation supplier in try-catch and propagates thrown checked exceptions as RuntimeException and enforces that result is not null.RxJavaPlugins.createComputationScheduler
(@NonNull ThreadFactory threadFactory) Create an instance of the defaultScheduler
used forSchedulers.computation()
except usingthreadFactory
for thread creation.RxJavaPlugins.createExecutorScheduler
(@NonNull Executor executor, boolean interruptibleWorker, boolean fair) RxJavaPlugins.createIoScheduler
(@NonNull ThreadFactory threadFactory) Create an instance of the defaultScheduler
used forSchedulers.io()
except usingthreadFactory
for thread creation.RxJavaPlugins.createNewThreadScheduler
(@NonNull ThreadFactory threadFactory) Create an instance of the defaultScheduler
used forSchedulers.newThread()
except usingthreadFactory
for thread creation.RxJavaPlugins.createSingleScheduler
(@NonNull ThreadFactory threadFactory) Create an instance of the defaultScheduler
used forSchedulers.single()
except usingthreadFactory
for thread creation.RxJavaPlugins.initComputationScheduler
(@NonNull Supplier<Scheduler> defaultScheduler) Calls the associated hook function.RxJavaPlugins.initIoScheduler
(@NonNull Supplier<Scheduler> defaultScheduler) Calls the associated hook function.RxJavaPlugins.initNewThreadScheduler
(@NonNull Supplier<Scheduler> defaultScheduler) Calls the associated hook function.RxJavaPlugins.initSingleScheduler
(@NonNull Supplier<Scheduler> defaultScheduler) Calls the associated hook function.static @NonNull Completable
RxJavaPlugins.onAssembly
(@NonNull Completable source) Calls the associated hook function.RxJavaPlugins.onAssembly
(@NonNull Flowable<@NonNull T> source) Calls the associated hook function.RxJavaPlugins.onAssembly
(@NonNull Maybe<@NonNull T> source) Calls the associated hook function.static <@NonNull T>
@NonNull Observable<T> RxJavaPlugins.onAssembly
(@NonNull Observable<@NonNull T> source) Calls the associated hook function.RxJavaPlugins.onAssembly
(@NonNull Single<@NonNull T> source) Calls the associated hook function.static <@NonNull T>
@NonNull ConnectableFlowable<T> RxJavaPlugins.onAssembly
(@NonNull ConnectableFlowable<@NonNull T> source) Calls the associated hook function.static <@NonNull T>
@NonNull ConnectableObservable<T> RxJavaPlugins.onAssembly
(@NonNull ConnectableObservable<@NonNull T> source) Calls the associated hook function.static <@NonNull T>
@NonNull ParallelFlowable<T> RxJavaPlugins.onAssembly
(@NonNull ParallelFlowable<@NonNull T> source) Calls the associated hook function.RxJavaPlugins.onComputationScheduler
(@NonNull Scheduler defaultScheduler) Calls the associated hook function.RxJavaPlugins.onIoScheduler
(@NonNull Scheduler defaultScheduler) Calls the associated hook function.RxJavaPlugins.onNewThreadScheduler
(@NonNull Scheduler defaultScheduler) Calls the associated hook function.RxJavaPlugins.onSchedule
(@NonNull Runnable run) Called when a task is scheduled.RxJavaPlugins.onSingleScheduler
(@NonNull Scheduler defaultScheduler) Calls the associated hook function.static @NonNull CompletableObserver
RxJavaPlugins.onSubscribe
(@NonNull Completable source, @NonNull CompletableObserver observer) Calls the associated hook function.RxJavaPlugins.onSubscribe
(@NonNull Flowable<@NonNull T> source, @NonNull org.reactivestreams.Subscriber<? super @NonNull T> subscriber) Calls the associated hook function.static <@NonNull T>
@NonNull MaybeObserver<? super T> RxJavaPlugins.onSubscribe
(@NonNull Maybe<@NonNull T> source, @NonNull MaybeObserver<? super @NonNull T> observer) Calls the associated hook function.RxJavaPlugins.onSubscribe
(@NonNull Observable<@NonNull T> source, @NonNull Observer<? super @NonNull T> observer) Calls the associated hook function.static <@NonNull T>
@NonNull SingleObserver<? super T> RxJavaPlugins.onSubscribe
(@NonNull Single<@NonNull T> source, @NonNull SingleObserver<? super @NonNull T> observer) Calls the associated hook function.RxJavaPlugins.onSubscribe
(@NonNull ParallelFlowable<@NonNull T> source, @NonNull org.reactivestreams.Subscriber<? super @NonNull T>[] subscribers) Calls the associated hook function.Method parameters in io.reactivex.rxjava3.plugins with annotations of type NonNullModifier and TypeMethodDescriptionRxJavaPlugins.apply
(@NonNull BiFunction<@NonNull T, @NonNull U, @NonNull R> f, @NonNull T t, @NonNull U u) Wraps the call to the function in try-catch and propagates thrown checked exceptions as RuntimeException.RxJavaPlugins.apply
(@NonNull BiFunction<@NonNull T, @NonNull U, @NonNull R> f, @NonNull T t, @NonNull U u) Wraps the call to the function in try-catch and propagates thrown checked exceptions as RuntimeException.RxJavaPlugins.apply
(@NonNull BiFunction<@NonNull T, @NonNull U, @NonNull R> f, @NonNull T t, @NonNull U u) Wraps the call to the function in try-catch and propagates thrown checked exceptions as RuntimeException.Wraps the call to the function in try-catch and propagates thrown checked exceptions as RuntimeException.Wraps the call to the function in try-catch and propagates thrown checked exceptions as RuntimeException.RxJavaPlugins.applyRequireNonNull
(@NonNull Function<? super Supplier<Scheduler>, ? extends Scheduler> f, Supplier<Scheduler> s) Wraps the call to the Scheduler creation function in try-catch and propagates thrown checked exceptions as RuntimeException and enforces that result is not null.RxJavaPlugins.callRequireNonNull
(@NonNull Supplier<Scheduler> s) Wraps the call to the Scheduler creation supplier in try-catch and propagates thrown checked exceptions as RuntimeException and enforces that result is not null.RxJavaPlugins.createComputationScheduler
(@NonNull ThreadFactory threadFactory) Create an instance of the defaultScheduler
used forSchedulers.computation()
except usingthreadFactory
for thread creation.RxJavaPlugins.createExecutorScheduler
(@NonNull Executor executor, boolean interruptibleWorker, boolean fair) RxJavaPlugins.createIoScheduler
(@NonNull ThreadFactory threadFactory) Create an instance of the defaultScheduler
used forSchedulers.io()
except usingthreadFactory
for thread creation.RxJavaPlugins.createNewThreadScheduler
(@NonNull ThreadFactory threadFactory) Create an instance of the defaultScheduler
used forSchedulers.newThread()
except usingthreadFactory
for thread creation.RxJavaPlugins.createSingleScheduler
(@NonNull ThreadFactory threadFactory) Create an instance of the defaultScheduler
used forSchedulers.single()
except usingthreadFactory
for thread creation.RxJavaPlugins.initComputationScheduler
(@NonNull Supplier<Scheduler> defaultScheduler) Calls the associated hook function.RxJavaPlugins.initIoScheduler
(@NonNull Supplier<Scheduler> defaultScheduler) Calls the associated hook function.RxJavaPlugins.initNewThreadScheduler
(@NonNull Supplier<Scheduler> defaultScheduler) Calls the associated hook function.RxJavaPlugins.initSingleScheduler
(@NonNull Supplier<Scheduler> defaultScheduler) Calls the associated hook function.static @NonNull Completable
RxJavaPlugins.onAssembly
(@NonNull Completable source) Calls the associated hook function.RxJavaPlugins.onAssembly
(@NonNull Flowable<@NonNull T> source) Calls the associated hook function.RxJavaPlugins.onAssembly
(@NonNull Maybe<@NonNull T> source) Calls the associated hook function.static <@NonNull T>
@NonNull Observable<T> RxJavaPlugins.onAssembly
(@NonNull Observable<@NonNull T> source) Calls the associated hook function.RxJavaPlugins.onAssembly
(@NonNull Single<@NonNull T> source) Calls the associated hook function.static <@NonNull T>
@NonNull ConnectableFlowable<T> RxJavaPlugins.onAssembly
(@NonNull ConnectableFlowable<@NonNull T> source) Calls the associated hook function.static <@NonNull T>
@NonNull ConnectableObservable<T> RxJavaPlugins.onAssembly
(@NonNull ConnectableObservable<@NonNull T> source) Calls the associated hook function.static <@NonNull T>
@NonNull ParallelFlowable<T> RxJavaPlugins.onAssembly
(@NonNull ParallelFlowable<@NonNull T> source) Calls the associated hook function.RxJavaPlugins.onComputationScheduler
(@NonNull Scheduler defaultScheduler) Calls the associated hook function.static void
Called when an undeliverable error occurs.RxJavaPlugins.onIoScheduler
(@NonNull Scheduler defaultScheduler) Calls the associated hook function.RxJavaPlugins.onNewThreadScheduler
(@NonNull Scheduler defaultScheduler) Calls the associated hook function.RxJavaPlugins.onSchedule
(@NonNull Runnable run) Called when a task is scheduled.RxJavaPlugins.onSingleScheduler
(@NonNull Scheduler defaultScheduler) Calls the associated hook function.static @NonNull CompletableObserver
RxJavaPlugins.onSubscribe
(@NonNull Completable source, @NonNull CompletableObserver observer) Calls the associated hook function.static @NonNull CompletableObserver
RxJavaPlugins.onSubscribe
(@NonNull Completable source, @NonNull CompletableObserver observer) Calls the associated hook function.RxJavaPlugins.onSubscribe
(@NonNull Flowable<@NonNull T> source, @NonNull org.reactivestreams.Subscriber<? super @NonNull T> subscriber) Calls the associated hook function.RxJavaPlugins.onSubscribe
(@NonNull Flowable<@NonNull T> source, @NonNull org.reactivestreams.Subscriber<? super @NonNull T> subscriber) Calls the associated hook function.static <@NonNull T>
@NonNull MaybeObserver<? super T> RxJavaPlugins.onSubscribe
(@NonNull Maybe<@NonNull T> source, @NonNull MaybeObserver<? super @NonNull T> observer) Calls the associated hook function.static <@NonNull T>
@NonNull MaybeObserver<? super T> RxJavaPlugins.onSubscribe
(@NonNull Maybe<@NonNull T> source, @NonNull MaybeObserver<? super @NonNull T> observer) Calls the associated hook function.RxJavaPlugins.onSubscribe
(@NonNull Observable<@NonNull T> source, @NonNull Observer<? super @NonNull T> observer) Calls the associated hook function.RxJavaPlugins.onSubscribe
(@NonNull Observable<@NonNull T> source, @NonNull Observer<? super @NonNull T> observer) Calls the associated hook function.static <@NonNull T>
@NonNull SingleObserver<? super T> RxJavaPlugins.onSubscribe
(@NonNull Single<@NonNull T> source, @NonNull SingleObserver<? super @NonNull T> observer) Calls the associated hook function.static <@NonNull T>
@NonNull SingleObserver<? super T> RxJavaPlugins.onSubscribe
(@NonNull Single<@NonNull T> source, @NonNull SingleObserver<? super @NonNull T> observer) Calls the associated hook function.RxJavaPlugins.onSubscribe
(@NonNull ParallelFlowable<@NonNull T> source, @NonNull org.reactivestreams.Subscriber<? super @NonNull T>[] subscribers) Calls the associated hook function.RxJavaPlugins.onSubscribe
(@NonNull ParallelFlowable<@NonNull T> source, @NonNull org.reactivestreams.Subscriber<? super @NonNull T>[] subscribers) Calls the associated hook function.(package private) static void
-
Uses of NonNull in io.reactivex.rxjava3.processors
Methods in io.reactivex.rxjava3.processors with annotations of type NonNullModifier and TypeMethodDescriptionstatic <T> @NonNull AsyncProcessor
<T> AsyncProcessor.create()
Creates a new AsyncProcessor.static <T> @NonNull BehaviorProcessor
<T> BehaviorProcessor.create()
Creates aBehaviorProcessor
without a default item.static <T> @NonNull MulticastProcessor
<T> MulticastProcessor.create()
Constructs a fresh instance with the default Flowable.bufferSize() prefetch amount and no refCount-behavior.static <T> @NonNull MulticastProcessor
<T> MulticastProcessor.create
(boolean refCount) Constructs a fresh instance with the default Flowable.bufferSize() prefetch amount and the optional refCount-behavior.static <T> @NonNull MulticastProcessor
<T> MulticastProcessor.create
(int bufferSize) Constructs a fresh instance with the given prefetch amount and no refCount behavior.static <T> @NonNull MulticastProcessor
<T> MulticastProcessor.create
(int bufferSize, boolean refCount) Constructs a fresh instance with the given prefetch amount and the optional refCount-behavior.static <T> @NonNull PublishProcessor
<T> PublishProcessor.create()
Constructs a PublishProcessor.static <T> @NonNull ReplayProcessor
<T> ReplayProcessor.create()
Creates an unbounded ReplayProcessor.static <T> @NonNull ReplayProcessor
<T> ReplayProcessor.create
(int capacityHint) Creates an unbounded ReplayProcessor with the specified initial buffer capacity.static <T> @NonNull UnicastProcessor
<T> UnicastProcessor.create()
Creates an UnicastSubject with an internal buffer capacity hint 16.static <T> @NonNull UnicastProcessor
<T> UnicastProcessor.create
(boolean delayError) Creates an UnicastProcessor with default internal buffer capacity hint and delay error flag.static <T> @NonNull UnicastProcessor
<T> UnicastProcessor.create
(int capacityHint) Creates an UnicastProcessor with the given internal buffer capacity hint.static <T> @NonNull UnicastProcessor
<T> Creates an UnicastProcessor with the given internal buffer capacity hint and a callback for the case when the single Subscriber cancels its subscription or the processor is terminated.static <T> @NonNull UnicastProcessor
<T> Creates an UnicastProcessor with the given internal buffer capacity hint, delay error flag and a callback for the case when the single Subscriber cancels its subscription or the processor is terminated.static <@NonNull T>
@NonNull BehaviorProcessor<T> BehaviorProcessor.createDefault
(@NonNull T defaultValue) Creates aBehaviorProcessor
that emits the last item it observed and all subsequent items to eachSubscriber
that subscribes to it.static <T> @NonNull ReplayProcessor
<T> ReplayProcessor.createWithSize
(int maxSize) Creates a size-bounded ReplayProcessor.static <T> @NonNull ReplayProcessor
<T> ReplayProcessor.createWithTime
(long maxAge, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Creates a time-bounded ReplayProcessor.static <T> @NonNull ReplayProcessor
<T> ReplayProcessor.createWithTimeAndSize
(long maxAge, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, int maxSize) Creates a time- and size-bounded ReplayProcessor.final @NonNull FlowableProcessor
<T> FlowableProcessor.toSerialized()
Wraps this FlowableProcessor and serializes the calls to the onSubscribe, onNext, onError and onComplete methods, making them thread-safe.Method parameters in io.reactivex.rxjava3.processors with annotations of type NonNullModifier and TypeMethodDescriptionstatic <T> @NonNull UnicastProcessor
<T> Creates an UnicastProcessor with the given internal buffer capacity hint and a callback for the case when the single Subscriber cancels its subscription or the processor is terminated.static <T> @NonNull UnicastProcessor
<T> Creates an UnicastProcessor with the given internal buffer capacity hint, delay error flag and a callback for the case when the single Subscriber cancels its subscription or the processor is terminated.static <T> @NonNull ReplayProcessor
<T> ReplayProcessor.createWithTime
(long maxAge, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Creates a time-bounded ReplayProcessor.static <T> @NonNull ReplayProcessor
<T> ReplayProcessor.createWithTime
(long maxAge, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Creates a time-bounded ReplayProcessor.static <T> @NonNull ReplayProcessor
<T> ReplayProcessor.createWithTimeAndSize
(long maxAge, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, int maxSize) Creates a time- and size-bounded ReplayProcessor.static <T> @NonNull ReplayProcessor
<T> ReplayProcessor.createWithTimeAndSize
(long maxAge, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, int maxSize) Creates a time- and size-bounded ReplayProcessor.boolean
Tries to emit the item to all currently subscribedSubscriber
s if all of them has requested some value, returnsfalse
otherwise.boolean
Tries to offer an item into the internal queue and returns false if the queue is full.boolean
Tries to emit the item to all currently subscribedSubscriber
s if all of them has requested some value, returnsfalse
otherwise.void
void
void
void
void
void
void
void
void
AsyncProcessor.onSubscribe
(@NonNull org.reactivestreams.Subscription s) void
BehaviorProcessor.onSubscribe
(@NonNull org.reactivestreams.Subscription s) void
MulticastProcessor.onSubscribe
(@NonNull org.reactivestreams.Subscription s) void
PublishProcessor.onSubscribe
(@NonNull org.reactivestreams.Subscription s) protected void
AsyncProcessor.subscribeActual
(@NonNull org.reactivestreams.Subscriber<? super @NonNull T> s) protected void
BehaviorProcessor.subscribeActual
(@NonNull org.reactivestreams.Subscriber<? super @NonNull T> s) protected void
MulticastProcessor.subscribeActual
(@NonNull org.reactivestreams.Subscriber<? super @NonNull T> s) protected void
PublishProcessor.subscribeActual
(@NonNull org.reactivestreams.Subscriber<? super @NonNull T> t) -
Uses of NonNull in io.reactivex.rxjava3.schedulers
Fields in io.reactivex.rxjava3.schedulers with annotations of type NonNullModifier and TypeFieldDescriptionSchedulers.COMPUTATION
Schedulers.IO
Schedulers.NEW_THREAD
Schedulers.SINGLE
Schedulers.TRAMPOLINE
Methods in io.reactivex.rxjava3.schedulers with annotations of type NonNullModifier and TypeMethodDescriptionSchedulers.computation()
Returns a default, sharedScheduler
instance intended for computational work.TestScheduler.createWorker()
SchedulerRunnableIntrospection.getWrappedRunnable()
Returns the wrapped action.Schedulers.io()
Returns a default, sharedScheduler
instance intended for IO-bound work.Schedulers.newThread()
Schedulers.single()
Returns a default, shared, single-thread-backedScheduler
instance for work requiring strongly-sequential execution on the same background thread.Schedulers.trampoline()
Returns a default, sharedScheduler
instance whoseScheduler.Worker
instances queue work and execute them in a FIFO manner on one of the participating threads.Timed.unit()
Returns the time unit of the contained time.Timed.value()
Returns the contained value.Method parameters in io.reactivex.rxjava3.schedulers with annotations of type NonNullModifier and TypeMethodDescriptionlong
long
long
Returns the contained time value in the time unit specified.Constructor parameters in io.reactivex.rxjava3.schedulers with annotations of type NonNull -
Uses of NonNull in io.reactivex.rxjava3.subjects
Methods in io.reactivex.rxjava3.subjects with annotations of type NonNullModifier and TypeMethodDescriptionstatic <T> @NonNull AsyncSubject
<T> AsyncSubject.create()
Creates a new AsyncProcessor.static <T> @NonNull BehaviorSubject
<T> BehaviorSubject.create()
Creates aBehaviorSubject
without a default item.static @NonNull CompletableSubject
CompletableSubject.create()
Creates a fresh CompletableSubject.static <T> @NonNull MaybeSubject
<T> MaybeSubject.create()
Creates a fresh MaybeSubject.static <T> @NonNull PublishSubject
<T> PublishSubject.create()
Constructs a PublishSubject.static <T> @NonNull ReplaySubject
<T> ReplaySubject.create()
Creates an unbounded replay subject.static <T> @NonNull ReplaySubject
<T> ReplaySubject.create
(int capacityHint) Creates an unbounded replay subject with the specified initial buffer capacity.static <T> @NonNull SingleSubject
<T> SingleSubject.create()
Creates a fresh SingleSubject.static <T> @NonNull UnicastSubject
<T> UnicastSubject.create()
Creates an UnicastSubject with an internal buffer capacity hint 16.static <T> @NonNull UnicastSubject
<T> UnicastSubject.create
(boolean delayError) Creates an UnicastSubject with an internal buffer capacity hint 16 and given delay error flag.static <T> @NonNull UnicastSubject
<T> UnicastSubject.create
(int capacityHint) Creates an UnicastSubject with the given internal buffer capacity hint.static <T> @NonNull UnicastSubject
<T> Creates an UnicastSubject with the given internal buffer capacity hint and a callback for the case when the single Subscriber cancels its subscription or the subject is terminated.static <T> @NonNull UnicastSubject
<T> Creates an UnicastSubject with the given internal buffer capacity hint, delay error flag and a callback for the case when the single Observer disposes itsDisposable
or the subject is terminated.static <@NonNull T>
@NonNull BehaviorSubject<T> BehaviorSubject.createDefault
(@NonNull T defaultValue) Creates aBehaviorSubject
that emits the last item it observed and all subsequent items to eachObserver
that subscribes to it.static <T> @NonNull ReplaySubject
<T> ReplaySubject.createWithSize
(int maxSize) Creates a size-bounded replay subject.static <T> @NonNull ReplaySubject
<T> ReplaySubject.createWithTime
(long maxAge, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Creates a time-bounded replay subject.static <T> @NonNull ReplaySubject
<T> ReplaySubject.createWithTimeAndSize
(long maxAge, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, int maxSize) Creates a time- and size-bounded replay subject.Subject.toSerialized()
Wraps this Subject and serializes the calls to the onSubscribe, onNext, onError and onComplete methods, making them thread-safe.Method parameters in io.reactivex.rxjava3.subjects with annotations of type NonNullModifier and TypeMethodDescription(package private) boolean
SingleSubject.add
(@NonNull SingleSubject.SingleDisposable<T> inner) static <T> @NonNull UnicastSubject
<T> Creates an UnicastSubject with the given internal buffer capacity hint and a callback for the case when the single Subscriber cancels its subscription or the subject is terminated.static <T> @NonNull UnicastSubject
<T> Creates an UnicastSubject with the given internal buffer capacity hint, delay error flag and a callback for the case when the single Observer disposes itsDisposable
or the subject is terminated.static <T> @NonNull ReplaySubject
<T> ReplaySubject.createWithTime
(long maxAge, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Creates a time-bounded replay subject.static <T> @NonNull ReplaySubject
<T> ReplaySubject.createWithTime
(long maxAge, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Creates a time-bounded replay subject.static <T> @NonNull ReplaySubject
<T> ReplaySubject.createWithTimeAndSize
(long maxAge, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, int maxSize) Creates a time- and size-bounded replay subject.static <T> @NonNull ReplaySubject
<T> ReplaySubject.createWithTimeAndSize
(long maxAge, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, int maxSize) Creates a time- and size-bounded replay subject.void
void
SingleSubject.onSubscribe
(@NonNull Disposable d) void
(package private) void
SingleSubject.remove
(@NonNull SingleSubject.SingleDisposable<T> inner) protected void
SingleSubject.subscribeActual
(@NonNull SingleObserver<? super T> observer) -
Uses of NonNull in io.reactivex.rxjava3.subscribers
Methods in io.reactivex.rxjava3.subscribers with annotations of type NonNullModifier and TypeMethodDescriptionstatic <T> @NonNull TestSubscriber
<T> TestSubscriber.create()
Creates aTestSubscriber
withLong.MAX_VALUE
initial request amount.static <T> @NonNull TestSubscriber
<T> TestSubscriber.create
(long initialRequested) Creates aTestSubscriber
with the given initial request amount.Method parameters in io.reactivex.rxjava3.subscribers with annotations of type NonNullModifier and TypeMethodDescriptionstatic <T> TestSubscriber
<T> Constructs a forwardingTestSubscriber
.void
void
void
void
void
void
SafeSubscriber.onSubscribe
(@NonNull org.reactivestreams.Subscription s) void
SerializedSubscriber.onSubscribe
(@NonNull org.reactivestreams.Subscription s) void
TestSubscriber.onSubscribe
(@NonNull org.reactivestreams.Subscription s) Constructor parameters in io.reactivex.rxjava3.subscribers with annotations of type NonNullModifierConstructorDescriptionSafeSubscriber
(@NonNull org.reactivestreams.Subscriber<? super @NonNull T> downstream) Constructs aSafeSubscriber
by wrapping the given actualSubscriber
.SerializedSubscriber
(@NonNull org.reactivestreams.Subscriber<? super T> actual, boolean delayError) Construct aSerializedSubscriber
by wrapping the given actualSubscriber
and optionally delaying the errors till all regular values have been emitted from the internal buffer.TestSubscriber
(@NonNull org.reactivestreams.Subscriber<? super T> downstream) Constructs a forwardingTestSubscriber
but leaves the requesting to the wrappedSubscriber
.TestSubscriber
(@NonNull org.reactivestreams.Subscriber<? super T> actual, long initialRequest) Constructs a forwardingTestSubscriber
with the specified initial request amount and an actualSubscriber
to forward events to.