com.aol.cyclops.reactor.hkt

Class MonoType<T>

java.lang.Object

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

Type Parameters:

T - Data type stored within the Mono

All Implemented Interfaces:

com.aol.cyclops.hkt.alias.Convert<com.aol.cyclops.hkt.alias.Higher<MonoType.µ,T>>, com.aol.cyclops.hkt.alias.Higher<MonoType.µ,T>, org.derive4j.hkt.__<MonoType.µ,T>, org.reactivestreams.Publisher<T>

public final class MonoType<T>
extends java.lang.Object
implements com.aol.cyclops.hkt.alias.Higher<MonoType.µ,T>, org.reactivestreams.Publisher<T>

Simulates Higher Kinded Types for Reactor Mono's MonoType is a Mono and a Higher Kinded Type (MonoType.µ,T)

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	MonoType.µ Witness type

Constructor Summary

Constructors

Constructor and Description
MonoType()

Method Summary

Modifier and Type	Method and Description
<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> MonoType<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> 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> MonoType<T>	just(T value) Construct a HKT encoded completed Mono
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)
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(com.aol.cyclops.hkt.alias.Higher<MonoType.µ,T> completableMono) Convert the HigherKindedType definition for a Mono into
static <T> MonoType<T>	narrowK(com.aol.cyclops.hkt.alias.Higher<MonoType.µ,T> future) Convert the raw Higher Kinded Type for MonoType types into the MonoType 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)
FutureW<T>	toFuture()
java.lang.String	toString()
<V> reactor.core.publisher.Mono<V>	transform(java.util.function.Function<? super reactor.core.publisher.Mono<T>,? extends org.reactivestreams.Publisher<V>> transformer)
static <T> MonoType<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> MonoType<T>	widen(org.reactivestreams.Publisher<T> completableMono)

Methods inherited from class java.lang.Object

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

Methods inherited from interface com.aol.cyclops.hkt.alias.Higher

apply_, apply, then

Methods inherited from interface com.aol.cyclops.hkt.alias.Convert

convert

Constructor Detail

MonoType

public MonoType()

Method Detail

just

public static <T> MonoType<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> MonoType<T> empty()

widen

public static <T> MonoType<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 MonoType#narrow If the supplied Mono implements MonoType it is returned already, otherwise it is wrapped into a Mono implementation that does implement MonoType

Parameters:

Mono - Mono to widen to a MonoType

Returns:

MonoType encoding HKT info about Monos

widen

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

narrowK

public static <T> MonoType<T> narrowK(com.aol.cyclops.hkt.alias.Higher<MonoType.µ,T> future)

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

Parameters:

future - HKT encoded list into a MonoType

Returns:

MonoType

narrow

public static <T> reactor.core.publisher.Mono<T> narrow(com.aol.cyclops.hkt.alias.Higher<MonoType.µ,T> completableMono)

Convert the HigherKindedType definition for a Mono into

Parameters:

Mono - 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 FutureW<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)

transform

public final <V> reactor.core.publisher.Mono<V> transform(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()