com.aol.cyclops.reactor.hkt

Class MonoKind<T>

java.lang.Object

com.aol.cyclops.reactor.hkt.MonoKind<T>

Type Parameters:

T - Data type stored within the Mono

All Implemented Interfaces:

Convert<Higher<ReactorWitness.mono,T>>, Higher<ReactorWitness.mono,T>, org.reactivestreams.Publisher<T>

public final class MonoKind<T>
extends java.lang.Object
implements Higher<ReactorWitness.mono,T>, org.reactivestreams.Publisher<T>

Simulates Higher Kinded Types for Reactor Mono's MonoKind is a Mono and a Higher Kinded Type (mono,T)

Method Summary

Modifier and Type	Method and Description
Active<ReactorWitness.mono,T>	allTypeclasses()
<T2> reactor.core.publisher.Mono<reactor.util.function.Tuple2<T,T2>>	and(reactor.core.publisher.Mono<? extends T2> other)
<P> P	as(java.util.function.Function<? super reactor.core.publisher.Mono<T>,P> transformer)
reactor.core.publisher.Mono<T>	awaitOnSubscribe()
T	block()
T	block(java.time.Duration timeout)
T	blockMillis(long timeout)
reactor.core.publisher.Mono<T>	cache()
reactor.core.publisher.Mono<T>	cancelOn(reactor.core.scheduler.Scheduler scheduler)
<E> reactor.core.publisher.Mono<E>	cast(java.lang.Class<E> clazz)
<V> reactor.core.publisher.Mono<V>	compose(java.util.function.Function<? super reactor.core.publisher.Mono<T>,? extends org.reactivestreams.Publisher<V>> transformer)
reactor.core.publisher.Flux<T>	concatWith(org.reactivestreams.Publisher<? extends T> other)
reactor.core.publisher.Mono<T>	defaultIfEmpty(T defaultV)
reactor.core.publisher.Mono<T>	delaySubscription(java.time.Duration delay)
<U> reactor.core.publisher.Mono<T>	delaySubscription(org.reactivestreams.Publisher<U> subscriptionDelay)
reactor.core.publisher.Mono<T>	delaySubscriptionMillis(long delay)
reactor.core.publisher.Mono<T>	delaySubscriptionMillis(long delay, reactor.core.scheduler.TimedScheduler timer)
<X> reactor.core.publisher.Mono<X>	dematerialize()
reactor.core.publisher.Mono<T>	doAfterTerminate(java.util.function.BiConsumer<? super T,java.lang.Throwable> afterTerminate)
reactor.core.publisher.Mono<T>	doOnCancel(java.lang.Runnable onCancel)
<E extends java.lang.Throwable> reactor.core.publisher.Mono<T>	doOnError(java.lang.Class<E> exceptionType, java.util.function.Consumer<? super E> onError)
reactor.core.publisher.Mono<T>	doOnError(java.util.function.Consumer<? super java.lang.Throwable> onError)
reactor.core.publisher.Mono<T>	doOnError(java.util.function.Predicate<? super java.lang.Throwable> predicate, java.util.function.Consumer<? super java.lang.Throwable> onError)
reactor.core.publisher.Mono<T>	doOnNext(java.util.function.Consumer<? super T> onNext)
reactor.core.publisher.Mono<T>	doOnRequest(java.util.function.LongConsumer consumer)
reactor.core.publisher.Mono<T>	doOnSubscribe(java.util.function.Consumer<? super org.reactivestreams.Subscription> onSubscribe)
reactor.core.publisher.Mono<T>	doOnSuccess(java.util.function.Consumer<? super T> onSuccess)
reactor.core.publisher.Mono<T>	doOnTerminate(java.util.function.BiConsumer<? super T,java.lang.Throwable> onTerminate)
reactor.core.publisher.Mono<reactor.util.function.Tuple2<java.lang.Long,T>>	elapsed()
reactor.core.publisher.Mono<reactor.util.function.Tuple2<java.lang.Long,T>>	elapsed(reactor.core.scheduler.TimedScheduler scheduler)
static <T> MonoKind<T>	empty()
boolean	equals(java.lang.Object obj)
reactor.core.publisher.Mono<T>	filter(java.util.function.Predicate<? super T> tester)
<R> reactor.core.publisher.Flux<R>	flatMap(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper)
<R> reactor.core.publisher.Flux<R>	flatMap(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapperOnNext, java.util.function.Function<java.lang.Throwable,? extends org.reactivestreams.Publisher<? extends R>> mapperOnError, java.util.function.Supplier<? extends org.reactivestreams.Publisher<? extends R>> mapperOnComplete)
<R> reactor.core.publisher.Flux<R>	flatMapIterable(java.util.function.Function<? super T,? extends java.lang.Iterable<? extends R>> mapper)
reactor.core.publisher.Flux<T>	flux()
<R> MonoKind<R>	fold(java.util.function.Function<? super reactor.core.publisher.Mono<? super T>,? extends reactor.core.publisher.Mono<R>> op)
<R> reactor.core.publisher.Mono<R>	handle(java.util.function.BiConsumer<? super T,reactor.core.publisher.SynchronousSink<R>> handler)
reactor.core.publisher.Mono<java.lang.Boolean>	hasElement()
int	hashCode()
reactor.core.publisher.Mono<T>	hide()
reactor.core.publisher.Mono<T>	ignoreElement()
static <T> MonoKind<T>	just(T value) Construct a HKT encoded completed Mono
<W extends WitnessType<W>> MonoT<W,T>	liftM(W witness)
reactor.core.publisher.Mono<T>	log()
reactor.core.publisher.Mono<T>	log(java.lang.String category)
reactor.core.publisher.Mono<T>	log(java.lang.String category, java.util.logging.Level level, boolean showOperatorLine, reactor.core.publisher.SignalType... options)
reactor.core.publisher.Mono<T>	log(java.lang.String category, java.util.logging.Level level, reactor.core.publisher.SignalType... options)
<R> reactor.core.publisher.Mono<R>	map(java.util.function.Function<? super T,? extends R> mapper)
<E extends java.lang.Throwable> reactor.core.publisher.Mono<T>	mapError(java.lang.Class<E> type, java.util.function.Function<? super E,? extends java.lang.Throwable> mapper)
reactor.core.publisher.Mono<T>	mapError(java.util.function.Function<java.lang.Throwable,? extends java.lang.Throwable> mapper)
reactor.core.publisher.Mono<T>	mapError(java.util.function.Predicate<? super java.lang.Throwable> predicate, java.util.function.Function<? super java.lang.Throwable,? extends java.lang.Throwable> mapper)
<W2,R> Nested<ReactorWitness.mono,W2,R>	mapM(java.util.function.Function<? super T,? extends Higher<W2,R>> fn, InstanceDefinitions<W2> defs)
reactor.core.publisher.Mono<reactor.core.publisher.Signal<T>>	materialize()
reactor.core.publisher.Flux<T>	mergeWith(org.reactivestreams.Publisher<? extends T> other)
reactor.core.publisher.Mono<T>	narrow()
static <T> reactor.core.publisher.Mono<T>	narrow(Higher<ReactorWitness.mono,T> completableMono) Convert the HigherKindedType definition for a Mono into
static <T> MonoKind<T>	narrowK(Higher<ReactorWitness.mono,T> future) Convert the raw Higher Kinded Type for MonoKind types into the MonoKind type definition class
<U> reactor.core.publisher.Mono<U>	ofType(java.lang.Class<U> clazz)
reactor.core.publisher.Mono<T>	onTerminateDetach()
reactor.core.publisher.Mono<T>	or(reactor.core.publisher.Mono<? extends T> other)
<E extends java.lang.Throwable> reactor.core.publisher.Mono<T>	otherwise(java.lang.Class<E> type, java.util.function.Function<? super E,? extends reactor.core.publisher.Mono<? extends T>> fallback)
reactor.core.publisher.Mono<T>	otherwise(java.util.function.Function<? super java.lang.Throwable,? extends reactor.core.publisher.Mono<? extends T>> fallback)
reactor.core.publisher.Mono<T>	otherwise(java.util.function.Predicate<? super java.lang.Throwable> predicate, java.util.function.Function<? super java.lang.Throwable,? extends reactor.core.publisher.Mono<? extends T>> fallback)
reactor.core.publisher.Mono<T>	otherwiseIfEmpty(reactor.core.publisher.Mono<? extends T> alternate)
<E extends java.lang.Throwable> reactor.core.publisher.Mono<T>	otherwiseReturn(java.lang.Class<E> type, T fallbackValue)
<E extends java.lang.Throwable> reactor.core.publisher.Mono<T>	otherwiseReturn(java.util.function.Predicate<? super java.lang.Throwable> predicate, T fallbackValue)
reactor.core.publisher.Mono<T>	otherwiseReturn(T fallback)
<R> reactor.core.publisher.Mono<R>	publish(java.util.function.Function<? super reactor.core.publisher.Mono<T>,? extends reactor.core.publisher.Mono<? extends R>> transform)
reactor.core.publisher.Mono<T>	publishOn(reactor.core.scheduler.Scheduler scheduler)
reactor.core.publisher.Flux<T>	repeat()
reactor.core.publisher.Flux<T>	repeat(java.util.function.BooleanSupplier predicate)
reactor.core.publisher.Flux<T>	repeat(long numRepeat)
reactor.core.publisher.Flux<T>	repeat(long numRepeat, java.util.function.BooleanSupplier predicate)
reactor.core.publisher.Flux<T>	repeatWhen(java.util.function.Function<reactor.core.publisher.Flux<java.lang.Long>,? extends org.reactivestreams.Publisher<?>> whenFactory)
reactor.core.publisher.Mono<T>	repeatWhenEmpty(java.util.function.Function<reactor.core.publisher.Flux<java.lang.Long>,? extends org.reactivestreams.Publisher<?>> repeatFactory)
reactor.core.publisher.Mono<T>	repeatWhenEmpty(int maxRepeat, java.util.function.Function<reactor.core.publisher.Flux<java.lang.Long>,? extends org.reactivestreams.Publisher<?>> repeatFactory)
reactor.core.publisher.Mono<T>	retry()
reactor.core.publisher.Mono<T>	retry(long numRetries)
reactor.core.publisher.Mono<T>	retry(long numRetries, java.util.function.Predicate<java.lang.Throwable> retryMatcher)
reactor.core.publisher.Mono<T>	retry(java.util.function.Predicate<java.lang.Throwable> retryMatcher)
reactor.core.publisher.Mono<T>	retryWhen(java.util.function.Function<reactor.core.publisher.Flux<java.lang.Throwable>,? extends org.reactivestreams.Publisher<?>> whenFactory)
reactor.core.publisher.MonoProcessor<T>	subscribe()
reactor.core.Cancellation	subscribe(java.util.function.Consumer<? super T> consumer)
reactor.core.Cancellation	subscribe(java.util.function.Consumer<? super T> consumer, java.util.function.Consumer<? super java.lang.Throwable> errorConsumer)
reactor.core.Cancellation	subscribe(java.util.function.Consumer<? super T> consumer, java.util.function.Consumer<? super java.lang.Throwable> errorConsumer, java.lang.Runnable completeConsumer)
void	subscribe(org.reactivestreams.Subscriber<? super T> s)
reactor.core.publisher.Mono<T>	subscribeOn(reactor.core.scheduler.Scheduler scheduler)
<E extends org.reactivestreams.Subscriber<? super T>> E	subscribeWith(E subscriber)
reactor.core.publisher.Mono<java.lang.Void>	then()
<V> reactor.core.publisher.Mono<V>	then(reactor.core.publisher.Mono<V> other)
<V> reactor.core.publisher.Mono<V>	then(java.util.function.Supplier<? extends reactor.core.publisher.Mono<V>> sourceSupplier)
<V> reactor.core.publisher.Flux<V>	thenMany(org.reactivestreams.Publisher<V> other)
<V> reactor.core.publisher.Flux<V>	thenMany(java.util.function.Supplier<? extends reactor.core.publisher.Mono<V>> sourceSupplier)
reactor.core.publisher.Mono<T>	timeout(java.time.Duration timeout)
reactor.core.publisher.Mono<T>	timeout(java.time.Duration timeout, reactor.core.publisher.Mono<? extends T> fallback)
<U> reactor.core.publisher.Mono<T>	timeout(org.reactivestreams.Publisher<U> firstTimeout)
<U> reactor.core.publisher.Mono<T>	timeout(org.reactivestreams.Publisher<U> firstTimeout, reactor.core.publisher.Mono<? extends T> fallback)
reactor.core.publisher.Mono<T>	timeoutMillis(long timeout)
reactor.core.publisher.Mono<T>	timeoutMillis(long timeout, reactor.core.publisher.Mono<? extends T> fallback)
reactor.core.publisher.Mono<T>	timeoutMillis(long timeout, reactor.core.publisher.Mono<? extends T> fallback, reactor.core.scheduler.TimedScheduler timer)
reactor.core.publisher.Mono<T>	timeoutMillis(long timeout, reactor.core.scheduler.TimedScheduler timer)
reactor.core.publisher.Mono<reactor.util.function.Tuple2<java.lang.Long,T>>	timestamp()
reactor.core.publisher.Mono<reactor.util.function.Tuple2<java.lang.Long,T>>	timestamp(reactor.core.scheduler.TimedScheduler scheduler)
Future<T>	toFuture()
java.lang.String	toString()
<V> reactor.core.publisher.Mono<V>	transformMono(java.util.function.Function<? super reactor.core.publisher.Mono<T>,? extends org.reactivestreams.Publisher<V>> transformer)
static <T> MonoKind<T>	widen(reactor.core.publisher.Mono<T> completableMono) Convert a Mono to a simulated HigherKindedType that captures Mono nature and Mono element data type separately.
static <T> MonoKind<T>	widen(org.reactivestreams.Publisher<T> completableMono)
static <T> Higher<ReactorWitness.mono,T>	widenK(reactor.core.publisher.Mono<T> completableList)

