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

All Methods Static Methods Concrete Methods

`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).

### 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