hu.akarnokd.rxjava2.operators

Class Flowables

java.lang.Object

hu.akarnokd.rxjava2.operators.Flowables

public final class Flowables
extends java.lang.Object

Utility class to create Flowable sources.

Method Summary

Modifier and Type	Method and Description
static io.reactivex.Flowable<java.lang.Long>	intervalBackpressure(long initialDelay, long period, java.util.concurrent.TimeUnit unit) Periodically tries to emit an ever increasing long value or buffers (efficiently) such emissions until the downstream requests.
static io.reactivex.Flowable<java.lang.Long>	intervalBackpressure(long initialDelay, long period, java.util.concurrent.TimeUnit unit, io.reactivex.Scheduler scheduler) Periodically tries to emit an ever increasing long value or buffers (efficiently) such emissions until the downstream requests.
static io.reactivex.Flowable<java.lang.Long>	intervalBackpressure(long period, java.util.concurrent.TimeUnit unit) Periodically tries to emit an ever increasing long value or buffers (efficiently) such emissions until the downstream requests.
static io.reactivex.Flowable<java.lang.Long>	intervalBackpressure(long period, java.util.concurrent.TimeUnit unit, io.reactivex.Scheduler scheduler) Periodically tries to emit an ever increasing long value or buffers (efficiently) such emissions until the downstream requests.
static <T extends java.lang.Comparable<? super T>> io.reactivex.Flowable<T>	orderedMerge(boolean delayErrors, int prefetch, org.reactivestreams.Publisher<T>... sources) Merges the source Publishers in an ordered fashion picking the smallest of the available value from them (determined by their natural order), allows delaying any error they may signal and sets the prefetch amount when requesting from these Publishers.
static <T extends java.lang.Comparable<? super T>> io.reactivex.Flowable<T>	orderedMerge(boolean delayErrors, org.reactivestreams.Publisher<T>... sources) Merges the source Publishers in an ordered fashion picking the smallest of the available value from them (determined by their natural order) and allows delaying any error they may signal.
static <T> io.reactivex.Flowable<T>	orderedMerge(java.util.Comparator<? super T> comparator, boolean delayErrors, int prefetch, org.reactivestreams.Publisher<T>... sources) Merges the source Publishers in an ordered fashion picking the smallest of the available value from them (determined by the Comparator), allows delaying any error they may signal and sets the prefetch amount when requesting from these Publishers.
static <T> io.reactivex.Flowable<T>	orderedMerge(java.util.Comparator<? super T> comparator, boolean delayErrors, org.reactivestreams.Publisher<T>... sources) Merges the source Publishers in an ordered fashion picking the smallest of the available value from them (determined by the Comparator) and allows delaying any error they may signal.
static <T> io.reactivex.Flowable<T>	orderedMerge(java.util.Comparator<? super T> comparator, org.reactivestreams.Publisher<T>... sources) Merges the source Publishers in an ordered fashion picking the smallest of the available value from them (determined by the Comparator).
static <T extends java.lang.Comparable<? super T>> io.reactivex.Flowable<T>	orderedMerge(java.lang.Iterable<? extends org.reactivestreams.Publisher<T>> sources) Merges the source Publishers in an ordered fashion picking the smallest of the available value from them (determined by their natural order).
static <T extends java.lang.Comparable<? super T>> io.reactivex.Flowable<T>	orderedMerge(java.lang.Iterable<? extends org.reactivestreams.Publisher<T>> sources, boolean delayErrors) Merges the source Publishers in an ordered fashion picking the smallest of the available value from them (determined by their natural order) and allows delaying any error they may signal.
static <T extends java.lang.Comparable<? super T>> io.reactivex.Flowable<T>	orderedMerge(java.lang.Iterable<? extends org.reactivestreams.Publisher<T>> sources, boolean delayErrors, int prefetch) Merges the source Publishers in an ordered fashion picking the smallest of the available value from them (determined by their natural order), allows delaying any error they may signal and sets the prefetch amount when requesting from these Publishers.
static <T> io.reactivex.Flowable<T>	orderedMerge(java.lang.Iterable<? extends org.reactivestreams.Publisher<T>> sources, java.util.Comparator<? super T> comparator) Merges the source Publishers in an ordered fashion picking the smallest of the available value from them (determined by the Comparator).
static <T> io.reactivex.Flowable<T>	orderedMerge(java.lang.Iterable<? extends org.reactivestreams.Publisher<T>> sources, java.util.Comparator<? super T> comparator, boolean delayErrors) Merges the source Publishers in an ordered fashion picking the smallest of the available value from them (determined by the Comparator) and allows delaying any error they may signal.
static <T> io.reactivex.Flowable<T>	orderedMerge(java.lang.Iterable<? extends org.reactivestreams.Publisher<T>> sources, java.util.Comparator<? super T> comparator, boolean delayErrors, int prefetch) Merges the source Publishers in an ordered fashion picking the smallest of the available value from them (determined by the Comparator), allows delaying any error they may signal and sets the prefetch amount when requesting from these Publishers.
static <T extends java.lang.Comparable<? super T>> io.reactivex.Flowable<T>	orderedMerge(org.reactivestreams.Publisher<T>... sources) Merges the source Publishers in an ordered fashion picking the smallest of the available value from them (determined by their natural order).
static <T> io.reactivex.Flowable<T>	repeat(T item) Repeats a scalar value indefinitely.
static <T> io.reactivex.Flowable<T>	repeatCallable(java.util.concurrent.Callable<T> callable) Repeatedly calls the given Callable to produce items indefinitely.
static <T,R> io.reactivex.Flowable<R>	zipLatest(io.reactivex.functions.Function<? super java.lang.Object[],? extends R> combiner, org.reactivestreams.Publisher<? extends T>... sources) Zips the latest available values of the source Publishers via a combiner function where the emission rate is determined by the slowest Publisher and the downstream consumption rate.
static <T,R> io.reactivex.Flowable<R>	zipLatest(io.reactivex.functions.Function<? super java.lang.Object[],? extends R> combiner, io.reactivex.Scheduler scheduler, org.reactivestreams.Publisher<? extends T>... sources) Zips the latest available values of the source Publishers via a combiner function where the emission rate is determined by the slowest Publisher and the downstream consumption rate.
static <T,R> io.reactivex.Flowable<R>	zipLatest(java.lang.Iterable<? extends org.reactivestreams.Publisher<? extends T>> sources, io.reactivex.functions.Function<? super java.lang.Object[],? extends R> combiner) Zips the latest available values of the source Publishers via a combiner function where the emission rate is determined by the slowest Publisher and the downstream consumption rate.
static <T,R> io.reactivex.Flowable<R>	zipLatest(java.lang.Iterable<? extends org.reactivestreams.Publisher<? extends T>> sources, io.reactivex.functions.Function<? super java.lang.Object[],? extends R> combiner, io.reactivex.Scheduler scheduler) Zips the latest available values of the source Publishers via a combiner function where the emission rate is determined by the slowest Publisher and the downstream consumption rate.
static <T1,T2,R> io.reactivex.Flowable<R>	zipLatest(org.reactivestreams.Publisher<T1> source1, org.reactivestreams.Publisher<T2> source2, io.reactivex.functions.BiFunction<? super T1,? super T2,? extends R> combiner) Zips the latest available values of the source Publishers via a combiner function where the emission rate is determined by the slowest Publisher and the downstream consumption rate.
static <T1,T2,R> io.reactivex.Flowable<R>	zipLatest(org.reactivestreams.Publisher<T1> source1, org.reactivestreams.Publisher<T2> source2, io.reactivex.functions.BiFunction<? super T1,? super T2,? extends R> combiner, io.reactivex.Scheduler scheduler) Zips the latest available values of the source Publishers via a combiner function where the emission rate is determined by the slowest Publisher and the downstream consumption rate.
static <T1,T2,T3,R> io.reactivex.Flowable<R>	zipLatest(org.reactivestreams.Publisher<T1> source1, org.reactivestreams.Publisher<T2> source2, org.reactivestreams.Publisher<T3> source3, io.reactivex.functions.Function3<? super T1,? super T2,? super T3,? extends R> combiner) Zips the latest available values of the source Publishers via a combiner function where the emission rate is determined by the slowest Publisher and the downstream consumption rate.
static <T1,T2,T3,R> io.reactivex.Flowable<R>	zipLatest(org.reactivestreams.Publisher<T1> source1, org.reactivestreams.Publisher<T2> source2, org.reactivestreams.Publisher<T3> source3, io.reactivex.functions.Function3<? super T1,? super T2,? super T3,? extends R> combiner, io.reactivex.Scheduler scheduler) Zips the latest available values of the source Publishers via a combiner function where the emission rate is determined by the slowest Publisher and the downstream consumption rate.
static <T1,T2,T3,T4,R> io.reactivex.Flowable<R>	zipLatest(org.reactivestreams.Publisher<T1> source1, org.reactivestreams.Publisher<T2> source2, org.reactivestreams.Publisher<T3> source3, org.reactivestreams.Publisher<T4> source4, io.reactivex.functions.Function4<? super T1,? super T2,? super T3,? super T4,? extends R> combiner) Zips the latest available values of the source Publishers via a combiner function where the emission rate is determined by the slowest Publisher and the downstream consumption rate.
static <T1,T2,T3,T4,R> io.reactivex.Flowable<R>	zipLatest(org.reactivestreams.Publisher<T1> source1, org.reactivestreams.Publisher<T2> source2, org.reactivestreams.Publisher<T3> source3, org.reactivestreams.Publisher<T4> source4, io.reactivex.functions.Function4<? super T1,? super T2,? super T3,? super T4,? extends R> combiner, io.reactivex.Scheduler scheduler) Zips the latest available values of the source Publishers via a combiner function where the emission rate is determined by the slowest Publisher and the downstream consumption rate.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Method Detail

