Publisher (servicetalk-concurrent-api 0.24.0 API)

Object
- Publisher<T>

Type Parameters:

T - Type of items emitted.

Direct Known Subclasses:

GroupedPublisher
```
public abstract class Publisher<T>
extends Object
```
An asynchronous computation that produces 0, 1 or more elements and may or may not terminate successfully or with an error.
How to subscribe?
This class does not provide a way to subscribe using a PublisherSource.Subscriber as such calls are ambiguous about the intent whether the subscribe is part of the same source (a.k.a an operator) or it is a terminal subscribe. If it is required to subscribe to a source, then a source adapter can be used to convert to a PublisherSource.

Constructor Summary

Constructors
Modifier Constructor and Description

protected Publisher()
New instance.

Constructors
Modifier	Constructor and Description
`protected`	`Publisher()` New instance.

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`Publisher<T>`	`afterCancel(Runnable onCancel)` Invokes the `onCancel` `Runnable` argument after `Cancellable.cancel()` is called for `PublisherSource.Subscription`s of the returned `Publisher`.
`Publisher<T>`	`afterFinally(Runnable doFinally)` Invokes the `whenFinally` `Runnable` argument after any of the following terminal methods are called: `PublisherSource.Subscriber.onComplete()` `PublisherSource.Subscriber.onError(Throwable)` `Cancellable.cancel()` for `PublisherSource.Subscription`s/`PublisherSource.Subscriber`s of the returned `Publisher`.
`Publisher<T>`	`afterOnComplete(Runnable onComplete)` Invokes the `onComplete` `Runnable` argument after `PublisherSource.Subscriber.onComplete()` is called for `PublisherSource.Subscriber`s of the returned `Publisher`.
`Publisher<T>`	`afterOnError(Consumer<Throwable> onError)` Invokes the `onError` `Consumer` argument after `PublisherSource.Subscriber.onError(Throwable)` is called for `PublisherSource.Subscriber`s of the returned `Publisher`.
`Publisher<T>`	`afterOnNext(Consumer<? super T> onNext)` Invokes the `onNext` `Consumer` argument after `PublisherSource.Subscriber.onNext(Object)` is called for `PublisherSource.Subscriber`s of the returned `Publisher`.
`Publisher<T>`	`afterOnSubscribe(Consumer<? super PublisherSource.Subscription> onSubscribe)` Invokes the `onSubscribe` `Consumer` argument after `PublisherSource.Subscriber.onSubscribe(PublisherSource.Subscription)` is called for `PublisherSource.Subscriber`s of the returned `Publisher`.
`Publisher<T>`	`afterRequest(LongConsumer onRequest)` Invokes the `onRequest` `LongConsumer` argument after `PublisherSource.Subscription.request(long)` is called for `PublisherSource.Subscription`s of the returned `Publisher`.
`Publisher<T>`	`afterSubscriber(Supplier<? extends PublisherSource.Subscriber<? super T>> subscriberSupplier)` Creates a new `PublisherSource.Subscriber` (via the `subscriberSupplier` argument) for each new subscribe and invokes all the `PublisherSource.Subscriber` methods after the `PublisherSource.Subscriber`s of the returned `Publisher`.
`Publisher<T>`	`afterSubscription(Supplier<? extends PublisherSource.Subscription> subscriptionSupplier)` Creates a new `PublisherSource.Subscription` (via the `subscriptionSupplier` argument) for each new subscribe and invokes all the `PublisherSource.Subscription` methods after the `PublisherSource.Subscription`s of the returned `Publisher`.
`Publisher<T>`	`beforeCancel(Runnable onCancel)` Invokes the `onCancel` `Runnable` argument before `Cancellable.cancel()` is called for `PublisherSource.Subscription`s of the returned `Publisher`.
`Publisher<T>`	`beforeFinally(Runnable doFinally)` Invokes the `whenFinally` `Runnable` argument before any of the following terminal methods are called: `PublisherSource.Subscriber.onComplete()` `PublisherSource.Subscriber.onError(Throwable)` `Cancellable.cancel()` for `PublisherSource.Subscription`s/`PublisherSource.Subscriber`s of the returned `Publisher`.
`Publisher<T>`	`beforeOnComplete(Runnable onComplete)` Invokes the `onComplete` `Runnable` argument before `PublisherSource.Subscriber.onComplete()` is called for `PublisherSource.Subscriber`s of the returned `Publisher`.
`Publisher<T>`	`beforeOnError(Consumer<Throwable> onError)` Invokes the `onError` `Consumer` argument before `PublisherSource.Subscriber.onError(Throwable)` is called for `PublisherSource.Subscriber`s of the returned `Publisher`.
`Publisher<T>`	`beforeOnNext(Consumer<? super T> onNext)` Invokes the `onNext` `Consumer` argument before `PublisherSource.Subscriber.onNext(Object)` is called for `PublisherSource.Subscriber`s of the returned `Publisher`.
`Publisher<T>`	`beforeOnSubscribe(Consumer<? super PublisherSource.Subscription> onSubscribe)` Invokes the `onSubscribe` `Consumer` argument before `PublisherSource.Subscriber.onSubscribe(PublisherSource.Subscription)` is called for `PublisherSource.Subscriber`s of the returned `Publisher`.
`Publisher<T>`	`beforeRequest(LongConsumer onRequest)` Invokes the `onRequest` `LongConsumer` argument before `PublisherSource.Subscription.request(long)` is called for `PublisherSource.Subscription`s of the returned `Publisher`.
`Publisher<T>`	`beforeSubscriber(Supplier<? extends PublisherSource.Subscriber<? super T>> subscriberSupplier)` Creates a new `PublisherSource.Subscriber` (via the `subscriberSupplier` argument) on each call to subscribe and invokes all the `PublisherSource.Subscriber` methods before the `PublisherSource.Subscriber`s of the returned `Publisher`.
`Publisher<T>`	`beforeSubscription(Supplier<? extends PublisherSource.Subscription> subscriptionSupplier)` Creates a new `PublisherSource.Subscription` (via the `subscriptionSupplier` argument) on each call to subscribe and invokes all the `PublisherSource.Subscription` methods before the `PublisherSource.Subscription`s of the returned `Publisher`.
`<R> Single<R>`	`collect(Supplier<? extends R> resultFactory, BiFunction<? super R,? super T,R> collector)` Collects all items emitted by this `Publisher` into a single item.
`Publisher<T>`	`concat(Completable next)` Listens for completion of `next` `Completable` after `this` `Publisher` terminates successfully.
`Publisher<T>`	`concat(Publisher<? extends T> next)` Emits items emitted by `next` `Publisher` after `this` `Publisher` terminates successfully.
`Publisher<T>`	`concat(Single<? extends T> next)` Listens and emits the result of `next` `Single` after `this` `Publisher` terminates successfully.
`static <T> Publisher<T>`	`defer(Supplier<? extends Publisher<? extends T>> publisherSupplier)` Defers creation of a `Publisher` till it is subscribed.
`static <T> Publisher<T>`	`empty()` Creates a new `Publisher` that completes when subscribed without emitting any item to its `PublisherSource.Subscriber`.
`static <T> Publisher<T>`	`failed(Throwable cause)` Creates a new `Publisher` that terminates its `PublisherSource.Subscriber` with an error without emitting any item to it.
`Publisher<T>`	`filter(Predicate<? super T> predicate)` Filters items emitted by this `Publisher`.
`Single<T>`	`firstOrElse(Supplier<T> defaultValueSupplier)` Converts this `Publisher` to a `Single`.
`Single<T>`	`firstOrError()` Ensures that this `Publisher` emits exactly a single `PublisherSource.Subscriber.onNext(Object)` to its `PublisherSource.Subscriber`.
`Completable`	`flatMapCompletable(Function<? super T,? extends Completable> mapper)` Turns every item emitted by this `Publisher` into a `Completable` and terminate the returned `Completable` when all the intermediate `Completable`s have terminated successfully or any one of them has terminated with a failure.
`Completable`	`flatMapCompletable(Function<? super T,? extends Completable> mapper, int maxConcurrency)` Turns every item emitted by this `Publisher` into a `Completable` and terminate the returned `Completable` when all the intermediate `Completable`s have terminated successfully or any one of them has terminated with a failure.
`Completable`	`flatMapCompletableDelayError(Function<? super T,? extends Completable> mapper)` Turns every item emitted by this `Publisher` into a `Completable` and terminate the returned `Completable` when all the intermediate `Completable`s have terminated.
`Completable`	`flatMapCompletableDelayError(Function<? super T,? extends Completable> mapper, int maxConcurrency)` Turns every item emitted by this `Publisher` into a `Completable` and terminate the returned `Completable` when all the intermediate `Completable`s have terminated.If any `Completable` returned by `mapper`, terminates with an error, the returned `Completable` will not immediately terminate.
`<R> Publisher<R>`	`flatMapConcatIterable(Function<? super T,? extends Iterable<? extends R>> mapper)` Create a `Publisher` that flattens each element returned by the `Iterable.iterator()` from `mapper`.
`<R> Publisher<R>`	`flatMapMergeSingle(Function<? super T,? extends Single<? extends R>> mapper)` Turns every item emitted by this `Publisher` into a `Single` and emits the items emitted by each of those `Single`s.
`<R> Publisher<R>`	`flatMapMergeSingle(Function<? super T,? extends Single<? extends R>> mapper, int maxConcurrency)` Turns every item emitted by this `Publisher` into a `Single` and emits the items emitted by each of those `Single`s.
`<R> Publisher<R>`	`flatMapMergeSingleDelayError(Function<? super T,? extends Single<? extends R>> mapper)` Turns every item emitted by this `Publisher` into a `Single` and emits the items emitted by each of those `Single`s.
`<R> Publisher<R>`	`flatMapMergeSingleDelayError(Function<? super T,? extends Single<? extends R>> mapper, int maxConcurrency)` Turns every item emitted by this `Publisher` into a `Single` and emits the items emitted by each of those `Single`s.
`Cancellable`	`forEach(Consumer<? super T> forEach)` Subscribes to this `Publisher` and invokes `forEach` `Consumer` for each item emitted by this `Publisher`.
`static <T> Publisher<T>`	`from(T... values)` Creates a new `Publisher` that emits all `values` to its `PublisherSource.Subscriber` and then `PublisherSource.Subscriber.onComplete()`.
`static <T> Publisher<T>`	`from(T value)` Creates a new `Publisher` that emits `value` to its `PublisherSource.Subscriber` and then `PublisherSource.Subscriber.onComplete()`.
`static <T> Publisher<T>`	`fromBlockingIterable(BlockingIterable<? extends T> iterable, LongSupplier timeoutSupplier, TimeUnit unit)` Create a new `Publisher` that when subscribed will get a `BlockingIterator` via `BlockingIterable.iterator()` and emit all values to the `PublisherSource.Subscriber` and then `PublisherSource.Subscriber.onComplete()`.
`static Publisher<byte[]>`	`fromInputStream(InputStream stream)` Create a new `Publisher` that when subscribed will emit all data from the `InputStream` to the `PublisherSource.Subscriber` and then `PublisherSource.Subscriber.onComplete()`.
`static <T> Publisher<T>`	`fromIterable(Iterable<? extends T> iterable)` Create a new `Publisher` that when subscribed will get an `Iterator` via `Iterable.iterator()` and emit all values to the `PublisherSource.Subscriber` and then `PublisherSource.Subscriber.onComplete()`.
`<Key> Publisher<GroupedPublisher<Key,T>>`	`groupBy(Function<? super T,? extends Key> keySelector, int groupMaxQueueSize)` Splits items from this `Publisher` into dynamically generated `GroupedPublisher`s.
`<Key> Publisher<GroupedPublisher<Key,T>>`	`groupBy(Function<? super T,? extends Key> keySelector, int groupMaxQueueSize, int expectedGroupCountHint)` Splits items from this `Publisher` into dynamically generated `GroupedPublisher`s.
`<Key> Publisher<GroupedPublisher<Key,T>>`	`groupToMany(Function<? super T,? extends Iterator<? extends Key>> keySelector, int groupMaxQueueSize)` The semantics are identical to `groupBy(Function, int)` except that the `keySelector` can map each data to multiple keys.
`<Key> Publisher<GroupedPublisher<Key,T>>`	`groupToMany(Function<? super T,? extends Iterator<? extends Key>> keySelector, int groupMaxQueueSize, int expectedGroupCountHint)` The semantics are identical to `groupBy(Function, int)` except that the `keySelector` can map each data to multiple keys.
`protected abstract void`	`handleSubscribe(PublisherSource.Subscriber<? super T> subscriber)` Handles a subscriber to this `Publisher`.
`Publisher<T>`	`idleTimeout(Duration duration)` Creates a new `Publisher` that will mimic the signals of this `Publisher` but will terminate with a `TimeoutException` if time `duration` elapses between adjacent `PublisherSource.Subscriber.onNext(Object)` calls.
`Publisher<T>`	`idleTimeout(Duration duration, Executor timeoutExecutor)` Creates a new `Publisher` that will mimic the signals of this `Publisher` but will terminate with a `TimeoutException` if time `duration` elapses between adjacent `PublisherSource.Subscriber.onNext(Object)` calls.
`Publisher<T>`	`idleTimeout(long duration, TimeUnit unit)` Creates a new `Publisher` that will mimic the signals of this `Publisher` but will terminate with a `TimeoutException` if time `duration` elapses between adjacent `PublisherSource.Subscriber.onNext(Object)` calls.
`Publisher<T>`	`idleTimeout(long duration, TimeUnit unit, Executor timeoutExecutor)` Creates a new `Publisher` that will mimic the signals of this `Publisher` but will terminate with a `TimeoutException` if time `duration` elapses between adjacent `PublisherSource.Subscriber.onNext(Object)` calls.
`Completable`	`ignoreElements()` Ignores all elements emitted by this `Publisher` and forwards the termination signal to the returned `Completable`.
`<R> Publisher<R>`	`liftAsync(PublisherOperator<? super T,? extends R> operator)` This method requires advanced knowledge of building operators.
`<R> Publisher<R>`	`liftSync(PublisherOperator<? super T,? extends R> operator)` This method requires advanced knowledge of building operators.
`<R> Single<R>`	`liftSyncToSingle(PublisherToSingleOperator<? super T,? extends R> operator)` This method requires advanced knowledge of building operators.
`<R> Publisher<R>`	`map(Function<? super T,? extends R> mapper)` Transforms elements emitted by this `Publisher` into a different type.
`Publisher<T>`	`multicastToExactly(int expectedSubscribers)` Create a `Publisher` that multicasts all the signals to exactly `expectedSubscribers`.
`Publisher<T>`	`multicastToExactly(int expectedSubscribers, int maxQueueSize)` Create a `Publisher` that allows exactly `expectedSubscribers` subscribes.
`static <T> Publisher<T>`	`never()` Creates a new `Publisher` that never emits any item to its `PublisherSource.Subscriber` and never call any terminal methods on it.
`Publisher<T>`	`publishAndSubscribeOn(Executor executor)` Creates a new `Publisher` that will use the passed `Executor` to invoke the following methods: All `PublisherSource.Subscriber` methods. All `PublisherSource.Subscription` methods. The `handleSubscribe(PublisherSource.Subscriber)` method. This method does not override preceding `Executor`s, if any, specified for `this` `Publisher`.
`Publisher<T>`	`publishAndSubscribeOnOverride(Executor executor)` Creates a new `Publisher` that will use the passed `Executor` to invoke the following methods: All `PublisherSource.Subscriber` methods. All `PublisherSource.Subscription` methods. The `handleSubscribe(PublisherSource.Subscriber)` method. This method overrides preceding `Executor`s, if any, specified for `this` `Publisher`.
`Publisher<T>`	`publishOn(Executor executor)` Creates a new `Publisher` that will use the passed `Executor` to invoke all `PublisherSource.Subscriber` methods.
`Publisher<T>`	`publishOnOverride(Executor executor)` Creates a new `Publisher` that will use the passed `Executor` to invoke all `PublisherSource.Subscriber` methods.
`Publisher<T>`	`recoverWith(Function<Throwable,? extends Publisher<? extends T>> nextFactory)` Recover from any error emitted by this `Publisher` by using another `Publisher` provided by the passed `nextFactory`.
`Publisher<T>`	`repeat(IntPredicate shouldRepeat)` Re-subscribes to this `Publisher` when it completes and the passed `IntPredicate` returns `true`.
`Publisher<T>`	`repeatWhen(IntFunction<? extends Completable> repeatWhen)` Re-subscribes to this `Publisher` when it completes and the `Completable` returned by the supplied `IntFunction` completes successfully.
`Publisher<T>`	`retry(BiIntPredicate<Throwable> shouldRetry)` Re-subscribes to this `Publisher` if an error is emitted and the passed `BiIntPredicate` returns `true`.
`Publisher<T>`	`retryWhen(BiIntFunction<Throwable,? extends Completable> retryWhen)` Re-subscribes to this `Publisher` if an error is emitted and the `Completable` returned by the supplied `BiIntFunction` completes successfully.
`protected void`	`subscribeInternal(PublisherSource.Subscriber<? super T> subscriber)` A internal subscribe method similar to `PublisherSource.subscribe(Subscriber)` which can be used by different implementations to subscribe.
`Publisher<T>`	`subscribeOn(Executor executor)` Creates a new `Publisher` that will use the passed `Executor` to invoke the following methods: All `PublisherSource.Subscription` methods. The `handleSubscribe(PublisherSource.Subscriber)` method. This method does not override preceding `Executor`s, if any, specified for `this` `Publisher`.
`Publisher<T>`	`subscribeOnOverride(Executor executor)` Creates a new `Publisher` that will use the passed `Executor` to invoke the following methods: All `PublisherSource.Subscription` methods. The `handleSubscribe(PublisherSource.Subscriber)` method. This method overrides preceding `Executor`s, if any, specified for `this` `Publisher`.
`Publisher<T>`	`subscribeShareContext()` Signifies that when the returned `Publisher` is subscribed to, the `AsyncContext` will be shared instead of making a `copy`.
`Publisher<T>`	`takeAtMost(long numElements)` Takes at most `numElements` elements from `this` `Publisher`.
`Publisher<T>`	`takeUntil(Completable until)` Takes elements until `Completable` is terminated successfully or with failure.
`Publisher<T>`	`takeWhile(Predicate<? super T> predicate)` Takes elements while `Predicate` is `true` and then cancel `PublisherSource.Subscription` of this `Publisher` once it returns `false`.
`CompletionStage<Collection<T>>`	`toCompletionStage()` Convert this `Publisher` into a `CompletionStage` with a `Collection` containing the elements of this `Publisher` upon successful termination.
`<R> CompletionStage<R>`	`toCompletionStage(Supplier<? extends R> resultFactory, BiFunction<? super R,? super T,R> reducer)` Convert this `Publisher` into a `CompletionStage` of type `R` which represents all elements of this `Publisher` upon successful termination.
`Future<Collection<T>>`	`toFuture()` Convert this `Publisher` into a `Future` with a `Collection` containing the elements of this `Publisher` upon successful termination.
`<R> Future<R>`	`toFuture(Supplier<? extends R> resultFactory, BiFunction<? super R,? super T,R> reducer)` Convert this `Publisher` into a `Future` of type `R` which represents all elements of this `Publisher` upon successful termination.
`InputStream`	`toInputStream(Function<? super T,byte[]> serializer)` Subscribes to `this` `Publisher` and converts all signals received by the `PublisherSource.Subscriber` to the returned `InputStream` following the below rules: `PublisherSource.Subscription` received by `PublisherSource.Subscriber.onSubscribe(PublisherSource.Subscription)` is used to request more data when required.
`InputStream`	`toInputStream(Function<? super T,byte[]> serializer, int queueCapacity)` Subscribes to `this` `Publisher` and converts all signals received by the `PublisherSource.Subscriber` to the returned `InputStream` following the below rules: `PublisherSource.Subscription` received by `PublisherSource.Subscriber.onSubscribe(PublisherSource.Subscription)` is used to request more data when required.
`BlockingIterable<T>`	`toIterable()` Converts `this` `Publisher` to an `BlockingIterable`.
`BlockingIterable<T>`	`toIterable(int queueCapacityHint)` Converts `this` `Publisher` to an `BlockingIterable`.
`Publisher<T>`	`whenCancel(Runnable onCancel)` Invokes the `onCancel` `Runnable` argument when `Cancellable.cancel()` is called for Subscriptions of the returned `Publisher`.
`Publisher<T>`	`whenFinally(Runnable doFinally)` Invokes the `whenFinally` `Runnable` argument exactly once, when any of the following terminal methods are called: `PublisherSource.Subscriber.onComplete()` `PublisherSource.Subscriber.onError(Throwable)` `Cancellable.cancel()` for `PublisherSource.Subscription`s/`PublisherSource.Subscriber`s of the returned `Publisher`.
`Publisher<T>`	`whenOnComplete(Runnable onComplete)` Invokes the `onComplete` `Runnable` argument when `PublisherSource.Subscriber.onComplete()` is called for `PublisherSource.Subscriber`s of the returned `Publisher`.
`Publisher<T>`	`whenOnError(Consumer<Throwable> onError)` Invokes the `onError` `Consumer` argument when `PublisherSource.Subscriber.onError(Throwable)` is called for `PublisherSource.Subscriber`s of the returned `Publisher`.
`Publisher<T>`	`whenOnNext(Consumer<? super T> onNext)` Invokes the `onNext` `Consumer` argument when `PublisherSource.Subscriber.onNext(Object)` is called for `PublisherSource.Subscriber`s of the returned `Publisher`.
`Publisher<T>`	`whenOnSubscribe(Consumer<? super PublisherSource.Subscription> onSubscribe)` Invokes the `onSubscribe` `Consumer` argument when `PublisherSource.Subscriber.onSubscribe(PublisherSource.Subscription)` is called for `PublisherSource.Subscriber`s of the returned `Publisher`.
`Publisher<T>`	`whenRequest(LongConsumer onRequest)` Invokes the `onRequest` `LongConsumer` argument when `PublisherSource.Subscription.request(long)` is called for `PublisherSource.Subscription`s of the returned `Publisher`.
`Publisher<T>`	`whenSubscriber(Supplier<? extends PublisherSource.Subscriber<? super T>> subscriberSupplier)` Creates a new `PublisherSource.Subscriber` (via the `subscriberSupplier` argument) for each new subscribe and invokes methods on that `PublisherSource.Subscriber` when the corresponding methods are called for `PublisherSource.Subscriber`s of the returned `Publisher`.
`Publisher<T>`	`whenSubscription(Supplier<? extends PublisherSource.Subscription> subscriptionSupplier)` Creates a new `PublisherSource.Subscription` (via the `subscriptionSupplier` argument) for each new subscribe and invokes all the `PublisherSource.Subscription` methods when the corresponding methods are called for `PublisherSource.Subscription`s of the returned `Publisher`.

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