Methods inherited from class java.lang.Object

clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface com.aol.cyclops2.hkt.Higher

applyHKT_, applyHKT, applyHKT

Methods inherited from interface com.aol.cyclops2.hkt.Convert

convert

Method Detail

fold

public <R> MonoKind<R> fold(java.util.function.Function<? super reactor.core.publisher.Mono<? super T>,? extends reactor.core.publisher.Mono<R>> op)

allTypeclasses

public Active<ReactorWitness.mono,T> allTypeclasses()

widenK

public static <T> Higher<ReactorWitness.mono,T> widenK(reactor.core.publisher.Mono<T> completableList)

mapM

public <W2,R> Nested<ReactorWitness.mono,W2,R> mapM(java.util.function.Function<? super T,? extends Higher<W2,R>> fn,
                                                    InstanceDefinitions<W2> defs)

liftM

public <W extends WitnessType<W>> MonoT<W,T> liftM(W witness)

just

public static <T> MonoKind<T> just(T value)

Construct a HKT encoded completed Mono

Parameters:

value - To encode inside a HKT encoded Mono

Returns:

Completed HKT encoded FMono

empty

public static <T> MonoKind<T> empty()

widen

public static <T> MonoKind<T> widen(reactor.core.publisher.Mono<T> completableMono)