orderedMerge

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T extends java.lang.Comparable<? super T>> io.reactivex.Flowable<T> orderedMerge(org.reactivestreams.Publisher<T>... sources)

Merges the source Publishers in an ordered fashion picking the smallest of the available value from them (determined by their natural order).

Type Parameters:

T - the value type of all sources

Parameters:

sources - the iterable sequence of sources

Returns:

the new Flowable instance

Since:

0.8.0

orderedMerge

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T extends java.lang.Comparable<? super T>> io.reactivex.Flowable<T> orderedMerge(boolean delayErrors,
                                                                                                                                                                    org.reactivestreams.Publisher<T>... sources)

Merges the source Publishers in an ordered fashion picking the smallest of the available value from them (determined by their natural order) and allows delaying any error they may signal.

Type Parameters:

T - the value type of all sources

Parameters:

sources - the iterable sequence of sources

delayErrors - if true, source errors are delayed until all sources terminate in some way

Returns:

the new Flowable instance

Since:

0.8.0

orderedMerge

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T extends java.lang.Comparable<? super T>> io.reactivex.Flowable<T> orderedMerge(boolean delayErrors,
                                                                                                                                                                    int prefetch,
                                                                                                                                                                    org.reactivestreams.Publisher<T>... sources)

Merges the source Publishers in an ordered fashion picking the smallest of the available value from them (determined by their natural order), allows delaying any error they may signal and sets the prefetch amount when requesting from these Publishers.