- Constructor Detail
  - Publisher
```
protected Publisher()
```
    New instance.
- Method Detail
  - map
```
public final <R> Publisher<R> map(Function<? super T,? extends R> mapper)
```
    Transforms elements emitted by this Publisher into a different type.
    This method provides a data transformation in sequential programming similar to:
```
     List<R> results = ...;
     for (T t : resultOfThisPublisher()) {
         results.add(mapper.apply(t));
     }
     return results;
 
```
    Type Parameters:
    
    R - Type of the items emitted by the returned Publisher.
    
    Parameters:
    
    mapper - Function to transform each item emitted by this Publisher.
    
    Returns:
    
    A Publisher that transforms elements emitted by this Publisher into a different type.
    
    See Also:
    
    ReactiveX map operator.
  - filter
```
public final Publisher<T> filter(Predicate<? super T> predicate)
```
    Filters items emitted by this Publisher.
    This method provides a data transformation in sequential programming similar to:
```
     List<T> results = ...;
     for (T t : resultOfThisPublisher()) {
         if (predicate.test(t)) {
             results.add(t);
         }
     }
     return results;
 
```
    Parameters:
    
    predicate - for the filter.
    
    Returns:
    
    A Publisher that only emits the items that pass the predicate.
    
    See Also:
    
    ReactiveX filter operator.
  - recoverWith
```
public final Publisher<T> recoverWith(Function<Throwable,? extends Publisher<? extends T>> nextFactory)
```
    Recover from any error emitted by this Publisher by using another Publisher provided by the passed nextFactory.
    This method provides similar capabilities to a try/catch block in sequential programming:
```
     List<T> results;
     try {
         results = resultOfThisPublisher();
     } catch (Throwable cause) {
         // Note that nextFactory returning a error Publisher is like re-throwing (nextFactory shouldn't throw).
         results = nextFactory.apply(cause);
     }
     return results;
 
```
    Parameters:
    
    nextFactory - Returns the next Publisher, when this Publisher emits an error.
    
    Returns:
    
    A Publisher that recovers from an error from this Publisher by using another Publisher provided by the passed nextFactory.
    
    See Also:
    
    ReactiveX catch operator.
  - flatMapMergeSingle
```
public final <R> Publisher<R> flatMapMergeSingle(Function<? super T,? extends Single<? extends R>> mapper)
```
    Turns every item emitted by this Publisher into a Single and emits the items emitted by each of those Singles.
    To control the amount of concurrent processing done by this operator see flatMapMergeSingle(Function, int).
    This method is similar to map(Function) but the result is asynchronous, and provides a data transformation in sequential programming similar to:
```
     ExecutorService e = ...;
     List<Future<R>> futures = ...; // assume this is thread safe
     for (T t : resultOfThisPublisher()) {
         // Note that flatMap process results in parallel.
         futures.add(e.submit(() -> {
             return mapper.apply(t); // Asynchronous result is flatten into a value by this operator.
         }));
     }
     List<R> results = new ArrayList<>(futures.size());
     // This is an approximation, this operator does not provide any ordering guarantees for the results.
     for (Future<R> future : futures) {
         R r = future.get(); // Throws if the processing for this item failed.
         results.add(r);
     }
     return results;
 
```
    Type Parameters:
    
    R - Type of items emitted by the returned Publisher.
    
    Parameters:
    
    mapper - Function to convert each item emitted by this Publisher into a Single.
    
    Returns:
    
    A new Publisher that emits all items emitted by each single produced by mapper.
    
    See Also:
    
    ReactiveX flatMap operator., flatMapMergeSingle(Function, int)
  - flatMapMergeSingle
```
public final <R> Publisher<R> flatMapMergeSingle(Function<? super T,? extends Single<? extends R>> mapper,
                                                 int maxConcurrency)
```
    Turns every item emitted by this Publisher into a Single and emits the items emitted by each of those Singles.
    This method is similar to map(Function) but the result is asynchronous, and provides a data transformation in sequential programming similar to:
```
     ExecutorService e = ...;
     List<Future<R>> futures = ...; // assume this is thread safe
     for (T t : resultOfThisPublisher()) {
         // Note that flatMap process results in parallel.
         futures.add(e.submit(() -> {
             return mapper.apply(t); // Asynchronous result is flatten into a value by this operator.
         }));
     }
     List<R> results = new ArrayList<>(futures.size());
     // This is an approximation, this operator does not provide any ordering guarantees for the results.
     for (Future<R> future : futures) {
         R r = future.get(); // Throws if the processing for this item failed.
         results.add(r);
     }
     return results;
 
```
    Type Parameters:
    
    R - Type of items emitted by the returned Publisher.
    
    Parameters:
    
    mapper - Function to convert each item emitted by this Publisher into a Single.
    
    maxConcurrency - Maximum active Singles at any time. Even if the number of items requested by a PublisherSource.Subscriber is more than this number, this will never request more than this number at any point.
    
    Returns:
    
    A new Publisher that emits all items emitted by each single produced by mapper.
    
    See Also:
    
    ReactiveX flatMap operator.
  - flatMapMergeSingleDelayError
