Nono (rxjava2-extensions 0.12.0 API)

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()

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(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)`
`<T> io.reactivex.Flowable<T>`	`andThen(org.reactivestreams.Publisher<? extends T> other)`
`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(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.
`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`	`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)`
`Nono`	`delay(long delay, java.util.concurrent.TimeUnit unit, io.reactivex.Scheduler scheduler)`
`Nono`	`delaySubscription(long delay, java.util.concurrent.TimeUnit unit)`
`Nono`	`delaySubscription(long delay, java.util.concurrent.TimeUnit unit, io.reactivex.Scheduler scheduler)`
`Nono`	`delaySubscription(org.reactivestreams.Publisher<?> other)`
`Nono`	`doAfterTerminate(io.reactivex.functions.Action onTerminate)` 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)`
`Nono`	`doOnError(io.reactivex.functions.Consumer<? super java.lang.Throwable> onError)`
`Nono`	`doOnRequest(io.reactivex.functions.LongConsumer onRequest)`
`Nono`	`doOnSubscribe(io.reactivex.functions.Consumer<? super org.reactivestreams.Subscription> 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)`
`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)`
`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)`
`protected static Nono`	`onAssembly(Nono source)` Optionally apply a function to the raw source and return a potentially modified Nono instance.
`Nono`	`onErrorComplete()`
`Nono`	`onErrorResumeNext(io.reactivex.functions.Function<? super java.lang.Throwable,? extends Nono> errorHandler)`
`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(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)`
`<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 delay, java.util.concurrent.TimeUnit unit)`
`Nono`	`timeout(long delay, java.util.concurrent.TimeUnit unit, Nono fallback)`
`Nono`	`timeout(long delay, java.util.concurrent.TimeUnit unit, io.reactivex.Scheduler scheduler)`
`Nono`	`timeout(long delay, java.util.concurrent.TimeUnit unit, io.reactivex.Scheduler scheduler, Nono fallback)`
`Nono`	`timeout(org.reactivestreams.Publisher<?> other)`
`Nono`	`timeout(org.reactivestreams.Publisher<?> other, Nono fallback)`
`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()`
`<T> io.reactivex.Flowable<T>`	`toFlowable()`
`<T> io.reactivex.Maybe<T>`	`toMaybe()`
`<T> io.reactivex.Observable<T>`	`toObservable()`
`Nono`	`unsubscribeOn(io.reactivex.Scheduler 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
  - 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)
```
  - andThen
```
public final Nono andThen(Nono other)
```
  - delay
```
@SchedulerSupport(value="io.reactivex:computation")
public final Nono delay(long delay,
                                                                             java.util.concurrent.TimeUnit unit)
```
  - delay
```
@SchedulerSupport(value="custom")
public final Nono delay(long delay,
                                                           java.util.concurrent.TimeUnit unit,
                                                           io.reactivex.Scheduler scheduler)
```
  - delaySubscription
```
public final Nono delaySubscription(org.reactivestreams.Publisher<?> other)
```
  - delaySubscription
```
public final Nono delaySubscription(long delay,
                                    java.util.concurrent.TimeUnit unit)
```
  - delaySubscription
```
public final Nono delaySubscription(long delay,
                                    java.util.concurrent.TimeUnit unit,
                                    io.reactivex.Scheduler scheduler)
```
  - timeout
```
public final Nono timeout(long delay,
                          java.util.concurrent.TimeUnit unit)
```
  - timeout
```
public final Nono timeout(long delay,
                          java.util.concurrent.TimeUnit unit,
                          Nono fallback)
```
  - timeout
```
public final Nono timeout(long delay,
                          java.util.concurrent.TimeUnit unit,
                          io.reactivex.Scheduler scheduler)
```
  - timeout
```
public final Nono timeout(long delay,
                          java.util.concurrent.TimeUnit unit,
                          io.reactivex.Scheduler scheduler,
                          Nono fallback)
```
  - timeout
```
public final Nono timeout(org.reactivestreams.Publisher<?> other)
```
  - timeout
```
public final Nono timeout(org.reactivestreams.Publisher<?> other,
                          Nono fallback)
```
  - onErrorComplete
```
public final Nono onErrorComplete()
```
  - onErrorResumeNext
```
public final Nono onErrorResumeNext(io.reactivex.functions.Function<? super java.lang.Throwable,? extends Nono> errorHandler)
```
  - mapError
```
public final Nono mapError(io.reactivex.functions.Function<? super java.lang.Throwable,? extends java.lang.Throwable> mapper)
```
  - 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)
```
  - 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()
```
  - toObservable
```
public final <T> io.reactivex.Observable<T> toObservable()
```
  - toCompletable
```
public final io.reactivex.Completable toCompletable()
```
  - toMaybe
```
public final <T> io.reactivex.Maybe<T> toMaybe()
```
  - subscribeOn
```
public final Nono subscribeOn(io.reactivex.Scheduler scheduler)
```
  - observeOn
```
public final Nono observeOn(io.reactivex.Scheduler scheduler)
```
  - unsubscribeOn
```
public final Nono unsubscribeOn(io.reactivex.Scheduler scheduler)
```
  - doOnComplete
```
public final Nono doOnComplete(io.reactivex.functions.Action onComplete)
```
  - doOnError
```
public final Nono doOnError(io.reactivex.functions.Consumer<? super java.lang.Throwable> onError)
```
  - doOnSubscribe
```
public final Nono doOnSubscribe(io.reactivex.functions.Consumer<? super org.reactivestreams.Subscription> onSubscribe)
```
  - doOnRequest
```
public final Nono doOnRequest(io.reactivex.functions.LongConsumer onRequest)
```
  - doAfterTerminate
```
public final Nono doAfterTerminate(io.reactivex.functions.Action onTerminate)
```
    Executes the callback after this Nono terminates and the downstream is notified.
    
    Parameters:
    
    onTerminate - 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
  - 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
```
@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(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

Class Nono

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

Nono

Method Detail

bufferSize

onAssembly

getOnAssemblyHandler

setOnAssemblyHandler

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

subscribeOn

observeOn

unsubscribeOn

doOnComplete

doOnError

doOnSubscribe