Type Parameters:

T - the value type of all sources

Parameters:

sources - the iterable sequence of sources

delayErrors - if true, source errors are delayed until all sources terminate in some way

prefetch - the number of items to prefetch from the sources

Returns:

the new Flowable instance

Since:

0.8.0

orderedMerge

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T> io.reactivex.Flowable<T> orderedMerge(java.util.Comparator<? super T> comparator,
                                                                                                                            org.reactivestreams.Publisher<T>... sources)

Merges the source Publishers in an ordered fashion picking the smallest of the available value from them (determined by the Comparator).

Type Parameters:

T - the value type of all sources

Parameters:

sources - the iterable sequence of sources

comparator - the comparator to use for comparing items; it is called with the last known smallest in its first argument

Returns:

the new Flowable instance

Since:

0.8.0

orderedMerge

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T> io.reactivex.Flowable<T> orderedMerge(java.util.Comparator<? super T> comparator,
                                                                                                                            boolean delayErrors,
                                                                                                                            org.reactivestreams.Publisher<T>... sources)

Merges the source Publishers in an ordered fashion picking the smallest of the available value from them (determined by the Comparator) and allows delaying any error they may signal.

Type Parameters:

T - the value type of all sources

Parameters:

sources - the iterable sequence of sources

comparator - the comparator to use for comparing items; it is called with the last known smallest in its first argument

delayErrors - if true, source errors are delayed until all sources terminate in some way

Returns:

the new Flowable instance

Since:

0.8.0

orderedMerge

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T> io.reactivex.Flowable<T> orderedMerge(java.util.Comparator<? super T> comparator,
                                                                                                                            boolean delayErrors,
                                                                                                                            int prefetch,
                                                                                                                            org.reactivestreams.Publisher<T>... sources)

Merges the source Publishers in an ordered fashion picking the smallest of the available value from them (determined by the Comparator), allows delaying any error they may signal and sets the prefetch amount when requesting from these Publishers.

Type Parameters:

T - the value type of all sources

Parameters:

sources - the iterable sequence of sources

comparator - the comparator to use for comparing items; it is called with the last known smallest in its first argument

delayErrors - if true, source errors are delayed until all sources terminate in some way

prefetch - the number of items to prefetch from the sources

Returns:

the new Flowable instance

Since:

0.8.0

orderedMerge

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T> io.reactivex.Flowable<T> orderedMerge(java.lang.Iterable<? extends org.reactivestreams.Publisher<T>> sources,
                                                                                                                            java.util.Comparator<? super T> comparator)

Merges the source Publishers in an ordered fashion picking the smallest of the available value from them (determined by the Comparator).

Type Parameters:

T - the value type of all sources

Parameters:

sources - the iterable sequence of sources