```
public final <R> Publisher<R> flatMapMergeSingleDelayError(Function<? super T,? extends Single<? extends R>> mapper)
```
    Turns every item emitted by this Publisher into a Single and emits the items emitted by each of those Singles. This is the same as flatMapMergeSingle(Function, int) just that if any Single returned by mapper, terminates with an error, the returned Publisher will not immediately terminate. Instead, it will wait for this Publisher and all Singles to terminate and then terminate the returned Publisher with all errors emitted by the Singles produced by the mapper.
    To control the amount of concurrent processing done by this operator see flatMapMergeSingleDelayError(Function, int).
    This method is similar to map(Function) but the result is asynchronous, and provides a data transformation in sequential programming similar to:
```
     Executor e = ...;
     List<T> tResults = resultOfThisPublisher();
     List<R> rResults = ...; // assume this is thread safe
     List<Throwable> errors = ...;  // assume this is thread safe
     CountDownLatch latch =  new CountDownLatch(tResults.size());
     for (T t : tResults) {
         // Note that flatMap process results in parallel.
         e.execute(() -> {
             try {
                 R r = mapper.apply(t); // Asynchronous result is flatten into a value by this operator.
                 rResults.add(r);
             } catch (Throwable cause) {
                 errors.add(cause);  // Asynchronous error is flatten into an error by this operator.
             } finally {
                 latch.countdown();
             }
         });
     }
     latch.await();
     if (errors.isEmpty()) {
         return rResults;
     }
     createAndThrowACompositeException(errors);
 
```
    Type Parameters:
    
    R - Type of items emitted by the returned Publisher.
    
    Parameters:
    
    mapper - Function to convert each item emitted by this Publisher into a Single.
    
    Returns:
    
    A new Publisher that emits all items emitted by each single produced by mapper.
    
    See Also:
    
    ReactiveX merge operator., flatMapMergeSingleDelayError(Function, int)
  - flatMapMergeSingleDelayError
```
public final <R> Publisher<R> flatMapMergeSingleDelayError(Function<? super T,? extends Single<? extends R>> mapper,
                                                           int maxConcurrency)
```
    Turns every item emitted by this Publisher into a Single and emits the items emitted by each of those Singles. This is the same as flatMapMergeSingle(Function, int) just that if any Single returned by mapper, terminates with an error, the returned Publisher will not immediately terminate. Instead, it will wait for this Publisher and all Singles to terminate and then terminate the returned Publisher with all errors emitted by the Singles produced by the mapper.
    This method is similar to map(Function) but the result is asynchronous, and provides a data transformation in sequential programming similar to:
```
     Executor e = ...;
     List<T> tResults = resultOfThisPublisher();
     List<R> rResults = ...; // assume this is thread safe
     List<Throwable> errors = ...;  // assume this is thread safe
     CountDownLatch latch =  new CountDownLatch(tResults.size());
     for (T t : tResults) {
         // Note that flatMap process results in parallel.
         e.execute(() -> {
             try {
                 R r = mapper.apply(t); // Asynchronous result is flatten into a value by this operator.
                 rResults.add(r);
             } catch (Throwable cause) {
                 errors.add(cause);  // Asynchronous error is flatten into an error by this operator.
             } finally {
                 latch.countdown();
             }
         });
     }
     latch.await();
     if (errors.isEmpty()) {
         return rResults;
     }
     createAndThrowACompositeException(errors);
 
```
    Type Parameters:
    
    R - Type of items emitted by the returned Publisher.
    
    Parameters:
    
    mapper - Function to convert each item emitted by this Publisher into a Single.
    
    maxConcurrency - Maximum active Singles at any time. Even if the number of items requested by a PublisherSource.Subscriber is more than this number, this will never request more than this number at any point.
    
    Returns:
    
    A new Publisher that emits all items emitted by each single produced by mapper.
    
    See Also:
    
    ReactiveX merge operator.
  - flatMapCompletable
```
public final Completable flatMapCompletable(Function<? super T,? extends Completable> mapper)
```
    Turns every item emitted by this Publisher into a Completable and terminate the returned Completable when all the intermediate Completables have terminated successfully or any one of them has terminated with a failure. If the returned Completable should wait for the termination of all remaining Completables when any one of them terminates with a failure, flatMapCompletableDelayError(Function) should be used.
    To control the amount of concurrent processing done by this operator see flatMapCompletable(Function, int).
    This method is similar to map(Function) but the result is asynchronous, and provides a data transformation in sequential programming similar to:
```
     ExecutorService e = ...;
     List<Future<Void>> futures = ...; // assume this is thread safe
     for (T t : resultOfThisPublisher()) {
         // Note that flatMap process results in parallel.
         futures.add(e.submit(() -> {
             return mapper.apply(t); // Asynchronous result is flatten into a value by this operator.
         }));
     }
     // This is an approximation, this operator does not provide any ordering guarantees for the results.
     for (Future<R> future : futures) {
         future.get(); // Throws if the processing for this item failed.
     }
 
```
    Parameters:
    
    mapper - Function to convert each item emitted by this Publisher into a Completable.
    
    Returns:
    
    A new Completable that terminates successfully if all the intermediate Completables have terminated successfully or any one of them has terminated with a failure.
    
    See Also:
    
    ReactiveX flatMap operator., flatMapCompletable(Function, int), flatMapCompletableDelayError(Function)
  - flatMapCompletable
```
public final Completable flatMapCompletable(Function<? super T,? extends Completable> mapper,
                                            int maxConcurrency)
```
    Turns every item emitted by this Publisher into a Completable and terminate the returned Completable when all the intermediate Completables have terminated successfully or any one of them has terminated with a failure. If the returned Completable should wait for the termination of all remaining Completables when any one of them terminates with a failure, flatMapCompletableDelayError(Function) should be used.
    This method is similar to map(Function) but the result is asynchronous, and provides a data transformation in sequential programming similar to:
```
     ExecutorService e = ...;
     List<Future<Void>> futures = ...; // assume this is thread safe
     for (T t : resultOfThisPublisher()) {
         // Note that flatMap process results in parallel.
         futures.add(e.submit(() -> {
             return mapper.apply(t); // Asynchronous result is flatten into a value by this operator.
         }));
     }
     // This is an approximation, this operator does not provide any ordering guarantees for the results.
     for (Future<R> future : futures) {
         future.get(); // Throws if the processing for this item failed.
     }
 
```
    Parameters:
    
    mapper - Function to convert each item emitted by this Publisher into a Completable.
    
    maxConcurrency - Maximum active Completables at any time.
    
    Returns:
    
    A new Completable that terminates successfully if all the intermediate Completables have terminated successfully or any one of them has terminated with a failure.
    
    See Also:
    
    ReactiveX flatMap operator., flatMapCompletable(Function), flatMapCompletableDelayError(Function, int)
  - flatMapCompletableDelayError
```
public final Completable flatMapCompletableDelayError(Function<? super T,? extends Completable> mapper)
```
    Turns every item emitted by this Publisher into a Completable and terminate the returned Completable when all the intermediate Completables have terminated. If any Completable returned by mapper, terminates with an error, the returned Completable will not immediately terminate. Instead, it will wait for this Publisher and all Completables to terminate and then terminate the returned Completable with all errors emitted by the Completables produced by the mapper.
    To control the amount of concurrent processing done by this operator see flatMapCompletableDelayError(Function, int).
    This method is similar to map(Function) but the result is asynchronous, and provides a data transformation in sequential programming similar to:
```
     Executor e = ...;
     List<Throwable> errors = ...;  // assume this is thread safe
     CountDownLatch latch =  new CountDownLatch(tResults.size());
     for (T t : tResults) {
         // Note that flatMap process results in parallel.
         e.execute(() -> {
             try {
                 mapper.apply(t); // Asynchronous result is flattened by this operator.
             } catch (Throwable cause) {
                 errors.add(cause);  // Asynchronous error is flatten into an error by this operator.
             } finally {
                 latch.countdown();
             }
         });
     }
     latch.await();
     if (!errors.isEmpty()) {
         createAndThrowACompositeException(errors);
     }
 
```
    Parameters:
    
    mapper - Function to convert each item emitted by this Publisher into a Completable.
    
    Returns:
    
    A new Completable that terminates successfully if all the intermediate Completables have terminated successfully or any one of them has terminated with a failure.
    
    See Also:
    
    ReactiveX merge operator., flatMapMergeSingleDelayError(Function, int)
  - flatMapCompletableDelayError
```
public final Completable flatMapCompletableDelayError(Function<? super T,? extends Completable> mapper,
                                                      int maxConcurrency)
```
    Turns every item emitted by this Publisher into a Completable and terminate the returned Completable when all the intermediate Completables have terminated.If any Completable returned by mapper, terminates with an error, the returned Completable will not immediately terminate. Instead, it will wait for this Publisher and all Completables to terminate and then terminate the returned Completable with all errors emitted by the Completables produced by the mapper.
    This method is similar to map(Function) but the result is asynchronous, and provides a data transformation in sequential programming similar to:
```
     Executor e = ...;
     List<Throwable> errors = ...;  // assume this is thread safe
     CountDownLatch latch =  new CountDownLatch(tResults.size());
     for (T t : tResults) {
         // Note that flatMap process results in parallel.
         e.execute(() -> {
             try {
                 mapper.apply(t); // Asynchronous result is flattened by this operator.
             } catch (Throwable cause) {
                 errors.add(cause);  // Asynchronous error is flatten into an error by this operator.
             } finally {
                 latch.countdown();
             }
         });
     }
     latch.await();
     if (!errors.isEmpty()) {
         createAndThrowACompositeException(errors);
     }
 
```
    Parameters:
    
    mapper - Function to convert each item emitted by this Publisher into a Completable.
    
    maxConcurrency - Maximum active Completables at any time.
    
    Returns:
    
    A new Completable that terminates successfully if all the intermediate Completables have terminated successfully or any one of them has terminated with a failure.
    
    See Also:
    
    ReactiveX merge operator., flatMapMergeSingleDelayError(Function, int)
  - flatMapConcatIterable
```
public final <R> Publisher<R> flatMapConcatIterable(Function<? super T,? extends Iterable<? extends R>> mapper)
```
    Create a Publisher that flattens each element returned by the Iterable.iterator() from mapper.
    The mapper Function will only be called when the previously returned Iterator has returned false from Iterator.hasNext().
    This method provides similar capabilities as expanding each result into a collection and concatenating each collection in sequential programming:
```
     List<R> results = ...;
     for (T t : resultOfThisPublisher()) {
         Iterable<? extends R> itr = mapper.apply(t);
         itr.forEach(results::add);
     }
     return results;
 
```
    Type Parameters:
    
    R - The elements returned by the Iterable.
    
    Parameters:
    
    mapper - A Function that returns an Iterable for each element.
    
    Returns:
    
    a Publisher that flattens each element returned by the Iterable.iterator() from mapper. The results will be sequential for each Iterator, and overall for all calls to Iterable.iterator()
  - whenOnSubscribe
```
public final Publisher<T> whenOnSubscribe(Consumer<? super PublisherSource.Subscription> onSubscribe)
```
    Invokes the onSubscribe Consumer argument when PublisherSource.Subscriber.onSubscribe(PublisherSource.Subscription) is called for PublisherSource.Subscribers of the returned Publisher.
    The order in which onSubscribe will be invoked relative to PublisherSource.Subscriber.onSubscribe(PublisherSource.Subscription) is undefined. If you need strict ordering see beforeOnSubscribe(Consumer) and afterOnSubscribe(Consumer).
    
    Parameters:
    
    onSubscribe - Invoked when PublisherSource.Subscriber.onSubscribe(PublisherSource.Subscription) is called for PublisherSource.Subscribers of the returned Publisher. MUST NOT throw.
    
    Returns:
    
    The new Publisher.
    
    See Also:
    
    beforeOnNext(Consumer), afterOnNext(Consumer)
  - whenOnNext
```
public final Publisher<T> whenOnNext(Consumer<? super T> onNext)
```
    Invokes the onNext Consumer argument when PublisherSource.Subscriber.onNext(Object) is called for PublisherSource.Subscribers of the returned Publisher.
    The order in which onNext will be invoked relative to PublisherSource.Subscriber.onNext(Object) is undefined. If you need strict ordering see beforeOnNext(Consumer) and afterOnNext(Consumer).
    From a sequential programming point of view this method is roughly equivalent to the following:
```
  for (T t: resultOfThisPublisher()) {
      // NOTE: The order of operations here is not guaranteed by this method!
      processNext(t);
      onNext.accept(t);
  }
 
```
    Parameters:
    
    onNext - Invoked when PublisherSource.Subscriber.onNext(Object) is called for PublisherSource.Subscribers of the returned Publisher. MUST NOT throw.
    
    Returns:
    
    The new Publisher.
    
    See Also:
    
    beforeOnNext(Consumer), afterOnNext(Consumer)
  - whenOnComplete
```
public final Publisher<T> whenOnComplete(Runnable onComplete)
```
    Invokes the onComplete Runnable argument when PublisherSource.Subscriber.onComplete() is called for PublisherSource.Subscribers of the returned Publisher.
    The order in which onComplete will be invoked relative to PublisherSource.Subscriber.onComplete() is undefined. If you need strict ordering see beforeOnComplete(Runnable) and afterOnComplete(Runnable).
    From a sequential programming point of view this method is roughly equivalent to the following:
```
  List<T> results = resultOfThisPublisher();
  // NOTE: The order of operations here is not guaranteed by this method!
  onSuccess.accept(results);
  nextOperation(results);
 
```
    Parameters:
    
    onComplete - Invoked when PublisherSource.Subscriber.onComplete() is called for PublisherSource.Subscribers of the returned Publisher. MUST NOT throw.
    
    Returns:
    
    The new Publisher.
    
    See Also:
    
    beforeOnComplete(Runnable), afterOnComplete(Runnable)
  - whenOnError
