static <@NonNull T> @NonNull Observable<T> |
Observable.amb(@NonNull java.lang.Iterable<? extends ObservableSource<? extends @NonNull T>> sources) |
Mirrors the one ObservableSource in an Iterable of several ObservableSource s that first either emits an item or sends
a termination notification.
|
static <@NonNull T> @NonNull Observable<T> |
Observable.ambArray(@NonNull ObservableSource<? extends @NonNull T>... sources) |
Mirrors the one ObservableSource in an array of several ObservableSource s that first either emits an item or sends
a termination notification.
|
@NonNull Observable<T> |
Observable.ambWith(@NonNull ObservableSource<? extends @NonNull T> other) |
Mirrors the current Observable or the other ObservableSource provided of which the first either emits an item or sends a termination
notification.
|
<@NonNull T> @NonNull Observable<T> |
Completable.andThen(@NonNull ObservableSource<@NonNull T> next) |
Returns an Observable which will subscribe to this Completable and once that is completed then
will subscribe to the next ObservableSource .
|
@NonNull Observable<@NonNull java.util.List<T>> |
Observable.buffer(int count) |
Returns an Observable that emits buffers of items it collects from the current Observable .
|
@NonNull Observable<@NonNull java.util.List<T>> |
Observable.buffer(int count,
int skip) |
Returns an Observable that emits buffers of items it collects from the current Observable .
|
<@NonNull U extends java.util.Collection<? super @NonNull T>> @NonNull Observable<U> |
Observable.buffer(int count,
int skip,
@NonNull Supplier<@NonNull U> bufferSupplier) |
Returns an Observable that emits buffers of items it collects from the current Observable .
|
<@NonNull U extends java.util.Collection<? super @NonNull T>> @NonNull Observable<U> |
Observable.buffer(int count,
@NonNull Supplier<@NonNull U> bufferSupplier) |
Returns an Observable that emits buffers of items it collects from the current Observable .
|
@NonNull Observable<@NonNull java.util.List<T>> |
Observable.buffer(long timespan,
long timeskip,
@NonNull java.util.concurrent.TimeUnit unit) |
Returns an Observable that emits buffers of items it collects from the current Observable .
|
@NonNull Observable<@NonNull java.util.List<T>> |
Observable.buffer(long timespan,
long timeskip,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler) |
Returns an Observable that emits buffers of items it collects from the current Observable .
|
<@NonNull U extends java.util.Collection<? super @NonNull T>> @NonNull Observable<U> |
Observable.buffer(long timespan,
long timeskip,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler,
@NonNull Supplier<@NonNull U> bufferSupplier) |
Returns an Observable that emits buffers of items it collects from the current Observable .
|
@NonNull Observable<@NonNull java.util.List<T>> |
Observable.buffer(long timespan,
@NonNull java.util.concurrent.TimeUnit unit) |
Returns an Observable that emits buffers of items it collects from the current Observable .
|
@NonNull Observable<@NonNull java.util.List<T>> |
Observable.buffer(long timespan,
@NonNull java.util.concurrent.TimeUnit unit,
int count) |
Returns an Observable that emits buffers of items it collects from the current Observable .
|
@NonNull Observable<@NonNull java.util.List<T>> |
Observable.buffer(long timespan,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler) |
Returns an Observable that emits buffers of items it collects from the current Observable .
|
@NonNull Observable<@NonNull java.util.List<T>> |
Observable.buffer(long timespan,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler,
int count) |
Returns an Observable that emits buffers of items it collects from the current Observable .
|
<@NonNull U extends java.util.Collection<? super @NonNull T>> @NonNull Observable<U> |
Observable.buffer(long timespan,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler,
int count,
@NonNull Supplier<@NonNull U> bufferSupplier,
boolean restartTimerOnMaxSize) |
Returns an Observable that emits buffers of items it collects from the current Observable .
|
<@NonNull TOpening,@NonNull TClosing> @NonNull Observable<@NonNull java.util.List<T>> |
Observable.buffer(@NonNull ObservableSource<? extends @NonNull TOpening> openingIndicator,
@NonNull Function<? super @NonNull TOpening,? extends ObservableSource<? extends @NonNull TClosing>> closingIndicator) |
Returns an Observable that emits buffers of items it collects from the current Observable .
|
<@NonNull TOpening,@NonNull TClosing,@NonNull U extends java.util.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 an Observable that emits buffers of items it collects from the current Observable .
|
<@NonNull B> @NonNull Observable<@NonNull java.util.List<T>> |
Observable.buffer(@NonNull ObservableSource<@NonNull B> boundaryIndicator) |
Returns an Observable that emits non-overlapping buffered items from the current Observable each time the
specified boundary ObservableSource emits an item.
|
<@NonNull B> @NonNull Observable<@NonNull java.util.List<T>> |
Observable.buffer(@NonNull ObservableSource<@NonNull B> boundaryIndicator,
int initialCapacity) |
Returns an Observable that emits non-overlapping buffered items from the current Observable each time the
specified boundary ObservableSource emits an item.
|
<@NonNull B,@NonNull U extends java.util.Collection<? super @NonNull T>> @NonNull Observable<U> |
Observable.buffer(@NonNull ObservableSource<@NonNull B> boundaryIndicator,
@NonNull Supplier<@NonNull U> bufferSupplier) |
Returns an Observable that emits non-overlapping buffered items from the current Observable each time the
specified boundary ObservableSource emits an item.
|
@NonNull Observable<T> |
Observable.cache() |
Returns an Observable that subscribes to the current Observable lazily, caches all of its events
and replays them, in the same order as received, to all the downstream observers.
|
@NonNull Observable<T> |
Observable.cacheWithInitialCapacity(int initialCapacity) |
Returns an Observable that subscribes to the current Observable lazily, caches all of its events
and replays them, in the same order as received, to all the downstream observers.
|
<@NonNull U> @NonNull Observable<U> |
Observable.cast(@NonNull java.lang.Class<@NonNull U> clazz) |
Returns an Observable that emits the upstream items while
they can be cast via Class.cast(Object) until the upstream terminates,
or until the upstream signals an item which can't be cast,
resulting in a ClassCastException to be signaled to the downstream.
|
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 source ObservableSource s by emitting an item that aggregates the latest values of each of the
ObservableSource s each time an item is received from any of the ObservableSource 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 source ObservableSource s by emitting an item that aggregates the latest values of each of the
ObservableSource s each time an item is received from any of the ObservableSource 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 source ObservableSource s by emitting an item that aggregates the latest values of each of the
ObservableSource s each time an item is received from any of the ObservableSource 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 source ObservableSource s by emitting an item that aggregates the latest values of each of the
ObservableSource s each time an item is received from any of the ObservableSource 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 source ObservableSource s by emitting an item that aggregates the latest values of each of the
ObservableSource s each time an item is received from any of the ObservableSource s, where this
aggregation is defined by a specified function.
|
static <@NonNull T1,@NonNull T2,@NonNull T3,@NonNull T4,@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 Function4<? super @NonNull T1,? super @NonNull T2,? super @NonNull T3,? super @NonNull T4,? extends @NonNull R> combiner) |
Combines four source ObservableSource s by emitting an item that aggregates the latest values of each of the
ObservableSource s each time an item is received from any of the ObservableSource s, where this
aggregation is defined by a specified function.
|
static <@NonNull T1,@NonNull T2,@NonNull T3,@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 Function3<? super @NonNull T1,? super @NonNull T2,? super @NonNull T3,? extends @NonNull R> combiner) |
Combines three source ObservableSource s by emitting an item that aggregates the latest values of each of the
ObservableSource s each time an item is received from any of the ObservableSource 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 source ObservableSource s by emitting an item that aggregates the latest values of each of the
ObservableSource s each time an item is received from either of the ObservableSource s, where this
aggregation is defined by a specified function.
|
static <@NonNull T,@NonNull R> @NonNull Observable<R> |
Observable.combineLatest(@NonNull java.lang.Iterable<? extends ObservableSource<? extends @NonNull T>> sources,
@NonNull Function<? super java.lang.Object[],? extends @NonNull R> combiner) |
Combines a collection of source ObservableSource s by emitting an item that aggregates the latest values of each of
the returned ObservableSource s each time an item is received from any of the returned ObservableSource s, where this
aggregation is defined by a specified function.
|
static <@NonNull T,@NonNull R> @NonNull Observable<R> |
Observable.combineLatest(@NonNull java.lang.Iterable<? extends ObservableSource<? extends @NonNull T>> sources,
@NonNull Function<? super java.lang.Object[],? extends @NonNull R> combiner,
int bufferSize) |
Combines an Iterable of source ObservableSource s by emitting an item that aggregates the latest values of each of
the returned ObservableSource s each time an item is received from any of the returned ObservableSource 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 java.lang.Object[],? extends @NonNull R> combiner) |
Combines an array of source ObservableSource s by emitting an item that aggregates the latest values of each of
the ObservableSource s each time an item is received from any of the returned ObservableSource 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 java.lang.Object[],? extends @NonNull R> combiner,
int bufferSize) |
Combines an array of source ObservableSource s by emitting an item that aggregates the latest values of each of
the ObservableSource s each time an item is received from any of the ObservableSource 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 java.lang.Object[],? extends @NonNull R> combiner) |
Combines an array of ObservableSource s by emitting an item that aggregates the latest values of each of
the ObservableSource s each time an item is received from any of the ObservableSource 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 java.lang.Object[],? extends @NonNull R> combiner,
int bufferSize) |
Combines an array of ObservableSource s by emitting an item that aggregates the latest values of each of
the ObservableSource s each time an item is received from any of the ObservableSource s, where this
aggregation is defined by a specified function and delays any error from the sources until
all source ObservableSource s terminate.
|
static <@NonNull T,@NonNull R> @NonNull Observable<R> |
Observable.combineLatestDelayError(@NonNull java.lang.Iterable<? extends ObservableSource<? extends @NonNull T>> sources,
@NonNull Function<? super java.lang.Object[],? extends @NonNull R> combiner) |
Combines an Iterable of ObservableSource s by emitting an item that aggregates the latest values of each of
the ObservableSource s each time an item is received from any of the ObservableSource s, where this
aggregation is defined by a specified function and delays any error from the sources until
all source ObservableSource s terminate.
|
static <@NonNull T,@NonNull R> @NonNull Observable<R> |
Observable.combineLatestDelayError(@NonNull java.lang.Iterable<? extends ObservableSource<? extends @NonNull T>> sources,
@NonNull Function<? super java.lang.Object[],? extends @NonNull R> combiner,
int bufferSize) |
Combines an Iterable of ObservableSource s by emitting an item that aggregates the latest values of each of
the ObservableSource s each time an item is received from any of the ObservableSource s, where this
aggregation is defined by a specified function and delays any error from the sources until
all source ObservableSource s terminate.
|
<@NonNull R> @NonNull Observable<R> |
Observable.compose(@NonNull ObservableTransformer<? super @NonNull T,? extends @NonNull R> composer) |
|
static <@NonNull T> @NonNull Observable<T> |
Observable.concat(@NonNull ObservableSource<? extends ObservableSource<? extends @NonNull T>> sources) |
Returns an Observable that emits the items emitted by each of the ObservableSource s emitted by the
ObservableSource , 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 an Observable that emits the items emitted by each of the ObservableSource s emitted by the outer
ObservableSource , 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 an Observable that emits the items emitted by three ObservableSource 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 an Observable that emits the items emitted by four ObservableSource 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 an Observable that emits the items emitted by two ObservableSource s, one after the other, without
interleaving them.
|
static <@NonNull T> @NonNull Observable<T> |
Observable.concat(@NonNull java.lang.Iterable<? extends ObservableSource<? extends @NonNull T>> sources) |
Concatenates elements of each ObservableSource provided via an Iterable 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) |
|
static <@NonNull T> @NonNull Observable<T> |
Observable.concatArray(@NonNull ObservableSource<? extends @NonNull T>... sources) |
|
static <@NonNull T> @NonNull Observable<T> |
Observable.concatArrayDelayError(@NonNull ObservableSource<? extends @NonNull T>... sources) |
Concatenates a variable number of ObservableSource sources and delays errors from any of them
till all terminate.
|
static <@NonNull T> @NonNull Observable<T> |
Observable.concatArrayEager(int maxConcurrency,
int bufferSize,
@NonNull ObservableSource<? extends @NonNull T>... sources) |
Concatenates an array of ObservableSource 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 of ObservableSource s eagerly into a single stream of values.
|
static <@NonNull T> @NonNull Observable<T> |
Observable.concatArrayEagerDelayError(int maxConcurrency,
int bufferSize,
@NonNull ObservableSource<? extends @NonNull T>... sources) |
Concatenates an array of ObservableSource 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 of ObservableSource s eagerly into a single stream of values
and delaying any errors until all sources terminate.
|
static <@NonNull T> @NonNull Observable<T> |
Observable.concatDelayError(@NonNull ObservableSource<? extends ObservableSource<? extends @NonNull T>> sources) |
Concatenates the ObservableSource sequence of ObservableSource s into a single Observable sequence
by subscribing to each inner ObservableSource , one after the other, one at a time and delays any errors till the
all inner and the outer ObservableSource s terminate.
|
static <@NonNull T> @NonNull Observable<T> |
Observable.concatDelayError(@NonNull ObservableSource<? extends ObservableSource<? extends @NonNull T>> sources,
int bufferSize,
boolean tillTheEnd) |
Concatenates the ObservableSource sequence of ObservableSource s into a single sequence by subscribing to each inner ObservableSource ,
one after the other, one at a time and delays any errors till the all inner and the outer ObservableSource s terminate.
|
static <@NonNull T> @NonNull Observable<T> |
Observable.concatDelayError(@NonNull java.lang.Iterable<? extends ObservableSource<? extends @NonNull T>> sources) |
Concatenates the Iterable sequence of ObservableSource s into a single Observable sequence
by subscribing to each ObservableSource , one after the other, one at a time and delays any errors till
the all inner ObservableSource s terminate.
|
static <@NonNull T> @NonNull Observable<T> |
Observable.concatEager(@NonNull ObservableSource<? extends ObservableSource<? extends @NonNull T>> sources) |
Concatenates an ObservableSource sequence of ObservableSource 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 an ObservableSource sequence of ObservableSource 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 java.lang.Iterable<? extends ObservableSource<? extends @NonNull T>> sources) |
Concatenates a sequence of ObservableSource s eagerly into a single stream of values.
|
static <@NonNull T> @NonNull Observable<T> |
Observable.concatEager(@NonNull java.lang.Iterable<? extends ObservableSource<? extends @NonNull T>> sources,
int maxConcurrency,
int bufferSize) |
Concatenates a sequence of ObservableSource 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.concatEagerDelayError(@NonNull ObservableSource<? extends ObservableSource<? extends @NonNull T>> sources) |
Concatenates an ObservableSource sequence of ObservableSource 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 an ObservableSource sequence of ObservableSource 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 java.lang.Iterable<? extends ObservableSource<? extends @NonNull T>> sources) |
Concatenates a sequence of ObservableSource 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 java.lang.Iterable<? extends ObservableSource<? extends @NonNull T>> sources,
int maxConcurrency,
int bufferSize) |
Concatenates a sequence of ObservableSource 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.
|
<@NonNull R> @NonNull Observable<R> |
Observable.concatMap(@NonNull Function<? super @NonNull T,? extends ObservableSource<? extends @NonNull R>> mapper) |
Returns a new Observable that emits items resulting from applying a function that you supply to each item
emitted by the current Observable , where that function returns an ObservableSource , and then emitting the items
that result from concatenating those returned ObservableSource s.
|
<@NonNull R> @NonNull Observable<R> |
Observable.concatMap(@NonNull Function<? super @NonNull T,? extends ObservableSource<? extends @NonNull R>> mapper,
int bufferSize) |
Returns a new Observable that emits items resulting from applying a function that you supply to each item
emitted by the current Observable , where that function returns an ObservableSource , and then emitting the items
that result from concatenating those returned ObservableSource s.
|
<@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 new Observable that emits items resulting from applying a function that you supply to each item
emitted by the current Observable , where that function returns an ObservableSource , and then emitting the items
that result from concatenating those returned ObservableSource s.
|
<@NonNull R> @NonNull Observable<R> |
Observable.concatMapDelayError(@NonNull Function<? super @NonNull T,? extends ObservableSource<? extends @NonNull R>> mapper) |
Maps each of the items into an ObservableSource , 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 inner ObservableSource s
till all of them terminate.
|
<@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 an ObservableSource , 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 inner ObservableSource s
till all of them terminate.
|
<@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 an ObservableSource , 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 inner ObservableSource s
till all of them terminate.
|
<@NonNull R> @NonNull Observable<R> |
Observable.concatMapEager(@NonNull Function<? super @NonNull T,? extends ObservableSource<? extends @NonNull R>> mapper) |
Maps a sequence of values into ObservableSource s and concatenates these ObservableSource s eagerly into a single
Observable sequence.
|
<@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 into ObservableSource s and concatenates these ObservableSource s eagerly into a single
Observable sequence.
|
<@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 into ObservableSource s and concatenates these ObservableSource s eagerly into a single
Observable sequence.
|
<@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 into ObservableSource s and concatenates these ObservableSource s eagerly into a single
Observable sequence.
|
<@NonNull U> @NonNull Observable<U> |
Observable.concatMapIterable(@NonNull Function<? super @NonNull T,? extends java.lang.Iterable<? extends @NonNull U>> mapper) |
Returns an Observable that concatenate each item emitted by the current Observable with the values in an
Iterable corresponding to that item that is generated by a selector.
|
<@NonNull R> @NonNull Observable<R> |
Observable.concatMapMaybe(@NonNull Function<? super @NonNull T,? extends MaybeSource<? extends @NonNull R>> mapper) |
Maps the upstream items into MaybeSource s and subscribes to them one after the
other succeeds or completes, emits their success value if available or terminates immediately if
either the current Observable or the current inner MaybeSource fail.
|
<@NonNull R> @NonNull Observable<R> |
Observable.concatMapMaybe(@NonNull Function<? super @NonNull T,? extends MaybeSource<? extends @NonNull R>> mapper,
int bufferSize) |
Maps the upstream items into MaybeSource s and subscribes to them one after the
other succeeds or completes, emits their success value if available or terminates immediately if
either the current Observable or the current inner MaybeSource fail.
|
<@NonNull R> @NonNull Observable<R> |
Observable.concatMapMaybeDelayError(@NonNull Function<? super @NonNull T,? extends MaybeSource<? extends @NonNull R>> mapper) |
Maps the upstream items into MaybeSource s and subscribes to them one after the
other terminates, emits their success value if available and delaying all errors
till both the current Observable and all inner MaybeSource s terminate.
|
<@NonNull R> @NonNull Observable<R> |
Observable.concatMapMaybeDelayError(@NonNull Function<? super @NonNull T,? extends MaybeSource<? extends @NonNull R>> mapper,
boolean tillTheEnd) |
Maps the upstream items into MaybeSource s and subscribes to them one after the
other terminates, emits their success value if available and optionally delaying all errors
till both the current Observable and all inner MaybeSource s terminate.
|
<@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 into MaybeSource s and subscribes to them one after the
other terminates, emits their success value if available and optionally delaying all errors
till both the current Observable and all inner MaybeSource s terminate.
|
<@NonNull R> @NonNull Observable<R> |
Observable.concatMapSingle(@NonNull Function<? super @NonNull T,? extends SingleSource<? extends @NonNull R>> mapper) |
Maps the upstream items into SingleSource s and subscribes to them one after the
other succeeds, emits their success values or terminates immediately if
either the current Observable or the current inner SingleSource fail.
|
<@NonNull R> @NonNull Observable<R> |
Observable.concatMapSingle(@NonNull Function<? super @NonNull T,? extends SingleSource<? extends @NonNull R>> mapper,
int bufferSize) |
Maps the upstream items into SingleSource s and subscribes to them one after the
other succeeds, emits their success values or terminates immediately if
either the current Observable or the current inner SingleSource fail.
|
<@NonNull R> @NonNull Observable<R> |
Observable.concatMapSingleDelayError(@NonNull Function<? super @NonNull T,? extends SingleSource<? extends @NonNull R>> mapper) |
Maps the upstream items into SingleSource s and subscribes to them one after the
other succeeds or fails, emits their success values and delays all errors
till both the current Observable and all inner SingleSource s terminate.
|
<@NonNull R> @NonNull Observable<R> |
Observable.concatMapSingleDelayError(@NonNull Function<? super @NonNull T,? extends SingleSource<? extends @NonNull R>> mapper,
boolean tillTheEnd) |
Maps the upstream items into SingleSource s and subscribes to them one after the
other succeeds or fails, emits their success values and optionally delays all errors
till both the current Observable and all inner SingleSource s terminate.
|
<@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 into SingleSource s and subscribes to them one after the
other succeeds or fails, emits their success values and optionally delays errors
till both the current Observable and all inner SingleSource s terminate.
|
<@NonNull R> @NonNull Observable<R> |
Observable.concatMapStream(@NonNull Function<? super @NonNull T,? extends java.util.stream.Stream<? extends @NonNull R>> mapper) |
Maps each upstream item into a Stream and emits the Stream 's items to the downstream in a sequential fashion.
|
@NonNull Observable<T> |
Observable.concatWith(@NonNull CompletableSource other) |
Returns an Observable that emits items from the current Observable and when it completes normally, the
other CompletableSource is subscribed to and the returned Observable emits its terminal events.
|
@NonNull Observable<T> |
Observable.concatWith(@NonNull MaybeSource<? extends @NonNull T> other) |
Returns an Observable that emits the items from the current Observable followed by the success item or terminal events
of the other MaybeSource .
|
@NonNull Observable<T> |
Observable.concatWith(@NonNull ObservableSource<? extends @NonNull T> other) |
Returns an Observable that first emits the items emitted from the current Observable , then items
from the other ObservableSource without interleaving them.
|
@NonNull Observable<T> |
Observable.concatWith(@NonNull SingleSource<? extends @NonNull T> other) |
Returns an Observable that emits the items from the current Observable followed by the success item or error event
of the other SingleSource .
|
static <@NonNull T> @NonNull Observable<T> |
Observable.create(@NonNull ObservableOnSubscribe<@NonNull T> source) |
Provides an API (via a cold Observable ) that bridges the reactive world with the callback-style world.
|
@NonNull Observable<T> |
Observable.debounce(long timeout,
@NonNull java.util.concurrent.TimeUnit unit) |
Returns an Observable that mirrors the current Observable , except that it drops items emitted by the
current Observable that are followed by newer items before a timeout value expires.
|
@NonNull Observable<T> |
Observable.debounce(long timeout,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler) |
Returns an Observable that mirrors the current Observable , except that it drops items emitted by the
current Observable that are followed by newer items before a timeout value expires on a specified
Scheduler .
|
@NonNull Observable<T> |
Observable.debounce(long timeout,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler,
@NonNull Consumer<? super @NonNull T> onDropped) |
Returns an Observable that mirrors the current Observable , except that it drops items emitted by the
current Observable that are followed by newer items before a timeout value expires on a specified
Scheduler .
|
<@NonNull U> @NonNull Observable<T> |
Observable.debounce(@NonNull Function<? super @NonNull T,? extends ObservableSource<@NonNull U>> debounceIndicator) |
Returns an Observable that mirrors the current Observable , except that it drops items emitted by the
current Observable that are followed by another item within a computed debounce duration
denoted by an item emission or completion from a generated inner ObservableSource for that original item.
|
@NonNull Observable<T> |
Observable.defaultIfEmpty(@NonNull T defaultItem) |
Returns an Observable that emits the items emitted by the current Observable or a specified default item
if the current Observable is empty.
|
static <@NonNull T> @NonNull Observable<T> |
Observable.defer(@NonNull Supplier<? extends @NonNull ObservableSource<? extends @NonNull T>> supplier) |
Returns an Observable that calls an ObservableSource factory to create an ObservableSource for each new Observer
that subscribes.
|
@NonNull Observable<T> |
Observable.delay(long time,
@NonNull java.util.concurrent.TimeUnit unit) |
Returns an Observable that emits the items emitted by the current Observable shifted forward in time by a
specified delay.
|
@NonNull Observable<T> |
Observable.delay(long time,
@NonNull java.util.concurrent.TimeUnit unit,
boolean delayError) |
Returns an Observable that emits the items emitted by the current Observable shifted forward in time by a
specified delay.
|
@NonNull Observable<T> |
Observable.delay(long time,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler) |
Returns an Observable that emits the items emitted by the current Observable shifted forward in time by a
specified delay.
|
@NonNull Observable<T> |
Observable.delay(long time,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler,
boolean delayError) |
Returns an Observable that emits the items emitted by the current Observable shifted forward in time by a
specified delay.
|
<@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 an Observable that delays the subscription to and emissions from the current Observable via
ObservableSource s for the subscription itself and on a per-item basis.
|
<@NonNull U> @NonNull Observable<T> |
Observable.delay(@NonNull Function<? super @NonNull T,? extends ObservableSource<@NonNull U>> itemDelayIndicator) |
Returns an Observable that delays the emissions of the current Observable via
a per-item derived ObservableSource 's item emission or termination, on a per source item basis.
|
@NonNull Observable<T> |
Observable.delaySubscription(long time,
@NonNull java.util.concurrent.TimeUnit unit) |
Returns an Observable that delays the subscription to the current Observable by a given amount of time.
|
@NonNull Observable<T> |
Observable.delaySubscription(long time,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler) |
Returns an Observable that delays the subscription to the current Observable by a given amount of time,
both waiting and subscribing on a given Scheduler .
|
<@NonNull U> @NonNull Observable<T> |
Observable.delaySubscription(@NonNull ObservableSource<@NonNull U> subscriptionIndicator) |
Returns an Observable that delays the subscription to the current Observable
until the other ObservableSource emits an element or completes normally.
|
<@NonNull R> @NonNull Observable<R> |
Observable.dematerialize(@NonNull Function<? super @NonNull T,Notification<@NonNull R>> selector) |
Returns an Observable that reverses the effect of materialize by transforming the
Notification objects extracted from the source items via a selector function
into their respective Observer signal types.
|
@NonNull Observable<T> |
Observable.distinct() |
Returns an Observable that emits all items emitted by the current Observable that are distinct
based on Object.equals(Object) comparison.
|
<@NonNull K> @NonNull Observable<T> |
Observable.distinct(@NonNull Function<? super @NonNull T,@NonNull K> keySelector) |
Returns an Observable that emits all items emitted by the current Observable that are distinct according
to a key selector function and based on Object.equals(Object) comparison of the objects
returned by the key selector function.
|
<@NonNull K> @NonNull Observable<T> |
Observable.distinct(@NonNull Function<? super @NonNull T,@NonNull K> keySelector,
@NonNull Supplier<? extends java.util.Collection<? super @NonNull K>> collectionSupplier) |
Returns an Observable that emits all items emitted by the current Observable that are distinct according
to a key selector function and based on Object.equals(Object) comparison of the objects
returned by the key selector function.
|
@NonNull Observable<T> |
Observable.distinctUntilChanged() |
Returns an Observable that emits all items emitted by the current Observable that are distinct from their
immediate predecessors based on Object.equals(Object) comparison.
|
@NonNull Observable<T> |
Observable.distinctUntilChanged(@NonNull BiPredicate<? super @NonNull T,? super @NonNull T> comparer) |
Returns an Observable that emits all items emitted by the current Observable that are distinct from their
immediate predecessors when compared with each other via the provided comparator function.
|
<@NonNull K> @NonNull Observable<T> |
Observable.distinctUntilChanged(@NonNull Function<? super @NonNull T,@NonNull K> keySelector) |
Returns an Observable that emits all items emitted by the current Observable that are distinct from their
immediate predecessors, according to a key selector function and based on Object.equals(Object) comparison
of those objects returned by the key selector function.
|
@NonNull Observable<T> |
Observable.doAfterNext(@NonNull Consumer<? super @NonNull T> onAfterNext) |
Calls the specified Consumer with the current item after this item has been emitted to the downstream.
|
@NonNull Observable<T> |
Observable.doAfterTerminate(@NonNull Action onAfterTerminate) |
|
@NonNull Observable<T> |
Observable.doFinally(@NonNull Action onFinally) |
Calls the specified action after the current Observable signals onError or onCompleted or gets disposed by
the downstream.
|
@NonNull Observable<T> |
Observable.doOnComplete(@NonNull Action onComplete) |
Returns an Observable that invokes an Action when the current Observable calls onComplete .
|
@NonNull Observable<T> |
Observable.doOnDispose(@NonNull Action onDispose) |
Calls the given shared Action if the downstream disposes the sequence.
|
@NonNull Observable<T> |
Observable.doOnEach(@NonNull Observer<? super @NonNull T> observer) |
Returns an Observable that forwards the items and terminal events of the current
Observable to its Observer s and to the given shared Observer instance.
|
@NonNull Observable<T> |
Observable.doOnEach(@NonNull Consumer<? super Notification<@NonNull T>> onNotification) |
Returns an Observable that invokes a Consumer with the appropriate Notification
object when the current Observable signals an item or terminates.
|
private @NonNull Observable<T> |
Observable.doOnEach(@NonNull Consumer<? super @NonNull T> onNext,
@NonNull Consumer<? super java.lang.Throwable> onError,
@NonNull Action onComplete,
@NonNull Action onAfterTerminate) |
Calls the appropriate onXXX consumer (shared between all Observer s) whenever a signal with the same type
passes through, before forwarding them to the downstream.
|
@NonNull Observable<T> |
Observable.doOnError(@NonNull Consumer<? super java.lang.Throwable> onError) |
Calls the given Consumer with the error Throwable if the current Observable failed before forwarding it to
the downstream.
|
@NonNull Observable<T> |
Observable.doOnLifecycle(@NonNull Consumer<? super Disposable> onSubscribe,
@NonNull Action onDispose) |
Calls the appropriate onXXX method (shared between all Observer s) for the lifecycle events of
the sequence (subscription, disposal).
|
@NonNull Observable<T> |
Observable.doOnNext(@NonNull Consumer<? super @NonNull T> onNext) |
Calls the given Consumer with the value emitted by the current Observable before forwarding it to the downstream.
|
@NonNull Observable<T> |
Observable.doOnSubscribe(@NonNull Consumer<? super Disposable> onSubscribe) |
Returns an Observable so that it invokes the given Consumer when the current Observable is subscribed from
its Observer s.
|
@NonNull Observable<T> |
Observable.doOnTerminate(@NonNull Action onTerminate) |
Returns an Observable so that it invokes an action when the current Observable calls onComplete or
onError .
|
static <@NonNull T> @NonNull Observable<T> |
Observable.empty() |
Returns an Observable that emits no items to the Observer and immediately invokes its
onComplete method.
|
static <@NonNull T> @NonNull Observable<T> |
Observable.error(@NonNull Supplier<? extends @NonNull java.lang.Throwable> supplier) |
Returns an Observable that invokes an Observer 's onError method when the
Observer subscribes to it.
|
static <@NonNull T> @NonNull Observable<T> |
Observable.error(@NonNull java.lang.Throwable throwable) |
Returns an Observable that invokes an Observer 's onError method when the
Observer subscribes to it.
|
@NonNull Observable<T> |
Observable.filter(@NonNull Predicate<? super @NonNull T> predicate) |
Filters items emitted by the current Observable by only emitting those that satisfy a specified Predicate .
|
<@NonNull R> @NonNull Observable<R> |
Observable.flatMap(@NonNull Function<? super @NonNull T,? extends ObservableSource<? extends @NonNull R>> mapper) |
Returns an Observable that emits items based on applying a function that you supply to each item emitted
by the current Observable , where that function returns an ObservableSource , and then merging those returned
ObservableSource s and emitting the results of this merger.
|
<@NonNull R> @NonNull Observable<R> |
Observable.flatMap(@NonNull Function<? super @NonNull T,? extends ObservableSource<? extends @NonNull R>> mapper,
boolean delayErrors) |
Returns an Observable that emits items based on applying a function that you supply to each item emitted
by the current Observable , where that function returns an ObservableSource , and then merging those returned
ObservableSource s and emitting the results of this merger.
|
<@NonNull R> @NonNull Observable<R> |
Observable.flatMap(@NonNull Function<? super @NonNull T,? extends ObservableSource<? extends @NonNull R>> mapper,
boolean delayErrors,
int maxConcurrency) |
Returns an Observable that emits items based on applying a function that you supply to each item emitted
by the current Observable , where that function returns an ObservableSource , and then merging those returned
ObservableSource s and emitting the results of this merger, while limiting the maximum number of concurrent
subscriptions to these ObservableSource s.
|
<@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 an Observable that emits items based on applying a function that you supply to each item emitted
by the current Observable , where that function returns an ObservableSource , and then merging those returned
ObservableSource s and emitting the results of this merger, while limiting the maximum number of concurrent
subscriptions to these ObservableSource s.
|
<@NonNull R> @NonNull Observable<R> |
Observable.flatMap(@NonNull Function<? super @NonNull T,? extends ObservableSource<? extends @NonNull R>> mapper,
int maxConcurrency) |
Returns an Observable that emits items based on applying a function that you supply to each item emitted
by the current Observable , where that function returns an ObservableSource , and then merging those returned
ObservableSource s and emitting the results of this merger, while limiting the maximum number of concurrent
subscriptions to these ObservableSource s.
|
<@NonNull R> @NonNull Observable<R> |
Observable.flatMap(@NonNull Function<? super @NonNull T,? extends ObservableSource<? extends @NonNull R>> onNextMapper,
@NonNull Function<? super java.lang.Throwable,? extends ObservableSource<? extends @NonNull R>> onErrorMapper,
@NonNull Supplier<? extends ObservableSource<? extends @NonNull R>> onCompleteSupplier) |
Returns an Observable that applies a function to each item emitted or notification raised by the current
Observable and then flattens the ObservableSource s returned from these functions and emits the resulting items.
|
<@NonNull R> @NonNull Observable<R> |
Observable.flatMap(@NonNull Function<? super @NonNull T,? extends ObservableSource<? extends @NonNull R>> onNextMapper,
@NonNull Function<java.lang.Throwable,? extends ObservableSource<? extends @NonNull R>> onErrorMapper,
@NonNull Supplier<? extends ObservableSource<? extends @NonNull R>> onCompleteSupplier,
int maxConcurrency) |
Returns an Observable that applies a function to each item emitted or notification raised by the current
Observable and then flattens the ObservableSource s returned from these functions and emits the resulting items,
while limiting the maximum number of concurrent subscriptions to these ObservableSource s.
|
<@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 an Observable that emits the results of a specified function to the pair of values emitted by the
current Observable and the mapped inner ObservableSource .
|
<@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 an Observable that emits the results of a specified function to the pair of values emitted by the
current Observable and the mapped inner ObservableSource .
|
<@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 an Observable that emits the results of a specified function to the pair of values emitted by the
current Observable and the mapped inner ObservableSource , while limiting the maximum number of concurrent
subscriptions to these ObservableSource s.
|
<@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 an Observable that emits the results of a specified function to the pair of values emitted by the
current Observable and the mapped inner ObservableSource , while limiting the maximum number of concurrent
subscriptions to these ObservableSource s.
|
<@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 an Observable that emits the results of a specified function to the pair of values emitted by the
current Observable and the mapped inner ObservableSource , while limiting the maximum number of concurrent
subscriptions to these ObservableSource s.
|
<@NonNull U> @NonNull Observable<U> |
Observable.flatMapIterable(@NonNull Function<? super @NonNull T,? extends java.lang.Iterable<? extends @NonNull U>> mapper) |
Merges Iterable s generated by a mapper Function for each individual item emitted by
the current Observable into a single Observable sequence.
|
<@NonNull U,@NonNull V> @NonNull Observable<V> |
Observable.flatMapIterable(@NonNull Function<? super @NonNull T,? extends java.lang.Iterable<? extends @NonNull U>> mapper,
@NonNull BiFunction<? super @NonNull T,? super @NonNull U,? extends @NonNull V> combiner) |
Merges Iterable s generated by a mapper Function for each individual item emitted by
the current Observable into a single Observable sequence where the resulting items will
be the combination of the original item and each inner item of the respective Iterable as returned
by the resultSelector BiFunction .
|
<@NonNull R> @NonNull Observable<R> |
Observable.flatMapMaybe(@NonNull Function<? super @NonNull T,? extends MaybeSource<? extends @NonNull R>> mapper) |
Maps each element of the current Observable into MaybeSource s, subscribes to all of them
and merges their onSuccess values, in no particular order, into a single Observable sequence.
|
<@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 current Observable into MaybeSource s, subscribes to them
and merges their onSuccess values, in no particular order, into a single Observable sequence,
optionally delaying all errors.
|
<@NonNull R> @NonNull Observable<R> |
Maybe.flatMapObservable(@NonNull Function<? super @NonNull T,? extends ObservableSource<? extends @NonNull R>> mapper) |
Returns an Observable that is based on applying a specified function to the item emitted by the current Maybe ,
where that function returns an ObservableSource .
|
<@NonNull R> @NonNull Observable<R> |
Single.flatMapObservable(@NonNull Function<? super @NonNull T,? extends ObservableSource<? extends @NonNull R>> mapper) |
Returns an Observable that is based on applying a specified function to the item emitted by the current Single ,
where that function returns an ObservableSource .
|
<@NonNull R> @NonNull Observable<R> |
Observable.flatMapSingle(@NonNull Function<? super @NonNull T,? extends SingleSource<? extends @NonNull R>> mapper) |
Maps each element of the current Observable into SingleSource s, subscribes to all of them
and merges their onSuccess values, in no particular order, into a single Observable sequence.
|
<@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 current Observable into SingleSource s, subscribes to them
and merges their onSuccess values, in no particular order, into a single Observable sequence,
optionally delaying all errors.
|
<@NonNull R> @NonNull Observable<R> |
Observable.flatMapStream(@NonNull Function<? super @NonNull T,? extends java.util.stream.Stream<? extends @NonNull R>> mapper) |
Maps each upstream item into a Stream and emits the Stream 's items to the downstream in a sequential fashion.
|
<@NonNull U> @NonNull Observable<U> |
Maybe.flattenAsObservable(@NonNull Function<? super @NonNull T,? extends java.lang.Iterable<? extends @NonNull U>> mapper) |
Maps the success value of the current Maybe into an Iterable and emits its items as an
Observable sequence.
|
<@NonNull U> @NonNull Observable<U> |
Single.flattenAsObservable(@NonNull Function<? super @NonNull T,? extends java.lang.Iterable<? extends @NonNull U>> mapper) |
Maps the success value of the current Single into an Iterable and emits its items as an
Observable sequence.
|
<@NonNull R> @NonNull Observable<R> |
Maybe.flattenStreamAsObservable(@NonNull Function<? super @NonNull T,? extends java.util.stream.Stream<? extends @NonNull R>> mapper) |
Maps the upstream succecss value into a Java Stream and emits its
items to the downstream consumer as an Observable .
|
<@NonNull R> @NonNull Observable<R> |
Single.flattenStreamAsObservable(@NonNull Function<? super @NonNull T,? extends java.util.stream.Stream<? extends @NonNull R>> mapper) |
Maps the upstream succecss value into a Java Stream and emits its
items to the downstream consumer as an Observable .
|
static <@NonNull T> @NonNull Observable<T> |
Observable.fromAction(@NonNull Action action) |
Returns an Observable instance that runs the given Action for each Observer and
emits either its exception or simply completes.
|
static <@NonNull T> @NonNull Observable<T> |
Observable.fromArray(@NonNull T... items) |
|
static <@NonNull T> @NonNull Observable<T> |
Observable.fromCallable(@NonNull java.util.concurrent.Callable<? extends @NonNull T> callable) |
Returns an Observable that, when an observer subscribes to it, invokes a function you specify and then
emits the value returned from that function.
|
static <@NonNull T> @NonNull Observable<T> |
Observable.fromCompletable(@NonNull CompletableSource completableSource) |
|
static <@NonNull T> @NonNull Observable<@NonNull T> |
Observable.fromCompletionStage(@NonNull java.util.concurrent.CompletionStage<@NonNull T> stage) |
Signals the completion value or error of the given (hot) CompletionStage -based asynchronous calculation.
|
static <@NonNull T> @NonNull Observable<T> |
Observable.fromFuture(@NonNull java.util.concurrent.Future<? extends @NonNull T> future) |
Converts a Future into an Observable .
|
static <@NonNull T> @NonNull Observable<T> |
Observable.fromFuture(@NonNull java.util.concurrent.Future<? extends @NonNull T> future,
long timeout,
@NonNull java.util.concurrent.TimeUnit unit) |
Converts a Future into an Observable , with a timeout on the Future .
|
static <@NonNull T> @NonNull Observable<T> |
Observable.fromIterable(@NonNull java.lang.Iterable<? extends @NonNull T> source) |
Converts an Iterable sequence into an Observable that emits the items in the sequence.
|
static <@NonNull T> @NonNull Observable<T> |
Observable.fromMaybe(@NonNull MaybeSource<@NonNull T> maybe) |
Returns an Observable instance that when subscribed to, subscribes to the MaybeSource instance and
emits onSuccess as a single item or forwards any onComplete or
onError signal.
|
static <@NonNull T> @NonNull Observable<@NonNull T> |
Observable.fromOptional(@NonNull java.util.Optional<@NonNull T> optional) |
Converts the existing value of the provided optional into a just(Object)
or an empty optional into an empty() Observable instance.
|
static <@NonNull T> @NonNull Observable<T> |
Observable.fromPublisher(@NonNull org.reactivestreams.Publisher<? extends @NonNull T> publisher) |
Converts an arbitrary Reactive Streams Publisher into an Observable .
|
static <@NonNull T> @NonNull Observable<T> |
Observable.fromRunnable(@NonNull java.lang.Runnable run) |
Returns an Observable instance that runs the given Runnable for each Observer and
emits either its unchecked exception or simply completes.
|
static <@NonNull T> @NonNull Observable<T> |
Observable.fromSingle(@NonNull SingleSource<@NonNull T> source) |
Returns an Observable instance that when subscribed to, subscribes to the SingleSource instance and
emits onSuccess as a single item or forwards the onError signal.
|
static <@NonNull T> @NonNull Observable<@NonNull T> |
Observable.fromStream(@NonNull java.util.stream.Stream<@NonNull T> stream) |
Converts a Stream into a finite Observable and emits its items in the sequence.
|
static <@NonNull T> @NonNull Observable<T> |
Observable.fromSupplier(@NonNull Supplier<? extends @NonNull T> supplier) |
Returns an Observable that, when an observer subscribes to it, invokes a supplier function you specify and then
emits the value returned from that function.
|
static <@NonNull T> @NonNull Observable<T> |
Observable.generate(@NonNull Consumer<Emitter<@NonNull T>> generator) |
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.
|
<@NonNull K> @NonNull Observable<GroupedObservable<K,T>> |
Observable.groupBy(@NonNull Function<? super @NonNull T,? extends @NonNull K> keySelector) |
Groups the items emitted by the current Observable according to a specified criterion, and emits these
grouped items as GroupedObservable s.
|
<@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 current Observable according to a specified criterion, and emits these
grouped items as GroupedObservable s.
|
<@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 current Observable according to a specified criterion, and emits these
grouped items as GroupedObservable s.
|
<@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 current Observable according to a specified criterion, and emits these
grouped items as GroupedObservable s.
|
<@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 current Observable according to a specified criterion, and emits these
grouped items as GroupedObservable s.
|
<@NonNull TRight,@NonNull TLeftEnd,@NonNull TRightEnd,@NonNull R> @NonNull Observable<R> |
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 an Observable that correlates two ObservableSource s when they overlap in time and groups the results.
|
@NonNull Observable<T> |
Observable.hide() |
Hides the identity of the current Observable and its Disposable .
|
static @NonNull Observable<java.lang.Long> |
Observable.interval(long initialDelay,
long period,
@NonNull java.util.concurrent.TimeUnit unit) |
Returns an Observable that emits a 0L after the initialDelay and ever increasing numbers
after each period of time thereafter.
|
static @NonNull Observable<java.lang.Long> |
Observable.interval(long initialDelay,
long period,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler) |
Returns an Observable that emits a 0L after the initialDelay and ever increasing numbers
after each period of time thereafter, on a specified Scheduler .
|
static @NonNull Observable<java.lang.Long> |
Observable.interval(long period,
@NonNull java.util.concurrent.TimeUnit unit) |
Returns an Observable that emits a sequential number every specified interval of time.
|
static @NonNull Observable<java.lang.Long> |
Observable.interval(long period,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler) |
Returns an Observable that emits a sequential number every specified interval of time, on a
specified Scheduler .
|
static @NonNull Observable<java.lang.Long> |
Observable.intervalRange(long start,
long count,
long initialDelay,
long period,
@NonNull java.util.concurrent.TimeUnit unit) |
Signals a range of long values, the first after some initial delay and the rest periodically after.
|
static @NonNull Observable<java.lang.Long> |
Observable.intervalRange(long start,
long count,
long initialDelay,
long period,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler) |
Signals a range of long values, the first after some initial delay and the rest periodically after.
|
<@NonNull TRight,@NonNull TLeftEnd,@NonNull TRightEnd,@NonNull R> @NonNull Observable<R> |
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 two ObservableSource s based on overlapping durations.
|
static <@NonNull T> @NonNull Observable<T> |
Observable.just(@NonNull T item) |
Returns an Observable that signals the given (constant reference) item and then completes.
|
static <@NonNull T> @NonNull Observable<T> |
Observable.just(@NonNull T item1,
@NonNull T item2) |
Converts two items into an Observable that emits those items.
|
static <@NonNull T> @NonNull Observable<T> |
Observable.just(@NonNull T item1,
@NonNull T item2,
@NonNull T item3) |
Converts three items into an Observable that emits those items.
|
static <@NonNull T> @NonNull Observable<T> |
Observable.just(@NonNull T item1,
@NonNull T item2,
@NonNull T item3,
@NonNull T item4) |
Converts four items into an Observable 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 an Observable 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 an Observable 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 an Observable 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 an Observable 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 an Observable 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 an Observable that emits those items.
|
<@NonNull R> @NonNull Observable<R> |
Observable.lift(@NonNull ObservableOperator<? extends @NonNull R,? super @NonNull T> lifter) |
This method requires advanced knowledge about building operators, please consider
other standard composition methods first;
Returns an Observable which, when subscribed to, invokes the apply(Observer) method
of the provided ObservableOperator for each individual downstream Observer and allows the
insertion of a custom operator by accessing the downstream's Observer during this subscription phase
and providing a new Observer , containing the custom operator's intended business logic, that will be
used in the subscription process going further upstream.
|
<@NonNull R> @NonNull Observable<R> |
Observable.map(@NonNull Function<? super @NonNull T,? extends @NonNull R> mapper) |
Returns an Observable that applies a specified function to each item emitted by the current Observable and
emits the results of these function applications.
|
<@NonNull R> @NonNull Observable<R> |
Observable.mapOptional(@NonNull Function<? super @NonNull T,@NonNull java.util.Optional<? extends @NonNull R>> mapper) |
Maps each upstream value into an Optional and emits the contained item if not empty.
|
@NonNull Observable<Notification<T>> |
Observable.materialize() |
Returns an Observable that represents all of the emissions and notifications from the current
Observable into emissions marked with their original types within Notification objects.
|
static <@NonNull T> @NonNull Observable<T> |
Observable.merge(@NonNull ObservableSource<? extends ObservableSource<? extends @NonNull T>> sources) |
Flattens an ObservableSource that emits ObservableSource s into a single Observable that emits the items emitted by
those ObservableSource s, without any transformation.
|
static <@NonNull T> @NonNull Observable<T> |
Observable.merge(@NonNull ObservableSource<? extends ObservableSource<? extends @NonNull T>> sources,
int maxConcurrency) |
Flattens an ObservableSource that emits ObservableSource s into a single Observable that emits the items emitted by
those ObservableSource s, without any transformation, while limiting the maximum number of concurrent
subscriptions to these ObservableSource s.
|
static <@NonNull T> @NonNull Observable<T> |
Observable.merge(@NonNull ObservableSource<? extends @NonNull T> source1,
@NonNull ObservableSource<? extends @NonNull T> source2) |
Flattens two ObservableSource s into a single Observable , 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 three ObservableSource s into a single Observable , 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 four ObservableSource s into a single Observable , without any transformation.
|
static <@NonNull T> @NonNull Observable<T> |
Observable.merge(@NonNull java.lang.Iterable<? extends ObservableSource<? extends @NonNull T>> sources) |
Flattens an Iterable of ObservableSource s into one Observable , without any transformation.
|
static <@NonNull T> @NonNull Observable<T> |
Observable.merge(@NonNull java.lang.Iterable<? extends ObservableSource<? extends @NonNull T>> sources,
int maxConcurrency) |
Flattens an Iterable of ObservableSource s into one Observable , without any transformation, while limiting the
number of concurrent subscriptions to these ObservableSource s.
|
static <@NonNull T> @NonNull Observable<T> |
Observable.merge(@NonNull java.lang.Iterable<? extends ObservableSource<? extends @NonNull T>> sources,
int maxConcurrency,
int bufferSize) |
Flattens an Iterable of ObservableSource s into one Observable , without any transformation, while limiting the
number of concurrent subscriptions to these ObservableSource s.
|
static <@NonNull T> @NonNull Observable<T> |
Observable.mergeArray(int maxConcurrency,
int bufferSize,
@NonNull ObservableSource<? extends @NonNull T>... sources) |
Flattens an array of ObservableSource s into one Observable , without any transformation, while limiting the
number of concurrent subscriptions to these ObservableSource s.
|
static <@NonNull T> @NonNull Observable<T> |
Observable.mergeArray(@NonNull ObservableSource<? extends @NonNull T>... sources) |
Flattens an array of ObservableSource s into one Observable , without any transformation.
|
static <@NonNull T> @NonNull Observable<T> |
Observable.mergeArrayDelayError(int maxConcurrency,
int bufferSize,
@NonNull ObservableSource<? extends @NonNull T>... sources) |
Flattens an array of ObservableSource s into one Observable , in a way that allows an Observer to receive all
successfully emitted items from each of the ObservableSource s without being interrupted by an error
notification from one of them, while limiting the number of concurrent subscriptions to these ObservableSource s.
|
static <@NonNull T> @NonNull Observable<T> |
Observable.mergeArrayDelayError(@NonNull ObservableSource<? extends @NonNull T>... sources) |
Flattens an array of ObservableSource s into one Observable , in a way that allows an Observer to receive all
successfully emitted items from each of the ObservableSource 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) |
Flattens an ObservableSource that emits ObservableSource s into one Observable , in a way that allows an Observer to
receive all successfully emitted items from all of the emitted ObservableSource 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 an ObservableSource that emits ObservableSource s into one Observable , in a way that allows an Observer to
receive all successfully emitted items from all of the emitted ObservableSource s without being interrupted by
an error notification from one of them, while limiting the
number of concurrent subscriptions to these ObservableSource s.
|
static <@NonNull T> @NonNull Observable<T> |
Observable.mergeDelayError(@NonNull ObservableSource<? extends @NonNull T> source1,
@NonNull ObservableSource<? extends @NonNull T> source2) |
Flattens two ObservableSource s into one Observable , in a way that allows an Observer to receive all
successfully emitted items from each of the ObservableSource 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 three ObservableSource s into one Observable , in a way that allows an Observer to receive all
successfully emitted items from all of the ObservableSource 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 four ObservableSource s into one Observable , in a way that allows an Observer to receive all
successfully emitted items from all of the ObservableSource s without being interrupted by an error
notification from one of them.
|
static <@NonNull T> @NonNull Observable<T> |
Observable.mergeDelayError(@NonNull java.lang.Iterable<? extends ObservableSource<? extends @NonNull T>> sources) |
Flattens an Iterable of ObservableSource s into one Observable , in a way that allows an Observer to receive all
successfully emitted items from each of the returned ObservableSource s without being interrupted by an error
notification from one of them.
|
static <@NonNull T> @NonNull Observable<T> |
Observable.mergeDelayError(@NonNull java.lang.Iterable<? extends ObservableSource<? extends @NonNull T>> sources,
int maxConcurrency) |
Flattens an Iterable of ObservableSource s into one Observable , in a way that allows an Observer to receive all
successfully emitted items from each of the returned ObservableSource s without being interrupted by an error
notification from one of them, while limiting the number of concurrent subscriptions to these ObservableSource s.
|
static <@NonNull T> @NonNull Observable<T> |
Observable.mergeDelayError(@NonNull java.lang.Iterable<? extends ObservableSource<? extends @NonNull T>> sources,
int maxConcurrency,
int bufferSize) |
Flattens an Iterable of ObservableSource s into one Observable , in a way that allows an Observer to receive all
successfully emitted items from each of the returned ObservableSource s without being interrupted by an error
notification from one of them, while limiting the number of concurrent subscriptions to these ObservableSource s.
|
@NonNull Observable<T> |
Observable.mergeWith(@NonNull CompletableSource other) |
Relays the items of the current Observable and completes only when the other CompletableSource completes
as well.
|
@NonNull Observable<T> |
Observable.mergeWith(@NonNull MaybeSource<? extends @NonNull T> other) |
Merges the sequence of items of the current Observable with the success value of the other MaybeSource
or waits both to complete normally if the MaybeSource is empty.
|
@NonNull Observable<T> |
Observable.mergeWith(@NonNull ObservableSource<? extends @NonNull T> other) |
Flattens the current Observable and another ObservableSource into a single Observable sequence, without any transformation.
|
@NonNull Observable<T> |
Observable.mergeWith(@NonNull SingleSource<? extends @NonNull T> other) |
Merges the sequence of items of the current Observable with the success value of the other SingleSource .
|
static <@NonNull T> @NonNull Observable<T> |
Observable.never() |
Returns an Observable that never sends any items or notifications to an Observer .
|
@NonNull Observable<T> |
Observable.observeOn(@NonNull Scheduler scheduler) |
Returns an Observable to perform the current Observable 's emissions and notifications on a specified Scheduler ,
asynchronously with an unbounded buffer with Flowable.bufferSize() "island size".
|
@NonNull Observable<T> |
Observable.observeOn(@NonNull Scheduler scheduler,
boolean delayError) |
Returns an Observable to perform the current Observable 's emissions and notifications on a specified Scheduler ,
asynchronously with an unbounded buffer with Flowable.bufferSize() "island size" and optionally delays onError notifications.
|
@NonNull Observable<T> |
Observable.observeOn(@NonNull Scheduler scheduler,
boolean delayError,
int bufferSize) |
Returns an Observable to perform the current Observable 's emissions and notifications on a specified Scheduler ,
asynchronously with an unbounded buffer of configurable "island size" and optionally delays onError notifications.
|
<@NonNull U> @NonNull Observable<U> |
Observable.ofType(@NonNull java.lang.Class<@NonNull U> clazz) |
Filters the items emitted by the current Observable , only emitting those of the specified type.
|
@NonNull Observable<T> |
Observable.onErrorComplete() |
Returns an Observable instance that if the current Observable emits an error, it will emit an onComplete
and swallow the throwable.
|
@NonNull Observable<T> |
Observable.onErrorComplete(@NonNull Predicate<? super java.lang.Throwable> predicate) |
Returns an Observable instance that if the current Observable emits an error and the predicate returns
true , it will emit an onComplete and swallow the throwable.
|
@NonNull Observable<T> |
Observable.onErrorResumeNext(@NonNull Function<? super java.lang.Throwable,? extends ObservableSource<? extends @NonNull T>> fallbackSupplier) |
Resumes the flow with an ObservableSource returned for the failure Throwable of the current Observable by a
function instead of signaling the error via onError .
|
@NonNull Observable<T> |
Observable.onErrorResumeWith(@NonNull ObservableSource<? extends @NonNull T> fallback) |
Resumes the flow with the given ObservableSource when the current Observable fails instead of
signaling the error via onError .
|
@NonNull Observable<T> |
Observable.onErrorReturn(@NonNull Function<? super java.lang.Throwable,? extends @NonNull T> itemSupplier) |
Ends the flow with a last item returned by a function for the Throwable error signaled by the current
Observable instead of signaling the error via onError .
|
@NonNull Observable<T> |
Observable.onErrorReturnItem(@NonNull T item) |
Ends the flow with the given last item when the current Observable fails instead of signaling the error via onError .
|
@NonNull Observable<T> |
Observable.onTerminateDetach() |
Nulls out references to the upstream producer and downstream Observer if
the sequence is terminated or downstream calls dispose() .
|
<@NonNull R> @NonNull Observable<R> |
Observable.publish(@NonNull Function<? super Observable<@NonNull T>,? extends ObservableSource<@NonNull R>> selector) |
Returns an Observable that emits the results of invoking a specified selector on items emitted by a
ConnectableObservable that shares a single subscription to the current Observable sequence.
|
static @NonNull Observable<java.lang.Integer> |
Observable.range(int start,
int count) |
Returns an Observable that emits a sequence of Integer s within a specified range.
|
static @NonNull Observable<java.lang.Long> |
Observable.rangeLong(long start,
long count) |
Returns an Observable that emits a sequence of Long s within a specified range.
|
@NonNull Observable<T> |
Observable.repeat() |
Returns an Observable that repeats the sequence of items emitted by the current Observable indefinitely.
|
@NonNull Observable<T> |
Observable.repeat(long times) |
Returns an Observable that repeats the sequence of items emitted by the current Observable at most
count times.
|
@NonNull Observable<T> |
Observable.repeatUntil(@NonNull BooleanSupplier stop) |
Returns an Observable that repeats the sequence of items emitted by the current Observable until
the provided stop function returns true .
|
@NonNull Observable<T> |
Observable.repeatWhen(@NonNull Function<? super Observable<java.lang.Object>,? extends ObservableSource<?>> handler) |
Returns an Observable that emits the same values as the current Observable with the exception of an
onComplete .
|
<@NonNull R> @NonNull Observable<R> |
Observable.replay(@NonNull Function<? super Observable<@NonNull T>,? extends ObservableSource<@NonNull R>> selector) |
Returns an Observable that emits items that are the results of invoking a specified selector on the items
emitted by a ConnectableObservable that shares a single subscription to the current Observable .
|
<@NonNull R> @NonNull Observable<R> |
Observable.replay(@NonNull Function<? super Observable<@NonNull T>,? extends ObservableSource<@NonNull R>> selector,
int bufferSize) |
Returns an Observable that emits items that are the results of invoking a specified selector on items
emitted by a ConnectableObservable that shares a single subscription to the current Observable ,
replaying bufferSize notifications.
|
<@NonNull R> @NonNull Observable<R> |
Observable.replay(@NonNull Function<? super Observable<@NonNull T>,? extends ObservableSource<@NonNull R>> selector,
int bufferSize,
boolean eagerTruncate) |
Returns an Observable that emits items that are the results of invoking a specified selector on items
emitted by a ConnectableObservable that shares a single subscription to the current Observable ,
replaying bufferSize notifications.
|
<@NonNull R> @NonNull Observable<R> |
Observable.replay(@NonNull Function<? super Observable<@NonNull T>,? extends ObservableSource<@NonNull R>> selector,
int bufferSize,
long time,
@NonNull java.util.concurrent.TimeUnit unit) |
Returns an Observable that emits items that are the results of invoking a specified selector on items
emitted by a ConnectableObservable that shares a single subscription to the current Observable ,
replaying no more than bufferSize items that were emitted within a specified time window.
|
<@NonNull R> @NonNull Observable<R> |
Observable.replay(@NonNull Function<? super Observable<@NonNull T>,? extends ObservableSource<@NonNull R>> selector,
int bufferSize,
long time,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler) |
Returns an Observable that emits items that are the results of invoking a specified selector on items
emitted by a ConnectableObservable that shares a single subscription to the current Observable ,
replaying no more than bufferSize items that were emitted within a specified time window.
|
<@NonNull R> @NonNull Observable<R> |
Observable.replay(@NonNull Function<? super Observable<@NonNull T>,? extends ObservableSource<@NonNull R>> selector,
int bufferSize,
long time,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler,
boolean eagerTruncate) |
Returns an Observable that emits items that are the results of invoking a specified selector on items
emitted by a ConnectableObservable that shares a single subscription to the current Observable ,
replaying no more than bufferSize items that were emitted within a specified time window.
|
<@NonNull R> @NonNull Observable<R> |
Observable.replay(@NonNull Function<? super Observable<@NonNull T>,? extends ObservableSource<@NonNull R>> selector,
long time,
@NonNull java.util.concurrent.TimeUnit unit) |
Returns an Observable that emits items that are the results of invoking a specified selector on items
emitted by a ConnectableObservable that shares a single subscription to the current Observable ,
replaying all items that were emitted within a specified time window.
|
<@NonNull R> @NonNull Observable<R> |
Observable.replay(@NonNull Function<? super Observable<@NonNull T>,? extends ObservableSource<@NonNull R>> selector,
long time,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler) |
Returns an Observable that emits items that are the results of invoking a specified selector on items
emitted by a ConnectableObservable that shares a single subscription to the current Observable ,
replaying all items that were emitted within a specified time window.
|
<@NonNull R> @NonNull Observable<R> |
Observable.replay(@NonNull Function<? super Observable<@NonNull T>,? extends ObservableSource<@NonNull R>> selector,
long time,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler,
boolean eagerTruncate) |
Returns an Observable that emits items that are the results of invoking a specified selector on items
emitted by a ConnectableObservable that shares a single subscription to the current Observable ,
replaying all items that were emitted within a specified time window.
|
@NonNull Observable<T> |
Observable.retry() |
Returns an Observable that mirrors the current Observable , resubscribing to it if it calls onError
(infinite retry count).
|
@NonNull Observable<T> |
Observable.retry(long times) |
Returns an Observable that mirrors the current Observable , resubscribing to it if it calls onError
up to a specified number of retries.
|
@NonNull Observable<T> |
Observable.retry(long times,
@NonNull Predicate<? super java.lang.Throwable> predicate) |
Retries at most times or until the predicate returns false , whichever happens first.
|
@NonNull Observable<T> |
Observable.retry(@NonNull BiPredicate<? super java.lang.Integer,? super java.lang.Throwable> predicate) |
Returns an Observable that mirrors the current Observable , resubscribing to it if it calls onError
and the predicate returns true for that specific exception and retry count.
|
@NonNull Observable<T> |
Observable.retry(@NonNull Predicate<? super java.lang.Throwable> predicate) |
Retries the current Observable if the predicate returns true .
|
@NonNull Observable<T> |
Observable.retryUntil(@NonNull BooleanSupplier stop) |
Retries until the given stop function returns true .
|
@NonNull Observable<T> |
Observable.retryWhen(@NonNull Function<? super Observable<java.lang.Throwable>,? extends ObservableSource<?>> handler) |
Returns an Observable that emits the same values as the current Observable with the exception of an
onError .
|
@NonNull Observable<T> |
Observable.sample(long period,
@NonNull java.util.concurrent.TimeUnit unit) |
Returns an Observable that emits the most recently emitted item (if any) emitted by the current Observable
within periodic time intervals.
|
@NonNull Observable<T> |
Observable.sample(long period,
@NonNull java.util.concurrent.TimeUnit unit,
boolean emitLast) |
Returns an Observable that emits the most recently emitted item (if any) emitted by the current Observable
within periodic time intervals and optionally emit the very last upstream item when the upstream completes.
|
@NonNull Observable<T> |
Observable.sample(long period,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler) |
Returns an Observable that emits the most recently emitted item (if any) emitted by the current Observable
within periodic time intervals, where the intervals are defined on a particular Scheduler .
|
@NonNull Observable<T> |
Observable.sample(long period,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler,
boolean emitLast) |
Returns an Observable that emits the most recently emitted item (if any) emitted by the current Observable
within periodic time intervals, where the intervals are defined on a particular Scheduler
and optionally emit the very last upstream item when the upstream completes.
|
@NonNull Observable<T> |
Observable.sample(long period,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler,
boolean emitLast,
@NonNull Consumer<? super @NonNull T> onDropped) |
Returns an Observable that emits the most recently emitted item (if any) emitted by the current Observable
within periodic time intervals, where the intervals are defined on a particular Scheduler .
|
<@NonNull U> @NonNull Observable<T> |
Observable.sample(@NonNull ObservableSource<@NonNull U> sampler) |
Returns an Observable that, when the specified sampler ObservableSource emits an item or completes,
emits the most recently emitted item (if any) emitted by the current Observable since the previous
emission from the sampler ObservableSource .
|
<@NonNull U> @NonNull Observable<T> |
Observable.sample(@NonNull ObservableSource<@NonNull U> sampler,
boolean emitLast) |
Returns an Observable that, when the specified sampler ObservableSource emits an item or completes,
emits the most recently emitted item (if any) emitted by the current Observable since the previous
emission from the sampler ObservableSource
and optionally emit the very last upstream item when the upstream or other ObservableSource complete.
|
@NonNull Observable<T> |
Observable.scan(@NonNull BiFunction<@NonNull T,@NonNull T,@NonNull T> accumulator) |
Returns an Observable that emits the first value emitted by the current Observable , then emits one value
for each subsequent value emitted by the current Observable .
|
<@NonNull R> @NonNull Observable<R> |
Observable.scan(@NonNull R initialValue,
@NonNull BiFunction<@NonNull R,? super @NonNull T,@NonNull R> accumulator) |
Returns an Observable that emits the provided initial (seed) value, then emits one value for each value emitted
by the current Observable .
|
<@NonNull R> @NonNull Observable<R> |
Observable.scanWith(@NonNull Supplier<@NonNull R> seedSupplier,
@NonNull BiFunction<@NonNull R,? super @NonNull T,@NonNull R> accumulator) |
Returns an Observable that emits the provided initial (seed) value, then emits one value for each value emitted
by the current Observable .
|
@NonNull Observable<T> |
Observable.serialize() |
|
@NonNull Observable<T> |
Observable.share() |
Returns a new Observable that multicasts (and shares a single subscription to) the current Observable .
|
@NonNull Observable<T> |
Observable.skip(long count) |
Returns an Observable that skips the first count items emitted by the current Observable and emits
the remainder.
|
@NonNull Observable<T> |
Observable.skip(long time,
@NonNull java.util.concurrent.TimeUnit unit) |
Returns an Observable that skips values emitted by the current Observable before a specified time window
elapses.
|
@NonNull Observable<T> |
Observable.skip(long time,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler) |
Returns an Observable that skips values emitted by the current Observable before a specified time window
on a specified Scheduler elapses.
|
@NonNull Observable<T> |
Observable.skipLast(int count) |
Returns an Observable that drops a specified number of items from the end of the sequence emitted by the
current Observable .
|
@NonNull Observable<T> |
Observable.skipLast(long time,
@NonNull java.util.concurrent.TimeUnit unit) |
Returns an Observable that drops items emitted by the current Observable during a specified time window
before the source completes.
|
@NonNull Observable<T> |
Observable.skipLast(long time,
@NonNull java.util.concurrent.TimeUnit unit,
boolean delayError) |
Returns an Observable that drops items emitted by the current Observable during a specified time window
before the source completes.
|
@NonNull Observable<T> |
Observable.skipLast(long time,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler) |
Returns an Observable that drops items emitted by the current Observable during a specified time window
(defined on a specified scheduler) before the source completes.
|
@NonNull Observable<T> |
Observable.skipLast(long time,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler,
boolean delayError) |
Returns an Observable that drops items emitted by the current Observable during a specified time window
(defined on a specified scheduler) before the source completes.
|
@NonNull Observable<T> |
Observable.skipLast(long time,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler,
boolean delayError,
int bufferSize) |
Returns an Observable that drops items emitted by the current Observable during a specified time window
(defined on a specified scheduler) before the source completes.
|
<@NonNull U> @NonNull Observable<T> |
Observable.skipUntil(@NonNull ObservableSource<@NonNull U> other) |
Returns an Observable that skips items emitted by the current Observable until a second ObservableSource emits
an item.
|
@NonNull Observable<T> |
Observable.skipWhile(@NonNull Predicate<? super @NonNull T> predicate) |
Returns an Observable that skips all items emitted by the current Observable as long as a specified
condition holds true , but emits all further source items as soon as the condition becomes false .
|
@NonNull Observable<T> |
Observable.sorted() |
Returns an Observable that emits the events emitted by the current Observable , in a
sorted order.
|
@NonNull Observable<T> |
Observable.sorted(@NonNull java.util.Comparator<? super @NonNull T> comparator) |
Returns an Observable that emits the events emitted by the current Observable , in a
sorted order based on a specified comparison function.
|
<@NonNull T> @NonNull Observable<T> |
Completable.startWith(@NonNull ObservableSource<@NonNull T> other) |
|
@NonNull Observable<T> |
Maybe.startWith(@NonNull ObservableSource<@NonNull T> other) |
|
@NonNull Observable<T> |
Observable.startWith(@NonNull CompletableSource other) |
Returns an Observable which first runs the other CompletableSource
then the current Observable if the other completed normally.
|
@NonNull Observable<T> |
Observable.startWith(@NonNull MaybeSource<@NonNull T> other) |
Returns an Observable which first runs the other MaybeSource
then the current Observable if the other succeeded or completed normally.
|
@NonNull Observable<T> |
Observable.startWith(@NonNull ObservableSource<? extends @NonNull T> other) |
Returns an Observable that emits the items in a specified ObservableSource before it begins to emit
items emitted by the current Observable .
|
@NonNull Observable<T> |
Observable.startWith(@NonNull SingleSource<@NonNull T> other) |
Returns an Observable which first runs the other SingleSource
then the current Observable if the other succeeded normally.
|
@NonNull Observable<T> |
Single.startWith(@NonNull ObservableSource<@NonNull T> other) |
|
@NonNull Observable<T> |
Observable.startWithArray(@NonNull T... items) |
Returns an Observable that emits the specified items before it begins to emit items emitted by the current
Observable .
|
@NonNull Observable<T> |
Observable.startWithItem(@NonNull T item) |
Returns an Observable that emits a specified item before it begins to emit items emitted by the current
Observable .
|
@NonNull Observable<T> |
Observable.startWithIterable(@NonNull java.lang.Iterable<? extends @NonNull T> items) |
Returns an Observable that emits the items in a specified Iterable before it begins to emit items
emitted by the current Observable .
|
@NonNull Observable<T> |
Observable.subscribeOn(@NonNull Scheduler scheduler) |
Asynchronously subscribes Observer s to the current Observable on the specified Scheduler .
|
@NonNull Observable<T> |
Observable.switchIfEmpty(@NonNull ObservableSource<? extends @NonNull T> other) |
Returns an Observable that emits the items emitted by the current Observable or the items of an alternate
ObservableSource if the current Observable is empty.
|
<@NonNull R> @NonNull Observable<R> |
Observable.switchMap(@NonNull Function<? super @NonNull T,? extends ObservableSource<? extends @NonNull R>> mapper) |
Returns a new Observable by applying a function that you supply to each item emitted by the current
Observable that returns an ObservableSource , and then emitting the items emitted by the most recently emitted
of these ObservableSource s.
|
<@NonNull R> @NonNull Observable<R> |
Observable.switchMap(@NonNull Function<? super @NonNull T,? extends ObservableSource<? extends @NonNull R>> mapper,
int bufferSize) |
Returns a new Observable by applying a function that you supply to each item emitted by the current
Observable that returns an ObservableSource , and then emitting the items emitted by the most recently emitted
of these ObservableSource s.
|
<@NonNull R> @NonNull Observable<R> |
Observable.switchMapDelayError(@NonNull Function<? super @NonNull T,? extends ObservableSource<? extends @NonNull R>> mapper) |
Returns a new Observable by applying a function that you supply to each item emitted by the current
Observable that returns an ObservableSource , and then emitting the items emitted by the most recently emitted
of these ObservableSource s and delays any error until all ObservableSource s terminate.
|
<@NonNull R> @NonNull Observable<R> |
Observable.switchMapDelayError(@NonNull Function<? super @NonNull T,? extends ObservableSource<? extends @NonNull R>> mapper,
int bufferSize) |
Returns a new Observable by applying a function that you supply to each item emitted by the current
Observable that returns an ObservableSource , and then emitting the items emitted by the most recently emitted
of these ObservableSource s and delays any error until all ObservableSource s terminate.
|
<@NonNull R> @NonNull Observable<R> |
Observable.switchMapMaybe(@NonNull Function<? super @NonNull T,? extends MaybeSource<? extends @NonNull R>> mapper) |
Maps the items of the current Observable into MaybeSource 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 current Observable or any of the
active inner MaybeSource s fail.
|
<@NonNull R> @NonNull Observable<R> |
Observable.switchMapMaybeDelayError(@NonNull Function<? super @NonNull T,? extends MaybeSource<? extends @NonNull R>> mapper) |
Maps the upstream items into MaybeSource 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 current Observable or the inner MaybeSource s until all terminate.
|
<@NonNull R> @NonNull Observable<R> |
Observable.switchMapSingle(@NonNull Function<? super @NonNull T,? extends SingleSource<? extends @NonNull R>> mapper) |
Returns a new Observable by applying a function that you supply to each item emitted by the current
Observable that returns a SingleSource , and then emitting the item emitted by the most recently emitted
of these SingleSource s.
|
<@NonNull R> @NonNull Observable<R> |
Observable.switchMapSingleDelayError(@NonNull Function<? super @NonNull T,? extends SingleSource<? extends @NonNull R>> mapper) |
Returns a new Observable by applying a function that you supply to each item emitted by the current
Observable that returns a SingleSource , and then emitting the item emitted by the most recently emitted
of these SingleSource s and delays any error until all SingleSource s terminate.
|
static <@NonNull T> @NonNull Observable<T> |
Observable.switchOnNext(@NonNull ObservableSource<? extends ObservableSource<? extends @NonNull T>> sources) |
Converts an ObservableSource that emits ObservableSource s into an Observable that emits the items emitted by the
most recently emitted of those ObservableSource s.
|
static <@NonNull T> @NonNull Observable<T> |
Observable.switchOnNext(@NonNull ObservableSource<? extends ObservableSource<? extends @NonNull T>> sources,
int bufferSize) |
Converts an ObservableSource that emits ObservableSource s into an Observable that emits the items emitted by the
most recently emitted of those ObservableSource s.
|
static <@NonNull T> @NonNull Observable<T> |
Observable.switchOnNextDelayError(@NonNull ObservableSource<? extends ObservableSource<? extends @NonNull T>> sources) |
Converts an ObservableSource that emits ObservableSource s into an Observable that emits the items emitted by the
most recently emitted of those ObservableSource s and delays any exception until all ObservableSource s terminate.
|
static <@NonNull T> @NonNull Observable<T> |
Observable.switchOnNextDelayError(@NonNull ObservableSource<? extends ObservableSource<? extends @NonNull T>> sources,
int bufferSize) |
Converts an ObservableSource that emits ObservableSource s into an Observable that emits the items emitted by the
most recently emitted of those ObservableSource s and delays any exception until all ObservableSource s terminate.
|
@NonNull Observable<T> |
Observable.take(long count) |
Returns an Observable that emits only the first count items emitted by the current Observable .
|
@NonNull Observable<T> |
Observable.take(long time,
@NonNull java.util.concurrent.TimeUnit unit) |
Returns an Observable that emits those items emitted by the current Observable before a specified time runs
out.
|
@NonNull Observable<T> |
Observable.take(long time,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler) |
Returns an Observable that emits those items emitted by the current Observable before a specified time (on a
specified Scheduler ) runs out.
|
@NonNull Observable<T> |
Observable.takeLast(int count) |
Returns an Observable that emits at most the last count items emitted by the current Observable .
|
@NonNull Observable<T> |
Observable.takeLast(long count,
long time,
@NonNull java.util.concurrent.TimeUnit unit) |
Returns an Observable that emits at most a specified number of items from the current Observable that were
emitted in a specified window of time before the current Observable completed.
|
@NonNull Observable<T> |
Observable.takeLast(long count,
long time,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler) |
Returns an Observable that emits at most a specified number of items from the current Observable that were
emitted in a specified window of time before the current Observable completed, where the timing information is
provided by a given Scheduler .
|
@NonNull Observable<T> |
Observable.takeLast(long count,
long time,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler,
boolean delayError,
int bufferSize) |
Returns an Observable that emits at most a specified number of items from the current Observable that were
emitted in a specified window of time before the current Observable completed, where the timing information is
provided by a given Scheduler .
|
@NonNull Observable<T> |
Observable.takeLast(long time,
@NonNull java.util.concurrent.TimeUnit unit) |
Returns an Observable that emits the items from the current Observable that were emitted in a specified
window of time before the current Observable completed.
|
@NonNull Observable<T> |
Observable.takeLast(long time,
@NonNull java.util.concurrent.TimeUnit unit,
boolean delayError) |
Returns an Observable that emits the items from the current Observable that were emitted in a specified
window of time before the current Observable completed.
|
@NonNull Observable<T> |
Observable.takeLast(long time,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler) |
Returns an Observable that emits the items from the current Observable that were emitted in a specified
window of time before the current Observable completed, where the timing information is provided by a specified
Scheduler .
|
@NonNull Observable<T> |
Observable.takeLast(long time,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler,
boolean delayError) |
Returns an Observable that emits the items from the current Observable that were emitted in a specified
window of time before the current Observable completed, where the timing information is provided by a specified
Scheduler .
|
@NonNull Observable<T> |
Observable.takeLast(long time,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler,
boolean delayError,
int bufferSize) |
Returns an Observable that emits the items from the current Observable that were emitted in a specified
window of time before the current Observable completed, where the timing information is provided by a specified
Scheduler .
|
<@NonNull U> @NonNull Observable<T> |
Observable.takeUntil(@NonNull ObservableSource<@NonNull U> other) |
Returns an Observable that emits the items emitted by the current Observable until a second ObservableSource
emits an item or completes.
|
@NonNull Observable<T> |
Observable.takeUntil(@NonNull Predicate<? super @NonNull T> stopPredicate) |
Returns an Observable that emits items emitted by the current Observable , checks the specified predicate
for each item, and then completes when the condition is satisfied.
|
@NonNull Observable<T> |
Observable.takeWhile(@NonNull Predicate<? super @NonNull T> predicate) |
Returns an Observable that emits items emitted by the current Observable so long as each item satisfied a
specified condition, and then completes as soon as this condition is not satisfied.
|
@NonNull Observable<T> |
Observable.throttleFirst(long windowDuration,
@NonNull java.util.concurrent.TimeUnit unit) |
Returns an Observable that emits only the first item emitted by the current Observable during sequential
time windows of a specified duration.
|
@NonNull Observable<T> |
Observable.throttleFirst(long skipDuration,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler) |
Returns an Observable that emits only the first item emitted by the current Observable during sequential
time windows of a specified duration, where the windows are managed by a specified Scheduler .
|
@NonNull Observable<T> |
Observable.throttleFirst(long skipDuration,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler,
@NonNull Consumer<? super @NonNull T> onDropped) |
Returns an Observable that emits only the first item emitted by the current Observable during sequential
time windows of a specified duration, where the windows are managed by a specified Scheduler .
|
@NonNull Observable<T> |
Observable.throttleLast(long intervalDuration,
@NonNull java.util.concurrent.TimeUnit unit) |
Returns an Observable that emits only the last item emitted by the current Observable during sequential
time windows of a specified duration.
|
@NonNull Observable<T> |
Observable.throttleLast(long intervalDuration,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler) |
Returns an Observable that emits only the last item emitted by the current Observable during sequential
time windows of a specified duration, where the duration is governed by a specified Scheduler .
|
@NonNull Observable<T> |
Observable.throttleLast(long intervalDuration,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler,
@NonNull Consumer<? super @NonNull T> onDropped) |
Returns an Observable that emits only the last item emitted by the current Observable during sequential
time windows of a specified duration, where the duration is governed by a specified Scheduler .
|
@NonNull Observable<T> |
Observable.throttleLatest(long timeout,
@NonNull java.util.concurrent.TimeUnit unit) |
Throttles items from the current Observable by first emitting the next
item from upstream, then periodically emitting the latest item (if any) when
the specified timeout elapses between them.
|
@NonNull Observable<T> |
Observable.throttleLatest(long timeout,
@NonNull java.util.concurrent.TimeUnit unit,
boolean emitLast) |
Throttles items from the current Observable by first emitting the next
item from upstream, then periodically emitting the latest item (if any) when
the specified timeout elapses between them.
|
@NonNull Observable<T> |
Observable.throttleLatest(long timeout,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler) |
Throttles items from the current Observable by first emitting the next
item from upstream, then periodically emitting the latest item (if any) when
the specified timeout elapses between them.
|
@NonNull Observable<T> |
Observable.throttleLatest(long timeout,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler,
boolean emitLast) |
Throttles items from the current Observable by first emitting the next
item from upstream, then periodically emitting the latest item (if any) when
the specified timeout elapses between them.
|
@NonNull Observable<T> |
Observable.throttleLatest(long timeout,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler,
boolean emitLast,
@NonNull Consumer<? super @NonNull T> onDropped) |
Throttles items from the current Observable 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.
|
@NonNull Observable<T> |
Observable.throttleWithTimeout(long timeout,
@NonNull java.util.concurrent.TimeUnit unit) |
Returns an Observable that mirrors the current Observable , except that it drops items emitted by the
current Observable that are followed by newer items before a timeout value expires.
|
@NonNull Observable<T> |
Observable.throttleWithTimeout(long timeout,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler) |
Returns an Observable that mirrors the current Observable , except that it drops items emitted by the
current Observable that are followed by newer items before a timeout value expires on a specified
Scheduler .
|
@NonNull Observable<T> |
Observable.throttleWithTimeout(long timeout,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler,
@NonNull Consumer<? super @NonNull T> onDropped) |
Returns an Observable that mirrors the current Observable , except that it drops items emitted by the
current Observable that are followed by newer items before a timeout value expires on a specified
Scheduler .
|
@NonNull Observable<Timed<T>> |
Observable.timeInterval() |
Returns an Observable that emits records of the time interval between consecutive items emitted by the
current Observable .
|
@NonNull Observable<Timed<T>> |
Observable.timeInterval(@NonNull Scheduler scheduler) |
Returns an Observable that emits records of the time interval between consecutive items emitted by the
current Observable , where this interval is computed on a specified Scheduler .
|
@NonNull Observable<Timed<T>> |
Observable.timeInterval(@NonNull java.util.concurrent.TimeUnit unit) |
Returns an Observable that emits records of the time interval between consecutive items emitted by the
current Observable .
|
@NonNull Observable<Timed<T>> |
Observable.timeInterval(@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler) |
Returns an Observable that emits records of the time interval between consecutive items emitted by the
current Observable , where this interval is computed on a specified Scheduler .
|
@NonNull Observable<T> |
Observable.timeout(long timeout,
@NonNull java.util.concurrent.TimeUnit unit) |
Returns an Observable that mirrors the current Observable but applies a timeout policy for each emitted
item.
|
@NonNull Observable<T> |
Observable.timeout(long timeout,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull ObservableSource<? extends @NonNull T> fallback) |
Returns an Observable that mirrors the current Observable but applies a timeout policy for each emitted
item.
|
@NonNull Observable<T> |
Observable.timeout(long timeout,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler) |
Returns an Observable that mirrors the current Observable but applies a timeout policy for each emitted
item, where this policy is governed on a specified Scheduler .
|
@NonNull Observable<T> |
Observable.timeout(long timeout,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler,
@NonNull ObservableSource<? extends @NonNull T> fallback) |
Returns an Observable that mirrors the current Observable but applies a timeout policy for each emitted
item using a specified Scheduler .
|
<@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 an Observable that mirrors the current Observable , but notifies observers of a
TimeoutException if either the first item emitted by the current Observable or any subsequent item
doesn't arrive within time windows defined by indicator ObservableSource s.
|
<@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 an Observable that mirrors the current Observable , but switches to a fallback ObservableSource if either
the first item emitted by the current Observable or any subsequent item doesn't arrive within time windows
defined by indicator ObservableSource s.
|
<@NonNull V> @NonNull Observable<T> |
Observable.timeout(@NonNull Function<? super @NonNull T,? extends ObservableSource<@NonNull V>> itemTimeoutIndicator) |
Returns an Observable that mirrors the current Observable , but notifies observers of a
TimeoutException if an item emitted by the current Observable doesn't arrive within a window of
time after the emission of the previous item, where that period of time is measured by an ObservableSource that
is a function of the previous item.
|
<@NonNull V> @NonNull Observable<T> |
Observable.timeout(@NonNull Function<? super @NonNull T,? extends ObservableSource<@NonNull V>> itemTimeoutIndicator,
@NonNull ObservableSource<? extends @NonNull T> fallback) |
Returns an Observable that mirrors the current Observable , but that switches to a fallback ObservableSource if
an item emitted by the current Observable doesn't arrive within a window of time after the emission of the
previous item, where that period of time is measured by an ObservableSource that is a function of the previous
item.
|
private @NonNull Observable<T> |
Observable.timeout0(long timeout,
@NonNull java.util.concurrent.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 Observable<java.lang.Long> |
Observable.timer(long delay,
@NonNull java.util.concurrent.TimeUnit unit) |
Returns an Observable that emits 0L after a specified delay, and then completes.
|
static @NonNull Observable<java.lang.Long> |
Observable.timer(long delay,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler) |
Returns an Observable that emits 0L after a specified delay, on a specified Scheduler , and then
completes.
|
@NonNull Observable<Timed<T>> |
Observable.timestamp() |
Returns an Observable that emits each item emitted by the current Observable , wrapped in a
Timed object.
|
@NonNull Observable<Timed<T>> |
Observable.timestamp(@NonNull Scheduler scheduler) |
Returns an Observable that emits each item emitted by the current Observable , wrapped in a
Timed object whose timestamps are provided by a specified Scheduler .
|
@NonNull Observable<Timed<T>> |
Observable.timestamp(@NonNull java.util.concurrent.TimeUnit unit) |
Returns an Observable that emits each item emitted by the current Observable , wrapped in a
Timed object.
|
@NonNull Observable<Timed<T>> |
Observable.timestamp(@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler) |
Returns an Observable that emits each item emitted by the current Observable , wrapped in a
Timed object whose timestamps are provided by a specified Scheduler .
|
<@NonNull T> @NonNull Observable<T> |
Completable.toObservable() |
Returns an Observable which when subscribed to subscribes to this Completable and
relays the terminal events to the downstream Observer .
|
@NonNull Observable<T> |
Flowable.toObservable() |
Converts the current Flowable into a non-backpressured Observable .
|
@NonNull Observable<T> |
Maybe.toObservable() |
Converts this Maybe into an Observable instance composing disposal
through.
|
@NonNull Observable<T> |
Single.toObservable() |
|
static <@NonNull T> @NonNull Observable<T> |
Observable.unsafeCreate(@NonNull ObservableSource<@NonNull T> onSubscribe) |
Create an Observable by wrapping an ObservableSource which has to be implemented according
to the Observable specification derived from the Reactive Streams specification by handling
disposal correctly; no safeguards are provided by the Observable itself.
|
@NonNull Observable<T> |
Observable.unsubscribeOn(@NonNull Scheduler scheduler) |
Return an Observable that schedules the downstream Observer s' dispose calls
aimed at the current Observable on the given Scheduler .
|
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 an Observable that creates a dependent resource object, an ObservableSource with
that resource and calls the provided resourceDisposer 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 an Observable that creates a dependent resource object, an ObservableSource with
that resource and calls the provided disposer function if this inner source terminates or the
downstream disposes the flow; doing it before these end-states have been reached if eager == true , after otherwise.
|
@NonNull Observable<Observable<T>> |
Observable.window(long count) |
Returns an Observable that emits windows of items it collects from the current Observable .
|
@NonNull Observable<Observable<T>> |
Observable.window(long count,
long skip) |
Returns an Observable that emits windows of items it collects from the current Observable .
|
@NonNull Observable<Observable<T>> |
Observable.window(long count,
long skip,
int bufferSize) |
Returns an Observable that emits windows of items it collects from the current Observable .
|
@NonNull Observable<Observable<T>> |
Observable.window(long timespan,
long timeskip,
@NonNull java.util.concurrent.TimeUnit unit) |
Returns an Observable that emits windows of items it collects from the current Observable .
|
@NonNull Observable<Observable<T>> |
Observable.window(long timespan,
long timeskip,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler) |
Returns an Observable that emits windows of items it collects from the current Observable .
|
@NonNull Observable<Observable<T>> |
Observable.window(long timespan,
long timeskip,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler,
int bufferSize) |
Returns an Observable that emits windows of items it collects from the current Observable .
|
@NonNull Observable<Observable<T>> |
Observable.window(long timespan,
@NonNull java.util.concurrent.TimeUnit unit) |
Returns an Observable that emits windows of items it collects from the current Observable .
|
@NonNull Observable<Observable<T>> |
Observable.window(long timespan,
@NonNull java.util.concurrent.TimeUnit unit,
long count) |
Returns an Observable that emits windows of items it collects from the current Observable .
|
@NonNull Observable<Observable<T>> |
Observable.window(long timespan,
@NonNull java.util.concurrent.TimeUnit unit,
long count,
boolean restart) |
Returns an Observable that emits windows of items it collects from the current Observable .
|
@NonNull Observable<Observable<T>> |
Observable.window(long timespan,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler) |
Returns an Observable that emits windows of items it collects from the current Observable .
|
@NonNull Observable<Observable<T>> |
Observable.window(long timespan,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler,
long count) |
Returns an Observable that emits windows of items it collects from the current Observable .
|
@NonNull Observable<Observable<T>> |
Observable.window(long timespan,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler,
long count,
boolean restart) |
Returns an Observable that emits windows of items it collects from the current Observable .
|
@NonNull Observable<Observable<T>> |
Observable.window(long timespan,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler,
long count,
boolean restart,
int bufferSize) |
Returns an Observable that emits windows of items it collects from the current Observable .
|
<@NonNull B> @NonNull Observable<Observable<T>> |
Observable.window(@NonNull ObservableSource<@NonNull B> boundaryIndicator) |
Returns an Observable that emits non-overlapping windows of items it collects from the current Observable
where the boundary of each window is determined by the items emitted from a specified boundary-governing
ObservableSource .
|
<@NonNull B> @NonNull Observable<Observable<T>> |
Observable.window(@NonNull ObservableSource<@NonNull B> boundaryIndicator,
int bufferSize) |
Returns an Observable that emits non-overlapping windows of items it collects from the current Observable
where the boundary of each window is determined by the items emitted from a specified boundary-governing
ObservableSource .
|
<@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 an Observable that emits windows of items it collects from the current Observable .
|
<@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 an Observable that emits windows of items it collects from the current Observable .
|
<@NonNull R> @NonNull Observable<R> |
Observable.withLatestFrom(@NonNull ObservableSource<?>[] others,
@NonNull Function<? super java.lang.Object[],@NonNull R> combiner) |
Combines the value emission from the current Observable with the latest emissions from the
other ObservableSource s via a function to produce the output item.
|
<@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 specified ObservableSource into the current Observable sequence by using the resultSelector
function only when the current Observable emits an item.
|
<@NonNull T1,@NonNull T2,@NonNull T3,@NonNull T4,@NonNull R> @NonNull Observable<R> |
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 current Observable with the latest emissions from the
other ObservableSource s via a function to produce the output item.
|
<@NonNull T1,@NonNull T2,@NonNull T3,@NonNull R> @NonNull Observable<R> |
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 current Observable with the latest emissions from the
other ObservableSource s via a function to produce the output item.
|
<@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 current Observable with the latest emissions from the
other ObservableSource s via a function to produce the output item.
|
<@NonNull R> @NonNull Observable<R> |
Observable.withLatestFrom(@NonNull java.lang.Iterable<? extends ObservableSource<?>> others,
@NonNull Function<? super java.lang.Object[],@NonNull R> combiner) |
Combines the value emission from the current Observable with the latest emissions from the
other ObservableSource s via a function to produce the output item.
|
static <@NonNull T> @NonNull Observable<T> |
Observable.wrap(@NonNull ObservableSource<@NonNull T> source) |
|
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 an Observable that emits the results of a specified combiner function applied to combinations of
nine items emitted, in sequence, by nine other ObservableSource 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 an Observable that emits the results of a specified combiner function applied to combinations of
eight items emitted, in sequence, by eight other ObservableSource 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 an Observable that emits the results of a specified combiner function applied to combinations of
seven items emitted, in sequence, by seven other ObservableSource 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 an Observable that emits the results of a specified combiner function applied to combinations of
six items emitted, in sequence, by six other ObservableSource 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 an Observable that emits the results of a specified combiner function applied to combinations of
five items emitted, in sequence, by five other ObservableSource s.
|
static <@NonNull T1,@NonNull T2,@NonNull T3,@NonNull T4,@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 Function4<? super @NonNull T1,? super @NonNull T2,? super @NonNull T3,? super @NonNull T4,? extends @NonNull R> zipper) |
Returns an Observable that emits the results of a specified combiner function applied to combinations of
four items emitted, in sequence, by four other ObservableSource s.
|
static <@NonNull T1,@NonNull T2,@NonNull T3,@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 Function3<? super @NonNull T1,? super @NonNull T2,? super @NonNull T3,? extends @NonNull R> zipper) |
Returns an Observable that emits the results of a specified combiner function applied to combinations of
three items emitted, in sequence, by three other ObservableSource 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 an Observable that emits the results of a specified combiner function applied to combinations of
two items emitted, in sequence, by two other ObservableSource 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 an Observable that emits the results of a specified combiner function applied to combinations of
two items emitted, in sequence, by two other ObservableSource 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 an Observable that emits the results of a specified combiner function applied to combinations of
two items emitted, in sequence, by two other ObservableSource s.
|
static <@NonNull T,@NonNull R> @NonNull Observable<R> |
Observable.zip(@NonNull java.lang.Iterable<? extends ObservableSource<? extends @NonNull T>> sources,
@NonNull Function<? super java.lang.Object[],? extends @NonNull R> zipper) |
Returns an Observable that emits the results of a specified combiner function applied to combinations of
items emitted, in sequence, by an Iterable of other ObservableSource s.
|
static <@NonNull T,@NonNull R> @NonNull Observable<R> |
Observable.zip(@NonNull java.lang.Iterable<? extends ObservableSource<? extends @NonNull T>> sources,
@NonNull Function<? super java.lang.Object[],? extends @NonNull R> zipper,
boolean delayError,
int bufferSize) |
Returns an Observable that emits the results of a specified combiner function applied to combinations of
items emitted, in sequence, by an Iterable of other ObservableSource s.
|
static <@NonNull T,@NonNull R> @NonNull Observable<R> |
Observable.zipArray(@NonNull Function<? super java.lang.Object[],? extends @NonNull R> zipper,
boolean delayError,
int bufferSize,
@NonNull ObservableSource<? extends @NonNull T>... sources) |
Returns an Observable that emits the results of a specified combiner function applied to combinations of
items emitted, in sequence, by an array of other ObservableSource s.
|
<@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 an Observable that emits items that are the result of applying a specified function to pairs of
values, one each from the current Observable and another specified ObservableSource .
|
<@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 an Observable that emits items that are the result of applying a specified function to pairs of
values, one each from the current Observable and another specified ObservableSource .
|
<@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 an Observable that emits items that are the result of applying a specified function to pairs of
values, one each from the current Observable and another specified ObservableSource .
|
<@NonNull U,@NonNull R> @NonNull Observable<R> |
Observable.zipWith(@NonNull java.lang.Iterable<@NonNull U> other,
@NonNull BiFunction<? super @NonNull T,? super @NonNull U,? extends @NonNull R> zipper) |
Returns an Observable that emits items that are the result of applying a specified function to pairs of
values, one each from the current Observable and a specified Iterable sequence.
|