comparator - the comparator to use for comparing items; it is called with the last known smallest in its first argument

Returns:

the new Flowable instance

Since:

0.8.0

orderedMerge

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T> io.reactivex.Flowable<T> orderedMerge(java.lang.Iterable<? extends org.reactivestreams.Publisher<T>> sources,
                                                                                                                            java.util.Comparator<? super T> comparator,
                                                                                                                            boolean delayErrors)

Merges the source Publishers in an ordered fashion picking the smallest of the available value from them (determined by the Comparator) and allows delaying any error they may signal.

Type Parameters:

T - the value type of all sources

Parameters:

sources - the iterable sequence of sources

comparator - the comparator to use for comparing items; it is called with the last known smallest in its first argument

delayErrors - if true, source errors are delayed until all sources terminate in some way

Returns:

the new Flowable instance

Since:

0.8.0

orderedMerge

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T> io.reactivex.Flowable<T> orderedMerge(java.lang.Iterable<? extends org.reactivestreams.Publisher<T>> sources,
                                                                                                                            java.util.Comparator<? super T> comparator,
                                                                                                                            boolean delayErrors,
                                                                                                                            int prefetch)

Merges the source Publishers in an ordered fashion picking the smallest of the available value from them (determined by the Comparator), allows delaying any error they may signal and sets the prefetch amount when requesting from these Publishers.

Type Parameters:

T - the value type of all sources

Parameters:

sources - the iterable sequence of sources

comparator - the comparator to use for comparing items; it is called with the last known smallest in its first argument

delayErrors - if true, source errors are delayed until all sources terminate in some way

prefetch - the number of items to prefetch from the sources

Returns:

the new Flowable instance

Since:

0.8.0

orderedMerge

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T extends java.lang.Comparable<? super T>> io.reactivex.Flowable<T> orderedMerge(java.lang.Iterable<? extends org.reactivestreams.Publisher<T>> sources)

Merges the source Publishers in an ordered fashion picking the smallest of the available value from them (determined by their natural order).

Type Parameters:

T - the value type of all sources

Parameters:

sources - the iterable sequence of sources

Returns:

the new Flowable instance

Since:

0.8.0

orderedMerge

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T extends java.lang.Comparable<? super T>> io.reactivex.Flowable<T> orderedMerge(java.lang.Iterable<? extends org.reactivestreams.Publisher<T>> sources,
                                                                                                                                                                    boolean delayErrors)

Merges the source Publishers in an ordered fashion picking the smallest of the available value from them (determined by their natural order) and allows delaying any error they may signal.

Type Parameters:

T - the value type of all sources

Parameters:

sources - the iterable sequence of sources

delayErrors - if true, source errors are delayed until all sources terminate in some way

Returns:

the new Flowable instance

Since:

0.8.0

orderedMerge

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T extends java.lang.Comparable<? super T>> io.reactivex.Flowable<T> orderedMerge(java.lang.Iterable<? extends org.reactivestreams.Publisher<T>> sources,
                                                                                                                                                                    boolean delayErrors,
                                                                                                                                                                    int prefetch)

Merges the source Publishers in an ordered fashion picking the smallest of the available value from them (determined by their natural order), allows delaying any error they may signal and sets the prefetch amount when requesting from these Publishers.

Type Parameters:

T - the value type of all sources

Parameters:

sources - the iterable sequence of sources

delayErrors - if true, source errors are delayed until all sources terminate in some way

prefetch - the number of items to prefetch from the sources

Returns:

the new Flowable instance

Since:

0.8.0

repeat

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T> io.reactivex.Flowable<T> repeat(T item)

Repeats a scalar value indefinitely.

Type Parameters:

T - the value type

Parameters:

item - the value to repeat

Returns:

the new Flowable instance

Since:

0.14.2

repeatCallable

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T> io.reactivex.Flowable<T> repeatCallable(java.util.concurrent.Callable<T> callable)

Repeatedly calls the given Callable to produce items indefinitely.

Type Parameters:

T - the value type

Parameters:

callable - the Callable to call

Returns:

the new Flowable instance

Since:

0.14.2

intervalBackpressure

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value="io.reactivex:computation")
public static io.reactivex.Flowable<java.lang.Long> intervalBackpressure(long period,
                                                                                                                                                                 java.util.concurrent.TimeUnit unit)

Periodically tries to emit an ever increasing long value or buffers (efficiently) such emissions until the downstream requests.

Backpressure:

The operator honors the backpressure of the downstream and no emission is lost, however, the timing of the reception of the values is now dependent on the downstream backpressure.

Scheduler:

The operator uses the computation Scheduler to time the emission and likely deliver the value (unless backpressured).

Parameters:

period - the emission period (including the delay for the first emission)

unit - the emission time unit

Returns:

the new Flowable instance

Since:

0.15.0

intervalBackpressure

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value="custom")
public static io.reactivex.Flowable<java.lang.Long> intervalBackpressure(long period,
                                                                                                                                               java.util.concurrent.TimeUnit unit,
                                                                                                                                               io.reactivex.Scheduler scheduler)

Periodically tries to emit an ever increasing long value or buffers (efficiently) such emissions until the downstream requests.

Backpressure:

The operator honors the backpressure of the downstream and no emission is lost, however, the timing of the reception of the values is now dependent on the downstream backpressure.

Scheduler:

The operator uses the computation Scheduler to time the emission and likely deliver the value (unless backpressured).

Parameters:

period - the emission period (including the delay for the first emission)

unit - the emission time unit

scheduler - the scheduler to use for timing and likely emitting items

Returns:

the new Flowable instance

Since:

0.15.0

intervalBackpressure

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value="io.reactivex:computation")
public static io.reactivex.Flowable<java.lang.Long> intervalBackpressure(long initialDelay,
                                                                                                                                                                 long period,
                                                                                                                                                                 java.util.concurrent.TimeUnit unit)

Periodically tries to emit an ever increasing long value or buffers (efficiently) such emissions until the downstream requests.

Backpressure:

The operator honors the backpressure of the downstream and no emission is lost, however, the timing of the reception of the values is now dependent on the downstream backpressure.

Scheduler:

The operator uses the computation Scheduler to time the emission and likely deliver the value (unless backpressured).

Parameters:

initialDelay - the initial delay before emitting the first 0L

period - the emission period after the first emission

unit - the emission time unit

Returns:

the new Flowable instance

Since:

0.15.0

intervalBackpressure

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value="custom")
public static io.reactivex.Flowable<java.lang.Long> intervalBackpressure(long initialDelay,
                                                                                                                                               long period,
                                                                                                                                               java.util.concurrent.TimeUnit unit,
                                                                                                                                               io.reactivex.Scheduler scheduler)

Periodically tries to emit an ever increasing long value or buffers (efficiently) such emissions until the downstream requests.

Backpressure:

The operator honors the backpressure of the downstream and no emission is lost, however, the timing of the reception of the values is now dependent on the downstream backpressure.

Scheduler:

The operator uses the Scheduler provided to time the emission and likely deliver the value (unless backpressured).

Parameters:

initialDelay - the initial delay before emitting the first 0L

period - the emission period (including the delay for the first emission)

unit - the emission time unit

scheduler - the scheduler to use for timing and likely emitting items

Returns:

the new Flowable instance

Since:

0.15.0

zipLatest

@BackpressureSupport(value=UNBOUNDED_IN)
 @SchedulerSupport(value="none")
public static <T,R> io.reactivex.Flowable<R> zipLatest(io.reactivex.functions.Function<? super java.lang.Object[],? extends R> combiner,
                                                                                                                                   org.reactivestreams.Publisher<? extends T>... sources)

Zips the latest available values of the source Publishers via a combiner function where the emission rate is determined by the slowest Publisher and the downstream consumption rate.

Non-consumed source values are overwritten by newer values. Unlike combineLatest, source values are not reused to form new combinations.

If any of the sources runs out of items, the other sources are cancelled and the sequence completes.

 A: ---o-o-o------o-o----o---o-|-------
 B: ---------x-x--x-------x-----x--x---
 ======= zipLatest (o, x -> M) ========
 R: ---------M----M-------M-----M|-----
 

Backpressure:

The operator honors the backpressure of the downstream and consumes the source Publishers in an unbounded manner, keeping only their latest values temporarily.

Scheduler:

The operator doesn't run on any particular Scheduler and the combined item emission happens on the thread that won the internal emission-right race.

Type Parameters:

T - the common source value type

R - the result type

Parameters:

combiner - the function receiving the latest values of the sources and returns a value to be emitted to the downstream.

sources - the array of source Publishers to zip/combine

Returns:

the new Flowable instance.

zipLatest

@BackpressureSupport(value=UNBOUNDED_IN)
 @SchedulerSupport(value="custom")
public static <T,R> io.reactivex.Flowable<R> zipLatest(io.reactivex.functions.Function<? super java.lang.Object[],? extends R> combiner,
                                                                                                                                     io.reactivex.Scheduler scheduler,
                                                                                                                                     org.reactivestreams.Publisher<? extends T>... sources)

Zips the latest available values of the source Publishers via a combiner function where the emission rate is determined by the slowest Publisher and the downstream consumption rate.

Non-consumed source values are overwritten by newer values. Unlike combineLatest, source values are not reused to form new combinations.