```
public final Publisher<T> whenOnError(Consumer<Throwable> onError)
```
    Invokes the onError Consumer argument when PublisherSource.Subscriber.onError(Throwable) is called for PublisherSource.Subscribers of the returned Publisher.
    The order in which onError will be invoked relative to PublisherSource.Subscriber.onError(Throwable) is undefined. If you need strict ordering see beforeOnError(Consumer) and afterOnError(Consumer).
    From a sequential programming point of view this method is roughly equivalent to the following:
```
  try {
    List<T> results = resultOfThisPublisher();
  } catch (Throwable cause) {
      // NOTE: The order of operations here is not guaranteed by this method!
      nextOperation(cause);
      onError.accept(cause);
  }
 
```
    Parameters:
    
    onError - Invoked before PublisherSource.Subscriber.onError(Throwable) is called for PublisherSource.Subscribers of the returned Publisher. MUST NOT throw.
    
    Returns:
    
    The new Publisher.
    
    See Also:
    
    beforeOnError(Consumer), afterOnError(Consumer)
  - whenFinally
```
public final Publisher<T> whenFinally(Runnable doFinally)
```
    Invokes the whenFinally Runnable argument exactly once, when any of the following terminal methods are called:
    - PublisherSource.Subscriber.onComplete()
    - PublisherSource.Subscriber.onError(Throwable)
    - Cancellable.cancel()
    for PublisherSource.Subscriptions/PublisherSource.Subscribers of the returned Publisher.
    The order in which whenFinally will be invoked relative to the above methods is undefined. If you need strict ordering see beforeFinally(Runnable) and afterFinally(Runnable).
    From a sequential programming point of view this method is roughly equivalent to the following:
```
  try {
      List<T> results = resultOfThisPublisher();
  } finally {
      // NOTE: The order of operations here is not guaranteed by this method!
      nextOperation(); // Maybe notifying of cancellation, or termination
      whenFinally.run();
  }
 
```
    Parameters:
    doFinally - Invoked exactly once, when any of the following terminal methods are called:
    
    PublisherSource.Subscriber.onComplete()
    
    PublisherSource.Subscriber.onError(Throwable)
    
    Cancellable.cancel()
    
    for PublisherSource.Subscriptions/PublisherSource.Subscribers of the returned Publisher. MUST NOT throw.
    Returns:
    
    The new Publisher.
    
    See Also:
    
    afterFinally(Runnable), beforeFinally(Runnable)
  - whenRequest
```
public final Publisher<T> whenRequest(LongConsumer onRequest)
```
    Invokes the onRequest LongConsumer argument when PublisherSource.Subscription.request(long) is called for PublisherSource.Subscriptions of the returned Publisher.
    
    Parameters:
    
    onRequest - Invoked when PublisherSource.Subscription.request(long) is called for PublisherSource.Subscriptions of the returned Publisher. MUST NOT throw.
    
    Returns:
    
    The new Publisher.
    
    See Also:
    
    ReactiveX do operator.
  - whenCancel
```
public final Publisher<T> whenCancel(Runnable onCancel)
```
    Invokes the onCancel Runnable argument when Cancellable.cancel() is called for Subscriptions of the returned Publisher.
    The order in which whenFinally will be invoked relative to Cancellable.cancel() is undefined. If you need strict ordering see beforeCancel(Runnable) and afterCancel(Runnable).
    
    Parameters:
    
    onCancel - Invoked when Cancellable.cancel() is called for Subscriptions of the returned Publisher. MUST NOT throw.
    
    Returns:
    
    The new Publisher.
    
    See Also:
    
    beforeCancel(Runnable), afterCancel(Runnable)
  - idleTimeout
```
public final Publisher<T> idleTimeout(long duration,
                                      TimeUnit unit)
```
    Creates a new Publisher that will mimic the signals of this Publisher but will terminate with a TimeoutException if time duration elapses between adjacent PublisherSource.Subscriber.onNext(Object) calls. The timer starts when the returned Publisher is subscribed.
    In the event of timeout any PublisherSource.Subscription from PublisherSource.Subscriber.onSubscribe(PublisherSource.Subscription) will be cancelled and the associated PublisherSource.Subscriber will be terminated.
    
    Parameters:
    
    duration - The time duration which is allowed to elapse between PublisherSource.Subscriber.onNext(Object) calls.
    
    unit - The units for duration.
    
    Returns:
    
    a new Publisher that will mimic the signals of this Publisher but will terminate with a TimeoutException if time duration elapses between PublisherSource.Subscriber.onNext(Object) calls.
    
    See Also:
    
    ReactiveX timeout operator., idleTimeout(long, TimeUnit, Executor)
  - idleTimeout
```
public final Publisher<T> idleTimeout(Duration duration)
```
    Creates a new Publisher that will mimic the signals of this Publisher but will terminate with a TimeoutException if time duration elapses between adjacent PublisherSource.Subscriber.onNext(Object) calls. The timer starts when the returned Publisher is subscribed.
    In the event of timeout any PublisherSource.Subscription from PublisherSource.Subscriber.onSubscribe(PublisherSource.Subscription) will be cancelled and the associated PublisherSource.Subscriber will be terminated.
    
    Parameters:
    
    duration - The time duration which is allowed to elapse between PublisherSource.Subscriber.onNext(Object) calls.
    
    Returns:
    
    a new Publisher that will mimic the signals of this Publisher but will terminate with a TimeoutException if time duration elapses between PublisherSource.Subscriber.onNext(Object) calls.
    
    See Also:
    
    ReactiveX timeout operator., idleTimeout(long, TimeUnit, Executor)
  - idleTimeout
```
public final Publisher<T> idleTimeout(long duration,
                                      TimeUnit unit,
                                      Executor timeoutExecutor)
```
    Creates a new Publisher that will mimic the signals of this Publisher but will terminate with a TimeoutException if time duration elapses between adjacent PublisherSource.Subscriber.onNext(Object) calls. The timer starts when the returned Publisher is subscribed.
    In the event of timeout any PublisherSource.Subscription from PublisherSource.Subscriber.onSubscribe(PublisherSource.Subscription) will be cancelled and the associated PublisherSource.Subscriber will be terminated.
    
    Parameters:
    
    duration - The time duration which is allowed to elapse between PublisherSource.Subscriber.onNext(Object) calls.
    
    unit - The units for duration.
    
    timeoutExecutor - The Executor to use for managing the timer notifications.
    
    Returns:
    
    a new Publisher that will mimic the signals of this Publisher but will terminate with a TimeoutException if time duration elapses between PublisherSource.Subscriber.onNext(Object) calls.
    
    See Also:
    
    ReactiveX timeout operator.
  - idleTimeout
```
public final Publisher<T> idleTimeout(Duration duration,
                                      Executor timeoutExecutor)
```
    Creates a new Publisher that will mimic the signals of this Publisher but will terminate with a TimeoutException if time duration elapses between adjacent PublisherSource.Subscriber.onNext(Object) calls. The timer starts when the returned Publisher is subscribed.
    In the event of timeout any PublisherSource.Subscription from PublisherSource.Subscriber.onSubscribe(PublisherSource.Subscription) will be cancelled and the associated PublisherSource.Subscriber will be terminated.
    
    Parameters:
    
    duration - The time duration which is allowed to elapse between PublisherSource.Subscriber.onNext(Object) calls.
    
    timeoutExecutor - The Executor to use for managing the timer notifications.
    
    Returns:
    
    a new Publisher that will mimic the signals of this Publisher but will terminate with a TimeoutException if time duration elapses between PublisherSource.Subscriber.onNext(Object) calls.
    
    See Also:
    
    ReactiveX timeout operator.
  - concat
```
public final Publisher<T> concat(Publisher<? extends T> next)
```
    Emits items emitted by next Publisher after this Publisher terminates successfully.
    This method provides a means to sequence the execution of two asynchronous sources and in sequential programming is similar to:
```
     List<T> results = resultOfThisPublisher();
     results.addAll(resultOfPublisher(next));
     return results;
 
```
    Parameters:
    
    next - Publisher's items that are emitted after this Publisher terminates successfully.
    
    Returns:
    
    A Publisher that emits all items from this Publisher and next Publisher.
    
    See Also:
    
    ReactiveX concat operator.
  - concat
```
public final Publisher<T> concat(Single<? extends T> next)
```
    Listens and emits the result of next Single after this Publisher terminates successfully.
    This method provides a means to sequence the execution of two asynchronous sources and in sequential programming is similar to:
```
     List<T> results = resultOfThisPublisher();
     results.add(resultOfSingle(next));
     return results;
 
```
    Parameters:
    
    next - Single's result that is emitted after this Publisher terminates successfully.
    
    Returns:
    
    A Publisher that emits all items from this Publisher and the result of next Single.
    
    See Also:
    
    ReactiveX concat operator.
  - concat
```
public final Publisher<T> concat(Completable next)
```
    Listens for completion of next Completable after this Publisher terminates successfully. Any error from this Publisher and next Completable is forwarded to the returned Publisher.
    This method provides a means to sequence the execution of two asynchronous sources and in sequential programming is similar to:
```
     List<T> results = resultOfThisPublisher();
     resultOfCompletable(next);
     return results;
 
```
    Parameters:
    
    next - Completable to wait for completion after this Publisher terminates successfully.
    
    Returns:
    
    A Publisher that emits all items from this Publisher and then awaits successful completion of next Completable.
    
    See Also:
    
    ReactiveX concat operator.
  - retry
```
public final Publisher<T> retry(BiIntPredicate<Throwable> shouldRetry)
```
    Re-subscribes to this Publisher if an error is emitted and the passed BiIntPredicate returns true.
    This method provides a means to retry an operation under certain failure conditions and in sequential programming is similar to:
```
     public List<T> execute() {
         List<T> results = ...;
         return execute(0, results);
     }

     private List<T> execute(int attempts, List<T> results) {
         try {
             Iterator<T> itr = resultOfThisPublisher();
             while (itr.hasNext()) {
                 T t = itr.next(); // Any iteration with the Iterator may throw
                 results.add(t);
             }
             return results;
         } catch (Throwable cause) {
             if (shouldRetry.apply(attempts + 1, cause)) {
                 return execute(attempts + 1, results);
             } else {
                 throw cause;
             }
         }
     }
 
```
    Parameters:
    
    shouldRetry - BiIntPredicate that given the retry count and the most recent Throwable emitted from this Publisher determines if the operation should be retried.
    
    Returns:
    
    A Publisher that emits all items from this Publisher and re-subscribes if an error is emitted if the passed BiIntPredicate returned true.
    
    See Also:
    
    ReactiveX retry operator.
  - retryWhen
```
public final Publisher<T> retryWhen(BiIntFunction<Throwable,? extends Completable> retryWhen)
```
    Re-subscribes to this Publisher if an error is emitted and the Completable returned by the supplied BiIntFunction completes successfully. If the returned Completable emits an error, the returned Publisher terminates with that error.
    This method provides a means to retry an operation under certain failure conditions in an asynchronous fashion and in sequential programming is similar to:
```
     public List<T> execute() {
         List<T> results = ...;
         return execute(0, results);
     }

     private List<T> execute(int attempts, List<T> results) {
         try {
             Iterator<T> itr = resultOfThisPublisher();
             while (itr.hasNext()) {
                 T t = itr.next(); // Any iteration with the Iterator may throw
                 results.add(t);
             }
             return results;
         } catch (Throwable cause) {
             try {
                 shouldRetry.apply(attempts + 1, cause); // Either throws or completes normally
                 execute(attempts + 1, results);
             } catch (Throwable ignored) {
                 throw cause;
             }
         }
     }
 
```
    Parameters:
    
    retryWhen - BiIntFunction that given the retry count and the most recent Throwable emitted from this Publisher returns a Completable. If this Completable emits an error, that error is emitted from the returned Publisher, otherwise, original Publisher is re-subscribed when this Completable completes.
    
    Returns:
    
    A Publisher that emits all items from this Publisher and re-subscribes if an error is emitted and Completable returned by BiIntFunction completes successfully.
    
    See Also:
    
    ReactiveX retry operator.
  - repeat
```
public final Publisher<T> repeat(IntPredicate shouldRepeat)
```
    Re-subscribes to this Publisher when it completes and the passed IntPredicate returns true.
    This method provides a means to repeat an operation multiple times and in sequential programming is similar to:
```
     List<T> results = new ...;
     int i = 0;
     do {
         results.addAll(resultOfThisPublisher());
     } while (shouldRepeat.test(++i));
     return results;
 
```
    Parameters:
    
    shouldRepeat - IntPredicate that given the repeat count determines if the operation should be repeated.
    
    Returns:
    
    A Publisher that emits all items from this Publisher and re-subscribes when it completes if the passed IntPredicate returns true.
    
    See Also:
    
    ReactiveX repeat operator.
  - repeatWhen
```
public final Publisher<T> repeatWhen(IntFunction<? extends Completable> repeatWhen)
```
    Re-subscribes to this Publisher when it completes and the Completable returned by the supplied IntFunction completes successfully. If the returned Completable emits an error, the returned Publisher is completed.
    This method provides a means to repeat an operation multiple times when in an asynchronous fashion and in sequential programming is similar to:
```
     List<T> results = new ...;
     int i = 0;
     while (true) {
         results.addAll(resultOfThisPublisher());
         try {
             repeatWhen.apply(++i); // Either throws or completes normally
         } catch (Throwable cause) {
             break;
         }
     }
     return results;
 
```
    Parameters:
    
    repeatWhen - IntFunction that given the repeat count returns a Completable. If this Completable emits an error repeat is terminated, otherwise, original Publisher is re-subscribed when this Completable completes.
    
    Returns:
    
    A Publisher that emits all items from this Publisher and re-subscribes if an error is emitted and Completable returned by IntFunction completes successfully.
    
    See Also:
    
    ReactiveX retry operator.
  - takeAtMost
