hu.akarnokd.rxjava2.basetypes

## Class Nono

- java.lang.Object
- - hu.akarnokd.rxjava2.basetypes.Nono

All Implemented Interfaces:
  org.reactivestreams.Publisher<java.lang.Void>

Direct Known Subclasses:
  NonoProcessor

    public abstract class Nono
    extends java.lang.Object
    implements org.reactivestreams.Publisher<java.lang.Void>

Represents the base reactive class with fluent API for Publisher-based, no-item just onError or onComplete source.

Since this type never emits any value, the implementations ignore the downstream request and emit the terminal events even if there was no request (which is allowed by the Reactive-Streams specification).

Since there is no bottom type in Java (that is T is a subtype of all other types), Nono implements the Publisher interface via the Void type parameter.

Since:
  0.11.0

### Constructor Summary

Constructors
Constructor and Description
`Nono()`

### Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods
`static Nono` `amb(java.lang.Iterable<? extends Nono> sources)` Returns a Nono that terminates when the first Nono from the sources sequence terminates.
`static Nono` `ambArray(Nono... sources)` Returns a Nono that terminates when the first Nono from the array terminates.
`Nono` `andThen(Nono other)` Run the other Nono when this Nono completes.
`<T> io.reactivex.Flowable<T>` `andThen(org.reactivestreams.Publisher<? extends T> other)` When this Nono completes, it is continued by the events of the other Publisher.
`java.lang.Throwable` `blockingAwait()` Blockingly await indefinitely the termination of this Nono and return the Throwable if this Nono terminated with an error, null otherwise.
`java.lang.Throwable` `blockingAwait(long timeout, java.util.concurrent.TimeUnit unit)` Blockingly await for the given timeout the termination of this Nono and return the Throwable if this Nono terminated with an error, null otherwise.
`void` `blockingSubscribe()` Block until this Nono terminates and ignore the actual events.
`void` `blockingSubscribe(io.reactivex.functions.Action onComplete)` Block until this Nono completes and call the Action on the thread where the blocking happens.
`void` `blockingSubscribe(io.reactivex.functions.Action onComplete, io.reactivex.functions.Consumer<? super java.lang.Throwable> onError)` Block until this Nono terminates and call the Action or Consumer depending on the terminal event on the thread where the blocking happens.
`static int` `bufferSize()` Returns the default buffer or prefetch size.
`Nono` `cache()` Caches the terminal event of the upstream Nono and relays/replays it to Subscribers.
`static Nono` `complete()` Returns a Nono that completes normally.
`Nono` `compose(io.reactivex.functions.Function<? super Nono,? extends Nono> composer)` Compose operators fluently via a function callback that returns a Nono for this Nono.
`static Nono` `concat(java.lang.Iterable<? extends Nono> sources)` Runs the Nono sources one after the other.
`static Nono` `concat(org.reactivestreams.Publisher<? extends Nono> sources)` Runs the Nono sources emitted by the Publisher one after the other.
`static Nono` `concat(org.reactivestreams.Publisher<? extends Nono> sources, int prefetch)` Runs the Nono sources emitted by the Publisher one after the other, prefetching the given number of Nono sources.
`static Nono` `concatArray(Nono... sources)` Runs the Nono sources one after the other.
`static Nono` `concatArrayDelayError(Nono... sources)` Runs the Nono sources one after the other, delaying errors from them till all sources have terminated.
`static Nono` `concatDelayError(java.lang.Iterable<? extends Nono> sources)` Runs the Nono sources one after the other, delaying errors from them till all sources have terminated.
`static Nono` `concatDelayError(org.reactivestreams.Publisher<? extends Nono> sources)` Runs the Nono sources emitted by the Publisher, one after the other, delaying errors from them till all sources have terminated.
`static Nono` `concatDelayError(org.reactivestreams.Publisher<? extends Nono> sources, int prefetch, boolean tillTheEnd)` Runs the Nono sources emitted by the Publisher, one after the other, delaying errors from them till all sources have terminated and prefetching Nonos from the upstream.
`static Nono` `create(io.reactivex.CompletableOnSubscribe onCreate)` Creates a Nono instance that when subscribed to, the given onCreate is called for each individual subscriber to generate a terminal event synchronously and synchronously in a cancellation-safe manner.
`static Nono` `defer(java.util.concurrent.Callable<? extends Nono> supplier)` Defers the creation of the actual Nono instance until a subscriber subscribes.
`Nono` `delay(long delay, java.util.concurrent.TimeUnit unit)` Delay the emission of the terminal events of this Nono by the given time amount.
`Nono` `delay(long delay, java.util.concurrent.TimeUnit unit, io.reactivex.Scheduler scheduler)` Delay the emission of the terminal events of this Nono by the given time amount.
`Nono` `delaySubscription(long delay, java.util.concurrent.TimeUnit unit)` Delays the actual subscription to this Nono until the given time passes.
`Nono` `delaySubscription(long delay, java.util.concurrent.TimeUnit unit, io.reactivex.Scheduler scheduler)` Delays the actual subscription to this Nono until the given time passes.
`Nono` `delaySubscription(org.reactivestreams.Publisher<?> other)` Delays the actual subscription to this Nono until the other Publisher signals an item or completes.
`Nono` `doAfterTerminate(io.reactivex.functions.Action onAfterTerminate)` Executes the callback after this Nono terminates and the downstream is notified.
`Nono` `doFinally(io.reactivex.functions.Action onFinally)` Executes the callback exactly if the upstream terminates or the downstream cancels the sequence.
`Nono` `doOnCancel(io.reactivex.functions.Action onCancel)` Executes the callback if the downstream cancels the sequence.
`Nono` `doOnComplete(io.reactivex.functions.Action onComplete)` Executes a callback when the upstream completes normally.
`Nono` `doOnError(io.reactivex.functions.Consumer<? super java.lang.Throwable> onError)` Executes a callback when the upstream signals an error.
`Nono` `doOnRequest(io.reactivex.functions.LongConsumer onRequest)` Executes the callback when the downstream requests from this Nolo.
`Nono` `doOnSubscribe(io.reactivex.functions.Consumer<? super org.reactivestreams.Subscription> onSubscribe)` Executes a callback when the upstream calls onSubscribe.
`static Nono` `error(java.util.concurrent.Callable<? extends java.lang.Throwable> errorSupplier)` Returns a Nono that signals a Throwable generated by the callable for each individual subscriber.
`static Nono` `error(java.lang.Throwable ex)` Returns a Nono that signals the given Throwable to all subscribers.
`<T> io.reactivex.Flowable<T>` `flatMap(io.reactivex.functions.Function<? super java.lang.Throwable,? extends org.reactivestreams.Publisher<? extends T>> onErrorMapper, java.util.concurrent.Callable<? extends org.reactivestreams.Publisher<? extends T>> onCompleteMapper)` Maps the upstream completion or error into a Publisher and emit its events as a Flowable.
`static Nono` `fromAction(io.reactivex.functions.Action action)` Executes an action when a subscriber subscribes to the returned Nono.
`static Nono` `fromCompletable(io.reactivex.CompletableSource source)` Wrap a Completable into a Nono and terminate when the source Completable terminates.
`static Nono` `fromFuture(java.util.concurrent.Future<?> future)` Blockingly waits indefinitely for the given Future to terminate, relaying any error the Future signals.
`static Nono` `fromFuture(java.util.concurrent.Future<?> future, long timeout, java.util.concurrent.TimeUnit unit)` Blockingly waits the given Future for the given timeout to terminate, relaying any error the Future signals.
`static Nono` `fromMaybe(io.reactivex.MaybeSource<?> source)` Wrap a Maybe, ignore its success value and terminate if the source Maybe terminates.
`static Nono` `fromObservable(io.reactivex.ObservableSource<?> source)` Wrap a general Observable, ignore all of its values and terminate if the source Observable terminates.
`static Nono` `fromPublisher(org.reactivestreams.Publisher<?> source)` Wrap a general Publisher, ignore all of its values and terminate if the source Publisher terminates.
`static Nono` `fromSingle(io.reactivex.SingleSource<?> source)` Wrap a Single, ignore its success value and terminate if the source Single terminates.
`static io.reactivex.functions.Function<Nono,Nono>` `getOnAssemblyHandler()` Returns the current onAssembly handler function or null if not set.
`Nono` `hide()` Hides the identity of this Nono.
`Nono` `lift(io.reactivex.functions.Function<org.reactivestreams.Subscriber<? super java.lang.Void>,org.reactivestreams.Subscriber<? super java.lang.Void>> lifter)` Transform the downstream's Subscriber into a Subscriber for the upstream via a function.
`Nono` `mapError(io.reactivex.functions.Function<? super java.lang.Throwable,? extends java.lang.Throwable> mapper)` Maps the upstream error into another Throwable via a function.
`static Nono` `merge(java.lang.Iterable<? extends Nono> sources)` Runs all Nono sources at once and completes once all of them complete.
`static Nono` `merge(java.lang.Iterable<? extends Nono> sources, int maxConcurrency)` Runs the maximum number of Nono sources at once and completes when all source Nono complete.
`static Nono` `merge(org.reactivestreams.Publisher<? extends Nono> sources)` Runs all Nono sources emitted by the Publisher at once and completes once all of them complete.
`static Nono` `merge(org.reactivestreams.Publisher<? extends Nono> sources, int maxConcurrency)` Runs the maximum number of Nono sources emitted by the Publisher at once and completes when all source Nono complete.
`static Nono` `mergeArray(int maxConcurrency, Nono... sources)` Runs the maximum number of Nono sources at once and completes when all source Nono complete.
`static Nono` `mergeArray(Nono... sources)` Runs all Nono sources at once and completes once all of them complete.
`static Nono` `mergeArrayDelayError(int maxConcurrency, Nono... sources)` Runs the maximum number of Nono sources at once and terminates when all source Nono terminate, delaying errors in the process.
`static Nono` `mergeArrayDelayError(Nono... sources)` Runs all Nono sources at once and terminates once all of them terminate, delaying errors in the process.
`static Nono` `mergeDelayError(java.lang.Iterable<? extends Nono> sources)` Runs all Nono sources at once and terminates once all of them terminate, delaying errors in the process.
`static Nono` `mergeDelayError(java.lang.Iterable<? extends Nono> sources, int maxConcurrency)` Runs the maximum number of Nono sources at once and terminates when all source Nono terminate, delaying errors in the process.
`static Nono` `mergeDelayError(org.reactivestreams.Publisher<? extends Nono> sources)` Runs all Nono sources emitted by the Publisher at once and terminates once all of them terminate, delaying errors in the process.
`static Nono` `mergeDelayError(org.reactivestreams.Publisher<? extends Nono> sources, int maxConcurrency)` Runs the maximum number of Nono sources emitted by the Publisher at once and terminates when all source Nono terminate, delaying errors in the process.
`static Nono` `never()` Returns a Nono that never terminates.
`Nono` `observeOn(io.reactivex.Scheduler scheduler)` Observes the onError and onComplete events on the specified Scheduler.
`protected static Nono` `onAssembly(Nono source)` Optionally apply a function to the raw source and return a potentially modified Nono instance.
`Nono` `onErrorComplete()` If this Nono signals an error, signal an onComplete instead.
`Nono` `onErrorResumeNext(io.reactivex.functions.Function<? super java.lang.Throwable,? extends Nono> errorHandler)` If this Nono signals an error, subscribe to the fallback Nono returned by the error handler function.
`Nono` `repeat()` Repeatedly run this Nono indefinitely.
`Nono` `repeat(io.reactivex.functions.BooleanSupplier stop)` Repeat until the given BooleanSupplier returns true.
`Nono` `repeat(long times)` Repeatedly run this Nono at most the given number of times.
`Nono` `repeatWhen(io.reactivex.functions.Function<? super io.reactivex.Flowable<java.lang.Object>,? extends org.reactivestreams.Publisher<?>> handler)` Repeat when the Publisher returned by the handler function signals a value or terminate accordingly.
`Nono` `retry()` Repeatedly run this Nono indefinitely if it fails.
`Nono` `retry(long times)` Repeatedly run this Nono at most the given number of times if it fails.
`Nono` `retry(io.reactivex.functions.Predicate<? super java.lang.Throwable> predicate)` Retry a failed Nono if the predicate return true
`Nono` `retryWhen(io.reactivex.functions.Function<? super io.reactivex.Flowable<java.lang.Throwable>,? extends org.reactivestreams.Publisher<?>> handler)` Retry this Nono when the Publisher returned by the handler function signals a normal item or terminate if the Publisher terminates.
`static void` `setOnAssemblyHandler(io.reactivex.functions.Function<Nono,Nono> handler)` Sets the onAssembly handler.
`io.reactivex.disposables.Disposable` `subscribe()` Subscribe to this Nono and ignore the events it produces.
`io.reactivex.disposables.Disposable` `subscribe(io.reactivex.functions.Action onComplete)` Subscribe to this Nono and execute the given action if this Nono completes.
`io.reactivex.disposables.Disposable` `subscribe(io.reactivex.functions.Action onComplete, io.reactivex.functions.Consumer<? super java.lang.Throwable> onError)` Subscribe to this Nono and execute the given action if this Nono completes or call the consumer if this Nono terminates with an error.
`void` `subscribe(org.reactivestreams.Subscriber<? super java.lang.Void> s)`
`protected abstract void` `subscribeActual(org.reactivestreams.Subscriber<? super java.lang.Void> s)` Implement this method to signal the terminal events to the given subscriber.
`Nono` `subscribeOn(io.reactivex.Scheduler scheduler)` Subscribes to the upstream on the specified Scheduler.
`<T,E extends org.reactivestreams.Subscriber<T>> E` `subscribeWith(E subscriber)` Subscribe with the given subscriber and return the same subscriber, allowing chaining methods on it or fluently reusing the instance.
`Nono` `takeUntil(org.reactivestreams.Publisher<?> other)` Run this Nono and cancel it when the other Publisher signals an item or completes.
`io.reactivex.subscribers.TestSubscriber<java.lang.Void>` `test()` Create a TestSubscriber, subscribe it to this Nono and return the TestSubscriber itself.
`io.reactivex.subscribers.TestSubscriber<java.lang.Void>` `test(boolean cancelled)` Create a TestSubscriber, optionally cancel it, subscribe it to this Nono and return the TestSubscriber itself.
`Nono` `timeout(long timeout, java.util.concurrent.TimeUnit unit)` Signals a TimeoutException if this Nono doesn't complete within the specified timeout.
`Nono` `timeout(long timeout, java.util.concurrent.TimeUnit unit, Nono fallback)` Switches to the fallback Nono if this Nono doesn't complete within the specified timeout.
`Nono` `timeout(long timeout, java.util.concurrent.TimeUnit unit, io.reactivex.Scheduler scheduler)` Signals a TimeoutException if this Nono doesn't complete within the specified timeout.
`Nono` `timeout(long timeout, java.util.concurrent.TimeUnit unit, io.reactivex.Scheduler scheduler, Nono fallback)` Switches to the fallback Nono if this Nono doesn't complete within the specified timeout.
`Nono` `timeout(org.reactivestreams.Publisher<?> other)` Signal a TimeoutException if the other Publisher signals an item or completes before this Nono completes.
`Nono` `timeout(org.reactivestreams.Publisher<?> other, Nono fallback)` Switch to the fallback Nono if the other Publisher signals an item or completes before this Nono completes.
`static Nono` `timer(long delay, java.util.concurrent.TimeUnit unit)` Completes after the specified amount of time on the computation scheduler.
`static Nono` `timer(long delay, java.util.concurrent.TimeUnit unit, io.reactivex.Scheduler scheduler)` Completes after the specified amount of time on the specified scheduler.
`<R> R` `to(io.reactivex.functions.Function<? super Nono,R> converter)` Fluently convert this Nono via a function callback into some type.
`io.reactivex.Completable` `toCompletable()` Convert this Nono instance into a Completable.
`<T> io.reactivex.Flowable<T>` `toFlowable()` Convert this Nono instance into a Flowable that only terminates.
`java.util.concurrent.Future<java.lang.Void>` `toFuture()` Converts this Nono into a Future and signals its single value.
`<T> io.reactivex.Maybe<T>` `toMaybe()` Convert this Nono instance into a Maybe that only terminates.
`<T> io.reactivex.Observable<T>` `toObservable()` Convert this Nono instance into an Observable that only terminates.
`<T> Perhaps<T>` `toPerhaps()` Convert this Nono instance into a Perhaps that only terminates.
`Nono` `unsubscribeOn(io.reactivex.Scheduler scheduler)` If the downstream cancels the sequence, the cancellation towards the upstream will happen on the specified Scheduler.
`static <R> Nono` `using(java.util.concurrent.Callable<R> resourceSupplier, io.reactivex.functions.Function<? super R,? extends Nono> sourceSupplier, io.reactivex.functions.Consumer<? super R> disposer)` Generate a resource and a Nono based on that resource and then dispose that resource eagerly when the Nono terminates or the downstream cancels the sequence.
`static <R> Nono` `using(java.util.concurrent.Callable<R> resourceSupplier, io.reactivex.functions.Function<? super R,? extends Nono> sourceSupplier, io.reactivex.functions.Consumer<? super R> disposer, boolean eager)` Generate a resource and a Nono based on that resource and then dispose that resource optionally eagerly when the Nono terminates or the downstream cancels the sequence.

