Nono (rxjava2-extensions 0.20.8 API)

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

All Implemented Interfaces:

Publisher<Void>

Direct Known Subclasses:

NonoProcessor
```
public abstract class Nono
extends Object
implements Publisher<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()

Constructors
Constructor and Description
`Nono()`

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`static Nono`	`amb(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> Flowable<T>`	`andThen(Publisher<? extends T> other)` When this Nono completes, it is continued by the events of the other Publisher.
`Throwable`	`blockingAwait()` Blockingly await indefinitely the termination of this Nono and return the Throwable if this Nono terminated with an error, null otherwise.
`Throwable`	`blockingAwait(long timeout, 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(Action onComplete)` Block until this Nono completes and call the Action on the thread where the blocking happens.
`void`	`blockingSubscribe(Action onComplete, Consumer<? super 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(Function<? super Nono,? extends Nono> composer)` Compose operators fluently via a function callback that returns a Nono for this Nono.
`static Nono`	`concat(Iterable<? extends Nono> sources)` Runs the Nono sources one after the other.
`static Nono`	`concat(Publisher<? extends Nono> sources)` Runs the Nono sources emitted by the Publisher one after the other.
`static Nono`	`concat(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(Iterable<? extends Nono> sources)` Runs the Nono sources one after the other, delaying errors from them till all sources have terminated.
`static Nono`	`concatDelayError(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(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(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(Callable<? extends Nono> supplier)` Defers the creation of the actual Nono instance until a subscriber subscribes.
`Nono`	`delay(long delay, TimeUnit unit)` Delay the emission of the terminal events of this Nono by the given time amount.
`Nono`	`delay(long delay, TimeUnit unit, Scheduler scheduler)` Delay the emission of the terminal events of this Nono by the given time amount.
`Nono`	`delaySubscription(long delay, TimeUnit unit)` Delays the actual subscription to this Nono until the given time passes.
`Nono`	`delaySubscription(long delay, TimeUnit unit, Scheduler scheduler)` Delays the actual subscription to this Nono until the given time passes.
`Nono`	`delaySubscription(Publisher<?> other)` Delays the actual subscription to this Nono until the other Publisher signals an item or completes.
`Nono`	`doAfterTerminate(Action onAfterTerminate)` Executes the callback after this Nono terminates and the downstream is notified.
`Nono`	`doFinally(Action onFinally)` Executes the callback exactly if the upstream terminates or the downstream cancels the sequence.
`Nono`	`doOnCancel(Action onCancel)` Executes the callback if the downstream cancels the sequence.
`Nono`	`doOnComplete(Action onComplete)` Executes a callback when the upstream completes normally.
`Nono`	`doOnError(Consumer<? super Throwable> onError)` Executes a callback when the upstream signals an error.
`Nono`	`doOnRequest(LongConsumer onRequest)` Executes the callback when the downstream requests from this Nolo.
`Nono`	`doOnSubscribe(Consumer<? super Subscription> onSubscribe)` Executes a callback when the upstream calls onSubscribe.
`static Nono`	`error(Callable<? extends Throwable> errorSupplier)` Returns a Nono that signals a Throwable generated by the callable for each individual subscriber.
`static Nono`	`error(Throwable ex)` Returns a Nono that signals the given Throwable to all subscribers.
`<T> Flowable<T>`	`flatMap(Function<? super Throwable,? extends Publisher<? extends T>> onErrorMapper, Callable<? extends Publisher<? extends T>> onCompleteMapper)` Maps the upstream completion or error into a Publisher and emit its events as a Flowable.
`static Nono`	`fromAction(Action action)` Executes an action when a subscriber subscribes to the returned Nono.
`static Nono`	`fromCompletable(CompletableSource source)` Wrap a Completable into a Nono and terminate when the source Completable terminates.
`static Nono`	`fromFuture(Future<?> future)` Blockingly waits indefinitely for the given Future to terminate, relaying any error the Future signals.
`static Nono`	`fromFuture(Future<?> future, long timeout, TimeUnit unit)` Blockingly waits the given Future for the given timeout to terminate, relaying any error the Future signals.
`static Nono`	`fromMaybe(MaybeSource<?> source)` Wrap a Maybe, ignore its success value and terminate if the source Maybe terminates.
`static Nono`	`fromObservable(ObservableSource<?> source)` Wrap a general Observable, ignore all of its values and terminate if the source Observable terminates.
`static Nono`	`fromPublisher(Publisher<?> source)` Wrap a general Publisher, ignore all of its values and terminate if the source Publisher terminates.
`static Nono`	`fromSingle(SingleSource<?> source)` Wrap a Single, ignore its success value and terminate if the source Single terminates.
`static 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(Function<Subscriber<? super Void>,Subscriber<? super Void>> lifter)` Transform the downstream's Subscriber into a Subscriber for the upstream via a function.
`Nono`	`mapError(Function<? super Throwable,? extends Throwable> mapper)` Maps the upstream error into another Throwable via a function.
`static Nono`	`merge(Iterable<? extends Nono> sources)` Runs all Nono sources at once and completes once all of them complete.
`static Nono`	`merge(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(Publisher<? extends Nono> sources)` Runs all Nono sources emitted by the Publisher at once and completes once all of them complete.
`static Nono`	`merge(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(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(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(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(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(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(Function<? super 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(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(Function<? super Flowable<Object>,? extends 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(Predicate<? super Throwable> predicate)` Retry a failed Nono if the predicate return true.
`Nono`	`retryWhen(Function<? super Flowable<Throwable>,? extends 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(Function<Nono,Nono> handler)` Sets the onAssembly handler.
`Disposable`	`subscribe()` Subscribe to this Nono and ignore the events it produces.
`Disposable`	`subscribe(Action onComplete)` Subscribe to this Nono and execute the given action if this Nono completes.
`Disposable`	`subscribe(Action onComplete, Consumer<? super 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(Subscriber<? super Void> s)`
`protected abstract void`	`subscribeActual(Subscriber<? super Void> s)` Implement this method to signal the terminal events to the given subscriber.
`Nono`	`subscribeOn(Scheduler scheduler)` Subscribes to the upstream on the specified Scheduler.
`<T,E extends 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(Publisher<?> other)` Run this Nono and cancel it when the other Publisher signals an item or completes.
`TestSubscriber<Void>`	`test()` Create a TestSubscriber, subscribe it to this Nono and return the TestSubscriber itself.
`TestSubscriber<Void>`	`test(boolean cancelled)` Create a TestSubscriber, optionally cancel it, subscribe it to this Nono and return the TestSubscriber itself.
`Nono`	`timeout(long timeout, TimeUnit unit)` Signals a TimeoutException if this Nono doesn't complete within the specified timeout.
`Nono`	`timeout(long timeout, TimeUnit unit, Nono fallback)` Switches to the fallback Nono if this Nono doesn't complete within the specified timeout.
`Nono`	`timeout(long timeout, TimeUnit unit, Scheduler scheduler)` Signals a TimeoutException if this Nono doesn't complete within the specified timeout.
`Nono`	`timeout(long timeout, TimeUnit unit, Scheduler scheduler, Nono fallback)` Switches to the fallback Nono if this Nono doesn't complete within the specified timeout.
`Nono`	`timeout(Publisher<?> other)` Signal a TimeoutException if the other Publisher signals an item or completes before this Nono completes.
`Nono`	`timeout(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, TimeUnit unit)` Completes after the specified amount of time on the computation scheduler.
`static Nono`	`timer(long delay, TimeUnit unit, Scheduler scheduler)` Completes after the specified amount of time on the specified scheduler.
`<R> R`	`to(Function<? super Nono,R> converter)` Fluently convert this Nono via a function callback into some type.
`Completable`	`toCompletable()` Convert this Nono instance into a Completable.
`<T> Flowable<T>`	`toFlowable()` Convert this Nono instance into a Flowable that only terminates.
`Future<Void>`	`toFuture()` Converts this Nono into a Future and signals its single value.
`<T> Maybe<T>`	`toMaybe()` Convert this Nono instance into a Maybe that only terminates.
`<T> 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(Scheduler scheduler)` If the downstream cancels the sequence, the cancellation towards the upstream will happen on the specified Scheduler.
`static <R> Nono`	`using(Callable<R> resourceSupplier, Function<? super R,? extends Nono> sourceSupplier, 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(Callable<R> resourceSupplier, Function<? super R,? extends Nono> sourceSupplier, 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 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(Function<Nono,Nono> handler)
```
    Sets the onAssembly handler.
    
    Parameters:
    
    handler - the new onAssembly handler, null clears the handler
  - create
```
public static Nono create(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(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(Callable<? extends 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(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(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(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(Future<?> future,
                              long timeout,
                              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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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,
                                                                              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,
                                                            TimeUnit unit,
                                                            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(Callable<R> resourceSupplier,
                             Function<? super R,? extends Nono> sourceSupplier,
                             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(Callable<R> resourceSupplier,
                             Function<? super R,? extends Nono> sourceSupplier,
                             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(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(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(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(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(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> Flowable<T> andThen(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,
                                                                             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,
                                                           TimeUnit unit,
                                                           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(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,
                                    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,
                                    TimeUnit unit,
                                    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,
                          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,
                          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,
                          TimeUnit unit,
                          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,
                          TimeUnit unit,
                          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(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(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(Function<? super 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(Function<? super Throwable,? extends 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> Flowable<T> flatMap(Function<? super Throwable,? extends Publisher<? extends T>> onErrorMapper,
                                     Callable<? extends 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(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(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(Function<Subscriber<? super Void>,Subscriber<? super 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> 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> 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 Completable toCompletable()
```
    Convert this Nono instance into a Completable.
    
    Returns:
    
    the new Completable instance
  - toMaybe
```
public final <T> 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(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(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(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(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(Consumer<? super 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(Consumer<? super 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(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(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(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(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(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(Function<? super Flowable<Object>,? extends 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(Predicate<? super 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(Function<? super Flowable<Throwable>,? extends 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(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(Subscriber<? super Void> s)
```
    Specified by:
    
    subscribe in interface Publisher<Void>
  - subscribeActual
```
protected abstract void subscribeActual(Subscriber<? super 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 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 TestSubscriber<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 TestSubscriber<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 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 Throwable blockingAwait(long timeout,
                                                                      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 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 Disposable subscribe(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 Disposable subscribe(Action onComplete,
                                                                   Consumer<? super 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(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(Action onComplete,
                                    Consumer<? super 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 Future<Void> toFuture()
```
    Converts this Nono into a Future and signals its single value.
    
    Returns:
    
    the new Future instance

Class Nono

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

Nono

Method Detail

bufferSize

onAssembly

getOnAssemblyHandler

setOnAssemblyHandler

create

complete

never

error

error

defer

fromAction

fromFuture

fromFuture

amb

ambArray

concat

concat

concat

concatArray

concatDelayError

concatDelayError

concatDelayError

concatArrayDelayError

merge

merge

merge

merge

mergeArray

mergeArray

mergeDelayError

mergeDelayError

mergeDelayError

mergeDelayError

mergeArrayDelayError

mergeArrayDelayError

timer

timer

using

using

fromPublisher

fromSingle

fromMaybe

fromCompletable

fromObservable

andThen

andThen

delay

delay

delaySubscription

delaySubscription

delaySubscription

timeout

timeout

timeout

timeout

timeout

timeout

onErrorComplete

onErrorResumeNext

mapError

flatMap

compose

to

lift

toFlowable

toObservable

toCompletable

toMaybe

toPerhaps

subscribeOn

observeOn

unsubscribeOn

doOnComplete