```
public final Publisher<T> takeAtMost(long numElements)
```
    Takes at most numElements elements from this Publisher.
    If no terminal event is received before receiving numElements elements, PublisherSource.Subscription for the PublisherSource.Subscriber is cancelled.
    This method provides a means to take a limited number of results from this Publisher and in sequential programming is similar to:
```
     List<T> results = ...;
     int i = 0;
     for (T t : resultOfThisPublisher()) {
         if (++i > numElements) {
             break;
         }
         results.add(t);
     }
     return results;
 
```
    Parameters:
    
    numElements - Number of elements to take.
    
    Returns:
    
    A Publisher that emits at most numElements elements from this Publisher.
    
    See Also:
    
    ReactiveX take operator.
  - takeWhile
```
public final Publisher<T> takeWhile(Predicate<? super T> predicate)
```
    Takes elements while Predicate is true and then cancel PublisherSource.Subscription of this Publisher once it returns false.
    This method provides a means to take a limited number of results from this Publisher and in sequential programming is similar to:
```
     List<T> results = ...;
     for (T t : resultOfThisPublisher()) {
         if (!predicate.test(result)) {
             break;
         }
         results.add(t);
     }
     return results;
 
```
    Parameters:
    
    predicate - Predicate that is checked before emitting any item to a PublisherSource.Subscriber. If this predicate returns true, that item is emitted, else PublisherSource.Subscription is cancelled.
    
    Returns:
    
    A Publisher that only emits the items as long as the Predicate.test(Object) method returns true.
    
    See Also:
    
    ReactiveX takeWhile operator.
  - takeUntil
```
public final Publisher<T> takeUntil(Completable until)
```
    Takes elements until Completable is terminated successfully or with failure.
    This method provides a means to take a limited number of results from this Publisher and in sequential programming is similar to:
```
     List<T> results = ...;
     for (T t : resultOfThisPublisher()) {
         if (isCompleted(until)) {
             break;
         }
         takeResults.add(t);
     }
     return results;
 
```
    Parameters:
    
    until - Completable, termination of which, terminates the returned Publisher.
    
    Returns:
    
    A Publisher that only emits the items till until Completable is completed.
    
    See Also:
    
    ReactiveX takeUntil operator.
  - groupBy
```
public final <Key> Publisher<GroupedPublisher<Key,T>> groupBy(Function<? super T,? extends Key> keySelector,
                                                              int groupMaxQueueSize)
```
    Splits items from this Publisher into dynamically generated GroupedPublishers. Item to group association is done by keySelector Function. If the selector selects a key which is previously seen and its associated PublisherSource.Subscriber has not yet cancelled its PublisherSource.Subscription, this item is sent to that PublisherSource.Subscriber. Otherwise a new GroupedPublisher is created and emitted from the returned Publisher.
    Flow control
    Multiple PublisherSource.Subscribers (for multiple GroupedPublishers) request items individually from this Publisher. Since, there is no way for a PublisherSource.Subscriber to only request elements for its group, elements requested by one group may end up producing items for a different group, which has not yet requested enough. This will cause items to be queued per group which can not be emitted due to lack of demand. This queue size can be controlled with the maxQueuePerGroup argument.
    Cancellation
    If the PublisherSource.Subscriber of the returned Publisher cancels its PublisherSource.Subscription, then all active GroupedPublishers will be terminated with an error and the PublisherSource.Subscription to this Publisher will be cancelled.
    PublisherSource.Subscribers of individual GroupedPublishers can cancel their PublisherSource.Subscriptions at any point. If any new item is emitted for the cancelled GroupedPublisher, a new GroupedPublisher will be emitted from the returned Publisher. Any queued items for a cancelled PublisherSource.Subscriber for a GroupedPublisher will be discarded and hence will not be emitted if the same GroupedPublisher is emitted again.
    In sequential programming this is similar to the following:
```
     Map<Key, List<T>> results = ...;
     for (T t : resultOfThisPublisher()) {
         Key k = keySelector.apply(result);
         List<T> v = results.get(k);
         if (v == null) {
             v = // new List
             results.put(k, v);
         }
         v.add(result);
     }
     return results;
 
```
    Type Parameters:
    
    Key - Type of GroupedPublisher keys.
    
    Parameters:
    
    keySelector - Function to assign an item emitted by this Publisher to a GroupedPublisher.
    
    groupMaxQueueSize - Maximum number of new groups that will be queued due to the PublisherSource.Subscriber of the Publisher returned from this method not requesting enough via PublisherSource.Subscription.request(long).
    
    Returns:
    
    A Publisher that emits GroupedPublishers for new keys as emitted by keySelector Function.
    
    See Also:
    
    ReactiveX groupBy operator.
  - groupBy
```
public final <Key> Publisher<GroupedPublisher<Key,T>> groupBy(Function<? super T,? extends Key> keySelector,
                                                              int groupMaxQueueSize,
                                                              int expectedGroupCountHint)
```
    Splits items from this Publisher into dynamically generated GroupedPublishers. Item to group association is done by keySelector Function. If the selector selects a key which is previously seen and its associated PublisherSource.Subscriber has not yet cancelled its PublisherSource.Subscription, this item is sent to that PublisherSource.Subscriber. Otherwise a new GroupedPublisher is created and emitted from the returned Publisher.
    Flow control
    Multiple PublisherSource.Subscribers (for multiple GroupedPublishers) request items individually from this Publisher. Since, there is no way for a PublisherSource.Subscriber to only request elements for its group, elements requested by one group may end up producing items for a different group, which has not yet requested enough. This will cause items to be queued per group which can not be emitted due to lack of demand. This queue size can be controlled with the maxQueuePerGroup argument.
    Cancellation
    If the PublisherSource.Subscriber of the returned Publisher cancels its PublisherSource.Subscription, then all active GroupedPublishers will be terminated with an error and the PublisherSource.Subscription to this Publisher will be cancelled.
    PublisherSource.Subscribers of individual GroupedPublishers can cancel their PublisherSource.Subscriptions at any point. If any new item is emitted for the cancelled GroupedPublisher, a new GroupedPublisher will be emitted from the returned Publisher. Any queued items for a cancelled PublisherSource.Subscriber for a GroupedPublisher will be discarded and hence will not be emitted if the same GroupedPublisher is emitted again.
    In sequential programming this is similar to the following:
```
     Map<Key, List<T>> results = ...;
     for (T t : resultOfThisPublisher()) {
         Key k = keySelector.apply(result);
         List<T> v = results.get(k);
         if (v == null) {
             v = // new List
             results.put(k, v);
         }
         v.add(result);
     }
     return results;
 
```
    Type Parameters:
    
    Key - Type of GroupedPublisher keys.
    
    Parameters:
    
    keySelector - Function to assign an item emitted by this Publisher to a GroupedPublisher.
    
    groupMaxQueueSize - Maximum number of new groups that will be queued due to the PublisherSource.Subscriber of the Publisher returned from this method not requesting enough via PublisherSource.Subscription.request(long).
    
    expectedGroupCountHint - Expected number of groups that would be emitted by this Publisher. This is just a hint for internal data structures and does not have to be precise.
    
    Returns:
    
    A Publisher that emits GroupedPublishers for new keys as emitted by keySelector Function.
    
    See Also:
    
    ReactiveX groupBy operator.
  - groupToMany
```
public final <Key> Publisher<GroupedPublisher<Key,T>> groupToMany(Function<? super T,? extends Iterator<? extends Key>> keySelector,
                                                                  int groupMaxQueueSize)
```
    The semantics are identical to groupBy(Function, int) except that the keySelector can map each data to multiple keys.
    In sequential programming this is similar to the following:
```
     Map<Key, List<T>> results = ...;
     for (T t : resultOfThisPublisher()) {
         Iterator<Key> keys = keySelector.apply(result);
         for (Key key : keys) {
             List<T> v = results.get(key);
             if (v == null) {
                 v = // new List
                 results.put(key, v);
             }
             v.add(result);
         }
     }
     return results;
 
```
    Type Parameters:
    
    Key - Type of GroupedPublisher keys.
    
    Parameters:
    
    keySelector - Function to assign an item emitted by this Publisher to multiple GroupedPublishers.
    
    groupMaxQueueSize - Maximum number of new groups that will be queued due to the PublisherSource.Subscriber of the Publisher returned from this method not requesting enough via PublisherSource.Subscription.request(long).
    
    Returns:
    
    A Publisher that emits GroupedPublishers for new keys as emitted by keySelector Function.
    
    See Also:
    
    groupBy(Function, int)
  - groupToMany
```
public final <Key> Publisher<GroupedPublisher<Key,T>> groupToMany(Function<? super T,? extends Iterator<? extends Key>> keySelector,
                                                                  int groupMaxQueueSize,
                                                                  int expectedGroupCountHint)
```
    The semantics are identical to groupBy(Function, int) except that the keySelector can map each data to multiple keys.
    In sequential programming this is similar to the following:
```
     Map<Key, List<T>> results = ...;
     for (T t : resultOfThisPublisher()) {
         Iterator<Key> keys = keySelector.apply(result);
         for (Key key : keys) {
             List<T> v = results.get(key);
             if (v == null) {
                 v = // new List
                 results.put(key, v);
             }
             v.add(result);
         }
     }
     return results;
 
```
    Type Parameters:
    
    Key - Type of GroupedPublisher keys.
    
    Parameters:
    
    keySelector - Function to assign an item emitted by this Publisher to multiple GroupedPublishers.
    
    groupMaxQueueSize - Maximum number of new groups that will be queued due to the PublisherSource.Subscriber of the Publisher returned from this method not requesting enough via PublisherSource.Subscription.request(long).
    
    expectedGroupCountHint - Expected number of groups that would be emitted by this Publisher. This is just a hint for internal data structures and does not have to be precise.
    
    Returns:
    
    A Publisher that emits GroupedPublishers for new keys as emitted by keySelector Function.
    
    See Also:
    
    groupBy(Function, int)
  - multicastToExactly
```
public final Publisher<T> multicastToExactly(int expectedSubscribers)
```
    Create a Publisher that multicasts all the signals to exactly expectedSubscribers.
    Depending on PublisherSource.Subscription.request(long) demand it is possible that data maybe queued before being delivered to each PublisherSource.Subscriber! For example if there are 2 PublisherSource.Subscribers and the first calls request(10), and the second only calls request(1), then 9 elements will be queued to deliver to second when more PublisherSource.Subscription.request(long) demand is made.
    In sequential programming this is similar to the following:
```
     List<T> results = resultOfThisPublisher();
     List<List<T>> multiResults = ...;
     for (int i = 0; i < expectedSubscribers; ++i) {
         multiResults.add(results);
     }
     return multiResults;
 
```
    Parameters:
    
    expectedSubscribers - The number of expected subscribe calls required on the returned Publisher before subscribing to this Publisher.
    
    Returns:
    
    a Publisher that allows exactly expectedSubscribers subscribes.
  - multicastToExactly
```
public final Publisher<T> multicastToExactly(int expectedSubscribers,
                                             int maxQueueSize)
```
    Create a Publisher that allows exactly expectedSubscribers subscribes. The events from this Publisher object will be delivered to each PublisherSource.Subscriber.
    Depending on PublisherSource.Subscription.request(long) demand it is possible that data maybe queued before being delivered to each PublisherSource.Subscriber! For example if there are 2 PublisherSource.Subscribers and the first calls request(10), and the second only calls request(10), then 9 elements will be queued to deliver to second when more PublisherSource.Subscription.request(long) demand is made.
    In sequential programming this is similar to the following:
```
     List<T> results = resultOfThisPublisher();
     List<List<T>> multiResults = ...;
     for (int i = 0; i < expectedSubscribers; ++i) {
         multiResults.add(results);
     }
     return multiResults;
 
```
    Parameters:
    
    expectedSubscribers - The number of expected subscribe calls required on the returned Publisher before subscribing to this Publisher.
    
    maxQueueSize - The maximum number of PublisherSource.Subscriber.onNext(Object) events that will be queued if there is no demand for data before the PublisherSource.Subscriber will be discarded.
    
    Returns:
    
    a Publisher that allows exactly expectedSubscribers subscribes.
  - beforeOnSubscribe
```
public final Publisher<T> beforeOnSubscribe(Consumer<? super PublisherSource.Subscription> onSubscribe)
```
    Invokes the onSubscribe Consumer argument before PublisherSource.Subscriber.onSubscribe(PublisherSource.Subscription) is called for PublisherSource.Subscribers of the returned Publisher.
    
    Parameters:
    
    onSubscribe - Invoked before PublisherSource.Subscriber.onSubscribe(PublisherSource.Subscription) is called for PublisherSource.Subscribers of the returned Publisher. MUST NOT throw.
    
    Returns:
    
    The new Publisher.
    
    See Also:
    
    ReactiveX do operator.
  - beforeOnNext
```
public final Publisher<T> beforeOnNext(Consumer<? super T> onNext)
```
    Invokes the onNext Consumer argument before PublisherSource.Subscriber.onNext(Object) is called for PublisherSource.Subscribers of the returned Publisher.
    From a sequential programming point of view this method is roughly equivalent to the following:
```
  List<T> results = resultOfThisPublisher();
  for (T result : results) {
      onNext.accept(result);
  }
  nextOperation(results);
 
```
    Parameters:
    
    onNext - Invoked before PublisherSource.Subscriber.onNext(Object) is called for PublisherSource.Subscribers of the returned Publisher. MUST NOT throw.
    
    Returns:
    
    The new Publisher.
    
    See Also:
    
    ReactiveX do operator.
  - beforeOnError
```
public final Publisher<T> beforeOnError(Consumer<Throwable> onError)
```
    Invokes the onError Consumer argument before PublisherSource.Subscriber.onError(Throwable) is called for PublisherSource.Subscribers of the returned Publisher.
    From a sequential programming point of view this method is roughly equivalent to the following:
```
  try {
    List<T> results = resultOfThisPublisher();
  } catch (Throwable cause) {
      onError.accept(cause);
      nextOperation(cause);
  }
 
```
    Parameters:
    
    onError - Invoked before PublisherSource.Subscriber.onError(Throwable) is called for PublisherSource.Subscribers of the returned Publisher. MUST NOT throw.
    
    Returns:
    
    The new Publisher.
    
    See Also:
    
    ReactiveX do operator.
  - beforeOnComplete
```
public final Publisher<T> beforeOnComplete(Runnable onComplete)
```
    Invokes the onComplete Runnable argument before PublisherSource.Subscriber.onComplete() is called for PublisherSource.Subscribers of the returned Publisher.
    From a sequential programming point of view this method is roughly equivalent to the following:
```
   List<T> results = resultOfThisPublisher();
   onComplete.run();
   nextOperation(results);
 
```
    Parameters:
    
    onComplete - Invoked before PublisherSource.Subscriber.onComplete() is called for PublisherSource.Subscribers of the returned Publisher. MUST NOT throw.
    
    Returns:
    
    The new Publisher.
    
    See Also:
    
    ReactiveX do operator.
  - beforeRequest
```
public final Publisher<T> beforeRequest(LongConsumer onRequest)
```
    Invokes the onRequest LongConsumer argument before PublisherSource.Subscription.request(long) is called for PublisherSource.Subscriptions of the returned Publisher.
    
    Parameters:
    
    onRequest - Invoked before PublisherSource.Subscription.request(long) is called for PublisherSource.Subscriptions of the returned Publisher. MUST NOT throw.
    
    Returns:
    
    The new Publisher.
    
    See Also:
    
    ReactiveX do operator.
  - beforeCancel
```
public final Publisher<T> beforeCancel(Runnable onCancel)
```
    Invokes the onCancel Runnable argument before Cancellable.cancel() is called for PublisherSource.Subscriptions of the returned Publisher.
    
    Parameters:
    
    onCancel - Invoked before Cancellable.cancel() is called for PublisherSource.Subscriptions of the returned Publisher. MUST NOT throw.
    
    Returns:
    
    The new Publisher.
    
    See Also:
    
    ReactiveX do operator.
  - beforeFinally
```
public final Publisher<T> beforeFinally(Runnable doFinally)
```
    Invokes the whenFinally Runnable argument before any of the following terminal methods are called:
    - PublisherSource.Subscriber.onComplete()
    - PublisherSource.Subscriber.onError(Throwable)
    - Cancellable.cancel()
    for PublisherSource.Subscriptions/PublisherSource.Subscribers of the returned Publisher.
    From a sequential programming point of view this method is roughly equivalent to the following:
```
  try {
      List<T> results = resultOfThisPublisher();
  } finally {
      whenFinally.run();
      nextOperation(); // Maybe notifying of cancellation, or termination
  }
 
```
    Parameters:
    doFinally - Invoked before any of the following terminal methods are called:
    
    PublisherSource.Subscriber.onComplete()
    
    PublisherSource.Subscriber.onError(Throwable)
    
    Cancellable.cancel()
    
    for PublisherSource.Subscriptions/PublisherSource.Subscribers of the returned Publisher. MUST NOT throw.
    Returns:
    
    The new Publisher.
    
    See Also:
    
    ReactiveX do operator.
  - beforeSubscriber
```
public final Publisher<T> beforeSubscriber(Supplier<? extends PublisherSource.Subscriber<? super T>> subscriberSupplier)
```
    Creates a new PublisherSource.Subscriber (via the subscriberSupplier argument) on each call to subscribe and invokes all the PublisherSource.Subscriber methods before the PublisherSource.Subscribers of the returned Publisher.
    
    Parameters:
    
    subscriberSupplier - Creates a new PublisherSource.Subscriber on each call to subscribe and invokes all the PublisherSource.Subscriber methods before the PublisherSource.Subscribers of the returned Publisher. PublisherSource.Subscriber methods MUST NOT throw.
    
    Returns:
    
    The new Publisher.
    
    See Also:
    
    ReactiveX do operator.
  - beforeSubscription
```
public final Publisher<T> beforeSubscription(Supplier<? extends PublisherSource.Subscription> subscriptionSupplier)
```
    Creates a new PublisherSource.Subscription (via the subscriptionSupplier argument) on each call to subscribe and invokes all the PublisherSource.Subscription methods before the PublisherSource.Subscriptions of the returned Publisher.
    
    Parameters:
    
    subscriptionSupplier - Creates a new PublisherSource.Subscription on each call to subscribe and invokes all the PublisherSource.Subscription methods before the PublisherSource.Subscriptions of the returned Publisher. PublisherSource.Subscription methods MUST NOT throw.
    
    Returns:
    
    The new Publisher.
    
    See Also:
    
    ReactiveX do operator.
  - afterOnSubscribe
```
public final Publisher<T> afterOnSubscribe(Consumer<? super PublisherSource.Subscription> onSubscribe)
```
    Invokes the onSubscribe Consumer argument after PublisherSource.Subscriber.onSubscribe(PublisherSource.Subscription) is called for PublisherSource.Subscribers of the returned Publisher.
    
    Parameters:
    
    onSubscribe - Invoked after PublisherSource.Subscriber.onSubscribe(PublisherSource.Subscription) is called for PublisherSource.Subscribers of the returned Publisher. MUST NOT throw.
    
    Returns:
    
    The new Publisher.
    
    See Also:
    
    ReactiveX do operator.
  - afterOnNext
```
public final Publisher<T> afterOnNext(Consumer<? super T> onNext)
```
    Invokes the onNext Consumer argument after PublisherSource.Subscriber.onNext(Object) is called for PublisherSource.Subscribers of the returned Publisher.
    From a sequential programming point of view this method is roughly equivalent to the following:
```
  List<T> results = resultOfThisPublisher();
  nextOperation(results);
  for (T result : results) {
      onNext.accept(result);
  }
 
```
    Parameters:
    
    onNext - Invoked after PublisherSource.Subscriber.onNext(Object) is called for PublisherSource.Subscribers of the returned Publisher. MUST NOT throw.
    
    Returns:
    
    The new Publisher.
    
    See Also:
    
    ReactiveX do operator.
  - afterOnError
```
public final Publisher<T> afterOnError(Consumer<Throwable> onError)
```
    Invokes the onError Consumer argument after PublisherSource.Subscriber.onError(Throwable) is called for PublisherSource.Subscribers of the returned Publisher.
    From a sequential programming point of view this method is roughly equivalent to the following:
```
  try {
    List<T> results = resultOfThisPublisher();
  } catch (Throwable cause) {
      nextOperation(cause);
      onError.accept(cause);
  }
 
```
    Parameters:
    
    onError - Invoked after PublisherSource.Subscriber.onError(Throwable) is called for PublisherSource.Subscribers of the returned Publisher. MUST NOT throw.
    
    Returns:
    
    The new Publisher.
    
    See Also:
    
    ReactiveX do operator.
  - afterOnComplete
```
public final Publisher<T> afterOnComplete(Runnable onComplete)
```
    Invokes the onComplete Runnable argument after PublisherSource.Subscriber.onComplete() is called for PublisherSource.Subscribers of the returned Publisher.
    From a sequential programming point of view this method is roughly equivalent to the following:
```
   List<T> results = resultOfThisPublisher();
   nextOperation(results);
   onComplete.run();
 
```
    Parameters:
    
    onComplete - Invoked after PublisherSource.Subscriber.onComplete() is called for PublisherSource.Subscribers of the returned Publisher. MUST NOT throw.
    
    Returns:
    
    The new Publisher.
    
    See Also:
    
    ReactiveX do operator.
  - afterRequest
```
public final Publisher<T> afterRequest(LongConsumer onRequest)
```
    Invokes the onRequest LongConsumer argument after PublisherSource.Subscription.request(long) is called for PublisherSource.Subscriptions of the returned Publisher.
    
    Parameters:
    
    onRequest - Invoked after PublisherSource.Subscription.request(long) is called for PublisherSource.Subscriptions of the returned Publisher. MUST NOT throw.
    
    Returns:
    
    The new Publisher.
    
    See Also:
    
    ReactiveX do operator.
  - afterCancel
```
public final Publisher<T> afterCancel(Runnable onCancel)
```
    Invokes the onCancel Runnable argument after Cancellable.cancel() is called for PublisherSource.Subscriptions of the returned Publisher.
    
    Parameters:
    
    onCancel - Invoked after Cancellable.cancel() is called for PublisherSource.Subscriptions of the returned Publisher. MUST NOT throw.
    
    Returns:
    
    The new Publisher.
    
    See Also:
    
    ReactiveX do operator.
  - afterFinally
```
public final Publisher<T> afterFinally(Runnable doFinally)
```
    Invokes the whenFinally Runnable argument after any of the following terminal methods are called:
    - PublisherSource.Subscriber.onComplete()
    - PublisherSource.Subscriber.onError(Throwable)
    - Cancellable.cancel()
    for PublisherSource.Subscriptions/PublisherSource.Subscribers of the returned Publisher.
    From a sequential programming point of view this method is roughly equivalent to the following:
```
  try {
      List<T> results = resultOfThisPublisher();
  } finally {
      nextOperation(); // Maybe notifying of cancellation, or termination
      whenFinally.run();
  }
 
```
    Parameters:
    doFinally - Invoked after any of the following terminal methods are called:
    
    PublisherSource.Subscriber.onComplete()
    
    PublisherSource.Subscriber.onError(Throwable)
    
    Cancellable.cancel()
    
    for PublisherSource.Subscriptions/PublisherSource.Subscribers of the returned Publisher. MUST NOT throw.
    Returns:
    
    The new Publisher.
    
    See Also:
    
    ReactiveX do operator.
  - afterSubscriber
```
public final Publisher<T> afterSubscriber(Supplier<? extends PublisherSource.Subscriber<? super T>> subscriberSupplier)
```
    Creates a new PublisherSource.Subscriber (via the subscriberSupplier argument) for each new subscribe and invokes all the PublisherSource.Subscriber methods after the PublisherSource.Subscribers of the returned Publisher.
    
    Parameters:
    
    subscriberSupplier - Creates a new PublisherSource.Subscriber for each new subscribe and invokes all the PublisherSource.Subscriber methods after the PublisherSource.Subscribers of the returned Publisher. PublisherSource.Subscriber methods MUST NOT throw.
    
    Returns:
    
    The new Publisher.
    
    See Also:
    
    ReactiveX do operator.
  - whenSubscriber
```
public final Publisher<T> whenSubscriber(Supplier<? extends PublisherSource.Subscriber<? super T>> subscriberSupplier)
```
    Creates a new PublisherSource.Subscriber (via the subscriberSupplier argument) for each new subscribe and invokes methods on that PublisherSource.Subscriber when the corresponding methods are called for PublisherSource.Subscribers of the returned Publisher.
    
    Parameters:
    
    subscriberSupplier - Creates a new PublisherSource.Subscriber for each new subscribe and invokes methods on that PublisherSource.Subscriber when the corresponding methods are called for PublisherSource.Subscribers of the returned Publisher. PublisherSource.Subscriber methods MUST NOT throw.
    
    Returns:
    
    The new Publisher.
  - afterSubscription
```
public final Publisher<T> afterSubscription(Supplier<? extends PublisherSource.Subscription> subscriptionSupplier)
```
    Creates a new PublisherSource.Subscription (via the subscriptionSupplier argument) for each new subscribe and invokes all the PublisherSource.Subscription methods after the PublisherSource.Subscriptions of the returned Publisher.
    
    Parameters:
    
    subscriptionSupplier - Creates a new PublisherSource.Subscription for each new subscribe and invokes all the PublisherSource.Subscription methods after the PublisherSource.Subscriptions of the returned Publisher. PublisherSource.Subscription methods MUST NOT throw.
    
    Returns:
    
    The new Publisher.
    
    See Also:
    
    ReactiveX do operator.
  - whenSubscription
```
public final Publisher<T> whenSubscription(Supplier<? extends PublisherSource.Subscription> subscriptionSupplier)
```
    Creates a new PublisherSource.Subscription (via the subscriptionSupplier argument) for each new subscribe and invokes all the PublisherSource.Subscription methods when the corresponding methods are called for PublisherSource.Subscriptions of the returned Publisher.
    
    Parameters:
    
    subscriptionSupplier - Creates a new PublisherSource.Subscription for each new subscribe and invokes all the PublisherSource.Subscription methods when the PublisherSource.Subscriptions of the returned Publisher. PublisherSource.Subscription methods MUST NOT throw.
    
    Returns:
    
    The new Publisher.
    
    See Also:
    
    ReactiveX do operator.
  - forEach
```
public final Cancellable forEach(Consumer<? super T> forEach)
```
    Subscribes to this Publisher and invokes forEach Consumer for each item emitted by this Publisher.
    This will request Long.MAX_VALUE from the PublisherSource.Subscription.
    From a sequential programming point of view this method is roughly equivalent to the following:
```
  List<T> results = resultOfThisPublisher();
  results.iterator().forEachRemaining(forEach);
 
```
    Parameters:
    
    forEach - Consumer to invoke for each PublisherSource.Subscriber.onNext(Object).
    
    Returns:
    
    Cancellable used to invoke Cancellable.cancel() on the parameter of PublisherSource.Subscriber.onSubscribe(PublisherSource.Subscription) for this Publisher.
  - publishOn
```
public final Publisher<T> publishOn(Executor executor)
```
    Creates a new Publisher that will use the passed Executor to invoke all PublisherSource.Subscriber methods. This method does not override preceding Executors, if any, specified for this Publisher. Only subsequent operations, if any, added in this execution chain will use this Executor. If such an override is required, publishOnOverride(Executor) can be used.
    
    Parameters:
    
    executor - Executor to use.
    
    Returns:
    
    A new Publisher that will use the passed Executor to invoke all methods of PublisherSource.Subscriber.
  - publishOnOverride