### Methods inherited from class java.lang.Object

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

### Constructor Detail

#### Nono

    public Nono()

### Method Detail

#### bufferSize

    public static int bufferSize()

Returns the default buffer or prefetch size.

Returns:
  the buffer or prefetch size

#### onAssembly

    protected static Nono onAssembly(Nono source)

Optionally apply a function to the raw source and return a potentially modified Nono instance.

Parameters:
  `source` - the source to apply to
Returns:
  the possibly wrapped Nono instance

#### getOnAssemblyHandler

    public static io.reactivex.functions.Function<Nono,Nono> getOnAssemblyHandler()

Returns the current onAssembly handler function or null if not set.

Returns:
  the current onAssembly handler function, maybe null

#### setOnAssemblyHandler

    public static void setOnAssemblyHandler(io.reactivex.functions.Function<Nono,Nono> handler)

Sets the onAssembly handler.

Parameters:
  `handler` - the new onAssembly handler, null clears the handler

#### create

    public static Nono create(io.reactivex.CompletableOnSubscribe onCreate)

Creates a Nono instance that when subscribed to, the given onCreate is called for each individual subscriber to generate a terminal event synchronously and synchronously in a cancellation-safe manner.

Parameters:
  `onCreate` - called for each individual subscriber with the abstraction of the incoming Subscriber
