Flowable (RxJava Javadoc 2.2.21)

java.lang.Object
- io.reactivex.Flowable

Type Parameters:

T - the type of the items emitted by the Flowable

All Implemented Interfaces:

Publisher

Direct Known Subclasses:

ConnectableFlowable, FlowableProcessor, GroupedFlowable
```
public abstract class Flowable
extends Object
implements Publisher
```
The Flowable class that implements the Reactive Streams Pattern and offers factory methods, intermediate operators and the ability to consume reactive dataflows.
Reactive Streams operates with Publishers which Flowable extends. Many operators therefore accept general Publishers directly and allow direct interoperation with other Reactive Streams implementations.
The Flowable hosts the default buffer size of 128 elements for operators, accessible via bufferSize(), that can be overridden globally via the system parameter rx2.buffer-size. Most operators, however, have overloads that allow setting their internal buffer size explicitly.
The documentation for this class makes use of marble diagrams. The following legend explains these diagrams:

The Flowable follows the protocol
```
      onSubscribe onNext* (onError | onComplete)?
 
```
where the stream can be disposed through the Subscription instance provided to consumers through Subscriber.onSubscribe(Subscription). Unlike the Observable.subscribe() of version 1.x, subscribe(Subscriber) does not allow external cancellation of a subscription and the Subscriber instance is expected to expose such capability if needed.
Flowables support backpressure and require Subscribers to signal demand via Subscription.request(long).
Example:
```
 Disposable d = Flowable.just("Hello world!")
     .delay(1, TimeUnit.SECONDS)
     .subscribeWith(new DisposableSubscriber() {
         @Override public void onStart() {
             System.out.println("Start!");
             request(1);
         }
         @Override public void onNext(String t) {
             System.out.println(t);
             request(1);
         }
         @Override public void onError(Throwable t) {
             t.printStackTrace();
         }
         @Override public void onComplete() {
             System.out.println("Done!");
         }
     });

 Thread.sleep(500);
 // the sequence can now be cancelled via dispose()
 d.dispose();
 
```
The Reactive Streams specification is relatively strict when defining interactions between Publishers and Subscribers, so much so that there is a significant performance penalty due certain timing requirements and the need to prepare for invalid request amounts via Subscription.request(long). Therefore, RxJava has introduced the FlowableSubscriber interface that indicates the consumer can be driven with relaxed rules. All RxJava operators are implemented with these relaxed rules in mind. If the subscribing Subscriber does not implement this interface, for example, due to it being from another Reactive Streams compliant library, the Flowable will automatically apply a compliance wrapper around it.
Flowable is an abstract class, but it is not advised to implement sources and custom operators by extending the class directly due to the large amounts of Reactive Streams rules to be followed to the letter. See the wiki for some guidance if such custom implementations are necessary.
The recommended way of creating custom Flowables is by using the create(FlowableOnSubscribe, BackpressureStrategy) factory method:
```
 Flowable source = Flowable.create(new FlowableOnSubscribe() {
     @Override
     public void subscribe(FlowableEmitter emitter) throws Exception {

         // signal an item
         emitter.onNext("Hello");

         // could be some blocking operation
         Thread.sleep(1000);

         // the consumer might have cancelled the flow
         if (emitter.isCancelled() {
             return;
         }

         emitter.onNext("World");

         Thread.sleep(1000);

         // the end-of-sequence has to be signaled, otherwise the
         // consumers may never finish
         emitter.onComplete();
     }
 }, BackpressureStrategy.BUFFER);

 System.out.println("Subscribe!");
 
 source.subscribe(System.out::println);
 
 System.out.println("Done!");
 
```
RxJava reactive sources, such as Flowable, are generally synchronous and sequential in nature. In the ReactiveX design, the location (thread) where operators run is orthogonal to when the operators can work with data. This means that asynchrony and parallelism has to be explicitly expressed via operators such as subscribeOn(Scheduler), observeOn(Scheduler) and parallel(). In general, operators featuring a Scheduler parameter are introducing this type of asynchrony into the flow.
For more information see the ReactiveX documentation.
See Also:

Observable, ParallelFlowable, DisposableSubscriber

Constructor Summary

Constructors
Constructor and Description

Flowable()

Constructors
Constructor and Description
`Flowable()`

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`Single<Boolean>`	`all(PredicateT> predicate)` Returns a Single that emits a Boolean that indicates whether all of the items emitted by the source Publisher satisfy a condition.
`static Flowable`	`amb(IterablePublisher> sources)` Mirrors the one Publisher in an Iterable of several Publishers that first either emits an item or sends a termination notification.
`static Flowable`	`ambArray(Publisher... sources)` Mirrors the one Publisher in an array of several Publishers that first either emits an item or sends a termination notification.
`Flowable<T>`	`ambWith(PublisherT> other)` Mirrors the Publisher (current or provided) that first either emits an item or sends a termination notification.
`Single<Boolean>`	`any(PredicateT> predicate)` Returns a Single that emits `true` if any item emitted by the source Publisher satisfies a specified condition, otherwise `false`.
`R`	`as(FlowableConverter<T,? extends R> converter)` Calls the specified converter function during assembly time and returns its resulting value.
`T`	`blockingFirst()` Returns the first item emitted by this `Flowable`, or throws `NoSuchElementException` if it emits no items.
`T`	`blockingFirst(T defaultItem)` Returns the first item emitted by this `Flowable`, or a default value if it emits no items.
`void`	`blockingForEach(ConsumerT> onNext)` Consumes the upstream `Flowable` in a blocking fashion and invokes the given `Consumer` with each upstream item on the current thread until the upstream terminates.
`Iterable<T>`	`blockingIterable()` Converts this `Flowable` into an `Iterable`.
`Iterable<T>`	`blockingIterable(int bufferSize)` Converts this `Flowable` into an `Iterable`.
`T`	`blockingLast()` Returns the last item emitted by this `Flowable`, or throws `NoSuchElementException` if this `Flowable` emits no items.
`T`	`blockingLast(T defaultItem)` Returns the last item emitted by this `Flowable`, or a default value if it emits no items.
`Iterable<T>`	`blockingLatest()` Returns an `Iterable` that returns the latest item emitted by this `Flowable`, waiting if necessary for one to become available.
`Iterable<T>`	`blockingMostRecent(T initialItem)` Returns an `Iterable` that always returns the item most recently emitted by this `Flowable`.
`Iterable<T>`	`blockingNext()` Returns an `Iterable` that blocks until this `Flowable` emits another item, then returns that item.
`T`	`blockingSingle()` If this `Flowable` completes after emitting a single item, return that item, otherwise throw a `NoSuchElementException`.
`T`	`blockingSingle(T defaultItem)` If this `Flowable` completes after emitting a single item, return that item; if it emits more than one item, throw an `IllegalArgumentException`; if it emits no items, return a default value.
`void`	`blockingSubscribe()` Runs the source Flowable to a terminal event, ignoring any values and rethrowing any exception.
`void`	`blockingSubscribe(ConsumerT> onNext)` Subscribes to the source and calls the given callbacks on the current thread.
`void`	`blockingSubscribe(ConsumerT> onNext, ConsumerThrowable> onError)` Subscribes to the source and calls the given callbacks on the current thread.
`void`	`blockingSubscribe(ConsumerT> onNext, ConsumerThrowable> onError, Action onComplete)` Subscribes to the source and calls the given callbacks on the current thread.
`void`	`blockingSubscribe(ConsumerT> onNext, ConsumerThrowable> onError, Action onComplete, int bufferSize)` Subscribes to the source and calls the given callbacks on the current thread.
`void`	`blockingSubscribe(ConsumerT> onNext, ConsumerThrowable> onError, int bufferSize)` Subscribes to the source and calls the given callbacks on the current thread.
`void`	`blockingSubscribe(ConsumerT> onNext, int bufferSize)` Subscribes to the source and calls the given callbacks on the current thread.
`void`	`blockingSubscribe(SubscriberT> subscriber)` Subscribes to the source and calls the `Subscriber` methods on the current thread.
`Flowable<List<T>>`	`buffer(CallablePublisher> boundaryIndicatorSupplier)` Returns a Flowable that emits buffers of items it collects from the source Publisher.
`CollectionT>> Flowable`	`buffer(CallablePublisher> boundaryIndicatorSupplier, Callable bufferSupplier)` Returns a Flowable that emits buffers of items it collects from the source Publisher.
`Flowable<List<T>>`	`buffer(Flowable openingIndicator, FunctionPublisher> closingIndicator)` Returns a Flowable that emits buffers of items it collects from the source Publisher.
`CollectionT>> Flowable`	`buffer(Flowable openingIndicator, FunctionPublisher> closingIndicator, Callable bufferSupplier)` Returns a Flowable that emits buffers of items it collects from the source Publisher.
`Flowable<List<T>>`	`buffer(int count)` Returns a Flowable that emits buffers of items it collects from the source Publisher.
`CollectionT>> Flowable`	`buffer(int count, Callable bufferSupplier)` Returns a Flowable that emits buffers of items it collects from the source Publisher.
`Flowable<List<T>>`	`buffer(int count, int skip)` Returns a Flowable that emits buffers of items it collects from the source Publisher.
`CollectionT>> Flowable`	`buffer(int count, int skip, Callable bufferSupplier)` Returns a Flowable that emits buffers of items it collects from the source Publisher.
`Flowable<List<T>>`	`buffer(long timespan, long timeskip, TimeUnit unit)` Returns a Flowable that emits buffers of items it collects from the source Publisher.
`Flowable<List<T>>`	`buffer(long timespan, long timeskip, TimeUnit unit, Scheduler scheduler)` Returns a Flowable that emits buffers of items it collects from the source Publisher.
`CollectionT>> Flowable`	`buffer(long timespan, long timeskip, TimeUnit unit, Scheduler scheduler, Callable bufferSupplier)` Returns a Flowable that emits buffers of items it collects from the source Publisher.
`Flowable<List<T>>`	`buffer(long timespan, TimeUnit unit)` Returns a Flowable that emits buffers of items it collects from the source Publisher.
`Flowable<List<T>>`	`buffer(long timespan, TimeUnit unit, int count)` Returns a Flowable that emits buffers of items it collects from the source Publisher.
`Flowable<List<T>>`	`buffer(long timespan, TimeUnit unit, Scheduler scheduler)` Returns a Flowable that emits buffers of items it collects from the source Publisher.
`Flowable<List<T>>`	`buffer(long timespan, TimeUnit unit, Scheduler scheduler, int count)` Returns a Flowable that emits buffers of items it collects from the source Publisher.
`CollectionT>> Flowable`	`buffer(long timespan, TimeUnit unit, Scheduler scheduler, int count, Callable bufferSupplier, boolean restartTimerOnMaxSize)` Returns a Flowable that emits buffers of items it collects from the source Publisher.
`Flowable<List<T>>`	`buffer(Publisher boundaryIndicator)` Returns a Flowable that emits non-overlapping buffered items from the source Publisher each time the specified boundary Publisher emits an item.
`CollectionT>> Flowable`	`buffer(Publisher boundaryIndicator, Callable bufferSupplier)` Returns a Flowable that emits non-overlapping buffered items from the source Publisher each time the specified boundary Publisher emits an item.
`Flowable<List<T>>`	`buffer(Publisher boundaryIndicator, int initialCapacity)` Returns a Flowable that emits non-overlapping buffered items from the source Publisher each time the specified boundary Publisher emits an item.
`static int`	`bufferSize()` Returns the default internal buffer size used by most async operators.
`Flowable<T>`	`cache()` Returns a Flowable that subscribes to this Publisher lazily, caches all of its events and replays them, in the same order as received, to all the downstream subscribers.
`Flowable<T>`	`cacheWithInitialCapacity(int initialCapacity)` Returns a Flowable that subscribes to this Publisher lazily, caches all of its events and replays them, in the same order as received, to all the downstream subscribers.
`Flowable`	`cast(Class clazz)` Returns a Flowable that emits the items emitted by the source Publisher, converted to the specified type.
`Single`	`collect(Callable initialItemSupplier, BiConsumerT> collector)` Collects items emitted by the finite source Publisher into a single mutable data structure and returns a Single that emits this structure.
`Single`	`collectInto(U initialItem, BiConsumerT> collector)` Collects items emitted by the finite source Publisher into a single mutable data structure and returns a Single that emits this structure.
`static Flowable`	`combineLatest(FunctionObject[],? extends R> combiner, Publisher... sources)` Combines a collection of source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function.
`static Flowable`	`combineLatest(IterablePublisher> sources, FunctionObject[],? extends R> combiner)` Combines a collection of source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function.
`static Flowable`	`combineLatest(IterablePublisher> sources, FunctionObject[],? extends R> combiner, int bufferSize)` Combines a collection of source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function.
`static Flowable`	`combineLatest(Publisher[] sources, FunctionObject[],? extends R> combiner)` Combines a collection of source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function.
`static Flowable`	`combineLatest(Publisher[] sources, FunctionObject[],? extends R> combiner, int bufferSize)` Combines a collection of source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function.
`static Flowable`	`combineLatest(Publisher source1, Publisher source2, BiFunction combiner)` Combines two source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from either of the source Publishers, where this aggregation is defined by a specified function.
`static Flowable`	`combineLatest(Publisher source1, Publisher source2, Publisher source3, Function3 combiner)` Combines three source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function.
`static Flowable`	`combineLatest(Publisher source1, Publisher source2, Publisher source3, Publisher source4, Function4 combiner)` Combines four source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function.
`static Flowable`	`combineLatest(Publisher source1, Publisher source2, Publisher source3, Publisher source4, Publisher source5, Function5 combiner)` Combines five source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function.
`static Flowable`	`combineLatest(Publisher source1, Publisher source2, Publisher source3, Publisher source4, Publisher source5, Publisher source6, Function6 combiner)` Combines six source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function.
`static Flowable`	`combineLatest(Publisher source1, Publisher source2, Publisher source3, Publisher source4, Publisher source5, Publisher source6, Publisher source7, Function7 combiner)` Combines seven source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function.
`static Flowable`	`combineLatest(Publisher source1, Publisher source2, Publisher source3, Publisher source4, Publisher source5, Publisher source6, Publisher source7, Publisher source8, Function8 combiner)` Combines eight source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function.
`static Flowable`	`combineLatest(Publisher source1, Publisher source2, Publisher source3, Publisher source4, Publisher source5, Publisher source6, Publisher source7, Publisher source8, Publisher source9, Function9 combiner)` Combines nine source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function.
`static Flowable`	`combineLatestDelayError(FunctionObject[],? extends R> combiner, int bufferSize, Publisher... sources)` Combines a collection of source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publisher, where this aggregation is defined by a specified function and delays any error from the sources until all source Publishers terminate.
`static Flowable`	`combineLatestDelayError(FunctionObject[],? extends R> combiner, Publisher... sources)` Combines a collection of source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function and delays any error from the sources until all source Publishers terminate.
`static Flowable`	`combineLatestDelayError(IterablePublisher> sources, FunctionObject[],? extends R> combiner)` Combines a collection of source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function and delays any error from the sources until all source Publishers terminate.
`static Flowable`	`combineLatestDelayError(IterablePublisher> sources, FunctionObject[],? extends R> combiner, int bufferSize)` Combines a collection of source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function and delays any error from the sources until all source Publishers terminate.
`static Flowable`	`combineLatestDelayError(Publisher[] sources, FunctionObject[],? extends R> combiner)` Combines a collection of source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function.
`static Flowable`	`combineLatestDelayError(Publisher[] sources, FunctionObject[],? extends R> combiner, int bufferSize)` Combines a collection of source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function and delays any error from the sources until all source Publishers terminate.
`Flowable`	`compose(FlowableTransformerT,? extends R> composer)` Transform a Publisher by applying a particular Transformer function to it.
`static Flowable`	`concat(IterablePublisher> sources)` Concatenates elements of each Publisher provided via an Iterable sequence into a single sequence of elements without interleaving them.
`static Flowable`	`concat(PublisherPublisher> sources)` Returns a Flowable that emits the items emitted by each of the Publishers emitted by the source Publisher, one after the other, without interleaving them.
`static Flowable`	`concat(PublisherPublisher> sources, int prefetch)` Returns a Flowable that emits the items emitted by each of the Publishers emitted by the source Publisher, one after the other, without interleaving them.
`static Flowable`	`concat(Publisher source1, Publisher source2)` Returns a Flowable that emits the items emitted by two Publishers, one after the other, without interleaving them.
`static Flowable`	`concat(Publisher source1, Publisher source2, Publisher source3)` Returns a Flowable that emits the items emitted by three Publishers, one after the other, without interleaving them.
`static Flowable`	`concat(Publisher source1, Publisher source2, Publisher source3, Publisher source4)` Returns a Flowable that emits the items emitted by four Publishers, one after the other, without interleaving them.
`static Flowable`	`concatArray(Publisher... sources)` Concatenates a variable number of Publisher sources.
`static Flowable`	`concatArrayDelayError(Publisher... sources)` Concatenates a variable number of Publisher sources and delays errors from any of them till all terminate.
`static Flowable`	`concatArrayEager(int maxConcurrency, int prefetch, Publisher... sources)` Concatenates an array of Publishers eagerly into a single stream of values.
`static Flowable`	`concatArrayEager(Publisher... sources)` Concatenates an array of Publishers eagerly into a single stream of values.
`static Flowable`	`concatArrayEagerDelayError(int maxConcurrency, int prefetch, Publisher... sources)` Concatenates an array of `Publisher`s eagerly into a single stream of values and delaying any errors until all sources terminate.
`static Flowable`	`concatArrayEagerDelayError(Publisher... sources)` Concatenates an array of `Publisher`s eagerly into a single stream of values and delaying any errors until all sources terminate.
`static Flowable`	`concatDelayError(IterablePublisher> sources)` Concatenates the Iterable sequence of Publishers into a single sequence by subscribing to each Publisher, one after the other, one at a time and delays any errors till the all inner Publishers terminate.
`static Flowable`	`concatDelayError(PublisherPublisher> sources)` Concatenates the Publisher sequence of Publishers into a single sequence by subscribing to each inner Publisher, one after the other, one at a time and delays any errors till the all inner and the outer Publishers terminate.
`static Flowable`	`concatDelayError(PublisherPublisher> sources, int prefetch, boolean tillTheEnd)` Concatenates the Publisher sequence of Publishers into a single sequence by subscribing to each inner Publisher, one after the other, one at a time and delays any errors till the all inner and the outer Publishers terminate.
`static Flowable`	`concatEager(IterablePublisher> sources)` Concatenates a sequence of Publishers eagerly into a single stream of values.
`static Flowable`	`concatEager(IterablePublisher> sources, int maxConcurrency, int prefetch)` Concatenates a sequence of Publishers eagerly into a single stream of values.
`static Flowable`	`concatEager(PublisherPublisher> sources)` Concatenates a Publisher sequence of Publishers eagerly into a single stream of values.
`static Flowable`	`concatEager(PublisherPublisher> sources, int maxConcurrency, int prefetch)` Concatenates a Publisher sequence of Publishers eagerly into a single stream of values.
`Flowable`	`concatMap(FunctionT,? extends Publisher> mapper)` Returns a new Flowable that emits items resulting from applying a function that you supply to each item emitted by the source Publisher, where that function returns a Publisher, and then emitting the items that result from concatenating those resulting Publishers.
`Flowable`	`concatMap(FunctionT,? extends Publisher> mapper, int prefetch)` Returns a new Flowable that emits items resulting from applying a function that you supply to each item emitted by the source Publisher, where that function returns a Publisher, and then emitting the items that result from concatenating those resulting Publishers.
`Completable`	`concatMapCompletable(FunctionT,? extends CompletableSource> mapper)` Maps the upstream items into `CompletableSource`s and subscribes to them one after the other completes.
`Completable`	`concatMapCompletable(FunctionT,? extends CompletableSource> mapper, int prefetch)` Maps the upstream items into `CompletableSource`s and subscribes to them one after the other completes.
`Completable`	`concatMapCompletableDelayError(FunctionT,? extends CompletableSource> mapper)` Maps the upstream items into `CompletableSource`s and subscribes to them one after the other terminates, delaying all errors till both this `Flowable` and all inner `CompletableSource`s terminate.
`Completable`	`concatMapCompletableDelayError(FunctionT,? extends CompletableSource> mapper, boolean tillTheEnd)` Maps the upstream items into `CompletableSource`s and subscribes to them one after the other terminates, optionally delaying all errors till both this `Flowable` and all inner `CompletableSource`s terminate.
`Completable`	`concatMapCompletableDelayError(FunctionT,? extends CompletableSource> mapper, boolean tillTheEnd, int prefetch)` Maps the upstream items into `CompletableSource`s and subscribes to them one after the other terminates, optionally delaying all errors till both this `Flowable` and all inner `CompletableSource`s terminate.
`Flowable`	`concatMapDelayError(FunctionT,? extends Publisher> mapper)` Maps each of the items into a Publisher, 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 Publishers till all of them terminate.
`Flowable`	`concatMapDelayError(FunctionT,? extends Publisher> mapper, int prefetch, boolean tillTheEnd)` Maps each of the items into a Publisher, 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 Publishers till all of them terminate.
`Flowable`	`concatMapEager(FunctionT,? extends Publisher> mapper)` Maps a sequence of values into Publishers and concatenates these Publishers eagerly into a single Publisher.
`Flowable`	`concatMapEager(FunctionT,? extends Publisher> mapper, int maxConcurrency, int prefetch)` Maps a sequence of values into Publishers and concatenates these Publishers eagerly into a single Publisher.
`Flowable`	`concatMapEagerDelayError(FunctionT,? extends Publisher> mapper, boolean tillTheEnd)` Maps a sequence of values into Publishers and concatenates these Publishers eagerly into a single Publisher.
`Flowable`	`concatMapEagerDelayError(FunctionT,? extends Publisher> mapper, int maxConcurrency, int prefetch, boolean tillTheEnd)` Maps a sequence of values into Publishers and concatenates these Publishers eagerly into a single Publisher.
`Flowable`	`concatMapIterable(FunctionT,? extends Iterable> mapper)` Returns a Flowable that concatenate each item emitted by the source Publisher with the values in an Iterable corresponding to that item that is generated by a selector.
`Flowable`	`concatMapIterable(FunctionT,? extends Iterable> mapper, int prefetch)` Returns a Flowable that concatenate each item emitted by the source Publisher with the values in an Iterable corresponding to that item that is generated by a selector.
`Flowable`	`concatMapMaybe(FunctionT,? extends MaybeSource> 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 this `Flowable` or the current inner `MaybeSource` fail.
`Flowable`	`concatMapMaybe(FunctionT,? extends MaybeSource> mapper, int prefetch)` 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 this `Flowable` or the current inner `MaybeSource` fail.
`Flowable`	`concatMapMaybeDelayError(FunctionT,? extends MaybeSource> 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 this `Flowable` and all inner `MaybeSource`s terminate.
`Flowable`	`concatMapMaybeDelayError(FunctionT,? extends MaybeSource> 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 this `Flowable` and all inner `MaybeSource`s terminate.
`Flowable`	`concatMapMaybeDelayError(FunctionT,? extends MaybeSource> mapper, boolean tillTheEnd, int prefetch)` 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 this `Flowable` and all inner `MaybeSource`s terminate.
`Flowable`	`concatMapSingle(FunctionT,? extends SingleSource> 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 this `Flowable` or the current inner `SingleSource` fail.
`Flowable`	`concatMapSingle(FunctionT,? extends SingleSource> mapper, int prefetch)` 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 this `Flowable` or the current inner `SingleSource` fail.
`Flowable`	`concatMapSingleDelayError(FunctionT,? extends SingleSource> 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 this `Flowable` and all inner `SingleSource`s terminate.
`Flowable`	`concatMapSingleDelayError(FunctionT,? extends SingleSource> 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 this `Flowable` and all inner `SingleSource`s terminate.
`Flowable`	`concatMapSingleDelayError(FunctionT,? extends SingleSource> mapper, boolean tillTheEnd, int prefetch)` 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 this `Flowable` and all inner `SingleSource`s terminate.
`Flowable<T>`	`concatWith(CompletableSource other)` Returns a `Flowable` that emits items from this `Flowable` and when it completes normally, the other `CompletableSource` is subscribed to and the returned `Flowable` emits its terminal events.
`Flowable<T>`	`concatWith(MaybeSourceT> other)` Returns a `Flowable` that emits the items from this `Flowable` followed by the success item or terminal events of the other `MaybeSource`.
`Flowable<T>`	`concatWith(PublisherT> other)` Returns a Flowable that emits the items emitted from the current Publisher, then the next, one after the other, without interleaving them.
`Flowable<T>`	`concatWith(SingleSourceT> other)` Returns a `Flowable` that emits the items from this `Flowable` followed by the success item or error event of the other `SingleSource`.
`Single<Boolean>`	`contains(Object item)` Returns a Single that emits a Boolean that indicates whether the source Publisher emitted a specified item.
`Single<Long>`	`count()` Returns a Single that counts the total number of items emitted by the source Publisher and emits this count as a 64-bit Long.
`static Flowable`	`create(FlowableOnSubscribe source, BackpressureStrategy mode)` Provides an API (via a cold Flowable) that bridges the reactive world with the callback-style, generally non-backpressured world.
`Flowable<T>`	`debounce(FunctionT,? extends Publisher> debounceIndicator)` Returns a Flowable that mirrors the source Publisher, except that it drops items emitted by the source Publisher that are followed by another item within a computed debounce duration.
`Flowable<T>`	`debounce(long timeout, TimeUnit unit)` Returns a Flowable that mirrors the source Publisher, except that it drops items emitted by the source Publisher that are followed by newer items before a timeout value expires.
`Flowable<T>`	`debounce(long timeout, TimeUnit unit, Scheduler scheduler)` Returns a Flowable that mirrors the source Publisher, except that it drops items emitted by the source Publisher that are followed by newer items before a timeout value expires on a specified Scheduler.
`Flowable<T>`	`defaultIfEmpty(T defaultItem)` Returns a Flowable that emits the items emitted by the source Publisher or a specified default item if the source Publisher is empty.
`static Flowable`	`defer(CallablePublisher> supplier)` Returns a Flowable that calls a Publisher factory to create a Publisher for each new Subscriber that subscribes.
`Flowable<T>`	`delay(FunctionT,? extends Publisher> itemDelayIndicator)` Returns a Flowable that delays the emissions of the source Publisher via another Publisher on a per-item basis.
`Flowable<T>`	`delay(long delay, TimeUnit unit)` Returns a Flowable that emits the items emitted by the source Publisher shifted forward in time by a specified delay.
`Flowable<T>`	`delay(long delay, TimeUnit unit, boolean delayError)` Returns a Flowable that emits the items emitted by the source Publisher shifted forward in time by a specified delay.
`Flowable<T>`	`delay(long delay, TimeUnit unit, Scheduler scheduler)` Returns a Flowable that emits the items emitted by the source Publisher shifted forward in time by a specified delay.
`Flowable<T>`	`delay(long delay, TimeUnit unit, Scheduler scheduler, boolean delayError)` Returns a Flowable that emits the items emitted by the source Publisher shifted forward in time by a specified delay.
`Flowable<T>`	`delay(Publisher subscriptionIndicator, FunctionT,? extends Publisher> itemDelayIndicator)` Returns a Flowable that delays the subscription to and emissions from the source Publisher via another Publisher on a per-item basis.
`Flowable<T>`	`delaySubscription(long delay, TimeUnit unit)` Returns a Flowable that delays the subscription to the source Publisher by a given amount of time.
`Flowable<T>`	`delaySubscription(long delay, TimeUnit unit, Scheduler scheduler)` Returns a Flowable that delays the subscription to the source Publisher by a given amount of time, both waiting and subscribing on a given Scheduler.
`Flowable<T>`	`delaySubscription(Publisher subscriptionIndicator)` Returns a Flowable that delays the subscription to this Publisher until the other Publisher emits an element or completes normally.
`Flowable`	`dematerialize()` Deprecated. in 2.2.4; inherently type-unsafe as it overrides the output generic type. Use `dematerialize(Function)` instead.
`Flowable`	`dematerialize(FunctionT,Notification> selector)` Returns a Flowable that reverses the effect of `materialize` by transforming the `Notification` objects extracted from the source items via a selector function into their respective `Subscriber` signal types.
`Flowable<T>`	`distinct()` Returns a Flowable that emits all items emitted by the source Publisher that are distinct based on `Object.equals(Object)` comparison.
`Flowable<T>`	`distinct(FunctionT,K> keySelector)` Returns a Flowable that emits all items emitted by the source Publisher 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.
`Flowable<T>`	`distinct(FunctionT,K> keySelector, CallableCollection> collectionSupplier)` Returns a Flowable that emits all items emitted by the source Publisher 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.
`Flowable<T>`	`distinctUntilChanged()` Returns a Flowable that emits all items emitted by the source Publisher that are distinct from their immediate predecessors based on `Object.equals(Object)` comparison.
`Flowable<T>`	`distinctUntilChanged(BiPredicateT,? super T> comparer)` Returns a Flowable that emits all items emitted by the source Publisher that are distinct from their immediate predecessors when compared with each other via the provided comparator function.
`Flowable<T>`	`distinctUntilChanged(FunctionT,K> keySelector)` Returns a Flowable that emits all items emitted by the source Publisher 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.
`Flowable<T>`	`doAfterNext(ConsumerT> onAfterNext)` Calls the specified consumer with the current item after this item has been emitted to the downstream.
`Flowable<T>`	`doAfterTerminate(Action onAfterTerminate)` Registers an `Action` to be called when this Publisher invokes either `onComplete` or `onError`.
`Flowable<T>`	`doFinally(Action onFinally)` Calls the specified action after this Flowable signals onError or onCompleted or gets canceled by the downstream.
`Flowable<T>`	`doOnCancel(Action onCancel)` Calls the cancel `Action` if the downstream cancels the sequence.
`Flowable<T>`	`doOnComplete(Action onComplete)` Modifies the source Publisher so that it invokes an action when it calls `onComplete`.
`Flowable<T>`	`doOnEach(ConsumerNotification<T>> onNotification)` Modifies the source Publisher so that it invokes an action for each item it emits.
`Flowable<T>`	`doOnEach(SubscriberT> subscriber)` Modifies the source Publisher so that it notifies a Subscriber for each item and terminal event it emits.
`Flowable<T>`	`doOnError(ConsumerThrowable> onError)` Modifies the source Publisher so that it invokes an action if it calls `onError`.
`Flowable<T>`	`doOnLifecycle(ConsumerSubscription> onSubscribe, LongConsumer onRequest, Action onCancel)` Calls the appropriate onXXX method (shared between all Subscribers) for the lifecycle events of the sequence (subscription, cancellation, requesting).
`Flowable<T>`	`doOnNext(ConsumerT> onNext)` Modifies the source Publisher so that it invokes an action when it calls `onNext`.
`Flowable<T>`	`doOnRequest(LongConsumer onRequest)` Modifies the source `Publisher` so that it invokes the given action when it receives a request for more items.
`Flowable<T>`	`doOnSubscribe(ConsumerSubscription> onSubscribe)` Modifies the source `Publisher` so that it invokes the given action when it is subscribed from its subscribers.
`Flowable<T>`	`doOnTerminate(Action onTerminate)` Modifies the source Publisher so that it invokes an action when it calls `onComplete` or `onError`.
`Maybe<T>`	`elementAt(long index)` Returns a Maybe that emits the single item at a specified index in a sequence of emissions from this Flowable or completes if this Flowable sequence has fewer elements than index.
`Single<T>`	`elementAt(long index, T defaultItem)` Returns a Single that emits the item found at a specified index in a sequence of emissions from this Flowable, or a default item if that index is out of range.
`Single<T>`	`elementAtOrError(long index)` Returns a Single that emits the item found at a specified index in a sequence of emissions from this Flowable or signals a `NoSuchElementException` if this Flowable has fewer elements than index.
`static Flowable`	`empty()` Returns a Flowable that emits no items to the `Subscriber` and immediately invokes its `onComplete` method.
`static Flowable`	`error(CallableThrowable> supplier)` Returns a Flowable that invokes a `Subscriber`'s `onError` method when the Subscriber subscribes to it.
`static Flowable`	`error(Throwable throwable)` Returns a Flowable that invokes a `Subscriber`'s `onError` method when the Subscriber subscribes to it.
`Flowable<T>`	`filter(PredicateT> predicate)` Filters items emitted by a Publisher by only emitting those that satisfy a specified predicate.
`Single<T>`	`first(T defaultItem)` Returns a Single that emits only the very first item emitted by this Flowable, or a default item if this Flowable completes without emitting anything.
`Maybe<T>`	`firstElement()` Returns a Maybe that emits only the very first item emitted by this Flowable or completes if this Flowable is empty.
`Single<T>`	`firstOrError()` Returns a Single that emits only the very first item emitted by this Flowable or signals a `NoSuchElementException` if this Flowable is empty.
`Flowable`	`flatMap(FunctionT,? extends Publisher> mapper)` Returns a Flowable that emits items based on applying a function that you supply to each item emitted by the source Publisher, where that function returns a Publisher, and then merging those resulting Publishers and emitting the results of this merger.
`Flowable`	`flatMap(FunctionT,? extends Publisher> mapper, boolean delayErrors)` Returns a Flowable that emits items based on applying a function that you supply to each item emitted by the source Publisher, where that function returns a Publisher, and then merging those resulting Publishers and emitting the results of this merger.
`Flowable`	`flatMap(FunctionT,? extends Publisher> mapper, boolean delayErrors, int maxConcurrency)` Returns a Flowable that emits items based on applying a function that you supply to each item emitted by the source Publisher, where that function returns a Publisher, and then merging those resulting Publishers and emitting the results of this merger, while limiting the maximum number of concurrent subscriptions to these Publishers.
`Flowable`	`flatMap(FunctionT,? extends Publisher> mapper, boolean delayErrors, int maxConcurrency, int bufferSize)` Returns a Flowable that emits items based on applying a function that you supply to each item emitted by the source Publisher, where that function returns a Publisher, and then merging those resulting Publishers and emitting the results of this merger, while limiting the maximum number of concurrent subscriptions to these Publishers.
`Flowable`	`flatMap(FunctionT,? extends Publisher> onNextMapper, FunctionThrowable,? extends Publisher> onErrorMapper, CallablePublisher> onCompleteSupplier)` Returns a Flowable that applies a function to each item emitted or notification raised by the source Publisher and then flattens the Publishers returned from these functions and emits the resulting items.
`Flowable`	`flatMap(FunctionT,? extends Publisher> onNextMapper, Function<Throwable,? extends Publisher> onErrorMapper, CallablePublisher> onCompleteSupplier, int maxConcurrency)` Returns a Flowable that applies a function to each item emitted or notification raised by the source Publisher and then flattens the Publishers returned from these functions and emits the resulting items, while limiting the maximum number of concurrent subscriptions to these Publishers.
`Flowable`	`flatMap(FunctionT,? extends Publisher> mapper, int maxConcurrency)` Returns a Flowable that emits items based on applying a function that you supply to each item emitted by the source Publisher, where that function returns a Publisher, and then merging those resulting Publishers and emitting the results of this merger, while limiting the maximum number of concurrent subscriptions to these Publishers.
`Flowable`	`flatMap(FunctionT,? extends Publisher> mapper, BiFunctionT,? super U,? extends R> combiner)` Returns a Flowable that emits the results of a specified function to the pair of values emitted by the source Publisher and a specified collection Publisher.
`Flowable`	`flatMap(FunctionT,? extends Publisher> mapper, BiFunctionT,? super U,? extends R> combiner, boolean delayErrors)` Returns a Flowable that emits the results of a specified function to the pair of values emitted by the source Publisher and a specified collection Publisher.
`Flowable`	`flatMap(FunctionT,? extends Publisher> mapper, BiFunctionT,? super U,? extends R> combiner, boolean delayErrors, int maxConcurrency)` Returns a Flowable that emits the results of a specified function to the pair of values emitted by the source Publisher and a specified collection Publisher, while limiting the maximum number of concurrent subscriptions to these Publishers.
`Flowable`	`flatMap(FunctionT,? extends Publisher> mapper, BiFunctionT,? super U,? extends R> combiner, boolean delayErrors, int maxConcurrency, int bufferSize)` Returns a Flowable that emits the results of a specified function to the pair of values emitted by the source Publisher and a specified collection Publisher, while limiting the maximum number of concurrent subscriptions to these Publishers.
`Flowable`	`flatMap(FunctionT,? extends Publisher> mapper, BiFunctionT,? super U,? extends R> combiner, int maxConcurrency)` Returns a Flowable that emits the results of a specified function to the pair of values emitted by the source Publisher and a specified collection Publisher, while limiting the maximum number of concurrent subscriptions to these Publishers.
`Completable`	`flatMapCompletable(FunctionT,? extends CompletableSource> mapper)` Maps each element of the upstream Flowable into CompletableSources, subscribes to them and waits until the upstream and all CompletableSources complete.
`Completable`	`flatMapCompletable(FunctionT,? extends CompletableSource> mapper, boolean delayErrors, int maxConcurrency)` Maps each element of the upstream Flowable into CompletableSources, subscribes to them and waits until the upstream and all CompletableSources complete, optionally delaying all errors.
`Flowable`	`flatMapIterable(FunctionT,? extends Iterable> mapper)` Returns a Flowable that merges each item emitted by the source Publisher with the values in an Iterable corresponding to that item that is generated by a selector.
`Flowable`	`flatMapIterable(FunctionT,? extends Iterable> mapper, BiFunctionT,? super U,? extends V> resultSelector)` Returns a Flowable that emits the results of applying a function to the pair of values from the source Publisher and an Iterable corresponding to that item that is generated by a selector.
`Flowable`	`flatMapIterable(FunctionT,? extends Iterable> mapper, BiFunctionT,? super U,? extends V> resultSelector, int prefetch)` Returns a Flowable that merges each item emitted by the source Publisher with the values in an Iterable corresponding to that item that is generated by a selector, while limiting the number of concurrent subscriptions to these Publishers.
`Flowable`	`flatMapIterable(FunctionT,? extends Iterable> mapper, int bufferSize)` Returns a Flowable that merges each item emitted by the source Publisher with the values in an Iterable corresponding to that item that is generated by a selector.
`Flowable`	`flatMapMaybe(FunctionT,? extends MaybeSource> mapper)` Maps each element of the upstream Flowable into MaybeSources, subscribes to all of them and merges their onSuccess values, in no particular order, into a single Flowable sequence.
`Flowable`	`flatMapMaybe(FunctionT,? extends MaybeSource> mapper, boolean delayErrors, int maxConcurrency)` Maps each element of the upstream Flowable into MaybeSources, subscribes to at most `maxConcurrency` MaybeSources at a time and merges their onSuccess values, in no particular order, into a single Flowable sequence, optionally delaying all errors.
`Flowable`	`flatMapSingle(FunctionT,? extends SingleSource> mapper)` Maps each element of the upstream Flowable into SingleSources, subscribes to all of them and merges their onSuccess values, in no particular order, into a single Flowable sequence.
`Flowable`	`flatMapSingle(FunctionT,? extends SingleSource> mapper, boolean delayErrors, int maxConcurrency)` Maps each element of the upstream Flowable into SingleSources, subscribes to at most `maxConcurrency` SingleSources at a time and merges their onSuccess values, in no particular order, into a single Flowable sequence, optionally delaying all errors.
`Disposable`	`forEach(ConsumerT> onNext)` Subscribes to the `Publisher` and receives notifications for each element.
`Disposable`	`forEachWhile(PredicateT> onNext)` Subscribes to the `Publisher` and receives notifications for each element until the onNext Predicate returns false.
`Disposable`	`forEachWhile(PredicateT> onNext, ConsumerThrowable> onError)` Subscribes to the `Publisher` and receives notifications for each element and error events until the onNext Predicate returns false.
`Disposable`	`forEachWhile(PredicateT> onNext, ConsumerThrowable> onError, Action onComplete)` Subscribes to the `Publisher` and receives notifications for each element and the terminal events until the onNext Predicate returns false.
`static Flowable`	`fromArray(T... items)` Converts an Array into a Publisher that emits the items in the Array.
`static Flowable`	`fromCallable(Callable supplier)` Returns a Flowable that, when a Subscriber subscribes to it, invokes a function you specify and then emits the value returned from that function.
`static Flowable`	`fromFuture(Future future)` Converts a `Future` into a Publisher.
`static Flowable`	`fromFuture(Future future, long timeout, TimeUnit unit)` Converts a `Future` into a Publisher, with a timeout on the Future.
`static Flowable`	`fromFuture(Future future, long timeout, TimeUnit unit, Scheduler scheduler)` Converts a `Future` into a Publisher, with a timeout on the Future.
`static Flowable`	`fromFuture(Future future, Scheduler scheduler)` Converts a `Future`, operating on a specified `Scheduler`, into a Publisher.
`static Flowable`	`fromIterable(Iterable source)` Converts an `Iterable` sequence into a Publisher that emits the items in the sequence.
`static Flowable`	`fromPublisher(Publisher source)` Converts an arbitrary Reactive Streams Publisher into a Flowable if not already a Flowable.
`static Flowable`	`generate(Callable initialState, BiConsumerEmitter> generator)` ~~Returns a cold, synchronous, stateful and backpressure-aware generator of values.~~
`static Flowable`	`generate(Callable initialState, BiConsumerEmitter> generator, Consumer disposeState)` ~~Returns a cold, synchronous, stateful and backpressure-aware generator of values.~~
`static Flowable`	`generate(Callable initialState, BiFunctionEmitter,S> generator)` ~~Returns a cold, synchronous, stateful and backpressure-aware generator of values.~~
`static Flowable`	`generate(Callable initialState, BiFunctionEmitter,S> generator, Consumer disposeState)` ~~Returns a cold, synchronous, stateful and backpressure-aware generator of values.~~
`static Flowable`	`generate(Consumer<Emitter> generator)` Returns a cold, synchronous, stateless and backpressure-aware generator of values.
`Flowable<GroupedFlowableT>>`	`groupBy(FunctionT,? extends K> keySelector)` Groups the items emitted by a `Publisher` according to a specified criterion, and emits these grouped items as `GroupedFlowable`s.
`Flowable<GroupedFlowableT>>`	`groupBy(FunctionT,? extends K> keySelector, boolean delayError)` Groups the items emitted by a `Publisher` according to a specified criterion, and emits these grouped items as `GroupedFlowable`s.
`Flowable<GroupedFlowable>`	`groupBy(FunctionT,? extends K> keySelector, FunctionT,? extends V> valueSelector)` Groups the items emitted by a `Publisher` according to a specified criterion, and emits these grouped items as `GroupedFlowable`s.
`Flowable<GroupedFlowable>`	`groupBy(FunctionT,? extends K> keySelector, FunctionT,? extends V> valueSelector, boolean delayError)` Groups the items emitted by a `Publisher` according to a specified criterion, and emits these grouped items as `GroupedFlowable`s.
`Flowable<GroupedFlowable>`	`groupBy(FunctionT,? extends K> keySelector, FunctionT,? extends V> valueSelector, boolean delayError, int bufferSize)` Groups the items emitted by a `Publisher` according to a specified criterion, and emits these grouped items as `GroupedFlowable`s.
`Flowable<GroupedFlowable>`	`groupBy(FunctionT,? extends K> keySelector, FunctionT,? extends V> valueSelector, boolean delayError, int bufferSize, FunctionConsumer<Object>,? extends MapObject>> evictingMapFactory)` Groups the items emitted by a `Publisher` according to a specified criterion, and emits these grouped items as `GroupedFlowable`s.
`Flowable`	`groupJoin(Publisher other, FunctionT,? extends Publisher> leftEnd, FunctionPublisher> rightEnd, BiFunctionT,? super Flowable,? extends R> resultSelector)` Returns a Flowable that correlates two Publishers when they overlap in time and groups the results.
`Flowable<T>`	`hide()` Hides the identity of this Flowable and its Subscription.
`Completable`	`ignoreElements()` Ignores all items emitted by the source Publisher and only calls `onComplete` or `onError`.
`static Flowable<Long>`	`interval(long initialDelay, long period, TimeUnit unit)` Returns a Flowable that emits a `0L` after the `initialDelay` and ever-increasing numbers after each `period` of time thereafter.
`static Flowable<Long>`	`interval(long initialDelay, long period, TimeUnit unit, Scheduler scheduler)` Returns a Flowable that emits a `0L` after the `initialDelay` and ever-increasing numbers after each `period` of time thereafter, on a specified `Scheduler`.
`static Flowable<Long>`	`interval(long period, TimeUnit unit)` Returns a Flowable that emits a sequential number every specified interval of time.
`static Flowable<Long>`	`interval(long period, TimeUnit unit, Scheduler scheduler)` Returns a Flowable that emits a sequential number every specified interval of time, on a specified Scheduler.
`static Flowable<Long>`	`intervalRange(long start, long count, long initialDelay, long period, TimeUnit unit)` Signals a range of long values, the first after some initial delay and the rest periodically after.
`static Flowable<Long>`	`intervalRange(long start, long count, long initialDelay, long period, TimeUnit unit, Scheduler scheduler)` Signals a range of long values, the first after some initial delay and the rest periodically after.
`Single<Boolean>`	`isEmpty()` Returns a Single that emits `true` if the source Publisher is empty, otherwise `false`.
`Flowable`	`join(Publisher other, FunctionT,? extends Publisher> leftEnd, FunctionPublisher> rightEnd, BiFunctionT,? super TRight,? extends R> resultSelector)` Correlates the items emitted by two Publishers based on overlapping durations.
`static Flowable`	`just(T item)` Returns a Flowable that signals the given (constant reference) item and then completes.
`static Flowable`	`just(T item1, T item2)` Converts two items into a Publisher that emits those items.
`static Flowable`	`just(T item1, T item2, T item3)` Converts three items into a Publisher that emits those items.
`static Flowable`	`just(T item1, T item2, T item3, T item4)` Converts four items into a Publisher that emits those items.
`static Flowable`	`just(T item1, T item2, T item3, T item4, T item5)` Converts five items into a Publisher that emits those items.
`static Flowable`	`just(T item1, T item2, T item3, T item4, T item5, T item6)` Converts six items into a Publisher that emits those items.
`static Flowable`	`just(T item1, T item2, T item3, T item4, T item5, T item6, T item7)` Converts seven items into a Publisher that emits those items.
`static Flowable`	`just(T item1, T item2, T item3, T item4, T item5, T item6, T item7, T item8)` Converts eight items into a Publisher that emits those items.
`static Flowable`	`just(T item1, T item2, T item3, T item4, T item5, T item6, T item7, T item8, T item9)` Converts nine items into a Publisher that emits those items.
`static Flowable`	`just(T item1, T item2, T item3, T item4, T item5, T item6, T item7, T item8, T item9, T item10)` Converts ten items into a Publisher that emits those items.
`Single<T>`	`last(T defaultItem)` Returns a Single that emits only the last item emitted by this Flowable, or a default item if this Flowable completes without emitting any items.
`Maybe<T>`	`lastElement()` Returns a Maybe that emits the last item emitted by this Flowable or completes if this Flowable is empty.
`Single<T>`	`lastOrError()` Returns a Single that emits only the last item emitted by this Flowable or signals a `NoSuchElementException` if this Flowable is empty.
`Flowable`	`lift(FlowableOperatorT> lifter)` This method requires advanced knowledge about building operators, please consider other standard composition methods first; Returns a `Flowable` which, when subscribed to, invokes the `apply(Subscriber)` method of the provided `FlowableOperator` for each individual downstream `Subscriber` and allows the insertion of a custom operator by accessing the downstream's `Subscriber` during this subscription phase and providing a new `Subscriber`, containing the custom operator's intended business logic, that will be used in the subscription process going further upstream.
`Flowable<T>`	`limit(long count)` Limits both the number of upstream items (after which the sequence completes) and the total downstream request amount requested from the upstream to possibly prevent the creation of excess items by the upstream.
`Flowable`	`map(FunctionT,? extends R> mapper)` Returns a Flowable that applies a specified function to each item emitted by the source Publisher and emits the results of these function applications.
`Flowable<Notification<T>>`	`materialize()` Returns a Flowable that represents all of the emissions and notifications from the source Publisher into emissions marked with their original types within `Notification` objects.
`static Flowable`	`merge(IterablePublisher> sources)` Flattens an Iterable of Publishers into one Publisher, without any transformation.
`static Flowable`	`merge(IterablePublisher> sources, int maxConcurrency)` Flattens an Iterable of Publishers into one Publisher, without any transformation, while limiting the number of concurrent subscriptions to these Publishers.
`static Flowable`	`merge(IterablePublisher> sources, int maxConcurrency, int bufferSize)` Flattens an Iterable of Publishers into one Publisher, without any transformation, while limiting the number of concurrent subscriptions to these Publishers.
`static Flowable`	`merge(PublisherPublisher> sources)` Flattens a Publisher that emits Publishers into a single Publisher that emits the items emitted by those Publishers, without any transformation.
`static Flowable`	`merge(PublisherPublisher> sources, int maxConcurrency)` Flattens a Publisher that emits Publishers into a single Publisher that emits the items emitted by those Publishers, without any transformation, while limiting the maximum number of concurrent subscriptions to these Publishers.
`static Flowable`	`merge(Publisher source1, Publisher source2)` Flattens two Publishers into a single Publisher, without any transformation.
`static Flowable`	`merge(Publisher source1, Publisher source2, Publisher source3)` Flattens three Publishers into a single Publisher, without any transformation.
`static Flowable`	`merge(Publisher source1, Publisher source2, Publisher source3, Publisher source4)` Flattens four Publishers into a single Publisher, without any transformation.
`static Flowable`	`mergeArray(int maxConcurrency, int bufferSize, Publisher... sources)` Flattens an Iterable of Publishers into one Publisher, without any transformation, while limiting the number of concurrent subscriptions to these Publishers.
`static Flowable`	`mergeArray(Publisher... sources)` Flattens an Array of Publishers into one Publisher, without any transformation.
`static Flowable`	`mergeArrayDelayError(int maxConcurrency, int bufferSize, Publisher... sources)` Flattens an array of Publishers into one Publisher, in a way that allows a Subscriber to receive all successfully emitted items from each of the source Publishers without being interrupted by an error notification from one of them, while limiting the number of concurrent subscriptions to these Publishers.
`static Flowable`	`mergeArrayDelayError(Publisher... sources)` Flattens an array of Publishers into one Flowable, in a way that allows a Subscriber to receive all successfully emitted items from each of the source Publishers without being interrupted by an error notification from one of them.
`static Flowable`	`mergeDelayError(IterablePublisher> sources)` Flattens an Iterable of Publishers into one Publisher, in a way that allows a Subscriber to receive all successfully emitted items from each of the source Publishers without being interrupted by an error notification from one of them.
`static Flowable`	`mergeDelayError(IterablePublisher> sources, int maxConcurrency)` Flattens an Iterable of Publishers into one Publisher, in a way that allows a Subscriber to receive all successfully emitted items from each of the source Publishers without being interrupted by an error notification from one of them, while limiting the number of concurrent subscriptions to these Publishers.
`static Flowable`	`mergeDelayError(IterablePublisher> sources, int maxConcurrency, int bufferSize)` Flattens an Iterable of Publishers into one Publisher, in a way that allows a Subscriber to receive all successfully emitted items from each of the source Publishers without being interrupted by an error notification from one of them, while limiting the number of concurrent subscriptions to these Publishers.
`static Flowable`	`mergeDelayError(PublisherPublisher> sources)` Flattens a Publisher that emits Publishers into one Publisher, in a way that allows a Subscriber to receive all successfully emitted items from all of the source Publishers without being interrupted by an error notification from one of them.
`static Flowable`	`mergeDelayError(PublisherPublisher> sources, int maxConcurrency)` Flattens a Publisher that emits Publishers into one Publisher, in a way that allows a Subscriber to receive all successfully emitted items from all of the source Publishers without being interrupted by an error notification from one of them, while limiting the number of concurrent subscriptions to these Publishers.
`static Flowable`	`mergeDelayError(Publisher source1, Publisher source2)` Flattens two Publishers into one Publisher, in a way that allows a Subscriber to receive all successfully emitted items from each of the source Publishers without being interrupted by an error notification from one of them.
`static Flowable`	`mergeDelayError(Publisher source1, Publisher source2, Publisher source3)` Flattens three Publishers into one Publisher, in a way that allows a Subscriber to receive all successfully emitted items from all of the source Publishers without being interrupted by an error notification from one of them.
`static Flowable`	`mergeDelayError(Publisher source1, Publisher source2, Publisher source3, Publisher source4)` Flattens four Publishers into one Publisher, in a way that allows a Subscriber to receive all successfully emitted items from all of the source Publishers without being interrupted by an error notification from one of them.
`Flowable<T>`	`mergeWith(CompletableSource other)` Relays the items of this Flowable and completes only when the other CompletableSource completes as well.
`Flowable<T>`	`mergeWith(MaybeSourceT> other)` Merges the sequence of items of this Flowable with the success value of the other MaybeSource or waits for both to complete normally if the MaybeSource is empty.
`Flowable<T>`	`mergeWith(PublisherT> other)` Flattens this and another Publisher into a single Publisher, without any transformation.
`Flowable<T>`	`mergeWith(SingleSourceT> other)` Merges the sequence of items of this Flowable with the success value of the other SingleSource.
`static Flowable`	`never()` Returns a Flowable that never sends any items or notifications to a `Subscriber`.
`Flowable<T>`	`observeOn(Scheduler scheduler)` Modifies a Publisher to perform its emissions and notifications on a specified `Scheduler`, asynchronously with a bounded buffer of `bufferSize()` slots.
`Flowable<T>`	`observeOn(Scheduler scheduler, boolean delayError)` Modifies a Publisher to perform its emissions and notifications on a specified `Scheduler`, asynchronously with a bounded buffer and optionally delays onError notifications.
`Flowable<T>`	`observeOn(Scheduler scheduler, boolean delayError, int bufferSize)` Modifies a Publisher to perform its emissions and notifications on a specified `Scheduler`, asynchronously with a bounded buffer of configurable size and optionally delays onError notifications.
`Flowable`	`ofType(Class clazz)` Filters the items emitted by a Publisher, only emitting those of the specified type.
`Flowable<T>`	`onBackpressureBuffer()` Instructs a Publisher that is emitting items faster than its Subscriber can consume them to buffer these items indefinitely until they can be emitted.
`Flowable<T>`	`onBackpressureBuffer(boolean delayError)` Instructs a Publisher that is emitting items faster than its Subscriber can consume them to buffer these items indefinitely until they can be emitted.
`Flowable<T>`	`onBackpressureBuffer(int capacity)` Instructs a Publisher that is emitting items faster than its Subscriber can consume them to buffer up to a given amount of items until they can be emitted.
`Flowable<T>`	`onBackpressureBuffer(int capacity, Action onOverflow)` Instructs a Publisher that is emitting items faster than its Subscriber can consume them to buffer up to a given amount of items until they can be emitted.
`Flowable<T>`	`onBackpressureBuffer(int capacity, boolean delayError)` Instructs a Publisher that is emitting items faster than its Subscriber can consume them to buffer up to a given amount of items until they can be emitted.
`Flowable<T>`	`onBackpressureBuffer(int capacity, boolean delayError, boolean unbounded)` Instructs a Publisher that is emitting items faster than its Subscriber can consume them to buffer up to a given amount of items until they can be emitted.
`Flowable<T>`	`onBackpressureBuffer(int capacity, boolean delayError, boolean unbounded, Action onOverflow)` Instructs a Publisher that is emitting items faster than its Subscriber can consume them to buffer up to a given amount of items until they can be emitted.
`Flowable<T>`	`onBackpressureBuffer(long capacity, Action onOverflow, BackpressureOverflowStrategy overflowStrategy)` Instructs a Publisher that is emitting items faster than its Subscriber can consume them to buffer up to a given amount of items until they can be emitted.
`Flowable<T>`	`onBackpressureDrop()` Instructs a Publisher that is emitting items faster than its Subscriber can consume them to discard, rather than emit, those items that its Subscriber is not prepared to observe.
`Flowable<T>`	`onBackpressureDrop(ConsumerT> onDrop)` Instructs a Publisher that is emitting items faster than its Subscriber can consume them to discard, rather than emit, those items that its Subscriber is not prepared to observe.
`Flowable<T>`	`onBackpressureLatest()` Instructs a Publisher that is emitting items faster than its Subscriber can consume them to hold onto the latest value and emit that on request.
`Flowable<T>`	`onErrorResumeNext(FunctionThrowable,? extends PublisherT>> resumeFunction)` Instructs a Publisher to pass control to another Publisher rather than invoking `onError` if it encounters an error.
`Flowable<T>`	`onErrorResumeNext(PublisherT> next)` Instructs a Publisher to pass control to another Publisher rather than invoking `onError` if it encounters an error.
`Flowable<T>`	`onErrorReturn(FunctionThrowable,? extends T> valueSupplier)` Instructs a Publisher to emit an item (returned by a specified function) rather than invoking `onError` if it encounters an error.
`Flowable<T>`	`onErrorReturnItem(T item)` Instructs a Publisher to emit an item (returned by a specified function) rather than invoking `onError` if it encounters an error.
`Flowable<T>`	`onExceptionResumeNext(PublisherT> next)` Instructs a Publisher to pass control to another Publisher rather than invoking `onError` if it encounters an `Exception`.
`Flowable<T>`	`onTerminateDetach()` Nulls out references to the upstream producer and downstream Subscriber if the sequence is terminated or downstream cancels.
`ParallelFlowable<T>`	`parallel()` Parallelizes the flow by creating multiple 'rails' (equal to the number of CPUs) and dispatches the upstream items to them in a round-robin fashion.
`ParallelFlowable<T>`	`parallel(int parallelism)` Parallelizes the flow by creating the specified number of 'rails' and dispatches the upstream items to them in a round-robin fashion.
`ParallelFlowable<T>`	`parallel(int parallelism, int prefetch)` Parallelizes the flow by creating the specified number of 'rails' and dispatches the upstream items to them in a round-robin fashion and uses the defined per-'rail' prefetch amount.
`ConnectableFlowable<T>`	`publish()` Returns a `ConnectableFlowable`, which is a variety of Publisher that waits until its `connect` method is called before it begins emitting items to those `Subscriber`s that have subscribed to it.
`Flowable`	`publish(FunctionFlowable<T>,? extends Publisher> selector, int prefetch)` Returns a Flowable that emits the results of invoking a specified selector on items emitted by a `ConnectableFlowable` that shares a single subscription to the underlying sequence.
`Flowable`	`publish(FunctionFlowable<T>,? extends Publisher> selector)` Returns a Flowable that emits the results of invoking a specified selector on items emitted by a `ConnectableFlowable` that shares a single subscription to the underlying sequence.
`ConnectableFlowable<T>`	`publish(int bufferSize)` Returns a `ConnectableFlowable`, which is a variety of Publisher that waits until its `connect` method is called before it begins emitting items to those `Subscriber`s that have subscribed to it.
`static Flowable<Integer>`	`range(int start, int count)` Returns a Flowable that emits a sequence of Integers within a specified range.
`static Flowable<Long>`	`rangeLong(long start, long count)` Returns a Flowable that emits a sequence of Longs within a specified range.
`Flowable<T>`	`rebatchRequests(int n)` Requests `n` initially from the upstream and then 75% of `n` subsequently after 75% of `n` values have been emitted to the downstream.
`Maybe<T>`	`reduce(BiFunction<T,T,T> reducer)` Returns a Maybe that applies a specified accumulator function to the first item emitted by a source Publisher, then feeds the result of that function along with the second item emitted by the source Publisher into the same function, and so on until all items have been emitted by the finite source Publisher, and emits the final result from the final call to your function as its sole item.
`Single`	`reduce(R seed, BiFunctionT,R> reducer)` Returns a Single that applies a specified accumulator function to the first item emitted by a source Publisher and a specified seed value, then feeds the result of that function along with the second item emitted by a Publisher into the same function, and so on until all items have been emitted by the finite source Publisher, emitting the final result from the final call to your function as its sole item.
`Single`	`reduceWith(Callable seedSupplier, BiFunctionT,R> reducer)` Returns a Single that applies a specified accumulator function to the first item emitted by a source Publisher and a seed value derived from calling a specified seedSupplier, then feeds the result of that function along with the second item emitted by a Publisher into the same function, and so on until all items have been emitted by the finite source Publisher, emitting the final result from the final call to your function as its sole item.
`Flowable<T>`	`repeat()` Returns a Flowable that repeats the sequence of items emitted by the source Publisher indefinitely.
`Flowable<T>`	`repeat(long times)` Returns a Flowable that repeats the sequence of items emitted by the source Publisher at most `count` times.
`Flowable<T>`	`repeatUntil(BooleanSupplier stop)` Returns a Flowable that repeats the sequence of items emitted by the source Publisher until the provided stop function returns true.
`Flowable<T>`	`repeatWhen(FunctionFlowable<Object>,? extends Publisher> handler)` Returns a Flowable that emits the same values as the source Publisher with the exception of an `onComplete`.
`ConnectableFlowable<T>`	`replay()` Returns a `ConnectableFlowable` that shares a single subscription to the underlying Publisher that will replay all of its items and notifications to any future `Subscriber`.
`Flowable`	`replay(FunctionFlowable<T>,? extends Publisher> selector)` Returns a Flowable that emits items that are the results of invoking a specified selector on the items emitted by a `ConnectableFlowable` that shares a single subscription to the source Publisher.
`Flowable`	`replay(FunctionFlowable<T>,? extends Publisher> selector, int bufferSize)` Returns a Flowable that emits items that are the results of invoking a specified selector on items emitted by a `ConnectableFlowable` that shares a single subscription to the source Publisher, replaying `bufferSize` notifications.
`Flowable`	`replay(FunctionFlowable<T>,? extends Publisher> selector, int bufferSize, long time, TimeUnit unit)` Returns a Flowable that emits items that are the results of invoking a specified selector on items emitted by a `ConnectableFlowable` that shares a single subscription to the source Publisher, replaying no more than `bufferSize` items that were emitted within a specified time window.
`Flowable`	`replay(FunctionFlowable<T>,? extends Publisher> selector, int bufferSize, long time, TimeUnit unit, Scheduler scheduler)` Returns a Flowable that emits items that are the results of invoking a specified selector on items emitted by a `ConnectableFlowable` that shares a single subscription to the source Publisher, replaying no more than `bufferSize` items that were emitted within a specified time window.
`Flowable`	`replay(FunctionFlowable<T>,? extends Publisher> selector, int bufferSize, Scheduler scheduler)` Returns a Flowable that emits items that are the results of invoking a specified selector on items emitted by a `ConnectableFlowable` that shares a single subscription to the source Publisher, replaying a maximum of `bufferSize` items.
`Flowable`	`replay(FunctionFlowable<T>,? extends Publisher> selector, long time, TimeUnit unit)` Returns a Flowable that emits items that are the results of invoking a specified selector on items emitted by a `ConnectableFlowable` that shares a single subscription to the source Publisher, replaying all items that were emitted within a specified time window.
`Flowable`	`replay(FunctionFlowable<T>,? extends Publisher> selector, long time, TimeUnit unit, Scheduler scheduler)` Returns a Flowable that emits items that are the results of invoking a specified selector on items emitted by a `ConnectableFlowable` that shares a single subscription to the source Publisher, replaying all items that were emitted within a specified time window.
`Flowable`	`replay(FunctionFlowable<T>,? extends Publisher> selector, Scheduler scheduler)` Returns a Flowable that emits items that are the results of invoking a specified selector on items emitted by a `ConnectableFlowable` that shares a single subscription to the source Publisher.
`ConnectableFlowable<T>`	`replay(int bufferSize)` Returns a `ConnectableFlowable` that shares a single subscription to the source Publisher that replays at most `bufferSize` items emitted by that Publisher.
`ConnectableFlowable<T>`	`replay(int bufferSize, long time, TimeUnit unit)` Returns a `ConnectableFlowable` that shares a single subscription to the source Publisher and replays at most `bufferSize` items that were emitted during a specified time window.
`ConnectableFlowable<T>`	`replay(int bufferSize, long time, TimeUnit unit, Scheduler scheduler)` Returns a `ConnectableFlowable` that shares a single subscription to the source Publisher and that replays a maximum of `bufferSize` items that are emitted within a specified time window.
`ConnectableFlowable<T>`	`replay(int bufferSize, Scheduler scheduler)` Returns a `ConnectableFlowable` that shares a single subscription to the source Publisher and replays at most `bufferSize` items emitted by that Publisher.
`ConnectableFlowable<T>`	`replay(long time, TimeUnit unit)` Returns a `ConnectableFlowable` that shares a single subscription to the source Publisher and replays all items emitted by that Publisher within a specified time window.
`ConnectableFlowable<T>`	`replay(long time, TimeUnit unit, Scheduler scheduler)` Returns a `ConnectableFlowable` that shares a single subscription to the source Publisher and replays all items emitted by that Publisher within a specified time window.
`ConnectableFlowable<T>`	`replay(Scheduler scheduler)` Returns a `ConnectableFlowable` that shares a single subscription to the source Publisher that will replay all of its items and notifications to any future `Subscriber` on the given `Scheduler`.
`Flowable<T>`	`retry()` Returns a Flowable that mirrors the source Publisher, resubscribing to it if it calls `onError` (infinite retry count).
`Flowable<T>`	`retry(BiPredicateInteger,? super Throwable> predicate)` Returns a Flowable that mirrors the source Publisher, resubscribing to it if it calls `onError` and the predicate returns true for that specific exception and retry count.
`Flowable<T>`	`retry(long count)` Returns a Flowable that mirrors the source Publisher, resubscribing to it if it calls `onError` up to a specified number of retries.
`Flowable<T>`	`retry(long times, PredicateThrowable> predicate)` Retries at most times or until the predicate returns false, whichever happens first.
`Flowable<T>`	`retry(PredicateThrowable> predicate)` Retries the current Flowable if the predicate returns true.
`Flowable<T>`	`retryUntil(BooleanSupplier stop)` Retries until the given stop function returns true.
`Flowable<T>`	`retryWhen(FunctionFlowable<Throwable>,? extends Publisher> handler)` Returns a Flowable that emits the same values as the source Publisher with the exception of an `onError`.
`void`	`safeSubscribe(SubscriberT> s)` Subscribes to the current Flowable and wraps the given Subscriber into a SafeSubscriber (if not already a SafeSubscriber) that deals with exceptions thrown by a misbehaving Subscriber (that doesn't follow the Reactive Streams specification).
`Flowable<T>`	`sample(long period, TimeUnit unit)` Returns a Flowable that emits the most recently emitted item (if any) emitted by the source Publisher within periodic time intervals.
`Flowable<T>`	`sample(long period, TimeUnit unit, boolean emitLast)` Returns a Flowable that emits the most recently emitted item (if any) emitted by the source Publisher within periodic time intervals and optionally emit the very last upstream item when the upstream completes.
`Flowable<T>`	`sample(long period, TimeUnit unit, Scheduler scheduler)` Returns a Flowable that emits the most recently emitted item (if any) emitted by the source Publisher within periodic time intervals, where the intervals are defined on a particular Scheduler.
`Flowable<T>`	`sample(long period, TimeUnit unit, Scheduler scheduler, boolean emitLast)` Returns a Flowable that emits the most recently emitted item (if any) emitted by the source Publisher 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.
`Flowable<T>`	`sample(Publisher sampler)` Returns a Flowable that, when the specified `sampler` Publisher emits an item or completes, emits the most recently emitted item (if any) emitted by the source Publisher since the previous emission from the `sampler` Publisher.
`Flowable<T>`	`sample(Publisher sampler, boolean emitLast)` Returns a Flowable that, when the specified `sampler` Publisher emits an item or completes, emits the most recently emitted item (if any) emitted by the source Publisher since the previous emission from the `sampler` Publisher and optionally emit the very last upstream item when the upstream or other Publisher complete.
`Flowable<T>`	`scan(BiFunction<T,T,T> accumulator)` Returns a Flowable that applies a specified accumulator function to the first item emitted by a source Publisher, then feeds the result of that function along with the second item emitted by the source Publisher into the same function, and so on until all items have been emitted by the source Publisher, emitting the result of each of these iterations.
`Flowable`	`scan(R initialValue, BiFunctionT,R> accumulator)` Returns a Flowable that applies a specified accumulator function to the first item emitted by a source Publisher and a seed value, then feeds the result of that function along with the second item emitted by the source Publisher into the same function, and so on until all items have been emitted by the source Publisher, emitting the result of each of these iterations.
`Flowable`	`scanWith(Callable seedSupplier, BiFunctionT,R> accumulator)` Returns a Flowable that applies a specified accumulator function to the first item emitted by a source Publisher and a seed value, then feeds the result of that function along with the second item emitted by the source Publisher into the same function, and so on until all items have been emitted by the source Publisher, emitting the result of each of these iterations.
`static Single<Boolean>`	`sequenceEqual(Publisher source1, Publisher source2)` Returns a Single that emits a Boolean value that indicates whether two Publisher sequences are the same by comparing the items emitted by each Publisher pairwise.
`static Single<Boolean>`	`sequenceEqual(Publisher source1, Publisher source2, BiPredicate isEqual)` Returns a Single that emits a Boolean value that indicates whether two Publisher sequences are the same by comparing the items emitted by each Publisher pairwise based on the results of a specified equality function.
`static Single<Boolean>`	`sequenceEqual(Publisher source1, Publisher source2, BiPredicate isEqual, int bufferSize)` Returns a Single that emits a Boolean value that indicates whether two Publisher sequences are the same by comparing the items emitted by each Publisher pairwise based on the results of a specified equality function.
`static Single<Boolean>`	`sequenceEqual(Publisher source1, Publisher source2, int bufferSize)` Returns a Single that emits a Boolean value that indicates whether two Publisher sequences are the same by comparing the items emitted by each Publisher pairwise.
`Flowable<T>`	`serialize()` Forces a Publisher's emissions and notifications to be serialized and for it to obey the Publisher contract in other ways.
`Flowable<T>`	`share()` Returns a new `Publisher` that multicasts (and shares a single subscription to) the original `Publisher`.
`Single<T>`	`single(T defaultItem)` Returns a Single that emits the single item emitted by the source Publisher, if that Publisher emits only a single item, or a default item if the source Publisher emits no items.
`Maybe<T>`	`singleElement()` Returns a Maybe that completes if this Flowable is empty, signals one item if this Flowable signals exactly one item or signals an `IllegalArgumentException` if this Flowable signals more than one item.
`Single<T>`	`singleOrError()` Returns a Single that emits the single item emitted by this Flowable, if this Flowable emits only a single item, otherwise if this Flowable completes without emitting any items a `NoSuchElementException` will be signaled and if this Flowable emits more than one item, an `IllegalArgumentException` will be signaled.
`Flowable<T>`	`skip(long count)` Returns a Flowable that skips the first `count` items emitted by the source Publisher and emits the remainder.
`Flowable<T>`	`skip(long time, TimeUnit unit)` Returns a Flowable that skips values emitted by the source Publisher before a specified time window elapses.
`Flowable<T>`	`skip(long time, TimeUnit unit, Scheduler scheduler)` Returns a Flowable that skips values emitted by the source Publisher before a specified time window on a specified `Scheduler` elapses.
`Flowable<T>`	`skipLast(int count)` Returns a Flowable that drops a specified number of items from the end of the sequence emitted by the source Publisher.
`Flowable<T>`	`skipLast(long time, TimeUnit unit)` Returns a Flowable that drops items emitted by the source Publisher during a specified time window before the source completes.
`Flowable<T>`	`skipLast(long time, TimeUnit unit, boolean delayError)` Returns a Flowable that drops items emitted by the source Publisher during a specified time window before the source completes.
`Flowable<T>`	`skipLast(long time, TimeUnit unit, Scheduler scheduler)` Returns a Flowable that drops items emitted by the source Publisher during a specified time window (defined on a specified scheduler) before the source completes.
`Flowable<T>`	`skipLast(long time, TimeUnit unit, Scheduler scheduler, boolean delayError)` Returns a Flowable that drops items emitted by the source Publisher during a specified time window (defined on a specified scheduler) before the source completes.
`Flowable<T>`	`skipLast(long time, TimeUnit unit, Scheduler scheduler, boolean delayError, int bufferSize)` Returns a Flowable that drops items emitted by the source Publisher during a specified time window (defined on a specified scheduler) before the source completes.
`Flowable<T>`	`skipUntil(Publisher other)` Returns a Flowable that skips items emitted by the source Publisher until a second Publisher emits an item.
`Flowable<T>`	`skipWhile(PredicateT> predicate)` Returns a Flowable that skips all items emitted by the source Publisher as long as a specified condition holds true, but emits all further source items as soon as the condition becomes false.
`Flowable<T>`	`sorted()` Returns a Flowable that emits the events emitted by source Publisher, in a sorted order.
`Flowable<T>`	`sorted(ComparatorT> sortFunction)` Returns a Flowable that emits the events emitted by source Publisher, in a sorted order based on a specified comparison function.
`Flowable<T>`	`startWith(IterableT> items)` Returns a Flowable that emits the items in a specified `Iterable` before it begins to emit items emitted by the source Publisher.
`Flowable<T>`	`startWith(PublisherT> other)` Returns a Flowable that emits the items in a specified `Publisher` before it begins to emit items emitted by the source Publisher.
`Flowable<T>`	`startWith(T value)` Returns a Flowable that emits a specified item before it begins to emit items emitted by the source Publisher.
`Flowable<T>`	`startWithArray(T... items)` Returns a Flowable that emits the specified items before it begins to emit items emitted by the source Publisher.
`Disposable`	`subscribe()` Subscribes to a Publisher and ignores `onNext` and `onComplete` emissions.
`Disposable`	`subscribe(ConsumerT> onNext)` Subscribes to a Publisher and provides a callback to handle the items it emits.
`Disposable`	`subscribe(ConsumerT> onNext, ConsumerThrowable> onError)` Subscribes to a Publisher and provides callbacks to handle the items it emits and any error notification it issues.
`Disposable`	`subscribe(ConsumerT> onNext, ConsumerThrowable> onError, Action onComplete)` Subscribes to a Publisher and provides callbacks to handle the items it emits and any error or completion notification it issues.
`Disposable`	`subscribe(ConsumerT> onNext, ConsumerThrowable> onError, Action onComplete, ConsumerSubscription> onSubscribe)` Subscribes to a Publisher and provides callbacks to handle the items it emits and any error or completion notification it issues.
`void`	`subscribe(FlowableSubscriberT> s)` Establish a connection between this Flowable and the given FlowableSubscriber and start streaming events based on the demand of the FlowableSubscriber.
`void`	`subscribe(SubscriberT> s)`
`protected abstract void`	`subscribeActual(SubscriberT> s)` Operator implementations (both source and intermediate) should implement this method that performs the necessary business logic and handles the incoming `Subscriber`s.
`Flowable<T>`	`subscribeOn(Scheduler scheduler)` Asynchronously subscribes Subscribers to this Publisher on the specified `Scheduler`.
`Flowable<T>`	`subscribeOn(Scheduler scheduler, boolean requestOn)` Asynchronously subscribes Subscribers to this Publisher on the specified `Scheduler` optionally reroutes requests from other threads to the same `Scheduler` thread.
`SubscriberT>> E`	`subscribeWith(E subscriber)` Subscribes a given Subscriber (subclass) to this Flowable and returns the given Subscriber as is.
`Flowable<T>`	`switchIfEmpty(PublisherT> other)` Returns a Flowable that emits the items emitted by the source Publisher or the items of an alternate Publisher if the source Publisher is empty.
`Flowable`	`switchMap(FunctionT,? extends Publisher> mapper)` Returns a new Publisher by applying a function that you supply to each item emitted by the source Publisher that returns a Publisher, and then emitting the items emitted by the most recently emitted of these Publishers.
`Flowable`	`switchMap(FunctionT,? extends Publisher> mapper, int bufferSize)` Returns a new Publisher by applying a function that you supply to each item emitted by the source Publisher that returns a Publisher, and then emitting the items emitted by the most recently emitted of these Publishers.
`Completable`	`switchMapCompletable(FunctionT,? extends CompletableSource> mapper)` Maps the upstream values into `CompletableSource`s, subscribes to the newer one while disposing the subscription to the previous `CompletableSource`, thus keeping at most one active `CompletableSource` running.
`Completable`	`switchMapCompletableDelayError(FunctionT,? extends CompletableSource> mapper)` Maps the upstream values into `CompletableSource`s, subscribes to the newer one while disposing the subscription to the previous `CompletableSource`, thus keeping at most one active `CompletableSource` running and delaying any main or inner errors until all of them terminate.
`Flowable`	`switchMapDelayError(FunctionT,? extends Publisher> mapper)` Returns a new Publisher by applying a function that you supply to each item emitted by the source Publisher that returns a Publisher, and then emitting the items emitted by the most recently emitted of these Publishers and delays any error until all Publishers terminate.
`Flowable`	`switchMapDelayError(FunctionT,? extends Publisher> mapper, int bufferSize)` Returns a new Publisher by applying a function that you supply to each item emitted by the source Publisher that returns a Publisher, and then emitting the items emitted by the most recently emitted of these Publishers and delays any error until all Publishers terminate.
`Flowable`	`switchMapMaybe(FunctionT,? extends MaybeSource> 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 while failing immediately if this `Flowable` or any of the active inner `MaybeSource`s fail.
`Flowable`	`switchMapMaybeDelayError(FunctionT,? extends MaybeSource> 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 this `Flowable` or the inner `MaybeSource`s until all terminate.
`Flowable`	`switchMapSingle(FunctionT,? extends SingleSource> mapper)` Maps the upstream items into `SingleSource`s and switches (subscribes) to the newer ones while disposing the older ones (and ignoring their signals) and emits the latest success value of the current one while failing immediately if this `Flowable` or any of the active inner `SingleSource`s fail.
`Flowable`	`switchMapSingleDelayError(FunctionT,? extends SingleSource> mapper)` Maps the upstream items into `SingleSource`s and switches (subscribes) to the newer ones while disposing the older ones (and ignoring their signals) and emits the latest success value of the current one, delaying errors from this `Flowable` or the inner `SingleSource`s until all terminate.
`static Flowable`	`switchOnNext(PublisherPublisher> sources)` Converts a Publisher that emits Publishers into a Publisher that emits the items emitted by the most recently emitted of those Publishers.
`static Flowable`	`switchOnNext(PublisherPublisher> sources, int bufferSize)` Converts a Publisher that emits Publishers into a Publisher that emits the items emitted by the most recently emitted of those Publishers.
`static Flowable`	`switchOnNextDelayError(PublisherPublisher> sources)` Converts a Publisher that emits Publishers into a Publisher that emits the items emitted by the most recently emitted of those Publishers and delays any exception until all Publishers terminate.
`static Flowable`	`switchOnNextDelayError(PublisherPublisher> sources, int prefetch)` Converts a Publisher that emits Publishers into a Publisher that emits the items emitted by the most recently emitted of those Publishers and delays any exception until all Publishers terminate.
`Flowable<T>`	`take(long count)` Returns a Flowable that emits only the first `count` items emitted by the source Publisher.
`Flowable<T>`	`take(long time, TimeUnit unit)` Returns a Flowable that emits those items emitted by source Publisher before a specified time runs out.
`Flowable<T>`	`take(long time, TimeUnit unit, Scheduler scheduler)` Returns a Flowable that emits those items emitted by source Publisher before a specified time (on a specified Scheduler) runs out.
`Flowable<T>`	`takeLast(int count)` Returns a Flowable that emits at most the last `count` items emitted by the source Publisher.
`Flowable<T>`	`takeLast(long count, long time, TimeUnit unit)` Returns a Flowable that emits at most a specified number of items from the source Publisher that were emitted in a specified window of time before the Publisher completed.
`Flowable<T>`	`takeLast(long count, long time, TimeUnit unit, Scheduler scheduler)` Returns a Flowable that emits at most a specified number of items from the source Publisher that were emitted in a specified window of time before the Publisher completed, where the timing information is provided by a given Scheduler.
`Flowable<T>`	`takeLast(long count, long time, TimeUnit unit, Scheduler scheduler, boolean delayError, int bufferSize)` Returns a Flowable that emits at most a specified number of items from the source Publisher that were emitted in a specified window of time before the Publisher completed, where the timing information is provided by a given Scheduler.
`Flowable<T>`	`takeLast(long time, TimeUnit unit)` Returns a Flowable that emits the items from the source Publisher that were emitted in a specified window of time before the Publisher completed.
`Flowable<T>`	`takeLast(long time, TimeUnit unit, boolean delayError)` Returns a Flowable that emits the items from the source Publisher that were emitted in a specified window of time before the Publisher completed.
`Flowable<T>`	`takeLast(long time, TimeUnit unit, Scheduler scheduler)` Returns a Flowable that emits the items from the source Publisher that were emitted in a specified window of time before the Publisher completed, where the timing information is provided by a specified Scheduler.
`Flowable<T>`	`takeLast(long time, TimeUnit unit, Scheduler scheduler, boolean delayError)` Returns a Flowable that emits the items from the source Publisher that were emitted in a specified window of time before the Publisher completed, where the timing information is provided by a specified Scheduler.
`Flowable<T>`	`takeLast(long time, TimeUnit unit, Scheduler scheduler, boolean delayError, int bufferSize)` Returns a Flowable that emits the items from the source Publisher that were emitted in a specified window of time before the Publisher completed, where the timing information is provided by a specified Scheduler.
`Flowable<T>`	`takeUntil(PredicateT> stopPredicate)` Returns a Flowable that emits items emitted by the source Publisher, checks the specified predicate for each item, and then completes when the condition is satisfied.
`Flowable<T>`	`takeUntil(Publisher other)` Returns a Flowable that emits the items emitted by the source Publisher until a second Publisher emits an item.
`Flowable<T>`	`takeWhile(PredicateT> predicate)` Returns a Flowable that emits items emitted by the source Publisher so long as each item satisfied a specified condition, and then completes as soon as this condition is not satisfied.
`TestSubscriber<T>`	`test()` Creates a TestSubscriber that requests Long.MAX_VALUE and subscribes it to this Flowable.
`TestSubscriber<T>`	`test(long initialRequest)` Creates a TestSubscriber with the given initial request amount and subscribes it to this Flowable.
`TestSubscriber<T>`	`test(long initialRequest, boolean cancel)` Creates a TestSubscriber with the given initial request amount, optionally cancels it before the subscription and subscribes it to this Flowable.
`Flowable<T>`	`throttleFirst(long windowDuration, TimeUnit unit)` Returns a Flowable that emits only the first item emitted by the source Publisher during sequential time windows of a specified duration.
`Flowable<T>`	`throttleFirst(long skipDuration, TimeUnit unit, Scheduler scheduler)` Returns a Flowable that emits only the first item emitted by the source Publisher during sequential time windows of a specified duration, where the windows are managed by a specified Scheduler.
`Flowable<T>`	`throttleLast(long intervalDuration, TimeUnit unit)` Returns a Flowable that emits only the last item emitted by the source Publisher during sequential time windows of a specified duration.
`Flowable<T>`	`throttleLast(long intervalDuration, TimeUnit unit, Scheduler scheduler)` Returns a Flowable that emits only the last item emitted by the source Publisher during sequential time windows of a specified duration, where the duration is governed by a specified Scheduler.
`Flowable<T>`	`throttleLatest(long timeout, TimeUnit unit)` Throttles items from the upstream `Flowable` by first emitting the next item from upstream, then periodically emitting the latest item (if any) when the specified timeout elapses between them.
`Flowable<T>`	`throttleLatest(long timeout, TimeUnit unit, boolean emitLast)` Throttles items from the upstream `Flowable` by first emitting the next item from upstream, then periodically emitting the latest item (if any) when the specified timeout elapses between them.
`Flowable<T>`	`throttleLatest(long timeout, TimeUnit unit, Scheduler scheduler)` Throttles items from the upstream `Flowable` by first emitting the next item from upstream, then periodically emitting the latest item (if any) when the specified timeout elapses between them.
`Flowable<T>`	`throttleLatest(long timeout, TimeUnit unit, Scheduler scheduler, boolean emitLast)` Throttles items from the upstream `Flowable` by first emitting the next item from upstream, then periodically emitting the latest item (if any) when the specified timeout elapses between them.
`Flowable<T>`	`throttleWithTimeout(long timeout, TimeUnit unit)` Returns a Flowable that mirrors the source Publisher, except that it drops items emitted by the source Publisher that are followed by newer items before a timeout value expires.
`Flowable<T>`	`throttleWithTimeout(long timeout, TimeUnit unit, Scheduler scheduler)` Returns a Flowable that mirrors the source Publisher, except that it drops items emitted by the source Publisher that are followed by newer items before a timeout value expires on a specified Scheduler.
`Flowable<Timed<T>>`	`timeInterval()` Returns a Flowable that emits records of the time interval between consecutive items emitted by the source Publisher.
`Flowable<Timed<T>>`	`timeInterval(Scheduler scheduler)` Returns a Flowable that emits records of the time interval between consecutive items emitted by the source Publisher, where this interval is computed on a specified Scheduler.
`Flowable<Timed<T>>`	`timeInterval(TimeUnit unit)` Returns a Flowable that emits records of the time interval between consecutive items emitted by the source Publisher.
`Flowable<Timed<T>>`	`timeInterval(TimeUnit unit, Scheduler scheduler)` Returns a Flowable that emits records of the time interval between consecutive items emitted by the source Publisher, where this interval is computed on a specified Scheduler.
`Flowable<T>`	`timeout(FunctionT,? extends Publisher> itemTimeoutIndicator)` Returns a Flowable that mirrors the source Publisher, but notifies Subscribers of a `TimeoutException` if an item emitted by the source Publisher doesn't arrive within a window of time after the emission of the previous item, where that period of time is measured by a Publisher that is a function of the previous item.
`Flowable<T>`	`timeout(FunctionT,? extends Publisher> itemTimeoutIndicator, FlowableT> other)` Returns a Flowable that mirrors the source Publisher, but that switches to a fallback Publisher if an item emitted by the source Publisher doesn't arrive within a window of time after the emission of the previous item, where that period of time is measured by a Publisher that is a function of the previous item.
`Flowable<T>`	`timeout(long timeout, TimeUnit timeUnit)` Returns a Flowable that mirrors the source Publisher but applies a timeout policy for each emitted item.
`Flowable<T>`	`timeout(long timeout, TimeUnit timeUnit, PublisherT> other)` Returns a Flowable that mirrors the source Publisher but applies a timeout policy for each emitted item.
`Flowable<T>`	`timeout(long timeout, TimeUnit timeUnit, Scheduler scheduler)` Returns a Flowable that mirrors the source Publisher but applies a timeout policy for each emitted item, where this policy is governed by a specified Scheduler.
`Flowable<T>`	`timeout(long timeout, TimeUnit timeUnit, Scheduler scheduler, PublisherT> other)` Returns a Flowable that mirrors the source Publisher but applies a timeout policy for each emitted item using a specified Scheduler.
`Flowable<T>`	`timeout(Publisher firstTimeoutIndicator, FunctionT,? extends Publisher> itemTimeoutIndicator)` Returns a Flowable that mirrors the source Publisher, but notifies Subscribers of a `TimeoutException` if either the first item emitted by the source Publisher or any subsequent item doesn't arrive within time windows defined by other Publishers.
`Flowable<T>`	`timeout(Publisher firstTimeoutIndicator, FunctionT,? extends Publisher> itemTimeoutIndicator, PublisherT> other)` Returns a Flowable that mirrors the source Publisher, but switches to a fallback Publisher if either the first item emitted by the source Publisher or any subsequent item doesn't arrive within time windows defined by other Publishers.
`static Flowable<Long>`	`timer(long delay, TimeUnit unit)` Returns a Flowable that emits `0L` after a specified delay, and then completes.
`static Flowable<Long>`	`timer(long delay, TimeUnit unit, Scheduler scheduler)` Returns a Flowable that emits `0L` after a specified delay, on a specified Scheduler, and then completes.
`Flowable<Timed<T>>`	`timestamp()` Returns a Flowable that emits each item emitted by the source Publisher, wrapped in a `Timed` object.
`Flowable<Timed<T>>`	`timestamp(Scheduler scheduler)` Returns a Flowable that emits each item emitted by the source Publisher, wrapped in a `Timed` object whose timestamps are provided by a specified Scheduler.
`Flowable<Timed<T>>`	`timestamp(TimeUnit unit)` Returns a Flowable that emits each item emitted by the source Publisher, wrapped in a `Timed` object.
`Flowable<Timed<T>>`	`timestamp(TimeUnit unit, Scheduler scheduler)` Returns a Flowable that emits each item emitted by the source Publisher, wrapped in a `Timed` object whose timestamps are provided by a specified Scheduler.
`R`	`to(FunctionFlowable<T>,R> converter)` Calls the specified converter function during assembly time and returns its resulting value.
`Future<T>`	`toFuture()` Returns a `Future` representing the only value emitted by this `Flowable`.
`Single<List<T>>`	`toList()` Returns a Single that emits a single item, a list composed of all the items emitted by the finite upstream source Publisher.
`CollectionT>> Single`	`toList(Callable collectionSupplier)` Returns a Single that emits a single item, a list composed of all the items emitted by the finite source Publisher.
`Single<List<T>>`	`toList(int capacityHint)` Returns a Single that emits a single item, a list composed of all the items emitted by the finite source Publisher.
`Single<MapT>>`	`toMap(FunctionT,? extends K> keySelector)` Returns a Single that emits a single HashMap containing all items emitted by the finite source Publisher, mapped by the keys returned by a specified `keySelector` function.
`Single<Map>`	`toMap(FunctionT,? extends K> keySelector, FunctionT,? extends V> valueSelector)` Returns a Single that emits a single HashMap containing values corresponding to items emitted by the finite source Publisher, mapped by the keys returned by a specified `keySelector` function.
`Single<Map>`	`toMap(FunctionT,? extends K> keySelector, FunctionT,? extends V> valueSelector, CallableMap> mapSupplier)` Returns a Single that emits a single Map, returned by a specified `mapFactory` function, that contains keys and values extracted from the items emitted by the finite source Publisher.
`Single<MapCollection<T>>>`	`toMultimap(FunctionT,? extends K> keySelector)` Returns a Single that emits a single HashMap that contains an ArrayList of items emitted by the finite source Publisher keyed by a specified `keySelector` function.
`Single<MapCollection>>`	`toMultimap(FunctionT,? extends K> keySelector, FunctionT,? extends V> valueSelector)` Returns a Single that emits a single HashMap that contains an ArrayList of values extracted by a specified `valueSelector` function from items emitted by the finite source Publisher, keyed by a specified `keySelector` function.
`Single<MapCollection>>`	`toMultimap(FunctionT,? extends K> keySelector, FunctionT,? extends V> valueSelector, CallableMapCollection>> mapSupplier, FunctionCollection> collectionFactory)` Returns a Single that emits a single Map, returned by a specified `mapFactory` function, that contains a custom collection of values, extracted by a specified `valueSelector` function from items emitted by the finite source Publisher, and keyed by the `keySelector` function.
`Single<MapCollection>>`	`toMultimap(FunctionT,? extends K> keySelector, FunctionT,? extends V> valueSelector, Callable<MapCollection>> mapSupplier)` Returns a Single that emits a single Map, returned by a specified `mapFactory` function, that contains an ArrayList of values, extracted by a specified `valueSelector` function from items emitted by the finite source Publisher and keyed by the `keySelector` function.
`Observable<T>`	`toObservable()` Converts the current Flowable into a non-backpressured `Observable`.
`Single<List<T>>`	`toSortedList()` Returns a Single that emits a list that contains the items emitted by the finite source Publisher, in a sorted order.
`Single<List<T>>`	`toSortedList(ComparatorT> comparator)` Returns a Single that emits a list that contains the items emitted by the finite source Publisher, in a sorted order based on a specified comparison function.
`Single<List<T>>`	`toSortedList(ComparatorT> comparator, int capacityHint)` Returns a Single that emits a list that contains the items emitted by the finite source Publisher, in a sorted order based on a specified comparison function.
`Single<List<T>>`	`toSortedList(int capacityHint)` Returns a Flowable that emits a list that contains the items emitted by the finite source Publisher, in a sorted order.
`static Flowable`	`unsafeCreate(Publisher onSubscribe)` Create a Flowable by wrapping a Publisher which has to be implemented according to the Reactive Streams specification by handling backpressure and cancellation correctly; no safeguards are provided by the Flowable itself.
`Flowable<T>`	`unsubscribeOn(Scheduler scheduler)` Modifies the source Publisher so that subscribers will cancel it on a specified `Scheduler`.
`static Flowable`	`using(Callable resourceSupplier, FunctionPublisher> sourceSupplier, Consumer resourceDisposer)` Constructs a Publisher that creates a dependent resource object which is disposed of on cancellation.
`static Flowable`	`using(Callable resourceSupplier, FunctionPublisher> sourceSupplier, Consumer resourceDisposer, boolean eager)` Constructs a Publisher that creates a dependent resource object which is disposed of just before termination if you have set `disposeEagerly` to `true` and cancellation does not occur before termination.
`Flowable<Flowable<T>>`	`window(CallablePublisher> boundaryIndicatorSupplier)` Returns a Flowable that emits windows of items it collects from the source Publisher.
`Flowable<Flowable<T>>`	`window(CallablePublisher> boundaryIndicatorSupplier, int bufferSize)` Returns a Flowable that emits windows of items it collects from the source Publisher.
`Flowable<Flowable<T>>`	`window(long count)` Returns a Flowable that emits windows of items it collects from the source Publisher.
`Flowable<Flowable<T>>`	`window(long count, long skip)` Returns a Flowable that emits windows of items it collects from the source Publisher.
`Flowable<Flowable<T>>`	`window(long count, long skip, int bufferSize)` Returns a Flowable that emits windows of items it collects from the source Publisher.
`Flowable<Flowable<T>>`	`window(long timespan, long timeskip, TimeUnit unit)` Returns a Flowable that emits windows of items it collects from the source Publisher.
`Flowable<Flowable<T>>`	`window(long timespan, long timeskip, TimeUnit unit, Scheduler scheduler)` Returns a Flowable that emits windows of items it collects from the source Publisher.
`Flowable<Flowable<T>>`	`window(long timespan, long timeskip, TimeUnit unit, Scheduler scheduler, int bufferSize)` Returns a Flowable that emits windows of items it collects from the source Publisher.
`Flowable<Flowable<T>>`	`window(long timespan, TimeUnit unit)` Returns a Flowable that emits windows of items it collects from the source Publisher.
`Flowable<Flowable<T>>`	`window(long timespan, TimeUnit unit, long count)` Returns a Flowable that emits windows of items it collects from the source Publisher.
`Flowable<Flowable<T>>`	`window(long timespan, TimeUnit unit, long count, boolean restart)` Returns a Flowable that emits windows of items it collects from the source Publisher.
`Flowable<Flowable<T>>`	`window(long timespan, TimeUnit unit, Scheduler scheduler)` Returns a Flowable that emits windows of items it collects from the source Publisher.
`Flowable<Flowable<T>>`	`window(long timespan, TimeUnit unit, Scheduler scheduler, long count)` Returns a Flowable that emits windows of items it collects from the source Publisher.
`Flowable<Flowable<T>>`	`window(long timespan, TimeUnit unit, Scheduler scheduler, long count, boolean restart)` Returns a Flowable that emits windows of items it collects from the source Publisher.
`Flowable<Flowable<T>>`	`window(long timespan, TimeUnit unit, Scheduler scheduler, long count, boolean restart, int bufferSize)` Returns a Flowable that emits windows of items it collects from the source Publisher.
`Flowable<Flowable<T>>`	`window(Publisher boundaryIndicator)` Returns a Flowable that emits non-overlapping windows of items it collects from the source Publisher where the boundary of each window is determined by the items emitted from a specified boundary-governing Publisher.
`Flowable<Flowable<T>>`	`window(Publisher boundaryIndicator, int bufferSize)` Returns a Flowable that emits non-overlapping windows of items it collects from the source Publisher where the boundary of each window is determined by the items emitted from a specified boundary-governing Publisher.
`Flowable<Flowable<T>>`	`window(Publisher openingIndicator, FunctionPublisher> closingIndicator)` Returns a Flowable that emits windows of items it collects from the source Publisher.
`Flowable<Flowable<T>>`	`window(Publisher openingIndicator, FunctionPublisher> closingIndicator, int bufferSize)` Returns a Flowable that emits windows of items it collects from the source Publisher.
`Flowable`	`withLatestFrom(IterablePublisher> others, FunctionObject[],R> combiner)` Combines the value emission from this Publisher with the latest emissions from the other Publishers via a function to produce the output item.
`Flowable`	`withLatestFrom(Publisher[] others, FunctionObject[],R> combiner)` Combines the value emission from this Publisher with the latest emissions from the other Publishers via a function to produce the output item.
`Flowable`	`withLatestFrom(Publisher other, BiFunctionT,? super U,? extends R> combiner)` Merges the specified Publisher into this Publisher sequence by using the `resultSelector` function only when the source Publisher (this instance) emits an item.
`Flowable`	`withLatestFrom(Publisher source1, Publisher source2, Function3T,? super T1,? super T2,R> combiner)` Combines the value emission from this Publisher with the latest emissions from the other Publishers via a function to produce the output item.
`Flowable`	`withLatestFrom(Publisher source1, Publisher source2, Publisher source3, Function4T,? super T1,? super T2,? super T3,R> combiner)` Combines the value emission from this Publisher with the latest emissions from the other Publishers via a function to produce the output item.
`Flowable`	`withLatestFrom(Publisher source1, Publisher source2, Publisher source3, Publisher source4, Function5T,? super T1,? super T2,? super T3,? super T4,R> combiner)` Combines the value emission from this Publisher with the latest emissions from the other Publishers via a function to produce the output item.
`static Flowable`	`zip(IterablePublisher> sources, FunctionObject[],? extends R> zipper)` Returns a Flowable that emits the results of a specified combiner function applied to combinations of items emitted, in sequence, by an Iterable of other Publishers.
`static Flowable`	`zip(PublisherPublisher> sources, FunctionObject[],? extends R> zipper)` Returns a Flowable that emits the results of a specified combiner function applied to combinations of n items emitted, in sequence, by the n Publishers emitted by a specified Publisher.
`static Flowable`	`zip(Publisher source1, Publisher source2, BiFunction zipper)` Returns a Flowable that emits the results of a specified combiner function applied to combinations of two items emitted, in sequence, by two other Publishers.
`static Flowable`	`zip(Publisher source1, Publisher source2, BiFunction zipper, boolean delayError)` Returns a Flowable that emits the results of a specified combiner function applied to combinations of two items emitted, in sequence, by two other Publishers.
`static Flowable`	`zip(Publisher source1, Publisher source2, BiFunction zipper, boolean delayError, int bufferSize)` Returns a Flowable that emits the results of a specified combiner function applied to combinations of two items emitted, in sequence, by two other Publishers.
`static Flowable`	`zip(Publisher source1, Publisher source2, Publisher source3, Function3 zipper)` Returns a Flowable that emits the results of a specified combiner function applied to combinations of three items emitted, in sequence, by three other Publishers.
`static Flowable`	`zip(Publisher source1, Publisher source2, Publisher source3, Publisher source4, Function4 zipper)` Returns a Flowable that emits the results of a specified combiner function applied to combinations of four items emitted, in sequence, by four other Publishers.
`static Flowable`	`zip(Publisher source1, Publisher source2, Publisher source3, Publisher source4, Publisher source5, Function5 zipper)` Returns a Flowable that emits the results of a specified combiner function applied to combinations of five items emitted, in sequence, by five other Publishers.
`static Flowable`	`zip(Publisher source1, Publisher source2, Publisher source3, Publisher source4, Publisher source5, Publisher source6, Function6 zipper)` Returns a Flowable that emits the results of a specified combiner function applied to combinations of six items emitted, in sequence, by six other Publishers.
`static Flowable`	`zip(Publisher source1, Publisher source2, Publisher source3, Publisher source4, Publisher source5, Publisher source6, Publisher source7, Function7 zipper)` Returns a Flowable that emits the results of a specified combiner function applied to combinations of seven items emitted, in sequence, by seven other Publishers.
`static Flowable`	`zip(Publisher source1, Publisher source2, Publisher source3, Publisher source4, Publisher source5, Publisher source6, Publisher source7, Publisher source8, Function8 zipper)` Returns a Flowable that emits the results of a specified combiner function applied to combinations of eight items emitted, in sequence, by eight other Publishers.
`static Flowable`	`zip(Publisher source1, Publisher source2, Publisher source3, Publisher source4, Publisher source5, Publisher source6, Publisher source7, Publisher source8, Publisher source9, Function9 zipper)` Returns a Flowable that emits the results of a specified combiner function applied to combinations of nine items emitted, in sequence, by nine other Publishers.
`static Flowable`	`zipArray(FunctionObject[],? extends R> zipper, boolean delayError, int bufferSize, Publisher... sources)` Returns a Flowable that emits the results of a specified combiner function applied to combinations of items emitted, in sequence, by an array of other Publishers.
`static Flowable`	`zipIterable(IterablePublisher> sources, FunctionObject[],? extends R> zipper, boolean delayError, int bufferSize)` Returns a Flowable that emits the results of a specified combiner function applied to combinations of items emitted, in sequence, by an Iterable of other Publishers.
`Flowable`	`zipWith(Iterable other, BiFunctionT,? super U,? extends R> zipper)` Returns a Flowable that emits items that are the result of applying a specified function to pairs of values, one each from the source Publisher and a specified Iterable sequence.
`Flowable`	`zipWith(Publisher other, BiFunctionT,? super U,? extends R> zipper)` Returns a Flowable that emits items that are the result of applying a specified function to pairs of values, one each from the source Publisher and another specified Publisher.
`Flowable`	`zipWith(Publisher other, BiFunctionT,? super U,? extends R> zipper, boolean delayError)` Returns a Flowable that emits items that are the result of applying a specified function to pairs of values, one each from the source Publisher and another specified Publisher.
`Flowable`	`zipWith(Publisher other, BiFunctionT,? super U,? extends R> zipper, boolean delayError, int bufferSize)` Returns a Flowable that emits items that are the result of applying a specified function to pairs of values, one each from the source Publisher and another specified Publisher.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - Flowable
```
public Flowable()
```
- Method Detail
  - amb
```
@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=PASS_THROUGH)
 @SchedulerSupport(value="none")
public static  Flowable amb(IterablePublisher> sources)
```
    Mirrors the one Publisher in an Iterable of several Publishers that first either emits an item or sends a termination notification.
    
    Backpressure:
    
    The operator itself doesn't interfere with backpressure which is determined by the winning Publisher's backpressure behavior.
    
    Scheduler:
    
    amb does not operate by default on a particular Scheduler.
    
    Type Parameters:
    
    T - the common element type
    
    Parameters:
    
    sources - an Iterable of Publishers sources competing to react first. A subscription to each Publisher will occur in the same order as in this Iterable.
    
    Returns:
    
    a Flowable that emits the same sequence as whichever of the source Publishers first emitted an item or sent a termination notification
    
    See Also:
    
    ReactiveX operators documentation: Amb
  - ambArray
```
@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=PASS_THROUGH)
 @SchedulerSupport(value="none")
public static  Flowable ambArray(Publisher... sources)
```
    Mirrors the one Publisher in an array of several Publishers that first either emits an item or sends a termination notification.
    
    Backpressure:
    
    The operator itself doesn't interfere with backpressure which is determined by the winning Publisher's backpressure behavior.
    
    Scheduler:
    
    ambArray does not operate by default on a particular Scheduler.
    
    Type Parameters:
    
    T - the common element type
    
    Parameters:
    
    sources - an array of Publisher sources competing to react first. A subscription to each Publisher will occur in the same order as in this Iterable.
    
    Returns:
    
    a Flowable that emits the same sequence as whichever of the source Publishers first emitted an item or sent a termination notification
    
    See Also:
    
    ReactiveX operators documentation: Amb
  - bufferSize
```
public static int bufferSize()
```
    Returns the default internal buffer size used by most async operators.
    The value can be overridden via system parameter rx2.buffer-size before the Flowable class is loaded.
    
    Returns:
    
    the default internal buffer size.
  - combineLatest
```
@SchedulerSupport(value="none")
 @CheckReturnValue
 @BackpressureSupport(value=FULL)
public static  Flowable combineLatest(Publisher[] sources,
        FunctionObject[],? extends R> combiner)
```
    Combines a collection of source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function.
    Note on method signature: since Java doesn't allow creating a generic array with new T[], the implementation of this operator has to create an Object[] instead. Unfortunately, a Function passed to the method would trigger a ClassCastException.
    If any of the sources never produces an item but only terminates (normally or with an error), the resulting sequence terminates immediately (normally or with all the errors accumulated until that point). If that input source is also synchronous, other sources after it will not be subscribed to.
    If the provided array of source Publishers is empty, the resulting sequence completes immediately without emitting any items and without any calls to the combiner function.
    
    Backpressure:
    
    The returned Publisher honors backpressure from downstream. The source Publishers are requested in a bounded manner, however, their backpressure is not enforced (the operator won't signal MissingBackpressureException) and may lead to OutOfMemoryError due to internal buffer bloat.
    
    Scheduler:
    
    combineLatest does not operate by default on a particular Scheduler.
    
    Type Parameters:
    
    T - the common base type of source values
    
    R - the result type
    
    Parameters:
    
    sources - the collection of source Publishers
    
    combiner - the aggregation function used to combine the items emitted by the source Publishers
    
    Returns:
    
    a Flowable that emits items that are the result of combining the items emitted by the source Publishers by means of the given aggregation function
    
    See Also:
    
    ReactiveX operators documentation: CombineLatest
  - combineLatest
```
@SchedulerSupport(value="none")
 @CheckReturnValue
 @BackpressureSupport(value=FULL)
public static  Flowable combineLatest(FunctionObject[],? extends R> combiner,
        Publisher... sources)
```
    Combines a collection of source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function.
    Note on method signature: since Java doesn't allow creating a generic array with new T[], the implementation of this operator has to create an Object[] instead. Unfortunately, a Function passed to the method would trigger a ClassCastException.
    If any of the sources never produces an item but only terminates (normally or with an error), the resulting sequence terminates immediately (normally or with all the errors accumulated until that point). If that input source is also synchronous, other sources after it will not be subscribed to.
    If there are no source Publishers provided, the resulting sequence completes immediately without emitting any items and without any calls to the combiner function.
    
    Backpressure:
    
    The returned Publisher honors backpressure from downstream. The source Publishers are requested in a bounded manner, however, their backpressure is not enforced (the operator won't signal MissingBackpressureException) and may lead to OutOfMemoryError due to internal buffer bloat.
    
    Scheduler:
    
    combineLatest does not operate by default on a particular Scheduler.
    
    Type Parameters:
    
    T - the common base type of source values
    
    R - the result type
    
    Parameters:
    
    sources - the collection of source Publishers
    
    combiner - the aggregation function used to combine the items emitted by the source Publishers
    
    Returns:
    
    a Flowable that emits items that are the result of combining the items emitted by the source Publishers by means of the given aggregation function
    
    See Also:
    
    ReactiveX operators documentation: CombineLatest
  - combineLatest
```
@SchedulerSupport(value="none")
 @CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
public static  Flowable combineLatest(Publisher[] sources,
        FunctionObject[],? extends R> combiner,
        int bufferSize)
```
    Combines a collection of source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function.
    Note on method signature: since Java doesn't allow creating a generic array with new T[], the implementation of this operator has to create an Object[] instead. Unfortunately, a Function passed to the method would trigger a ClassCastException.
    If any of the sources never produces an item but only terminates (normally or with an error), the resulting sequence terminates immediately (normally or with all the errors accumulated until that point). If that input source is also synchronous, other sources after it will not be subscribed to.
    If the provided array of source Publishers is empty, the resulting sequence completes immediately without emitting any items and without any calls to the combiner function.
    
    Backpressure:
    
    The returned Publisher honors backpressure from downstream. The source Publishers are requested in a bounded manner, however, their backpressure is not enforced (the operator won't signal MissingBackpressureException) and may lead to OutOfMemoryError due to internal buffer bloat.
    
    Scheduler:
    
    combineLatest does not operate by default on a particular Scheduler.
    
    Type Parameters:
    
    T - the common base type of source values
    
    R - the result type
    
    Parameters:
    
    sources - the collection of source Publishers
    
    combiner - the aggregation function used to combine the items emitted by the source Publishers
    
    bufferSize - the internal buffer size and prefetch amount applied to every source Flowable
    
    Returns:
    
    a Flowable that emits items that are the result of combining the items emitted by the source Publishers by means of the given aggregation function
    
    See Also:
    
    ReactiveX operators documentation: CombineLatest
  - combineLatest
```
@SchedulerSupport(value="none")
 @CheckReturnValue
 @BackpressureSupport(value=FULL)
public static  Flowable combineLatest(IterablePublisher> sources,
        FunctionObject[],? extends R> combiner)
```
    Combines a collection of source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function.
    Note on method signature: since Java doesn't allow creating a generic array with new T[], the implementation of this operator has to create an Object[] instead. Unfortunately, a Function passed to the method would trigger a ClassCastException.
    If any of the sources never produces an item but only terminates (normally or with an error), the resulting sequence terminates immediately (normally or with all the errors accumulated until that point). If that input source is also synchronous, other sources after it will not be subscribed to.
    If the provided iterable of source Publishers is empty, the resulting sequence completes immediately without emitting any items and without any calls to the combiner function.
    
    Backpressure:
    
    The returned Publisher honors backpressure from downstream. The source Publishers are requested in a bounded manner, however, their backpressure is not enforced (the operator won't signal MissingBackpressureException) and may lead to OutOfMemoryError due to internal buffer bloat.
    
    Scheduler:
    
    combineLatest does not operate by default on a particular Scheduler.
    
    Type Parameters:
    
    T - the common base type of source values
    
    R - the result type
    
    Parameters:
    
    sources - the collection of source Publishers
    
    combiner - the aggregation function used to combine the items emitted by the source Publishers
    
    Returns:
    
    a Flowable that emits items that are the result of combining the items emitted by the source Publishers by means of the given aggregation function
    
    See Also:
    
    ReactiveX operators documentation: CombineLatest
  - combineLatest
```
@SchedulerSupport(value="none")
 @CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
public static  Flowable combineLatest(IterablePublisher> sources,
        FunctionObject[],? extends R> combiner,
        int bufferSize)
```
    Combines a collection of source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function.
    Note on method signature: since Java doesn't allow creating a generic array with new T[], the implementation of this operator has to create an Object[] instead. Unfortunately, a Function passed to the method would trigger a ClassCastException.
    If any of the sources never produces an item but only terminates (normally or with an error), the resulting sequence terminates immediately (normally or with all the errors accumulated until that point). If that input source is also synchronous, other sources after it will not be subscribed to.
    If the provided iterable of source Publishers is empty, the resulting sequence completes immediately without emitting any items and without any calls to the combiner function.
    
    Backpressure:
    
    The returned Publisher honors backpressure from downstream. The source Publishers are requested in a bounded manner, however, their backpressure is not enforced (the operator won't signal MissingBackpressureException) and may lead to OutOfMemoryError due to internal buffer bloat.
    
    Scheduler:
    
    combineLatest does not operate by default on a particular Scheduler.
    
    Type Parameters:
    
    T - the common base type of source values
    
    R - the result type
    
    Parameters:
    
    sources - the collection of source Publishers
    
    combiner - the aggregation function used to combine the items emitted by the source Publishers
    
    bufferSize - the internal buffer size and prefetch amount applied to every source Flowable
    
    Returns:
    
    a Flowable that emits items that are the result of combining the items emitted by the source Publishers by means of the given aggregation function
    
    See Also:
    
    ReactiveX operators documentation: CombineLatest
  - combineLatestDelayError
```
@SchedulerSupport(value="none")
 @CheckReturnValue
 @BackpressureSupport(value=FULL)
public static  Flowable combineLatestDelayError(Publisher[] sources,
        FunctionObject[],? extends R> combiner)
```
    Combines a collection of source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function.
    Note on method signature: since Java doesn't allow creating a generic array with new T[], the implementation of this operator has to create an Object[] instead. Unfortunately, a Function passed to the method would trigger a ClassCastException.
    If any of the sources never produces an item but only terminates (normally or with an error), the resulting sequence terminates immediately (normally or with all the errors accumulated until that point). If that input source is also synchronous, other sources after it will not be subscribed to.
    If the provided array of source Publishers is empty, the resulting sequence completes immediately without emitting any items and without any calls to the combiner function.
    
    Backpressure:
    
    The returned Publisher honors backpressure from downstream. The source Publishers are requested in a bounded manner, however, their backpressure is not enforced (the operator won't signal MissingBackpressureException) and may lead to OutOfMemoryError due to internal buffer bloat.
    
    Scheduler:
    
    combineLatestDelayError does not operate by default on a particular Scheduler.
    
    Type Parameters:
    
    T - the common base type of source values
    
    R - the result type
    
    Parameters:
    
    sources - the collection of source Publishers
    
    combiner - the aggregation function used to combine the items emitted by the source Publishers
    
    Returns:
    
    a Flowable that emits items that are the result of combining the items emitted by the source Publishers by means of the given aggregation function
    
    See Also:
    
    ReactiveX operators documentation: CombineLatest
  - combineLatestDelayError
```
@SchedulerSupport(value="none")
 @CheckReturnValue
 @BackpressureSupport(value=FULL)
public static  Flowable combineLatestDelayError(FunctionObject[],? extends R> combiner,
        Publisher... sources)
```
    Combines a collection of source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function and delays any error from the sources until all source Publishers terminate.
    Note on method signature: since Java doesn't allow creating a generic array with new T[], the implementation of this operator has to create an Object[] instead. Unfortunately, a Function passed to the method would trigger a ClassCastException.
    If any of the sources never produces an item but only terminates (normally or with an error), the resulting sequence terminates immediately (normally or with all the errors accumulated until that point). If that input source is also synchronous, other sources after it will not be subscribed to.
    If there are no source Publishers provided, the resulting sequence completes immediately without emitting any items and without any calls to the combiner function.
    
    Backpressure:
    
    The returned Publisher honors backpressure from downstream. The source Publishers are requested in a bounded manner, however, their backpressure is not enforced (the operator won't signal MissingBackpressureException) and may lead to OutOfMemoryError due to internal buffer bloat.
    
    Scheduler:
    
    combineLatestDelayError does not operate by default on a particular Scheduler.
    
    Type Parameters:
    
    T - the common base type of source values
    
    R - the result type
    
    Parameters:
    
    sources - the collection of source Publishers
    
    combiner - the aggregation function used to combine the items emitted by the source Publishers
    
    Returns:
    
    a Flowable that emits items that are the result of combining the items emitted by the source Publishers by means of the given aggregation function
    
    See Also:
    
    ReactiveX operators documentation: CombineLatest
  - combineLatestDelayError
```
@SchedulerSupport(value="none")
 @CheckReturnValue
 @BackpressureSupport(value=FULL)
public static  Flowable combineLatestDelayError(FunctionObject[],? extends R> combiner,
        int bufferSize,
        Publisher... sources)
```
    Combines a collection of source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publisher, where this aggregation is defined by a specified function and delays any error from the sources until all source Publishers terminate.
    Note on method signature: since Java doesn't allow creating a generic array with new T[], the implementation of this operator has to create an Object[] instead. Unfortunately, a Function passed to the method would trigger a ClassCastException.
    If any of the sources never produces an item but only terminates (normally or with an error), the resulting sequence terminates immediately (normally or with all the errors accumulated until that point). If that input source is also synchronous, other sources after it will not be subscribed to.
    If there are no source Publishers provided, the resulting sequence completes immediately without emitting any items and without any calls to the combiner function.
    
    Backpressure:
    
    The returned Publisher honors backpressure from downstream. The source Publishers are requested in a bounded manner, however, their backpressure is not enforced (the operator won't signal MissingBackpressureException) and may lead to OutOfMemoryError due to internal buffer bloat.
    
    Scheduler:
    
    combineLatestDelayError does not operate by default on a particular Scheduler.
    
    Type Parameters:
    
    T - the common base type of source values
    
    R - the result type
    
    Parameters:
    
    sources - the collection of source Publishers
    
    combiner - the aggregation function used to combine the items emitted by the source Publishers
    
    bufferSize - the internal buffer size and prefetch amount applied to every source Publisher
    
    Returns:
    
    a Flowable that emits items that are the result of combining the items emitted by the source Publishers by means of the given aggregation function
    
    See Also:
    
    ReactiveX operators documentation: CombineLatest
  - combineLatestDelayError
```
@SchedulerSupport(value="none")
 @CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
public static  Flowable combineLatestDelayError(Publisher[] sources,
        FunctionObject[],? extends R> combiner,
        int bufferSize)
```
    Combines a collection of source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function and delays any error from the sources until all source Publishers terminate.
    Note on method signature: since Java doesn't allow creating a generic array with new T[], the implementation of this operator has to create an Object[] instead. Unfortunately, a Function passed to the method would trigger a ClassCastException.
    If any of the sources never produces an item but only terminates (normally or with an error), the resulting sequence terminates immediately (normally or with all the errors accumulated until that point). If that input source is also synchronous, other sources after it will not be subscribed to.
    If the provided array of source Publishers is empty, the resulting sequence completes immediately without emitting any items and without any calls to the combiner function.
    
    Backpressure:
    
    The returned Publisher honors backpressure from downstream. The source Publishers are requested in a bounded manner, however, their backpressure is not enforced (the operator won't signal MissingBackpressureException) and may lead to OutOfMemoryError due to internal buffer bloat.
    
    Scheduler:
    
    combineLatestDelayError does not operate by default on a particular Scheduler.
    
    Type Parameters:
    
    T - the common base type of source values
    
    R - the result type
    
    Parameters:
    
    sources - the collection of source Publishers
    
    combiner - the aggregation function used to combine the items emitted by the source Publishers
    
    bufferSize - the internal buffer size and prefetch amount applied to every source Flowable
    
    Returns:
    
    a Flowable that emits items that are the result of combining the items emitted by the source Publishers by means of the given aggregation function
    
    See Also:
    
    ReactiveX operators documentation: CombineLatest
  - combineLatestDelayError
```
@SchedulerSupport(value="none")
 @CheckReturnValue
 @BackpressureSupport(value=FULL)
public static  Flowable combineLatestDelayError(IterablePublisher> sources,
        FunctionObject[],? extends R> combiner)
```
    Combines a collection of source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function and delays any error from the sources until all source Publishers terminate.
    Note on method signature: since Java doesn't allow creating a generic array with new T[], the implementation of this operator has to create an Object[] instead. Unfortunately, a Function passed to the method would trigger a ClassCastException.
    If any of the sources never produces an item but only terminates (normally or with an error), the resulting sequence terminates immediately (normally or with all the errors accumulated until that point). If that input source is also synchronous, other sources after it will not be subscribed to.
    If the provided iterable of source Publishers is empty, the resulting sequence completes immediately without emitting any items and without any calls to the combiner function.
    
    Backpressure:
    
    The returned Publisher honors backpressure from downstream. The source Publishers are requested in a bounded manner, however, their backpressure is not enforced (the operator won't signal MissingBackpressureException) and may lead to OutOfMemoryError due to internal buffer bloat.
    
    Scheduler:
    
    combineLatestDelayError does not operate by default on a particular Scheduler.
    
    Type Parameters:
    
    T - the common base type of source values
    
    R - the result type
    
    Parameters:
    
    sources - the collection of source Publishers
    
    combiner - the aggregation function used to combine the items emitted by the source Publishers
    
    Returns:
    
    a Flowable that emits items that are the result of combining the items emitted by the source Publishers by means of the given aggregation function
    
    See Also:
    
    ReactiveX operators documentation: CombineLatest
  - combineLatestDelayError
```
@SchedulerSupport(value="none")
 @CheckReturnValue
 @BackpressureSupport(value=FULL)
public static  Flowable combineLatestDelayError(IterablePublisher> sources,
        FunctionObject[],? extends R> combiner,
        int bufferSize)
```
    Combines a collection of source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function and delays any error from the sources until all source Publishers terminate.
    Note on method signature: since Java doesn't allow creating a generic array with new T[], the implementation of this operator has to create an Object[] instead. Unfortunately, a Function passed to the method would trigger a ClassCastException.
    If any of the sources never produces an item but only terminates (normally or with an error), the resulting sequence terminates immediately (normally or with all the errors accumulated until that point). If that input source is also synchronous, other sources after it will not be subscribed to.
    If the provided iterable of source Publishers is empty, the resulting sequence completes immediately without emitting any items and without any calls to the combiner function.
    
    Backpressure:
    
    The returned Publisher honors backpressure from downstream. The source Publishers are requested in a bounded manner, however, their backpressure is not enforced (the operator won't signal MissingBackpressureException) and may lead to OutOfMemoryError due to internal buffer bloat.
    
    Scheduler:
    
    combineLatestDelayError does not operate by default on a particular Scheduler.
    
    Type Parameters:
    
    T - the common base type of source values
    
    R - the result type
    
    Parameters:
    
    sources - the collection of source Publishers
    
    combiner - the aggregation function used to combine the items emitted by the source Publishers
    
    bufferSize - the internal buffer size and prefetch amount applied to every source Flowable
    
    Returns:
    
    a Flowable that emits items that are the result of combining the items emitted by the source Publishers by means of the given aggregation function
    
    See Also:
    
    ReactiveX operators documentation: CombineLatest
  - combineLatest
```
@CheckReturnValue
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static  Flowable combineLatest(Publisher source1,
        Publisher source2,
        BiFunction combiner)
```
    Combines two source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from either of the source Publishers, where this aggregation is defined by a specified function.
    If any of the sources never produces an item but only terminates (normally or with an error), the resulting sequence terminates immediately (normally or with all the errors accumulated until that point). If that input source is also synchronous, other sources after it will not be subscribed to.
    
    Backpressure:
    
    The returned Publisher honors backpressure from downstream. The source Publishers are requested in a bounded manner, however, their backpressure is not enforced (the operator won't signal MissingBackpressureException) and may lead to OutOfMemoryError due to internal buffer bloat.
    
    Scheduler:
    
    combineLatest does not operate by default on a particular Scheduler.
    
    Type Parameters:
    
    T1 - the element type of the first source
    
    T2 - the element type of the second source
    
    R - the combined output type
    
    Parameters:
    
    source1 - the first source Publisher
    
    source2 - the second source Publisher
    
    combiner - the aggregation function used to combine the items emitted by the source Publishers
    
    Returns:
    
    a Flowable that emits items that are the result of combining the items emitted by the source Publishers by means of the given aggregation function
    
    See Also:
    
    ReactiveX operators documentation: CombineLatest
  - combineLatest
```
@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static  Flowable combineLatest(Publisher source1,
        Publisher source2,
        Publisher source3,
        Function3 combiner)
```
    Combines three source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function.
    If any of the sources never produces an item but only terminates (normally or with an error), the resulting sequence terminates immediately (normally or with all the errors accumulated until that point). If that input source is also synchronous, other sources after it will not be subscribed to.
    
    Backpressure:
    
    The returned Publisher honors backpressure from downstream. The source Publishers are requested in a bounded manner, however, their backpressure is not enforced (the operator won't signal MissingBackpressureException) and may lead to OutOfMemoryError due to internal buffer bloat.
    
    Scheduler:
    
    combineLatest does not operate by default on a particular Scheduler.
    
    Type Parameters:
    
    T1 - the element type of the first source
    
    T2 - the element type of the second source
    
    T3 - the element type of the third source
    
    R - the combined output type
    
    Parameters:
    
    source1 - the first source Publisher
    
    source2 - the second source Publisher
    
    source3 - the third source Publisher
    
    combiner - the aggregation function used to combine the items emitted by the source Publishers
    
    Returns:
    
    a Flowable that emits items that are the result of combining the items emitted by the source Publishers by means of the given aggregation function
    
    See Also:
    
    ReactiveX operators documentation: CombineLatest
  - combineLatest
```
@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static  Flowable combineLatest(Publisher source1,
        Publisher source2,
        Publisher source3,
        Publisher source4,
        Function4 combiner)
```
    Combines four source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function.
    If any of the sources never produces an item but only terminates (normally or with an error), the resulting sequence terminates immediately (normally or with all the errors accumulated until that point). If that input source is also synchronous, other sources after it will not be subscribed to.
    
    Backpressure:
    
    The returned Publisher honors backpressure from downstream. The source Publishers are requested in a bounded manner, however, their backpressure is not enforced (the operator won't signal MissingBackpressureException) and may lead to OutOfMemoryError due to internal buffer bloat.
    
    Scheduler:
    
    combineLatest does not operate by default on a particular Scheduler.
    
    Type Parameters:
    
    T1 - the element type of the first source
    
    T2 - the element type of the second source
    
    T3 - the element type of the third source
    
    T4 - the element type of the fourth source
    
    R - the combined output type
    
    Parameters:
    
    source1 - the first source Publisher
    
    source2 - the second source Publisher
    
    source3 - the third source Publisher
    
    source4 - the fourth source Publisher
    
    combiner - the aggregation function used to combine the items emitted by the source Publishers
    
    Returns:
    
    a Flowable that emits items that are the result of combining the items emitted by the source Publishers by means of the given aggregation function
    
    See Also:
    
    ReactiveX operators documentation: CombineLatest
  - combineLatest
```
@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static  Flowable combineLatest(Publisher source1,
        Publisher source2,
        Publisher source3,
        Publisher source4,
        Publisher source5,
        Function5 combiner)
```
    Combines five source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function.
    If any of the sources never produces an item but only terminates (normally or with an error), the resulting sequence terminates immediately (normally or with all the errors accumulated until that point). If that input source is also synchronous, other sources after it will not be subscribed to.
    
    Backpressure:
    
    The returned Publisher honors backpressure from downstream. The source Publishers are requested in a bounded manner, however, their backpressure is not enforced (the operator won't signal MissingBackpressureException) and may lead to OutOfMemoryError due to internal buffer bloat.
    
    Scheduler:
    
    combineLatest does not operate by default on a particular Scheduler.
    
    Type Parameters:
    
    T1 - the element type of the first source
    
    T2 - the element type of the second source
    
    T3 - the element type of the third source
    
    T4 - the element type of the fourth source
    
    T5 - the element type of the fifth source
    
    R - the combined output type
    
    Parameters:
    
    source1 - the first source Publisher
    
    source2 - the second source Publisher
    
    source3 - the third source Publisher
    
    source4 - the fourth source Publisher
    
    source5 - the fifth source Publisher
    
    combiner - the aggregation function used to combine the items emitted by the source Publishers
    
    Returns:
    
    a Flowable that emits items that are the result of combining the items emitted by the source Publishers by means of the given aggregation function
    
    See Also:
    
    ReactiveX operators documentation: CombineLatest
  - combineLatest
```
@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static  Flowable combineLatest(Publisher source1,
        Publisher source2,
        Publisher source3,
        Publisher source4,
        Publisher source5,
        Publisher source6,
        Function6 combiner)
```
    Combines six source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function.
    If any of the sources never produces an item but only terminates (normally or with an error), the resulting sequence terminates immediately (normally or with all the errors accumulated until that point). If that input source is also synchronous, other sources after it will not be subscribed to.
    
    Backpressure:
    
    The returned Publisher honors backpressure from downstream. The source Publishers are requested in a bounded manner, however, their backpressure is not enforced (the operator won't signal MissingBackpressureException) and may lead to OutOfMemoryError due to internal buffer bloat.
    
    Scheduler:
    
    combineLatest does not operate by default on a particular Scheduler.
    
    Type Parameters:
    
    T1 - the element type of the first source
    
    T2 - the element type of the second source
    
    T3 - the element type of the third source
    
    T4 - the element type of the fourth source
    
    T5 - the element type of the fifth source
    
    T6 - the element type of the sixth source
    
    R - the combined output type
    
    Parameters:
    
    source1 - the first source Publisher
    
    source2 - the second source Publisher
    
    source3 - the third source Publisher
    
    source4 - the fourth source Publisher
    
    source5 - the fifth source Publisher
    
    source6 - the sixth source Publisher
    
    combiner - the aggregation function used to combine the items emitted by the source Publishers
    
    Returns:
    
    a Flowable that emits items that are the result of combining the items emitted by the source Publishers by means of the given aggregation function
    
    See Also:
    
    ReactiveX operators documentation: CombineLatest
  - combineLatest
```
@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static  Flowable combineLatest(Publisher source1,
        Publisher source2,
        Publisher source3,
        Publisher source4,
        Publisher source5,
        Publisher source6,
        Publisher source7,
        Function7 combiner)
```
    Combines seven source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function.
    If any of the sources never produces an item but only terminates (normally or with an error), the resulting sequence terminates immediately (normally or with all the errors accumulated until that point). If that input source is also synchronous, other sources after it will not be subscribed to.
    
    Backpressure:
    
    The returned Publisher honors backpressure from downstream. The source Publishers are requested in a bounded manner, however, their backpressure is not enforced (the operator won't signal MissingBackpressureException) and may lead to OutOfMemoryError due to internal buffer bloat.
    
    Scheduler:
    
    combineLatest does not operate by default on a particular Scheduler.
    
    Type Parameters:
    
    T1 - the element type of the first source
    
    T2 - the element type of the second source
    
    T3 - the element type of the third source
    
    T4 - the element type of the fourth source
    
    T5 - the element type of the fifth source
    
    T6 - the element type of the sixth source
    
    T7 - the element type of the seventh source
    
    R - the combined output type
    
    Parameters:
    
    source1 - the first source Publisher
    
    source2 - the second source Publisher
    
    source3 - the third source Publisher
    
    source4 - the fourth source Publisher
    
    source5 - the fifth source Publisher
    
    source6 - the sixth source Publisher
    
    source7 - the seventh source Publisher
    
    combiner - the aggregation function used to combine the items emitted by the source Publishers
    
    Returns:
    
    a Flowable that emits items that are the result of combining the items emitted by the source Publishers by means of the given aggregation function
    
    See Also:
    
    ReactiveX operators documentation: CombineLatest
  - combineLatest
```
@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static  Flowable combineLatest(Publisher source1,
        Publisher source2,
        Publisher source3,
        Publisher source4,
        Publisher source5,
        Publisher source6,
        Publisher source7,
        Publisher source8,
        Function8 combiner)
```
    Combines eight source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function.
    If any of the sources never produces an item but only terminates (normally or with an error), the resulting sequence terminates immediately (normally or with all the errors accumulated until that point). If that input source is also synchronous, other sources after it will not be subscribed to.
    
    Backpressure:
    
    The returned Publisher honors backpressure from downstream. The source Publishers are requested in a bounded manner, however, their backpressure is not enforced (the operator won't signal MissingBackpressureException) and may lead to OutOfMemoryError due to internal buffer bloat.
    
    Scheduler:
    
    combineLatest does not operate by default on a particular Scheduler.
    
    Type Parameters:
    
    T1 - the element type of the first source
    
    T2 - the element type of the second source
    
    T3 - the element type of the third source
    
    T4 - the element type of the fourth source
    
    T5 - the element type of the fifth source
    
    T6 - the element type of the sixth source
    
    T7 - the element type of the seventh source
    
    T8 - the element type of the eighth source
    
    R - the combined output type
    
    Parameters:
    
    source1 - the first source Publisher
    
    source2 - the second source Publisher
    
    source3 - the third source Publisher
    
    source4 - the fourth source Publisher
    
    source5 - the fifth source Publisher
    
    source6 - the sixth source Publisher
    
    source7 - the seventh source Publisher
    
    source8 - the eighth source Publisher
    
    combiner - the aggregation function used to combine the items emitted by the source Publishers
    
    Returns:
    
    a Flowable that emits items that are the result of combining the items emitted by the source Publishers by means of the given aggregation function
    
    See Also:
    
    ReactiveX operators documentation: CombineLatest
  - combineLatest
```
@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static  Flowable combineLatest(Publisher source1,
        Publisher source2,
        Publisher source3,
        Publisher source4,
        Publisher source5,
        Publisher source6,
        Publisher source7,
        Publisher source8,
        Publisher source9,
        Function9 combiner)
```
    Combines nine source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function.
    If any of the sources never produces an item but only terminates (normally or with an error), the resulting sequence terminates immediately (normally or with all the errors accumulated until that point). If that input source is also synchronous, other sources after it will not be subscribed to.
    
    Backpressure:
    
    The returned Publisher honors backpressure from downstream. The source Publishers are requested in a bounded manner, however, their backpressure is not enforced (the operator won't signal MissingBackpressureException) and may lead to OutOfMemoryError due to internal buffer bloat.
    
    Scheduler:
    
    combineLatest does not operate by default on a particular Scheduler.
    
    Type Parameters:
    
    T1 - the element type of the first source
    
    T2 - the element type of the second source
    
    T3 - the element type of the third source
    
    T4 - the element type of the fourth source
    
    T5 - the element type of the fifth source
    
    T6 - the element type of the sixth source
    
    T7 - the element type of the seventh source
    
    T8 - the element type of the eighth source
    
    T9 - the element type of the ninth source
    
    R - the combined output type
    
    Parameters:
    
    source1 - the first source Publisher
    
    source2 - the second source Publisher
    
    source3 - the third source Publisher
    
    source4 - the fourth source Publisher
    
    source5 - the fifth source Publisher
    
    source6 - the sixth source Publisher
    
    source7 - the seventh source Publisher
    
    source8 - the eighth source Publisher
    
    source9 - the ninth source Publisher
    
    combiner - the aggregation function used to combine the items emitted by the source Publishers
    
    Returns:
    
    a Flowable that emits items that are the result of combining the items emitted by the source Publishers by means of the given aggregation function
    
    See Also:
    
    ReactiveX operators documentation: CombineLatest
  - concat
```
@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static  Flowable concat(IterablePublisher> sources)
```
    Concatenates elements of each Publisher provided via an Iterable sequence into a single sequence of elements without interleaving them.
    
    Backpressure:
    
    The operator honors backpressure from downstream. The Publisher sources are expected to honor backpressure as well. If any of the source Publishers violate this, it may throw an IllegalStateException when the source Publisher completes.
    
    Scheduler:
    
    concat does not operate by default on a particular Scheduler.
    
    Type Parameters:
    
    T - the common value type of the sources
    
    Parameters:
    
    sources - the Iterable sequence of Publishers
    
    Returns:
    
    the new Flowable instance
  - concat
```
@CheckReturnValue
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static  Flowable concat(PublisherPublisher> sources)
```
    Returns a Flowable that emits the items emitted by each of the Publishers emitted by the source Publisher, one after the other, without interleaving them.
    
    Backpressure:
    
    The operator honors backpressure from downstream. Both the outer and inner Publisher sources are expected to honor backpressure as well. If the outer violates this, a MissingBackpressureException is signaled. If any of the inner Publishers violates this, it may throw an IllegalStateException when an inner Publisher completes.
    
    Scheduler:
    
    concat does not operate by default on a particular Scheduler.
    
    Type Parameters:
    
    T - the common element base type
    
    Parameters:
    
    sources - a Publisher that emits Publishers
    
    Returns:
    
    a Flowable that emits items all of the items emitted by the Publishers emitted by Publishers, one after the other, without interleaving them
    
    See Also:
    
    ReactiveX operators documentation: Concat
  - concat
```
@CheckReturnValue
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static  Flowable concat(PublisherPublisher> sources,
        int prefetch)
```
    Returns a Flowable that emits the items emitted by each of the Publishers emitted by the source Publisher, one after the other, without interleaving them.
    
    Backpressure:
    
    The operator honors backpressure from downstream. Both the outer and inner Publisher sources are expected to honor backpressure as well. If the outer violates this, a MissingBackpressureException is signaled. If any of the inner Publishers violates this, it may throw an IllegalStateException when an inner Publisher completes.
    
    Scheduler:
    
    concat does not operate by default on a particular Scheduler.
    
    Type Parameters:
    
    T - the common element base type
    
    Parameters:
    
    sources - a Publisher that emits Publishers
    
    prefetch - the number of Publishers to prefetch from the sources sequence.
    
    Returns:
    
    a Flowable that emits items all of the items emitted by the Publishers emitted by Publishers, one after the other, without interleaving them
    
    See Also:
    
    ReactiveX operators documentation: Concat
  - concat
```
@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static  Flowable concat(Publisher source1,
        Publisher source2)
```
    Returns a Flowable that emits the items emitted by two Publishers, one after the other, without interleaving them.
    
    Backpressure:
    
    The operator honors backpressure from downstream. The Publisher sources are expected to honor backpressure as well. If any of the source Publishers violate this, it may throw an IllegalStateException when the source Publisher completes.
    
    Scheduler:
    
    concat does not operate by default on a particular Scheduler.
    
    Type Parameters:
    
    T - the common element base type
    
    Parameters:
    
    source1 - a Publisher to be concatenated
    
    source2 - a Publisher to be concatenated
    
    Returns:
    
    a Flowable that emits items emitted by the two source Publishers, one after the other, without interleaving them
    
    See Also:
    
    ReactiveX operators documentation: Concat
  - concat
```
@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static  Flowable concat(Publisher source1,
        Publisher source2,
        Publisher source3)
```
    Returns a Flowable that emits the items emitted by three Publishers, one after the other, without interleaving them.
    
    Backpressure:
    
    The operator honors backpressure from downstream. The Publisher sources are expected to honor backpressure as well. If any of the source Publishers violate this, it may throw an IllegalStateException when the source Publisher completes.
    
    Scheduler:
    
    concat does not operate by default on a particular Scheduler.
    
    Type Parameters:
    
    T - the common element base type
    
    Parameters:
    
    source1 - a Publisher to be concatenated
    
    source2 - a Publisher to be concatenated
    
    source3 - a Publisher to be concatenated
    
    Returns:
    
    a Flowable that emits items emitted by the three source Publishers, one after the other, without interleaving them
    
    See Also:
    
    ReactiveX operators documentation: Concat
  - concat
```
@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static  Flowable concat(Publisher source1,
        Publisher source2,
        Publisher source3,
        Publisher source4)
```
    Returns a Flowable that emits the items emitted by four Publishers, one after the other, without interleaving them.
    
    Backpressure:
    
    The operator honors backpressure from downstream. The Publisher sources are expected to honor backpressure as well. If any of the source Publishers violate this, it may throw an IllegalStateException when the source Publisher completes.
    
    Scheduler:
    
    concat does not operate by default on a particular Scheduler.
    
    Type Parameters:
    
    T - the common element base type
    
    Parameters:
    
    source1 - a Publisher to be concatenated
    
    source2 - a Publisher to be concatenated
    
    source3 - a Publisher to be concatenated
    
    source4 - a Publisher to be concatenated
    
    Returns:
    
    a Flowable that emits items emitted by the four source Publishers, one after the other, without interleaving them
    
    See Also:
    
    ReactiveX operators documentation: Concat
  - concatArray
```
@CheckReturnValue
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static  Flowable concatArray(Publisher... sources)
```
    Concatenates a variable number of Publisher sources.
    Note: named this way because of overload conflict with concat(Publisher).
    
    Backpressure:
    
    The operator honors backpressure from downstream. The Publisher sources are expected to honor backpressure as well. If any of the source Publishers violate this, it may throw an IllegalStateException when the source Publisher completes.
    
    Scheduler:
    
    concatArray does not operate by default on a particular Scheduler.
    
    Type Parameters:
    
    T - the common base value type
    
    Parameters:
    
    sources - the array of sources
    
    Returns:
    
    the new Publisher instance
    
    Throws:
    
    NullPointerException - if sources is null
  - concatArrayDelayError
```
@CheckReturnValue
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static  Flowable concatArrayDelayError(Publisher... sources)
```
    Concatenates a variable number of Publisher sources and delays errors from any of them till all terminate.
    
    Backpressure:
    
    The operator honors backpressure from downstream. The Publisher sources are expected to honor backpressure as well. If any of the source Publishers violate this, it may throw an IllegalStateException when the source Publisher completes.
    
    Scheduler:
    
    concatArrayDelayError does not operate by default on a particular Scheduler.
    
    Type Parameters:
    
    T - the common base value type
    
    Parameters:
    
    sources - the array of sources
    
    Returns:
    
    the new Flowable instance
    
    Throws:
    
    NullPointerException - if sources is null
  - concatArrayEager
```
@CheckReturnValue
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static  Flowable concatArrayEager(Publisher... sources)
```
    Concatenates an array of Publishers eagerly into a single stream of values.
    
    Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the source Publishers. The operator buffers the values emitted by these Publishers and then drains them in order, each one after the previous one completes.
    
    Backpressure:
    
    The operator honors backpressure from downstream. The Publisher sources are expected to honor backpressure as well. If any of the source Publishers violate this, the operator will signal a MissingBackpressureException.
    
    Scheduler:
    
    This method does not operate by default on a particular Scheduler.
    
    Type Parameters:
    
    T - the value type
    
    Parameters:
    
    sources - an array of Publishers that need to be eagerly concatenated
    
    Returns:
    
    the new Publisher instance with the specified concatenation behavior
    
    Since:
    
    2.0
  - concatArrayEager
```
@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static  Flowable concatArrayEager(int maxConcurrency,
        int prefetch,
        Publisher... sources)
```
    Concatenates an array of Publishers eagerly into a single stream of values.
    
    Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the source Publishers. The operator buffers the values emitted by these Publishers and then drains them in order, each one after the previous one completes.
    
    Backpressure:
    
    The operator honors backpressure from downstream. The Publisher sources are expected to honor backpressure as well. If any of the source Publishers violate this, the operator will signal a MissingBackpressureException.
    
    Scheduler:
    
    This method does not operate by default on a particular Scheduler.
    
    Type Parameters:
    
    T - the value type
    
    Parameters:
    
    sources - an array of Publishers that need to be eagerly concatenated
    
    maxConcurrency - the maximum number of concurrent subscriptions at a time, Integer.MAX_VALUE is interpreted as an indication to subscribe to all sources at once
    
    prefetch - the number of elements to prefetch from each Publisher source
    
    Returns:
    
    the new Publisher instance with the specified concatenation behavior
    
    Since:
    
    2.0
  - concatArrayEagerDelayError
```
@CheckReturnValue
 @SchedulerSupport(value="none")
 @BackpressureSupport(value=FULL)
public static  Flowable concatArrayEagerDelayError(Publisher... sources)
```
    Concatenates an array of Publishers eagerly into a single stream of values and delaying any errors until all sources terminate.
    
    Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the source Publishers. The operator buffers the values emitted by these Publishers and then drains them in order, each one after the previous one completes.
    
    Backpressure:
    
    The operator honors backpressure from downstream. The Publisher sources are expected to honor backpressure as well. If any of the source Publishers violate this, the operator will signal a MissingBackpressureException.
    
    Scheduler:
    
    This method does not operate by default on a particular Scheduler.
    
    Type Parameters:
    
    T - the value type
    
    Parameters:
    
    sources - an array of Publishers that need to be eagerly concatenated
    
    Returns:
    
    the new Flowable instance with the specified concatenation behavior
    
    Since:
    
    2.2.1 - experimental
  - concatArrayEagerDelayError
```
@CheckReturnValue
 @SchedulerSupport(value="none")
 @BackpressureSupport(value=FULL)
public static  Flowable concatArrayEagerDelayError(int maxConcurrency,
        int prefetch,
        Publisher... sources)
```
    Concatenates an array of Publishers eagerly into a single stream of values and delaying any errors until all sources terminate.
    
    Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the source Publishers. The operator buffers the values emitted by these Publishers and then drains them in order, each one after the previous one completes.
    
    Backpressure:
    
    The operator honors backpressure from downstream. The Publisher sources are expected to honor backpressure as well. If any of the source Publishers violate this, the operator will signal a MissingBackpressureException.
    
    Scheduler:
    
    This method does not operate by default on a particular Scheduler.
    
    Type Parameters:
    
    T - the value type
    
    Parameters:
    
    sources - an array of Publishers that need to be eagerly concatenated
    
    maxConcurrency - the maximum number of concurrent subscriptions at a time, Integer.MAX_VALUE is interpreted as indication to subscribe to all sources at once
    
    prefetch - the number of elements to prefetch from each Publisher source
    
    Returns:
    
    the new Flowable instance with the specified concatenation behavior
    
    Since:
    
    2.2.1 - experimental
  - concatDelayError
```
@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static  Flowable concatDelayError(IterablePublisher> sources)
```
    Concatenates the Iterable sequence of Publishers into a single sequence by subscribing to each Publisher, one after the other, one at a time and delays any errors till the all inner Publishers terminate.
    
    Backpressure:
    
    The operator honors backpressure from downstream. Both the outer and inner Publisher sources are expected to honor backpressure as well. If the outer violates this, a MissingBackpressureException is signaled. If any of the inner Publishers violates this, it may throw an IllegalStateException when an inner Publisher completes.
    
    Scheduler:
    
    concatDelayError does not operate by default on a particular Scheduler.
    
    Type Parameters:
    
    T - the common element base type
    
    Parameters:
    
    sources - the Iterable sequence of Publishers
    
    Returns:
    
    the new Publisher with the concatenating behavior
  - concatDelayError
```
@CheckReturnValue
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static  Flowable concatDelayError(PublisherPublisher> sources)
```
    Concatenates the Publisher sequence of Publishers into a single sequence by subscribing to each inner Publisher, one after the other, one at a time and delays any errors till the all inner and the outer Publishers terminate.
    
    Backpressure:
    
    concatDelayError fully supports backpressure.
    
    Scheduler:
    
    concatDelayError does not operate by default on a particular Scheduler.
    
    Type Parameters:
    
    T - the common element base type
    
    Parameters:
    
    sources - the Publisher sequence of Publishers
    
    Returns:
    
    the new Publisher with the concatenating behavior
  - concatDelayError
```
@CheckReturnValue
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static  Flowable concatDelayError(PublisherPublisher> sources,
        int prefetch,
        boolean tillTheEnd)
```
    Concatenates the Publisher sequence of Publishers into a single sequence by subscribing to each inner Publisher, one after the other, one at a time and delays any errors till the all inner and the outer Publishers terminate.
    
    Backpressure:
    
    concatDelayError fully supports backpressure.
    
    Scheduler:
    
    concatDelayError does not operate by default on a particular Scheduler.
    
    Type Parameters:
    
    T - the common element base type
    
    Parameters:
    
    sources - the Publisher sequence of Publishers
    
    prefetch - the number of elements to prefetch from the outer Publisher
    
    tillTheEnd - if true exceptions from the outer and all inner Publishers are delayed to the end if false, exception from the outer Publisher is delayed till the current Publisher terminates
    
    Returns:
    
    the new Publisher with the concatenating behavior
  - concatEager
```
@CheckReturnValue
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static  Flowable concatEager(PublisherPublisher> sources)
```
    Concatenates a Publisher sequence of Publishers eagerly into a single stream of values.
    Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the emitted source Publishers as they are observed. The operator buffers the values emitted by these Publishers and then drains them in order, each one after the previous one completes.
    
    Backpressure:
    
    Backpressure is honored towards the downstream and both the outer and inner Publishers are expected to support backpressure. Violating this assumption, the operator will signal MissingBackpressureException.
    
    Scheduler:
    
    This method does not operate by default on a particular Scheduler.
    
    Type Parameters:
    
    T - the value type
    
    Parameters:
    
    sources - a sequence of Publishers that need to be eagerly concatenated
    
    Returns:
    
    the new Publisher instance with the specified concatenation behavior
    
    Since:
    
    2.0
  - concatEager
```
@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static  Flowable concatEager(PublisherPublisher> sources,
        int maxConcurrency,
        int prefetch)
```
    Concatenates a Publisher sequence of Publishers eagerly into a single stream of values.
    Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the emitted source Publishers as they are observed. The operator buffers the values emitted by these Publishers and then drains them in order, each one after the previous one completes.
    
    Backpressure:
    
    Backpressure is honored towards the downstream and both the outer and inner Publishers are expected to support backpressure. Violating this assumption, the operator will signal MissingBackpressureException.
    
    Scheduler:
    
    This method does not operate by default on a particular Scheduler.
    
    Type Parameters:
    
    T - the value type
    
    Parameters:
    
    sources - a sequence of Publishers that need to be eagerly concatenated
    
    maxConcurrency - the maximum number of concurrently running inner Publishers; Integer.MAX_VALUE is interpreted as all inner Publishers can be active at the same time
    
    prefetch - the number of elements to prefetch from each inner Publisher source
    
    Returns:
    
    the new Publisher instance with the specified concatenation behavior
    
    Since:
    
    2.0
  - concatEager
```
@CheckReturnValue
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static  Flowable concatEager(IterablePublisher> sources)
```
    Concatenates a sequence of Publishers eagerly into a single stream of values.
    Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the source Publishers. The operator buffers the values emitted by these Publishers and then drains them in order, each one after the previous one completes.
    
    Backpressure:
    
    Backpressure is honored towards the downstream and the inner Publishers are expected to support backpressure. Violating this assumption, the operator will signal MissingBackpressureException.
    
    Scheduler:
    
    This method does not operate by default on a particular Scheduler.
    
    Type Parameters:
    
    T - the value type
    
    Parameters:
    
    sources - a sequence of Publishers that need to be eagerly concatenated
    
    Returns:
    
    the new Publisher instance with the specified concatenation behavior
    
    Since:
    
    2.0
  - concatEager
```
@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static  Flowable concatEager(IterablePublisher> sources,
        int maxConcurrency,
        int prefetch)
```
    Concatenates a sequence of Publishers eagerly into a single stream of values.
    Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the source Publishers. The operator buffers the values emitted by these Publishers and then drains them in order, each one after the previous one completes.
    
    Backpressure:
    
    Backpressure is honored towards the downstream and both the outer and inner Publishers are expected to support backpressure. Violating this assumption, the operator will signal MissingBackpressureException.
    
    Scheduler:
    
    This method does not operate by default on a particular Scheduler.
    
    Type Parameters:
    
    T - the value type
    
    Parameters:
    
    sources - a sequence of Publishers that need to be eagerly concatenated
    
    maxConcurrency - the maximum number of concurrently running inner Publishers; Integer.MAX_VALUE is interpreted as all inner Publishers can be active at the same time
    
    prefetch - the number of elements to prefetch from each inner Publisher source
    
    Returns:
    
    the new Publisher instance with the specified concatenation behavior
    
    Since:
    
    2.0
  - create
```
@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=SPECIAL)
 @SchedulerSupport(value="none")
public static  Flowable create(FlowableOnSubscribe source,
        BackpressureStrategy mode)
```
    Provides an API (via a cold Flowable) that bridges the reactive world with the callback-style, generally non-backpressured world.
    Example:
```
 Flowable.create(emitter -> {
     Callback listener = new Callback() {
         @Override
         public void onEvent(Event e) {
             emitter.onNext(e);
             if (e.isLast()) {
                 emitter.onComplete();
             }
         }

         @Override
         public void onFailure(Exception e) {
             emitter.onError(e);
         }
     };

     AutoCloseable c = api.someMethod(listener);

     emitter.setCancellable(c::close);

 }, BackpressureStrategy.BUFFER);
 
```
    You should call the FlowableEmitter onNext, onError and onComplete methods in a serialized fashion. The rest of its methods are thread-safe.
    
    Backpressure:
    
    The backpressure behavior is determined by the mode parameter.
    
    Scheduler:
    
    create does not operate by default on a particular Scheduler.
    Type Parameters:
    
    T - the element type
    
    Parameters:
    
    source - the emitter that is called when a Subscriber subscribes to the returned Flowable
    
    mode - the backpressure mode to apply if the downstream Subscriber doesn't request (fast) enough
    
    Returns:
    
    the new Flowable instance
    
    See Also:
    
    FlowableOnSubscribe, BackpressureStrategy, Cancellable
  - defer
```
@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=PASS_THROUGH)
 @SchedulerSupport(value="none")
public static  Flowable defer(CallablePublisher> supplier)
```
    Returns a Flowable that calls a Publisher factory to create a Publisher for each new Subscriber that subscribes. That is, for each subscriber, the actual Publisher that subscriber observes is determined by the factory function.
    
    The defer Subscriber allows you to defer or delay emitting items from a Publisher until such time as a Subscriber subscribes to the Publisher. This allows a Subscriber to easily obtain updates or a refreshed version of the sequence.
    
    Backpressure:
    
    The operator itself doesn't interfere with backpressure which is determined by the Publisher returned by the supplier.
    
    Scheduler:
    
    defer does not operate by default on a particular Scheduler.
    
    Type Parameters:
    
    T - the type of the items emitted by the Publisher
    
    Parameters:
    
    supplier - the Publisher factory function to invoke for each Subscriber that subscribes to the resulting Publisher
    
    Returns:
    
    a Flowable whose Subscribers' subscriptions trigger an invocation of the given Publisher factory function
    
    See Also:
    
    ReactiveX operators documentation: Defer
  - empty
```
@CheckReturnValue
 @BackpressureSupport(value=PASS_THROUGH)
 @SchedulerSupport(value="none")
public static  Flowable empty()
```
    Returns a Flowable that emits no items to the Subscriber and immediately invokes its onComplete method.
    
    Backpressure:
    
    This source doesn't produce any elements and effectively ignores downstream backpressure.
    
    Scheduler:
    
    empty does not operate by default on a particular Scheduler.
    
    Type Parameters:
    
    T - the type of the items (ostensibly) emitted by the Publisher
    
    Returns:
    
    a Flowable that emits no items to the Subscriber but immediately invokes the Subscriber's onComplete method
    
    See Also:
    
    ReactiveX operators documentation: Empty
  - error
```
@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=PASS_THROUGH)
 @SchedulerSupport(value="none")
public static  Flowable error(CallableThrowable> supplier)
```
    Returns a Flowable that invokes a Subscriber's onError method when the Subscriber subscribes to it.
    
    Backpressure:
    
    This source doesn't produce any elements and effectively ignores downstream backpressure.
    
    Scheduler:
    
    error does not operate by default on a particular Scheduler.
    
    Type Parameters:
    
    T - the type of the items (ostensibly) emitted by the Publisher
    
    Parameters:
    
    supplier - a Callable factory to return a Throwable for each individual Subscriber
    
    Returns:
    
    a Flowable that invokes the Subscriber's onError method when the Subscriber subscribes to it
    
    See Also:
    
    ReactiveX operators documentation: Throw
  - error
```
@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=PASS_THROUGH)
 @SchedulerSupport(value="none")
public static  Flowable error(Throwable throwable)
```
    Returns a Flowable that invokes a Subscriber's onError method when the Subscriber subscribes to it.
    
    Backpressure:
    
    This source doesn't produce any elements and effectively ignores downstream backpressure.
    
    Scheduler:
    
    error does not operate by default on a particular Scheduler.
    
    Type Parameters:
    
    T - the type of the items (ostensibly) emitted by the Publisher
    
    Parameters:
    
    throwable - the particular Throwable to pass to onError
    
    Returns:
    
    a Flowable that invokes the Subscriber's onError method when the Subscriber subscribes to it
    
    See Also:
    
    ReactiveX operators documentation: Throw
  - fromArray
```
@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static  Flowable fromArray(T... items)
```
    Converts an Array into a Publisher that emits the items in the Array.
    
    Backpressure:
    
    The operator honors backpressure from downstream and iterates the given array on demand (i.e., when requested).
    
    Scheduler:
    
    fromArray does not operate by default on a particular Scheduler.
    
    Type Parameters:
    
    T - the type of items in the Array and the type of items to be emitted by the resulting Publisher
    
    Parameters:
    
    items - the array of elements
    
    Returns:
    
    a Flowable that emits each item in the source Array
    
    See Also:
    
    ReactiveX operators documentation: From
  - fromCallable
```
@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static  Flowable fromCallable(Callable supplier)
```
    Returns a Flowable that, when a Subscriber subscribes to it, invokes a function you specify and then emits the value returned from that function.
    
    This allows you to defer the execution of the function you specify until a Subscriber subscribes to the Publisher. That is to say, it makes the function "lazy."
    
    Backpressure:
    
    The operator honors backpressure from downstream.
    
    Scheduler:
    
    fromCallable does not operate by default on a particular Scheduler.
    
    Error handling:
    
    If the Callable throws an exception, the respective Throwable is delivered to the downstream via Subscriber.onError(Throwable), except when the downstream has canceled this Flowable source. In this latter case, the Throwable is delivered to the global error handler via RxJavaPlugins.onError(Throwable) as an UndeliverableException.
    
    Type Parameters:
    
    T - the type of the item emitted by the Publisher
    
    Parameters:
    
    supplier - a function, the execution of which should be deferred; fromCallable will invoke this function only when a Subscriber subscribes to the Publisher that fromCallable returns
    
    Returns:
    
    a Flowable whose Subscribers' subscriptions trigger an invocation of the given function
    
    Since:
    
    2.0
    
    See Also:
    
    defer(Callable)
  - fromFuture
```
@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static  Flowable fromFuture(Future future)
```
    Converts a Future into a Publisher.
    
    You can convert any object that supports the Future interface into a Publisher that emits the return value of the Future.get() method of that object by passing the object into the from method.
    Important note: This Publisher is blocking on the thread it gets subscribed on; you cannot cancel it.
    Unlike 1.x, canceling the Flowable won't cancel the future. If necessary, one can use composition to achieve the cancellation effect: futurePublisher.doOnCancel(() -> future.cancel(true));.
    
    Backpressure:
    
    The operator honors backpressure from downstream.
    
    Scheduler:
    
    fromFuture does not operate by default on a particular Scheduler.
    
    Type Parameters:
    
    T - the type of object that the Future returns, and also the type of item to be emitted by the resulting Publisher
    
    Parameters:
    
    future - the source Future
    
    Returns:
    
    a Flowable that emits the item from the source Future
    
    See Also:
    
    ReactiveX operators documentation: From
  - fromFuture
```
@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static  Flowable fromFuture(Future future,
        long timeout,
        TimeUnit unit)
```
    Converts a Future into a Publisher, with a timeout on the Future.
    
    You can convert any object that supports the Future interface into a Publisher that emits the return value of the Future.get() method of that object by passing the object into the fromFuture method.
    Unlike 1.x, canceling the Flowable won't cancel the future. If necessary, one can use composition to achieve the cancellation effect: futurePublisher.doOnCancel(() -> future.cancel(true));.
    Important note: This Publisher is blocking on the thread it gets subscribed on; you cannot cancel it.
    
    Backpressure:
    
    The operator honors backpressure from downstream.
    
    Scheduler:
    
    fromFuture does not operate by default on a particular Scheduler.
    
    Type Parameters:
    
    T - the type of object that the Future returns, and also the type of item to be emitted by the resulting Publisher
    
    Parameters:
    
    future - the source Future
    
    timeout - the maximum time to wait before calling get
    
    unit - the TimeUnit of the timeout argument
    
    Returns:
    
    a Flowable that emits the item from the source Future
    
    See Also:
    
    ReactiveX operators documentation: From
  - fromFuture
```
@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="custom")
public static  Flowable fromFuture(Future future,
        long timeout,
        TimeUnit unit,
        Scheduler scheduler)
```
    Converts a Future into a Publisher, with a timeout on the Future.
    
    You can convert any object that supports the Future interface into a Publisher that emits the return value of the Future.get() method of that object by passing the object into the from method.
    Unlike 1.x, canceling the Flowable won't cancel the future. If necessary, one can use composition to achieve the cancellation effect: futurePublisher.doOnCancel(() -> future.cancel(true));.
    Important note: This Publisher is blocking; you cannot cancel it.
    
    Backpressure:
    
    The operator honors backpressure from downstream.
    
    Scheduler:
    
    fromFuture does not operate by default on a particular Scheduler.
    
    Type Parameters:
    
    T - the type of object that the Future returns, and also the type of item to be emitted by the resulting Publisher
    
    Parameters:
    
    future - the source Future
    
    timeout - the maximum time to wait before calling get
    
    unit - the TimeUnit of the timeout argument
    
    scheduler - the Scheduler to wait for the Future on. Use a Scheduler such as Schedulers.io() that can block and wait on the Future
    
    Returns:
    
    a Flowable that emits the item from the source Future
    
    See Also:
    
    ReactiveX operators documentation: From
  - fromFuture
```
@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="custom")
public static  Flowable fromFuture(Future future,
        Scheduler scheduler)
```
    Converts a Future, operating on a specified Scheduler, into a Publisher.
    
    You can convert any object that supports the Future interface into a Publisher that emits the return value of the Future.get() method of that object by passing the object into the from method.
    Unlike 1.x, canceling the Flowable won't cancel the future. If necessary, one can use composition to achieve the cancellation effect: futurePublisher.doOnCancel(() -> future.cancel(true));.
    
    Backpressure:
    
    The operator honors backpressure from downstream.
    
    Scheduler:
    
    You specify which Scheduler this operator will use.
    
    Type Parameters:
    
    T - the type of object that the Future returns, and also the type of item to be emitted by the resulting Publisher
    
    Parameters:
    
    future - the source Future
    
    scheduler - the Scheduler to wait for the Future on. Use a Scheduler such as Schedulers.io() that can block and wait on the Future
    
    Returns:
    
    a Flowable that emits the item from the source Future
    
    See Also:
    
    ReactiveX operators documentation: From
  - fromIterable
```
@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static  Flowable fromIterable(Iterable source)
```
    Converts an Iterable sequence into a Publisher that emits the items in the sequence.
    
    Backpressure:
    
    The operator honors backpressure from downstream and iterates the given iterable on demand (i.e., when requested).
    
    Scheduler:
    
    fromIterable does not operate by default on a particular Scheduler.
    
    Type Parameters:
    
    T - the type of items in the Iterable sequence and the type of items to be emitted by the resulting Publisher
    
    Parameters:
    
    source - the source Iterable sequence
    
    Returns:
    
    a Flowable that emits each item in the source Iterable sequence
    
    See Also:
    
    ReactiveX operators documentation: From
  - fromPublisher
```
@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=PASS_THROUGH)
 @SchedulerSupport(value="none")
public static  Flowable fromPublisher(Publisher source)
```
    Converts an arbitrary Reactive Streams Publisher into a Flowable if not already a Flowable.
    The Publisher must follow the Reactive Streams specification. Violating the specification may result in undefined behavior.
    If possible, use create(FlowableOnSubscribe, BackpressureStrategy) to create a source-like Flowable instead.
    Note that even though Publisher appears to be a functional interface, it is not recommended to implement it through a lambda as the specification requires state management that is not achievable with a stateless lambda.
    
    Backpressure:
    
    The operator is a pass-through for backpressure and its behavior is determined by the backpressure behavior of the wrapped publisher.
    
    Scheduler:
    
    fromPublisher does not operate by default on a particular Scheduler.
    
    Type Parameters:
    
    T - the value type of the flow
    
    Parameters:
    
    source - the Publisher to convert
    
    Returns:
    
    the new Flowable instance
    
    Throws:
    
    NullPointerException - if the source Publisher is null
    
    See Also:
    
    create(FlowableOnSubscribe, BackpressureStrategy)
  - generate
```
@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static  Flowable generate(Consumer<Emitter> generator)
```
    Returns a cold, synchronous, stateless and backpressure-aware generator of values.
    Note that the Emitter.onNext(T), Emitter.onError(java.lang.Throwable) and Emitter.onComplete() methods provided to the function via the Emitter instance should be called synchronously, never concurrently and only while the function body is executing. Calling them from multiple threads or outside the function call is not supported and leads to an undefined behavior.
    
    Backpressure:
    
    The operator honors downstream backpressure.
    
    Scheduler:
    
    generate does not operate by default on a particular Scheduler.
    
    Type Parameters:
    
    T - the generated value type
    
    Parameters:
    
    generator - the Consumer called whenever a particular downstream Subscriber has requested a value. The callback then should call onNext, onError or onComplete to signal a value or a terminal event. Signaling multiple onNext in a call will make the operator signal IllegalStateException.
    
    Returns:
    
    the new Flowable instance
  - generate
```
@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static  Flowable generate(Callable initialState,
        BiConsumerEmitter> generator)
```
    Returns a cold, synchronous, stateful and backpressure-aware generator of values.
    Note that the Emitter.onNext(T), Emitter.onError(java.lang.Throwable) and Emitter.onComplete() methods provided to the function via the Emitter instance should be called synchronously, never concurrently and only while the function body is executing. Calling them from multiple threads or outside the function call is not supported and leads to an undefined behavior.
    
    Backpressure:
    
    The operator honors downstream backpressure.
    
    Scheduler:
    
    generate does not operate by default on a particular Scheduler.
    
    Type Parameters:
    
    S - the type of the per-Subscriber state
    
    T - the generated value type
    
    Parameters:
    
    initialState - the Callable to generate the initial state for each Subscriber
    
    generator - the Consumer called with the current state whenever a particular downstream Subscriber has requested a value. The callback then should call onNext, onError or onComplete to signal a value or a terminal event. Signaling multiple onNext in a call will make the operator signal IllegalStateException.
    
    Returns:
    
    the new Flowable instance
  generate
  
  @CheckReturnValue @NonNull @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public static  Flowable generate(Callable ~~initialState, BiConsumerEmitter> generator, Consumer disposeState)~~
  
  Returns a cold, synchronous, stateful and backpressure-aware generator of values.
  Note that the Emitter.onNext(T), Emitter.onError(java.lang.Throwable) and Emitter.onComplete() methods provided to the function via the Emitter instance should be called synchronously, never concurrently and only while the function body is executing. Calling them from multiple threads or outside the function call is not supported and leads to an undefined behavior.
  
  Backpressure:
  
  The operator honors downstream backpressure.
  
  Scheduler:
  
  generate does not operate by default on a particular Scheduler.
  
  Type Parameters:
  
  S - the type of the per-Subscriber state
  
  T - the generated value type
  
  Parameters:
  
  initialState - the Callable to generate the initial state for each Subscriber
  
  generator - the Consumer called with the current state whenever a particular downstream Subscriber has requested a value. The callback then should call onNext, onError or onComplete to signal a value or a terminal event. Signaling multiple onNext in a call will make the operator signal IllegalStateException.
  
  disposeState - the Consumer that is called with the current state when the generator terminates the sequence or it gets canceled
  
  Returns:
  
  the new Flowable instance
  
  generate
  
  @CheckReturnValue @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public static  Flowable generate(Callable ~~initialState, BiFunctionEmitter,S> generator)~~
  
  Returns a cold, synchronous, stateful and backpressure-aware generator of values.
  Note that the Emitter.onNext(T), Emitter.onError(java.lang.Throwable) and Emitter.onComplete() methods provided to the function via the Emitter instance should be called synchronously, never concurrently and only while the function body is executing. Calling them from multiple threads or outside the function call is not supported and leads to an undefined behavior.
  
  Backpressure:
  
  The operator honors downstream backpressure.
  
  Scheduler:
  
  generate does not operate by default on a particular Scheduler.
  
  Type Parameters:
  
  S - the type of the per-Subscriber state
  
  T - the generated value type
  
  Parameters:
  
  initialState - the Callable to generate the initial state for each Subscriber
  
  generator - the Function called with the current state whenever a particular downstream Subscriber has requested a value. The callback then should call onNext, onError or onComplete to signal a value or a terminal event and should return a (new) state for the next invocation. Signaling multiple onNext in a call will make the operator signal IllegalStateException.
  
  Returns:
  
  the new Flowable instance
  
  generate
  
  @CheckReturnValue @NonNull @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public static  Flowable generate(Callable ~~initialState, BiFunctionEmitter,S> generator, Consumer disposeState)~~
  
  Returns a cold, synchronous, stateful and backpressure-aware generator of values.
  Note that the Emitter.onNext(T), Emitter.onError(java.lang.Throwable) and Emitter.onComplete() methods provided to the function via the Emitter instance should be called synchronously, never concurrently and only while the function body is executing. Calling them from multiple threads or outside the function call is not supported and leads to an undefined behavior.
  
  Backpressure:
  
  The operator honors downstream backpressure.
  
  Scheduler:
  
  generate does not operate by default on a particular Scheduler.
  
  Type Parameters:
  
  S - the type of the per-Subscriber state
  
  T - the generated value type
  
  Parameters:
  
  initialState - the Callable to generate the initial state for each Subscriber
  
  generator - the Function called with the current state whenever a particular downstream Subscriber has requested a value. The callback then should call onNext, onError or onComplete to signal a value or a terminal event and should return a (new) state for the next invocation. Signaling multiple onNext in a call will make the operator signal IllegalStateException.
  
  disposeState - the Consumer that is called with the current state when the generator terminates the sequence or it gets canceled
  
  Returns:
  
  the new Flowable instance
  
  interval
  
  @CheckReturnValue @BackpressureSupport(value=ERROR) @SchedulerSupport(value="io.reactivex:computation") public static Flowable<Long> interval(long initialDelay, long period, TimeUnit unit)
  
  Returns a Flowable that emits a 0L after the initialDelay and ever-increasing numbers after each period of time thereafter.
  
  Backpressure:
  
  The operator generates values based on time and ignores downstream backpressure which may lead to MissingBackpressureException at some point in the chain. Consumers should consider applying one of the onBackpressureXXX operators as well.
  
  Scheduler:
  
  interval operates by default on the computation Scheduler.
  
  Parameters:
  
  initialDelay - the initial delay time to wait before emitting the first value of 0L
  
  period - the period of time between emissions of the subsequent numbers
  
  unit - the time unit for both initialDelay and period
  
  Returns:
  
  a Flowable that emits a 0L after the initialDelay and ever-increasing numbers after each period of time thereafter
  
  Since:
  
  1.0.12
  
  See Also:
  
  ReactiveX operators documentation: Interval
  
  interval
  
  @CheckReturnValue @NonNull @BackpressureSupport(value=ERROR) @SchedulerSupport(value="custom") public static Flowable<Long> interval(long initialDelay, long period, TimeUnit unit, Scheduler scheduler)
  
  Returns a Flowable that emits a 0L after the initialDelay and ever-increasing numbers after each period of time thereafter, on a specified Scheduler.
  
  Backpressure:
  
  The operator generates values based on time and ignores downstream backpressure which may lead to MissingBackpressureException at some point in the chain. Consumers should consider applying one of the onBackpressureXXX operators as well.
  
  Scheduler:
  
  You specify which Scheduler this operator will use.
  
  Parameters:
  
  initialDelay - the initial delay time to wait before emitting the first value of 0L
  
  period - the period of time between emissions of the subsequent numbers
  
  unit - the time unit for both initialDelay and period
  
  scheduler - the Scheduler on which the waiting happens and items are emitted
  
  Returns:
  
  a Flowable that emits a 0L after the initialDelay and ever-increasing numbers after each period of time thereafter, while running on the given Scheduler
  
  Since:
  
  1.0.12
  
  See Also:
  
  ReactiveX operators documentation: Interval
  
  interval
  
  @CheckReturnValue @BackpressureSupport(value=ERROR) @SchedulerSupport(value="io.reactivex:computation") public static Flowable<Long> interval(long period, TimeUnit unit)
  
  Returns a Flowable that emits a sequential number every specified interval of time.
  
  Backpressure:
  
  The operator signals a MissingBackpressureException if the downstream is not ready to receive the next value.
  
  Scheduler:
  
  interval operates by default on the computation Scheduler.
  
  Parameters:
  
  period - the period size in time units (see below)
  
  unit - time units to use for the interval size
  
  Returns:
  
  a Flowable that emits a sequential number each time interval
  
  See Also:
  
  ReactiveX operators documentation: Interval
  
  interval
  
  @CheckReturnValue @BackpressureSupport(value=ERROR) @SchedulerSupport(value="custom") public static Flowable<Long> interval(long period, TimeUnit unit, Scheduler scheduler)
  
  Returns a Flowable that emits a sequential number every specified interval of time, on a specified Scheduler.
  
  Backpressure:
  
  The operator generates values based on time and ignores downstream backpressure which may lead to MissingBackpressureException at some point in the chain. Consumers should consider applying one of the onBackpressureXXX operators as well.
  
  Scheduler:
  
  You specify which Scheduler this operator will use.
  
  Parameters:
  
  period - the period size in time units (see below)
  
  unit - time units to use for the interval size
  
  scheduler - the Scheduler to use for scheduling the items
  
  Returns:
  
  a Flowable that emits a sequential number each time interval
  
  See Also:
  
  ReactiveX operators documentation: Interval
  
  intervalRange
  
  @CheckReturnValue @BackpressureSupport(value=ERROR) @SchedulerSupport(value="io.reactivex:computation") public static Flowable<Long> intervalRange(long start, long count, long initialDelay, long period, TimeUnit unit)
  
  Signals a range of long values, the first after some initial delay and the rest periodically after.
  The sequence completes immediately after the last value (start + count - 1) has been reached.
  
  Backpressure:
  
  The operator signals a MissingBackpressureException if the downstream can't keep up.
  
  Scheduler:
  
  intervalRange by default operates on the computation Scheduler.
  
  Parameters:
  
  start - that start value of the range
  
  count - the number of values to emit in total, if zero, the operator emits an onComplete after the initial delay.
  
  initialDelay - the initial delay before signaling the first value (the start)
  
  period - the period between subsequent values
  
  unit - the unit of measure of the initialDelay and period amounts
  
  Returns:
  
  the new Flowable instance
  
  intervalRange
  
  @CheckReturnValue @NonNull @BackpressureSupport(value=ERROR) @SchedulerSupport(value="custom") public static Flowable<Long> intervalRange(long start, long count, long initialDelay, long period, TimeUnit unit, Scheduler scheduler)
  
  Signals a range of long values, the first after some initial delay and the rest periodically after.
  The sequence completes immediately after the last value (start + count - 1) has been reached.
  
  Backpressure:
  
  The operator signals a MissingBackpressureException if the downstream can't keep up.
  
  Scheduler:
  
  you provide the Scheduler.
  
  Parameters:
  
  start - that start value of the range
  
  count - the number of values to emit in total, if zero, the operator emits an onComplete after the initial delay.
  
  initialDelay - the initial delay before signaling the first value (the start)
  
  period - the period between subsequent values
  
  unit - the unit of measure of the initialDelay and period amounts
  
  scheduler - the target scheduler where the values and terminal signals will be emitted
  
  Returns:
  
  the new Flowable instance
  
  just
  
  @CheckReturnValue @NonNull @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public static  Flowable just(T item)
  
  Returns a Flowable that signals the given (constant reference) item and then completes.
  
  Note that the item is taken and re-emitted as is and not computed by any means by just. Use fromCallable(Callable) to generate a single item on demand (when Subscribers subscribe to it).
  See the multi-parameter overloads of just to emit more than one (constant reference) items one after the other. Use fromArray(Object...) to emit an arbitrary number of items that are known upfront.
  To emit the items of an Iterable sequence (such as a List), use fromIterable(Iterable).
  
  Backpressure:
  
  The operator honors backpressure from downstream.
  
  Scheduler:
  
  just does not operate by default on a particular Scheduler.
  
  Type Parameters:
  
  T - the type of that item
  
  Parameters:
  
  item - the item to emit
  
  Returns:
  
  a Flowable that emits value as a single item and then completes
  
  See Also:
  
  ReactiveX operators documentation: Just, just(Object, Object), fromCallable(Callable), fromArray(Object...), fromIterable(Iterable)
  
  just
  
  @CheckReturnValue @NonNull @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public static  Flowable just(T item1, T item2)
  
  Converts two items into a Publisher that emits those items.
  
  Backpressure:
  
  The operator honors backpressure from downstream and signals each value on-demand (i.e., when requested).
  
  Scheduler:
  
  just does not operate by default on a particular Scheduler.
  
  Type Parameters:
  
  T - the type of these items
  
  Parameters:
  
  item1 - first item
  
  item2 - second item
  
  Returns:
  
  a Flowable that emits each item
  
  See Also:
  
  ReactiveX operators documentation: Just
  
  just
  
  @CheckReturnValue @NonNull @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public static  Flowable just(T item1, T item2, T item3)
  
  Converts three items into a Publisher that emits those items.
  
  Backpressure:
  
  The operator honors backpressure from downstream and signals each value on-demand (i.e., when requested).
  
  Scheduler:
  
  just does not operate by default on a particular Scheduler.
  
  Type Parameters:
  
  T - the type of these items
  
  Parameters:
  
  item1 - first item
  
  item2 - second item
  
  item3 - third item
  
  Returns:
  
  a Flowable that emits each item
  
  See Also:
  
  ReactiveX operators documentation: Just
  
  just
  
  @CheckReturnValue @NonNull @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public static  Flowable just(T item1, T item2, T item3, T item4)
  
  Converts four items into a Publisher that emits those items.
  
  Backpressure:
  
  The operator honors backpressure from downstream and signals each value on-demand (i.e., when requested).
  
  Scheduler:
  
  just does not operate by default on a particular Scheduler.
  
  Type Parameters:
  
  T - the type of these items
  
  Parameters:
  
  item1 - first item
  
  item2 - second item
  
  item3 - third item
  
  item4 - fourth item
  
  Returns:
  
  a Flowable that emits each item
  
  See Also:
  
  ReactiveX operators documentation: Just
  
  just
  
  @CheckReturnValue @NonNull @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public static  Flowable just(T item1, T item2, T item3, T item4, T item5)
  
  Converts five items into a Publisher that emits those items.
  
  Backpressure:
  
  The operator honors backpressure from downstream and signals each value on-demand (i.e., when requested).
  
  Scheduler:
  
  just does not operate by default on a particular Scheduler.
  
  Type Parameters:
  
  T - the type of these items
  
  Parameters:
  
  item1 - first item
  
  item2 - second item
  
  item3 - third item
  
  item4 - fourth item
  
  item5 - fifth item
  
  Returns:
  
  a Flowable that emits each item
  
  See Also:
  
  ReactiveX operators documentation: Just
  
  just
  
  @CheckReturnValue @NonNull @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public static  Flowable just(T item1, T item2, T item3, T item4, T item5, T item6)
  
  Converts six items into a Publisher that emits those items.
  
  Backpressure:
  
  The operator honors backpressure from downstream and signals each value on-demand (i.e., when requested).
  
  Scheduler:
  
  just does not operate by default on a particular Scheduler.
  
  Type Parameters:
  
  T - the type of these items
  
  Parameters:
  
  item1 - first item
  
  item2 - second item
  
  item3 - third item
  
  item4 - fourth item
  
  item5 - fifth item
  
  item6 - sixth item
  
  Returns:
  
  a Flowable that emits each item
  
  See Also:
  
  ReactiveX operators documentation: Just
  
  just
  
  @CheckReturnValue @NonNull @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public static  Flowable just(T item1, T item2, T item3, T item4, T item5, T item6, T item7)
  
  Converts seven items into a Publisher that emits those items.
  
  Backpressure:
  
  The operator honors backpressure from downstream and signals each value on-demand (i.e., when requested).
  
  Scheduler:
  
  just does not operate by default on a particular Scheduler.
  
  Type Parameters:
  
  T - the type of these items
  
  Parameters:
  
  item1 - first item
  
  item2 - second item
  
  item3 - third item
  
  item4 - fourth item
  
  item5 - fifth item
  
  item6 - sixth item
  
  item7 - seventh item
  
  Returns:
  
  a Flowable that emits each item
  
  See Also:
  
  ReactiveX operators documentation: Just
  
  just
  
  @CheckReturnValue @NonNull @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public static  Flowable just(T item1, T item2, T item3, T item4, T item5, T item6, T item7, T item8)
  
  Converts eight items into a Publisher that emits those items.
  
  Backpressure:
  
  The operator honors backpressure from downstream and signals each value on-demand (i.e., when requested).
  
  Scheduler:
  
  just does not operate by default on a particular Scheduler.
  
  Type Parameters:
  
  T - the type of these items
  
  Parameters:
  
  item1 - first item
  
  item2 - second item
  
  item3 - third item
  
  item4 - fourth item
  
  item5 - fifth item
  
  item6 - sixth item
  
  item7 - seventh item
  
  item8 - eighth item
  
  Returns:
  
  a Flowable that emits each item
  
  See Also:
  
  ReactiveX operators documentation: Just
  
  just
  
  @CheckReturnValue @NonNull @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public static  Flowable just(T item1, T item2, T item3, T item4, T item5, T item6, T item7, T item8, T item9)
  
  Converts nine items into a Publisher that emits those items.
  
  Backpressure:
  
  The operator honors backpressure from downstream and signals each value on-demand (i.e., when requested).
  
  Scheduler:
  
  just does not operate by default on a particular Scheduler.
  
  Type Parameters:
  
  T - the type of these items
  
  Parameters:
  
  item1 - first item
  
  item2 - second item
  
  item3 - third item
  
  item4 - fourth item
  
  item5 - fifth item
  
  item6 - sixth item
  
  item7 - seventh item
  
  item8 - eighth item
  
  item9 - ninth item
  
  Returns:
  
  a Flowable that emits each item
  
  See Also:
  
  ReactiveX operators documentation: Just
  
  just
  
  @CheckReturnValue @NonNull @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public static  Flowable just(T item1, T item2, T item3, T item4, T item5, T item6, T item7, T item8, T item9, T item10)
  
  Converts ten items into a Publisher that emits those items.
  
  Backpressure:
  
  The operator honors backpressure from downstream and signals each value on-demand (i.e., when requested).
  
  Scheduler:
  
  just does not operate by default on a particular Scheduler.
  
  Type Parameters:
  
  T - the type of these items
  
  Parameters:
  
  item1 - first item
  
  item2 - second item
  
  item3 - third item
  
  item4 - fourth item
  
  item5 - fifth item
  
  item6 - sixth item
  
  item7 - seventh item
  
  item8 - eighth item
  
  item9 - ninth item
  
  item10 - tenth item
  
  Returns:
  
  a Flowable that emits each item
  
  See Also:
  
  ReactiveX operators documentation: Just
  
  merge
  
  @CheckReturnValue @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public static  Flowable merge(IterablePublisher> sources, int maxConcurrency, int bufferSize)
  
  Flattens an Iterable of Publishers into one Publisher, without any transformation, while limiting the number of concurrent subscriptions to these Publishers.
  
  You can combine the items emitted by multiple Publishers so that they appear as a single Publisher, by using the merge method.
  
  Backpressure:
  
  The operator honors backpressure from downstream. The source Publishers are expected to honor backpressure; if violated, the operator may signal MissingBackpressureException.
  
  Scheduler:
  
  merge does not operate by default on a particular Scheduler.
  
  Error handling:
  
  If any of the source Publishers signal a Throwable via onError, the resulting Flowable terminates with that Throwable and all other source Publishers are canceled. If more than one Publisher signals an error, the resulting Flowable may terminate with the first one's error or, depending on the concurrency of the sources, may terminate with a CompositeException containing two or more of the various error signals. Throwables that didn't make into the composite will be sent (individually) to the global error handler via RxJavaPlugins.onError(Throwable) method as UndeliverableException errors. Similarly, Throwables signaled by source(s) after the returned Flowable has been canceled or terminated with a (composite) error will be sent to the same global error handler. Use mergeDelayError(Iterable, int, int) to merge sources and terminate only when all source Publishers have completed or failed with an error.
  
  Type Parameters:
  
  T - the common element base type
  
  Parameters:
  
  sources - the Iterable of Publishers
  
  maxConcurrency - the maximum number of Publishers that may be subscribed to concurrently
  
  bufferSize - the number of items to prefetch from each inner Publisher
  
  Returns:
  
  a Flowable that emits items that are the result of flattening the items emitted by the Publishers in the Iterable
  
  Throws:
  
  IllegalArgumentException - if maxConcurrency is less than or equal to 0
  
  See Also:
  
  ReactiveX operators documentation: Merge, mergeDelayError(Iterable, int, int)
  
  mergeArray
  
  @CheckReturnValue @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public static  Flowable mergeArray(int maxConcurrency, int bufferSize, Publisher... sources)
  
  Flattens an Iterable of Publishers into one Publisher, without any transformation, while limiting the number of concurrent subscriptions to these Publishers.
  
  You can combine the items emitted by multiple Publishers so that they appear as a single Publisher, by using the merge method.
  
  Backpressure:
  
  The operator honors backpressure from downstream. The source Publishers are expected to honor backpressure; if violated, the operator may signal MissingBackpressureException.
  
  Scheduler:
  
  mergeArray does not operate by default on a particular Scheduler.
  
  Error handling:
  
  If any of the source Publishers signal a Throwable via onError, the resulting Flowable terminates with that Throwable and all other source Publishers are canceled. If more than one Publisher signals an error, the resulting Flowable may terminate with the first one's error or, depending on the concurrency of the sources, may terminate with a CompositeException containing two or more of the various error signals. Throwables that didn't make into the composite will be sent (individually) to the global error handler via RxJavaPlugins.onError(Throwable) method as UndeliverableException errors. Similarly, Throwables signaled by source(s) after the returned Flowable has been canceled or terminated with a (composite) error will be sent to the same global error handler. Use mergeArrayDelayError(int, int, Publisher[]) to merge sources and terminate only when all source Publishers have completed or failed with an error.
  
  Type Parameters:
  
  T - the common element base type
  
  Parameters:
  
  sources - the array of Publishers
  
  maxConcurrency - the maximum number of Publishers that may be subscribed to concurrently
  
  bufferSize - the number of items to prefetch from each inner Publisher
  
  Returns:
  
  a Flowable that emits items that are the result of flattening the items emitted by the Publishers in the Iterable
  
  Throws:
  
  IllegalArgumentException - if maxConcurrency is less than or equal to 0
  
  See Also:
  
  ReactiveX operators documentation: Merge, mergeArrayDelayError(int, int, Publisher...)
  
  merge
  
  @CheckReturnValue @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public static  Flowable merge(IterablePublisher> sources)
  
  Flattens an Iterable of Publishers into one Publisher, without any transformation.
  
  You can combine the items emitted by multiple Publishers so that they appear as a single Publisher, by using the merge method.
  
  Backpressure:
  
  The operator honors backpressure from downstream. The source Publishers are expected to honor backpressure; if violated, the operator may signal MissingBackpressureException.
  
  Scheduler:
  
  merge does not operate by default on a particular Scheduler.
  
  Error handling:
  
  If any of the source Publishers signal a Throwable via onError, the resulting Flowable terminates with that Throwable and all other source Publishers are canceled. If more than one Publisher signals an error, the resulting Flowable may terminate with the first one's error or, depending on the concurrency of the sources, may terminate with a CompositeException containing two or more of the various error signals. Throwables that didn't make into the composite will be sent (individually) to the global error handler via RxJavaPlugins.onError(Throwable) method as UndeliverableException errors. Similarly, Throwables signaled by source(s) after the returned Flowable has been canceled or terminated with a (composite) error will be sent to the same global error handler. Use mergeDelayError(Iterable) to merge sources and terminate only when all source Publishers have completed or failed with an error.
  
  Type Parameters:
  
  T - the common element base type
  
  Parameters:
  
  sources - the Iterable of Publishers
  
  Returns:
  
  a Flowable that emits items that are the result of flattening the items emitted by the Publishers in the Iterable
  
  See Also:
  
  ReactiveX operators documentation: Merge, mergeDelayError(Iterable)
  
  merge
  
  @CheckReturnValue @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public static  Flowable merge(IterablePublisher> sources, int maxConcurrency)
  
  Flattens an Iterable of Publishers into one Publisher, without any transformation, while limiting the number of concurrent subscriptions to these Publishers.
  
  You can combine the items emitted by multiple Publishers so that they appear as a single Publisher, by using the merge method.
  
  Backpressure:
  
  The operator honors backpressure from downstream. The source Publishers are expected to honor backpressure; if violated, the operator may signal MissingBackpressureException.
  
  Scheduler:
  
  merge does not operate by default on a particular Scheduler.
  
  Error handling:
  
  If any of the source Publishers signal a Throwable via onError, the resulting Flowable terminates with that Throwable and all other source Publishers are canceled. If more than one Publisher signals an error, the resulting Flowable may terminate with the first one's error or, depending on the concurrency of the sources, may terminate with a CompositeException containing two or more of the various error signals. Throwables that didn't make into the composite will be sent (individually) to the global error handler via RxJavaPlugins.onError(Throwable) method as UndeliverableException errors. Similarly, Throwables signaled by source(s) after the returned Flowable has been canceled or terminated with a (composite) error will be sent to the same global error handler. Use mergeDelayError(Iterable, int) to merge sources and terminate only when all source Publishers have completed or failed with an error.
  
  Type Parameters:
  
  T - the common element base type
  
  Parameters:
  
  sources - the Iterable of Publishers
  
  maxConcurrency - the maximum number of Publishers that may be subscribed to concurrently
  
  Returns:
  
  a Flowable that emits items that are the result of flattening the items emitted by the Publishers in the Iterable
  
  Throws:
  
  IllegalArgumentException - if maxConcurrency is less than or equal to 0
  
  See Also:
  
  ReactiveX operators documentation: Merge, mergeDelayError(Iterable, int)
  
  merge
  
  @CheckReturnValue @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public static  Flowable merge(PublisherPublisher> sources)
  
  Flattens a Publisher that emits Publishers into a single Publisher that emits the items emitted by those Publishers, without any transformation.
  
  You can combine the items emitted by multiple Publishers so that they appear as a single Publisher, by using the merge method.
  
  Backpressure:
  
  The operator honors backpressure from downstream. The outer Publisher is consumed in unbounded mode (i.e., no backpressure is applied to it). The inner Publishers are expected to honor backpressure; if violated, the operator may signal MissingBackpressureException.
  
  Scheduler:
  
  merge does not operate by default on a particular Scheduler.
  
  Error handling:
  
  If any of the source Publishers signal a Throwable via onError, the resulting Flowable terminates with that Throwable and all other source Publishers are canceled. If more than one Publisher signals an error, the resulting Flowable may terminate with the first one's error or, depending on the concurrency of the sources, may terminate with a CompositeException containing two or more of the various error signals. Throwables that didn't make into the composite will be sent (individually) to the global error handler via RxJavaPlugins.onError(Throwable) method as UndeliverableException errors. Similarly, Throwables signaled by source(s) after the returned Flowable has been canceled or terminated with a (composite) error will be sent to the same global error handler. Use mergeDelayError(Publisher) to merge sources and terminate only when all source Publishers have completed or failed with an error.
  
  Type Parameters:
  
  T - the common element base type
  
  Parameters:
  
  sources - a Publisher that emits Publishers
  
  Returns:
  
  a Flowable that emits items that are the result of flattening the Publishers emitted by the source Publisher
  
  See Also:
  
  ReactiveX operators documentation: Merge, mergeDelayError(Publisher)
  
  merge
  
  @CheckReturnValue @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public static  Flowable merge(PublisherPublisher> sources, int maxConcurrency)
  
  Flattens a Publisher that emits Publishers into a single Publisher that emits the items emitted by those Publishers, without any transformation, while limiting the maximum number of concurrent subscriptions to these Publishers.
  
  You can combine the items emitted by multiple Publishers so that they appear as a single Publisher, by using the merge method.
  
  Backpressure:
  
  The operator honors backpressure from downstream. Both the outer and inner Publishers are expected to honor backpressure; if violated, the operator may signal MissingBackpressureException.
  
  Scheduler:
  
  merge does not operate by default on a particular Scheduler.
  
  Error handling:
  
  If any of the source Publishers signal a Throwable via onError, the resulting Flowable terminates with that Throwable and all other source Publishers are canceled. If more than one Publisher signals an error, the resulting Flowable may terminate with the first one's error or, depending on the concurrency of the sources, may terminate with a CompositeException containing two or more of the various error signals. Throwables that didn't make into the composite will be sent (individually) to the global error handler via RxJavaPlugins.onError(Throwable) method as UndeliverableException errors. Similarly, Throwables signaled by source(s) after the returned Flowable has been canceled or terminated with a (composite) error will be sent to the same global error handler. Use mergeDelayError(Publisher, int) to merge sources and terminate only when all source Publishers have completed or failed with an error.
  
  Type Parameters:
  
  T - the common element base type
  
  Parameters:
  
  sources - a Publisher that emits Publishers
  
  maxConcurrency - the maximum number of Publishers that may be subscribed to concurrently
  
  Returns:
  
  a Flowable that emits items that are the result of flattening the Publishers emitted by the source Publisher
  
  Throws:
  
  IllegalArgumentException - if maxConcurrency is less than or equal to 0
  
  Since:
  
  1.1.0
  
  See Also:
  
  ReactiveX operators documentation: Merge, mergeDelayError(Publisher, int)
  
  mergeArray
  
  @CheckReturnValue @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public static  Flowable mergeArray(Publisher... sources)
  
  Flattens an Array of Publishers into one Publisher, without any transformation.
  
  You can combine items emitted by multiple Publishers so that they appear as a single Publisher, by using the merge method.
  
  Backpressure:
  
  The operator honors backpressure from downstream. The source Publishers are expected to honor backpressure; if violated, the operator may signal MissingBackpressureException.
  
  Scheduler:
  
  mergeArray does not operate by default on a particular Scheduler.
  
  Error handling:
  
  If any of the source Publishers signal a Throwable via onError, the resulting Flowable terminates with that Throwable and all other source Publishers are canceled. If more than one Publisher signals an error, the resulting Flowable may terminate with the first one's error or, depending on the concurrency of the sources, may terminate with a CompositeException containing two or more of the various error signals. Throwables that didn't make into the composite will be sent (individually) to the global error handler via RxJavaPlugins.onError(Throwable) method as UndeliverableException errors. Similarly, Throwables signaled by source(s) after the returned Flowable has been canceled or terminated with a (composite) error will be sent to the same global error handler. Use mergeArrayDelayError(Publisher...) to merge sources and terminate only when all source Publishers have completed or failed with an error.
  
  Type Parameters:
  
  T - the common element base type
  
  Parameters:
  
  sources - the array of Publishers
  
  Returns:
  
  a Flowable that emits all of the items emitted by the Publishers in the Array
  
  See Also:
  
  ReactiveX operators documentation: Merge, mergeArrayDelayError(Publisher...)
  
  merge
  
  @CheckReturnValue @NonNull @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public static  Flowable merge(Publisher source1, Publisher source2)
  
  Flattens two Publishers into a single Publisher, without any transformation.
  
  You can combine items emitted by multiple Publishers so that they appear as a single Publisher, by using the merge method.
  
  Backpressure:
  
  The operator honors backpressure from downstream. The source Publishers are expected to honor backpressure; if violated, the operator may signal MissingBackpressureException.
  
  Scheduler:
  
  merge does not operate by default on a particular Scheduler.
  
  Error handling:
  
  If any of the source Publishers signal a Throwable via onError, the resulting Flowable terminates with that Throwable and all other source Publishers are canceled. If more than one Publisher signals an error, the resulting Flowable may terminate with the first one's error or, depending on the concurrency of the sources, may terminate with a CompositeException containing two or more of the various error signals. Throwables that didn't make into the composite will be sent (individually) to the global error handler via RxJavaPlugins.onError(Throwable) method as UndeliverableException errors. Similarly, Throwables signaled by source(s) after the returned Flowable has been canceled or terminated with a (composite) error will be sent to the same global error handler. Use mergeDelayError(Publisher, Publisher) to merge sources and terminate only when all source Publishers have completed or failed with an error.
  
  Type Parameters:
  
  T - the common element base type
  
  Parameters:
  
  source1 - a Publisher to be merged
  
  source2 - a Publisher to be merged
  
  Returns:
  
  a Flowable that emits all of the items emitted by the source Publishers
  
  See Also:
  
  ReactiveX operators documentation: Merge, mergeDelayError(Publisher, Publisher)
  
  merge
  
  @CheckReturnValue @NonNull @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public static  Flowable merge(Publisher source1, Publisher source2, Publisher source3)
  
  Flattens three Publishers into a single Publisher, without any transformation.
  
  You can combine items emitted by multiple Publishers so that they appear as a single Publisher, by using the merge method.
  
  Backpressure:
  
  The operator honors backpressure from downstream. The source Publishers are expected to honor backpressure; if violated, the operator may signal MissingBackpressureException.
  
  Scheduler:
  
  merge does not operate by default on a particular Scheduler.
  
  Error handling:
  
  If any of the source Publishers signal a Throwable via onError, the resulting Flowable terminates with that Throwable and all other source Publishers are canceled. If more than one Publisher signals an error, the resulting Flowable may terminate with the first one's error or, depending on the concurrency of the sources, may terminate with a CompositeException containing two or more of the various error signals. Throwables that didn't make into the composite will be sent (individually) to the global error handler via RxJavaPlugins.onError(Throwable) method as UndeliverableException errors. Similarly, Throwables signaled by source(s) after the returned Flowable has been canceled or terminated with a (composite) error will be sent to the same global error handler. Use mergeDelayError(Publisher, Publisher, Publisher) to merge sources and terminate only when all source Publishers have completed or failed with an error.
  
  Type Parameters:
  
  T - the common element base type
  
  Parameters:
  
  source1 - a Publisher to be merged
  
  source2 - a Publisher to be merged
  
  source3 - a Publisher to be merged
  
  Returns:
  
  a Flowable that emits all of the items emitted by the source Publishers
  
  See Also:
  
  ReactiveX operators documentation: Merge, mergeDelayError(Publisher, Publisher, Publisher)
  
  merge
  
  @CheckReturnValue @NonNull @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public static  Flowable merge(Publisher source1, Publisher source2, Publisher source3, Publisher source4)
  
  Flattens four Publishers into a single Publisher, without any transformation.
  
  You can combine items emitted by multiple Publishers so that they appear as a single Publisher, by using the merge method.
  
  Backpressure:
  
  The operator honors backpressure from downstream. The source Publishers are expected to honor backpressure; if violated, the operator may signal MissingBackpressureException.
  
  Scheduler:
  
  merge does not operate by default on a particular Scheduler.
  
  Error handling:
  
  If any of the source Publishers signal a Throwable via onError, the resulting Flowable terminates with that Throwable and all other source Publishers are canceled. If more than one Publisher signals an error, the resulting Flowable may terminate with the first one's error or, depending on the concurrency of the sources, may terminate with a CompositeException containing two or more of the various error signals. Throwables that didn't make into the composite will be sent (individually) to the global error handler via RxJavaPlugins.onError(Throwable) method as UndeliverableException errors. Similarly, Throwables signaled by source(s) after the returned Flowable has been canceled or terminated with a (composite) error will be sent to the same global error handler. Use mergeDelayError(Publisher, Publisher, Publisher, Publisher) to merge sources and terminate only when all source Publishers have completed or failed with an error.
  
  Type Parameters:
  
  T - the common element base type
  
  Parameters:
  
  source1 - a Publisher to be merged
  
  source2 - a Publisher to be merged
  
  source3 - a Publisher to be merged
  
  source4 - a Publisher to be merged
  
  Returns:
  
  a Flowable that emits all of the items emitted by the source Publishers
  
  See Also:
  
  ReactiveX operators documentation: Merge, mergeDelayError(Publisher, Publisher, Publisher, Publisher)
  
  mergeDelayError
  
  @CheckReturnValue @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public static  Flowable mergeDelayError(IterablePublisher> sources)
  
  Flattens an Iterable of Publishers into one Publisher, in a way that allows a Subscriber to receive all successfully emitted items from each of the source Publishers without being interrupted by an error notification from one of them.
  This behaves like merge(Publisher) except that if any of the merged Publishers notify of an error via onError, mergeDelayError will refrain from propagating that error notification until all of the merged Publishers have finished emitting items.
  
  Even if multiple merged Publishers send onError notifications, mergeDelayError will only invoke the onError method of its Subscribers once.
  
  Backpressure:
  
  The operator honors backpressure from downstream. All inner Publishers are expected to honor backpressure; if violated, the operator may signal MissingBackpressureException.
  
  Scheduler:
  
  mergeDelayError does not operate by default on a particular Scheduler.
  
  Type Parameters:
  
  T - the common element base type
  
  Parameters:
  
  sources - the Iterable of Publishers
  
  Returns:
  
  a Flowable that emits items that are the result of flattening the items emitted by the Publishers in the Iterable
  
  See Also:
  
  ReactiveX operators documentation: Merge
  
  mergeDelayError
  
  @CheckReturnValue @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public static  Flowable mergeDelayError(IterablePublisher> sources, int maxConcurrency, int bufferSize)
  
  Flattens an Iterable of Publishers into one Publisher, in a way that allows a Subscriber to receive all successfully emitted items from each of the source Publishers without being interrupted by an error notification from one of them, while limiting the number of concurrent subscriptions to these Publishers.
  This behaves like merge(Publisher) except that if any of the merged Publishers notify of an error via onError, mergeDelayError will refrain from propagating that error notification until all of the merged Publishers have finished emitting items.
  
  Even if multiple merged Publishers send onError notifications, mergeDelayError will only invoke the onError method of its Subscribers once.
  
  Backpressure:
  
  The operator honors backpressure from downstream. All inner Publishers are expected to honor backpressure; if violated, the operator may signal MissingBackpressureException.
  
  Scheduler:
  
  mergeDelayError does not operate by default on a particular Scheduler.
  
  Type Parameters:
  
  T - the common element base type
  
  Parameters:
  
  sources - the Iterable of Publishers
  
  maxConcurrency - the maximum number of Publishers that may be subscribed to concurrently
  
  bufferSize - the number of items to prefetch from each inner Publisher
  
  Returns:
  
  a Flowable that emits items that are the result of flattening the items emitted by the Publishers in the Iterable
  
  See Also:
  
  ReactiveX operators documentation: Merge
  
  mergeArrayDelayError
  
  @CheckReturnValue @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public static  Flowable mergeArrayDelayError(int maxConcurrency, int bufferSize, Publisher... sources)
  
  Flattens an array of Publishers into one Publisher, in a way that allows a Subscriber to receive all successfully emitted items from each of the source Publishers without being interrupted by an error notification from one of them, while limiting the number of concurrent subscriptions to these Publishers.
  This behaves like merge(Publisher) except that if any of the merged Publishers notify of an error via onError, mergeDelayError will refrain from propagating that error notification until all of the merged Publishers have finished emitting items.
  
  Even if multiple merged Publishers send onError notifications, mergeDelayError will only invoke the onError method of its Subscribers once.
  
  Backpressure:
  
  The operator honors backpressure from downstream. All source Publishers are expected to honor backpressure; if violated, the operator may signal MissingBackpressureException.
  
  Scheduler:
  
  mergeArrayDelayError does not operate by default on a particular Scheduler.
  
  Type Parameters:
  
  T - the common element base type
  
  Parameters:
  
  sources - the array of Publishers
  
  maxConcurrency - the maximum number of Publishers that may be subscribed to concurrently
  
  bufferSize - the number of items to prefetch from each inner Publisher
  
  Returns:
  
  a Flowable that emits items that are the result of flattening the items emitted by the Publishers in the Iterable
  
  See Also:
  
  ReactiveX operators documentation: Merge
  
  mergeDelayError
  
  @CheckReturnValue @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public static  Flowable mergeDelayError(IterablePublisher> sources, int maxConcurrency)
  
  Flattens an Iterable of Publishers into one Publisher, in a way that allows a Subscriber to receive all successfully emitted items from each of the source Publishers without being interrupted by an error notification from one of them, while limiting the number of concurrent subscriptions to these Publishers.
  This behaves like merge(Publisher) except that if any of the merged Publishers notify of an error via onError, mergeDelayError will refrain from propagating that error notification until all of the merged Publishers have finished emitting items.
  
  Even if multiple merged Publishers send onError notifications, mergeDelayError will only invoke the onError method of its Subscribers once.
  
  Backpressure:
  
  The operator honors backpressure from downstream. All inner Publishers are expected to honor backpressure; if violated, the operator may signal MissingBackpressureException.
  
  Scheduler:
  
  mergeDelayError does not operate by default on a particular Scheduler.
  
  Type Parameters:
  
  T - the common element base type
  
  Parameters:
  
  sources - the Iterable of Publishers
  
  maxConcurrency - the maximum number of Publishers that may be subscribed to concurrently
  
  Returns:
  
  a Flowable that emits items that are the result of flattening the items emitted by the Publishers in the Iterable
  
  See Also:
  
  ReactiveX operators documentation: Merge
  
  mergeDelayError
  
  @CheckReturnValue @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public static  Flowable mergeDelayError(PublisherPublisher> sources)
  
  Flattens a Publisher that emits Publishers into one Publisher, in a way that allows a Subscriber to receive all successfully emitted items from all of the source Publishers without being interrupted by an error notification from one of them.
  This behaves like merge(Publisher) except that if any of the merged Publishers notify of an error via onError, mergeDelayError will refrain from propagating that error notification until all of the merged Publishers have finished emitting items.
  
  Even if multiple merged Publishers send onError notifications, mergeDelayError will only invoke the onError method of its Subscribers once.
  
  Backpressure:
  
  The operator honors backpressure from downstream. The outer Publisher is consumed in unbounded mode (i.e., no backpressure is applied to it). The inner Publishers are expected to honor backpressure; if violated, the operator may signal MissingBackpressureException.
  
  Scheduler:
  
  mergeDelayError does not operate by default on a particular Scheduler.
  
  Type Parameters:
  
  T - the common element base type
  
  Parameters:
  
  sources - a Publisher that emits Publishers
  
  Returns:
  
  a Flowable that emits all of the items emitted by the Publishers emitted by the source Publisher
  
  See Also:
  
  ReactiveX operators documentation: Merge
  
  mergeDelayError
  
  @CheckReturnValue @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public static  Flowable mergeDelayError(PublisherPublisher> sources, int maxConcurrency)
  
  Flattens a Publisher that emits Publishers into one Publisher, in a way that allows a Subscriber to receive all successfully emitted items from all of the source Publishers without being interrupted by an error notification from one of them, while limiting the number of concurrent subscriptions to these Publishers.
  This behaves like merge(Publisher) except that if any of the merged Publishers notify of an error via onError, mergeDelayError will refrain from propagating that error notification until all of the merged Publishers have finished emitting items.
  
  Even if multiple merged Publishers send onError notifications, mergeDelayError will only invoke the onError method of its Subscribers once.
  
  Backpressure:
  
  The operator honors backpressure from downstream. Both the outer and inner Publishers are expected to honor backpressure; if violated, the operator may signal MissingBackpressureException.
  
  Scheduler:
  
  mergeDelayError does not operate by default on a particular Scheduler.
  
  Type Parameters:
  
  T - the common element base type
  
  Parameters:
  
  sources - a Publisher that emits Publishers
  
  maxConcurrency - the maximum number of Publishers that may be subscribed to concurrently
  
  Returns:
  
  a Flowable that emits all of the items emitted by the Publishers emitted by the source Publisher
  
  Since:
  
  2.0
  
  See Also:
  
  ReactiveX operators documentation: Merge
  
  mergeArrayDelayError
  
  @CheckReturnValue @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public static  Flowable mergeArrayDelayError(Publisher... sources)
  
  Flattens an array of Publishers into one Flowable, in a way that allows a Subscriber to receive all successfully emitted items from each of the source Publishers without being interrupted by an error notification from one of them.
  This behaves like merge(Publisher) except that if any of the merged Publishers notify of an error via onError, mergeDelayError will refrain from propagating that error notification until all of the merged Publishers have finished emitting items.
  
  Even if multiple merged Publishers send onError notifications, mergeDelayError will only invoke the onError method of its Subscribers once.
  
  Backpressure:
  
  The operator honors backpressure from downstream. Both the outer and inner Publishers are expected to honor backpressure; if violated, the operator may signal MissingBackpressureException.
  
  Scheduler:
  
  mergeArrayDelayError does not operate by default on a particular Scheduler.
  
  Type Parameters:
  
  T - the common element base type
  
  Parameters:
  
  sources - the Iterable of Publishers
  
  Returns:
  
  a Flowable that emits items that are the result of flattening the items emitted by the Publishers in the Iterable
  
  See Also:
  
  ReactiveX operators documentation: Merge
  
  mergeDelayError
  
  @CheckReturnValue @NonNull @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public static  Flowable mergeDelayError(Publisher source1, Publisher source2)
  
  Flattens two Publishers into one Publisher, in a way that allows a Subscriber to receive all successfully emitted items from each of the source Publishers without being interrupted by an error notification from one of them.
  This behaves like merge(Publisher, Publisher) except that if any of the merged Publishers notify of an error via onError, mergeDelayError will refrain from propagating that error notification until all of the merged Publishers have finished emitting items.
  
  Even if both merged Publishers send onError notifications, mergeDelayError will only invoke the onError method of its Subscribers once.
  
  Backpressure:
  
  The operator honors backpressure from downstream. The source Publishers are expected to honor backpressure; if violated, the operator may signal MissingBackpressureException.
  
  Scheduler:
  
  mergeDelayError does not operate by default on a particular Scheduler.
  
  Type Parameters:
  
  T - the common element base type
  
  Parameters:
  
  source1 - a Publisher to be merged
  
  source2 - a Publisher to be merged
  
  Returns:
  
  a Flowable that emits all of the items that are emitted by the two source Publishers
  
  See Also:
  
  ReactiveX operators documentation: Merge
  
  mergeDelayError
  
  @CheckReturnValue @NonNull @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public static  Flowable mergeDelayError(Publisher source1, Publisher source2, Publisher source3)
  
  Flattens three Publishers into one Publisher, in a way that allows a Subscriber to receive all successfully emitted items from all of the source Publishers without being interrupted by an error notification from one of them.
  This behaves like merge(Publisher, Publisher, Publisher) except that if any of the merged Publishers notify of an error via onError, mergeDelayError will refrain from propagating that error notification until all of the merged Publishers have finished emitting items.
  
  Even if multiple merged Publishers send onError notifications, mergeDelayError will only invoke the onError method of its Subscribers once.
  
  Backpressure:
  
  The operator honors backpressure from downstream. The source Publishers are expected to honor backpressure; if violated, the operator may signal MissingBackpressureException.
  
  Scheduler:
  
  mergeDelayError does not operate by default on a particular Scheduler.
  
  Type Parameters:
  
  T - the common element base type
  
  Parameters:
  
  source1 - a Publisher to be merged
  
  source2 - a Publisher to be merged
  
  source3 - a Publisher to be merged
  
  Returns:
  
  a Flowable that emits all of the items that are emitted by the source Publishers
  
  See Also:
  
  ReactiveX operators documentation: Merge
  
  mergeDelayError
  
  @CheckReturnValue @NonNull @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public static  Flowable mergeDelayError(Publisher source1, Publisher source2, Publisher source3, Publisher source4)
  
  Flattens four Publishers into one Publisher, in a way that allows a Subscriber to receive all successfully emitted items from all of the source Publishers without being interrupted by an error notification from one of them.
  This behaves like merge(Publisher, Publisher, Publisher, Publisher) except that if any of the merged Publishers notify of an error via onError, mergeDelayError will refrain from propagating that error notification until all of the merged Publishers have finished emitting items.
  
  Even if multiple merged Publishers send onError notifications, mergeDelayError will only invoke the onError method of its Subscribers once.
  
  Backpressure:
  
  The operator honors backpressure from downstream. The source Publishers are expected to honor backpressure; if violated, the operator may signal MissingBackpressureException.
  
  Scheduler:
  
  mergeDelayError does not operate by default on a particular Scheduler.
  
  Type Parameters:
  
  T - the common element base type
  
  Parameters:
  
  source1 - a Publisher to be merged
  
  source2 - a Publisher to be merged
  
  source3 - a Publisher to be merged
  
  source4 - a Publisher to be merged
  
  Returns:
  
  a Flowable that emits all of the items that are emitted by the source Publishers
  
  See Also:
  
  ReactiveX operators documentation: Merge
  
  never
  
  @CheckReturnValue @BackpressureSupport(value=PASS_THROUGH) @SchedulerSupport(value="none") public static  Flowable never()
  
  Returns a Flowable that never sends any items or notifications to a Subscriber.
  
  This Publisher is useful primarily for testing purposes.
  
  Backpressure:
  
  This source doesn't produce any elements and effectively ignores downstream backpressure.
  
  Scheduler:
  
  never does not operate by default on a particular Scheduler.
  
  Type Parameters:
  
  T - the type of items (not) emitted by the Publisher
  
  Returns:
  
  a Flowable that never emits any items or sends any notifications to a Subscriber
  
  See Also:
  
  ReactiveX operators documentation: Never
  
  range
  
  @CheckReturnValue @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public static Flowable<Integer> range(int start, int count)
  
  Returns a Flowable that emits a sequence of Integers within a specified range.
  
  Backpressure:
  
  The operator honors backpressure from downstream and signals values on-demand (i.e., when requested).
  
  Scheduler:
  
  range does not operate by default on a particular Scheduler.
  
  Parameters:
  
  start - the value of the first Integer in the sequence
  
  count - the number of sequential Integers to generate
  
  Returns:
  
  a Flowable that emits a range of sequential Integers
  
  Throws:
  
  IllegalArgumentException - if count is less than zero, or if start + count − 1 exceeds Integer.MAX_VALUE
  
  See Also:
  
  ReactiveX operators documentation: Range
  
  rangeLong
  
  @CheckReturnValue @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public static Flowable<Long> rangeLong(long start, long count)
  
  Returns a Flowable that emits a sequence of Longs within a specified range.
  
  Backpressure:
  
  The operator honors backpressure from downstream and signals values on-demand (i.e., when requested).
  
  Scheduler:
  
  rangeLong does not operate by default on a particular Scheduler.
  
  Parameters:
  
  start - the value of the first Long in the sequence
  
  count - the number of sequential Longs to generate
  
  Returns:
  
  a Flowable that emits a range of sequential Longs
  
  Throws:
  
  IllegalArgumentException - if count is less than zero, or if start + count − 1 exceeds Long.MAX_VALUE
  
  See Also:
  
  ReactiveX operators documentation: Range
  
  sequenceEqual
  
  @CheckReturnValue @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public static  Single<Boolean> sequenceEqual(Publisher source1, Publisher source2)
  
  Returns a Single that emits a Boolean value that indicates whether two Publisher sequences are the same by comparing the items emitted by each Publisher pairwise.
  
  Backpressure:
  
  This operator honors downstream backpressure and expects both of its sources to honor backpressure as well. If violated, the operator will emit a MissingBackpressureException.
  
  Scheduler:
  
  sequenceEqual does not operate by default on a particular Scheduler.
  
  Type Parameters:
  
  T - the type of items emitted by each Publisher
  
  Parameters:
  
  source1 - the first Publisher to compare
  
  source2 - the second Publisher to compare
  
  Returns:
  
  a Flowable that emits a Boolean value that indicates whether the two sequences are the same
  
  See Also:
  
  ReactiveX operators documentation: SequenceEqual
  
  sequenceEqual
  
  @CheckReturnValue @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public static  Single<Boolean> sequenceEqual(Publisher source1, Publisher source2, BiPredicate isEqual)
  
  Returns a Single that emits a Boolean value that indicates whether two Publisher sequences are the same by comparing the items emitted by each Publisher pairwise based on the results of a specified equality function.
  
  Backpressure:
  
  The operator honors backpressure from downstream. The source Publishers are expected to honor backpressure; if violated, the operator signals a MissingBackpressureException.
  
  Scheduler:
  
  sequenceEqual does not operate by default on a particular Scheduler.
  
  Type Parameters:
  
  T - the type of items emitted by each Publisher
  
  Parameters:
  
  source1 - the first Publisher to compare
  
  source2 - the second Publisher to compare
  
  isEqual - a function used to compare items emitted by each Publisher
  
  Returns:
  
  a Single that emits a Boolean value that indicates whether the two Publisher sequences are the same according to the specified function
  
  See Also:
  
  ReactiveX operators documentation: SequenceEqual
  
  sequenceEqual
  
  @CheckReturnValue @NonNull @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public static  Single<Boolean> sequenceEqual(Publisher source1, Publisher source2, BiPredicate isEqual, int bufferSize)
  
  Returns a Single that emits a Boolean value that indicates whether two Publisher sequences are the same by comparing the items emitted by each Publisher pairwise based on the results of a specified equality function.
  
  Backpressure:
  
  The operator honors backpressure from downstream. The source Publishers are expected to honor backpressure; if violated, the operator signals a MissingBackpressureException.
  
  Scheduler:
  
  sequenceEqual does not operate by default on a particular Scheduler.
  
  Type Parameters:
  
  T - the type of items emitted by each Publisher
  
  Parameters:
  
  source1 - the first Publisher to compare
  
  source2 - the second Publisher to compare
  
  isEqual - a function used to compare items emitted by each Publisher
  
  bufferSize - the number of items to prefetch from the first and second source Publisher
  
  Returns:
  
  a Single that emits a Boolean value that indicates whether the two Publisher sequences are the same according to the specified function
  
  See Also:
  
  ReactiveX operators documentation: SequenceEqual
  
  sequenceEqual
  
  @CheckReturnValue @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public static  Single<Boolean> sequenceEqual(Publisher source1, Publisher source2, int bufferSize)
  
  Returns a Single that emits a Boolean value that indicates whether two Publisher sequences are the same by comparing the items emitted by each Publisher pairwise.
  
  Backpressure:
  
  This operator honors downstream backpressure and expects both of its sources to honor backpressure as well. If violated, the operator will emit a MissingBackpressureException.
  
  Scheduler:
  
  sequenceEqual does not operate by default on a particular Scheduler.
  
  Type Parameters:
  
  T - the type of items emitted by each Publisher
  
  Parameters:
  
  source1 - the first Publisher to compare
  
  source2 - the second Publisher to compare
  
  bufferSize - the number of items to prefetch from the first and second source Publisher
  
  Returns:
  
  a Single that emits a Boolean value that indicates whether the two sequences are the same
  
  See Also:
  
  ReactiveX operators documentation: SequenceEqual
  
  switchOnNext
  
  @CheckReturnValue @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public static  Flowable switchOnNext(PublisherPublisher> sources, int bufferSize)
  
  Converts a Publisher that emits Publishers into a Publisher that emits the items emitted by the most recently emitted of those Publishers.
  
  switchOnNext subscribes to a Publisher that emits Publishers. Each time it observes one of these emitted Publishers, the Publisher returned by switchOnNext begins emitting the items emitted by that Publisher. When a new Publisher is emitted, switchOnNext stops emitting items from the earlier-emitted Publisher and begins emitting items from the new one.
  The resulting Publisher completes if both the outer Publisher and the last inner Publisher, if any, complete. If the outer Publisher signals an onError, the inner Publisher is canceled and the error delivered in-sequence.
  
  Backpressure:
  
  The operator honors backpressure from downstream. The outer Publisher is consumed in an unbounded manner (i.e., without backpressure) and the inner Publishers are expected to honor backpressure but it is not enforced; the operator won't signal a MissingBackpressureException but the violation may lead to OutOfMemoryError due to internal buffer bloat.
  
  Scheduler:
  
  switchOnNext does not operate by default on a particular Scheduler.
  
  Type Parameters:
  
  T - the item type
  
  Parameters:
  
  sources - the source Publisher that emits Publishers
  
  bufferSize - the number of items to prefetch from the inner Publishers
  
  Returns:
  
  a Flowable that emits the items emitted by the Publisher most recently emitted by the source Publisher
  
  See Also:
  
  ReactiveX operators documentation: Switch
  
  switchOnNext
  
  @CheckReturnValue @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public static  Flowable switchOnNext(PublisherPublisher> sources)
  
  Converts a Publisher that emits Publishers into a Publisher that emits the items emitted by the most recently emitted of those Publishers.
  
  switchOnNext subscribes to a Publisher that emits Publishers. Each time it observes one of these emitted Publishers, the Publisher returned by switchOnNext begins emitting the items emitted by that Publisher. When a new Publisher is emitted, switchOnNext stops emitting items from the earlier-emitted Publisher and begins emitting items from the new one.
  The resulting Publisher completes if both the outer Publisher and the last inner Publisher, if any, complete. If the outer Publisher signals an onError, the inner Publisher is canceled and the error delivered in-sequence.
  
  Backpressure:
  
  The operator honors backpressure from downstream. The outer Publisher is consumed in an unbounded manner (i.e., without backpressure) and the inner Publishers are expected to honor backpressure but it is not enforced; the operator won't signal a MissingBackpressureException but the violation may lead to OutOfMemoryError due to internal buffer bloat.
  
  Scheduler:
  
  switchOnNext does not operate by default on a particular Scheduler.
  
  Type Parameters:
  
  T - the item type
  
  Parameters:
  
  sources - the source Publisher that emits Publishers
  
  Returns:
  
  a Flowable that emits the items emitted by the Publisher most recently emitted by the source Publisher
  
  See Also:
  
  ReactiveX operators documentation: Switch
  
  switchOnNextDelayError
  
  @CheckReturnValue @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public static  Flowable switchOnNextDelayError(PublisherPublisher> sources)
  
  Converts a Publisher that emits Publishers into a Publisher that emits the items emitted by the most recently emitted of those Publishers and delays any exception until all Publishers terminate.
  
  switchOnNext subscribes to a Publisher that emits Publishers. Each time it observes one of these emitted Publishers, the Publisher returned by switchOnNext begins emitting the items emitted by that Publisher. When a new Publisher is emitted, switchOnNext stops emitting items from the earlier-emitted Publisher and begins emitting items from the new one.
  The resulting Publisher completes if both the main Publisher and the last inner Publisher, if any, complete. If the main Publisher signals an onError, the termination of the last inner Publisher will emit that error as is or wrapped into a CompositeException along with the other possible errors the former inner Publishers signaled.
  
  Backpressure:
  
  The operator honors backpressure from downstream. The outer Publisher is consumed in an unbounded manner (i.e., without backpressure) and the inner Publishers are expected to honor backpressure but it is not enforced; the operator won't signal a MissingBackpressureException but the violation may lead to OutOfMemoryError due to internal buffer bloat.
  
  Scheduler:
  
  switchOnNextDelayError does not operate by default on a particular Scheduler.
  
  Type Parameters:
  
  T - the item type
  
  Parameters:
  
  sources - the source Publisher that emits Publishers
  
  Returns:
  
  a Flowable that emits the items emitted by the Publisher most recently emitted by the source Publisher
  
  Since:
  
  2.0
  
  See Also:
  
  ReactiveX operators documentation: Switch
  
  switchOnNextDelayError
  
  @CheckReturnValue @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public static  Flowable switchOnNextDelayError(PublisherPublisher> sources, int prefetch)
  
  Converts a Publisher that emits Publishers into a Publisher that emits the items emitted by the most recently emitted of those Publishers and delays any exception until all Publishers terminate.
  
  switchOnNext subscribes to a Publisher that emits Publishers. Each time it observes one of these emitted Publishers, the Publisher returned by switchOnNext begins emitting the items emitted by that Publisher. When a new Publisher is emitted, switchOnNext stops emitting items from the earlier-emitted Publisher and begins emitting items from the new one.
  The resulting Publisher completes if both the main Publisher and the last inner Publisher, if any, complete. If the main Publisher signals an onError, the termination of the last inner Publisher will emit that error as is or wrapped into a CompositeException along with the other possible errors the former inner Publishers signaled.
  
  Backpressure:
  
  The operator honors backpressure from downstream. The outer Publisher is consumed in an unbounded manner (i.e., without backpressure) and the inner Publishers are expected to honor backpressure but it is not enforced; the operator won't signal a MissingBackpressureException but the violation may lead to OutOfMemoryError due to internal buffer bloat.
  
  Scheduler:
  
  switchOnNextDelayError does not operate by default on a particular Scheduler.
  
  Type Parameters:
  
  T - the item type
  
  Parameters:
  
  sources - the source Publisher that emits Publishers
  
  prefetch - the number of items to prefetch from the inner Publishers
  
  Returns:
  
  a Flowable that emits the items emitted by the Publisher most recently emitted by the source Publisher
  
  Since:
  
  2.0
  
  See Also:
  
  ReactiveX operators documentation: Switch
  
  timer
  
  @CheckReturnValue @BackpressureSupport(value=ERROR) @SchedulerSupport(value="io.reactivex:computation") public static Flowable<Long> timer(long delay, TimeUnit unit)
  
  Returns a Flowable that emits 0L after a specified delay, and then completes.
  
  Backpressure:
  
  This operator does not support backpressure as it uses time. If the downstream needs a slower rate it should slow the timer or use something like onBackpressureDrop().
  
  Scheduler:
  
  timer operates by default on the computation Scheduler.
  
  Parameters:
  
  delay - the initial delay before emitting a single 0L
  
  unit - time units to use for delay
  
  Returns:
  
  a Flowable that emits 0L after a specified delay, and then completes
  
  See Also:
  
  ReactiveX operators documentation: Timer
  
  timer
  
  @CheckReturnValue @NonNull @BackpressureSupport(value=ERROR) @SchedulerSupport(value="custom") public static Flowable<Long> timer(long delay, TimeUnit unit, Scheduler scheduler)
  
  Returns a Flowable that emits 0L after a specified delay, on a specified Scheduler, and then completes.
  
  Backpressure:
  
  This operator does not support backpressure as it uses time. If the downstream needs a slower rate it should slow the timer or use something like onBackpressureDrop().
  
  Scheduler:
  
  You specify which Scheduler this operator will use.
  
  Parameters:
  
  delay - the initial delay before emitting a single 0L
  
  unit - time units to use for delay
  
  scheduler - the Scheduler to use for scheduling the item
  
  Returns:
  
  a Flowable that emits 0L after a specified delay, on a specified Scheduler, and then completes
  
  See Also:
  
  ReactiveX operators documentation: Timer
  
  unsafeCreate
  
  @CheckReturnValue @NonNull @BackpressureSupport(value=NONE) @SchedulerSupport(value="none") public static  Flowable unsafeCreate(Publisher onSubscribe)
  
  Create a Flowable by wrapping a Publisher which has to be implemented according to the Reactive Streams specification by handling backpressure and cancellation correctly; no safeguards are provided by the Flowable itself.
  
  Backpressure:
  
  This operator is a pass-through for backpressure and the behavior is determined by the provided Publisher implementation.
  
  Scheduler:
  
  unsafeCreate by default doesn't operate on any particular Scheduler.
  
  Type Parameters:
  
  T - the value type emitted
  
  Parameters:
  
  onSubscribe - the Publisher instance to wrap
  
  Returns:
  
  the new Flowable instance
  
  Throws:
  
  IllegalArgumentException - if onSubscribe is a subclass of Flowable; such instances don't need conversion and is possibly a port remnant from 1.x or one should use hide() instead.
  
  using
  
  @CheckReturnValue @BackpressureSupport(value=PASS_THROUGH) @SchedulerSupport(value="none") public static  Flowable using(Callable resourceSupplier, FunctionPublisher> sourceSupplier, Consumer resourceDisposer)
  
  Constructs a Publisher that creates a dependent resource object which is disposed of on cancellation.
  
  Backpressure:
  
  The operator is a pass-through for backpressure and otherwise depends on the backpressure support of the Publisher returned by the resourceFactory.
  
  Scheduler:
  
  using does not operate by default on a particular Scheduler.
  
  Type Parameters:
  
  T - the element type of the generated Publisher
  
  D - the type of the resource associated with the output sequence
  
  Parameters:
  
  resourceSupplier - the factory function to create a resource object that depends on the Publisher
  
  sourceSupplier - the factory function to create a Publisher
  
  resourceDisposer - the function that will dispose of the resource
  
  Returns:
  
  the Publisher whose lifetime controls the lifetime of the dependent resource object
  
  See Also:
  
  ReactiveX operators documentation: Using
  
  using
  
  @CheckReturnValue @NonNull @BackpressureSupport(value=PASS_THROUGH) @SchedulerSupport(value="none") public static  Flowable using(Callable resourceSupplier, FunctionPublisher> sourceSupplier, Consumer resourceDisposer, boolean eager)
  
  Constructs a Publisher that creates a dependent resource object which is disposed of just before termination if you have set disposeEagerly to true and cancellation does not occur before termination. Otherwise, resource disposal will occur on cancellation. Eager disposal is particularly appropriate for a synchronous Publisher that reuses resources. disposeAction will only be called once per subscription.
  
  Backpressure:
  
  The operator is a pass-through for backpressure and otherwise depends on the backpressure support of the Publisher returned by the resourceFactory.
  
  Scheduler:
  
  using does not operate by default on a particular Scheduler.
  
  Type Parameters:
  
  T - the element type of the generated Publisher
  
  D - the type of the resource associated with the output sequence
  
  Parameters:
  
  resourceSupplier - the factory function to create a resource object that depends on the Publisher
  
  sourceSupplier - the factory function to create a Publisher
  
  resourceDisposer - the function that will dispose of the resource
  
  eager - if true then disposal will happen either on cancellation or just before emission of a terminal event (onComplete or onError).
  
  Returns:
  
  the Publisher whose lifetime controls the lifetime of the dependent resource object
  
  Since:
  
  2.0
  
  See Also:
  
  ReactiveX operators documentation: Using
  
  zip
  
  @CheckReturnValue @NonNull @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public static  Flowable zip(IterablePublisher> sources, FunctionObject[],? extends R> zipper)
  
  Returns a Flowable that emits the results of a specified combiner function applied to combinations of items emitted, in sequence, by an Iterable of other Publishers.
  zip applies this function in strict sequence, so the first item emitted by the new Publisher will be the result of the function applied to the first item emitted by each of the source Publishers; the second item emitted by the new Publisher will be the result of the function applied to the second item emitted by each of those Publishers; and so forth.
  The resulting Publisher returned from zip will invoke onNext as many times as the number of onNext invocations of the source Publisher that emits the fewest items.
  The operator subscribes to its sources in the order they are specified and completes eagerly if one of the sources is shorter than the rest while canceling the other sources. Therefore, it is possible those other sources will never be able to run to completion (and thus not calling doOnComplete()). This can also happen if the sources are exactly the same length; if source A completes and B has been consumed and is about to complete, the operator detects A won't be sending further values and it will cancel B immediately. For example:
  zip(Arrays.asList(range(1, 5).doOnComplete(action1), range(6, 5).doOnComplete(action2)), (a) -> a)
  action1 will be called but action2 won't.
  To work around this termination property, use doOnCancel(Action) as well or use using() to do cleanup in case of completion or cancellation.
  
  Backpressure:
  
  The operator expects backpressure from the sources and honors backpressure from the downstream. (I.e., zipping with interval(long, TimeUnit) may result in MissingBackpressureException, use one of the onBackpressureX to handle similar, backpressure-ignoring sources.
  
  Scheduler:
  
  zip does not operate by default on a particular Scheduler.
  
  Type Parameters:
  
  T - the common value type
  
  R - the zipped result type
  
  Parameters:
  
  sources - an Iterable of source Publishers
  
  zipper - a function that, when applied to an item emitted by each of the source Publishers, results in an item that will be emitted by the resulting Publisher
  
  Returns:
  
  a Flowable that emits the zipped results
  
  See Also:
  
  ReactiveX operators documentation: Zip
  
  zip
  
  @CheckReturnValue @NonNull @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public static  Flowable zip(PublisherPublisher> sources, FunctionObject[],? extends R> zipper)
  
  Returns a Flowable that emits the results of a specified combiner function applied to combinations of n items emitted, in sequence, by the n Publishers emitted by a specified Publisher.
  zip applies this function in strict sequence, so the first item emitted by the new Publisher will be the result of the function applied to the first item emitted by each of the Publishers emitted by the source Publisher; the second item emitted by the new Publisher will be the result of the function applied to the second item emitted by each of those Publishers; and so forth.
  The resulting Publisher returned from zip will invoke onNext as many times as the number of onNext invocations of the source Publisher that emits the fewest items.
  The operator subscribes to its sources in the order they are specified and completes eagerly if one of the sources is shorter than the rest while cancel the other sources. Therefore, it is possible those other sources will never be able to run to completion (and thus not calling doOnComplete()). This can also happen if the sources are exactly the same length; if source A completes and B has been consumed and is about to complete, the operator detects A won't be sending further values and it will cancel B immediately. For example:
  zip(just(range(1, 5).doOnComplete(action1), range(6, 5).doOnComplete(action2)), (a) -> a)
  action1 will be called but action2 won't.
  To work around this termination property, use doOnCancel(Action) as well or use using() to do cleanup in case of completion or cancellation.
  
  Backpressure:
  
  The operator expects backpressure from the sources and honors backpressure from the downstream. (I.e., zipping with interval(long, TimeUnit) may result in MissingBackpressureException, use one of the onBackpressureX to handle similar, backpressure-ignoring sources.
  
  Scheduler:
  
  zip does not operate by default on a particular Scheduler.
  
  Type Parameters:
  
  T - the value type of the inner Publishers
  
  R - the zipped result type
  
  Parameters:
  
  sources - a Publisher of source Publishers
  
  zipper - a function that, when applied to an item emitted by each of the Publishers emitted by ws, results in an item that will be emitted by the resulting Publisher
  
  Returns:
  
  a Flowable that emits the zipped results
  
  See Also:
  
  ReactiveX operators documentation: Zip
  
  zip
  
  @CheckReturnValue @NonNull @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public static  Flowable zip(Publisher source1, Publisher source2, BiFunction zipper)
  
  Returns a Flowable that emits the results of a specified combiner function applied to combinations of two items emitted, in sequence, by two other Publishers.
  
  zip applies this function in strict sequence, so the first item emitted by the new Publisher will be the result of the function applied to the first item emitted by o1 and the first item emitted by o2; the second item emitted by the new Publisher will be the result of the function applied to the second item emitted by o1 and the second item emitted by o2; and so forth.
  The resulting Publisher returned from zip will invoke onNext as many times as the number of onNext invocations of the source Publisher that emits the fewest items.
  The operator subscribes to its sources in the order they are specified and completes eagerly if one of the sources is shorter than the rest while canceling the other sources. Therefore, it is possible those other sources will never be able to run to completion (and thus not calling doOnComplete()). This can also happen if the sources are exactly the same length; if source A completes and B has been consumed and is about to complete, the operator detects A won't be sending further values and it will cancel B immediately. For example:
  zip(range(1, 5).doOnComplete(action1), range(6, 5).doOnComplete(action2), (a, b) -> a + b)
  action1 will be called but action2 won't.
  To work around this termination property, use doOnCancel(Action) as well or use using() to do cleanup in case of completion or cancellation.
  
  Backpressure:
  
  The operator expects backpressure from the sources and honors backpressure from the downstream. (I.e., zipping with interval(long, TimeUnit) may result in MissingBackpressureException, use one of the onBackpressureX to handle similar, backpressure-ignoring sources.
  
  Scheduler:
  
  zip does not operate by default on a particular Scheduler.
  
  Type Parameters:
  
  T1 - the value type of the first source
  
  T2 - the value type of the second source
  
  R - the zipped result type
  
  Parameters:
  
  source1 - the first source Publisher
  
  source2 - a second source Publisher
  
  zipper - a function that, when applied to an item emitted by each of the source Publishers, results in an item that will be emitted by the resulting Publisher
  
  Returns:
  
  a Flowable that emits the zipped results
  
  See Also:
  
  ReactiveX operators documentation: Zip
  
  zip
  
  @CheckReturnValue @NonNull @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public static  Flowable zip(Publisher source1, Publisher source2, BiFunction zipper, boolean delayError)
  
  Returns a Flowable that emits the results of a specified combiner function applied to combinations of two items emitted, in sequence, by two other Publishers.
  
  zip applies this function in strict sequence, so the first item emitted by the new Publisher will be the result of the function applied to the first item emitted by o1 and the first item emitted by o2; the second item emitted by the new Publisher will be the result of the function applied to the second item emitted by o1 and the second item emitted by o2; and so forth.
  The resulting Publisher returned from zip will invoke onNext as many times as the number of onNext invocations of the source Publisher that emits the fewest items.
  The operator subscribes to its sources in the order they are specified and completes eagerly if one of the sources is shorter than the rest while canceling the other sources. Therefore, it is possible those other sources will never be able to run to completion (and thus not calling doOnComplete()). This can also happen if the sources are exactly the same length; if source A completes and B has been consumed and is about to complete, the operator detects A won't be sending further values and it will cancel B immediately. For example:
  zip(range(1, 5).doOnComplete(action1), range(6, 5).doOnComplete(action2), (a, b) -> a + b)
  action1 will be called but action2 won't.
  To work around this termination property, use doOnCancel(Action) as well or use using() to do cleanup in case of completion or cancellation.
  
  Backpressure:
  
  The operator expects backpressure from the sources and honors backpressure from the downstream. (I.e., zipping with interval(long, TimeUnit) may result in MissingBackpressureException, use one of the onBackpressureX to handle similar, backpressure-ignoring sources.
  
  Scheduler:
  
  zip does not operate by default on a particular Scheduler.
  
  Type Parameters:
  
  T1 - the value type of the first source
  
  T2 - the value type of the second source
  
  R - the zipped result type
  
  Parameters:
  
  source1 - the first source Publisher
  
  source2 - a second source Publisher
  
  zipper - a function that, when applied to an item emitted by each of the source Publishers, results in an item that will be emitted by the resulting Publisher
  
  delayError - delay errors from any of the source Publishers till the other terminates
  
  Returns:
  
  a Flowable that emits the zipped results
  
  See Also:
  
  ReactiveX operators documentation: Zip
  
  zip
  
  @CheckReturnValue @NonNull @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public static  Flowable zip(Publisher source1, Publisher source2, BiFunction zipper, boolean delayError, int bufferSize)
  
  Returns a Flowable that emits the results of a specified combiner function applied to combinations of two items emitted, in sequence, by two other Publishers.
  
  zip applies this function in strict sequence, so the first item emitted by the new Publisher will be the result of the function applied to the first item emitted by o1 and the first item emitted by o2; the second item emitted by the new Publisher will be the result of the function applied to the second item emitted by o1 and the second item emitted by o2; and so forth.
  The resulting Publisher returned from zip will invoke onNext as many times as the number of onNext invocations of the source Publisher that emits the fewest items.
  The operator subscribes to its sources in the order they are specified and completes eagerly if one of the sources is shorter than the rest while canceling the other sources. Therefore, it is possible those other sources will never be able to run to completion (and thus not calling doOnComplete()). This can also happen if the sources are exactly the same length; if source A completes and B has been consumed and is about to complete, the operator detects A won't be sending further values and it will cancel B immediately. For example:
  zip(range(1, 5).doOnComplete(action1), range(6, 5).doOnComplete(action2), (a, b) -> a + b)
  action1 will be called but action2 won't.
  To work around this termination property, use doOnCancel(Action) as well or use using() to do cleanup in case of completion or cancellation.
  
  Backpressure:
  
  The operator expects backpressure from the sources and honors backpressure from the downstream. (I.e., zipping with interval(long, TimeUnit) may result in MissingBackpressureException, use one of the onBackpressureX to handle similar, backpressure-ignoring sources.
  
  Scheduler:
  
  zip does not operate by default on a particular Scheduler.
  
  Type Parameters:
  
  T1 - the value type of the first source
  
  T2 - the value type of the second source
  
  R - the zipped result type
  
  Parameters:
  
  source1 - the first source Publisher
  
  source2 - a second source Publisher
  
  zipper - a function that, when applied to an item emitted by each of the source Publishers, results in an item that will be emitted by the resulting Publisher
  
  delayError - delay errors from any of the source Publishers till the other terminates
  
  bufferSize - the number of elements to prefetch from each source Publisher
  
  Returns:
  
  a Flowable that emits the zipped results
  
  See Also:
  
  ReactiveX operators documentation: Zip
  
  zip
  
  @CheckReturnValue @NonNull @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public static  Flowable zip(Publisher source1, Publisher source2, Publisher source3, Function3 zipper)
  
  Returns a Flowable that emits the results of a specified combiner function applied to combinations of three items emitted, in sequence, by three other Publishers.
  
  zip applies this function in strict sequence, so the first item emitted by the new Publisher will be the result of the function applied to the first item emitted by o1, the first item emitted by o2, and the first item emitted by o3; the second item emitted by the new Publisher will be the result of the function applied to the second item emitted by o1, the second item emitted by o2, and the second item emitted by o3; and so forth.
  The resulting Publisher returned from zip will invoke onNext as many times as the number of onNext invocations of the source Publisher that emits the fewest items.
  The operator subscribes to its sources in the order they are specified and completes eagerly if one of the sources is shorter than the rest while canceling the other sources. Therefore, it is possible those other sources will never be able to run to completion (and thus not calling doOnComplete()). This can also happen if the sources are exactly the same length; if source A completes and B has been consumed and is about to complete, the operator detects A won't be sending further values and it will cancel B immediately. For example:
  zip(range(1, 5).doOnComplete(action1), range(6, 5).doOnComplete(action2), ..., (a, b, c) -> a + b)
  action1 will be called but action2 won't.
  To work around this termination property, use doOnCancel(Action) as well or use using() to do cleanup in case of completion or cancellation.
  
  Backpressure:
  
  The operator expects backpressure from the sources and honors backpressure from the downstream. (I.e., zipping with interval(long, TimeUnit) may result in MissingBackpressureException, use one of the onBackpressureX to handle similar, backpressure-ignoring sources.
  
  Scheduler:
  
  zip does not operate by default on a particular Scheduler.
  
  Type Parameters:
  
  T1 - the value type of the first source
  
  T2 - the value type of the second source
  
  T3 - the value type of the third source
  
  R - the zipped result type
  
  Parameters:
  
  source1 - the first source Publisher
  
  source2 - a second source Publisher
  
  source3 - a third source Publisher
  
  zipper - a function that, when applied to an item emitted by each of the source Publishers, results in an item that will be emitted by the resulting Publisher
  
  Returns:
  
  a Flowable that emits the zipped results
  
  See Also:
  
  ReactiveX operators documentation: Zip
  
  zip
  
  @CheckReturnValue @NonNull @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public static  Flowable zip(Publisher source1, Publisher source2, Publisher source3, Publisher source4, Function4 zipper)
  
  Returns a Flowable that emits the results of a specified combiner function applied to combinations of four items emitted, in sequence, by four other Publishers.
  
  zip applies this function in strict sequence, so the first item emitted by the new Publisher will be the result of the function applied to the first item emitted by o1, the first item emitted by o2, the first item emitted by o3, and the first item emitted by 04; the second item emitted by the new Publisher will be the result of the function applied to the second item emitted by each of those Publishers; and so forth.
  The resulting Publisher returned from zip will invoke onNext as many times as the number of onNext invocations of the source Publisher that emits the fewest items.
  The operator subscribes to its sources in the order they are specified and completes eagerly if one of the sources is shorter than the rest while canceling the other sources. Therefore, it is possible those other sources will never be able to run to completion (and thus not calling doOnComplete()). This can also happen if the sources are exactly the same length; if source A completes and B has been consumed and is about to complete, the operator detects A won't be sending further values and it will cancel B immediately. For example:
  zip(range(1, 5).doOnComplete(action1), range(6, 5).doOnComplete(action2), ..., (a, b, c, d) -> a + b)
  action1 will be called but action2 won't.
  To work around this termination property, use doOnCancel(Action) as well or use using() to do cleanup in case of completion or cancellation.
  
  Backpressure:
  
  The operator expects backpressure from the sources and honors backpressure from the downstream. (I.e., zipping with interval(long, TimeUnit) may result in MissingBackpressureException, use one of the onBackpressureX to handle similar, backpressure-ignoring sources.
  
  Scheduler:
  
  zip does not operate by default on a particular Scheduler.
  
  Type Parameters:
  
  T1 - the value type of the first source
  
  T2 - the value type of the second source
  
  T3 - the value type of the third source
  
  T4 - the value type of the fourth source
  
  R - the zipped result type
  
  Parameters:
  
  source1 - the first source Publisher
  
  source2 - a second source Publisher
  
  source3 - a third source Publisher
  
  source4 - a fourth source Publisher
  
  zipper - a function that, when applied to an item emitted by each of the source Publishers, results in an item that will be emitted by the resulting Publisher
  
  Returns:
  
  a Flowable that emits the zipped results
  
  See Also:
  
  ReactiveX operators documentation: Zip
  
  zip
  
  @CheckReturnValue @NonNull @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public static  Flowable zip(Publisher source1, Publisher source2, Publisher source3, Publisher source4, Publisher source5, Function5 zipper)
  
  Returns a Flowable that emits the results of a specified combiner function applied to combinations of five items emitted, in sequence, by five other Publishers.
  
  zip applies this function in strict sequence, so the first item emitted by the new Publisher will be the result of the function applied to the first item emitted by o1, the first item emitted by o2, the first item emitted by o3, the first item emitted by o4, and the first item emitted by o5; the second item emitted by the new Publisher will be the result of the function applied to the second item emitted by each of those Publishers; and so forth.
  The resulting Publisher returned from zip will invoke onNext as many times as the number of onNext invocations of the source Publisher that emits the fewest items.
  The operator subscribes to its sources in the order they are specified and completes eagerly if one of the sources is shorter than the rest while canceling the other sources. Therefore, it is possible those other sources will never be able to run to completion (and thus not calling doOnComplete()). This can also happen if the sources are exactly the same length; if source A completes and B has been consumed and is about to complete, the operator detects A won't be sending further values and it will cancel B immediately. For example:
  zip(range(1, 5).doOnComplete(action1), range(6, 5).doOnComplete(action2), ..., (a, b, c, d, e) -> a + b)
  action1 will be called but action2 won't.
  To work around this termination property, use doOnCancel(Action) as well or use using() to do cleanup in case of completion or cancellation.
  
  Backpressure:
  
  The operator expects backpressure from the sources and honors backpressure from the downstream. (I.e., zipping with interval(long, TimeUnit) may result in MissingBackpressureException, use one of the onBackpressureX to handle similar, backpressure-ignoring sources.
  
  Scheduler:
  
  zip does not operate by default on a particular Scheduler.
  
  Type Parameters:
  
  T1 - the value type of the first source
  
  T2 - the value type of the second source
  
  T3 - the value type of the third source
  
  T4 - the value type of the fourth source
  
  T5 - the value type of the fifth source
  
  R - the zipped result type
  
  Parameters:
  
  source1 - the first source Publisher
  
  source2 - a second source Publisher
  
  source3 - a third source Publisher
  
  source4 - a fourth source Publisher
  
  source5 - a fifth source Publisher
  
  zipper - a function that, when applied to an item emitted by each of the source Publishers, results in an item that will be emitted by the resulting Publisher
  
  Returns:
  
  a Flowable that emits the zipped results
  
  See Also:
  
  ReactiveX operators documentation: Zip
  
  zip
  
  @CheckReturnValue @NonNull @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public static  Flowable zip(Publisher source1, Publisher source2, Publisher source3, Publisher source4, Publisher source5, Publisher source6, Function6 zipper)
  
  Returns a Flowable that emits the results of a specified combiner function applied to combinations of six items emitted, in sequence, by six other Publishers.
  
  zip applies this function in strict sequence, so the first item emitted by the new Publisher will be the result of the function applied to the first item emitted by each source Publisher, the second item emitted by the new Publisher will be the result of the function applied to the second item emitted by each of those Publishers, and so forth.
  The resulting Publisher returned from zip will invoke onNext as many times as the number of onNext invocations of the source Publisher that emits the fewest items.
  The operator subscribes to its sources in the order they are specified and completes eagerly if one of the sources is shorter than the rest while canceling the other sources. Therefore, it is possible those other sources will never be able to run to completion (and thus not calling doOnComplete()). This can also happen if the sources are exactly the same length; if source A completes and B has been consumed and is about to complete, the operator detects A won't be sending further values and it will cancel B immediately. For example:
  zip(range(1, 5).doOnComplete(action1), range(6, 5).doOnComplete(action2), ..., (a, b, c, d, e, f) -> a + b)
  action1 will be called but action2 won't.
  To work around this termination property, use doOnCancel(Action) as well or use using() to do cleanup in case of completion or cancellation.
  
  Backpressure:
  
  The operator expects backpressure from the sources and honors backpressure from the downstream. (I.e., zipping with interval(long, TimeUnit) may result in MissingBackpressureException, use one of the onBackpressureX to handle similar, backpressure-ignoring sources.
  
  Scheduler:
  
  zip does not operate by default on a particular Scheduler.
  
  Type Parameters:
  
  T1 - the value type of the first source
  
  T2 - the value type of the second source
  
  T3 - the value type of the third source
  
  T4 - the value type of the fourth source
  
  T5 - the value type of the fifth source
  
  T6 - the value type of the sixth source
  
  R - the zipped result type
  
  Parameters:
  
  source1 - the first source Publisher
  
  source2 - a second source Publisher
  
  source3 - a third source Publisher
  
  source4 - a fourth source Publisher
  
  source5 - a fifth source Publisher
  
  source6 - a sixth source Publisher
  
  zipper - a function that, when applied to an item emitted by each of the source Publishers, results in an item that will be emitted by the resulting Publisher
  
  Returns:
  
  a Flowable that emits the zipped results
  
  See Also:
  
  ReactiveX operators documentation: Zip
  
  zip
  
  @CheckReturnValue @NonNull @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public static  Flowable zip(Publisher source1, Publisher source2, Publisher source3, Publisher source4, Publisher source5, Publisher source6, Publisher source7, Function7 zipper)
  
  Returns a Flowable that emits the results of a specified combiner function applied to combinations of seven items emitted, in sequence, by seven other Publishers.
  
  zip applies this function in strict sequence, so the first item emitted by the new Publisher will be the result of the function applied to the first item emitted by each source Publisher, the second item emitted by the new Publisher will be the result of the function applied to the second item emitted by each of those Publishers, and so forth.
  The resulting Publisher returned from zip will invoke onNext as many times as the number of onNext invocations of the source Publisher that emits the fewest items.
  The operator subscribes to its sources in the order they are specified and completes eagerly if one of the sources is shorter than the rest while canceling the other sources. Therefore, it is possible those other sources will never be able to run to completion (and thus not calling doOnComplete()). This can also happen if the sources are exactly the same length; if source A completes and B has been consumed and is about to complete, the operator detects A won't be sending further values and it will cancel B immediately. For example:
  zip(range(1, 5).doOnComplete(action1), range(6, 5).doOnComplete(action2), ..., (a, b, c, d, e, f, g) -> a + b)
  action1 will be called but action2 won't.
  To work around this termination property, use doOnCancel(Action) as well or use using() to do cleanup in case of completion or cancellation.
  
  Backpressure:
  
  The operator expects backpressure from the sources and honors backpressure from the downstream. (I.e., zipping with interval(long, TimeUnit) may result in MissingBackpressureException, use one of the onBackpressureX to handle similar, backpressure-ignoring sources.
  
  Scheduler:
  
  zip does not operate by default on a particular Scheduler.
  
  Type Parameters:
  
  T1 - the value type of the first source
  
  T2 - the value type of the second source
  
  T3 - the value type of the third source
  
  T4 - the value type of the fourth source
  
  T5 - the value type of the fifth source
  
  T6 - the value type of the sixth source
  
  T7 - the value type of the seventh source
  
  R - the zipped result type
  
  Parameters:
  
  source1 - the first source Publisher
  
  source2 - a second source Publisher
  
  source3 - a third source Publisher
  
  source4 - a fourth source Publisher
  
  source5 - a fifth source Publisher
  
  source6 - a sixth source Publisher
  
  source7 - a seventh source Publisher
  
  zipper - a function that, when applied to an item emitted by each of the source Publishers, results in an item that will be emitted by the resulting Publisher
  
  Returns:
  
  a Flowable that emits the zipped results
  
  See Also:
  
  ReactiveX operators documentation: Zip
  
  zip
  
  @CheckReturnValue @NonNull @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public static  Flowable zip(Publisher source1, Publisher source2, Publisher source3, Publisher source4, Publisher source5, Publisher source6, Publisher source7, Publisher source8, Function8 zipper)
  
  Returns a Flowable that emits the results of a specified combiner function applied to combinations of eight items emitted, in sequence, by eight other Publishers.
  
  zip applies this function in strict sequence, so the first item emitted by the new Publisher will be the result of the function applied to the first item emitted by each source Publisher, the second item emitted by the new Publisher will be the result of the function applied to the second item emitted by each of those Publishers, and so forth.
  The resulting Publisher returned from zip will invoke onNext as many times as the number of onNext invocations of the source Publisher that emits the fewest items.
  The operator subscribes to its sources in the order they are specified and completes eagerly if one of the sources is shorter than the rest while canceling the other sources. Therefore, it is possible those other sources will never be able to run to completion (and thus not calling doOnComplete()). This can also happen if the sources are exactly the same length; if source A completes and B has been consumed and is about to complete, the operator detects A won't be sending further values and it will cancel B immediately. For example:
  zip(range(1, 5).doOnComplete(action1), range(6, 5).doOnComplete(action2), ..., (a, b, c, d, e, f, g, h) -> a + b)
  action1 will be called but action2 won't.
  To work around this termination property, use doOnCancel(Action) as well or use using() to do cleanup in case of completion or cancellation.
  
  Backpressure:
  
  The operator expects backpressure from the sources and honors backpressure from the downstream. (I.e., zipping with interval(long, TimeUnit) may result in MissingBackpressureException, use one of the onBackpressureX to handle similar, backpressure-ignoring sources.
  
  Scheduler:
  
  zip does not operate by default on a particular Scheduler.
  
  Type Parameters:
  
  T1 - the value type of the first source
  
  T2 - the value type of the second source
  
  T3 - the value type of the third source
  
  T4 - the value type of the fourth source
  
  T5 - the value type of the fifth source
  
  T6 - the value type of the sixth source
  
  T7 - the value type of the seventh source
  
  T8 - the value type of the eighth source
  
  R - the zipped result type
  
  Parameters:
  
  source1 - the first source Publisher
  
  source2 - a second source Publisher
  
  source3 - a third source Publisher
  
  source4 - a fourth source Publisher
  
  source5 - a fifth source Publisher
  
  source6 - a sixth source Publisher
  
  source7 - a seventh source Publisher
  
  source8 - an eighth source Publisher
  
  zipper - a function that, when applied to an item emitted by each of the source Publishers, results in an item that will be emitted by the resulting Publisher
  
  Returns:
  
  a Flowable that emits the zipped results
  
  See Also:
  
  ReactiveX operators documentation: Zip
  
  zip
  
  @CheckReturnValue @NonNull @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public static  Flowable zip(Publisher source1, Publisher source2, Publisher source3, Publisher source4, Publisher source5, Publisher source6, Publisher source7, Publisher source8, Publisher source9, Function9 zipper)
  
  Returns a Flowable that emits the results of a specified combiner function applied to combinations of nine items emitted, in sequence, by nine other Publishers.
  
  zip applies this function in strict sequence, so the first item emitted by the new Publisher will be the result of the function applied to the first item emitted by each source Publisher, the second item emitted by the new Publisher will be the result of the function applied to the second item emitted by each of those Publishers, and so forth.
  The resulting Publisher returned from zip will invoke onNext as many times as the number of onNext invocations of the source Publisher that emits the fewest items.
  The operator subscribes to its sources in the order they are specified and completes eagerly if one of the sources is shorter than the rest while canceling the other sources. Therefore, it is possible those other sources will never be able to run to completion (and thus not calling doOnComplete()). This can also happen if the sources are exactly the same length; if source A completes and B has been consumed and is about to complete, the operator detects A won't be sending further values and it will cancel B immediately. For example:
  zip(range(1, 5).doOnComplete(action1), range(6, 5).doOnComplete(action2), ..., (a, b, c, d, e, f, g, h, i) -> a + b)
  action1 will be called but action2 won't.
  To work around this termination property, use doOnCancel(Action) as well or use using() to do cleanup in case of completion or cancellation.
  
  Backpressure:
  
  The operator expects backpressure from the sources and honors backpressure from the downstream. (I.e., zipping with interval(long, TimeUnit) may result in MissingBackpressureException, use one of the onBackpressureX to handle similar, backpressure-ignoring sources.
  
  Scheduler:
  
  zip does not operate by default on a particular Scheduler.
  
  Type Parameters:
  
  T1 - the value type of the first source
  
  T2 - the value type of the second source
  
  T3 - the value type of the third source
  
  T4 - the value type of the fourth source
  
  T5 - the value type of the fifth source
  
  T6 - the value type of the sixth source
  
  T7 - the value type of the seventh source
  
  T8 - the value type of the eighth source
  
  T9 - the value type of the ninth source
  
  R - the zipped result type
  
  Parameters:
  
  source1 - the first source Publisher
  
  source2 - a second source Publisher
  
  source3 - a third source Publisher
  
  source4 - a fourth source Publisher
  
  source5 - a fifth source Publisher
  
  source6 - a sixth source Publisher
  
  source7 - a seventh source Publisher
  
  source8 - an eighth source Publisher
  
  source9 - a ninth source Publisher
  
  zipper - a function that, when applied to an item emitted by each of the source Publishers, results in an item that will be emitted by the resulting Publisher
  
  Returns:
  
  a Flowable that emits the zipped results
  
  See Also:
  
  ReactiveX operators documentation: Zip
  
  zipArray
  
  @CheckReturnValue @NonNull @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public static  Flowable zipArray(FunctionObject[],? extends R> zipper, boolean delayError, int bufferSize, Publisher... sources)
  
  Returns a Flowable that emits the results of a specified combiner function applied to combinations of items emitted, in sequence, by an array of other Publishers.
  zip applies this function in strict sequence, so the first item emitted by the new Publisher will be the result of the function applied to the first item emitted by each of the source Publishers; the second item emitted by the new Publisher will be the result of the function applied to the second item emitted by each of those Publishers; and so forth.
  The resulting Publisher returned from zip will invoke onNext as many times as the number of onNext invocations of the source Publisher that emits the fewest items.
  The operator subscribes to its sources in the order they are specified and completes eagerly if one of the sources is shorter than the rest while canceling the other sources. Therefore, it is possible those other sources will never be able to run to completion (and thus not calling doOnComplete()). This can also happen if the sources are exactly the same length; if source A completes and B has been consumed and is about to complete, the operator detects A won't be sending further values and it will cancel B immediately. For example:
  zip(new Publisher[]{range(1, 5).doOnComplete(action1), range(6, 5).doOnComplete(action2)}, (a) -> a)
  action1 will be called but action2 won't.
  To work around this termination property, use doOnCancel(Action) as well or use using() to do cleanup in case of completion or cancellation.
  
  Backpressure:
  
  The operator expects backpressure from the sources and honors backpressure from the downstream. (I.e., zipping with interval(long, TimeUnit) may result in MissingBackpressureException, use one of the onBackpressureX to handle similar, backpressure-ignoring sources.
  
  Scheduler:
  
  zipArray does not operate by default on a particular Scheduler.
  
  Type Parameters:
  
  T - the common element type
  
  R - the result type
  
  Parameters:
  
  sources - an array of source Publishers
  
  zipper - a function that, when applied to an item emitted by each of the source Publishers, results in an item that will be emitted by the resulting Publisher
  
  delayError - delay errors signaled by any of the source Publisher until all Publishers terminate
  
  bufferSize - the number of elements to prefetch from each source Publisher
  
  Returns:
  
  a Flowable that emits the zipped results
  
  See Also:
  
  ReactiveX operators documentation: Zip
  
  zipIterable
  
  @CheckReturnValue @NonNull @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public static  Flowable zipIterable(IterablePublisher> sources, FunctionObject[],? extends R> zipper, boolean delayError, int bufferSize)
  
  Returns a Flowable that emits the results of a specified combiner function applied to combinations of items emitted, in sequence, by an Iterable of other Publishers.
  zip applies this function in strict sequence, so the first item emitted by the new Publisher will be the result of the function applied to the first item emitted by each of the source Publishers; the second item emitted by the new Publisher will be the result of the function applied to the second item emitted by each of those Publishers; and so forth.
  The resulting Publisher returned from zip will invoke onNext as many times as the number of onNext invocations of the source Publisher that emits the fewest items.
  The operator subscribes to its sources in the order they are specified and completes eagerly if one of the sources is shorter than the rest while canceling the other sources. Therefore, it is possible those other sources will never be able to run to completion (and thus not calling doOnComplete()). This can also happen if the sources are exactly the same length; if source A completes and B has been consumed and is about to complete, the operator detects A won't be sending further values and it will cancel B immediately. For example:
  zip(Arrays.asList(range(1, 5).doOnComplete(action1), range(6, 5).doOnComplete(action2)), (a) -> a)
  action1 will be called but action2 won't.
  To work around this termination property, use doOnCancel(Action) as well or use using() to do cleanup in case of completion or cancellation.
  
  Backpressure:
  
  The operator expects backpressure from the sources and honors backpressure from the downstream. (I.e., zipping with interval(long, TimeUnit) may result in MissingBackpressureException, use one of the onBackpressureX to handle similar, backpressure-ignoring sources.
  
  Scheduler:
  
  zipIterable does not operate by default on a particular Scheduler.
  
  Type Parameters:
  
  T - the common source value type
  
  R - the zipped result type
  
  Parameters:
  
  sources - an Iterable of source Publishers
  
  zipper - a function that, when applied to an item emitted by each of the source Publishers, results in an item that will be emitted by the resulting Publisher
  
  delayError - delay errors signaled by any of the source Publisher until all Publishers terminate
  
  bufferSize - the number of elements to prefetch from each source Publisher
  
  Returns:
  
  a Flowable that emits the zipped results
  
  See Also:
  
  ReactiveX operators documentation: Zip
  
  all
  
  @CheckReturnValue @NonNull @BackpressureSupport(value=UNBOUNDED_IN) @SchedulerSupport(value="none") public final Single<Boolean> all(PredicateT> predicate)
  
  Returns a Single that emits a Boolean that indicates whether all of the items emitted by the source Publisher satisfy a condition.
  
  Backpressure:
  
  The operator honors backpressure from downstream and consumes the source Publisher in an unbounded manner (i.e., without applying backpressure).
  
  Scheduler:
  
  all does not operate by default on a particular Scheduler.
  
  Parameters:
  
  predicate - a function that evaluates an item and returns a Boolean
  
  Returns:
  
  a Single that emits true if all items emitted by the source Publisher satisfy the predicate; otherwise, false
  
  See Also:
  
  ReactiveX operators documentation: All
  
  ambWith
  
  @CheckReturnValue @NonNull @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public final Flowable<T> ambWith(PublisherT> other)
  
  Mirrors the Publisher (current or provided) that first either emits an item or sends a termination notification.
  
  Backpressure:
  
  The operator itself doesn't interfere with backpressure which is determined by the winning Publisher's backpressure behavior.
  
  Scheduler:
  
  ambWith does not operate by default on a particular Scheduler.
  
  Parameters:
  
  other - a Publisher competing to react first. A subscription to this provided Publisher will occur after subscribing to the current Publisher.
  
  Returns:
  
  a Flowable that emits the same sequence as whichever of the source Publishers first emitted an item or sent a termination notification
  
  See Also:
  
  ReactiveX operators documentation: Amb
  
  any
  
  @CheckReturnValue @NonNull @BackpressureSupport(value=UNBOUNDED_IN) @SchedulerSupport(value="none") public final Single<Boolean> any(PredicateT> predicate)
  
  Returns a Single that emits true if any item emitted by the source Publisher satisfies a specified condition, otherwise false. Note: this always emits false if the source Publisher is empty.
  
  In Rx.Net this is the any operator but we renamed it in RxJava to better match Java naming idioms.
  
  Backpressure:
  
  The operator honors backpressure from downstream and consumes the source Publisher in an unbounded manner (i.e., no backpressure applied to it).
  
  Scheduler:
  
  any does not operate by default on a particular Scheduler.
  
  Parameters:
  
  predicate - the condition to test items emitted by the source Publisher
  
  Returns:
  
  a Single that emits a Boolean that indicates whether any item emitted by the source Publisher satisfies the predicate
  
  See Also:
  
  ReactiveX operators documentation: Contains
  
  as
  
  @CheckReturnValue @BackpressureSupport(value=SPECIAL) @SchedulerSupport(value="none") public final  R as(@NonNull FlowableConverter<T,? extends R> converter)
  
  Calls the specified converter function during assembly time and returns its resulting value.
  This allows fluent conversion to any other type.
  
  Backpressure:
  
  The backpressure behavior depends on what happens in the converter function.
  
  Scheduler:
  
  as does not operate by default on a particular Scheduler.
  
  History: 2.1.7 - experimental
  
  Type Parameters:
  
  R - the resulting object type
  
  Parameters:
  
  converter - the function that receives the current Flowable instance and returns a value
  
  Returns:
  
  the converted value
  
  Throws:
  
  NullPointerException - if converter is null
  
  Since:
  
  2.2
  
  blockingFirst
  
  @CheckReturnValue @BackpressureSupport(value=UNBOUNDED_IN) @SchedulerSupport(value="none") public final T blockingFirst()
  
  Returns the first item emitted by this Flowable, or throws NoSuchElementException if it emits no items.
  
  Backpressure:
  
  The operator consumes the source Flowable in an unbounded manner (i.e., no backpressure applied to it).
  
  Scheduler:
  
  blockingFirst does not operate by default on a particular Scheduler.
  
  Error handling:
  
  If the source signals an error, the operator wraps a checked Exception into RuntimeException and throws that. Otherwise, RuntimeExceptions and Errors are rethrown as they are.
  
  Returns:
  
  the first item emitted by this Flowable
  
  Throws:
  
  NoSuchElementException - if this Flowable emits no items
  
  See Also:
  
  ReactiveX documentation: First
  
  blockingFirst
  
  @CheckReturnValue @BackpressureSupport(value=UNBOUNDED_IN) @SchedulerSupport(value="none") public final T blockingFirst(T defaultItem)
  
  Returns the first item emitted by this Flowable, or a default value if it emits no items.
  
  Backpressure:
  
  The operator consumes the source Flowable in an unbounded manner (i.e., no backpressure applied to it).
  
  Scheduler:
  
  blockingFirst does not operate by default on a particular Scheduler.
  
  Error handling:
  
  If the source signals an error, the operator wraps a checked Exception into RuntimeException and throws that. Otherwise, RuntimeExceptions and Errors are rethrown as they are.
  
  Parameters:
  
  defaultItem - a default value to return if this Flowable emits no items
  
  Returns:
  
  the first item emitted by this Flowable, or the default value if it emits no items
  
  See Also:
  
  ReactiveX documentation: First
  
  blockingForEach
  
  @BackpressureSupport(value=UNBOUNDED_IN) @SchedulerSupport(value="none") public final void blockingForEach(ConsumerT> onNext)
  
  Consumes the upstream Flowable in a blocking fashion and invokes the given Consumer with each upstream item on the current thread until the upstream terminates.
  
  Note: the method will only return if the upstream terminates or the current thread is interrupted.
  This method executes the Consumer on the current thread while subscribe(Consumer) executes the consumer on the original caller thread of the sequence.
  
  Backpressure:
  
  The operator consumes the source Flowable in an unbounded manner (i.e., no backpressure applied to it).
  
  Scheduler:
  
  blockingForEach does not operate by default on a particular Scheduler.
  
  Error handling:
  
  If the source signals an error, the operator wraps a checked Exception into RuntimeException and throws that. Otherwise, RuntimeExceptions and Errors are rethrown as they are.
  
  Parameters:
  
  onNext - the Consumer to invoke for each item emitted by the Flowable
  
  Throws:
  
  RuntimeException - if an error occurs
  
  See Also:
  
  ReactiveX documentation: Subscribe, subscribe(Consumer)
  
  blockingIterable
  
  @CheckReturnValue @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public final Iterable<T> blockingIterable()
  
  Converts this Flowable into an Iterable.
  
  Backpressure:
  
  The operator expects the upstream to honor backpressure otherwise the returned Iterable's iterator will throw a MissingBackpressureException.
  
  Scheduler:
  
  blockingIterable does not operate by default on a particular Scheduler.
  
  Returns:
  
  an Iterable version of this Flowable
  
  See Also:
  
  ReactiveX documentation: To
  
  blockingIterable
  
  @CheckReturnValue @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public final Iterable<T> blockingIterable(int bufferSize)
  
  Converts this Flowable into an Iterable.
  
  Backpressure:
  
  The operator expects the upstream to honor backpressure otherwise the returned Iterable's iterator will throw a MissingBackpressureException.
  
  Scheduler:
  
  blockingIterable does not operate by default on a particular Scheduler.
  
  Parameters:
  
  bufferSize - the number of items to prefetch from the current Flowable
  
  Returns:
  
  an Iterable version of this Flowable
  
  See Also:
  
  ReactiveX documentation: To
  
  blockingLast
  
  @CheckReturnValue @BackpressureSupport(value=UNBOUNDED_IN) @SchedulerSupport(value="none") public final T blockingLast()
  
  Returns the last item emitted by this Flowable, or throws NoSuchElementException if this Flowable emits no items.
  
  Backpressure:
  
  The operator consumes the source Flowable in an unbounded manner (i.e., no backpressure applied to it).
  
  Scheduler:
  
  blockingLast does not operate by default on a particular Scheduler.
  
  Error handling:
  
  If the source signals an error, the operator wraps a checked Exception into RuntimeException and throws that. Otherwise, RuntimeExceptions and Errors are rethrown as they are.
  
  Returns:
  
  the last item emitted by this Flowable
  
  Throws:
  
  NoSuchElementException - if this Flowable emits no items
  
  See Also:
  
  ReactiveX documentation: Last
  
  blockingLast
  
  @CheckReturnValue @BackpressureSupport(value=UNBOUNDED_IN) @SchedulerSupport(value="none") public final T blockingLast(T defaultItem)
  
  Returns the last item emitted by this Flowable, or a default value if it emits no items.
  
  Backpressure:
  
  The operator consumes the source Flowable in an unbounded manner (i.e., no backpressure applied to it).
  
  Scheduler:
  
  blockingLast does not operate by default on a particular Scheduler.
  
  Error handling:
  
  If the source signals an error, the operator wraps a checked Exception into RuntimeException and throws that. Otherwise, RuntimeExceptions and Errors are rethrown as they are.
  
  Parameters:
  
  defaultItem - a default value to return if this Flowable emits no items
  
  Returns:
  
  the last item emitted by the Flowable, or the default value if it emits no items
  
  See Also:
  
  ReactiveX documentation: Last
  
  blockingLatest
  
  @CheckReturnValue @BackpressureSupport(value=UNBOUNDED_IN) @SchedulerSupport(value="none") public final Iterable<T> blockingLatest()
  
  Returns an Iterable that returns the latest item emitted by this Flowable, waiting if necessary for one to become available.
  If this Flowable produces items faster than Iterator.next takes them, onNext events might be skipped, but onError or onComplete events are not.
  Note also that an onNext directly followed by onComplete might hide the onNext event.
  
  Backpressure:
  
  The operator consumes the source Flowable in an unbounded manner (i.e., no backpressure applied to it).
  
  Scheduler:
  
  blockingLatest does not operate by default on a particular Scheduler.
  
  Returns:
  
  an Iterable that always returns the latest item emitted by this Flowable
  
  See Also:
  
  ReactiveX documentation: First
  
  blockingMostRecent
  
  @CheckReturnValue @BackpressureSupport(value=UNBOUNDED_IN) @SchedulerSupport(value="none") public final Iterable<T> blockingMostRecent(T initialItem)
  
  Returns an Iterable that always returns the item most recently emitted by this Flowable.
  
  Backpressure:
  
  The operator consumes the source Flowable in an unbounded manner (i.e., no backpressure applied to it).
  
  Scheduler:
  
  blockingMostRecent does not operate by default on a particular Scheduler.
  
  Parameters:
  
  initialItem - the initial item that the Iterable sequence will yield if this Flowable has not yet emitted an item
  
  Returns:
  
  an Iterable that on each iteration returns the item that this Flowable has most recently emitted
  
  See Also:
  
  ReactiveX documentation: First
  
  blockingNext
  
  @CheckReturnValue @BackpressureSupport(value=UNBOUNDED_IN) @SchedulerSupport(value="none") public final Iterable<T> blockingNext()
  
  Returns an Iterable that blocks until this Flowable emits another item, then returns that item.
  
  Backpressure:
  
  The operator consumes the source Flowable in an unbounded manner (i.e., no backpressure applied to it).
  
  Scheduler:
  
  blockingNext does not operate by default on a particular Scheduler.
  
  Returns:
  
  an Iterable that blocks upon each iteration until this Flowable emits a new item, whereupon the Iterable returns that item
  
  See Also:
  
  ReactiveX documentation: TakeLast
  
  blockingSingle
  
  @CheckReturnValue @BackpressureSupport(value=UNBOUNDED_IN) @SchedulerSupport(value="none") public final T blockingSingle()
  
  If this Flowable completes after emitting a single item, return that item, otherwise throw a NoSuchElementException.
  
  Backpressure:
  
  The operator consumes the source Flowable in an unbounded manner (i.e., no backpressure applied to it).
  
  Scheduler:
  
  blockingSingle does not operate by default on a particular Scheduler.
  
  Error handling:
  
  If the source signals an error, the operator wraps a checked Exception into RuntimeException and throws that. Otherwise, RuntimeExceptions and Errors are rethrown as they are.
  
  Returns:
  
  the single item emitted by this Flowable
  
  See Also:
  
  ReactiveX documentation: First
  
  blockingSingle
  
  @CheckReturnValue @BackpressureSupport(value=UNBOUNDED_IN) @SchedulerSupport(value="none") public final T blockingSingle(T defaultItem)
  
  If this Flowable completes after emitting a single item, return that item; if it emits more than one item, throw an IllegalArgumentException; if it emits no items, return a default value.
  
  Backpressure:
  
  The operator consumes the source Flowable in an unbounded manner (i.e., no backpressure applied to it).
  
  Scheduler:
  
  blockingSingle does not operate by default on a particular Scheduler.
  
  Error handling:
  
  If the source signals an error, the operator wraps a checked Exception into RuntimeException and throws that. Otherwise, RuntimeExceptions and Errors are rethrown as they are.
  
  Parameters:
  
  defaultItem - a default value to return if this Flowable emits no items
  
  Returns:
  
  the single item emitted by this Flowable, or the default value if it emits no items
  
  See Also:
  
  ReactiveX documentation: First
  
  toFuture
  
  @CheckReturnValue @BackpressureSupport(value=UNBOUNDED_IN) @SchedulerSupport(value="none") public final Future<T> toFuture()
  
  Returns a Future representing the only value emitted by this Flowable.
  
  If the Flowable emits more than one item, Future will receive an IndexOutOfBoundsException. If the Flowable is empty, Future will receive a NoSuchElementException. The Flowable source has to terminate in order for the returned Future to terminate as well.
  If the Flowable may emit more than one item, use Flowable.toList().toFuture().
  
  Backpressure:
  
  The operator consumes the source Flowable in an unbounded manner (i.e., no backpressure applied to it).
  
  Scheduler:
  
  toFuture does not operate by default on a particular Scheduler.
  
  Returns:
  
  a Future that expects a single item to be emitted by this Flowable
  
  See Also:
  
  ReactiveX documentation: To
  
  blockingSubscribe
  
  @BackpressureSupport(value=UNBOUNDED_IN) @SchedulerSupport(value="none") public final void blockingSubscribe()
  
  Runs the source Flowable to a terminal event, ignoring any values and rethrowing any exception.
  Note that calling this method will block the caller thread until the upstream terminates normally or with an error. Therefore, calling this method from special threads such as the Android Main Thread or the Swing Event Dispatch Thread is not recommended.
  
  Backpressure:
  
  The operator consumes the source Flowable in an unbounded manner (i.e., no backpressure applied to it).
  
  Scheduler:
  
  blockingSubscribe does not operate by default on a particular Scheduler.
  
  Since:
  
  2.0
  
  See Also:
  
  blockingSubscribe(Consumer), blockingSubscribe(Consumer, Consumer), blockingSubscribe(Consumer, Consumer, Action)
  
  blockingSubscribe
  
  @BackpressureSupport(value=UNBOUNDED_IN) @SchedulerSupport(value="none") public final void blockingSubscribe(ConsumerT> onNext)
  
  Subscribes to the source and calls the given callbacks on the current thread.
  If the Flowable emits an error, it is wrapped into an OnErrorNotImplementedException and routed to the RxJavaPlugins.onError handler. Using the overloads blockingSubscribe(Consumer, Consumer) or blockingSubscribe(Consumer, Consumer, Action) instead is recommended.
  Note that calling this method will block the caller thread until the upstream terminates normally or with an error. Therefore, calling this method from special threads such as the Android Main Thread or the Swing Event Dispatch Thread is not recommended.
  
  Backpressure:
  
  The operator consumes the source Flowable in an unbounded manner (i.e., no backpressure applied to it).
  
  Scheduler:
  
  blockingSubscribe does not operate by default on a particular Scheduler.
  
  Parameters:
  
  onNext - the callback action for each source value
  
  Since:
  
  2.0
  
  See Also:
  
  blockingSubscribe(Consumer, Consumer), blockingSubscribe(Consumer, Consumer, Action)
  
  blockingSubscribe
  
  @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public final void blockingSubscribe(ConsumerT> onNext, int bufferSize)
  
  Subscribes to the source and calls the given callbacks on the current thread.
  If the Flowable emits an error, it is wrapped into an OnErrorNotImplementedException and routed to the RxJavaPlugins.onError handler. Using the overloads blockingSubscribe(Consumer, Consumer) or blockingSubscribe(Consumer, Consumer, Action) instead is recommended.
  Note that calling this method will block the caller thread until the upstream terminates normally or with an error. Therefore, calling this method from special threads such as the Android Main Thread or the Swing Event Dispatch Thread is not recommended.
  
  Backpressure:
  
  The operator consumes the source Flowable in an bounded manner (up to bufferSize outstanding request amount for items).
  
  Scheduler:
  
  blockingSubscribe does not operate by default on a particular Scheduler.
  
  History: 2.1.15 - experimental
  
  Parameters:
  
  onNext - the callback action for each source value
  
  bufferSize - the size of the buffer
  
  Since:
  
  2.2
  
  See Also:
  
  blockingSubscribe(Consumer, Consumer), blockingSubscribe(Consumer, Consumer, Action)
  
  blockingSubscribe
  
  @BackpressureSupport(value=UNBOUNDED_IN) @SchedulerSupport(value="none") public final void blockingSubscribe(ConsumerT> onNext, ConsumerThrowable> onError)
  
  Subscribes to the source and calls the given callbacks on the current thread.
  Note that calling this method will block the caller thread until the upstream terminates normally or with an error. Therefore, calling this method from special threads such as the Android Main Thread or the Swing Event Dispatch Thread is not recommended.
  
  Backpressure:
  
  The operator consumes the source Flowable in an unbounded manner (i.e., no backpressure applied to it).
  
  Scheduler:
  
  blockingSubscribe does not operate by default on a particular Scheduler.
  
  Parameters:
  
  onNext - the callback action for each source value
  
  onError - the callback action for an error event
  
  Since:
  
  2.0
  
  See Also:
  
  blockingSubscribe(Consumer, Consumer, Action)
  
  blockingSubscribe
  
  @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public final void blockingSubscribe(ConsumerT> onNext, ConsumerThrowable> onError, int bufferSize)
  
  Subscribes to the source and calls the given callbacks on the current thread.
  Note that calling this method will block the caller thread until the upstream terminates normally or with an error. Therefore, calling this method from special threads such as the Android Main Thread or the Swing Event Dispatch Thread is not recommended.
  
  Backpressure:
  
  The operator consumes the source Flowable in an bounded manner (up to bufferSize outstanding request amount for items).
  
  Scheduler:
  
  blockingSubscribe does not operate by default on a particular Scheduler.
  
  History: 2.1.15 - experimental
  
  Parameters:
  
  onNext - the callback action for each source value
  
  onError - the callback action for an error event
  
  bufferSize - the size of the buffer
  
  Since:
  
  2.2
  
  See Also:
  
  blockingSubscribe(Consumer, Consumer, Action)
  
  blockingSubscribe
  
  @BackpressureSupport(value=UNBOUNDED_IN) @SchedulerSupport(value="none") public final void blockingSubscribe(ConsumerT> onNext, ConsumerThrowable> onError, Action onComplete)
  
  Subscribes to the source and calls the given callbacks on the current thread.
  Note that calling this method will block the caller thread until the upstream terminates normally or with an error. Therefore, calling this method from special threads such as the Android Main Thread or the Swing Event Dispatch Thread is not recommended.
  
  Backpressure:
  
  The operator consumes the source Flowable in an unbounded manner (i.e., no backpressure applied to it).
  
  Scheduler:
  
  blockingSubscribe does not operate by default on a particular Scheduler.
  
  Parameters:
  
  onNext - the callback action for each source value
  
  onError - the callback action for an error event
  
  onComplete - the callback action for the completion event.
  
  Since:
  
  2.0
  
  blockingSubscribe
  
  @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public final void blockingSubscribe(ConsumerT> onNext, ConsumerThrowable> onError, Action onComplete, int bufferSize)
  
  Subscribes to the source and calls the given callbacks on the current thread.
  Note that calling this method will block the caller thread until the upstream terminates normally or with an error. Therefore, calling this method from special threads such as the Android Main Thread or the Swing Event Dispatch Thread is not recommended.
  
  Backpressure:
  
  The operator consumes the source Flowable in an bounded manner (up to bufferSize outstanding request amount for items).
  
  Scheduler:
  
  blockingSubscribe does not operate by default on a particular Scheduler.
  
  History: 2.1.15 - experimental
  
  Parameters:
  
  onNext - the callback action for each source value
  
  onError - the callback action for an error event
  
  onComplete - the callback action for the completion event.
  
  bufferSize - the size of the buffer
  
  Since:
  
  2.2
  
  blockingSubscribe
  
  @BackpressureSupport(value=SPECIAL) @SchedulerSupport(value="none") public final void blockingSubscribe(SubscriberT> subscriber)
  
  Subscribes to the source and calls the Subscriber methods on the current thread.
  Note that calling this method will block the caller thread until the upstream terminates normally, with an error or the Subscriber cancels the Subscription it receives via Subscriber.onSubscribe(Subscription). Therefore, calling this method from special threads such as the Android Main Thread or the Swing Event Dispatch Thread is not recommended.
  
  Backpressure:
  
  The supplied Subscriber determines how backpressure is applied.
  
  Scheduler:
  
  blockingSubscribe does not operate by default on a particular Scheduler.
  
  The cancellation and backpressure is composed through.
  
  Parameters:
  
  subscriber - the subscriber to forward events and calls to in the current thread
  
  Since:
  
  2.0
  
  buffer
  
  @CheckReturnValue @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public final Flowable<List<T>> buffer(int count)
  
  Returns a Flowable that emits buffers of items it collects from the source Publisher. The resulting Publisher emits connected, non-overlapping buffers, each containing count items. When the source Publisher completes, the resulting Publisher emits the current buffer and propagates the notification from the source Publisher. Note that if the source Publisher issues an onError notification the event is passed on immediately without first emitting the buffer it is in the process of assembling.
  
  Backpressure:
  
  The operator honors backpressure from downstream and expects the source Publisher to honor it as well, although not enforced; violation may lead to MissingBackpressureException somewhere downstream.
  
  Scheduler:
  
  This version of buffer does not operate by default on a particular Scheduler.
  
  Parameters:
  
  count - the maximum number of items in each buffer before it should be emitted
  
  Returns:
  
  a Flowable that emits connected, non-overlapping buffers, each containing at most count items from the source Publisher
  
  See Also:
  
  ReactiveX operators documentation: Buffer
  
  buffer
  
  @CheckReturnValue @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public final Flowable<List<T>> buffer(int count, int skip)
  
  Returns a Flowable that emits buffers of items it collects from the source Publisher. The resulting Publisher emits buffers every skip items, each containing count items. When the source Publisher completes, the resulting Publisher emits the current buffer and propagates the notification from the source Publisher. Note that if the source Publisher issues an onError notification the event is passed on immediately without first emitting the buffer it is in the process of assembling.
  
  Backpressure:
  
  The operator honors backpressure from downstream and expects the source Publisher to honor it as well, although not enforced; violation may lead to MissingBackpressureException somewhere downstream.
  
  Scheduler:
  
  This version of buffer does not operate by default on a particular Scheduler.
  
  Parameters:
  
  count - the maximum size of each buffer before it should be emitted
  
  skip - how many items emitted by the source Publisher should be skipped before starting a new buffer. Note that when skip and count are equal, this is the same operation as buffer(int).
  
  Returns:
  
  a Flowable that emits buffers for every skip item from the source Publisher and containing at most count items
  
  See Also:
  
  ReactiveX operators documentation: Buffer
  
  buffer
  
  @CheckReturnValue @NonNull @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public final CollectionT>> Flowable buffer(int count, int skip, Callable bufferSupplier)
  
  Returns a Flowable that emits buffers of items it collects from the source Publisher. The resulting Publisher emits buffers every skip items, each containing count items. When the source Publisher completes, the resulting Publisher emits the current buffer and propagates the notification from the source Publisher. Note that if the source Publisher issues an onError notification the event is passed on immediately without first emitting the buffer it is in the process of assembling.
  
  Backpressure:
  
  The operator honors backpressure from downstream and expects the source Publisher to honor it as well, although not enforced; violation may lead to MissingBackpressureException somewhere downstream.
  
  Scheduler:
  
  This version of buffer does not operate by default on a particular Scheduler.
  
  Type Parameters:
  
  U - the collection subclass type to buffer into
  
  Parameters:
  
  count - the maximum size of each buffer before it should be emitted
  
  skip - how many items emitted by the source Publisher should be skipped before starting a new buffer. Note that when skip and count are equal, this is the same operation as buffer(int).
  
  bufferSupplier - a factory function that returns an instance of the collection subclass to be used and returned as the buffer
  
  Returns:
  
  a Flowable that emits buffers for every skip item from the source Publisher and containing at most count items
  
  See Also:
  
  ReactiveX operators documentation: Buffer
  
  buffer
  
  @CheckReturnValue @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public final CollectionT>> Flowable buffer(int count, Callable bufferSupplier)
  
  Returns a Flowable that emits buffers of items it collects from the source Publisher. The resulting Publisher emits connected, non-overlapping buffers, each containing count items. When the source Publisher completes, the resulting Publisher emits the current buffer and propagates the notification from the source Publisher. Note that if the source Publisher issues an onError notification the event is passed on immediately without first emitting the buffer it is in the process of assembling.
  
  Backpressure:
  
  The operator honors backpressure from downstream and expects the source Publisher to honor it as well, although not enforced; violation may lead to MissingBackpressureException somewhere downstream.
  
  Scheduler:
  
  This version of buffer does not operate by default on a particular Scheduler.
  
  Type Parameters:
  
  U - the collection subclass type to buffer into
  
  Parameters:
  
  count - the maximum number of items in each buffer before it should be emitted
  
  bufferSupplier - a factory function that returns an instance of the collection subclass to be used and returned as the buffer
  
  Returns:
  
  a Flowable that emits connected, non-overlapping buffers, each containing at most count items from the source Publisher
  
  See Also:
  
  ReactiveX operators documentation: Buffer
  
  buffer
  
  @CheckReturnValue @BackpressureSupport(value=ERROR) @SchedulerSupport(value="io.reactivex:computation") public final Flowable<List<T>> buffer(long timespan, long timeskip, TimeUnit unit)
  
  Returns a Flowable that emits buffers of items it collects from the source Publisher. The resulting Publisher starts a new buffer periodically, as determined by the timeskip argument. It emits each buffer after a fixed timespan, specified by the timespan argument. When the source Publisher completes, the resulting Publisher emits the current buffer and propagates the notification from the source Publisher. Note that if the source Publisher issues an onError notification the event is passed on immediately without first emitting the buffer it is in the process of assembling.
  
  Backpressure:
  
  This operator does not support backpressure as it uses time. It requests Long.MAX_VALUE upstream and does not obey downstream requests.
  
  Scheduler:
  
  This version of buffer operates by default on the computation Scheduler.
  
  Parameters:
  
  timespan - the period of time each buffer collects items before it is emitted
  
  timeskip - the period of time after which a new buffer will be created
  
  unit - the unit of time that applies to the timespan and timeskip arguments
  
  Returns:
  
  a Flowable that emits new buffers of items emitted by the source Publisher periodically after a fixed timespan has elapsed
  
  See Also:
  
  ReactiveX operators documentation: Buffer
  
  buffer
  
  @CheckReturnValue @BackpressureSupport(value=ERROR) @SchedulerSupport(value="custom") public final Flowable<List<T>> buffer(long timespan, long timeskip, TimeUnit unit, Scheduler scheduler)
  
  Returns a Flowable that emits buffers of items it collects from the source Publisher. The resulting Publisher starts a new buffer periodically, as determined by the timeskip argument, and on the specified scheduler. It emits each buffer after a fixed timespan, specified by the timespan argument. When the source Publisher completes, the resulting Publisher emits the current buffer and propagates the notification from the source Publisher. Note that if the source Publisher issues an onError notification the event is passed on immediately without first emitting the buffer it is in the process of assembling.
  
  Backpressure:
  
  This operator does not support backpressure as it uses time. It requests Long.MAX_VALUE upstream and does not obey downstream requests.
  
  Scheduler:
  
  You specify which Scheduler this operator will use.
  
  Parameters:
  
  timespan - the period of time each buffer collects items before it is emitted
  
  timeskip - the period of time after which a new buffer will be created
  
  unit - the unit of time that applies to the timespan and timeskip arguments
  
  scheduler - the Scheduler to use when determining the end and start of a buffer
  
  Returns:
  
  a Flowable that emits new buffers of items emitted by the source Publisher periodically after a fixed timespan has elapsed
  
  See Also:
  
  ReactiveX operators documentation: Buffer
  
  buffer
  
  @CheckReturnValue @NonNull @BackpressureSupport(value=ERROR) @SchedulerSupport(value="custom") public final CollectionT>> Flowable buffer(long timespan, long timeskip, TimeUnit unit, Scheduler scheduler, Callable bufferSupplier)
  
  Returns a Flowable that emits buffers of items it collects from the source Publisher. The resulting Publisher starts a new buffer periodically, as determined by the timeskip argument, and on the specified scheduler. It emits each buffer after a fixed timespan, specified by the timespan argument. When the source Publisher completes, the resulting Publisher emits the current buffer and propagates the notification from the source Publisher. Note that if the source Publisher issues an onError notification the event is passed on immediately without first emitting the buffer it is in the process of assembling.
  
  Backpressure:
  
  This operator does not support backpressure as it uses time. It requests Long.MAX_VALUE upstream and does not obey downstream requests.
  
  Scheduler:
  
  You specify which Scheduler this operator will use.
  
  Type Parameters:
  
  U - the collection subclass type to buffer into
  
  Parameters:
  
  timespan - the period of time each buffer collects items before it is emitted
  
  timeskip - the period of time after which a new buffer will be created
  
  unit - the unit of time that applies to the timespan and timeskip arguments
  
  scheduler - the Scheduler to use when determining the end and start of a buffer
  
  bufferSupplier - a factory function that returns an instance of the collection subclass to be used and returned as the buffer
  
  Returns:
  
  a Flowable that emits new buffers of items emitted by the source Publisher periodically after a fixed timespan has elapsed
  
  See Also:
  
  ReactiveX operators documentation: Buffer
  
  buffer
  
  @CheckReturnValue @BackpressureSupport(value=ERROR) @SchedulerSupport(value="io.reactivex:computation") public final Flowable<List<T>> buffer(long timespan, TimeUnit unit)
  
  Returns a Flowable that emits buffers of items it collects from the source Publisher. The resulting Publisher emits connected, non-overlapping buffers, each of a fixed duration specified by the timespan argument. When the source Publisher completes, the resulting Publisher emits the current buffer and propagates the notification from the source Publisher. Note that if the source Publisher issues an onError notification the event is passed on immediately without first emitting the buffer it is in the process of assembling.
  
  Backpressure:
  
  This operator does not support backpressure as it uses time. It requests Long.MAX_VALUE upstream and does not obey downstream requests.
  
  Scheduler:
  
  This version of buffer operates by default on the computation Scheduler.
  
  Parameters:
  
  timespan - the period of time each buffer collects items before it is emitted and replaced with a new buffer
  
  unit - the unit of time that applies to the timespan argument
  
  Returns:
  
  a Flowable that emits connected, non-overlapping buffers of items emitted by the source Publisher within a fixed duration
  
  See Also:
  
  ReactiveX operators documentation: Buffer
  
  buffer
  
  @CheckReturnValue @BackpressureSupport(value=ERROR) @SchedulerSupport(value="io.reactivex:computation") public final Flowable<List<T>> buffer(long timespan, TimeUnit unit, int count)
  
  Returns a Flowable that emits buffers of items it collects from the source Publisher. The resulting Publisher emits connected, non-overlapping buffers, each of a fixed duration specified by the timespan argument or a maximum size specified by the count argument (whichever is reached first). When the source Publisher completes, the resulting Publisher emits the current buffer and propagates the notification from the source Publisher. Note that if the source Publisher issues an onError notification the event is passed on immediately without first emitting the buffer it is in the process of assembling.
  
  Backpressure:
  
  This operator does not support backpressure as it uses time. It requests Long.MAX_VALUE upstream and does not obey downstream requests.
  
  Scheduler:
  
  This version of buffer operates by default on the computation Scheduler.
  
  Parameters:
  
  timespan - the period of time each buffer collects items before it is emitted and replaced with a new buffer
  
  unit - the unit of time which applies to the timespan argument
  
  count - the maximum size of each buffer before it is emitted
  
  Returns:
  
  a Flowable that emits connected, non-overlapping buffers of items emitted by the source Publisher, after a fixed duration or when the buffer reaches maximum capacity (whichever occurs first)
  
  See Also:
  
  ReactiveX operators documentation: Buffer
  
  buffer
  
  @CheckReturnValue @BackpressureSupport(value=ERROR) @SchedulerSupport(value="custom") public final Flowable<List<T>> buffer(long timespan, TimeUnit unit, Scheduler scheduler, int count)
  
  Returns a Flowable that emits buffers of items it collects from the source Publisher. The resulting Publisher emits connected, non-overlapping buffers, each of a fixed duration specified by the timespan argument as measured on the specified scheduler, or a maximum size specified by the count argument (whichever is reached first). When the source Publisher completes, the resulting Publisher emits the current buffer and propagates the notification from the source Publisher. Note that if the source Publisher issues an onError notification the event is passed on immediately without first emitting the buffer it is in the process of assembling.
  
  Backpressure:
  
  This operator does not support backpressure as it uses time. It requests Long.MAX_VALUE upstream and does not obey downstream requests.
  
  Scheduler:
  
  You specify which Scheduler this operator will use.
  
  Parameters:
  
  timespan - the period of time each buffer collects items before it is emitted and replaced with a new buffer
  
  unit - the unit of time which applies to the timespan argument
  
  scheduler - the Scheduler to use when determining the end and start of a buffer
  
  count - the maximum size of each buffer before it is emitted
  
  Returns:
  
  a Flowable that emits connected, non-overlapping buffers of items emitted by the source Publisher after a fixed duration or when the buffer reaches maximum capacity (whichever occurs first)
  
  See Also:
  
  ReactiveX operators documentation: Buffer
  
  buffer
  
  @CheckReturnValue @BackpressureSupport(value=ERROR) @SchedulerSupport(value="custom") public final CollectionT>> Flowable buffer(long timespan, TimeUnit unit, Scheduler scheduler, int count, Callable bufferSupplier, boolean restartTimerOnMaxSize)
  
  Returns a Flowable that emits buffers of items it collects from the source Publisher. The resulting Publisher emits connected, non-overlapping buffers, each of a fixed duration specified by the timespan argument as measured on the specified scheduler, or a maximum size specified by the count argument (whichever is reached first). When the source Publisher completes, the resulting Publisher emits the current buffer and propagates the notification from the source Publisher. Note that if the source Publisher issues an onError notification the event is passed on immediately without first emitting the buffer it is in the process of assembling.
  
  Backpressure:
  
  This operator does not support backpressure as it uses time. It requests Long.MAX_VALUE upstream and does not obey downstream requests.
  
  Scheduler:
  
  You specify which Scheduler this operator will use.
  
  Type Parameters:
  
  U - the collection subclass type to buffer into
  
  Parameters:
  
  timespan - the period of time each buffer collects items before it is emitted and replaced with a new buffer
  
  unit - the unit of time which applies to the timespan argument
  
  scheduler - the Scheduler to use when determining the end and start of a buffer
  
  count - the maximum size of each buffer before it is emitted
  
  bufferSupplier - a factory function that returns an instance of the collection subclass to be used and returned as the buffer
  
  restartTimerOnMaxSize - if true the time window is restarted when the max capacity of the current buffer is reached
  
  Returns:
  
  a Flowable that emits connected, non-overlapping buffers of items emitted by the source Publisher after a fixed duration or when the buffer reaches maximum capacity (whichever occurs first)
  
  See Also:
  
  ReactiveX operators documentation: Buffer
  
  buffer
  
  @CheckReturnValue @BackpressureSupport(value=ERROR) @SchedulerSupport(value="custom") public final Flowable<List<T>> buffer(long timespan, TimeUnit unit, Scheduler scheduler)
  
  Returns a Flowable that emits buffers of items it collects from the source Publisher. The resulting Publisher emits connected, non-overlapping buffers, each of a fixed duration specified by the timespan argument and on the specified scheduler. When the source Publisher completes, the resulting Publisher emits the current buffer and propagates the notification from the source Publisher. Note that if the source Publisher issues an onError notification the event is passed on immediately without first emitting the buffer it is in the process of assembling.
  
  Backpressure:
  
  This operator does not support backpressure as it uses time. It requests Long.MAX_VALUE upstream and does not obey downstream requests.
  
  Scheduler:
  
  You specify which Scheduler this operator will use.
  
  Parameters:
  
  timespan - the period of time each buffer collects items before it is emitted and replaced with a new buffer
  
  unit - the unit of time which applies to the timespan argument
  
  scheduler - the Scheduler to use when determining the end and start of a buffer
  
  Returns:
  
  a Flowable that emits connected, non-overlapping buffers of items emitted by the source Publisher within a fixed duration
  
  See Also:
  
  ReactiveX operators documentation: Buffer
  
  buffer
  
  @CheckReturnValue @BackpressureSupport(value=ERROR) @SchedulerSupport(value="none") public final  Flowable<List<T>> buffer(Flowable openingIndicator, FunctionPublisher> closingIndicator)
  
  Returns a Flowable that emits buffers of items it collects from the source Publisher. The resulting Publisher emits buffers that it creates when the specified openingIndicator Publisher emits an item, and closes when the Publisher returned from closingIndicator emits an item. If any of the source Publisher, openingIndicator or closingIndicator issues an onError notification the event is passed on immediately without first emitting the buffer it is in the process of assembling.
  
  Backpressure:
  
  This operator does not support backpressure as it is instead controlled by the given Publishers and buffers data. It requests Long.MAX_VALUE upstream and does not obey downstream requests.
  
  Scheduler:
  
  This version of buffer does not operate by default on a particular Scheduler.
  
  Type Parameters:
  
  TOpening - the element type of the buffer-opening Publisher
  
  TClosing - the element type of the individual buffer-closing Publishers
  
  Parameters:
  
  openingIndicator - the Publisher that, when it emits an item, causes a new buffer to be created
  
  closingIndicator - the Function that is used to produce a Publisher for every buffer created. When this Publisher emits an item, the associated buffer is emitted.
  
  Returns:
  
  a Flowable that emits buffers, containing items from the source Publisher, that are created and closed when the specified Publishers emit items
  
  See Also:
  
  ReactiveX operators documentation: Buffer
  
  buffer
  
  @CheckReturnValue @BackpressureSupport(value=ERROR) @SchedulerSupport(value="none") public final CollectionT>> Flowable buffer(Flowable openingIndicator, FunctionPublisher> closingIndicator, Callable bufferSupplier)
  
  Returns a Flowable that emits buffers of items it collects from the source Publisher. The resulting Publisher emits buffers that it creates when the specified openingIndicator Publisher emits an item, and closes when the Publisher returned from closingIndicator emits an item. If any of the source Publisher, openingIndicator or closingIndicator issues an onError notification the event is passed on immediately without first emitting the buffer it is in the process of assembling.
  
  Backpressure:
  
  This operator does not support backpressure as it is instead controlled by the given Publishers and buffers data. It requests Long.MAX_VALUE upstream and does not obey downstream requests.
  
  Scheduler:
  
  This version of buffer does not operate by default on a particular Scheduler.
  
  Type Parameters:
  
  U - the collection subclass type to buffer into
  
  TOpening - the element type of the buffer-opening Publisher
  
  TClosing - the element type of the individual buffer-closing Publishers
  
  Parameters:
  
  openingIndicator - the Publisher that, when it emits an item, causes a new buffer to be created
  
  closingIndicator - the Function that is used to produce a Publisher for every buffer created. When this Publisher emits an item, the associated buffer is emitted.
  
  bufferSupplier - a factory function that returns an instance of the collection subclass to be used and returned as the buffer
  
  Returns:
  
  a Flowable that emits buffers, containing items from the source Publisher, that are created and closed when the specified Publishers emit items
  
  See Also:
  
  ReactiveX operators documentation: Buffer
  
  buffer
  
  @CheckReturnValue @BackpressureSupport(value=ERROR) @SchedulerSupport(value="none") public final  Flowable<List<T>> buffer(Publisher boundaryIndicator)
  
  Returns a Flowable that emits non-overlapping buffered items from the source Publisher each time the specified boundary Publisher emits an item.
  
  Completion of either the source or the boundary Publisher causes the returned Publisher to emit the latest buffer and complete. If either the source Publisher or the boundary Publisher issues an onError notification the event is passed on immediately without first emitting the buffer it is in the process of assembling.
  
  Backpressure:
  
  This operator does not support backpressure as it is instead controlled by the Publisher boundary and buffers data. It requests Long.MAX_VALUE upstream and does not obey downstream requests.
  
  Scheduler:
  
  This version of buffer does not operate by default on a particular Scheduler.
  
  Type Parameters:
  
  B - the boundary value type (ignored)
  
  Parameters:
  
  boundaryIndicator - the boundary Publisher
  
  Returns:
  
  a Flowable that emits buffered items from the source Publisher when the boundary Publisher emits an item
  
  See Also:
  
  buffer(Publisher, int), ReactiveX operators documentation: Buffer
  
  buffer
  
  @CheckReturnValue @BackpressureSupport(value=ERROR) @SchedulerSupport(value="none") public final  Flowable<List<T>> buffer(Publisher boundaryIndicator, int initialCapacity)
  
  Returns a Flowable that emits non-overlapping buffered items from the source Publisher each time the specified boundary Publisher emits an item.
  
  Completion of either the source or the boundary Publisher causes the returned Publisher to emit the latest buffer and complete. If either the source Publisher or the boundary Publisher issues an onError notification the event is passed on immediately without first emitting the buffer it is in the process of assembling.
  
  Backpressure:
  
  This operator does not support backpressure as it is instead controlled by the Publisher boundary and buffers data. It requests Long.MAX_VALUE upstream and does not obey downstream requests.
  
  Scheduler:
  
  This version of buffer does not operate by default on a particular Scheduler.
  
  Type Parameters:
  
  B - the boundary value type (ignored)
  
  Parameters:
  
  boundaryIndicator - the boundary Publisher
  
  initialCapacity - the initial capacity of each buffer chunk
  
  Returns:
  
  a Flowable that emits buffered items from the source Publisher when the boundary Publisher emits an item
  
  See Also:
  
  ReactiveX operators documentation: Buffer, buffer(Publisher)
  
  buffer
  
  @CheckReturnValue @BackpressureSupport(value=ERROR) @SchedulerSupport(value="none") public final CollectionT>> Flowable buffer(Publisher boundaryIndicator, Callable bufferSupplier)
  
  Returns a Flowable that emits non-overlapping buffered items from the source Publisher each time the specified boundary Publisher emits an item.
  
  Completion of either the source or the boundary Publisher causes the returned Publisher to emit the latest buffer and complete. If either the source Publisher or the boundary Publisher issues an onError notification the event is passed on immediately without first emitting the buffer it is in the process of assembling.
  
  Backpressure:
  
  This operator does not support backpressure as it is instead controlled by the Publisher boundary and buffers data. It requests Long.MAX_VALUE upstream and does not obey downstream requests.
  
  Scheduler:
  
  This version of buffer does not operate by default on a particular Scheduler.
  
  Type Parameters:
  
  U - the collection subclass type to buffer into
  
  B - the boundary value type (ignored)
  
  Parameters:
  
  boundaryIndicator - the boundary Publisher
  
  bufferSupplier - a factory function that returns an instance of the collection subclass to be used and returned as the buffer
  
  Returns:
  
  a Flowable that emits buffered items from the source Publisher when the boundary Publisher emits an item
  
  See Also:
  
  buffer(Publisher, int), ReactiveX operators documentation: Buffer
  
  buffer
  
  @CheckReturnValue @BackpressureSupport(value=ERROR) @SchedulerSupport(value="none") public final  Flowable<List<T>> buffer(CallablePublisher> boundaryIndicatorSupplier)
  
  Returns a Flowable that emits buffers of items it collects from the source Publisher. The resulting Publisher emits connected, non-overlapping buffers. It emits the current buffer and replaces it with a new buffer whenever the Publisher produced by the specified boundaryIndicatorSupplier emits an item.
  
  If either the source Publisher or the boundary Publisher issues an onError notification the event is passed on immediately without first emitting the buffer it is in the process of assembling.
  
  Backpressure:
  
  This operator does not support backpressure as it is instead controlled by the given Publishers and buffers data. It requests Long.MAX_VALUE upstream and does not obey downstream requests.
  
  Scheduler:
  
  This version of buffer does not operate by default on a particular Scheduler.
  
  Type Parameters:
  
  B - the value type of the boundary-providing Publisher
  
  Parameters:
  
  boundaryIndicatorSupplier - a Callable that produces a Publisher that governs the boundary between buffers. Whenever the supplied Publisher emits an item, buffer emits the current buffer and begins to fill a new one
  
  Returns:
  
  a Flowable that emits a connected, non-overlapping buffer of items from the source Publisher each time the Publisher created with the closingIndicator argument emits an item
  
  See Also:
  
  ReactiveX operators documentation: Buffer
  
  buffer
  
  @CheckReturnValue @BackpressureSupport(value=ERROR) @SchedulerSupport(value="none") public final CollectionT>> Flowable buffer(CallablePublisher> boundaryIndicatorSupplier, Callable bufferSupplier)
  
  Returns a Flowable that emits buffers of items it collects from the source Publisher. The resulting Publisher emits connected, non-overlapping buffers. It emits the current buffer and replaces it with a new buffer whenever the Publisher produced by the specified boundaryIndicatorSupplier emits an item.
  
  If either the source Publisher or the boundary Publisher issues an onError notification the event is passed on immediately without first emitting the buffer it is in the process of assembling.
  
  Backpressure:
  
  This operator does not support backpressure as it is instead controlled by the given Publishers and buffers data. It requests Long.MAX_VALUE upstream and does not obey downstream requests.
  
  Scheduler:
  
  This version of buffer does not operate by default on a particular Scheduler.
  
  Type Parameters:
  
  U - the collection subclass type to buffer into
  
  B - the value type of the boundary-providing Publisher
  
  Parameters:
  
  boundaryIndicatorSupplier - a Callable that produces a Publisher that governs the boundary between buffers. Whenever the supplied Publisher emits an item, buffer emits the current buffer and begins to fill a new one
  
  bufferSupplier - a factory function that returns an instance of the collection subclass to be used and returned as the buffer
  
  Returns:
  
  a Flowable that emits a connected, non-overlapping buffer of items from the source Publisher each time the Publisher created with the closingIndicator argument emits an item
  
  See Also:
  
  ReactiveX operators documentation: Buffer
  
  cache
  
  @CheckReturnValue @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public final Flowable<T> cache()
  
  Returns a Flowable that subscribes to this Publisher lazily, caches all of its events and replays them, in the same order as received, to all the downstream subscribers.
  
  This is useful when you want a Publisher to cache responses and you can't control the subscribe/cancel behavior of all the Subscribers.
  The operator subscribes only when the first downstream subscriber subscribes and maintains a single subscription towards this Publisher. In contrast, the operator family of replay() that return a ConnectableFlowable require an explicit call to ConnectableFlowable.connect().
  Note: You sacrifice the ability to cancel the origin when you use the cache Subscriber so be careful not to use this Subscriber on Publishers that emit an infinite or very large number of items that will use up memory. A possible workaround is to apply `takeUntil` with a predicate or another source before (and perhaps after) the application of cache().
  AtomicBoolean shouldStop = new AtomicBoolean(); source.takeUntil(v -> shouldStop.get()) .cache() .takeUntil(v -> shouldStop.get()) .subscribe(...);
  Since the operator doesn't allow clearing the cached values either, the possible workaround is to forget all references to it via onTerminateDetach() applied along with the previous workaround:
  AtomicBoolean shouldStop = new AtomicBoolean(); source.takeUntil(v -> shouldStop.get()) .onTerminateDetach() .cache() .takeUntil(v -> shouldStop.get()) .onTerminateDetach() .subscribe(...);
  
  Backpressure:
  
  The operator consumes this Publisher in an unbounded fashion but respects the backpressure of each downstream Subscriber individually.
  
  Scheduler:
  
  cache does not operate by default on a particular Scheduler.
  
  Returns:
  
  a Flowable that, when first subscribed to, caches all of its items and notifications for the benefit of subsequent subscribers
  
  See Also:
  
  ReactiveX operators documentation: Replay
  
  cacheWithInitialCapacity
  
  @CheckReturnValue @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public final Flowable<T> cacheWithInitialCapacity(int initialCapacity)
  
  Returns a Flowable that subscribes to this Publisher lazily, caches all of its events and replays them, in the same order as received, to all the downstream subscribers.
  
  This is useful when you want a Publisher to cache responses and you can't control the subscribe/cancel behavior of all the Subscribers.
  The operator subscribes only when the first downstream subscriber subscribes and maintains a single subscription towards this Publisher. In contrast, the operator family of replay() that return a ConnectableFlowable require an explicit call to ConnectableFlowable.connect().
  Note: You sacrifice the ability to cancel the origin when you use the cache Subscriber so be careful not to use this Subscriber on Publishers that emit an infinite or very large number of items that will use up memory. A possible workaround is to apply `takeUntil` with a predicate or another source before (and perhaps after) the application of cache().
  AtomicBoolean shouldStop = new AtomicBoolean(); source.takeUntil(v -> shouldStop.get()) .cache() .takeUntil(v -> shouldStop.get()) .subscribe(...);
  Since the operator doesn't allow clearing the cached values either, the possible workaround is to forget all references to it via onTerminateDetach() applied along with the previous workaround:
  AtomicBoolean shouldStop = new AtomicBoolean(); source.takeUntil(v -> shouldStop.get()) .onTerminateDetach() .cache() .takeUntil(v -> shouldStop.get()) .onTerminateDetach() .subscribe(...);
  
  Backpressure:
  
  The operator consumes this Publisher in an unbounded fashion but respects the backpressure of each downstream Subscriber individually.
  
  Scheduler:
  
  cacheWithInitialCapacity does not operate by default on a particular Scheduler.
  
  Note: The capacity hint is not an upper bound on cache size. For that, consider replay(int) in combination with ConnectableFlowable.autoConnect() or similar.
  
  Parameters:
  
  initialCapacity - hint for number of items to cache (for optimizing underlying data structure)
  
  Returns:
  
  a Flowable that, when first subscribed to, caches all of its items and notifications for the benefit of subsequent subscribers
  
  See Also:
  
  ReactiveX operators documentation: Replay
  
  cast
  
  @CheckReturnValue @NonNull @BackpressureSupport(value=PASS_THROUGH) @SchedulerSupport(value="none") public final  Flowable cast(Class clazz)
  
  Returns a Flowable that emits the items emitted by the source Publisher, converted to the specified type.
  
  Backpressure:
  
  The operator doesn't interfere with backpressure which is determined by the source Publisher's backpressure behavior.
  
  Scheduler:
  
  cast does not operate by default on a particular Scheduler.
  
  Type Parameters:
  
  U - the output value type cast to
  
  Parameters:
  
  clazz - the target class type that cast will cast the items emitted by the source Publisher into before emitting them from the resulting Publisher
  
  Returns:
  
  a Flowable that emits each item from the source Publisher after converting it to the specified type
  
  See Also:
  
  ReactiveX operators documentation: Map
  
  collect
  
  @CheckReturnValue @NonNull @BackpressureSupport(value=UNBOUNDED_IN) @SchedulerSupport(value="none") public final  Single collect(Callable initialItemSupplier, BiConsumerT> collector)
  
  Collects items emitted by the finite source Publisher into a single mutable data structure and returns a Single that emits this structure.
  
  This is a simplified version of reduce that does not need to return the state on each pass.
  Note that this operator requires the upstream to signal onComplete for the accumulator object to be emitted. Sources that are infinite and never complete will never emit anything through this operator and an infinite source may lead to a fatal OutOfMemoryError.
  
  Backpressure:
  
  This operator does not support backpressure because by intent it will receive all values and reduce them to a single onNext.
  
  Scheduler:
  
  collect does not operate by default on a particular Scheduler.
  
  Type Parameters:
  
  U - the accumulator and output type
  
  Parameters:
  
  initialItemSupplier - the mutable data structure that will collect the items
  
  collector - a function that accepts the state and an emitted item, and modifies state accordingly
  
  Returns:
  
  a Single that emits the result of collecting the values emitted by the source Publisher into a single mutable data structure
  
  See Also:
  
  ReactiveX operators documentation: Reduce
  
  collectInto
  
  @CheckReturnValue @NonNull @BackpressureSupport(value=UNBOUNDED_IN) @SchedulerSupport(value="none") public final  Single collectInto(U initialItem, BiConsumerT> collector)
  
  Collects items emitted by the finite source Publisher into a single mutable data structure and returns a Single that emits this structure.
  
  This is a simplified version of reduce that does not need to return the state on each pass.
  Note that this operator requires the upstream to signal onComplete for the accumulator object to be emitted. Sources that are infinite and never complete will never emit anything through this operator and an infinite source may lead to a fatal OutOfMemoryError.
  
  Backpressure:
  
  This operator does not support backpressure because by intent it will receive all values and reduce them to a single onNext.
  
  Scheduler:
  
  collectInto does not operate by default on a particular Scheduler.
  
  Type Parameters:
  
  U - the accumulator and output type
  
  Parameters:
  
  initialItem - the mutable data structure that will collect the items
  
  collector - a function that accepts the state and an emitted item, and modifies state accordingly
  
  Returns:
  
  a Single that emits the result of collecting the values emitted by the source Publisher into a single mutable data structure
  
  See Also:
  
  ReactiveX operators documentation: Reduce
  
  compose
  
  @CheckReturnValue @BackpressureSupport(value=PASS_THROUGH) @SchedulerSupport(value="none") public final  Flowable compose(FlowableTransformerT,? extends R> composer)
  
  Transform a Publisher by applying a particular Transformer function to it.
  This method operates on the Publisher itself whereas lift(io.reactivex.FlowableOperator) operates on the Publisher's Subscribers or Subscribers.
  If the operator you are creating is designed to act on the individual items emitted by a source Publisher, use lift(io.reactivex.FlowableOperator). If your operator is designed to transform the source Publisher as a whole (for instance, by applying a particular set of existing RxJava operators to it) use compose.
  
  Backpressure:
  
  The operator itself doesn't interfere with the backpressure behavior which only depends on what kind of Publisher the transformer returns.
  
  Scheduler:
  
  compose does not operate by default on a particular Scheduler.
  
  Type Parameters:
  
  R - the value type of the output Publisher
  
  Parameters:
  
  composer - implements the function that transforms the source Publisher
  
  Returns:
  
  the source Publisher, transformed by the transformer function
  
  See Also:
  
  RxJava wiki: Implementing Your Own Operators
  
  concatMap
  
  @CheckReturnValue @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public final  Flowable concatMap(FunctionT,? extends Publisher> mapper)
  
  Returns a new Flowable that emits items resulting from applying a function that you supply to each item emitted by the source Publisher, where that function returns a Publisher, and then emitting the items that result from concatenating those resulting Publishers.
  
  Backpressure:
  
  The operator honors backpressure from downstream. Both this and the inner Publishers are expected to honor backpressure as well. If the source Publisher violates the rule, the operator will signal a MissingBackpressureException. If any of the inner Publishers doesn't honor backpressure, that may throw an IllegalStateException when that Publisher completes.
  
  Scheduler:
  
  concatMap does not operate by default on a particular Scheduler.
  
  Type Parameters:
  
  R - the type of the inner Publisher sources and thus the output type
  
  Parameters:
  
  mapper - a function that, when applied to an item emitted by the source Publisher, returns a Publisher
  
  Returns:
  
  a Flowable that emits the result of applying the transformation function to each item emitted by the source Publisher and concatenating the Publishers obtained from this transformation
  
  See Also:
  
  ReactiveX operators documentation: FlatMap
  
  concatMap
  
  @CheckReturnValue @NonNull @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public final  Flowable concatMap(FunctionT,? extends Publisher> mapper, int prefetch)
  
  Returns a new Flowable that emits items resulting from applying a function that you supply to each item emitted by the source Publisher, where that function returns a Publisher, and then emitting the items that result from concatenating those resulting Publishers.
  
  Backpressure:
  
  The operator honors backpressure from downstream. Both this and the inner Publishers are expected to honor backpressure as well. If the source Publisher violates the rule, the operator will signal a MissingBackpressureException. If any of the inner Publishers doesn't honor backpressure, that may throw an IllegalStateException when that Publisher completes.
  
  Scheduler:
  
  concatMap does not operate by default on a particular Scheduler.
  
  Type Parameters:
  
  R - the type of the inner Publisher sources and thus the output type
  
  Parameters:
  
  mapper - a function that, when applied to an item emitted by the source Publisher, returns a Publisher
  
  prefetch - the number of elements to prefetch from the current Flowable
  
  Returns:
  
  a Flowable that emits the result of applying the transformation function to each item emitted by the source Publisher and concatenating the Publishers obtained from this transformation
  
  See Also:
  
  ReactiveX operators documentation: FlatMap
  
  concatMapCompletable
  
  @CheckReturnValue @SchedulerSupport(value="none") @BackpressureSupport(value=FULL) public final Completable concatMapCompletable(FunctionT,? extends CompletableSource> mapper)
  
  Maps the upstream items into CompletableSources and subscribes to them one after the other completes.
  
  Backpressure:
  
  The operator expects the upstream to support backpressure. If this Flowable violates the rule, the operator will signal a MissingBackpressureException.
  
  Scheduler:
  
  concatMapCompletable does not operate by default on a particular Scheduler.
  
  History: 2.1.11 - experimental
  
  Parameters:
  
  mapper - the function called with the upstream item and should return a CompletableSource to become the next source to be subscribed to
  
  Returns:
  
  a new Completable instance
  
  Since:
  
  2.2
  
  See Also:
  
  concatMapCompletableDelayError(Function)
  
  concatMapCompletable
  
  @CheckReturnValue @NonNull @SchedulerSupport(value="none") @BackpressureSupport(value=FULL) public final Completable concatMapCompletable(FunctionT,? extends CompletableSource> mapper, int prefetch)
  
  Maps the upstream items into CompletableSources and subscribes to them one after the other completes.
  
  Backpressure:
  
  The operator expects the upstream to support backpressure. If this Flowable violates the rule, the operator will signal a MissingBackpressureException.
  
  Scheduler:
  
  concatMapCompletable does not operate by default on a particular Scheduler.
  
  History: 2.1.11 - experimental
  
  Parameters:
  
  mapper - the function called with the upstream item and should return a CompletableSource to become the next source to be subscribed to
  
  prefetch - The number of upstream items to prefetch so that fresh items are ready to be mapped when a previous CompletableSource terminates. The operator replenishes after half of the prefetch amount has been consumed and turned into CompletableSources.
  
  Returns:
  
  a new Completable instance
  
  Since:
  
  2.2
  
  See Also:
  
  concatMapCompletableDelayError(Function, boolean, int)
  
  concatMapCompletableDelayError
  
  @CheckReturnValue @SchedulerSupport(value="none") @BackpressureSupport(value=FULL) public final Completable concatMapCompletableDelayError(FunctionT,? extends CompletableSource> mapper)
  
  Maps the upstream items into CompletableSources and subscribes to them one after the other terminates, delaying all errors till both this Flowable and all inner CompletableSources terminate.
  
  Backpressure:
  
  The operator expects the upstream to support backpressure. If this Flowable violates the rule, the operator will signal a MissingBackpressureException.
  
  Scheduler:
  
  concatMapCompletableDelayError does not operate by default on a particular Scheduler.
  
  History: 2.1.11 - experimental
  
  Parameters:
  
  mapper - the function called with the upstream item and should return a CompletableSource to become the next source to be subscribed to
  
  Returns:
  
  a new Completable instance
  
  Since:
  
  2.2
  
  See Also:
  
  concatMapCompletable(Function, int)
  
  concatMapCompletableDelayError
  
  @CheckReturnValue @SchedulerSupport(value="none") @BackpressureSupport(value=FULL) public final Completable concatMapCompletableDelayError(FunctionT,? extends CompletableSource> mapper, boolean tillTheEnd)
  
  Maps the upstream items into CompletableSources and subscribes to them one after the other terminates, optionally delaying all errors till both this Flowable and all inner CompletableSources terminate.
  
  Backpressure:
  
  The operator expects the upstream to support backpressure. If this Flowable violates the rule, the operator will signal a MissingBackpressureException.
  
  Scheduler:
  
  concatMapCompletableDelayError does not operate by default on a particular Scheduler.
  
  History: 2.1.11 - experimental
  
  Parameters:
  
  mapper - the function called with the upstream item and should return a CompletableSource to become the next source to be subscribed to
  
  tillTheEnd - If true, errors from this Flowable or any of the inner CompletableSources are delayed until all of them terminate. If false, an error from this Flowable is delayed until the current inner CompletableSource terminates and only then is it emitted to the downstream.
  
  Returns:
  
  a new Completable instance
  
  Since:
  
  2.2
  
  See Also:
  
  concatMapCompletable(Function)
  
  concatMapCompletableDelayError
  
  @CheckReturnValue @NonNull @SchedulerSupport(value="none") @BackpressureSupport(value=FULL) public final Completable concatMapCompletableDelayError(FunctionT,? extends CompletableSource> mapper, boolean tillTheEnd, int prefetch)
  
  Maps the upstream items into CompletableSources and subscribes to them one after the other terminates, optionally delaying all errors till both this Flowable and all inner CompletableSources terminate.
  
  Backpressure:
  
  The operator expects the upstream to support backpressure. If this Flowable violates the rule, the operator will signal a MissingBackpressureException.
  
  Scheduler:
  
  concatMapCompletableDelayError does not operate by default on a particular Scheduler.
  
  History: 2.1.11 - experimental
  
  Parameters:
  
  mapper - the function called with the upstream item and should return a CompletableSource to become the next source to be subscribed to
  
  tillTheEnd - If true, errors from this Flowable or any of the inner CompletableSources are delayed until all of them terminate. If false, an error from this Flowable is delayed until the current inner CompletableSource terminates and only then is it emitted to the downstream.
  
  prefetch - The number of upstream items to prefetch so that fresh items are ready to be mapped when a previous CompletableSource terminates. The operator replenishes after half of the prefetch amount has been consumed and turned into CompletableSources.
  
  Returns:
  
  a new Completable instance
  
  Since:
  
  2.2
  
  See Also:
  
  concatMapCompletable(Function, int)
  
  concatMapDelayError
  
  @CheckReturnValue @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public final  Flowable concatMapDelayError(FunctionT,? extends Publisher> mapper)
  
  Maps each of the items into a Publisher, 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 Publishers till all of them terminate.
  
  Backpressure:
  
  The operator honors backpressure from downstream. Both this and the inner Publishers are expected to honor backpressure as well. If the source Publisher violates the rule, the operator will signal a MissingBackpressureException. If any of the inner Publishers doesn't honor backpressure, that may throw an IllegalStateException when that Publisher completes.
  
  Scheduler:
  
  concatMapDelayError does not operate by default on a particular Scheduler.
  
  Type Parameters:
  
  R - the result value type
  
  Parameters:
  
  mapper - the function that maps the items of this Publisher into the inner Publishers.
  
  Returns:
  
  the new Publisher instance with the concatenation behavior
  
  concatMapDelayError
  
  @CheckReturnValue @NonNull @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public final  Flowable concatMapDelayError(FunctionT,? extends Publisher> mapper, int prefetch, boolean tillTheEnd)
  
  Maps each of the items into a Publisher, 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 Publishers till all of them terminate.
  
  Backpressure:
  
  The operator honors backpressure from downstream. Both this and the inner Publishers are expected to honor backpressure as well. If the source Publisher violates the rule, the operator will signal a MissingBackpressureException. If any of the inner Publishers doesn't honor backpressure, that may throw an IllegalStateException when that Publisher completes.
  
  Scheduler:
  
  concatMapDelayError does not operate by default on a particular Scheduler.
  
  Type Parameters:
  
  R - the result value type
  
  Parameters:
  
  mapper - the function that maps the items of this Publisher into the inner Publishers.
  
  prefetch - the number of elements to prefetch from the current Flowable
  
  tillTheEnd - if true, all errors from the outer and inner Publisher sources are delayed until the end, if false, an error from the main source is signaled when the current Publisher source terminates
  
  Returns:
  
  the new Publisher instance with the concatenation behavior
  
  concatMapEager
  
  @CheckReturnValue @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public final  Flowable concatMapEager(FunctionT,? extends Publisher> mapper)
  
  Maps a sequence of values into Publishers and concatenates these Publishers eagerly into a single Publisher.
  Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the source Publishers. The operator buffers the values emitted by these Publishers and then drains them in order, each one after the previous one completes.
  
  Backpressure:
  
  Backpressure is honored towards the downstream, however, due to the eagerness requirement, sources are subscribed to in unbounded mode and their values are queued up in an unbounded buffer.
  
  Scheduler:
  
  This method does not operate by default on a particular Scheduler.
  
  Type Parameters:
  
  R - the value type
  
  Parameters:
  
  mapper - the function that maps a sequence of values into a sequence of Publishers that will be eagerly concatenated
  
  Returns:
  
  the new Publisher instance with the specified concatenation behavior
  
  Since:
  
  2.0
  
  concatMapEager
  
  @CheckReturnValue @NonNull @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public final  Flowable concatMapEager(FunctionT,? extends Publisher> mapper, int maxConcurrency, int prefetch)
  
  Maps a sequence of values into Publishers and concatenates these Publishers eagerly into a single Publisher.
  Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the source Publishers. The operator buffers the values emitted by these Publishers and then drains them in order, each one after the previous one completes.
  
  Backpressure:
  
  Backpressure is honored towards the downstream, however, due to the eagerness requirement, sources are subscribed to in unbounded mode and their values are queued up in an unbounded buffer.
  
  Scheduler:
  
  This method does not operate by default on a particular Scheduler.
  
  Type Parameters:
  
  R - the value type
  
  Parameters:
  
  mapper - the function that maps a sequence of values into a sequence of Publishers that will be eagerly concatenated
  
  maxConcurrency - the maximum number of concurrent subscribed Publishers
  
  prefetch - hints about the number of expected values from each inner Publisher, must be positive
  
  Returns:
  
  the new Publisher instance with the specified concatenation behavior
  
  Since:
  
  2.0
  
  concatMapEagerDelayError
  
  @CheckReturnValue @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public final  Flowable concatMapEagerDelayError(FunctionT,? extends Publisher> mapper, boolean tillTheEnd)
  
  Maps a sequence of values into Publishers and concatenates these Publishers eagerly into a single Publisher.
  Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the source Publishers. The operator buffers the values emitted by these Publishers and then drains them in order, each one after the previous one completes.
  
  Backpressure:
  
  Backpressure is honored towards the downstream, however, due to the eagerness requirement, sources are subscribed to in unbounded mode and their values are queued up in an unbounded buffer.
  
  Scheduler:
  
  This method does not operate by default on a particular Scheduler.
  
  Type Parameters:
  
  R - the value type
  
  Parameters:
  
  mapper - the function that maps a sequence of values into a sequence of Publishers that will be eagerly concatenated
  
  tillTheEnd - if true, all errors from the outer and inner Publisher sources are delayed until the end, if false, an error from the main source is signaled when the current Publisher source terminates
  
  Returns:
  
  the new Publisher instance with the specified concatenation behavior
  
  Since:
  
  2.0
  
  concatMapEagerDelayError
  
  @CheckReturnValue @NonNull @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public final  Flowable concatMapEagerDelayError(FunctionT,? extends Publisher> mapper, int maxConcurrency, int prefetch, boolean tillTheEnd)
  
  Maps a sequence of values into Publishers and concatenates these Publishers eagerly into a single Publisher.
  Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the source Publishers. The operator buffers the values emitted by these Publishers and then drains them in order, each one after the previous one completes.
  
  Backpressure:
  
  Backpressure is honored towards the downstream, however, due to the eagerness requirement, sources are subscribed to in unbounded mode and their values are queued up in an unbounded buffer.
  
  Scheduler:
  
  This method does not operate by default on a particular Scheduler.
  
  Type Parameters:
  
  R - the value type
  
  Parameters:
  
  mapper - the function that maps a sequence of values into a sequence of Publishers that will be eagerly concatenated
  
  maxConcurrency - the maximum number of concurrent subscribed Publishers
  
  prefetch - the number of elements to prefetch from each source Publisher
  
  tillTheEnd - if true, exceptions from the current Flowable and all the inner Publishers are delayed until all of them terminate, if false, exception from the current Flowable is delayed until the currently running Publisher terminates
  
  Returns:
  
  the new Publisher instance with the specified concatenation behavior
  
  Since:
  
  2.0
  
  concatMapIterable
  
  @CheckReturnValue @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public final  Flowable concatMapIterable(FunctionT,? extends Iterable> mapper)
  
  Returns a Flowable that concatenate each item emitted by the source Publisher with the values in an Iterable corresponding to that item that is generated by a selector.
  
  Backpressure:
  
  The operator honors backpressure from downstream. The source Publishers is expected to honor backpressure as well. If the source Publisher violates the rule, the operator will signal a MissingBackpressureException.
  
  Scheduler:
  
  concatMapIterable does not operate by default on a particular Scheduler.
  
  Type Parameters:
  
  U - the type of item emitted by the resulting Publisher
  
  Parameters:
  
  mapper - a function that returns an Iterable sequence of values for when given an item emitted by the source Publisher
  
  Returns:
  
  a Flowable that emits the results of concatenating the items emitted by the source Publisher with the values in the Iterables corresponding to those items, as generated by collectionSelector
  
  See Also:
  
  ReactiveX operators documentation: FlatMap
  
  concatMapIterable
  
  @CheckReturnValue @NonNull @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public final  Flowable concatMapIterable(FunctionT,? extends Iterable> mapper, int prefetch)
  
  Returns a Flowable that concatenate each item emitted by the source Publisher with the values in an Iterable corresponding to that item that is generated by a selector.
  
  Backpressure:
  
  The operator honors backpressure from downstream. The source Publishers is expected to honor backpressure as well. If the source Publisher violates the rule, the operator will signal a MissingBackpressureException.
  
  Scheduler:
  
  concatMapIterable does not operate by default on a particular Scheduler.
  
  Type Parameters:
  
  U - the type of item emitted by the resulting Publisher
  
  Parameters:
  
  mapper - a function that returns an Iterable sequence of values for when given an item emitted by the source Publisher
  
  prefetch - the number of elements to prefetch from the current Flowable
  
  Returns:
  
  a Flowable that emits the results of concatenating the items emitted by the source Publisher with the values in the Iterables corresponding to those items, as generated by collectionSelector
  
  See Also:
  
  ReactiveX operators documentation: FlatMap
  
  concatMapMaybe
  
  @CheckReturnValue @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public final  Flowable concatMapMaybe(FunctionT,? extends MaybeSource> mapper)
  
  Maps the upstream items into MaybeSources and subscribes to them one after the other succeeds or completes, emits their success value if available or terminates immediately if either this Flowable or the current inner MaybeSource fail.
  
  Backpressure:
  
  The operator expects the upstream to support backpressure and honors the backpressure from downstream. If this Flowable violates the rule, the operator will signal a MissingBackpressureException.
  
  Scheduler:
  
  concatMapMaybe does not operate by default on a particular Scheduler.
  
  History: 2.1.11 - experimental
  
  Type Parameters:
  
  R - the result type of the inner MaybeSources
  
  Parameters:
  
  mapper - the function called with the upstream item and should return a MaybeSource to become the next source to be subscribed to
  
  Returns:
  
  a new Flowable instance
  
  Since:
  
  2.2
  
  See Also:
  
  concatMapMaybeDelayError(Function), concatMapMaybe(Function, int)
  
  concatMapMaybe
  
  @CheckReturnValue @NonNull @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public final  Flowable concatMapMaybe(FunctionT,? extends MaybeSource> mapper, int prefetch)
  
  Maps the upstream items into MaybeSources and subscribes to them one after the other succeeds or completes, emits their success value if available or terminates immediately if either this Flowable or the current inner MaybeSource fail.
  
  Backpressure:
  
  The operator expects the upstream to support backpressure and honors the backpressure from downstream. If this Flowable violates the rule, the operator will signal a MissingBackpressureException.
  
  Scheduler:
  
  concatMapMaybe does not operate by default on a particular Scheduler.
  
  History: 2.1.11 - experimental
  
  Type Parameters:
  
  R - the result type of the inner MaybeSources
  
  Parameters:
  
  mapper - the function called with the upstream item and should return a MaybeSource to become the next source to be subscribed to
  
  prefetch - The number of upstream items to prefetch so that fresh items are ready to be mapped when a previous MaybeSource terminates. The operator replenishes after half of the prefetch amount has been consumed and turned into MaybeSources.
  
  Returns:
  
  a new Flowable instance
  
  Since:
  
  2.2
  
  See Also:
  
  concatMapMaybe(Function), concatMapMaybeDelayError(Function, boolean, int)
  
  concatMapMaybeDelayError
  
  @CheckReturnValue @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public final  Flowable concatMapMaybeDelayError(FunctionT,? extends MaybeSource> mapper)
  
  Maps the upstream items into MaybeSources and subscribes to them one after the other terminates, emits their success value if available and delaying all errors till both this Flowable and all inner MaybeSources terminate.
  
  Backpressure:
  
  The operator expects the upstream to support backpressure and honors the backpressure from downstream. If this Flowable violates the rule, the operator will signal a MissingBackpressureException.
  
  Scheduler:
  
  concatMapMaybeDelayError does not operate by default on a particular Scheduler.
  
  History: 2.1.11 - experimental
  
  Type Parameters:
  
  R - the result type of the inner MaybeSources
  
  Parameters:
  
  mapper - the function called with the upstream item and should return a MaybeSource to become the next source to be subscribed to
  
  Returns:
  
  a new Flowable instance
  
  Since:
  
  2.2
  
  See Also:
  
  concatMapMaybe(Function), concatMapMaybeDelayError(Function, boolean)
  
  concatMapMaybeDelayError
  
  @CheckReturnValue @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public final  Flowable concatMapMaybeDelayError(FunctionT,? extends MaybeSource> mapper, boolean tillTheEnd)
  
  Maps the upstream items into MaybeSources and subscribes to them one after the other terminates, emits their success value if available and optionally delaying all errors till both this Flowable and all inner MaybeSources terminate.
  
  Backpressure:
  
  The operator expects the upstream to support backpressure and honors the backpressure from downstream. If this Flowable violates the rule, the operator will signal a MissingBackpressureException.
  
  Scheduler:
  
  concatMapMaybeDelayError does not operate by default on a particular Scheduler.
  
  History: 2.1.11 - experimental
  
  Type Parameters:
  
  R - the result type of the inner MaybeSources
  
  Parameters:
  
  mapper - the function called with the upstream item and should return a MaybeSource to become the next source to be subscribed to
  
  tillTheEnd - If true, errors from this Flowable or any of the inner MaybeSources are delayed until all of them terminate. If false, an error from this Flowable is delayed until the current inner MaybeSource terminates and only then is it emitted to the downstream.
  
  Returns:
  
  a new Flowable instance
  
  Since:
  
  2.2
  
  See Also:
  
  concatMapMaybe(Function, int), concatMapMaybeDelayError(Function, boolean, int)
  
  concatMapMaybeDelayError
  
  @CheckReturnValue @NonNull @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public final  Flowable concatMapMaybeDelayError(FunctionT,? extends MaybeSource> mapper, boolean tillTheEnd, int prefetch)
  
  Maps the upstream items into MaybeSources and subscribes to them one after the other terminates, emits their success value if available and optionally delaying all errors till both this Flowable and all inner MaybeSources terminate.
  
  Backpressure:
  
  The operator expects the upstream to support backpressure and honors the backpressure from downstream. If this Flowable violates the rule, the operator will signal a MissingBackpressureException.
  
  Scheduler:
  
  concatMapMaybeDelayError does not operate by default on a particular Scheduler.
  
  History: 2.1.11 - experimental
  
  Type Parameters:
  
  R - the result type of the inner MaybeSources
  
  Parameters:
  
  mapper - the function called with the upstream item and should return a MaybeSource to become the next source to be subscribed to
  
  tillTheEnd - If true, errors from this Flowable or any of the inner MaybeSources are delayed until all of them terminate. If false, an error from this Flowable is delayed until the current inner MaybeSource terminates and only then is it emitted to the downstream.
  
  prefetch - The number of upstream items to prefetch so that fresh items are ready to be mapped when a previous MaybeSource terminates. The operator replenishes after half of the prefetch amount has been consumed and turned into MaybeSources.
  
  Returns:
  
  a new Flowable instance
  
  Since:
  
  2.2
  
  See Also:
  
  concatMapMaybe(Function, int)
  
  concatMapSingle
  
  @CheckReturnValue @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public final  Flowable concatMapSingle(FunctionT,? extends SingleSource> mapper)
  
  Maps the upstream items into SingleSources and subscribes to them one after the other succeeds, emits their success values or terminates immediately if either this Flowable or the current inner SingleSource fail.
  
  Backpressure:
  
  The operator expects the upstream to support backpressure and honors the backpressure from downstream. If this Flowable violates the rule, the operator will signal a MissingBackpressureException.
  
  Scheduler:
  
  concatMapSingle does not operate by default on a particular Scheduler.
  
  History: 2.1.11 - experimental
  
  Type Parameters:
  
  R - the result type of the inner SingleSources
  
  Parameters:
  
  mapper - the function called with the upstream item and should return a SingleSource to become the next source to be subscribed to
  
  Returns:
  
  a new Flowable instance
  
  Since:
  
  2.2
  
  See Also:
  
  concatMapSingleDelayError(Function), concatMapSingle(Function, int)
  
  concatMapSingle
  
  @CheckReturnValue @NonNull @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public final  Flowable concatMapSingle(FunctionT,? extends SingleSource> mapper, int prefetch)
  
  Maps the upstream items into SingleSources and subscribes to them one after the other succeeds, emits their success values or terminates immediately if either this Flowable or the current inner SingleSource fail.
  
  Backpressure:
  
  The operator expects the upstream to support backpressure and honors the backpressure from downstream. If this Flowable violates the rule, the operator will signal a MissingBackpressureException.
  
  Scheduler:
  
  concatMapSingle does not operate by default on a particular Scheduler.
  
  History: 2.1.11 - experimental
  
  Type Parameters:
  
  R - the result type of the inner SingleSources
  
  Parameters:
  
  mapper - the function called with the upstream item and should return a SingleSource to become the next source to be subscribed to
  
  prefetch - The number of upstream items to prefetch so that fresh items are ready to be mapped when a previous SingleSource terminates. The operator replenishes after half of the prefetch amount has been consumed and turned into SingleSources.
  
  Returns:
  
  a new Flowable instance
  
  Since:
  
  2.2
  
  See Also:
  
  concatMapSingle(Function), concatMapSingleDelayError(Function, boolean, int)
  
  concatMapSingleDelayError
  
  @CheckReturnValue @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public final  Flowable concatMapSingleDelayError(FunctionT,? extends SingleSource> mapper)
  
  Maps the upstream items into SingleSources and subscribes to them one after the other succeeds or fails, emits their success values and delays all errors till both this Flowable and all inner SingleSources terminate.
  
  Backpressure:
  
  The operator expects the upstream to support backpressure and honors the backpressure from downstream. If this Flowable violates the rule, the operator will signal a MissingBackpressureException.
  
  Scheduler:
  
  concatMapSingleDelayError does not operate by default on a particular Scheduler.
  
  History: 2.1.11 - experimental
  
  Type Parameters:
  
  R - the result type of the inner SingleSources
  
  Parameters:
  
  mapper - the function called with the upstream item and should return a SingleSource to become the next source to be subscribed to
  
  Returns:
  
  a new Flowable instance
  
  Since:
  
  2.2
  
  See Also:
  
  concatMapSingle(Function), concatMapSingleDelayError(Function, boolean)
  
  concatMapSingleDelayError
  
  @CheckReturnValue @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public final  Flowable concatMapSingleDelayError(FunctionT,? extends SingleSource> mapper, boolean tillTheEnd)
  
  Maps the upstream items into SingleSources and subscribes to them one after the other succeeds or fails, emits their success values and optionally delays all errors till both this Flowable and all inner SingleSources terminate.
  
  Backpressure:
  
  The operator expects the upstream to support backpressure and honors the backpressure from downstream. If this Flowable violates the rule, the operator will signal a MissingBackpressureException.
  
  Scheduler:
  
  concatMapSingleDelayError does not operate by default on a particular Scheduler.
  
  History: 2.1.11 - experimental
  
  Type Parameters:
  
  R - the result type of the inner SingleSources
  
  Parameters:
  
  mapper - the function called with the upstream item and should return a SingleSource to become the next source to be subscribed to
  
  tillTheEnd - If true, errors from this Flowable or any of the inner SingleSources are delayed until all of them terminate. If false, an error from this Flowable is delayed until the current inner SingleSource terminates and only then is it emitted to the downstream.
  
  Returns:
  
  a new Flowable instance
  
  Since:
  
  2.2
  
  See Also:
  
  concatMapSingle(Function, int), concatMapSingleDelayError(Function, boolean, int)
  
  concatMapSingleDelayError
  
  @CheckReturnValue @NonNull @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public final  Flowable concatMapSingleDelayError(FunctionT,? extends SingleSource> mapper, boolean tillTheEnd, int prefetch)
  
  Maps the upstream items into SingleSources and subscribes to them one after the other succeeds or fails, emits their success values and optionally delays errors till both this Flowable and all inner SingleSources terminate.
  
  Backpressure:
  
  The operator expects the upstream to support backpressure and honors the backpressure from downstream. If this Flowable violates the rule, the operator will signal a MissingBackpressureException.
  
  Scheduler:
  
  concatMapSingleDelayError does not operate by default on a particular Scheduler.
  
  History: 2.1.11 - experimental
  
  Type Parameters:
  
  R - the result type of the inner SingleSources
  
  Parameters:
  
  mapper - the function called with the upstream item and should return a SingleSource to become the next source to be subscribed to
  
  tillTheEnd - If true, errors from this Flowable or any of the inner SingleSources are delayed until all of them terminate. If false, an error from this Flowable is delayed until the current inner SingleSource terminates and only then is it emitted to the downstream.
  
  prefetch - The number of upstream items to prefetch so that fresh items are ready to be mapped when a previous SingleSource terminates. The operator replenishes after half of the prefetch amount has been consumed and turned into SingleSources.
  
  Returns:
  
  a new Flowable instance
  
  Since:
  
  2.2
  
  See Also:
  
  concatMapSingle(Function, int)
  
  concatWith
  
  @CheckReturnValue @NonNull @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public final Flowable<T> concatWith(PublisherT> other)
  
  Returns a Flowable that emits the items emitted from the current Publisher, then the next, one after the other, without interleaving them.
  
  Backpressure:
  
  The operator honors backpressure from downstream. Both this and the other Publishers are expected to honor backpressure as well. If any of then violates this rule, it may throw an IllegalStateException when the source Publisher completes.
  
  Scheduler:
  
  concatWith does not operate by default on a particular Scheduler.
  
  Parameters:
  
  other - a Publisher to be concatenated after the current
  
  Returns:
  
  a Flowable that emits items emitted by the two source Publishers, one after the other, without interleaving them
  
  See Also:
  
  ReactiveX operators documentation: Concat
  
  concatWith
  
  @CheckReturnValue @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public final Flowable<T> concatWith(@NonNull SingleSourceT> other)
  
  Returns a Flowable that emits the items from this Flowable followed by the success item or error event of the other SingleSource.
  
  Backpressure:
  
  The operator supports backpressure and makes sure the success item of the other SingleSource is only emitted when there is a demand for it.
  
  Scheduler:
  
  concatWith does not operate by default on a particular Scheduler.
  
  History: 2.1.10 - experimental
  
  Parameters:
  
  other - the SingleSource whose signal should be emitted after this Flowable completes normally.
  
  Returns:
  
  the new Flowable instance
  
  Since:
  
  2.2
  
  concatWith
  
  @CheckReturnValue @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public final Flowable<T> concatWith(@NonNull MaybeSourceT> other)
  
  Returns a Flowable that emits the items from this Flowable followed by the success item or terminal events of the other MaybeSource.
  
  Backpressure:
  
  The operator supports backpressure and makes sure the success item of the other MaybeSource is only emitted when there is a demand for it.
  
  Scheduler:
  
  concatWith does not operate by default on a particular Scheduler.
  
  History: 2.1.10 - experimental
  
  Parameters:
  
  other - the MaybeSource whose signal should be emitted after this Flowable completes normally.
  
  Returns:
  
  the new Flowable instance
  
  Since:
  
  2.2
  
  concatWith
  
  @CheckReturnValue @BackpressureSupport(value=PASS_THROUGH) @SchedulerSupport(value="none") public final Flowable<T> concatWith(@NonNull CompletableSource other)
  
  Returns a Flowable that emits items from this Flowable and when it completes normally, the other CompletableSource is subscribed to and the returned Flowable emits its terminal events.
  
  Backpressure:
  
  The operator does not interfere with backpressure between the current Flowable and the downstream consumer (i.e., acts as pass-through). When the operator switches to the Completable, backpressure is no longer present because Completable doesn't have items to apply backpressure to.
  
  Scheduler:
  
  concatWith does not operate by default on a particular Scheduler.
  
  History: 2.1.10 - experimental
  
  Parameters:
  
  other - the CompletableSource to subscribe to once the current Flowable completes normally
  
  Returns:
  
  the new Flowable instance
  
  Since:
  
  2.2
  
  contains
  
  @CheckReturnValue @NonNull @BackpressureSupport(value=UNBOUNDED_IN) @SchedulerSupport(value="none") public final Single<Boolean> contains(Object item)
  
  Returns a Single that emits a Boolean that indicates whether the source Publisher emitted a specified item.
  
  Backpressure:
  
  The operator honors backpressure from downstream and consumes the source Publisher in an unbounded manner (i.e., without applying backpressure).
  
  Scheduler:
  
  contains does not operate by default on a particular Scheduler.
  
  Parameters:
  
  item - the item to search for in the emissions from the source Publisher
  
  Returns:
  
  a Flowable that emits true if the specified item is emitted by the source Publisher, or false if the source Publisher completes without emitting that item
  
  See Also:
  
  ReactiveX operators documentation: Contains
  
  count
  
  @CheckReturnValue @BackpressureSupport(value=UNBOUNDED_IN) @SchedulerSupport(value="none") public final Single<Long> count()
  
  Returns a Single that counts the total number of items emitted by the source Publisher and emits this count as a 64-bit Long.
  
  Backpressure:
  
  The operator honors backpressure from downstream and consumes the source Publisher in an unbounded manner (i.e., without applying backpressure).
  
  Scheduler:
  
  count does not operate by default on a particular Scheduler.
  
  Returns:
  
  a Single that emits a single item: the number of items emitted by the source Publisher as a 64-bit Long item
  
  See Also:
  
  ReactiveX operators documentation: Count
  
  debounce
  
  @CheckReturnValue @NonNull @BackpressureSupport(value=ERROR) @SchedulerSupport(value="none") public final  Flowable<T> debounce(FunctionT,? extends Publisher> debounceIndicator)
  
  Returns a Flowable that mirrors the source Publisher, except that it drops items emitted by the source Publisher that are followed by another item within a computed debounce duration.
  
  The delivery of the item happens on the thread of the first onNext or onComplete signal of the generated Publisher sequence, which if takes too long, a newer item may arrive from the upstream, causing the generated sequence to get cancelled, which may also interrupt any downstream blocking operation (yielding an InterruptedException). It is recommended processing items that may take long time to be moved to another thread via observeOn(io.reactivex.Scheduler) applied after debounce itself.
  
  Backpressure:
  
  This operator does not support backpressure as it uses the debounceSelector to mark boundaries.
  
  Scheduler:
  
  This version of debounce does not operate by default on a particular Scheduler.
  
  Type Parameters:
  
  U - the debounce value type (ignored)
  
  Parameters:
  
  debounceIndicator - function to retrieve a sequence that indicates the throttle duration for each item
  
  Returns:
  
  a Flowable that omits items emitted by the source Publisher that are followed by another item within a computed debounce duration
  
  See Also:
  
  ReactiveX operators documentation: Debounce, RxJava wiki: Backpressure
  
  debounce
  
  @CheckReturnValue @BackpressureSupport(value=ERROR) @SchedulerSupport(value="io.reactivex:computation") public final Flowable<T> debounce(long timeout, TimeUnit unit)
  
  Returns a Flowable that mirrors the source Publisher, except that it drops items emitted by the source Publisher that are followed by newer items before a timeout value expires. The timer resets on each emission.
  Note: If items keep being emitted by the source Publisher faster than the timeout then no items will be emitted by the resulting Publisher.
  
  Delivery of the item after the grace period happens on the computation Scheduler's Worker which if takes too long, a newer item may arrive from the upstream, causing the Worker's task to get disposed, which may also interrupt any downstream blocking operation (yielding an InterruptedException). It is recommended processing items that may take long time to be moved to another thread via observeOn(io.reactivex.Scheduler) applied after debounce itself.
  
  Backpressure:
  
  This operator does not support backpressure as it uses time to control data flow.
  
  Scheduler:
  
  debounce operates by default on the computation Scheduler.
  
  Parameters:
  
  timeout - the length of the window of time that must pass after the emission of an item from the source Publisher in which that Publisher emits no items in order for the item to be emitted by the resulting Publisher
  
  unit - the unit of time for the specified timeout
  
  Returns:
  
  a Flowable that filters out items from the source Publisher that are too quickly followed by newer items
  
  See Also:
  
  ReactiveX operators documentation: Debounce, RxJava wiki: Backpressure, throttleWithTimeout(long, TimeUnit)
  
  debounce
  
  @CheckReturnValue @NonNull @BackpressureSupport(value=ERROR) @SchedulerSupport(value="custom") public final Flowable<T> debounce(long timeout, TimeUnit unit, Scheduler scheduler)
  
  Returns a Flowable that mirrors the source Publisher, except that it drops items emitted by the source Publisher that are followed by newer items before a timeout value expires on a specified Scheduler. The timer resets on each emission.
  Note: If items keep being emitted by the source Publisher faster than the timeout then no items will be emitted by the resulting Publisher.
  
  Delivery of the item after the grace period happens on the given Scheduler's Worker which if takes too long, a newer item may arrive from the upstream, causing the Worker's task to get disposed, which may also interrupt any downstream blocking operation (yielding an InterruptedException). It is recommended processing items that may take long time to be moved to another thread via observeOn(io.reactivex.Scheduler) applied after debounce itself.
  
  Backpressure:
  
  This operator does not support backpressure as it uses time to control data flow.
  
  Scheduler:
  
  You specify which Scheduler this operator will use.
  
  Parameters:
  
  timeout - the time each item has to be "the most recent" of those emitted by the source Publisher to ensure that it's not dropped
  
  unit - the unit of time for the specified timeout
  
  scheduler - the Scheduler to use internally to manage the timers that handle the timeout for each item
  
  Returns:
  
  a Flowable that filters out items from the source Publisher that are too quickly followed by newer items
  
  See Also:
  
  ReactiveX operators documentation: Debounce, RxJava wiki: Backpressure, throttleWithTimeout(long, TimeUnit, Scheduler)
  
  defaultIfEmpty
  
  @CheckReturnValue @NonNull @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public final Flowable<T> defaultIfEmpty(T defaultItem)
  
  Returns a Flowable that emits the items emitted by the source Publisher or a specified default item if the source Publisher is empty.
  
  Backpressure:
  
  If the source Publisher is empty, this operator is guaranteed to honor backpressure from downstream. If the source Publisher is non-empty, it is expected to honor backpressure as well; if the rule is violated, a MissingBackpressureException may get signaled somewhere downstream.
  
  Scheduler:
  
  defaultIfEmpty does not operate by default on a particular Scheduler.
  
  Parameters:
  
  defaultItem - the item to emit if the source Publisher emits no items
  
  Returns:
  
  a Flowable that emits either the specified default item if the source Publisher emits no items, or the items emitted by the source Publisher
  
  See Also:
  
  ReactiveX operators documentation: DefaultIfEmpty
  
  delay
  
  @CheckReturnValue @NonNull @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public final  Flowable<T> delay(FunctionT,? extends Publisher> itemDelayIndicator)
  
  Returns a Flowable that delays the emissions of the source Publisher via another Publisher on a per-item basis.
  
  Note: the resulting Publisher will immediately propagate any onError notification from the source Publisher.
  
  Backpressure:
  
  The operator doesn't interfere with the backpressure behavior which is determined by the source Publisher. All of the other Publishers supplied by the function are consumed in an unbounded manner (i.e., no backpressure applied to them).
  
  Scheduler:
  
  This version of delay does not operate by default on a particular Scheduler.
  
  Type Parameters:
  
  U - the item delay value type (ignored)
  
  Parameters:
  
  itemDelayIndicator - a function that returns a Publisher for each item emitted by the source Publisher, which is then used to delay the emission of that item by the resulting Publisher until the Publisher returned from itemDelay emits an item
  
  Returns:
  
  a Flowable that delays the emissions of the source Publisher via another Publisher on a per-item basis
  
  See Also:
  
  ReactiveX operators documentation: Delay
  
  delay
  
  @CheckReturnValue @BackpressureSupport(value=FULL) @SchedulerSupport(value="io.reactivex:computation") public final Flowable<T> delay(long delay, TimeUnit unit)
  
  Returns a Flowable that emits the items emitted by the source Publisher shifted forward in time by a specified delay. Error notifications from the source Publisher are not delayed.
  
  Backpressure:
  
  The operator doesn't interfere with the backpressure behavior which is determined by the source Publisher.
  
  Scheduler:
  
  This version of delay operates by default on the computation Scheduler.
  
  Parameters:
  
  delay - the delay to shift the source by
  
  unit - the TimeUnit in which period is defined
  
  Returns:
  
  the source Publisher shifted in time by the specified delay
  
  See Also:
  
  ReactiveX operators documentation: Delay
  
  delay
  
  @CheckReturnValue @BackpressureSupport(value=FULL) @SchedulerSupport(value="io.reactivex:computation") public final Flowable<T> delay(long delay, TimeUnit unit, boolean delayError)
  
  Returns a Flowable that emits the items emitted by the source Publisher shifted forward in time by a specified delay. If delayError is true, error notifications will also be delayed.
  
  Backpressure:
  
  The operator doesn't interfere with the backpressure behavior which is determined by the source Publisher.
  
  Scheduler:
  
  This version of delay operates by default on the computation Scheduler.
  
  Parameters:
  
  delay - the delay to shift the source by
  
  unit - the TimeUnit in which period is defined
  
  delayError - if true, the upstream exception is signaled with the given delay, after all preceding normal elements, if false, the upstream exception is signaled immediately
  
  Returns:
  
  the source Publisher shifted in time by the specified delay
  
  See Also:
  
  ReactiveX operators documentation: Delay
  
  delay
  
  @CheckReturnValue @BackpressureSupport(value=FULL) @SchedulerSupport(value="custom") public final Flowable<T> delay(long delay, TimeUnit unit, Scheduler scheduler)
  
  Returns a Flowable that emits the items emitted by the source Publisher shifted forward in time by a specified delay. Error notifications from the source Publisher are not delayed.
  
  Backpressure:
  
  The operator doesn't interfere with the backpressure behavior which is determined by the source Publisher.
  
  Scheduler:
  
  You specify which Scheduler this operator will use.
  
  Parameters:
  
  delay - the delay to shift the source by
  
  unit - the time unit of delay
  
  scheduler - the Scheduler to use for delaying
  
  Returns:
  
  the source Publisher shifted in time by the specified delay
  
  See Also:
  
  ReactiveX operators documentation: Delay
  
  delay
  
  @CheckReturnValue @NonNull @BackpressureSupport(value=FULL) @SchedulerSupport(value="custom") public final Flowable<T> delay(long delay, TimeUnit unit, Scheduler scheduler, boolean delayError)
  
  Returns a Flowable that emits the items emitted by the source Publisher shifted forward in time by a specified delay. If delayError is true, error notifications will also be delayed.
  
  Backpressure:
  
  The operator doesn't interfere with the backpressure behavior which is determined by the source Publisher.
  
  Scheduler:
  
  You specify which Scheduler this operator will use.
  
  Parameters:
  
  delay - the delay to shift the source by
  
  unit - the time unit of delay
  
  scheduler - the Scheduler to use for delaying
  
  delayError - if true, the upstream exception is signaled with the given delay, after all preceding normal elements, if false, the upstream exception is signaled immediately
  
  Returns:
  
  the source Publisher shifted in time by the specified delay
  
  See Also:
  
  ReactiveX operators documentation: Delay
  
  delay
  
  @CheckReturnValue @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public final  Flowable<T> delay(Publisher subscriptionIndicator, FunctionT,? extends Publisher> itemDelayIndicator)
  
  Returns a Flowable that delays the subscription to and emissions from the source Publisher via another Publisher on a per-item basis.
  
  Note: the resulting Publisher will immediately propagate any onError notification from the source Publisher.
  
  Backpressure:
  
  The operator doesn't interfere with the backpressure behavior which is determined by the source Publisher. All of the other Publishers supplied by the functions are consumed in an unbounded manner (i.e., no backpressure applied to them).
  
  Scheduler:
  
  This version of delay does not operate by default on a particular Scheduler.
  
  Type Parameters:
  
  U - the subscription delay value type (ignored)
  
  V - the item delay value type (ignored)
  
  Parameters:
  
  subscriptionIndicator - a function that returns a Publisher that triggers the subscription to the source Publisher once it emits any item
  
  itemDelayIndicator - a function that returns a Publisher for each item emitted by the source Publisher, which is then used to delay the emission of that item by the resulting Publisher until the Publisher returned from itemDelay emits an item
  
  Returns:
  
  a Flowable that delays the subscription and emissions of the source Publisher via another Publisher on a per-item basis
  
  See Also:
  
  ReactiveX operators documentation: Delay
  
  delaySubscription
  
  @CheckReturnValue @NonNull @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public final  Flowable<T> delaySubscription(Publisher subscriptionIndicator)
  
  Returns a Flowable that delays the subscription to this Publisher until the other Publisher emits an element or completes normally.
  
  Backpressure:
  
  The operator forwards the backpressure requests to this Publisher once the subscription happens and requests Long.MAX_VALUE from the other Publisher
  
  Scheduler:
  
  This method does not operate by default on a particular Scheduler.
  
  Type Parameters:
  
  U - the value type of the other Publisher, irrelevant
  
  Parameters:
  
  subscriptionIndicator - the other Publisher that should trigger the subscription to this Publisher.
  
  Returns:
  
  a Flowable that delays the subscription to this Publisher until the other Publisher emits an element or completes normally.
  
  Since:
  
  2.0
  
  delaySubscription
  
  @CheckReturnValue @BackpressureSupport(value=FULL) @SchedulerSupport(value="io.reactivex:computation") public final Flowable<T> delaySubscription(long delay, TimeUnit unit)
  
  Returns a Flowable that delays the subscription to the source Publisher by a given amount of time.
  
  Backpressure:
  
  The operator doesn't interfere with the backpressure behavior which is determined by the source Publisher.
  
  Scheduler:
  
  This version of delaySubscription operates by default on the computation Scheduler.
  
  Parameters:
  
  delay - the time to delay the subscription
  
  unit - the time unit of delay
  
  Returns:
  
  a Flowable that delays the subscription to the source Publisher by the given amount
  
  See Also:
  
  ReactiveX operators documentation: Delay
  
  delaySubscription
  
  @CheckReturnValue @BackpressureSupport(value=FULL) @SchedulerSupport(value="custom") public final Flowable<T> delaySubscription(long delay, TimeUnit unit, Scheduler scheduler)
  
  Returns a Flowable that delays the subscription to the source Publisher by a given amount of time, both waiting and subscribing on a given Scheduler.
  
  Backpressure:
  
  The operator doesn't interfere with the backpressure behavior which is determined by the source Publisher.
  
  Scheduler:
  
  You specify which Scheduler this operator will use.
  
  Parameters:
  
  delay - the time to delay the subscription
  
  unit - the time unit of delay
  
  scheduler - the Scheduler on which the waiting and subscription will happen
  
  Returns:
  
  a Flowable that delays the subscription to the source Publisher by a given amount, waiting and subscribing on the given Scheduler
  
  See Also:
  
  ReactiveX operators documentation: Delay
  
  dematerialize
  
  @CheckReturnValue @SchedulerSupport(value="none") @BackpressureSupport(value=PASS_THROUGH) @Deprecated public final  Flowable dematerialize()
  
  Deprecated. in 2.2.4; inherently type-unsafe as it overrides the output generic type. Use dematerialize(Function) instead.
  
  Returns a Flowable that reverses the effect of materialize by transforming the Notification objects emitted by the source Publisher into the items or notifications they represent.
  
  When the upstream signals an onError or onComplete item, the returned Flowable cancels the flow and terminates with that type of terminal event:
  Flowable.just(createOnNext(1), createOnComplete(), createOnNext(2)) .doOnCancel(() -> System.out.println("Cancelled!")); .dematerialize() .test() .assertResult(1);
  If the upstream signals onError or onComplete directly, the flow is terminated with the same event.
  Flowable.just(createOnNext(1), createOnNext(2)) .dematerialize() .test() .assertResult(1, 2);
  If this behavior is not desired, the completion can be suppressed by applying concatWith(Publisher) with a never() source.
  
  Backpressure:
  
  The operator doesn't interfere with backpressure which is determined by the source Publisher's backpressure behavior.
  
  Scheduler:
  
  dematerialize does not operate by default on a particular Scheduler.
  
  Type Parameters:
  
  T2 - the output value type
  
  Returns:
  
  a Flowable that emits the items and notifications embedded in the Notification objects emitted by the source Publisher
  
  See Also:
  
  ReactiveX operators documentation: Dematerialize, dematerialize(Function)
  
  dematerialize
  
  @CheckReturnValue @NonNull @SchedulerSupport(value="none") @BackpressureSupport(value=PASS_THROUGH) public final  Flowable dematerialize(FunctionT,Notification> selector)
  
  Returns a Flowable that reverses the effect of materialize by transforming the Notification objects extracted from the source items via a selector function into their respective Subscriber signal types.
  
  The intended use of the selector function is to perform a type-safe identity mapping (see example) on a source that is already of type Notification. The Java language doesn't allow limiting instance methods to a certain generic argument shape, therefore, a function is used to ensure the conversion remains type safe.
  When the upstream signals an onError or onComplete item, the returned Flowable cancels of the flow and terminates with that type of terminal event:
  Flowable.just(createOnNext(1), createOnComplete(), createOnNext(2)) .doOnCancel(() -> System.out.println("Canceled!")); .dematerialize(notification -> notification) .test() .assertResult(1);
  If the upstream signals onError or onComplete directly, the flow is terminated with the same event.
  Flowable.just(createOnNext(1), createOnNext(2)) .dematerialize(notification -> notification) .test() .assertResult(1, 2);
  If this behavior is not desired, the completion can be suppressed by applying concatWith(Publisher) with a never() source.
  
  Backpressure:
  
  The operator doesn't interfere with backpressure which is determined by the source Publisher's backpressure behavior.
  
  Scheduler:
  
  dematerialize does not operate by default on a particular Scheduler.
  
  Type Parameters:
  
  R - the output value type
  
  Parameters:
  
  selector - function that returns the upstream item and should return a Notification to signal the corresponding Subscriber event to the downstream.
  
  Returns:
  
  a Flowable that emits the items and notifications embedded in the Notification objects selected from the items emitted by the source Flowable
  
  Since:
  
  2.2.4 - experimental
  
  See Also:
  
  ReactiveX operators documentation: Dematerialize
  
  distinct
  
  @CheckReturnValue @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public final Flowable<T> distinct()
  
  Returns a Flowable that emits all items emitted by the source Publisher that are distinct based on Object.equals(Object) comparison.
  
  It is recommended the elements' class T in the flow overrides the default Object.equals() and Object.hashCode() to provide a meaningful comparison between items as the default Java implementation only considers reference equivalence.
  By default, distinct() uses an internal HashSet per Subscriber to remember previously seen items and uses Set.add(Object) returning false as the indicator for duplicates.
  Note that this internal HashSet may grow unbounded as items won't be removed from it by the operator. Therefore, using very long or infinite upstream (with very distinct elements) may lead to OutOfMemoryError.
  Customizing the retention policy can happen only by providing a custom Collection implementation to the distinct(Function, Callable) overload.
  
  Backpressure:
  
  The operator doesn't interfere with backpressure which is determined by the source Publisher's backpressure behavior.
  
  Scheduler:
  
  distinct does not operate by default on a particular Scheduler.
  
  Returns:
  
  a Flowable that emits only those items emitted by the source Publisher that are distinct from each other
  
  See Also:
  
  ReactiveX operators documentation: Distinct, distinct(Function), distinct(Function, Callable)
  
  distinct
  
  @CheckReturnValue @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public final  Flowable<T> distinct(FunctionT,K> keySelector)
  
  Returns a Flowable that emits all items emitted by the source Publisher 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.
  
  It is recommended the keys' class K overrides the default Object.equals() and Object.hashCode() to provide a meaningful comparison between the key objects as the default Java implementation only considers reference equivalence.
  By default, distinct() uses an internal HashSet per Subscriber to remember previously seen keys and uses Set.add(Object) returning false as the indicator for duplicates.
  Note that this internal HashSet may grow unbounded as keys won't be removed from it by the operator. Therefore, using very long or infinite upstream (with very distinct keys) may lead to OutOfMemoryError.
  Customizing the retention policy can happen only by providing a custom Collection implementation to the distinct(Function, Callable) overload.
  
  Backpressure:
  
  The operator doesn't interfere with backpressure which is determined by the source Publisher's backpressure behavior.
  
  Scheduler:
  
  distinct does not operate by default on a particular Scheduler.
  
  Type Parameters:
  
  K - the key type
  
  Parameters:
  
  keySelector - a function that projects an emitted item to a key value that is used to decide whether an item is distinct from another one or not
  
  Returns:
  
  a Flowable that emits those items emitted by the source Publisher that have distinct keys
  
  See Also:
  
  ReactiveX operators documentation: Distinct, distinct(Function, Callable)
  
  distinct
  
  @CheckReturnValue @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public final  Flowable<T> distinct(FunctionT,K> keySelector, CallableCollection> collectionSupplier)
  
  Returns a Flowable that emits all items emitted by the source Publisher 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.
  
  It is recommended the keys' class K overrides the default Object.equals() and Object.hashCode() to provide a meaningful comparison between the key objects as the default Java implementation only considers reference equivalence.
  
  Backpressure:
  
  The operator doesn't interfere with backpressure which is determined by the source Publisher's backpressure behavior.
  
  Scheduler:
  
  distinct does not operate by default on a particular Scheduler.
  
  Type Parameters:
  
  K - the key type
  
  Parameters:
  
  keySelector - a function that projects an emitted item to a key value that is used to decide whether an item is distinct from another one or not
  
  collectionSupplier - function called for each individual Subscriber to return a Collection subtype for holding the extracted keys and whose add() method's return indicates uniqueness.
  
  Returns:
  
  a Flowable that emits those items emitted by the source Publisher that have distinct keys
  
  See Also:
  
  ReactiveX operators documentation: Distinct
  
  distinctUntilChanged
  
  @CheckReturnValue @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public final Flowable<T> distinctUntilChanged()
  
  Returns a Flowable that emits all items emitted by the source Publisher that are distinct from their immediate predecessors based on Object.equals(Object) comparison.
  
  It is recommended the elements' class T in the flow overrides the default Object.equals() to provide a meaningful comparison between items as the default Java implementation only considers reference equivalence. Alternatively, use the distinctUntilChanged(BiPredicate) overload and provide a comparison function in case the class T can't be overridden with custom equals() or the comparison itself should happen on different terms or properties of the class T.
  Note that the operator always retains the latest item from upstream regardless of the comparison result and uses it in the next comparison with the next upstream item.
  Note that if element type T in the flow is mutable, the comparison of the previous and current item may yield unexpected results if the items are mutated externally. Common cases are mutable CharSequences or Lists where the objects will actually have the same references when they are modified and distinctUntilChanged will evaluate subsequent items as same. To avoid such situation, it is recommended that mutable data is converted to an immutable one, for example using map(CharSequence::toString) or map(list -> Collections.unmodifiableList(new ArrayList<>(list))).
  
  Backpressure:
  
  The operator doesn't interfere with backpressure which is determined by the source Publisher's backpressure behavior.
  
  Scheduler:
  
  distinctUntilChanged does not operate by default on a particular Scheduler.
  
  Returns:
  
  a Flowable that emits those items from the source Publisher that are distinct from their immediate predecessors
  
  See Also:
  
  ReactiveX operators documentation: Distinct, distinctUntilChanged(BiPredicate)
  
  distinctUntilChanged
  
  @CheckReturnValue @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public final  Flowable<T> distinctUntilChanged(FunctionT,K> keySelector)
  
  Returns a Flowable that emits all items emitted by the source Publisher 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.
  
  It is recommended the keys' class K overrides the default Object.equals() to provide a meaningful comparison between the key objects as the default Java implementation only considers reference equivalence. Alternatively, use the distinctUntilChanged(BiPredicate) overload and provide a comparison function in case the class K can't be overridden with custom equals() or the comparison itself should happen on different terms or properties of the item class T (for which the keys can be derived via a similar selector).
  Note that the operator always retains the latest key from upstream regardless of the comparison result and uses it in the next comparison with the next key derived from the next upstream item.
  Note that if element type T in the flow is mutable, the comparison of the previous and current item may yield unexpected results if the items are mutated externally. Common cases are mutable CharSequences or Lists where the objects will actually have the same references when they are modified and distinctUntilChanged will evaluate subsequent items as same. To avoid such situation, it is recommended that mutable data is converted to an immutable one, for example using map(CharSequence::toString) or map(list -> Collections.unmodifiableList(new ArrayList<>(list))).
  
  Backpressure:
  
  The operator doesn't interfere with backpressure which is determined by the source Publisher's backpressure behavior.
  
  Scheduler:
  
  distinctUntilChanged does not operate by default on a particular Scheduler.
  
  Type Parameters:
  
  K - the key type
  
  Parameters:
  
  keySelector - a function that projects an emitted item to a key value that is used to decide whether an item is distinct from another one or not
  
  Returns:
  
  a Flowable that emits those items from the source Publisher whose keys are distinct from those of their immediate predecessors
  
  See Also:
  
  ReactiveX operators documentation: Distinct
  
  distinctUntilChanged
  
  @CheckReturnValue @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public final Flowable<T> distinctUntilChanged(BiPredicateT,? super T> comparer)
  
  Returns a Flowable that emits all items emitted by the source Publisher that are distinct from their immediate predecessors when compared with each other via the provided comparator function.
  
  Note that the operator always retains the latest item from upstream regardless of the comparison result and uses it in the next comparison with the next upstream item.
  Note that if element type T in the flow is mutable, the comparison of the previous and current item may yield unexpected results if the items are mutated externally. Common cases are mutable CharSequences or Lists where the objects will actually have the same references when they are modified and distinctUntilChanged will evaluate subsequent items as same. To avoid such situation, it is recommended that mutable data is converted to an immutable one, for example using map(CharSequence::toString) or map(list -> Collections.unmodifiableList(new ArrayList<>(list))).
  
  Backpressure:
  
  The operator doesn't interfere with backpressure which is determined by the source Publisher's backpressure behavior.
  
  Scheduler:
  
  distinctUntilChanged does not operate by default on a particular Scheduler.
  
  Parameters:
  
  comparer - the function that receives the previous item and the current item and is expected to return true if the two are equal, thus skipping the current value.
  
  Returns:
  
  a Flowable that emits those items from the source Publisher that are distinct from their immediate predecessors
  
  Since:
  
  2.0
  
  See Also:
  
  ReactiveX operators documentation: Distinct
  
  doFinally
  
  @CheckReturnValue @BackpressureSupport(value=PASS_THROUGH) @SchedulerSupport(value="none") public final Flowable<T> doFinally(Action onFinally)
  
  Calls the specified action after this Flowable signals onError or onCompleted or gets canceled by the downstream.
  In case of a race between a terminal event and a cancellation, the provided onFinally action is executed once per subscription.
  Note that the onFinally action is shared between subscriptions and as such should be thread-safe.
  
  Backpressure:
  
  The operator doesn't interfere with backpressure which is determined by the source Publisher's backpressure behavior.
  
  Scheduler:
  
  doFinally does not operate by default on a particular Scheduler.
  
  Operator-fusion:
  
  This operator supports normal and conditional Subscribers as well as boundary-limited synchronous or asynchronous queue-fusion.
  
  History: 2.0.1 - experimental
  
  Parameters:
  
  onFinally - the action called when this Flowable terminates or gets canceled
  
  Returns:
  
  the new Flowable instance
  
  Since:
  
  2.1
  
  doAfterNext
  
  @CheckReturnValue @BackpressureSupport(value=PASS_THROUGH) @SchedulerSupport(value="none") public final Flowable<T> doAfterNext(ConsumerT> onAfterNext)
  
  Calls the specified consumer with the current item after this item has been emitted to the downstream.
  Note that the onAfterNext action is shared between subscriptions and as such should be thread-safe.
  
  Backpressure:
  
  The operator doesn't interfere with backpressure which is determined by the source Publisher's backpressure behavior.
  
  Scheduler:
  
  doAfterNext does not operate by default on a particular Scheduler.
  
  Operator-fusion:
  
  This operator supports normal and conditional Subscribers as well as boundary-limited synchronous or asynchronous queue-fusion.
  
  History: 2.0.1 - experimental
  
  Parameters:
  
  onAfterNext - the Consumer that will be called after emitting an item from upstream to the downstream
  
  Returns:
  
  the new Flowable instance
  
  Since:
  
  2.1
  
  doAfterTerminate
  
  @CheckReturnValue @BackpressureSupport(value=PASS_THROUGH) @SchedulerSupport(value="none") public final Flowable<T> doAfterTerminate(Action onAfterTerminate)
  
  Registers an Action to be called when this Publisher invokes either onComplete or onError.
  
  Backpressure:
  
  The operator doesn't interfere with backpressure which is determined by the source Publisher's backpressure behavior.
  
  Scheduler:
  
  doAfterTerminate does not operate by default on a particular Scheduler.
  
  Parameters:
  
  onAfterTerminate - an Action to be invoked when the source Publisher finishes
  
  Returns:
  
  a Flowable that emits the same items as the source Publisher, then invokes the Action
  
  See Also:
  
  ReactiveX operators documentation: Do, doOnTerminate(Action)
  
  doOnCancel
  
  @CheckReturnValue @BackpressureSupport(value=PASS_THROUGH) @SchedulerSupport(value="none") public final Flowable<T> doOnCancel(Action onCancel)
  
  Calls the cancel Action if the downstream cancels the sequence.
  The action is shared between subscriptions and thus may be called concurrently from multiple threads; the action must be thread-safe.
  If the action throws a runtime exception, that exception is rethrown by the onCancel() call, sometimes as a CompositeException if there were multiple exceptions along the way.
  Note that terminal events trigger the action unless the Publisher is subscribed to via unsafeSubscribe().
  
  Backpressure:
  
  doOnCancel does not interact with backpressure requests or value delivery; backpressure behavior is preserved between its upstream and its downstream.
  
  Scheduler:
  
  doOnCancel does not operate by default on a particular Scheduler.
  
  Parameters:
  
  onCancel - the action that gets called when the source Publisher's Subscription is canceled
  
  Returns:
  
  the source Publisher modified so as to call this Action when appropriate
  
  See Also:
  
  ReactiveX operators documentation: Do
  
  doOnComplete
  
  @CheckReturnValue @BackpressureSupport(value=PASS_THROUGH) @SchedulerSupport(value="none") public final Flowable<T> doOnComplete(Action onComplete)
  
  Modifies the source Publisher so that it invokes an action when it calls onComplete.
  
  Backpressure:
  
  The operator doesn't interfere with backpressure which is determined by the source Publisher's backpressure behavior.
  
  Scheduler:
  
  doOnComplete does not operate by default on a particular Scheduler.
  
  Parameters:
  
  onComplete - the action to invoke when the source Publisher calls onComplete
  
  Returns:
  
  the source Publisher with the side-effecting behavior applied
  
  See Also:
  
  ReactiveX operators documentation: Do
  
  doOnEach
  
  @CheckReturnValue @NonNull @BackpressureSupport(value=PASS_THROUGH) @SchedulerSupport(value="none") public final Flowable<T> doOnEach(ConsumerNotification<T>> onNotification)
  
  Modifies the source Publisher so that it invokes an action for each item it emits.
  
  Backpressure:
  
  The operator doesn't interfere with backpressure which is determined by the source Publisher's backpressure behavior.
  
  Scheduler:
  
  doOnEach does not operate by default on a particular Scheduler.
  
  Parameters:
  
  onNotification - the action to invoke for each item emitted by the source Publisher
  
  Returns:
  
  the source Publisher with the side-effecting behavior applied
  
  See Also:
  
  ReactiveX operators documentation: Do
  
  doOnEach
  
  @CheckReturnValue @NonNull @BackpressureSupport(value=PASS_THROUGH) @SchedulerSupport(value="none") public final Flowable<T> doOnEach(SubscriberT> subscriber)
  
  Modifies the source Publisher so that it notifies a Subscriber for each item and terminal event it emits.
  In case the onError of the supplied Subscriber throws, the downstream will receive a composite exception containing the original exception and the exception thrown by onError. If either the onNext or the onComplete method of the supplied Subscriber throws, the downstream will be terminated and will receive this thrown exception.
  
  Backpressure:
  
  The operator doesn't interfere with backpressure which is determined by the source Publisher's backpressure behavior.
  
  Scheduler:
  
  doOnEach does not operate by default on a particular Scheduler.
  
  Parameters:
  
  subscriber - the Subscriber to be notified about onNext, onError and onComplete events on its respective methods before the actual downstream Subscriber gets notified.
  
  Returns:
  
  the source Publisher with the side-effecting behavior applied
  
  See Also:
  
  ReactiveX operators documentation: Do
  
  doOnError
  
  @CheckReturnValue @BackpressureSupport(value=PASS_THROUGH) @SchedulerSupport(value="none") public final Flowable<T> doOnError(ConsumerThrowable> onError)
  
  Modifies the source Publisher so that it invokes an action if it calls onError.
  In case the onError action throws, the downstream will receive a composite exception containing the original exception and the exception thrown by onError.
  
  Backpressure:
  
  The operator doesn't interfere with backpressure which is determined by the source Publisher's backpressure behavior.
  
  Scheduler:
  
  doOnError does not operate by default on a particular Scheduler.
  
  Parameters:
  
  onError - the action to invoke if the source Publisher calls onError
  
  Returns:
  
  the source Publisher with the side-effecting behavior applied
  
  See Also:
  
  ReactiveX operators documentation: Do
  
  doOnLifecycle
  
  @CheckReturnValue @NonNull @BackpressureSupport(value=PASS_THROUGH) @SchedulerSupport(value="none") public final Flowable<T> doOnLifecycle(ConsumerSubscription> onSubscribe, LongConsumer onRequest, Action onCancel)
  
  Calls the appropriate onXXX method (shared between all Subscribers) for the lifecycle events of the sequence (subscription, cancellation, requesting).
  
  Backpressure:
  
  The operator doesn't interfere with backpressure which is determined by the source Publisher's backpressure behavior.
  
  Scheduler:
  
  doOnLifecycle does not operate by default on a particular Scheduler.
  
  Parameters:
  
  onSubscribe - a Consumer called with the Subscription sent via Subscriber.onSubscribe()
  
  onRequest - a LongConsumer called with the request amount sent via Subscription.request()
  
  onCancel - called when the downstream cancels the Subscription via cancel()
  
  Returns:
  
  the source Publisher with the side-effecting behavior applied
  
  See Also:
  
  ReactiveX operators documentation: Do
  
  doOnNext
  
  @CheckReturnValue @BackpressureSupport(value=PASS_THROUGH) @SchedulerSupport(value="none") public final Flowable<T> doOnNext(ConsumerT> onNext)
  
  Modifies the source Publisher so that it invokes an action when it calls onNext.
  
  Backpressure:
  
  The operator doesn't interfere with backpressure which is determined by the source Publisher's backpressure behavior.
  
  Scheduler:
  
  doOnNext does not operate by default on a particular Scheduler.
  
  Parameters:
  
  onNext - the action to invoke when the source Publisher calls onNext
  
  Returns:
  
  the source Publisher with the side-effecting behavior applied
  
  See Also:
  
  ReactiveX operators documentation: Do
  
  doOnRequest
  
  @CheckReturnValue @BackpressureSupport(value=PASS_THROUGH) @SchedulerSupport(value="none") public final Flowable<T> doOnRequest(LongConsumer onRequest)
  
  Modifies the source Publisher so that it invokes the given action when it receives a request for more items.
  Note: This operator is for tracing the internal behavior of back-pressure request patterns and generally intended for debugging use.
  
  Backpressure:
  
  The operator doesn't interfere with backpressure which is determined by the source Publisher's backpressure behavior.
  
  Scheduler:
  
  doOnRequest does not operate by default on a particular Scheduler.
  
  Parameters:
  
  onRequest - the action that gets called when a Subscriber requests items from this Publisher
  
  Returns:
  
  the source Publisher modified so as to call this Action when appropriate
  
  Since:
  
  2.0
  
  See Also:
  
  ReactiveX operators documentation: Do
  
  doOnSubscribe
  
  @CheckReturnValue @BackpressureSupport(value=PASS_THROUGH) @SchedulerSupport(value="none") public final Flowable<T> doOnSubscribe(ConsumerSubscription> onSubscribe)
  
  Modifies the source Publisher so that it invokes the given action when it is subscribed from its subscribers. Each subscription will result in an invocation of the given action except when the source Publisher is reference counted, in which case the source Publisher will invoke the given action for the first subscription.
  
  Backpressure:
  
  The operator doesn't interfere with backpressure which is determined by the source Publisher's backpressure behavior.
  
  Scheduler:
  
  doOnSubscribe does not operate by default on a particular Scheduler.
  
  Parameters:
  
  onSubscribe - the Consumer that gets called when a Subscriber subscribes to the current Flowable
  
  Returns:
  
  the source Publisher modified so as to call this Consumer when appropriate
  
  See Also:
  
  ReactiveX operators documentation: Do
  
  doOnTerminate
  
  @CheckReturnValue @BackpressureSupport(value=PASS_THROUGH) @SchedulerSupport(value="none") public final Flowable<T> doOnTerminate(Action onTerminate)
  
  Modifies the source Publisher so that it invokes an action when it calls onComplete or onError.
  
  This differs from doAfterTerminate in that this happens before the onComplete or onError notification.
  
  Backpressure:
  
  The operator doesn't interfere with backpressure which is determined by the source Publisher's backpressure behavior.
  
  Scheduler:
  
  doOnTerminate does not operate by default on a particular Scheduler.
  
  Parameters:
  
  onTerminate - the action to invoke when the source Publisher calls onComplete or onError
  
  Returns:
  
  the source Publisher with the side-effecting behavior applied
  
  See Also:
  
  ReactiveX operators documentation: Do, doAfterTerminate(Action)
  
  elementAt
  
  @CheckReturnValue @BackpressureSupport(value=UNBOUNDED_IN) @SchedulerSupport(value="none") public final Maybe<T> elementAt(long index)
  
  Returns a Maybe that emits the single item at a specified index in a sequence of emissions from this Flowable or completes if this Flowable sequence has fewer elements than index.
  
  Backpressure:
  
  The operator honors backpressure from downstream and consumes the source Publisher in an unbounded manner (i.e., no backpressure applied to it).
  
  Scheduler:
  
  elementAt does not operate by default on a particular Scheduler.
  
  Parameters:
  
  index - the zero-based index of the item to retrieve
  
  Returns:
  
  a Maybe that emits a single item: the item at the specified position in the sequence of those emitted by the source Publisher
  
  See Also:
  
  ReactiveX operators documentation: ElementAt
  
  elementAt
  
  @CheckReturnValue @NonNull @BackpressureSupport(value=UNBOUNDED_IN) @SchedulerSupport(value="none") public final Single<T> elementAt(long index, T defaultItem)
  
  Returns a Single that emits the item found at a specified index in a sequence of emissions from this Flowable, or a default item if that index is out of range.
  
  Backpressure:
  
  The operator honors backpressure from downstream and consumes the source Publisher in an unbounded manner (i.e., no backpressure applied to it).
  
  Scheduler:
  
  elementAt does not operate by default on a particular Scheduler.
  
  Parameters:
  
  index - the zero-based index of the item to retrieve
  
  defaultItem - the default item
  
  Returns:
  
  a Single that emits the item at the specified position in the sequence emitted by the source Publisher, or the default item if that index is outside the bounds of the source sequence
  
  Throws:
  
  IndexOutOfBoundsException - if index is less than 0
  
  See Also:
  
  ReactiveX operators documentation: ElementAt
  
  elementAtOrError
  
  @CheckReturnValue @BackpressureSupport(value=UNBOUNDED_IN) @SchedulerSupport(value="none") public final Single<T> elementAtOrError(long index)
  
  Returns a Single that emits the item found at a specified index in a sequence of emissions from this Flowable or signals a NoSuchElementException if this Flowable has fewer elements than index.
  
  Backpressure:
  
  The operator honors backpressure from downstream and consumes the source Publisher in an unbounded manner (i.e., no backpressure applied to it).
  
  Scheduler:
  
  elementAtOrError does not operate by default on a particular Scheduler.
  
  Parameters:
  
  index - the zero-based index of the item to retrieve
  
  Returns:
  
  a Single that emits the item at the specified position in the sequence emitted by the source Publisher, or the default item if that index is outside the bounds of the source sequence
  
  Throws:
  
  IndexOutOfBoundsException - if index is less than 0
  
  See Also:
  
  ReactiveX operators documentation: ElementAt
  
  filter
  
  @CheckReturnValue @NonNull @BackpressureSupport(value=PASS_THROUGH) @SchedulerSupport(value="none") public final Flowable<T> filter(PredicateT> predicate)
  
  Filters items emitted by a Publisher by only emitting those that satisfy a specified predicate.
  
  Backpressure:
  
  The operator doesn't interfere with backpressure which is determined by the source Publisher's backpressure behavior.
  
  Scheduler:
  
  filter does not operate by default on a particular Scheduler.
  
  Parameters:
  
  predicate - a function that evaluates each item emitted by the source Publisher, returning true if it passes the filter
  
  Returns:
  
  a Flowable that emits only those items emitted by the source Publisher that the filter evaluates as true
  
  See Also:
  
  ReactiveX operators documentation: Filter
  
  firstElement
  
  @CheckReturnValue @BackpressureSupport(value=SPECIAL) @SchedulerSupport(value="none") public final Maybe<T> firstElement()
  
  Returns a Maybe that emits only the very first item emitted by this Flowable or completes if this Flowable is empty.
  
  Backpressure:
  
  The operator honors backpressure from downstream and consumes the source Publisher in an unbounded manner (i.e., without applying backpressure).
  
  Scheduler:
  
  firstElement does not operate by default on a particular Scheduler.
  
  Returns:
  
  the new Maybe instance
  
  See Also:
  
  ReactiveX operators documentation: First
  
  first
  
  @CheckReturnValue @BackpressureSupport(value=SPECIAL) @SchedulerSupport(value="none") public final Single<T> first(T defaultItem)
  
  Returns a Single that emits only the very first item emitted by this Flowable, or a default item if this Flowable completes without emitting anything.
  
  Backpressure:
  
  The operator honors backpressure from downstream and consumes the source Publisher in an unbounded manner (i.e., without applying backpressure).
  
  Scheduler:
  
  first does not operate by default on a particular Scheduler.
  
  Parameters:
  
  defaultItem - the default item to emit if the source Publisher doesn't emit anything
  
  Returns:
  
  a Single that emits only the very first item from the source, or a default item if the source Publisher completes without emitting any items
  
  See Also:
  
  ReactiveX operators documentation: First
  
  firstOrError
  
  @CheckReturnValue @BackpressureSupport(value=SPECIAL) @SchedulerSupport(value="none") public final Single<T> firstOrError()
  
  Returns a Single that emits only the very first item emitted by this Flowable or signals a NoSuchElementException if this Flowable is empty.
  
  Backpressure:
  
  The operator honors backpressure from downstream and consumes the source Publisher in an unbounded manner (i.e., without applying backpressure).
  
  Scheduler:
  
  firstOrError does not operate by default on a particular Scheduler.
  
  Returns:
  
  the new Single instance
  
  See Also:
  
  ReactiveX operators documentation: First
  
  flatMap
  
  @CheckReturnValue @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public final  Flowable flatMap(FunctionT,? extends Publisher> mapper)
  
  Returns a Flowable that emits items based on applying a function that you supply to each item emitted by the source Publisher, where that function returns a Publisher, and then merging those resulting Publishers and emitting the results of this merger.
  
  Backpressure:
  
  The operator honors backpressure from downstream. The upstream Flowable is consumed in a bounded manner (up to bufferSize() outstanding request amount for items). The inner Publishers are expected to honor backpressure; if violated, the operator may signal MissingBackpressureException.
  
  Scheduler:
  
  flatMap does not operate by default on a particular Scheduler.
  
  Type Parameters:
  
  R - the value type of the inner Publishers and the output type
  
  Parameters:
  
  mapper - a function that, when applied to an item emitted by the source Publisher, returns a Publisher
  
  Returns:
  
  a Flowable that emits the result of applying the transformation function to each item emitted by the source Publisher and merging the results of the Publishers obtained from this transformation
  
  See Also:
  
  ReactiveX operators documentation: FlatMap
  
  flatMap
  
  @CheckReturnValue @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public final  Flowable flatMap(FunctionT,? extends Publisher> mapper, boolean delayErrors)
  
  Returns a Flowable that emits items based on applying a function that you supply to each item emitted by the source Publisher, where that function returns a Publisher, and then merging those resulting Publishers and emitting the results of this merger.
  
  Backpressure:
  
  The operator honors backpressure from downstream. The upstream Flowable is consumed in a bounded manner (up to bufferSize() outstanding request amount for items). The inner Publishers are expected to honor backpressure; if violated, the operator may signal MissingBackpressureException.
  
  Scheduler:
  
  flatMap does not operate by default on a particular Scheduler.
  
  Type Parameters:
  
  R - the value type of the inner Publishers and the output type
  
  Parameters:
  
  mapper - a function that, when applied to an item emitted by the source Publisher, returns a Publisher
  
  delayErrors - if true, exceptions from the current Flowable and all inner Publishers are delayed until all of them terminate if false, the first one signaling an exception will terminate the whole sequence immediately
  
  Returns:
  
  a Flowable that emits the result of applying the transformation function to each item emitted by the source Publisher and merging the results of the Publishers obtained from this transformation
  
  See Also:
  
  ReactiveX operators documentation: FlatMap
  
  flatMap
  
  @CheckReturnValue @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public final  Flowable flatMap(FunctionT,? extends Publisher> mapper, int maxConcurrency)
  
  Returns a Flowable that emits items based on applying a function that you supply to each item emitted by the source Publisher, where that function returns a Publisher, and then merging those resulting Publishers and emitting the results of this merger, while limiting the maximum number of concurrent subscriptions to these Publishers.
  
  Backpressure:
  
  The operator honors backpressure from downstream. The upstream Flowable is consumed in a bounded manner (up to maxConcurrency outstanding request amount for items). The inner Publishers are expected to honor backpressure; if violated, the operator may signal MissingBackpressureException.
  
  Scheduler:
  
  flatMap does not operate by default on a particular Scheduler.
  
  Type Parameters:
  
  R - the value type of the inner Publishers and the output type
  
  Parameters:
  
  mapper - a function that, when applied to an item emitted by the source Publisher, returns a Publisher
  
  maxConcurrency - the maximum number of Publishers that may be subscribed to concurrently
  
  Returns:
  
  a Flowable that emits the result of applying the transformation function to each item emitted by the source Publisher and merging the results of the Publishers obtained from this transformation
  
  Since:
  
  2.0
  
  See Also:
  
  ReactiveX operators documentation: FlatMap
  
  flatMap
  
  @CheckReturnValue @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public final  Flowable flatMap(FunctionT,? extends Publisher> mapper, boolean delayErrors, int maxConcurrency)
  
  Returns a Flowable that emits items based on applying a function that you supply to each item emitted by the source Publisher, where that function returns a Publisher, and then merging those resulting Publishers and emitting the results of this merger, while limiting the maximum number of concurrent subscriptions to these Publishers.
  
  Backpressure:
  
  The operator honors backpressure from downstream. The upstream Flowable is consumed in a bounded manner (up to maxConcurrency outstanding request amount for items). The inner Publishers are expected to honor backpressure; if violated, the operator may signal MissingBackpressureException.
  
  Scheduler:
  
  flatMap does not operate by default on a particular Scheduler.
  
  Type Parameters:
  
  R - the value type of the inner Publishers and the output type
  
  Parameters:
  
  mapper - a function that, when applied to an item emitted by the source Publisher, returns a Publisher
  
  maxConcurrency - the maximum number of Publishers that may be subscribed to concurrently
  
  delayErrors - if true, exceptions from the current Flowable and all inner Publishers are delayed until all of them terminate if false, the first one signaling an exception will terminate the whole sequence immediately
  
  Returns:
  
  a Flowable that emits the result of applying the transformation function to each item emitted by the source Publisher and merging the results of the Publishers obtained from this transformation
  
  Since:
  
  2.0
  
  See Also:
  
  ReactiveX operators documentation: FlatMap
  
  flatMap
  
  @CheckReturnValue @NonNull @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public final  Flowable flatMap(FunctionT,? extends Publisher> mapper, boolean delayErrors, int maxConcurrency, int bufferSize)
  
  Returns a Flowable that emits items based on applying a function that you supply to each item emitted by the source Publisher, where that function returns a Publisher, and then merging those resulting Publishers and emitting the results of this merger, while limiting the maximum number of concurrent subscriptions to these Publishers.
  
  Backpressure:
  
  The operator honors backpressure from downstream. The upstream Flowable is consumed in a bounded manner (up to maxConcurrency outstanding request amount for items). The inner Publishers are expected to honor backpressure; if violated, the operator may signal MissingBackpressureException.
  
  Scheduler:
  
  flatMap does not operate by default on a particular Scheduler.
  
  Type Parameters:
  
  R - the value type of the inner Publishers and the output type
  
  Parameters:
  
  mapper - a function that, when applied to an item emitted by the source Publisher, returns a Publisher
  
  maxConcurrency - the maximum number of Publishers that may be subscribed to concurrently
  
  delayErrors - if true, exceptions from the current Flowable and all inner Publishers are delayed until all of them terminate if false, the first one signaling an exception will terminate the whole sequence immediately
  
  bufferSize - the number of elements to prefetch from each inner Publisher
  
  Returns:
  
  a Flowable that emits the result of applying the transformation function to each item emitted by the source Publisher and merging the results of the Publishers obtained from this transformation
  
  Since:
  
  2.0
  
  See Also:
  
  ReactiveX operators documentation: FlatMap
  
  flatMap
  
  @CheckReturnValue @NonNull @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public final  Flowable flatMap(FunctionT,? extends Publisher> onNextMapper, FunctionThrowable,? extends Publisher> onErrorMapper, CallablePublisher> onCompleteSupplier)
  
  Returns a Flowable that applies a function to each item emitted or notification raised by the source Publisher and then flattens the Publishers returned from these functions and emits the resulting items.
  
  Backpressure:
  
  The operator honors backpressure from downstream. The upstream Flowable is consumed in a bounded manner (up to bufferSize() outstanding request amount for items). The inner Publishers are expected to honor backpressure; if violated, the operator may signal MissingBackpressureException.
  
  Scheduler:
  
  flatMap does not operate by default on a particular Scheduler.
  
  Type Parameters:
  
  R - the result type
  
  Parameters:
  
  onNextMapper - a function that returns a Publisher to merge for each item emitted by the source Publisher
  
  onErrorMapper - a function that returns a Publisher to merge for an onError notification from the source Publisher
  
  onCompleteSupplier - a function that returns a Publisher to merge for an onComplete notification from the source Publisher
  
  Returns:
  
  a Flowable that emits the results of merging the Publishers returned from applying the specified functions to the emissions and notifications of the source Publisher
  
  See Also:
  
  ReactiveX operators documentation: FlatMap
  
  flatMap
  
  @CheckReturnValue @NonNull @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public final  Flowable flatMap(FunctionT,? extends Publisher> onNextMapper, Function<Throwable,? extends Publisher> onErrorMapper, CallablePublisher> onCompleteSupplier, int maxConcurrency)
  
  Returns a Flowable that applies a function to each item emitted or notification raised by the source Publisher and then flattens the Publishers returned from these functions and emits the resulting items, while limiting the maximum number of concurrent subscriptions to these Publishers.
  
  Backpressure:
  
  The operator honors backpressure from downstream. The upstream Flowable is consumed in a bounded manner (up to maxConcurrency outstanding request amount for items). The inner Publishers are expected to honor backpressure; if violated, the operator may signal MissingBackpressureException.
  
  Scheduler:
  
  flatMap does not operate by default on a particular Scheduler.
  
  Type Parameters:
  
  R - the result type
  
  Parameters:
  
  onNextMapper - a function that returns a Publisher to merge for each item emitted by the source Publisher
  
  onErrorMapper - a function that returns a Publisher to merge for an onError notification from the source Publisher
  
  onCompleteSupplier - a function that returns a Publisher to merge for an onComplete notification from the source Publisher
  
  maxConcurrency - the maximum number of Publishers that may be subscribed to concurrently
  
  Returns:
  
  a Flowable that emits the results of merging the Publishers returned from applying the specified functions to the emissions and notifications of the source Publisher
  
  Since:
  
  2.0
  
  See Also:
  
  ReactiveX operators documentation: FlatMap
  
  flatMap
  
  @CheckReturnValue @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public final  Flowable flatMap(FunctionT,? extends Publisher> mapper, BiFunctionT,? super U,? extends R> combiner)
  
  Returns a Flowable that emits the results of a specified function to the pair of values emitted by the source Publisher and a specified collection Publisher.
  
  Backpressure:
  
  The operator honors backpressure from downstream. The upstream Flowable is consumed in a bounded manner (up to maxConcurrency outstanding request amount for items). The inner Publishers are expected to honor backpressure; if violated, the operator may signal MissingBackpressureException.
  
  Scheduler:
  
  flatMap does not operate by default on a particular Scheduler.
  
  Type Parameters:
  
  U - the type of items emitted by the inner Publishers
  
  R - the type of items emitted by the combiner function
  
  Parameters:
  
  mapper - a function that returns a Publisher for each item emitted by the source Publisher
  
  combiner - a function that combines one item emitted by each of the source and collection Publishers and returns an item to be emitted by the resulting Publisher
  
  Returns:
  
  a Flowable that emits the results of applying a function to a pair of values emitted by the source Publisher and the collection Publisher
  
  See Also:
  
  ReactiveX operators documentation: FlatMap
  
  flatMap
  
  @CheckReturnValue @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public final  Flowable flatMap(FunctionT,? extends Publisher> mapper, BiFunctionT,? super U,? extends R> combiner, boolean delayErrors)
  
  Returns a Flowable that emits the results of a specified function to the pair of values emitted by the source Publisher and a specified collection Publisher.
  
  Backpressure:
  
  The operator honors backpressure from downstream. The upstream Flowable is consumed in a bounded manner (up to bufferSize() outstanding request amount for items). The inner Publishers are expected to honor backpressure; if violated, the operator may signal MissingBackpressureException.
  
  Scheduler:
  
  flatMap does not operate by default on a particular Scheduler.
  
  Type Parameters:
  
  U - the type of items emitted by the inner Publishers
  
  R - the type of items emitted by the combiner functions
  
  Parameters:
  
  mapper - a function that returns a Publisher for each item emitted by the source Publisher
  
  combiner - a function that combines one item emitted by each of the source and collection Publishers and returns an item to be emitted by the resulting Publisher
  
  delayErrors - if true, exceptions from the current Flowable and all inner Publishers are delayed until all of them terminate if false, the first one signaling an exception will terminate the whole sequence immediately
  
  Returns:
  
  a Flowable that emits the results of applying a function to a pair of values emitted by the source Publisher and the collection Publisher
  
  See Also:
  
  ReactiveX operators documentation: FlatMap
  
  flatMap
  
  @CheckReturnValue @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public final  Flowable flatMap(FunctionT,? extends Publisher> mapper, BiFunctionT,? super U,? extends R> combiner, boolean delayErrors, int maxConcurrency)
  
  Returns a Flowable that emits the results of a specified function to the pair of values emitted by the source Publisher and a specified collection Publisher, while limiting the maximum number of concurrent subscriptions to these Publishers.
  
  Backpressure:
  
  The operator honors backpressure from downstream. The upstream Flowable is consumed in a bounded manner (up to maxConcurrency outstanding request amount for items). The inner Publishers are expected to honor backpressure; if violated, the operator may signal MissingBackpressureException.
  
  Scheduler:
  
  flatMap does not operate by default on a particular Scheduler.
  
  Type Parameters:
  
  U - the type of items emitted by the inner Publishers
  
  R - the type of items emitted by the combiner function
  
  Parameters:
  
  mapper - a function that returns a Publisher for each item emitted by the source Publisher
  
  combiner - a function that combines one item emitted by each of the source and collection Publishers and returns an item to be emitted by the resulting Publisher
  
  maxConcurrency - the maximum number of Publishers that may be subscribed to concurrently
  
  delayErrors - if true, exceptions from the current Flowable and all inner Publishers are delayed until all of them terminate if false, the first one signaling an exception will terminate the whole sequence immediately
  
  Returns:
  
  a Flowable that emits the results of applying a function to a pair of values emitted by the source Publisher and the collection Publisher
  
  Since:
  
  2.0
  
  See Also:
  
  ReactiveX operators documentation: FlatMap
  
  flatMap
  
  @CheckReturnValue @NonNull @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public final  Flowable flatMap(FunctionT,? extends Publisher> mapper, BiFunctionT,? super U,? extends R> combiner, boolean delayErrors, int maxConcurrency, int bufferSize)
  
  Returns a Flowable that emits the results of a specified function to the pair of values emitted by the source Publisher and a specified collection Publisher, while limiting the maximum number of concurrent subscriptions to these Publishers.
  
  Backpressure:
  
  The operator honors backpressure from downstream. The upstream Flowable is consumed in a bounded manner (up to maxConcurrency outstanding request amount for items). The inner Publishers are expected to honor backpressure; if violated, the operator may signal MissingBackpressureException.
  
  Scheduler:
  
  flatMap does not operate by default on a particular Scheduler.
  
  Type Parameters:
  
  U - the type of items emitted by the inner Publishers
  
  R - the type of items emitted by the combiner function
  
  Parameters:
  
  mapper - a function that returns a Publisher for each item emitted by the source Publisher
  
  combiner - a function that combines one item emitted by each of the source and collection Publishers and returns an item to be emitted by the resulting Publisher
  
  maxConcurrency - the maximum number of Publishers that may be subscribed to concurrently
  
  delayErrors - if true, exceptions from the current Flowable and all inner Publishers are delayed until all of them terminate if false, the first one signaling an exception will terminate the whole sequence immediately
  
  bufferSize - the number of elements to prefetch from the inner Publishers.
  
  Returns:
  
  a Flowable that emits the results of applying a function to a pair of values emitted by the source Publisher and the collection Publisher
  
  Since:
  
  2.0
  
  See Also:
  
  ReactiveX operators documentation: FlatMap
  
  flatMap
  
  @CheckReturnValue @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public final  Flowable flatMap(FunctionT,? extends Publisher> mapper, BiFunctionT,? super U,? extends R> combiner, int maxConcurrency)
  
  Returns a Flowable that emits the results of a specified function to the pair of values emitted by the source Publisher and a specified collection Publisher, while limiting the maximum number of concurrent subscriptions to these Publishers.
  
  Backpressure:
  
  The operator honors backpressure from downstream. The upstream Flowable is consumed in a bounded manner (up to bufferSize() outstanding request amount for items). The inner Publishers are expected to honor backpressure; if violated, the operator may signal MissingBackpressureException.
  
  Scheduler:
  
  flatMap does not operate by default on a particular Scheduler.
  
  Type Parameters:
  
  U - the type of items emitted by the inner Publishers
  
  R - the type of items emitted by the combiner function
  
  Parameters:
  
  mapper - a function that returns a Publisher for each item emitted by the source Publisher
  
  combiner - a function that combines one item emitted by each of the source and collection Publishers and returns an item to be emitted by the resulting Publisher
  
  maxConcurrency - the maximum number of Publishers that may be subscribed to concurrently
  
  Returns:
  
  a Flowable that emits the results of applying a function to a pair of values emitted by the source Publisher and the collection Publisher
  
  Since:
  
  2.0
  
  See Also:
  
  ReactiveX operators documentation: FlatMap
  
  flatMapCompletable
  
  @CheckReturnValue @BackpressureSupport(value=UNBOUNDED_IN) @SchedulerSupport(value="none") public final Completable flatMapCompletable(FunctionT,? extends CompletableSource> mapper)
  
  Maps each element of the upstream Flowable into CompletableSources, subscribes to them and waits until the upstream and all CompletableSources complete.
  
  Backpressure:
  
  The operator consumes the upstream in an unbounded manner.
  
  Scheduler:
  
  flatMapCompletable does not operate by default on a particular Scheduler.
  
  Parameters:
  
  mapper - the function that received each source value and transforms them into CompletableSources.
  
  Returns:
  
  the new Completable instance
  
  flatMapCompletable
  
  @CheckReturnValue @NonNull @BackpressureSupport(value=UNBOUNDED_IN) @SchedulerSupport(value="none") public final Completable flatMapCompletable(FunctionT,? extends CompletableSource> mapper, boolean delayErrors, int maxConcurrency)
  
  Maps each element of the upstream Flowable into CompletableSources, subscribes to them and waits until the upstream and all CompletableSources complete, optionally delaying all errors.
  
  Backpressure:
  
  If maxConcurrency == Integer.MAX_VALUE the operator consumes the upstream in an unbounded manner. Otherwise, the operator expects the upstream to honor backpressure. If the upstream doesn't support backpressure the operator behaves as if maxConcurrency == Integer.MAX_VALUE was used.
  
  Scheduler:
  
  flatMapCompletable does not operate by default on a particular Scheduler.
  
  Parameters:
  
  mapper - the function that received each source value and transforms them into CompletableSources.
  
  delayErrors - if true errors from the upstream and inner CompletableSources are delayed until each of them terminates.
  
  maxConcurrency - the maximum number of active subscriptions to the CompletableSources.
  
  Returns:
  
  the new Completable instance
  
  flatMapIterable
  
  @CheckReturnValue @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public final  Flowable flatMapIterable(FunctionT,? extends Iterable> mapper)
  
  Returns a Flowable that merges each item emitted by the source Publisher with the values in an Iterable corresponding to that item that is generated by a selector.
  
  Backpressure:
  
  The operator honors backpressure from downstream. The source Publishers is expected to honor backpressure as well. If the source Publisher violates the rule, the operator will signal a MissingBackpressureException.
  
  Scheduler:
  
  flatMapIterable does not operate by default on a particular Scheduler.
  
  Type Parameters:
  
  U - the type of item emitted by the resulting Iterable
  
  Parameters:
  
  mapper - a function that returns an Iterable sequence of values for when given an item emitted by the source Publisher
  
  Returns:
  
  a Flowable that emits the results of merging the items emitted by the source Publisher with the values in the Iterables corresponding to those items, as generated by collectionSelector
  
  See Also:
  
  ReactiveX operators documentation: FlatMap
  
  flatMapIterable
  
  @CheckReturnValue @NonNull @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public final  Flowable flatMapIterable(FunctionT,? extends Iterable> mapper, int bufferSize)
  
  Returns a Flowable that merges each item emitted by the source Publisher with the values in an Iterable corresponding to that item that is generated by a selector.
  
  Backpressure:
  
  The operator honors backpressure from downstream. The source Publishers is expected to honor backpressure as well. If the source Publisher violates the rule, the operator will signal a MissingBackpressureException.
  
  Scheduler:
  
  flatMapIterable does not operate by default on a particular Scheduler.
  
  Type Parameters:
  
  U - the type of item emitted by the resulting Iterable
  
  Parameters:
  
  mapper - a function that returns an Iterable sequence of values for when given an item emitted by the source Publisher
  
  bufferSize - the number of elements to prefetch from the current Flowable
  
  Returns:
  
  a Flowable that emits the results of merging the items emitted by the source Publisher with the values in the Iterables corresponding to those items, as generated by collectionSelector
  
  See Also:
  
  ReactiveX operators documentation: FlatMap
  
  flatMapIterable
  
  @CheckReturnValue @NonNull @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public final  Flowable flatMapIterable(FunctionT,? extends Iterable> mapper, BiFunctionT,? super U,? extends V> resultSelector)
  
  Returns a Flowable that emits the results of applying a function to the pair of values from the source Publisher and an Iterable corresponding to that item that is generated by a selector.
  
  Backpressure:
  
  The operator honors backpressure from downstream and the source Publishers is consumed in an unbounded manner (i.e., no backpressure is applied to it).
  
  Scheduler:
  
  flatMapIterable does not operate by default on a particular Scheduler.
  
  Type Parameters:
  
  U - the collection element type
  
  V - the type of item emitted by the resulting Iterable
  
  Parameters:
  
  mapper - a function that returns an Iterable sequence of values for each item emitted by the source Publisher
  
  resultSelector - a function that returns an item based on the item emitted by the source Publisher and the Iterable returned for that item by the collectionSelector
  
  Returns:
  
  a Flowable that emits the items returned by resultSelector for each item in the source Publisher
  
  See Also:
  
  ReactiveX operators documentation: FlatMap
  
  flatMapIterable
  
  @CheckReturnValue @NonNull @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public final  Flowable flatMapIterable(FunctionT,? extends Iterable> mapper, BiFunctionT,? super U,? extends V> resultSelector, int prefetch)
  
  Returns a Flowable that merges each item emitted by the source Publisher with the values in an Iterable corresponding to that item that is generated by a selector, while limiting the number of concurrent subscriptions to these Publishers.
  
  Backpressure:
  
  The operator honors backpressure from downstream. The source Publishers is expected to honor backpressure as well. If the source Publisher violates the rule, the operator will signal a MissingBackpressureException.
  
  Scheduler:
  
  flatMapIterable does not operate by default on a particular Scheduler.
  
  Type Parameters:
  
  U - the element type of the inner Iterable sequences
  
  V - the type of item emitted by the resulting Publisher
  
  Parameters:
  
  mapper - a function that returns an Iterable sequence of values for when given an item emitted by the source Publisher
  
  resultSelector - a function that returns an item based on the item emitted by the source Publisher and the Iterable returned for that item by the collectionSelector
  
  prefetch - the number of elements to prefetch from the current Flowable
  
  Returns:
  
  a Flowable that emits the results of merging the items emitted by the source Publisher with the values in the Iterables corresponding to those items, as generated by collectionSelector
  
  Since:
  
  2.0
  
  See Also:
  
  ReactiveX operators documentation: FlatMap
  
  flatMapMaybe
  
  @CheckReturnValue @BackpressureSupport(value=UNBOUNDED_IN) @SchedulerSupport(value="none") public final  Flowable flatMapMaybe(FunctionT,? extends MaybeSource> mapper)
  
  Maps each element of the upstream Flowable into MaybeSources, subscribes to all of them and merges their onSuccess values, in no particular order, into a single Flowable sequence.
  
  Backpressure:
  
  The operator consumes the upstream in an unbounded manner.
  
  Scheduler:
  
  flatMapMaybe does not operate by default on a particular Scheduler.
  
  Type Parameters:
  
  R - the result value type
  
  Parameters:
  
  mapper - the function that received each source value and transforms them into MaybeSources.
  
  Returns:
  
  the new Flowable instance
  
  flatMapMaybe
  
  @CheckReturnValue @NonNull @BackpressureSupport(value=UNBOUNDED_IN) @SchedulerSupport(value="none") public final  Flowable flatMapMaybe(FunctionT,? extends MaybeSource> mapper, boolean delayErrors, int maxConcurrency)
  
  Maps each element of the upstream Flowable into MaybeSources, subscribes to at most maxConcurrency MaybeSources at a time and merges their onSuccess values, in no particular order, into a single Flowable sequence, optionally delaying all errors.
  
  Backpressure:
  
  If maxConcurrency == Integer.MAX_VALUE the operator consumes the upstream in an unbounded manner. Otherwise, the operator expects the upstream to honor backpressure. If the upstream doesn't support backpressure the operator behaves as if maxConcurrency == Integer.MAX_VALUE was used.
  
  Scheduler:
  
  flatMapMaybe does not operate by default on a particular Scheduler.
  
  Type Parameters:
  
  R - the result value type
  
  Parameters:
  
  mapper - the function that received each source value and transforms them into MaybeSources.
  
  delayErrors - if true errors from the upstream and inner MaybeSources are delayed until each of them terminates.
  
  maxConcurrency - the maximum number of active subscriptions to the MaybeSources.
  
  Returns:
  
  the new Flowable instance
  
  flatMapSingle
  
  @CheckReturnValue @BackpressureSupport(value=UNBOUNDED_IN) @SchedulerSupport(value="none") public final  Flowable flatMapSingle(FunctionT,? extends SingleSource> mapper)
  
  Maps each element of the upstream Flowable into SingleSources, subscribes to all of them and merges their onSuccess values, in no particular order, into a single Flowable sequence.
  
  Backpressure:
  
  The operator consumes the upstream in an unbounded manner.
  
  Scheduler:
  
  flatMapSingle does not operate by default on a particular Scheduler.
  
  Type Parameters:
  
  R - the result value type
  
  Parameters:
  
  mapper - the function that received each source value and transforms them into SingleSources.
  
  Returns:
  
  the new Flowable instance
  
  flatMapSingle
  
  @CheckReturnValue @NonNull @BackpressureSupport(value=UNBOUNDED_IN) @SchedulerSupport(value="none") public final  Flowable flatMapSingle(FunctionT,? extends SingleSource> mapper, boolean delayErrors, int maxConcurrency)
  
  Maps each element of the upstream Flowable into SingleSources, subscribes to at most maxConcurrency SingleSources at a time and merges their onSuccess values, in no particular order, into a single Flowable sequence, optionally delaying all errors.
  
  Backpressure:
  
  If maxConcurrency == Integer.MAX_VALUE the operator consumes the upstream in an unbounded manner. Otherwise, the operator expects the upstream to honor backpressure. If the upstream doesn't support backpressure the operator behaves as if maxConcurrency == Integer.MAX_VALUE was used.
  
  Scheduler:
  
  flatMapSingle does not operate by default on a particular Scheduler.
  
  Type Parameters:
  
  R - the result value type
  
  Parameters:
  
  mapper - the function that received each source value and transforms them into SingleSources.
  
  delayErrors - if true errors from the upstream and inner SingleSources are delayed until each of them terminates.
  
  maxConcurrency - the maximum number of active subscriptions to the SingleSources.
  
  Returns:
  
  the new Flowable instance
  
  forEach
  
  @CheckReturnValue @BackpressureSupport(value=NONE) @SchedulerSupport(value="none") public final Disposable forEach(ConsumerT> onNext)
  
  Subscribes to the Publisher and receives notifications for each element.
  Alias to subscribe(Consumer)
  
  Backpressure:
  
  The operator consumes the source Publisher in an unbounded manner (i.e., no backpressure is applied to it).
  
  Scheduler:
  
  forEach does not operate by default on a particular Scheduler.
  
  Parameters:
  
  onNext - Consumer to execute for each item.
  
  Returns:
  
  a Disposable that allows canceling an asynchronous sequence
  
  Throws:
  
  NullPointerException - if onNext is null
  
  See Also:
  
  ReactiveX operators documentation: Subscribe
  
  forEachWhile
  
  @CheckReturnValue @BackpressureSupport(value=NONE) @SchedulerSupport(value="none") public final Disposable forEachWhile(PredicateT> onNext)
  
  Subscribes to the Publisher and receives notifications for each element until the onNext Predicate returns false.
  If the Flowable emits an error, it is wrapped into an OnErrorNotImplementedException and routed to the RxJavaPlugins.onError handler.
  
  Backpressure:
  
  The operator consumes the source Publisher in an unbounded manner (i.e., no backpressure is applied to it).
  
  Scheduler:
  
  forEachWhile does not operate by default on a particular Scheduler.
  
  Parameters:
  
  onNext - Predicate to execute for each item.
  
  Returns:
  
  a Disposable that allows canceling an asynchronous sequence
  
  Throws:
  
  NullPointerException - if onNext is null
  
  See Also:
  
  ReactiveX operators documentation: Subscribe
  
  forEachWhile
  
  @CheckReturnValue @BackpressureSupport(value=NONE) @SchedulerSupport(value="none") public final Disposable forEachWhile(PredicateT> onNext, ConsumerThrowable> onError)
  
  Subscribes to the Publisher and receives notifications for each element and error events until the onNext Predicate returns false.
  
  Backpressure:
  
  The operator consumes the source Publisher in an unbounded manner (i.e., no backpressure is applied to it).
  
  Scheduler:
  
  forEachWhile does not operate by default on a particular Scheduler.
  
  Parameters:
  
  onNext - Predicate to execute for each item.
  
  onError - Consumer to execute when an error is emitted.
  
  Returns:
  
  a Disposable that allows canceling an asynchronous sequence
  
  Throws:
  
  NullPointerException - if onNext is null, or if onError is null
  
  See Also:
  
  ReactiveX operators documentation: Subscribe
  
  forEachWhile
  
  @CheckReturnValue @NonNull @BackpressureSupport(value=NONE) @SchedulerSupport(value="none") public final Disposable forEachWhile(PredicateT> onNext, ConsumerThrowable> onError, Action onComplete)
  
  Subscribes to the Publisher and receives notifications for each element and the terminal events until the onNext Predicate returns false.
  
  Backpressure:
  
  The operator consumes the source Publisher in an unbounded manner (i.e., no backpressure is applied to it).
  
  Scheduler:
  
  forEachWhile does not operate by default on a particular Scheduler.
  
  Parameters:
  
  onNext - Predicate to execute for each item.
  
  onError - Consumer to execute when an error is emitted.
  
  onComplete - Action to execute when completion is signaled.
  
  Returns:
  
  a Disposable that allows canceling an asynchronous sequence
  
  Throws:
  
  NullPointerException - if onNext is null, or if onError is null, or if onComplete is null
  
  See Also:
  
  ReactiveX operators documentation: Subscribe
  
  groupBy
  
  @CheckReturnValue @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public final  Flowable<GroupedFlowableT>> groupBy(FunctionT,? extends K> keySelector)
  
  Groups the items emitted by a Publisher according to a specified criterion, and emits these grouped items as GroupedFlowables. The emitted GroupedPublisher allows only a single Subscriber during its lifetime and if this Subscriber cancels before the source terminates, the next emission by the source having the same key will trigger a new GroupedPublisher emission.
  
  Note: A GroupedFlowable will cache the items it is to emit until such time as it is subscribed to. For this reason, in order to avoid memory leaks, you should not simply ignore those GroupedPublishers that do not concern you. Instead, you can signal to them that they may discard their buffers by applying an operator like ignoreElements() to them.
  Note that the GroupedFlowables should be subscribed to as soon as possible, otherwise, the unconsumed groups may starve other groups due to the internal backpressure coordination of the groupBy operator. Such hangs can be usually avoided by using flatMap(Function, int) or concatMapEager(Function, int, int) and overriding the default maximum concurrency value to be greater or equal to the expected number of groups, possibly using Integer.MAX_VALUE if the number of expected groups is unknown.
  
  Backpressure:
  
  Both the returned and its inner Publishers honor backpressure and the source Publisher is consumed in a bounded mode (i.e., requested a fixed amount upfront and replenished based on downstream consumption). Note that both the returned and its inner Publishers use unbounded internal buffers and if the source Publisher doesn't honor backpressure, that may lead to OutOfMemoryError.
  
  Scheduler:
  
  groupBy does not operate by default on a particular Scheduler.
  
  Type Parameters:
  
  K - the key type
  
  Parameters:
  
  keySelector - a function that extracts the key for each item
  
  Returns:
  
  a Publisher that emits GroupedFlowables, each of which corresponds to a unique key value and each of which emits those items from the source Publisher that share that key value
  
  See Also:
  
  ReactiveX operators documentation: GroupBy
  
  groupBy
  
  @CheckReturnValue @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public final  Flowable<GroupedFlowableT>> groupBy(FunctionT,? extends K> keySelector, boolean delayError)
  
  Groups the items emitted by a Publisher according to a specified criterion, and emits these grouped items as GroupedFlowables. The emitted GroupedPublisher allows only a single Subscriber during its lifetime and if this Subscriber cancels before the source terminates, the next emission by the source having the same key will trigger a new GroupedPublisher emission.
  
  Note: A GroupedFlowable will cache the items it is to emit until such time as it is subscribed to. For this reason, in order to avoid memory leaks, you should not simply ignore those GroupedPublishers that do not concern you. Instead, you can signal to them that they may discard their buffers by applying an operator like ignoreElements() to them.
  Note that the GroupedFlowables should be subscribed to as soon as possible, otherwise, the unconsumed groups may starve other groups due to the internal backpressure coordination of the groupBy operator. Such hangs can be usually avoided by using flatMap(Function, int) or concatMapEager(Function, int, int) and overriding the default maximum concurrency value to be greater or equal to the expected number of groups, possibly using Integer.MAX_VALUE if the number of expected groups is unknown.
  
  Backpressure:
  
  Both the returned and its inner Publishers honor backpressure and the source Publisher is consumed in a bounded mode (i.e., requested a fixed amount upfront and replenished based on downstream consumption). Note that both the returned and its inner Publishers use unbounded internal buffers and if the source Publisher doesn't honor backpressure, that may lead to OutOfMemoryError.
  
  Scheduler:
  
  groupBy does not operate by default on a particular Scheduler.
  
  Type Parameters:
  
  K - the key type
  
  Parameters:
  
  keySelector - a function that extracts the key for each item
  
  delayError - if true, the exception from the current Flowable is delayed in each group until that specific group emitted the normal values; if false, the exception bypasses values in the groups and is reported immediately.
  
  Returns:
  
  a Publisher that emits GroupedFlowables, each of which corresponds to a unique key value and each of which emits those items from the source Publisher that share that key value
  
  See Also:
  
  ReactiveX operators documentation: GroupBy
  
  groupBy
  
  @CheckReturnValue @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public final  Flowable<GroupedFlowable> groupBy(FunctionT,? extends K> keySelector, FunctionT,? extends V> valueSelector)
  
  Groups the items emitted by a Publisher according to a specified criterion, and emits these grouped items as GroupedFlowables. The emitted GroupedPublisher allows only a single Subscriber during its lifetime and if this Subscriber cancels before the source terminates, the next emission by the source having the same key will trigger a new GroupedPublisher emission.
  
  Note: A GroupedFlowable will cache the items it is to emit until such time as it is subscribed to. For this reason, in order to avoid memory leaks, you should not simply ignore those GroupedPublishers that do not concern you. Instead, you can signal to them that they may discard their buffers by applying an operator like ignoreElements() to them.
  Note that the GroupedFlowables should be subscribed to as soon as possible, otherwise, the unconsumed groups may starve other groups due to the internal backpressure coordination of the groupBy operator. Such hangs can be usually avoided by using flatMap(Function, int) or concatMapEager(Function, int, int) and overriding the default maximum concurrency value to be greater or equal to the expected number of groups, possibly using Integer.MAX_VALUE if the number of expected groups is unknown.
  
  Backpressure:
  
  Both the returned and its inner Publishers honor backpressure and the source Publisher is consumed in a bounded mode (i.e., requested a fixed amount upfront and replenished based on downstream consumption). Note that both the returned and its inner Publishers use unbounded internal buffers and if the source Publisher doesn't honor backpressure, that may lead to OutOfMemoryError.
  
  Scheduler:
  
  groupBy does not operate by default on a particular Scheduler.
  
  Type Parameters:
  
  K - the key type
  
  V - the element type
  
  Parameters:
  
  keySelector - a function that extracts the key for each item
  
  valueSelector - a function that extracts the return element for each item
  
  Returns:
  
  a Publisher that emits GroupedFlowables, each of which corresponds to a unique key value and each of which emits those items from the source Publisher that share that key value
  
  See Also:
  
  ReactiveX operators documentation: GroupBy
  
  groupBy
  
  @CheckReturnValue @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public final  Flowable<GroupedFlowable> groupBy(FunctionT,? extends K> keySelector, FunctionT,? extends V> valueSelector, boolean delayError)
  
  Groups the items emitted by a Publisher according to a specified criterion, and emits these grouped items as GroupedFlowables. The emitted GroupedPublisher allows only a single Subscriber during its lifetime and if this Subscriber cancels before the source terminates, the next emission by the source having the same key will trigger a new GroupedPublisher emission.
  
  Note: A GroupedFlowable will cache the items it is to emit until such time as it is subscribed to. For this reason, in order to avoid memory leaks, you should not simply ignore those GroupedPublishers that do not concern you. Instead, you can signal to them that they may discard their buffers by applying an operator like ignoreElements() to them.
  Note that the GroupedFlowables should be subscribed to as soon as possible, otherwise, the unconsumed groups may starve other groups due to the internal backpressure coordination of the groupBy operator. Such hangs can be usually avoided by using flatMap(Function, int) or concatMapEager(Function, int, int) and overriding the default maximum concurrency value to be greater or equal to the expected number of groups, possibly using Integer.MAX_VALUE if the number of expected groups is unknown.
  
  Backpressure:
  
  Both the returned and its inner Publishers honor backpressure and the source Publisher is consumed in a bounded mode (i.e., requested a fixed amount upfront and replenished based on downstream consumption). Note that both the returned and its inner Publishers use unbounded internal buffers and if the source Publisher doesn't honor backpressure, that may lead to OutOfMemoryError.
  
  Scheduler:
  
  groupBy does not operate by default on a particular Scheduler.
  
  Type Parameters:
  
  K - the key type
  
  V - the element type
  
  Parameters:
  
  keySelector - a function that extracts the key for each item
  
  valueSelector - a function that extracts the return element for each item
  
  delayError - if true, the exception from the current Flowable is delayed in each group until that specific group emitted the normal values; if false, the exception bypasses values in the groups and is reported immediately.
  
  Returns:
  
  a Publisher that emits GroupedFlowables, each of which corresponds to a unique key value and each of which emits those items from the source Publisher that share that key value
  
  See Also:
  
  ReactiveX operators documentation: GroupBy
  
  groupBy
  
  @CheckReturnValue @NonNull @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public final  Flowable<GroupedFlowable> groupBy(FunctionT,? extends K> keySelector, FunctionT,? extends V> valueSelector, boolean delayError, int bufferSize)
  
  Groups the items emitted by a Publisher according to a specified criterion, and emits these grouped items as GroupedFlowables. The emitted GroupedPublisher allows only a single Subscriber during its lifetime and if this Subscriber cancels before the source terminates, the next emission by the source having the same key will trigger a new GroupedPublisher emission.
  
  Note: A GroupedFlowable will cache the items it is to emit until such time as it is subscribed to. For this reason, in order to avoid memory leaks, you should not simply ignore those GroupedPublishers that do not concern you. Instead, you can signal to them that they may discard their buffers by applying an operator like ignoreElements() to them.
  Note that the GroupedFlowables should be subscribed to as soon as possible, otherwise, the unconsumed groups may starve other groups due to the internal backpressure coordination of the groupBy operator. Such hangs can be usually avoided by using flatMap(Function, int) or concatMapEager(Function, int, int) and overriding the default maximum concurrency value to be greater or equal to the expected number of groups, possibly using Integer.MAX_VALUE if the number of expected groups is unknown.
  
  Backpressure:
  
  Both the returned and its inner Publishers honor backpressure and the source Publisher is consumed in a bounded mode (i.e., requested a fixed amount upfront and replenished based on downstream consumption). Note that both the returned and its inner Publishers use unbounded internal buffers and if the source Publisher doesn't honor backpressure, that may lead to OutOfMemoryError.
  
  Scheduler:
  
  groupBy does not operate by default on a particular Scheduler.
  
  Type Parameters:
  
  K - the key type
  
  V - the element type
  
  Parameters:
  
  keySelector - a function that extracts the key for each item
  
  valueSelector - a function that extracts the return element for each item
  
  delayError - if true, the exception from the current Flowable is delayed in each group until that specific group emitted the normal values; if false, the exception bypasses values in the groups and is reported immediately.
  
  bufferSize - the hint for how many GroupedFlowables and element in each GroupedFlowable should be buffered
  
  Returns:
  
  a Publisher that emits GroupedFlowables, each of which corresponds to a unique key value and each of which emits those items from the source Publisher that share that key value
  
  See Also:
  
  ReactiveX operators documentation: GroupBy
  
  groupBy
  
  @CheckReturnValue @NonNull @BackpressureSupport(value=FULL) @SchedulerSupport(value="none") public final  Flowable<GroupedFlowable> groupBy(FunctionT,? extends K> keySelector, FunctionT,? extends V> valueSelector, boolean delayError, int bufferSize, FunctionConsumer<Object>,? extends MapObject>> evictingMapFactory)
  
  Groups the items emitted by a Publisher according to a specified criterion, and emits these grouped items as GroupedFlowables. The emitted GroupedFlowable allows only a single Subscriber during its lifetime and if this Subscriber cancels before the source terminates, the next emission by the source having the same key will trigger a new GroupedPublisher emission. The evictingMapFactory is used to create a map that will be used to hold the GroupedFlowables by key. The evicting map created by this factory must notify the provided Consumer