Convert a Mono to a simulated HigherKindedType that captures Mono nature and Mono element data type separately. Recover via @see MonoKind#narrow If the supplied Mono implements MonoKind it is returned already, otherwise it is wrapped into a Mono implementation that does implement MonoKind

Parameters:

completableMono - Mono to widen to a MonoKind

Returns:

MonoKind encoding HKT info about Monos

widen

public static <T> MonoKind<T> widen(org.reactivestreams.Publisher<T> completableMono)

narrowK

public static <T> MonoKind<T> narrowK(Higher<ReactorWitness.mono,T> future)

Convert the raw Higher Kinded Type for MonoKind types into the MonoKind type definition class

Parameters:

future - HKT encoded list into a MonoKind

Returns:

MonoKind

narrow

public static <T> reactor.core.publisher.Mono<T> narrow(Higher<ReactorWitness.mono,T> completableMono)

Convert the HigherKindedType definition for a Mono into

Parameters:

completableMono - Type Constructor to convert back into narrowed type

Returns:

Mono from Higher Kinded Type

narrow

public reactor.core.publisher.Mono<T> narrow()

Returns:

wrapped Mono

toFuture

public Future<T> toFuture()

subscribe

public void subscribe(org.reactivestreams.Subscriber<? super T> s)

Specified by:

subscribe in interface org.reactivestreams.Publisher<T>

Parameters:

s -

See Also:

Publisher.subscribe(org.reactivestreams.Subscriber)

hashCode

public int hashCode()

Overrides:

hashCode in class java.lang.Object

Returns:

See Also:

Object.hashCode()

equals

public boolean equals(java.lang.Object obj)

Overrides:

equals in class java.lang.Object

Parameters:

obj -

Returns:

See Also:

Object.equals(java.lang.Object)

as

public final <P> P as(java.util.function.Function<? super reactor.core.publisher.Mono<T>,P> transformer)

Parameters:

transformer -

Returns:

See Also:

Mono.as(java.util.function.Function)

and

public final <T2> reactor.core.publisher.Mono<reactor.util.function.Tuple2<T,T2>> and(reactor.core.publisher.Mono<? extends T2> other)

Parameters:

other -

Returns:

See Also:

Mono.and(reactor.core.publisher.Mono)

awaitOnSubscribe

public final reactor.core.publisher.Mono<T> awaitOnSubscribe()

Returns:

See Also:

Mono.awaitOnSubscribe()

block

public T block()

Returns:

See Also:

Mono.block()

block

public final T block(java.time.Duration timeout)

Parameters:

timeout -

Returns:

See Also:

Mono.block(java.time.Duration)

blockMillis

public T blockMillis(long timeout)

Parameters:

timeout -

Returns:

See Also:

Mono.blockMillis(long)

cast

public final <E> reactor.core.publisher.Mono<E> cast(java.lang.Class<E> clazz)

Parameters:

clazz -

Returns:

See Also:

Mono.cast(java.lang.Class)

cache

public final reactor.core.publisher.Mono<T> cache()

Returns:

See Also:

Mono.cache()

cancelOn

public final reactor.core.publisher.Mono<T> cancelOn(reactor.core.scheduler.Scheduler scheduler)

Parameters:

scheduler -

Returns:

See Also:

Mono.cancelOn(reactor.core.scheduler.Scheduler)

compose

public final <V> reactor.core.publisher.Mono<V> compose(java.util.function.Function<? super reactor.core.publisher.Mono<T>,? extends org.reactivestreams.Publisher<V>> transformer)

Parameters:

transformer -

Returns:

See Also:

Mono.compose(java.util.function.Function)

concatWith

public final reactor.core.publisher.Flux<T> concatWith(org.reactivestreams.Publisher<? extends T> other)

Parameters:

other -

Returns:

See Also:

Mono.concatWith(org.reactivestreams.Publisher)

defaultIfEmpty

public final reactor.core.publisher.Mono<T> defaultIfEmpty(T defaultV)

Parameters:

defaultV -

Returns:

See Also:

Mono.defaultIfEmpty(java.lang.Object)

delaySubscription

public final reactor.core.publisher.Mono<T> delaySubscription(java.time.Duration delay)

Parameters:

delay -

Returns:

See Also:

Mono.delaySubscription(java.time.Duration)

delaySubscription

public final <U> reactor.core.publisher.Mono<T> delaySubscription(org.reactivestreams.Publisher<U> subscriptionDelay)

Parameters:

subscriptionDelay -

Returns:

See Also:

Mono.delaySubscription(org.reactivestreams.Publisher)

delaySubscriptionMillis

public final reactor.core.publisher.Mono<T> delaySubscriptionMillis(long delay)

Parameters:

delay -

Returns:

See Also:

Mono.delaySubscriptionMillis(long)

delaySubscriptionMillis

public final reactor.core.publisher.Mono<T> delaySubscriptionMillis(long delay,
                                                                    reactor.core.scheduler.TimedScheduler timer)

Parameters:

delay -

timer -

Returns:

See Also:

Mono.delaySubscriptionMillis(long, reactor.core.scheduler.TimedScheduler)