Returns:
  the new Nono instance

#### complete

    public static Nono complete()

Returns a Nono that completes normally.

Returns:
  the new Nono instance

#### never

    public static Nono never()

Returns a Nono that never terminates.

Returns:
  the new Nono instance

#### error

    public static Nono error(java.lang.Throwable ex)

Returns a Nono that signals the given Throwable to all subscribers.

Parameters:
  `ex` - the Throwable to signal, not null
Returns:
  the new Nono instance

#### error

    public static Nono error(java.util.concurrent.Callable<? extends java.lang.Throwable> errorSupplier)

Returns a Nono that signals a Throwable generated by the callable for each individual subscriber.

Parameters:
  `errorSupplier` - the Throwable error supplier, not null
Returns:
  the new Nono instance

#### defer

    public static Nono defer(java.util.concurrent.Callable<? extends Nono> supplier)

Defers the creation of the actual Nono instance until a subscriber subscribes.

Parameters:
  `supplier` - the supplier of Nono instances for each individual subscriber.
Returns:
  the new Nono instance

#### fromAction

    public static Nono fromAction(io.reactivex.functions.Action action)

Executes an action when a subscriber subscribes to the returned Nono.

Parameters:
  `action` - the action to execute, not null
Returns:
  the new nono instance

#### fromFuture

    public static Nono fromFuture(java.util.concurrent.Future<?> future)