If any of the sources runs out of items, the other sources are cancelled and the sequence completes.

 A: ---o-o-o------o-o----o---o-|-------
 B: ---------x-x--x-------x-----x--x---
 ======= zipLatest (o, x -> M) ========
 R: ---------M----M-------M-----M|-----
 

Backpressure:

The operator honors the backpressure of the downstream and consumes the source Publishers in an unbounded manner, keeping only their latest values temporarily.

Scheduler:

The operator emits the combined items on the Scheduler provided.

Type Parameters:

T - the common source value type

R - the result type

Parameters:

combiner - the function receiving the latest values of the sources and returns a value to be emitted to the downstream.

sources - the array of source Publishers to zip/combine

scheduler - the Scheduler to use for emitting items and/or terminal signals

Returns:

the new Flowable instance.

zipLatest

@BackpressureSupport(value=UNBOUNDED_IN)
 @SchedulerSupport(value="none")
public static <T,R> io.reactivex.Flowable<R> zipLatest(java.lang.Iterable<? extends org.reactivestreams.Publisher<? extends T>> sources,
                                                                                                                                   io.reactivex.functions.Function<? super java.lang.Object[],? extends R> combiner)

Zips the latest available values of the source Publishers via a combiner function where the emission rate is determined by the slowest Publisher and the downstream consumption rate.

Non-consumed source values are overwritten by newer values. Unlike combineLatest, source values are not reused to form new combinations.

If any of the sources runs out of items, the other sources are cancelled and the sequence completes.

 A: ---o-o-o------o-o----o---o-|-------
 B: ---------x-x--x-------x-----x--x---
 ======= zipLatest (o, x -> M) ========
 R: ---------M----M-------M-----M|-----
 

Backpressure:

The operator honors the backpressure of the downstream and consumes the source Publishers in an unbounded manner, keeping only their latest values temporarily.

Scheduler:

The operator doesn't run on any particular Scheduler scheduler and the combined item emission happens on the thread that won the internal emission-right race.

Type Parameters:

T - the common source value type

R - the result type

Parameters:

combiner - the function receiving the latest values of the sources and returns a value to be emitted to the downstream.

sources - the array of source Publishers to zip/combine

Returns:

the new Flowable instance.

zipLatest

@BackpressureSupport(value=UNBOUNDED_IN)
 @SchedulerSupport(value="custom")
public static <T,R> io.reactivex.Flowable<R> zipLatest(java.lang.Iterable<? extends org.reactivestreams.Publisher<? extends T>> sources,
                                                                                                                                     io.reactivex.functions.Function<? super java.lang.Object[],? extends R> combiner,
                                                                                                                                     io.reactivex.Scheduler scheduler)

Zips the latest available values of the source Publishers via a combiner function where the emission rate is determined by the slowest Publisher and the downstream consumption rate.

Non-consumed source values are overwritten by newer values. Unlike combineLatest, source values are not reused to form new combinations.

If any of the sources runs out of items, the other sources are cancelled and the sequence completes.

 A: ---o-o-o------o-o----o---o-|-------
 B: ---------x-x--x-------x-----x--x---
 ======= zipLatest (o, x -> M) ========
 R: ---------M----M-------M-----M|-----
 

Backpressure:

The operator honors the backpressure of the downstream and consumes the source Publishers in an unbounded manner, keeping only their latest values temporarily.

Scheduler:

The operator emits the combined items on the Scheduler provided.

Type Parameters:

T - the common source value type

R - the result type

Parameters:

combiner - the function receiving the latest values of the sources and returns a value to be emitted to the downstream.

sources - the array of source Publishers to zip/combine

scheduler - the Scheduler to use for emitting items and/or terminal signals

Returns:

the new Flowable instance.

zipLatest

@BackpressureSupport(value=UNBOUNDED_IN)
 @SchedulerSupport(value="none")
public static <T1,T2,R> io.reactivex.Flowable<R> zipLatest(org.reactivestreams.Publisher<T1> source1,
                                                                                                                                       org.reactivestreams.Publisher<T2> source2,
                                                                                                                                       io.reactivex.functions.BiFunction<? super T1,? super T2,? extends R> combiner)

Zips the latest available values of the source Publishers via a combiner function where the emission rate is determined by the slowest Publisher and the downstream consumption rate.

Non-consumed source values are overwritten by newer values. Unlike combineLatest, source values are not reused to form new combinations.

If any of the sources runs out of items, the other sources are cancelled and the sequence completes.

 A: ---o-o-o------o-o----o---o-|-------
 B: ---------x-x--x-------x-----x--x---
 ======= zipLatest (o, x -> M) ========
 R: ---------M----M-------M-----M|-----
 

Backpressure:

The operator honors the backpressure of the downstream and consumes the source Publishers in an unbounded manner, keeping only their latest values temporarily.

Scheduler:

The operator doesn't run on any particular Scheduler scheduler and the combined item emission happens on the thread that won the internal emission-right race.

Type Parameters:

T1 - the value type of the first source Publisher

T2 - the value type of the second source Publisher

R - the result type

Parameters:

combiner - the function receiving the latest values of the sources and returns a value to be emitted to the downstream.

source1 - the first source Publisher instance

source2 - the second source Publisher instance

Returns:

the new Flowable instance.

zipLatest

@BackpressureSupport(value=UNBOUNDED_IN)
 @SchedulerSupport(value="custom")
public static <T1,T2,R> io.reactivex.Flowable<R> zipLatest(org.reactivestreams.Publisher<T1> source1,
                                                                                                                                         org.reactivestreams.Publisher<T2> source2,
                                                                                                                                         io.reactivex.functions.BiFunction<? super T1,? super T2,? extends R> combiner,
                                                                                                                                         io.reactivex.Scheduler scheduler)

Zips the latest available values of the source Publishers via a combiner function where the emission rate is determined by the slowest Publisher and the downstream consumption rate.

Non-consumed source values are overwritten by newer values. Unlike combineLatest, source values are not reused to form new combinations.

If any of the sources runs out of items, the other sources are cancelled and the sequence completes.

 A: ---o-o-o------o-o----o---o-|-------
 B: ---------x-x--x-------x-----x--x---
 ======= zipLatest (o, x -> M) ========
 R: ---------M----M-------M-----M|-----
 

Backpressure:

The operator honors the backpressure of the downstream and consumes the source Publishers in an unbounded manner, keeping only their latest values temporarily.

Scheduler:

The operator emits the combined items on the Scheduler provided.

Type Parameters:

T1 - the value type of the first source Publisher

T2 - the value type of the second source Publisher

R - the result type

Parameters:

combiner - the function receiving the latest values of the sources and returns a value to be emitted to the downstream.

source1 - the first source Publisher instance

source2 - the second source Publisher instance

scheduler - the Scheduler to use for emitting items and/or terminal signals

Returns:

the new Flowable instance.

zipLatest

@BackpressureSupport(value=UNBOUNDED_IN)
 @SchedulerSupport(value="none")
public static <T1,T2,T3,R> io.reactivex.Flowable<R> zipLatest(org.reactivestreams.Publisher<T1> source1,
                                                                                                                                          org.reactivestreams.Publisher<T2> source2,
                                                                                                                                          org.reactivestreams.Publisher<T3> source3,
                                                                                                                                          io.reactivex.functions.Function3<? super T1,? super T2,? super T3,? extends R> combiner)

Zips the latest available values of the source Publishers via a combiner function where the emission rate is determined by the slowest Publisher and the downstream consumption rate.

Non-consumed source values are overwritten by newer values. Unlike combineLatest, source values are not reused to form new combinations.

If any of the sources runs out of items, the other sources are cancelled and the sequence completes.

 A: ---o-o-o------o-o----o---o-|-------
 B: ---------x-x--x-------x-----x--x---
 ======= zipLatest (o, x -> M) ========
 R: ---------M----M-------M-----M|-----
 

Backpressure:

The operator honors the backpressure of the downstream and consumes the source Publishers in an unbounded manner, keeping only their latest values temporarily.

Scheduler:

The operator doesn't run on any particular Scheduler scheduler and the combined item emission happens on the thread that won the internal emission-right race.

Type Parameters:

T1 - the value type of the first source Publisher

T2 - the value type of the second source Publisher

T3 - the value type of the third source Publisher

R - the result type

Parameters:

combiner - the function receiving the latest values of the sources and returns a value to be emitted to the downstream.

source1 - the first source Publisher instance

source2 - the second source Publisher instance

source3 - the third source Publisher instance

Returns:

the new Flowable instance.

zipLatest

@BackpressureSupport(value=UNBOUNDED_IN)
 @SchedulerSupport(value="custom")
public static <T1,T2,T3,R> io.reactivex.Flowable<R> zipLatest(org.reactivestreams.Publisher<T1> source1,
                                                                                                                                            org.reactivestreams.Publisher<T2> source2,
                                                                                                                                            org.reactivestreams.Publisher<T3> source3,
                                                                                                                                            io.reactivex.functions.Function3<? super T1,? super T2,? super T3,? extends R> combiner,
                                                                                                                                            io.reactivex.Scheduler scheduler)

Zips the latest available values of the source Publishers via a combiner function where the emission rate is determined by the slowest Publisher and the downstream consumption rate.

Non-consumed source values are overwritten by newer values. Unlike combineLatest, source values are not reused to form new combinations.