dematerialize

public final <X> reactor.core.publisher.Mono<X> dematerialize()

Returns:

See Also:

Mono.dematerialize()

doAfterTerminate

public final reactor.core.publisher.Mono<T> doAfterTerminate(java.util.function.BiConsumer<? super T,java.lang.Throwable> afterTerminate)

Parameters:

afterTerminate -

Returns:

See Also:

Mono.doAfterTerminate(java.util.function.BiConsumer)

doOnCancel

public final reactor.core.publisher.Mono<T> doOnCancel(java.lang.Runnable onCancel)

Parameters:

onCancel -

Returns:

See Also:

Mono.doOnCancel(java.lang.Runnable)

doOnNext

public final reactor.core.publisher.Mono<T> doOnNext(java.util.function.Consumer<? super T> onNext)

Parameters:

onNext -

Returns:

See Also:

Mono.doOnNext(java.util.function.Consumer)

doOnSuccess

public final reactor.core.publisher.Mono<T> doOnSuccess(java.util.function.Consumer<? super T> onSuccess)

Parameters:

onSuccess -

Returns:

See Also:

Mono.doOnSuccess(java.util.function.Consumer)

doOnError

public final reactor.core.publisher.Mono<T> doOnError(java.util.function.Consumer<? super java.lang.Throwable> onError)

Parameters:

onError -

Returns:

See Also:

Mono.doOnError(java.util.function.Consumer)

doOnError

public final <E extends java.lang.Throwable> reactor.core.publisher.Mono<T> doOnError(java.lang.Class<E> exceptionType,
                                                                                      java.util.function.Consumer<? super E> onError)

Parameters:

exceptionType -

onError -

Returns:

See Also:

Mono.doOnError(java.lang.Class, java.util.function.Consumer)

doOnError

public final reactor.core.publisher.Mono<T> doOnError(java.util.function.Predicate<? super java.lang.Throwable> predicate,
                                                      java.util.function.Consumer<? super java.lang.Throwable> onError)

Parameters:

predicate -

onError -

Returns:

See Also:

Mono.doOnError(java.util.function.Predicate, java.util.function.Consumer)

doOnRequest

public final reactor.core.publisher.Mono<T> doOnRequest(java.util.function.LongConsumer consumer)

Parameters:

consumer -

Returns:

See Also:

Mono.doOnRequest(java.util.function.LongConsumer)

doOnSubscribe

public final reactor.core.publisher.Mono<T> doOnSubscribe(java.util.function.Consumer<? super org.reactivestreams.Subscription> onSubscribe)

Parameters:

onSubscribe -

Returns:

See Also:

Mono.doOnSubscribe(java.util.function.Consumer)

doOnTerminate

public final reactor.core.publisher.Mono<T> doOnTerminate(java.util.function.BiConsumer<? super T,java.lang.Throwable> onTerminate)

Parameters:

onTerminate -

Returns:

See Also:

Mono.doOnTerminate(java.util.function.BiConsumer)

elapsed

public final reactor.core.publisher.Mono<reactor.util.function.Tuple2<java.lang.Long,T>> elapsed()

Returns:

See Also:

Mono.elapsed()

elapsed

public final reactor.core.publisher.Mono<reactor.util.function.Tuple2<java.lang.Long,T>> elapsed(reactor.core.scheduler.TimedScheduler scheduler)

Parameters:

scheduler -

Returns:

See Also:

Mono.elapsed(reactor.core.scheduler.TimedScheduler)

filter

public final reactor.core.publisher.Mono<T> filter(java.util.function.Predicate<? super T> tester)

Parameters:

tester -

Returns:

See Also:

Mono.filter(java.util.function.Predicate)

flatMap

public final <R> reactor.core.publisher.Flux<R> flatMap(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper)

Parameters:

mapper -

Returns:

See Also:

Mono.flatMap(java.util.function.Function)

flatMap

public final <R> reactor.core.publisher.Flux<R> flatMap(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapperOnNext,
                                                        java.util.function.Function<java.lang.Throwable,? extends org.reactivestreams.Publisher<? extends R>> mapperOnError,
                                                        java.util.function.Supplier<? extends org.reactivestreams.Publisher<? extends R>> mapperOnComplete)

Parameters:

mapperOnNext -

mapperOnError -

mapperOnComplete -

Returns:

See Also:

Mono.flatMap(java.util.function.Function, java.util.function.Function, java.util.function.Supplier)

flatMapIterable

public final <R> reactor.core.publisher.Flux<R> flatMapIterable(java.util.function.Function<? super T,? extends java.lang.Iterable<? extends R>> mapper)

Parameters:

mapper -

Returns:

See Also:

Mono.flatMapIterable(java.util.function.Function)

flux

public final reactor.core.publisher.Flux<T> flux()

Returns:

See Also:

Mono.flux()

hasElement

public final reactor.core.publisher.Mono<java.lang.Boolean> hasElement()

Returns:

See Also:

Mono.hasElement()

handle

public final <R> reactor.core.publisher.Mono<R> handle(java.util.function.BiConsumer<? super T,reactor.core.publisher.SynchronousSink<R>> handler)

Parameters:

handler -

Returns:

See Also:

Mono.handle(java.util.function.BiConsumer)

hide

public final reactor.core.publisher.Mono<T> hide()

Returns:

See Also:

Mono.hide()

ignoreElement

public final reactor.core.publisher.Mono<T> ignoreElement()

Returns:

See Also:

Mono.ignoreElement()

log

public final reactor.core.publisher.Mono<T> log()

Returns:

See Also:

Mono.log()

log

public final reactor.core.publisher.Mono<T> log(java.lang.String category)

Parameters:

category -

Returns:

See Also:

Mono.log(java.lang.String)

log

public final reactor.core.publisher.Mono<T> log(java.lang.String category,
                                                java.util.logging.Level level,
                                                reactor.core.publisher.SignalType... options)

Parameters:

category -

level -

options -

Returns:

See Also:

Mono.log(java.lang.String, java.util.logging.Level, reactor.core.publisher.SignalType[])

log

public final reactor.core.publisher.Mono<T> log(java.lang.String category,
                                                java.util.logging.Level level,
                                                boolean showOperatorLine,
                                                reactor.core.publisher.SignalType... options)

Parameters:

category -

level -

showOperatorLine -

options -

Returns:

See Also:

Mono.log(java.lang.String, java.util.logging.Level, boolean, reactor.core.publisher.SignalType[])

map

public final <R> reactor.core.publisher.Mono<R> map(java.util.function.Function<? super T,? extends R> mapper)

Parameters:

mapper -

Returns:

See Also:

Mono.map(java.util.function.Function)

mapError

public final reactor.core.publisher.Mono<T> mapError(java.util.function.Function<java.lang.Throwable,? extends java.lang.Throwable> mapper)

Parameters:

mapper -

Returns:

See Also:

Mono.mapError(java.util.function.Function)

mapError

public final <E extends java.lang.Throwable> reactor.core.publisher.Mono<T> mapError(java.lang.Class<E> type,
                                                                                     java.util.function.Function<? super E,? extends java.lang.Throwable> mapper)

Parameters:

type -

mapper -

Returns:

See Also:

Mono.mapError(java.lang.Class, java.util.function.Function)

mapError

public final reactor.core.publisher.Mono<T> mapError(java.util.function.Predicate<? super java.lang.Throwable> predicate,
                                                     java.util.function.Function<? super java.lang.Throwable,? extends java.lang.Throwable> mapper)

Parameters:

predicate -

mapper -

Returns:

See Also:

Mono.mapError(java.util.function.Predicate, java.util.function.Function)

materialize

public final reactor.core.publisher.Mono<reactor.core.publisher.Signal<T>> materialize()

Returns:

See Also:

Mono.materialize()

mergeWith

public final reactor.core.publisher.Flux<T> mergeWith(org.reactivestreams.Publisher<? extends T> other)

Parameters:

other -

Returns:

See Also:

Mono.mergeWith(org.reactivestreams.Publisher)

or

public final reactor.core.publisher.Mono<T> or(reactor.core.publisher.Mono<? extends T> other)

Parameters:

other -

Returns:

See Also:

Mono.or(reactor.core.publisher.Mono)

ofType

public final <U> reactor.core.publisher.Mono<U> ofType(java.lang.Class<U> clazz)

Parameters:

clazz -

Returns:

See Also:

Mono.ofType(java.lang.Class)

otherwise

public final reactor.core.publisher.Mono<T> otherwise(java.util.function.Function<? super java.lang.Throwable,? extends reactor.core.publisher.Mono<? extends T>> fallback)

Parameters:

fallback -

Returns:

See Also:

Mono.otherwise(java.util.function.Function)

otherwise

public final <E extends java.lang.Throwable> reactor.core.publisher.Mono<T> otherwise(java.lang.Class<E> type,
                                                                                      java.util.function.Function<? super E,? extends reactor.core.publisher.Mono<? extends T>> fallback)

Parameters:

type -

fallback -

Returns:

See Also:

Mono.otherwise(java.lang.Class, java.util.function.Function)

otherwise

public final reactor.core.publisher.Mono<T> otherwise(java.util.function.Predicate<? super java.lang.Throwable> predicate,
                                                      java.util.function.Function<? super java.lang.Throwable,? extends reactor.core.publisher.Mono<? extends T>> fallback)

Parameters:

predicate -

fallback -

Returns:

See Also:

Mono.otherwise(java.util.function.Predicate, java.util.function.Function)

otherwiseIfEmpty

public final reactor.core.publisher.Mono<T> otherwiseIfEmpty(reactor.core.publisher.Mono<? extends T> alternate)

Parameters:

alternate -

Returns:

See Also:

Mono.otherwiseIfEmpty(reactor.core.publisher.Mono)

otherwiseReturn

public final reactor.core.publisher.Mono<T> otherwiseReturn(T fallback)

Parameters:

fallback -

Returns:

See Also:

Mono.otherwiseReturn(java.lang.Object)

otherwiseReturn

public final <E extends java.lang.Throwable> reactor.core.publisher.Mono<T> otherwiseReturn(java.lang.Class<E> type,
                                                                                            T fallbackValue)

Parameters:

type -

fallbackValue -