Blockingly waits indefinitely for the given Future to terminate, relaying any error the Future signals.

Parameters:
  `future` - the future to await
Returns:
  the new Nono instance

#### fromFuture

    public static Nono fromFuture(java.util.concurrent.Future<?> future,
                                  long timeout,
                                  java.util.concurrent.TimeUnit unit)

Blockingly waits the given Future for the given timeout to terminate, relaying any error the Future signals.

Parameters:
  `future` - the future to await
  `timeout` - the timeout value to wait for termination
  `unit` - the unit for the timeout parameter
Returns:
  the new Nono instance

#### amb

    public static Nono amb(java.lang.Iterable<? extends Nono> sources)

Returns a Nono that terminates when the first Nono from the sources sequence terminates.

Parameters:
  `sources` - the Iterable sequence of sources
Returns:
  the new Nono instance

#### ambArray

    public static Nono ambArray(Nono... sources)

Returns a Nono that terminates when the first Nono from the array terminates.

Parameters:
  `sources` - the array of sources
Returns:
  the new Nono instance

#### concat

    public static Nono concat(java.lang.Iterable<? extends Nono> sources)

Runs the Nono sources one after the other.

Parameters:
  `sources` - the Iterable sequence of sources
Returns:
  the new Nono instances

#### concat

    public static Nono concat(org.reactivestreams.Publisher<? extends Nono> sources)

Runs the Nono sources emitted by the Publisher one after the other.

Parameters:
  `sources` - the Publisher of Nono sources
Returns:
  the new Nono instance

#### concat

    public static Nono concat(org.reactivestreams.Publisher<? extends Nono> sources,
                              int prefetch)

Runs the Nono sources emitted by the Publisher one after the other, prefetching the given number of Nono sources.

Parameters:
  `sources` - the Publisher of Nono sources
  `prefetch` - the number of Nono sources to prefetch from upstream
Returns:
  the new Nono instance

#### concatArray

    public static Nono concatArray(Nono... sources)

Runs the Nono sources one after the other.

Parameters:
  `sources` - the array of sources
Returns:
  the new Nono instances

#### concatDelayError

    public static Nono concatDelayError(java.lang.Iterable<? extends Nono> sources)

Runs the Nono sources one after the other, delaying errors from them till all sources have terminated.

Parameters:
  `sources` - the Iterable sequence of sources
Returns:
  the new Nono instances

#### concatDelayError

    public static Nono concatDelayError(org.reactivestreams.Publisher<? extends Nono> sources)

Runs the Nono sources emitted by the Publisher, one after the other, delaying errors from them till all sources have terminated.

Parameters:
  `sources` - the Publisher of source Nonos
Returns:
  the new Nono instances

#### concatDelayError

    public static Nono concatDelayError(org.reactivestreams.Publisher<? extends Nono> sources,
                                        int prefetch,
                                        boolean tillTheEnd)

Runs the Nono sources emitted by the Publisher, one after the other, delaying errors from them till all sources have terminated and prefetching Nonos from the upstream.

Parameters:
  `sources` - the Publisher of source Nonos
  `prefetch` - the number of Nonos to prefetch from the upstream
  `tillTheEnd` - if true the errors from the source are also delayed till the end; if false, error(s) are emitted when an inner Nono source terminates
Returns:
  the new Nono instances

#### concatArrayDelayError

    public static Nono concatArrayDelayError(Nono... sources)

Runs the Nono sources one after the other, delaying errors from them till all sources have terminated.

Parameters:
  `sources` - the array of sources
Returns:
  the new Nono instances

#### merge

    public static Nono merge(java.lang.Iterable<? extends Nono> sources)

Runs all Nono sources at once and completes once all of them complete.

Parameters:
  `sources` - the Iterable sequence of Nono sources
Returns:
  the new Nono instance

#### merge

    public static Nono merge(java.lang.Iterable<? extends Nono> sources,
                             int maxConcurrency)

Runs the maximum number of Nono sources at once and completes when all source Nono complete.

Parameters:
  `sources` - the Iterable sequence of Nono sources
  `maxConcurrency` - the maximum number of active Nono sources at a given time
Returns:
  the new Nono instance

#### merge

    public static Nono merge(org.reactivestreams.Publisher<? extends Nono> sources)