```
public final Publisher<T> publishOnOverride(Executor executor)
```
    Creates a new Publisher that will use the passed Executor to invoke all PublisherSource.Subscriber methods. This method overrides preceding Executors, if any, specified for this Publisher. That is to say preceding and subsequent operations for this execution chain will use this Executor. If such an override is not required, publishOn(Executor) can be used.
    
    Parameters:
    
    executor - Executor to use.
    
    Returns:
    
    A new Publisher that will use the passed Executor to invoke all methods of PublisherSource.Subscriber both for the returned Publisher as well as this Publisher.
  - subscribeOn
```
public final Publisher<T> subscribeOn(Executor executor)
```
    Creates a new Publisher that will use the passed Executor to invoke the following methods:
    - All PublisherSource.Subscription methods.
    - The handleSubscribe(PublisherSource.Subscriber) method.
    This method does not override preceding Executors, if any, specified for this Publisher. Only subsequent operations, if any, added in this execution chain will use this Executor. If such an override is required, subscribeOnOverride(Executor) can be used.
    Parameters:
    
    executor - Executor to use.
    
    Returns:
    
    A new Publisher that will use the passed Executor to invoke all methods of PublisherSource.Subscription and handleSubscribe(PublisherSource.Subscriber).
  - subscribeOnOverride
```
public final Publisher<T> subscribeOnOverride(Executor executor)
```
    Creates a new Publisher that will use the passed Executor to invoke the following methods:
    - All PublisherSource.Subscription methods.
    - The handleSubscribe(PublisherSource.Subscriber) method.
    This method overrides preceding Executors, if any, specified for this Publisher. That is to say preceding and subsequent operations for this execution chain will use this Executor. If such an override is not required, subscribeOn(Executor) can be used.
    Parameters:
    
    executor - Executor to use.
    
    Returns:
    
    A new Publisher that will use the passed Executor to invoke all methods of PublisherSource.Subscription and handleSubscribe(PublisherSource.Subscriber) both for the returned Publisher as well as this Publisher.
  - publishAndSubscribeOn
```
public final Publisher<T> publishAndSubscribeOn(Executor executor)
```
    Creates a new Publisher that will use the passed Executor to invoke the following methods:
    - All PublisherSource.Subscriber methods.
    - All PublisherSource.Subscription methods.
    - The handleSubscribe(PublisherSource.Subscriber) method.
    This method does not override preceding Executors, if any, specified for this Publisher. Only subsequent operations, if any, added in this execution chain will use this Executor. If such an override is required, publishAndSubscribeOnOverride(Executor) can be used.
    Parameters:
    
    executor - Executor to use.
    
    Returns:
    
    A new Publisher that will use the passed Executor to invoke all methods PublisherSource.Subscriber, PublisherSource.Subscription and handleSubscribe(PublisherSource.Subscriber).
  - publishAndSubscribeOnOverride
```
public final Publisher<T> publishAndSubscribeOnOverride(Executor executor)
```
    Creates a new Publisher that will use the passed Executor to invoke the following methods:
    - All PublisherSource.Subscriber methods.
    - All PublisherSource.Subscription methods.
    - The handleSubscribe(PublisherSource.Subscriber) method.
    This method overrides preceding Executors, if any, specified for this Publisher. That is to say preceding and subsequent operations for this execution chain will use this Executor. If such an override is not required, publishAndSubscribeOn(Executor) can be used.
    Parameters:
    
    executor - Executor to use.
    
    Returns:
    
    A new Publisher that will use the passed Executor to invoke all methods of PublisherSource.Subscriber, PublisherSource.Subscription and handleSubscribe(PublisherSource.Subscriber) both for the returned Publisher as well as this Publisher.
  - subscribeShareContext
```
public final Publisher<T> subscribeShareContext()
```
    Signifies that when the returned Publisher is subscribed to, the AsyncContext will be shared instead of making a copy.
    This operator only impacts behavior if the returned Publisher is subscribed directly after this operator, that means this must be the "last operator" in the chain for this to have an impact.
    
    Returns:
    
    A Publisher that will share the AsyncContext instead of making a copy when subscribed to.
  - liftSync
```
public final <R> Publisher<R> liftSync(PublisherOperator<? super T,? extends R> operator)
```
    This method requires advanced knowledge of building operators. Before using this method please attempt to compose existing operator(s) to satisfy your use case.
    Returns a Publisher which when subscribed, the operator argument will be used to wrap the PublisherSource.Subscriber before subscribing to this Publisher.
```
     Publisher<X> pub = ...;
     pub.map(..) // A
        .liftSync(original -> modified)
        .filter(..) // B
 
```
    The original -> modified "operator" MUST be "synchronous" in that it does not interact with the original PublisherSource.Subscriber from outside the modified PublisherSource.Subscriber or PublisherSource.Subscription threads. That is to say this operator will not impact the Executor constraints already in place between A and B above. If you need asynchronous behavior, or are unsure, see liftAsync(PublisherOperator).
    Type Parameters:
    
    R - Type of the items emitted by the returned Publisher.
    
    Parameters:
    
    operator - The custom operator logic. The input is the "original" PublisherSource.Subscriber to this Publisher and the return is the "modified" PublisherSource.Subscriber that provides custom operator business logic.
    
    Returns:
    
    a Publisher which when subscribed, the operator argument will be used to wrap the PublisherSource.Subscriber before subscribing to this Publisher.
    
    See Also:
    
    liftAsync(PublisherOperator)
  - liftSyncToSingle
```
public final <R> Single<R> liftSyncToSingle(PublisherToSingleOperator<? super T,? extends R> operator)
```
    This method requires advanced knowledge of building operators. Before using this method please attempt to compose existing operator(s) to satisfy your use case.
    Returns a Single which when subscribed, the operator argument will be used to convert between the SingleSource.Subscriber to a PublisherSource.Subscriber before subscribing to this Publisher.
```
     Publisher<X> pub = ...;
     pub.map(..) // A
        .liftSync(original -> modified)
        .filter(..) // B - we have converted to Single now!
 
```
    The original -> modified "operator" MUST be "synchronous" in that it does not interact with the original PublisherSource.Subscriber from outside the modified PublisherSource.Subscriber or PublisherSource.Subscription threads. That is to say this operator will not impact the Executor constraints already in place between A and B above. If you need asynchronous behavior, or are unsure, don't use this operator.
    Type Parameters:
    
    R - Type of the items emitted by the returned Single.
    
    Parameters:
    
    operator - The custom operator logic. The input is the "original" SingleSource.Subscriber to the returned Single and the return is the "modified" PublisherSource.Subscriber that provides custom operator business logic on this Publisher.
    
    Returns:
    
    a Single which when subscribed, the operator argument will be used to convert the SingleSource.Subscriber to a PublisherSource.Subscriber before subscribing to this Publisher.
  - liftAsync
```
public final <R> Publisher<R> liftAsync(PublisherOperator<? super T,? extends R> operator)
```
    This method requires advanced knowledge of building operators. Before using this method please attempt to compose existing operator(s) to satisfy your use case.
    Returns a Publisher which will wrap the PublisherSource.Subscriber using the provided operator argument before subscribing to this Publisher.
```
     Publisher<X> pub = ...;
     pub.map(..) // A
        .liftAsync(original -> modified)
        .filter(..) // B
 
```
    The original -> modified "operator" MAY be "asynchronous" in that it may interact with the original PublisherSource.Subscriber from outside the modified PublisherSource.Subscriber or PublisherSource.Subscription threads. More specifically:
    - all of the PublisherSource.Subscriber invocations going "downstream" (i.e. from A to B above) MAY be offloaded via an Executor
    - all of the PublisherSource.Subscription invocations going "upstream" (i.e. from B to A above) MAY be offloaded via an Executor
    This behavior exists to prevent blocking code negatively impacting the thread that powers the upstream source of data (e.g. an EventLoop).
    Type Parameters:
    
    R - Type of the items emitted by the returned Publisher.
    
    Parameters:
    
    operator - The custom operator logic. The input is the "original" PublisherSource.Subscriber to this Publisher and the return is the "modified" PublisherSource.Subscriber that provides custom operator business logic.
    
    Returns:
    
    a Publisher which when subscribed, the operator argument will be used to wrap the PublisherSource.Subscriber before subscribing to this Publisher.
    
    See Also:
    
    liftSync(PublisherOperator)
  - firstOrElse
```
public final Single<T> firstOrElse(Supplier<T> defaultValueSupplier)
```
    Converts this Publisher to a Single.
    
    Parameters:
    
    defaultValueSupplier - A Supplier of default value if this Publisher did not emit any item.
    
    Returns:
    
    A Single that will contain the first item emitted from the this Publisher. If the source Publisher does not emit any item, then the returned Single will contain the value as returned by the passed Supplier.
    
    See Also:
    
    ReactiveX first operator.
  - firstOrError
```
public final Single<T> firstOrError()
```
    Ensures that this Publisher emits exactly a single PublisherSource.Subscriber.onNext(Object) to its PublisherSource.Subscriber. If this Publisher terminates without emitting any items a NoSuchElementException will be signaled and if this Publisher emits more than one item, an IllegalArgumentException will be signaled. Any error emitted by this Publisher will be forwarded to the returned Single.
    
    Returns:
    
    A Single that will contain the first item emitted from the this Publisher. If the source Publisher does not emit any item, then the returned Single will terminate with NoSuchElementException.
  - ignoreElements
```
public final Completable ignoreElements()
```
    Ignores all elements emitted by this Publisher and forwards the termination signal to the returned Completable.
    
    Returns:
    
    A Completable that mirrors the terminal signal from this Publisher.
    
    See Also:
    
    ReactiveX ignoreElements operator.
  - collect
```
public final <R> Single<R> collect(Supplier<? extends R> resultFactory,
                                   BiFunction<? super R,? super T,R> collector)
```
    Collects all items emitted by this Publisher into a single item.
    
    Type Parameters:
    
    R - Type of the reduced item.
    
    Parameters:
    
    resultFactory - Factory for the result which collects all items emitted by this Publisher. This will be called every time the returned Single is subscribed.
    
    collector - Invoked for every item emitted by the source Publisher and returns the same or altered result object.
    
    Returns:
    
    A Single that completes with the single result or any error emitted by the source Publisher.
    
    See Also:
    
    ReactiveX reduce operator.
  - toFuture
```
public final Future<Collection<T>> toFuture()
```
    Convert this Publisher into a Future with a Collection containing the elements of this Publisher upon successful termination. If this Publisher terminates in an error, then the intermediate Collection will be discarded and the Future will complete exceptionally.
    
    Returns:
    
    a Future with a Collection containing the elements of this Publisher upon successful termination.
    
    See Also:
    
    toFuture(Supplier, BiFunction)
  - toFuture
```
public final <R> Future<R> toFuture(Supplier<? extends R> resultFactory,
                                    BiFunction<? super R,? super T,R> reducer)
```
    Convert this Publisher into a Future of type R which represents all elements of this Publisher upon successful termination. If this Publisher terminates in an error, then the intermediate R will be discarded and the Future will complete exceptionally.
    
    Type Parameters:
    
    R - Type of the reduced item.
    
    Parameters:
    
    resultFactory - Factory for the result which collects all items emitted by this Publisher.
    
    reducer - Invoked for every item emitted by the source Publisher and returns the same or altered result object.
    
    Returns:
    
    a Future of type R which represents all elements of this Publisher upon successful termination.
  - toCompletionStage
```
public final CompletionStage<Collection<T>> toCompletionStage()
```
    Convert this Publisher into a CompletionStage with a Collection containing the elements of this Publisher upon successful termination. If this Publisher terminates in an error, then the intermediate Collection will be discarded and the CompletionStage will complete exceptionally.
    
    Returns:
    
    a CompletionStage with a Collection containing the elements of this Publisher upon successful termination.
    
    See Also:
    
    toCompletionStage(Supplier, BiFunction)
  - toCompletionStage
```
public final <R> CompletionStage<R> toCompletionStage(Supplier<? extends R> resultFactory,
                                                      BiFunction<? super R,? super T,R> reducer)
```
    Convert this Publisher into a CompletionStage of type R which represents all elements of this Publisher upon successful termination. If this Publisher terminates in an error, then the intermediate R will be discarded and the CompletionStage will complete exceptionally.
    
    Type Parameters:
    
    R - Type of the reduced item.
    
    Parameters:
    
    resultFactory - Factory for the result which collects all items emitted by this Publisher.
    
    reducer - Invoked for every item emitted by the source Publisher and returns the same or altered result object.
    
    Returns:
    
    a CompletionStage of type R which represents all elements of this Publisher upon successful termination.
  - toInputStream
```
public final InputStream toInputStream(Function<? super T,byte[]> serializer)
```
    Subscribes to this Publisher and converts all signals received by the PublisherSource.Subscriber to the returned InputStream following the below rules:
    - PublisherSource.Subscription received by PublisherSource.Subscriber.onSubscribe(PublisherSource.Subscription) is used to request more data when required. If the returned InputStream is closed, PublisherSource.Subscription is cancelled and any unread data is disposed.
    - Any items received by PublisherSource.Subscriber.onNext(Object) are converted to a byte[] using the passed serializer. These bytes are available to be read from the InputStream
    - Any Throwable received by PublisherSource.Subscriber.onError(Throwable) is thrown (wrapped in an IOException) when data is read from the returned InputStream. This error will be thrown only after draining all queued data, if any.
    - When PublisherSource.Subscriber.onComplete() is called, returned InputStream's read methods will return -1 to indicate end of stream after emitting all received data.
    Flow control
    This operator may pre-fetch may pre-fetch items from this Publisher if available to reduce blocking for read operations from the returned InputStream. In order to increase responsiveness of the InputStream some amount of buffering may be done. Use toInputStream(Function, int) to manage capacity of this buffer.
    Parameters:
    
    serializer - Function that is invoked for every item emitted by this Publisher.
    
    Returns:
    
    InputStream that emits all data emitted by this Publisher. If this Publisher terminates with an error, same error is thrown (wrapped in an IOException) from the returned InputStreams read methods after emitting all received data.
  - toInputStream