Returns:

See Also:

Mono.otherwiseReturn(java.lang.Class, java.lang.Object)

otherwiseReturn

public final <E extends java.lang.Throwable> reactor.core.publisher.Mono<T> otherwiseReturn(java.util.function.Predicate<? super java.lang.Throwable> predicate,
                                                                                            T fallbackValue)

Parameters:

predicate -

fallbackValue -

Returns:

See Also:

Mono.otherwiseReturn(java.util.function.Predicate, java.lang.Object)

onTerminateDetach

public final reactor.core.publisher.Mono<T> onTerminateDetach()

Returns:

See Also:

Mono.onTerminateDetach()

publish

public final <R> reactor.core.publisher.Mono<R> publish(java.util.function.Function<? super reactor.core.publisher.Mono<T>,? extends reactor.core.publisher.Mono<? extends R>> transform)

Parameters:

transform -

Returns:

See Also:

Mono.publish(java.util.function.Function)

publishOn

public final reactor.core.publisher.Mono<T> publishOn(reactor.core.scheduler.Scheduler scheduler)

Parameters:

scheduler -

Returns:

See Also:

Mono.publishOn(reactor.core.scheduler.Scheduler)

repeat

public final reactor.core.publisher.Flux<T> repeat()

Returns:

See Also:

Mono.repeat()

repeat

public final reactor.core.publisher.Flux<T> repeat(java.util.function.BooleanSupplier predicate)

Parameters:

predicate -

Returns:

See Also:

Mono.repeat(java.util.function.BooleanSupplier)

repeat

public final reactor.core.publisher.Flux<T> repeat(long numRepeat)

Parameters:

numRepeat -

Returns:

See Also:

Mono.repeat(long)

repeat

public final reactor.core.publisher.Flux<T> repeat(long numRepeat,
                                                   java.util.function.BooleanSupplier predicate)

Parameters:

numRepeat -

predicate -

Returns:

See Also:

Mono.repeat(long, java.util.function.BooleanSupplier)

repeatWhen

public final reactor.core.publisher.Flux<T> repeatWhen(java.util.function.Function<reactor.core.publisher.Flux<java.lang.Long>,? extends org.reactivestreams.Publisher<?>> whenFactory)

Parameters:

whenFactory -

Returns:

See Also:

Mono.repeatWhen(java.util.function.Function)

repeatWhenEmpty

public final reactor.core.publisher.Mono<T> repeatWhenEmpty(java.util.function.Function<reactor.core.publisher.Flux<java.lang.Long>,? extends org.reactivestreams.Publisher<?>> repeatFactory)

Parameters:

repeatFactory -

Returns:

See Also:

Mono.repeatWhenEmpty(java.util.function.Function)

repeatWhenEmpty

public final reactor.core.publisher.Mono<T> repeatWhenEmpty(int maxRepeat,
                                                            java.util.function.Function<reactor.core.publisher.Flux<java.lang.Long>,? extends org.reactivestreams.Publisher<?>> repeatFactory)

Parameters:

maxRepeat -

repeatFactory -

Returns:

See Also:

Mono.repeatWhenEmpty(int, java.util.function.Function)

retry

public final reactor.core.publisher.Mono<T> retry()

Returns:

See Also:

Mono.retry()

retry

public final reactor.core.publisher.Mono<T> retry(long numRetries)

Parameters:

numRetries -

Returns:

See Also:

Mono.retry(long)

retry

public final reactor.core.publisher.Mono<T> retry(java.util.function.Predicate<java.lang.Throwable> retryMatcher)

Parameters:

retryMatcher -

Returns:

See Also:

Mono.retry(java.util.function.Predicate)

retry

public final reactor.core.publisher.Mono<T> retry(long numRetries,
                                                  java.util.function.Predicate<java.lang.Throwable> retryMatcher)

Parameters:

numRetries -

retryMatcher -

Returns:

See Also:

Mono.retry(long, java.util.function.Predicate)

retryWhen

public final reactor.core.publisher.Mono<T> retryWhen(java.util.function.Function<reactor.core.publisher.Flux<java.lang.Throwable>,? extends org.reactivestreams.Publisher<?>> whenFactory)

Parameters:

whenFactory -

Returns:

See Also:

Mono.retryWhen(java.util.function.Function)

subscribe

public final reactor.core.publisher.MonoProcessor<T> subscribe()

Returns:

See Also:

Mono.subscribe()

subscribe

public final reactor.core.Cancellation subscribe(java.util.function.Consumer<? super T> consumer)

Parameters:

consumer -

Returns:

See Also:

Mono.subscribe(java.util.function.Consumer)

subscribe

public final reactor.core.Cancellation subscribe(java.util.function.Consumer<? super T> consumer,
                                                 java.util.function.Consumer<? super java.lang.Throwable> errorConsumer)

Parameters:

consumer -

errorConsumer -

Returns:

See Also:

Mono.subscribe(java.util.function.Consumer, java.util.function.Consumer)

subscribe

public final reactor.core.Cancellation subscribe(java.util.function.Consumer<? super T> consumer,
                                                 java.util.function.Consumer<? super java.lang.Throwable> errorConsumer,
                                                 java.lang.Runnable completeConsumer)