Runs all Nono sources emitted by the Publisher at once and completes once all of them complete.

Parameters:
  `sources` - the Publisher of Nono sources
Returns:
  the new Nono instance

#### merge

    public static Nono merge(org.reactivestreams.Publisher<? extends Nono> sources,
                             int maxConcurrency)

Runs the maximum number of Nono sources emitted by the Publisher at once and completes when all source Nono complete.

Parameters:
  `sources` - the Publisher of Nono sources
  `maxConcurrency` - the maximum number of active Nono sources at a given time
Returns:
  the new Nono instance

#### mergeArray

    public static Nono mergeArray(Nono... sources)

Runs all Nono sources at once and completes once all of them complete.

Parameters:
  `sources` - the array of Nono sources
Returns:
  the new Nono instance

#### mergeArray

    public static Nono mergeArray(int maxConcurrency,
                                  Nono... sources)

Runs the maximum number of Nono sources at once and completes when all source Nono complete.

Parameters:
  `sources` - the array of Nono sources
  `maxConcurrency` - the maximum number of active Nono sources at a given time
Returns:
  the new Nono instance

#### mergeDelayError

    public static Nono mergeDelayError(java.lang.Iterable<? extends Nono> sources)

Runs all Nono sources at once and terminates once all of them terminate, delaying errors in the process.

Parameters:
  `sources` - the Iterable sequence of Nono sources
Returns:
  the new Nono instance

#### mergeDelayError

    public static Nono mergeDelayError(java.lang.Iterable<? extends Nono> sources,
                                       int maxConcurrency)

Runs the maximum number of Nono sources at once and terminates when all source Nono terminate, delaying errors in the process.

Parameters:
  `sources` - the Iterable sequence of Nono sources
  `maxConcurrency` - the maximum number of active Nono sources at a given time
Returns:
  the new Nono instance

#### mergeDelayError

    public static Nono mergeDelayError(org.reactivestreams.Publisher<? extends Nono> sources)

Runs all Nono sources emitted by the Publisher at once and terminates once all of them terminate, delaying errors in the process.

Parameters:
  `sources` - the Publisher of Nono sources
Returns:
  the new Nono instance

#### mergeDelayError

    public static Nono mergeDelayError(org.reactivestreams.Publisher<? extends Nono> sources,
                                       int maxConcurrency)

Runs the maximum number of Nono sources emitted by the Publisher at once and terminates when all source Nono terminate, delaying errors in the process.

Parameters:
  `sources` - the Publisher of Nono sources
  `maxConcurrency` - the maximum number of active Nono sources at a given time
Returns:
  the new Nono instance

#### mergeArrayDelayError

    public static Nono mergeArrayDelayError(Nono... sources)

Runs all Nono sources at once and terminates once all of them terminate, delaying errors in the process.

Parameters:
  `sources` - the array of Nono sources
Returns:
  the new Nono instance

#### mergeArrayDelayError

    public static Nono mergeArrayDelayError(int maxConcurrency,
                                            Nono... sources)

Runs the maximum number of Nono sources at once and terminates when all source Nono terminate, delaying errors in the process.

Parameters:
  `sources` - the array of Nono sources
  `maxConcurrency` - the maximum number of active Nono sources at a given time
Returns:
  the new Nono instance

#### timer

    @SchedulerSupport(value="io.reactivex:computation")
    public static Nono timer(long delay,
                                                                                  java.util.concurrent.TimeUnit unit)

Completes after the specified amount of time on the computation scheduler.

Parameters:
  `delay` - the delay value
  `unit` - the delay time unit
Returns:
  the new Nono instance

#### timer

    @SchedulerSupport(value="custom")
    public static Nono timer(long delay,
                                                                java.util.concurrent.TimeUnit unit,
                                                                io.reactivex.Scheduler scheduler)

Completes after the specified amount of time on the specified scheduler.

Parameters:
  `delay` - the delay value
  `unit` - the delay time unit
  `scheduler` - the scheduler to delay the completion signal
Returns:
  the new Nono instance

#### using

    public static <R> Nono using(java.util.concurrent.Callable<R> resourceSupplier,
                                 io.reactivex.functions.Function<? super R,? extends Nono> sourceSupplier,
                                 io.reactivex.functions.Consumer<? super R> disposer)

Generate a resource and a Nono based on that resource and then dispose that resource eagerly when the Nono terminates or the downstream cancels the sequence.

Type Parameters:
  `R` - the resource type
Parameters:
  `resourceSupplier` - the callback to get a resource for each subscriber
  `sourceSupplier` - the function that returns a Nono for the generated resource
  `disposer` - the consumer of the resource once the upstream terminates or the downstream cancels
Returns:
  the new Nono instance

#### using

    public static <R> Nono using(java.util.concurrent.Callable<R> resourceSupplier,
                                 io.reactivex.functions.Function<? super R,? extends Nono> sourceSupplier,
                                 io.reactivex.functions.Consumer<? super R> disposer,
                                 boolean eager)

Generate a resource and a Nono based on that resource and then dispose that resource optionally eagerly when the Nono terminates or the downstream cancels the sequence.

Type Parameters:
  `R` - the resource type
Parameters:
  `resourceSupplier` - the callback to get a resource for each subscriber
  `sourceSupplier` - the function that returns a Nono for the generated resource
  `disposer` - the consumer of the resource once the upstream terminates or the downstream cancels
  `eager` - if true, the resource is disposed before the terminal event is emitted if false, the resource is disposed after the terminal event has been emitted
Returns:
  the new Nono instance

#### fromPublisher

    public static Nono fromPublisher(org.reactivestreams.Publisher<?> source)

Wrap a general Publisher, ignore all of its values and terminate if the source Publisher terminates.

Parameters:
  `source` - the Publisher to wrap into a Nono
Returns:
  the Nono instance

#### fromSingle

    public static Nono fromSingle(io.reactivex.SingleSource<?> source)

Wrap a Single, ignore its success value and terminate if the source Single terminates.

Parameters:
  `source` - the SingleSource to wrap into a Nono
Returns:
  the new Nono instance

#### fromMaybe

    public static Nono fromMaybe(io.reactivex.MaybeSource<?> source)