```
public final InputStream toInputStream(Function<? super T,byte[]> serializer,
                                       int queueCapacity)
```
    Subscribes to this Publisher and converts all signals received by the PublisherSource.Subscriber to the returned InputStream following the below rules:
    - PublisherSource.Subscription received by PublisherSource.Subscriber.onSubscribe(PublisherSource.Subscription) is used to request more data when required. If the returned InputStream is closed, PublisherSource.Subscription is cancelled and any unread data is disposed.
    - Any items received by PublisherSource.Subscriber.onNext(Object) are convertedto a byte[] using the passed serializer. These bytes are available to be read from the InputStream
    - Any Throwable received by PublisherSource.Subscriber.onError(Throwable) is thrown (wrapped in an IOException) when data is read from the returned InputStream. This error will be thrown only after draining all queued data, if any.
    - When PublisherSource.Subscriber.onComplete() is called, returned InputStream's read methods will return -1 to indicate end of stream after emitting all received data.
    Flow control
    This operator may pre-fetch items from this Publisher if available to reduce blocking for read operations from the returned InputStream. In order to increase responsiveness of the InputStream some amount of buffering may be done. queueCapacity can be used to bound this buffer.
    Parameters:
    
    serializer - Function that is invoked for every item emitted by this Publisher.
    
    queueCapacity - Hint for the capacity of the intermediary queue that stores items that are emitted by this Publisher but has not yet been read from the returned InputStream.
    
    Returns:
    
    InputStream that emits all data emitted by this Publisher. If this Publisher terminates with an error, same error is thrown (wrapped in an IOException) from the returned InputStreams read methods after emitting all received data.
  - toIterable
```
public final BlockingIterable<T> toIterable()
```
    Converts this Publisher to an BlockingIterable. Every time BlockingIterable.iterator() is called on the returned BlockingIterable, this Publisher is subscribed following the below rules:
    - PublisherSource.Subscription received by PublisherSource.Subscriber.onSubscribe(PublisherSource.Subscription) is used to request more data when required.
    - Any items received by PublisherSource.Subscriber.onNext(Object) is returned from a call to BlockingIterator.next().
    - Any Throwable received by PublisherSource.Subscriber.onError(Throwable) is thrown (wrapped in a RuntimeException if required) when BlockingIterator.next() is called. This error will be thrown only after draining all queued data, if any.
    - When PublisherSource.Subscriber.onComplete() is called, returned BlockingIterators Iterator.hasNext() will return false BlockingIterator.next() will throw NoSuchElementException. This error will be thrown only after draining all queued data, if any.
    Flow control
    This operator may pre-fetch items from this Publisher if available to reduce blocking of Iterator.hasNext() from the returned BlockingIterable. In order to increase responsiveness of the Iterator some amount of buffering may be done. Use toIterable(int) to manage capacity of this buffer.
    Blocking
    The returned BlockingIterator from the returned BlockingIterable will block on Iterator.hasNext() and BlockingIterator.next() if no data is available. This operator may try to reduce this blocking by requesting data ahead of time.
    Returns:
    
    BlockingIterable representing this Publisher. Every time BlockingIterable.iterator() is invoked on the BlockingIterable, this Publisher is subscribed. BlockingIterators returned from this BlockingIterable do not support Iterator.remove().
  - toIterable
```
public final BlockingIterable<T> toIterable(int queueCapacityHint)
```
    Converts this Publisher to an BlockingIterable. Every time BlockingIterable.iterator() is called on the returned BlockingIterable, this Publisher is subscribed following the below rules:
    - PublisherSource.Subscription received by PublisherSource.Subscriber.onSubscribe(PublisherSource.Subscription) is used to request more data when required.
    - Any items received by PublisherSource.Subscriber.onNext(Object) is returned from a call to BlockingIterator.next().
    - Any Throwable received by PublisherSource.Subscriber.onError(Throwable) is thrown (wrapped in a RuntimeException if required) when BlockingIterator.next(). This error will be thrown only after draining all queued data, if any.
    - When PublisherSource.Subscriber.onComplete() is called, returned BlockingIterators Iterator.hasNext() will return false and BlockingIterator.next() will throw NoSuchElementException. This error will be thrown only after draining all queued data, if any.
    Flow control
    This operator may pre-fetch items from this Publisher if available to reduce blocking of Iterator.hasNext() from the returned BlockingIterable. In order to increase responsiveness of the BlockingIterator some amount of buffering may be done. queueCapacityHint can be used to bound this buffer.
    Blocking
    The returned BlockingIterator from the returned BlockingIterable will block on Iterator.hasNext() and BlockingIterator.next() if no data is available. This operator may try to reduce this blocking by requesting data ahead of time.
    Parameters:
    
    queueCapacityHint - Hint for the capacity of the intermediary queue that stores items that are emitted by this Publisher but has not yet been returned from the BlockingIterator.
    
    Returns:
    
    BlockingIterable representing this Publisher. Every time BlockingIterable.iterator() is invoked on the BlockingIterable, this Publisher is subscribed. BlockingIterators returned from this BlockingIterable do not support Iterator.remove().
  - subscribeInternal
```
protected final void subscribeInternal(PublisherSource.Subscriber<? super T> subscriber)
```
    A internal subscribe method similar to PublisherSource.subscribe(Subscriber) which can be used by different implementations to subscribe.
    
    Parameters:
    
    subscriber - PublisherSource.Subscriber to subscribe for the result.
  - handleSubscribe
```
protected abstract void handleSubscribe(PublisherSource.Subscriber<? super T> subscriber)
```
    Handles a subscriber to this Publisher.
    
    Parameters:
    
    subscriber - the subscriber.
  - from
```
public static <T> Publisher<T> from(@Nullable
                                    T value)
```
    Creates a new Publisher that emits value to its PublisherSource.Subscriber and then PublisherSource.Subscriber.onComplete().
    
    Type Parameters:
    
    T - Type of items emitted by the returned Publisher.
    
    Parameters:
    
    value - Value that the returned Publisher will emit.
    
    Returns:
    
    A new Publisher that emits value to its PublisherSource.Subscriber and then PublisherSource.Subscriber.onComplete().
    
    See Also:
    
    ReactiveX just operator.
  - from
```
@SafeVarargs
public static <T> Publisher<T> from(T... values)
```
    Creates a new Publisher that emits all values to its PublisherSource.Subscriber and then PublisherSource.Subscriber.onComplete().
    
    Type Parameters:
    
    T - Type of items emitted by the returned Publisher.
    
    Parameters:
    
    values - Values that the returned Publisher will emit.
    
    Returns:
    
    A new Publisher that emits all values to its PublisherSource.Subscriber and then PublisherSource.Subscriber.onComplete().
    
    See Also:
    
    ReactiveX from operator.
  - fromIterable
```
public static <T> Publisher<T> fromIterable(Iterable<? extends T> iterable)
```
    Create a new Publisher that when subscribed will get an Iterator via Iterable.iterator() and emit all values to the PublisherSource.Subscriber and then PublisherSource.Subscriber.onComplete().
    The Reactive Streams specification provides two criteria ( 3.4, and 3.5) stating the PublisherSource.Subscription should be "responsive". The responsiveness of the associated PublisherSource.Subscriptions will depend upon the behavior of the iterable below. Make sure the Executor for this execution chain can tolerate this responsiveness and any blocking behavior.
    
    Type Parameters:
    
    T - Type of items emitted by the returned Publisher.
    
    Parameters:
    
    iterable - used to obtain instances of Iterator to extract data from. Iterable.iterator() must not return null. If this is of type BlockingIterable then any generated BlockingIterators will have their BlockingIterator.close() method called if an error occurs.
    
    Returns:
    
    a new Publisher that when subscribed will get an Iterator via Iterable.iterator() and emit all values to the PublisherSource.Subscriber and then PublisherSource.Subscriber.onComplete().
  - fromBlockingIterable
```
public static <T> Publisher<T> fromBlockingIterable(BlockingIterable<? extends T> iterable,
                                                    LongSupplier timeoutSupplier,
                                                    TimeUnit unit)
```
    Create a new Publisher that when subscribed will get a BlockingIterator via BlockingIterable.iterator() and emit all values to the PublisherSource.Subscriber and then PublisherSource.Subscriber.onComplete().
    The Reactive Streams specification provides two criteria ( 3.4, and 3.5) stating the PublisherSource.Subscription should be "responsive". The responsiveness of the associated PublisherSource.Subscriptions will depend upon the behavior of the iterable below. Make sure the Executor for this execution chain can tolerate this responsiveness and any blocking behavior.
    
    Type Parameters:
    
    T - Type of items emitted by the returned Publisher.
    
    Parameters:
    
    iterable - used to obtain instances of Iterator to extract data from. Iterable.iterator() must not return null. Any generated BlockingIterators will have their BlockingIterator.close() method called if an error occurs.
    
    timeoutSupplier - A LongSupplier which provides the time duration to wait for each interaction with iterable.
    
    unit - The time units for the timeout duration.
    
    Returns:
    
    a new Publisher that when subscribed will get a BlockingIterator via BlockingIterable.iterator() and emit all values to the PublisherSource.Subscriber and then PublisherSource.Subscriber.onComplete().
  - fromInputStream
```
public static Publisher<byte[]> fromInputStream(InputStream stream)
```
    Create a new Publisher that when subscribed will emit all data from the InputStream to the PublisherSource.Subscriber and then PublisherSource.Subscriber.onComplete().
    The Reactive Streams specification provides two criteria ( 3.4, and 3.5) stating the PublisherSource.Subscription should be "responsive". The responsiveness of the associated PublisherSource.Subscriptions will depend upon the behavior of the stream below. Make sure the Executor for this execution chain can tolerate this responsiveness and any blocking behavior.
    
    Parameters:
    
    stream - provides the data in the form of byte[] to be emitted to the PublisherSource.Subscriber to the returned Publisher. Given the blocking nature of InputStream, assume PublisherSource.Subscription.request(long) can block when the underlying InputStream blocks on InputStream.read(byte[], int, int).
    
    Returns:
    
    a new Publisher that when subscribed will emit all data from the InputStream to the PublisherSource.Subscriber and then PublisherSource.Subscriber.onComplete().
  - empty
```
public static <T> Publisher<T> empty()
```
    Creates a new Publisher that completes when subscribed without emitting any item to its PublisherSource.Subscriber.
    
    Type Parameters:
    
    T - Type of items emitted by the returned Publisher.
    
    Returns:
    
    A new Publisher that completes when subscribed without emitting any item to its PublisherSource.Subscriber.
    
    See Also:
    
    ReactiveX empty operator.
  - never
```
public static <T> Publisher<T> never()
```
    Creates a new Publisher that never emits any item to its PublisherSource.Subscriber and never call any terminal methods on it.
    
    Type Parameters:
    
    T - Type of items emitted by the returned Publisher.
    
    Returns:
    
    A new Publisher that never emits any item to its PublisherSource.Subscriber and never call any terminal methods on it.
    
    See Also:
    
    ReactiveX never operator.
  - failed
```
public static <T> Publisher<T> failed(Throwable cause)
```
    Creates a new Publisher that terminates its PublisherSource.Subscriber with an error without emitting any item to it.
    
    Type Parameters:
    
    T - Type of items emitted by the returned Publisher.
    
    Parameters:
    
    cause - The Throwable that is used to terminate the PublisherSource.Subscriber.
    
    Returns:
    
    A new Publisher that terminates its PublisherSource.Subscriber with an error without emitting any item to it.
    
    See Also:
    
    ReactiveX error operator.
  - defer
```
public static <T> Publisher<T> defer(Supplier<? extends Publisher<? extends T>> publisherSupplier)
```
    Defers creation of a Publisher till it is subscribed.
    
    Type Parameters:
    
    T - Type of items emitted by the returned Publisher.
    
    Parameters:
    
    publisherSupplier - Supplier to create a new Publisher every time the returned Publisher is subscribed.
    
    Returns:
    
    A new Publisher that creates a new Publisher using publisherSupplier every time it is subscribed and forwards all items and terminal events from the newly created Publisher to its PublisherSource.Subscriber.
    
    See Also:
    
    ReactiveX defer operator.

Class Publisher<T>

How to subscribe?

Constructor Summary

Method Summary

Methods inherited from class Object

Constructor Detail

Publisher

Method Detail

map

filter

recoverWith

flatMapMergeSingle

flatMapMergeSingle

flatMapMergeSingleDelayError

flatMapMergeSingleDelayError

flatMapCompletable

flatMapCompletable

flatMapCompletableDelayError

flatMapCompletableDelayError

flatMapConcatIterable

whenOnSubscribe

whenOnNext

whenOnComplete

whenOnError

whenFinally

whenRequest

whenCancel

idleTimeout

idleTimeout

idleTimeout

idleTimeout

concat

concat

concat

retry

retryWhen

repeat

repeatWhen

takeAtMost

takeWhile

takeUntil

groupBy

Flow control

Cancellation

groupBy

Flow control

Cancellation

groupToMany

groupToMany

multicastToExactly

multicastToExactly

beforeOnSubscribe

beforeOnNext

beforeOnError

beforeOnComplete

beforeRequest

beforeCancel

beforeFinally

beforeSubscriber

beforeSubscription

afterOnSubscribe

afterOnNext

afterOnError

afterOnComplete

afterRequest

afterCancel

afterFinally

afterSubscriber

whenSubscriber

afterSubscription

whenSubscription

forEach

publishOn

publishOnOverride

subscribeOn

subscribeOnOverride

publishAndSubscribeOn

publishAndSubscribeOnOverride

subscribeShareContext

liftSync