Parameters:

consumer -

errorConsumer -

completeConsumer -

Returns:

See Also:

Mono.subscribe(java.util.function.Consumer, java.util.function.Consumer, java.lang.Runnable)

subscribeOn

public final reactor.core.publisher.Mono<T> subscribeOn(reactor.core.scheduler.Scheduler scheduler)

Parameters:

scheduler -

Returns:

See Also:

Mono.subscribeOn(reactor.core.scheduler.Scheduler)

subscribeWith

public final <E extends org.reactivestreams.Subscriber<? super T>> E subscribeWith(E subscriber)

Parameters:

subscriber -

Returns:

See Also:

Mono.subscribeWith(org.reactivestreams.Subscriber)

then

public final reactor.core.publisher.Mono<java.lang.Void> then()

Returns:

See Also:

Mono.then()

then

public final <V> reactor.core.publisher.Mono<V> then(reactor.core.publisher.Mono<V> other)

Parameters:

other -

Returns:

See Also:

Mono.then(reactor.core.publisher.Mono)

then

public final <V> reactor.core.publisher.Mono<V> then(java.util.function.Supplier<? extends reactor.core.publisher.Mono<V>> sourceSupplier)

Parameters:

sourceSupplier -

Returns:

See Also:

Mono.then(java.util.function.Supplier)

thenMany

public final <V> reactor.core.publisher.Flux<V> thenMany(org.reactivestreams.Publisher<V> other)

Parameters:

other -

Returns:

See Also:

Mono.thenMany(org.reactivestreams.Publisher)

thenMany

public final <V> reactor.core.publisher.Flux<V> thenMany(java.util.function.Supplier<? extends reactor.core.publisher.Mono<V>> sourceSupplier)

Parameters:

sourceSupplier -

Returns:

See Also:

Mono.thenMany(java.util.function.Supplier)

timeout

public final reactor.core.publisher.Mono<T> timeout(java.time.Duration timeout)

Parameters:

timeout -

Returns:

See Also:

Mono.timeout(java.time.Duration)

timeout

public final reactor.core.publisher.Mono<T> timeout(java.time.Duration timeout,
                                                    reactor.core.publisher.Mono<? extends T> fallback)

Parameters:

timeout -

fallback -

Returns:

See Also:

Mono.timeout(java.time.Duration, reactor.core.publisher.Mono)

timeout

public final <U> reactor.core.publisher.Mono<T> timeout(org.reactivestreams.Publisher<U> firstTimeout)

Parameters:

firstTimeout -

Returns:

See Also:

Mono.timeout(org.reactivestreams.Publisher)

timeout

public final <U> reactor.core.publisher.Mono<T> timeout(org.reactivestreams.Publisher<U> firstTimeout,
                                                        reactor.core.publisher.Mono<? extends T> fallback)

Parameters:

firstTimeout -

fallback -

Returns:

See Also:

Mono.timeout(org.reactivestreams.Publisher, reactor.core.publisher.Mono)

timeoutMillis

public final reactor.core.publisher.Mono<T> timeoutMillis(long timeout)

Parameters:

timeout -

Returns:

See Also:

Mono.timeoutMillis(long)

timeoutMillis

public final reactor.core.publisher.Mono<T> timeoutMillis(long timeout,
                                                          reactor.core.scheduler.TimedScheduler timer)

Parameters:

timeout -

timer -

Returns:

See Also:

Mono.timeoutMillis(long, reactor.core.scheduler.TimedScheduler)

timeoutMillis

public final reactor.core.publisher.Mono<T> timeoutMillis(long timeout,
                                                          reactor.core.publisher.Mono<? extends T> fallback)

Parameters:

timeout -

fallback -

Returns:

See Also:

Mono.timeoutMillis(long, reactor.core.publisher.Mono)

timeoutMillis

public final reactor.core.publisher.Mono<T> timeoutMillis(long timeout,
                                                          reactor.core.publisher.Mono<? extends T> fallback,
                                                          reactor.core.scheduler.TimedScheduler timer)

Parameters:

timeout -

fallback -

timer -

Returns:

See Also:

Mono.timeoutMillis(long, reactor.core.publisher.Mono, reactor.core.scheduler.TimedScheduler)

timestamp

public final reactor.core.publisher.Mono<reactor.util.function.Tuple2<java.lang.Long,T>> timestamp()

Returns:

See Also:

Mono.timestamp()

timestamp

public final reactor.core.publisher.Mono<reactor.util.function.Tuple2<java.lang.Long,T>> timestamp(reactor.core.scheduler.TimedScheduler scheduler)

Parameters:

scheduler -

Returns:

See Also:

Mono.timestamp(reactor.core.scheduler.TimedScheduler)

transformMono

public final <V> reactor.core.publisher.Mono<V> transformMono(java.util.function.Function<? super reactor.core.publisher.Mono<T>,? extends org.reactivestreams.Publisher<V>> transformer)

Parameters:

transformer -

Returns:

See Also:

Mono.transform(java.util.function.Function)

toString

public java.lang.String toString()

Overrides:

toString in class java.lang.Object

Returns:

See Also:

Mono.toString()