Wrap a Maybe, ignore its success value and terminate if the source Maybe terminates.

Parameters:
  `source` - the MaybeSource to wrap into a Nono
Returns:
  the new Nono instance

#### fromCompletable

    public static Nono fromCompletable(io.reactivex.CompletableSource source)

Wrap a Completable into a Nono and terminate when the source Completable terminates.

Parameters:
  `source` - the MaybeSource to wrap into a Nono
Returns:
  the new Nono instance

#### fromObservable

    public static Nono fromObservable(io.reactivex.ObservableSource<?> source)

Wrap a general Observable, ignore all of its values and terminate if the source Observable terminates.

Parameters:
  `source` - the ObservableSource to wrap into a Nono
Returns:
  the new Nono instance

#### andThen

    public final <T> io.reactivex.Flowable<T> andThen(org.reactivestreams.Publisher<? extends T> other)

When this Nono completes, it is continued by the events of the other Publisher.

Type Parameters:
  `T` - the value type of the other Publisher
Parameters:
  `other` - the other Publisher to continue with
Returns:
  the new Flowable instance

#### andThen

    public final Nono andThen(Nono other)

Run the other Nono when this Nono completes.

Parameters:
  `other` - the other Nono to continue with.
Returns:
  the new Nono instance

#### delay

    @SchedulerSupport(value="io.reactivex:computation")
    public final Nono delay(long delay,
                                                                                 java.util.concurrent.TimeUnit unit)

Delay the emission of the terminal events of this Nono by the given time amount.

Parameters:
  `delay` - the delay amount
  `unit` - the time unit
Returns:
  the new Nono instance

#### delay

    @SchedulerSupport(value="custom")
    public final Nono delay(long delay,
                                                               java.util.concurrent.TimeUnit unit,
                                                               io.reactivex.Scheduler scheduler)

Delay the emission of the terminal events of this Nono by the given time amount.

Parameters:
  `delay` - the delay amount
  `unit` - the time unit
  `scheduler` - the scheduler to wait on
Returns:
  the new Nono instance

#### delaySubscription

    public final Nono delaySubscription(org.reactivestreams.Publisher<?> other)

Delays the actual subscription to this Nono until the other Publisher signals an item or completes.

Parameters:
  `other` - the other Publisher to await a signal from
Returns:
  the new Nono instance

#### delaySubscription

    public final Nono delaySubscription(long delay,
                                        java.util.concurrent.TimeUnit unit)

Delays the actual subscription to this Nono until the given time passes.

Parameters:
  `delay` - the delay amount
  `unit` - the time unit
Returns:
  the new Nono instance

#### delaySubscription

    public final Nono delaySubscription(long delay,
                                        java.util.concurrent.TimeUnit unit,
                                        io.reactivex.Scheduler scheduler)

Delays the actual subscription to this Nono until the given time passes.

Parameters:
  `delay` - the delay amount
  `unit` - the time unit
  `scheduler` - the scheduler to wait on
Returns:
  the new Nono instance

#### timeout

    public final Nono timeout(long timeout,
                              java.util.concurrent.TimeUnit unit)

Signals a TimeoutException if this Nono doesn't complete within the specified timeout.

Parameters:
  `timeout` - the timeout amount
  `unit` - the time unit
Returns:
  the new Nono instance

#### timeout

    public final Nono timeout(long timeout,
                              java.util.concurrent.TimeUnit unit,
                              Nono fallback)

Switches to the fallback Nono if this Nono doesn't complete within the specified timeout.

Parameters:
  `timeout` - the timeout amount
  `unit` - the time unit
  `fallback` - the Nono to switch to if this Nono times out
Returns:
  the new Nono instance

#### timeout

    public final Nono timeout(long timeout,
                              java.util.concurrent.TimeUnit unit,
                              io.reactivex.Scheduler scheduler)

Signals a TimeoutException if this Nono doesn't complete within the specified timeout.

Parameters:
  `timeout` - the timeout amount
  `unit` - the time unit
  `scheduler` - the scheduler to wait on
Returns:
  the new Nono instance

#### timeout

    public final Nono timeout(long timeout,
                              java.util.concurrent.TimeUnit unit,
                              io.reactivex.Scheduler scheduler,
                              Nono fallback)

Switches to the fallback Nono if this Nono doesn't complete within the specified timeout.

Parameters:
  `timeout` - the timeout amount
  `unit` - the time unit
  `scheduler` - the scheduler to wait on
  `fallback` - the Nono to switch to if this Nono times out
Returns:
  the new Nono instance

#### timeout

    public final Nono timeout(org.reactivestreams.Publisher<?> other)

Signal a TimeoutException if the other Publisher signals an item or completes before this Nono completes.

Parameters:
  `other` - the other Publisher instance
Returns:
  the new Nono instance

#### timeout

    public final Nono timeout(org.reactivestreams.Publisher<?> other,
                              Nono fallback)

Switch to the fallback Nono if the other Publisher signals an item or completes before this Nono completes.

Parameters:
  `other` - the other Publisher instance
  `fallback` - the fallback Nono instance
Returns:
  the new Nono instance

#### onErrorComplete

    public final Nono onErrorComplete()

If this Nono signals an error, signal an onComplete instead.

Returns:
  the new Nono instance

#### onErrorResumeNext

    public final Nono onErrorResumeNext(io.reactivex.functions.Function<? super java.lang.Throwable,? extends Nono> errorHandler)

If this Nono signals an error, subscribe to the fallback Nono returned by the error handler function.

Parameters:
  `errorHandler` - the function called with the error and should return a Nono to resume with.
Returns:
  the new Nono instance

#### mapError

    public final Nono mapError(io.reactivex.functions.Function<? super java.lang.Throwable,? extends java.lang.Throwable> mapper)

Maps the upstream error into another Throwable via a function.

Parameters:
  `mapper` - the function that receives the upstream Throwable and should return another Throwable to be emitted to downstream
Returns:
  the new Nono instance

#### flatMap

    public final <T> io.reactivex.Flowable<T> flatMap(io.reactivex.functions.Function<? super java.lang.Throwable,? extends org.reactivestreams.Publisher<? extends T>> onErrorMapper,
                                                      java.util.concurrent.Callable<? extends org.reactivestreams.Publisher<? extends T>> onCompleteMapper)

