hu.akarnokd.rxjava2.basetypes

Class Nono

java.lang.Object

hu.akarnokd.rxjava2.basetypes.Nono

All Implemented Interfaces:

org.reactivestreams.Publisher<java.lang.Void>

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

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

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

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

Since:

0.11.0

Constructor Summary

Constructors

Constructor and Description
Nono()

Method Summary

Modifier and Type	Method and Description
static Nono	amb(java.lang.Iterable<? extends Nono> sources)
static Nono	ambArray(Nono... sources)
Nono	andThen(Nono other)
<T> io.reactivex.Flowable<T>	andThen(org.reactivestreams.Publisher<? extends T> other)
java.lang.Throwable	blockingAwait()
java.lang.Throwable	blockingAwait(long timeout, java.util.concurrent.TimeUnit unit)
void	blockingSubscribe(io.reactivex.functions.Action onComplete)
void	blockingSubscribe(io.reactivex.functions.Action onComplete, io.reactivex.functions.Consumer<? super java.lang.Throwable> onError)
static int	bufferSize() Returns the default buffer or prefetch size.
static Nono	complete()
Nono	compose(io.reactivex.functions.Function<? super Nono,? extends Nono> composer)
static Nono	concat(java.lang.Iterable<? extends Nono> sources)
static Nono	concat(org.reactivestreams.Publisher<? extends Nono> sources)
static Nono	concat(org.reactivestreams.Publisher<? extends Nono> sources, int prefetch)
static Nono	concatArray(Nono... sources)
static Nono	concatArrayDelayError(Nono... sources)
static Nono	concatDelayError(java.lang.Iterable<? extends Nono> sources)
static Nono	concatDelayError(org.reactivestreams.Publisher<? extends Nono> sources)
static Nono	concatDelayError(org.reactivestreams.Publisher<? extends Nono> sources, int prefetch, boolean tillTheEnd)
static Nono	defer(java.util.concurrent.Callable<? extends Nono> supplier)
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	doAfterComplete(io.reactivex.functions.Action action)
Nono	doAfterTerminate(io.reactivex.functions.Action action)
Nono	doFinally(io.reactivex.functions.Action action)
Nono	doOnCancel(io.reactivex.functions.Action action)
Nono	doOnComplete(io.reactivex.functions.Action action)
Nono	doOnError(io.reactivex.functions.Consumer<? super java.lang.Throwable> error)
static Nono	error(java.util.concurrent.Callable<? extends java.lang.Throwable> errorSupplier)
static Nono	error(java.lang.Throwable ex)
<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)
static Nono	fromCompletable(io.reactivex.CompletableSource source)
static Nono	fromFuture(java.util.concurrent.Future<?> future)
static Nono	fromFuture(java.util.concurrent.Future<?> future, long timeout, java.util.concurrent.TimeUnit unit)
static Nono	fromMaybe(io.reactivex.MaybeSource<?> source)
static Nono	fromObservable(io.reactivex.ObservableSource<?> source)
static Nono	fromPublisher(org.reactivestreams.Publisher<?> source)
static Nono	fromSingle(io.reactivex.SingleSource<?> source)
static io.reactivex.functions.Function<Nono,Nono>	getOnAssemblyHandler()
Nono	lift(io.reactivex.functions.Function<org.reactivestreams.Subscriber<? super java.lang.Void>,org.reactivestreams.Subscriber<? super java.lang.Void>> lifter)
Nono	mapError(io.reactivex.functions.Function<? super java.lang.Throwable,? extends java.lang.Throwable> mapper)
static Nono	merge(java.lang.Iterable<? extends Nono> sources)
static Nono	merge(java.lang.Iterable<? extends Nono> sources, int maxConcurrency)
static Nono	merge(org.reactivestreams.Publisher<? extends Nono> sources)
static Nono	merge(org.reactivestreams.Publisher<? extends Nono> sources, int maxConcurrency)
static Nono	mergeArray(int maxConcurrency, Nono... sources)
static Nono	mergeArray(Nono... sources)
static Nono	mergeArrayDelayError(int maxConcurrency, Nono... sources)
static Nono	mergeArrayDelayError(Nono... sources)
static Nono	mergeDelayError(java.lang.Iterable<? extends Nono> sources)
static Nono	mergeDelayError(java.lang.Iterable<? extends Nono> sources, int maxConcurrency)
static Nono	mergeDelayError(org.reactivestreams.Publisher<? extends Nono> sources)
static Nono	mergeDelayError(org.reactivestreams.Publisher<? extends Nono> sources, int maxConcurrency)
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()
Nono	repeat(io.reactivex.functions.BooleanSupplier stop)
Nono	repeat(long times)
Nono	repeatWhen(io.reactivex.functions.Function<io.reactivex.Flowable<java.lang.Object>,org.reactivestreams.Publisher<?>> handler)
Nono	retry()
Nono	retry(long times)
Nono	retry(io.reactivex.functions.Predicate<? super java.lang.Throwable> predicate)
Nono	retryWhen(io.reactivex.functions.Function<io.reactivex.Flowable<java.lang.Throwable>,org.reactivestreams.Publisher<?>> handler)
static void	setOnAssemblyHandler(io.reactivex.functions.Function<Nono,Nono> handler)
io.reactivex.disposables.Disposable	subscribe(io.reactivex.functions.Action onComplete)
io.reactivex.disposables.Disposable	subscribe(io.reactivex.functions.Action onComplete, io.reactivex.functions.Consumer<? super java.lang.Throwable> onError)
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.
io.reactivex.subscribers.TestSubscriber<java.lang.Void>	test()
io.reactivex.subscribers.TestSubscriber<java.lang.Void>	test(boolean cancelled)
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)
static Nono	timer(long delay, java.util.concurrent.TimeUnit unit)
static Nono	timer(long delay, java.util.concurrent.TimeUnit unit, io.reactivex.Scheduler scheduler)
<R> R	to(io.reactivex.functions.Function<? super Nono,R> converter)
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)
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)

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

setOnAssemblyHandler

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

complete

public static Nono complete()

error

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

error

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

defer

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

fromAction

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

fromFuture

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

fromFuture

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

amb

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

ambArray

public static Nono ambArray(Nono... sources)

concat

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

concat

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

concat

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

concatArray

public static Nono concatArray(Nono... sources)

concatDelayError

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

concatDelayError

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

concatDelayError

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

concatArrayDelayError

public static Nono concatArrayDelayError(Nono... sources)

merge

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

merge

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

merge

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

merge

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

mergeArray

public static Nono mergeArray(Nono... sources)

mergeArray

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

mergeDelayError

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

mergeDelayError

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

mergeDelayError

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

mergeDelayError

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

mergeArrayDelayError

public static Nono mergeArrayDelayError(Nono... sources)

mergeArrayDelayError

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

timer

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

timer

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

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)

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)

fromPublisher

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

fromSingle

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

fromMaybe

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

fromCompletable

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

fromObservable

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

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)

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)

to

public final <R> R to(io.reactivex.functions.Function<? super Nono,R> 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)

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

doOnError

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

doAfterComplete

public final Nono doAfterComplete(io.reactivex.functions.Action action)

doAfterTerminate

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

doFinally

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

doOnCancel

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

repeat

public final Nono repeat()

repeat

public final Nono repeat(long times)

repeat

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

repeatWhen

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

retry

public final Nono retry()

retry

public final Nono retry(long times)

retry

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

retryWhen

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

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

test

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

blockingAwait

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

blockingAwait

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

subscribe

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

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)

blockingSubscribe

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

blockingSubscribe

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