If any of the sources runs out of items, the other sources are cancelled and the sequence completes.

 A: ---o-o-o------o-o----o---o-|-------
 B: ---------x-x--x-------x-----x--x---
 ======= zipLatest (o, x -> M) ========
 R: ---------M----M-------M-----M|-----
 

Backpressure:

The operator honors the backpressure of the downstream and consumes the source Publishers in an unbounded manner, keeping only their latest values temporarily.

Scheduler:

The operator emits the combined items on the Scheduler provided.

Type Parameters:

T1 - the value type of the first source Publisher

T2 - the value type of the second source Publisher

T3 - the value type of the third source Publisher

R - the result type

Parameters:

combiner - the function receiving the latest values of the sources and returns a value to be emitted to the downstream.

source1 - the first source Publisher instance

source2 - the second source Publisher instance

source3 - the third source Publisher instance

scheduler - the Scheduler to use for emitting items and/or terminal signals

Returns:

the new Flowable instance.

zipLatest

@BackpressureSupport(value=UNBOUNDED_IN)
 @SchedulerSupport(value="none")
public static <T1,T2,T3,T4,R> io.reactivex.Flowable<R> zipLatest(org.reactivestreams.Publisher<T1> source1,
                                                                                                                                             org.reactivestreams.Publisher<T2> source2,
                                                                                                                                             org.reactivestreams.Publisher<T3> source3,
                                                                                                                                             org.reactivestreams.Publisher<T4> source4,
                                                                                                                                             io.reactivex.functions.Function4<? super T1,? super T2,? super T3,? super T4,? extends R> combiner)

Zips the latest available values of the source Publishers via a combiner function where the emission rate is determined by the slowest Publisher and the downstream consumption rate.

Non-consumed source values are overwritten by newer values. Unlike combineLatest, source values are not reused to form new combinations.

If any of the sources runs out of items, the other sources are cancelled and the sequence completes.

 A: ---o-o-o------o-o----o---o-|-------
 B: ---------x-x--x-------x-----x--x---
 ======= zipLatest (o, x -> M) ========
 R: ---------M----M-------M-----M|-----
 

Backpressure:

The operator honors the backpressure of the downstream and consumes the source Publishers in an unbounded manner, keeping only their latest values temporarily.

Scheduler:

The operator doesn't run on any particular Scheduler scheduler and the combined item emission happens on the thread that won the internal emission-right race.

Type Parameters:

T1 - the value type of the first source Publisher

T2 - the value type of the second source Publisher

T3 - the value type of the third source Publisher

T4 - the value type of the fourth source Publisher

R - the result type

Parameters:

combiner - the function receiving the latest values of the sources and returns a value to be emitted to the downstream.

source1 - the first source Publisher instance

source2 - the second source Publisher instance

source3 - the third source Publisher instance

source4 - the fourth source Publisher instance

Returns:

the new Flowable instance.

zipLatest

@BackpressureSupport(value=UNBOUNDED_IN)
 @SchedulerSupport(value="custom")
public static <T1,T2,T3,T4,R> io.reactivex.Flowable<R> zipLatest(org.reactivestreams.Publisher<T1> source1,
                                                                                                                                               org.reactivestreams.Publisher<T2> source2,
                                                                                                                                               org.reactivestreams.Publisher<T3> source3,
                                                                                                                                               org.reactivestreams.Publisher<T4> source4,
                                                                                                                                               io.reactivex.functions.Function4<? super T1,? super T2,? super T3,? super T4,? extends R> combiner,
                                                                                                                                               io.reactivex.Scheduler scheduler)

Zips the latest available values of the source Publishers via a combiner function where the emission rate is determined by the slowest Publisher and the downstream consumption rate.

Non-consumed source values are overwritten by newer values. Unlike combineLatest, source values are not reused to form new combinations.

If any of the sources runs out of items, the other sources are cancelled and the sequence completes.

 A: ---o-o-o------o-o----o---o-|-------
 B: ---------x-x--x-------x-----x--x---
 ======= zipLatest (o, x -> M) ========
 R: ---------M----M-------M-----M|-----
 

Backpressure:

The operator honors the backpressure of the downstream and consumes the source Publishers in an unbounded manner, keeping only their latest values temporarily.

Scheduler:

The operator emits the combined items on the Scheduler provided.

Type Parameters:

T1 - the value type of the first source Publisher

T2 - the value type of the second source Publisher

T3 - the value type of the third source Publisher

T4 - the value type of the fourth source Publisher

R - the result type

Parameters:

combiner - the function receiving the latest values of the sources and returns a value to be emitted to the downstream.

source1 - the first source Publisher instance

source2 - the second source Publisher instance

source3 - the third source Publisher instance

source4 - the fourth source Publisher instance

scheduler - the Scheduler to use for emitting items and/or terminal signals

Returns:

the new Flowable instance.