Maps the upstream completion or error into a Publisher and emit its events as a Flowable.

Type Parameters:
  `T` - the value type
Parameters:
  `onErrorMapper` - the function that receives the upstream error and returns a Publisher to emit events of
  `onCompleteMapper` - the callable that returns a Publisher to emit events of
Returns:
  the new Flowable instance

#### compose

    public final Nono compose(io.reactivex.functions.Function<? super Nono,? extends Nono> composer)

Compose operators fluently via a function callback that returns a Nono for this Nono.

Parameters:
  `composer` - the function receiving this and returns a Nono
Returns:
  the Nono returned by the function

#### to

    public final <R> R to(io.reactivex.functions.Function<? super Nono,R> converter)

Fluently convert this Nono via a function callback into some type.

Type Parameters:
  `R` - the result value type
Parameters:
  `converter` - the function receiving this and returning a value
Returns:
  the value returned by the converter

#### lift

    public final Nono lift(io.reactivex.functions.Function<org.reactivestreams.Subscriber<? super java.lang.Void>,org.reactivestreams.Subscriber<? super java.lang.Void>> lifter)

Transform the downstream's Subscriber into a Subscriber for the upstream via a function.

Parameters:
  `lifter` - the function receiving the downstream Subscriber and returns a Subscriber for the upstream.
Returns:
  the new Nono instance

#### toFlowable

    public final <T> io.reactivex.Flowable<T> toFlowable()

Convert this Nono instance into a Flowable that only terminates.

Type Parameters:
  `T` - the value type
Returns:
  the new Flowable instance

#### toObservable

    public final <T> io.reactivex.Observable<T> toObservable()

Convert this Nono instance into an Observable that only terminates.

Type Parameters:
  `T` - the value type
Returns:
  the new Observable instance

#### toCompletable

    public final io.reactivex.Completable toCompletable()

Convert this Nono instance into a Completable.

Returns:
  the new Completable instance

#### toMaybe

    public final <T> io.reactivex.Maybe<T> toMaybe()

Convert this Nono instance into a Maybe that only terminates.

Type Parameters:
  `T` - the value type
Returns:
  the new Maybe instance

#### toPerhaps

    public final <T> Perhaps<T> toPerhaps()

Convert this Nono instance into a Perhaps that only terminates.

Type Parameters:
  `T` - the value type
Returns:
  the new Perhap instance

#### subscribeOn

    public final Nono subscribeOn(io.reactivex.Scheduler scheduler)

Subscribes to the upstream on the specified Scheduler.

Parameters:
  `scheduler` - the Scheduler to subscribe on
Returns:
  the new Nono instance

#### observeOn

    public final Nono observeOn(io.reactivex.Scheduler scheduler)

Observes the onError and onComplete events on the specified Scheduler.

Parameters:
  `scheduler` - the Scheduler to emit terminal events on
Returns:
  the new Nono instance

#### unsubscribeOn

    public final Nono unsubscribeOn(io.reactivex.Scheduler scheduler)

If the downstream cancels the sequence, the cancellation towards the upstream will happen on the specified Scheduler.

Parameters:
  `scheduler` - the Scheduler to cancel on
Returns:
  the new Nono instance

#### doOnComplete

    public final Nono doOnComplete(io.reactivex.functions.Action onComplete)

Executes a callback when the upstream completes normally.

Parameters:
  `onComplete` - the consumer called before the completion event is emitted to the downstream.
Returns:
  the new Nolo instance

#### doOnError

    public final Nono doOnError(io.reactivex.functions.Consumer<? super java.lang.Throwable> onError)

Executes a callback when the upstream signals an error.

Parameters:
  `onError` - the consumer called before the error is emitted to the downstream
Returns:
  the new Nolo instance

#### doOnSubscribe

    public final Nono doOnSubscribe(io.reactivex.functions.Consumer<? super org.reactivestreams.Subscription> onSubscribe)

Executes a callback when the upstream calls onSubscribe.

Parameters:
  `onSubscribe` - the consumer called with the upstream Subscription
Returns:
  the new Nolo instance

#### doOnRequest

    public final Nono doOnRequest(io.reactivex.functions.LongConsumer onRequest)

Executes the callback when the downstream requests from this Nolo.

Parameters:
  `onRequest` - the callback called with the request amount
Returns:
  the new Nolo instance

#### doAfterTerminate

    public final Nono doAfterTerminate(io.reactivex.functions.Action onAfterTerminate)

Executes the callback after this Nono terminates and the downstream is notified.

Parameters:
  `onAfterTerminate` - the callback to call after the downstream is notified
Returns:
  the new Nono instance

#### doFinally

    public final Nono doFinally(io.reactivex.functions.Action onFinally)

Executes the callback exactly if the upstream terminates or the downstream cancels the sequence.

Parameters:
  `onFinally` - the action to call
Returns:
  the new Nono instance

#### doOnCancel

    public final Nono doOnCancel(io.reactivex.functions.Action onCancel)

Executes the callback if the downstream cancels the sequence.

Parameters:
  `onCancel` - the action to call
Returns:
  the new Nono instance

#### repeat

    public final Nono repeat()

Repeatedly run this Nono indefinitely.

Returns:
  the new Nono instance

#### repeat

    public final Nono repeat(long times)

Repeatedly run this Nono at most the given number of times.

Parameters:
  `times` - the repeat count
Returns:
  the new Nono instance

#### repeat

    public final Nono repeat(io.reactivex.functions.BooleanSupplier stop)

Repeat until the given BooleanSupplier returns true.

Parameters:
  `stop` - the boolean supplier to return null to stop repeating
Returns:
  the new Nono instance

#### repeatWhen

    public final Nono repeatWhen(io.reactivex.functions.Function<? super io.reactivex.Flowable<java.lang.Object>,? extends org.reactivestreams.Publisher<?>> handler)

Repeat when the Publisher returned by the handler function signals a value or terminate accordingly.

Parameters:
  `handler` - the Function that receives a Flowable that emits an object when this Nono completes normally and should return a Publisher that if signals a normal item, it triggers a resubscription to this Nono.
Returns:
  the new Nono instance

#### retry

    public final Nono retry()

Repeatedly run this Nono indefinitely if it fails.

Returns:
  the new Nono instance

#### retry

    public final Nono retry(long times)

Repeatedly run this Nono at most the given number of times if it fails.

Parameters:
  `times` - the repeat count
Returns:
  the new Nono instance

#### retry

    public final Nono retry(io.reactivex.functions.Predicate<? super java.lang.Throwable> predicate)

Retry a failed Nono if the predicate return true

Parameters:
  `predicate` - the predicate receiving the failure Throwable and returns true to trigger a retry.
Returns:
  the new Nono instance

#### retryWhen

    public final Nono retryWhen(io.reactivex.functions.Function<? super io.reactivex.Flowable<java.lang.Throwable>,? extends org.reactivestreams.Publisher<?>> handler)

Retry this Nono when the Publisher returned by the handler function signals a normal item or terminate if the Publisher terminates.

Parameters:
  `handler` - the Function that receives a Flowable of the failure Throwable and returns a Publisher that if signals a normal item, it triggers a resubscription.
Returns:
  the new Nono instance

#### hide

    public final Nono hide()

Hides the identity of this Nono.

This also breaks optimizations such as operator fusion - useful when diagnosing issues.

Returns:
  the new Nono instance

#### takeUntil

    public final Nono takeUntil(org.reactivestreams.Publisher<?> other)

Run this Nono and cancel it when the other Publisher signals an item or completes.

Parameters:
  `other` - the other Publisher
Returns:
  the new Nono instance

#### cache

    public final Nono cache()

Caches the terminal event of the upstream Nono and relays/replays it to Subscribers.

Returns:
  the new Nono instance
Since:
  0.14.1

#### subscribe

    public final void subscribe(org.reactivestreams.Subscriber<? super java.lang.Void> s)

Specified by:
  `subscribe` in interface `org.reactivestreams.Publisher<java.lang.Void>`

#### subscribeActual

    protected abstract void subscribeActual(org.reactivestreams.Subscriber<? super java.lang.Void> s)

Implement this method to signal the terminal events to the given subscriber.

Parameters:
  `s` - the downstream subscriber, not null

#### subscribeWith

    @SchedulerSupport(value="none")
    public final <T,E extends org.reactivestreams.Subscriber<T>> E subscribeWith(E subscriber)

Subscribe with the given subscriber and return the same subscriber, allowing chaining methods on it or fluently reusing the instance.

Type Parameters:
  `T` - the target value type of the subscriber
  `E` - the subscriber's (sub)type
Parameters:
  `subscriber` - the subscriber to subscribe with, not null
Returns:
  the subscriber

#### test

    @SchedulerSupport(value="none")
    public final io.reactivex.subscribers.TestSubscriber<java.lang.Void> test()

Create a TestSubscriber, subscribe it to this Nono and return the TestSubscriber itself.

Returns:
  the TestSubscriber created

#### test

    @SchedulerSupport(value="none")
    public final io.reactivex.subscribers.TestSubscriber<java.lang.Void> test(boolean cancelled)

Create a TestSubscriber, optionally cancel it, subscribe it to this Nono and return the TestSubscriber itself.

Parameters:
  `cancelled` - shoud the TestSubscriber be cancelled before the subscription
Returns:
  the TestSubscriber created

#### blockingAwait

    @SchedulerSupport(value="none")
    public final java.lang.Throwable blockingAwait()

Blockingly await indefinitely the termination of this Nono and return the Throwable if this Nono terminated with an error, null otherwise.

Returns:
  the Throwable error of the Nono, null if completed normally

#### blockingAwait

    @SchedulerSupport(value="none")
    public final java.lang.Throwable blockingAwait(long timeout,
                                                                                    java.util.concurrent.TimeUnit unit)

Blockingly await for the given timeout the termination of this Nono and return the Throwable if this Nono terminated with an error, null otherwise.

Parameters:
  `timeout` - the timeout value
  `unit` - the time unit
Returns:
  the Throwable error of the Nono, null if completed normally

#### subscribe

    public final io.reactivex.disposables.Disposable subscribe()

Subscribe to this Nono and ignore the events it produces.

Returns:
  the Disposable to cancel the subscription
Since:
  0.13.0

#### subscribe

    @SchedulerSupport(value="none")
    public final io.reactivex.disposables.Disposable subscribe(io.reactivex.functions.Action onComplete)

Subscribe to this Nono and execute the given action if this Nono completes.

Parameters:
  `onComplete` - the callback Action to be called when this Nono completes
Returns:
  the Disposable to cancel the subscription

#### subscribe

    @SchedulerSupport(value="none")
    public final io.reactivex.disposables.Disposable subscribe(io.reactivex.functions.Action onComplete,
                                                                                                io.reactivex.functions.Consumer<? super java.lang.Throwable> onError)

Subscribe to this Nono and execute the given action if this Nono completes or call the consumer if this Nono terminates with an error.

Parameters:
  `onComplete` - the callback Action to be called when this Nono completes
  `onError` - the callback Consumer to be called with the terminal error.
Returns:
  the Disposable to cancel the subscription

#### blockingSubscribe

    public final void blockingSubscribe()

Block until this Nono terminates and ignore the actual events.

Since:
  0.13.0

#### blockingSubscribe

    public final void blockingSubscribe(io.reactivex.functions.Action onComplete)

Block until this Nono completes and call the Action on the thread where the blocking happens.

Parameters:
  `onComplete` - the Action to call when this Nono terminates

#### blockingSubscribe

    public final void blockingSubscribe(io.reactivex.functions.Action onComplete,
                                        io.reactivex.functions.Consumer<? super java.lang.Throwable> onError)

Block until this Nono terminates and call the Action or Consumer depending on the terminal event on the thread where the blocking happens.

Parameters:
  `onComplete` - the Action to call when this Nono completes
  `onError` - the Consumer to call when this Nono terminates with an error

#### toFuture

    public final java.util.concurrent.Future<java.lang.Void> toFuture()

Converts this Nono into a Future and signals its single value.

Returns:
  the new Future instance