Uses of Class
reactor.util.annotation.Nullable

Packages that use Nullable

Package	Description
reactor.core	Core components of the framework supporting extensions to the Reactive Stream programming model.
reactor.core.publisher	Provide main Reactive APIs in Flux and Mono, as well as various helper classes, interfaces used in the composition API, variants of Flux and operator-building utilities.
reactor.core.scheduler	Scheduler contract and static registry and factory methods in Schedulers.
reactor.test	Main test components supporting the testing and assertion of publishers.
reactor.test.publisher	Components supporting the creation of test-oriented Publishers.
reactor.test.subscriber	Components supporting the creation of test-oriented Subscribers.
reactor.util.context	Miscellaneous utility classes, such as loggers, tuples or queue suppliers and implementations.
reactor.util.function	Tuples provide a type-safe way to specify multiple parameters.
reactor.util.retry

Uses of Nullable in reactor.core

Methods in reactor.core with annotations of type Nullable

Modifier and Type	Method and Description
T	Scannable.Attr.defaultValue() Meaningful and always applicable default value for the attribute, returned instead of null when a specific value hasn't been defined for a component.
default T	Fuseable.QueueSubscription.peek()
default <T> T	Scannable.scan(Scannable.Attr<T> key) Introspect a component's specific state attribute, returning an associated value specific to that component, or the default value associated with the key, or null if the attribute doesn't make sense for that particular component and has no sensible default.
Object	Scannable.scanUnsafe(Scannable.Attr key) This method is used internally by components to define their key-value mappings in a single place.
static <T> Throwable	Exceptions.terminate(AtomicReferenceFieldUpdater<T,Throwable> field, T instance) Atomic utility to safely mark a volatile throwable reference with a terminal marker.

Method parameters in reactor.core with annotations of type Nullable

Modifier and Type	Method and Description
default boolean	Fuseable.QueueSubscription.add(T t)
default boolean	Fuseable.QueueSubscription.contains(Object o)
static Scannable	Scannable.from(Object o) Attempt to cast the Object to a Scannable.
static boolean	Exceptions.isBubbling(Throwable t) Check if the given exception is a bubbled wrapped exception.
static boolean	Exceptions.isCancel(Throwable t) Check if the given error is a cancel signal.
static boolean	Exceptions.isErrorCallbackNotImplemented(Throwable t) Check if the given error is a callback not implemented exception, in which case its cause will be the propagated error that couldn't be processed.
static boolean	Exceptions.isFatal(Throwable t) Check if a Throwable is considered by Reactor as Fatal and would be thrown by Exceptions.throwIfFatal(Throwable).
static boolean	Exceptions.isJvmFatal(Throwable t) Check if a Throwable is considered by Reactor as Jvm Fatal and would be thrown by both Exceptions.throwIfFatal(Throwable) and Exceptions.throwIfJvmFatal(Throwable).
static boolean	Exceptions.isMultiple(Throwable t) Check a Throwable to see if it is a composite, as created by Exceptions.multiple(Throwable...).
static boolean	Exceptions.isOverflow(Throwable t) Check if the given exception represents an overflow.
static boolean	Exceptions.isRetryExhausted(Throwable t) Check a Throwable to see if it indicates too many retry attempts have failed.
static boolean	Exceptions.isTraceback(Throwable t) Check a Throwable to see if it is a traceback, as created by the checkpoint operator or debug utilities.
default boolean	Fuseable.QueueSubscription.offer(T t)
default boolean	Fuseable.QueueSubscription.remove(Object o)
boolean	Disposable.Swap.replace(Disposable next) Atomically set the next Disposable on this container but don't dispose the previous one (if any).
static RuntimeException	Exceptions.retryExhausted(String message, Throwable cause) Return a new RuntimeException that represents too many failures on retry.
static void	Exceptions.throwIfFatal(Throwable t) Throws a particular Throwable only if it belongs to a set of "fatal" error varieties.
static void	Exceptions.throwIfJvmFatal(Throwable t) Throws a particular Throwable only if it belongs to a set of "fatal" error varieties native to the JVM.
static List<Throwable>	Exceptions.unwrapMultiple(Throwable potentialMultiple) Attempt to unwrap a Throwable into a List of Throwables.
static List<Throwable>	Exceptions.unwrapMultipleExcludingTracebacks(Throwable potentialMultiple) Attempt to unwrap a Throwable into a List of Throwables, excluding instances that are tracebacks.
boolean	Disposable.Swap.update(Disposable next) Atomically set the next Disposable on this container and dispose the previous one (if any).

Constructor parameters in reactor.core with annotations of type Nullable

Constructor and Description
Attr(T defaultValue)
Attr(T defaultValue, Function<Object,? extends T> safeConverter)
Attr(T defaultValue, Function<Object,? extends T> safeConverter)

Uses of Nullable in reactor.core.publisher

Fields in reactor.core.publisher with annotations of type Nullable

Modifier and Type	Field and Description
protected O	Operators.MonoSubscriber.value The value stored by this Mono operator.

Methods in reactor.core.publisher with annotations of type Nullable

Modifier and Type	Method and Description
static <T,P extends Publisher<T>> Publisher<T>	Hooks.addCallSiteInfo(P publisher, String callSite) Deprecated. Should only be used by the instrumentation, DOES NOT guarantee any compatibility
static <T,P extends Publisher<T>> Publisher<T>	Hooks.addReturnInfo(P publisher, String method) Deprecated. Should only be used by the instrumentation, DOES NOT guarantee any compatibility
static <T> Fuseable.QueueSubscription<T>	Operators.as(Subscription s) Returns the subscription as QueueSubscription if possible or null.
O	MonoProcessor.block() Deprecated. Block the calling thread indefinitely, waiting for the completion of this MonoProcessor.
T	Mono.block() Subscribe to this Mono and block indefinitely until a next signal is received.
O	MonoProcessor.block(Duration timeout) Deprecated. Block the calling thread for the specified time, waiting for the completion of this MonoProcessor.
T	Mono.block(Duration timeout) Subscribe to this Mono and block until a next signal is received or a timeout expires.
T	Flux.blockFirst() Subscribe to this Flux and block indefinitely until the upstream signals its first value or completes.
T	Flux.blockFirst(Duration timeout) Subscribe to this Flux and block until the upstream signals its first value, completes or a timeout expires.
T	Flux.blockLast() Subscribe to this Flux and block indefinitely until the upstream signals its last value or completes.
T	Flux.blockLast(Duration timeout) Subscribe to this Flux and block until the upstream signals its last value, completes or a timeout expires.
T	Signal.get() Retrieves the item associated with this (onNext) signal.
Throwable	ReplayProcessor.getError() Deprecated.
Throwable	DirectProcessor.getError() Deprecated.
Throwable	UnicastProcessor.getError() Deprecated.
Throwable	EmitterProcessor.getError() Deprecated.
Throwable	FluxProcessor.getError() Deprecated. Current error if any, default to null
Throwable	MonoProcessor.getError() Deprecated. Return the produced Throwable error if any or null
Subscription	Signal.getSubscription() Read the subscription associated with this (onSubscribe) signal.
Throwable	Signal.getThrowable() Read the error associated with this (onError) signal.
static <T> Throwable	Operators.onNextError(T value, Throwable error, Context context) Find the OnNextFailureStrategy to apply to the calling async operator (which could be a local error mode defined in the Context) and apply it.
static <T> Throwable	Operators.onNextError(T value, Throwable error, Context context, Subscription subscriptionForCancel) Find the OnNextFailureStrategy to apply to the calling operator (which could be a local error mode defined in the Context) and apply it.
static <T> RuntimeException	Operators.onNextPollError(T value, Throwable error, Context context) Find the OnNextFailureStrategy to apply to the calling async operator (which could be a local error mode defined in the Context) and apply it.
O	MonoProcessor.peek() Deprecated. this method is discouraged, consider peeking into a MonoProcessor by turning it into a CompletableFuture
O	Operators.MonoSubscriber.poll()
T	UnicastProcessor.poll() Deprecated.
Object	ReplayProcessor.scanUnsafe(Scannable.Attr key) Deprecated.
Object	Operators.DeferredSubscription.scanUnsafe(Scannable.Attr key)
Object	Operators.MonoSubscriber.scanUnsafe(Scannable.Attr key)
Object	EmitterProcessor.scanUnsafe(Scannable.Attr key) Deprecated.
Object	FluxProcessor.scanUnsafe(Scannable.Attr key) Deprecated.
Object	FluxOperator.scanUnsafe(Scannable.Attr key)
Object	MonoProcessor.scanUnsafe(Scannable.Attr key) Deprecated.
Object	MonoOperator.scanUnsafe(Scannable.Attr key)

Method parameters in reactor.core.publisher with annotations of type Nullable

Modifier and Type	Method and Description
static <T,P extends Publisher<T>> Publisher<T>	Hooks.addCallSiteInfo(P publisher, String callSite) Deprecated. Should only be used by the instrumentation, DOES NOT guarantee any compatibility
static <T,P extends Publisher<T>> Publisher<T>	Hooks.addReturnInfo(P publisher, String method) Deprecated. Should only be used by the instrumentation, DOES NOT guarantee any compatibility
O	MonoProcessor.block(Duration timeout) Deprecated. Block the calling thread for the specified time, waiting for the completion of this MonoProcessor.
static <T> ReplayProcessor<T>	ReplayProcessor.cacheLastOrDefault(T value) Deprecated. use Sinks.many().replay().latestOrDefault(value) (or the unsafe variant if you're sure about external synchronization). To be removed in 3.5.
Flux<T>	Flux.checkpoint(String description, boolean forceStackTrace) Activate traceback (full assembly tracing or the lighter assembly marking depending on the forceStackTrace option).
Mono<T>	Mono.checkpoint(String description, boolean forceStackTrace) Activate traceback (full assembly tracing or the lighter assembly marking depending on the forceStackTrace option).
Mono<List<T>>	Flux.collectSortedList(Comparator<? super T> comparator) Collect all elements emitted by this Flux until this sequence completes, and then sort them using a Comparator into a List that is emitted by the resulting Mono.
void	Operators.MonoSubscriber.complete(O v) Tries to emit the value and complete the underlying subscriber or stores the value away until there is a request for it.
protected void	Operators.MonoSubscriber.discard(O v) Discard the given value, generally this.value field.
void	Sinks.One.emitValue(T value, Sinks.EmitFailureHandler failureHandler) A simplified attempt at emitting a non-null element via the Sinks.One.tryEmitValue(Object) API, generating an onNext signal immediately followed by an Subscriber.onComplete() signal.
static Context	Operators.enableOnDiscard(Context target, Consumer<?> discardConsumer) Utility method to activate the onDiscard feature (see Flux.doOnDiscard(Class, Consumer)) in a target Context.
<R> Flux<R>	Flux.flatMap(Function<? super T,? extends Publisher<? extends R>> mapperOnNext, Function<? super Throwable,? extends Publisher<? extends R>> mapperOnError, Supplier<? extends Publisher<? extends R>> mapperOnComplete) Transform the signals emitted by this Flux asynchronously into Publishers, then flatten these inner publishers into a single Flux through merging, which allow them to interleave.
<R> Flux<R>	Flux.flatMap(Function<? super T,? extends Publisher<? extends R>> mapperOnNext, Function<? super Throwable,? extends Publisher<? extends R>> mapperOnError, Supplier<? extends Publisher<? extends R>> mapperOnComplete) Transform the signals emitted by this Flux asynchronously into Publishers, then flatten these inner publishers into a single Flux through merging, which allow them to interleave.
<R> Flux<R>	Flux.flatMap(Function<? super T,? extends Publisher<? extends R>> mapperOnNext, Function<? super Throwable,? extends Publisher<? extends R>> mapperOnError, Supplier<? extends Publisher<? extends R>> mapperOnComplete) Transform the signals emitted by this Flux asynchronously into Publishers, then flatten these inner publishers into a single Flux through merging, which allow them to interleave.
static <T> Mono<T>	Mono.justOrEmpty(Optional<? extends T> data) Create a new Mono that emits the specified item if Optional.isPresent() otherwise only emits onComplete.
static <T> Mono<T>	Mono.justOrEmpty(T data) Create a new Mono that emits the specified item if non null otherwise only emits onComplete.
ParallelFlux<T>	ParallelFlux.log(String category) Observe all Reactive Streams signals and use Logger support to handle trace implementation.
Mono<T>	Mono.log(String category) Observe all Reactive Streams signals and use Logger support to handle trace implementation.
Flux<T>	Flux.log(String category, Level level, boolean showOperatorLine, SignalType... options) Observe Reactive Streams signals matching the passed filter options and trace them using Logger support.
ParallelFlux<T>	ParallelFlux.log(String category, Level level, boolean showOperatorLine, SignalType... options) Observe Reactive Streams signals matching the passed filter options and use Logger support to handle trace implementation.
Mono<T>	Mono.log(String category, Level level, boolean showOperatorLine, SignalType... options) Observe Reactive Streams signals matching the passed filter options and use Logger support to handle trace implementation.
Flux<T>	Flux.log(String category, Level level, SignalType... options) Observe Reactive Streams signals matching the passed filter options and trace them using Logger support.
ParallelFlux<T>	ParallelFlux.log(String category, Level level, SignalType... options) Observe Reactive Streams signals matching the passed filter options and use Logger support to handle trace implementation.
Mono<T>	Mono.log(String category, Level level, SignalType... options) Observe Reactive Streams signals matching the passed flags options and use Logger support to handle trace implementation.
static <T> void	Operators.onDiscard(T element, Context context) Invoke a (local or global) hook that processes elements that get discarded.
static void	Operators.onDiscardMultiple(Collection<?> multiple, Context context) Invoke a (local or global) hook that processes elements that get discarded en masse.
static void	Operators.onDiscardMultiple(Iterator<?> multiple, boolean knownToBeFinite, Context context) Invoke a (local or global) hook that processes elements that remains in an Iterator.
static void	Operators.onDiscardMultiple(Spliterator<?> multiple, boolean knownToBeFinite, Context context) Invoke a (local or global) hook that processes elements that remains in an Spliterator.
static <T> void	Operators.onDiscardQueueWithClear(Queue<T> queue, Context context, Function<T,Stream<?>> extract) Invoke a (local or global) hook that processes elements that get discarded en masse after having been enqueued, due to cancellation or error.
static <T> void	Operators.onDiscardQueueWithClear(Queue<T> queue, Context context, Function<T,Stream<?>> extract) Invoke a (local or global) hook that processes elements that get discarded en masse after having been enqueued, due to cancellation or error.
static <T> Throwable	Operators.onNextError(T value, Throwable error, Context context) Find the OnNextFailureStrategy to apply to the calling async operator (which could be a local error mode defined in the Context) and apply it.
static <T> Throwable	Operators.onNextError(T value, Throwable error, Context context, Subscription subscriptionForCancel) Find the OnNextFailureStrategy to apply to the calling operator (which could be a local error mode defined in the Context) and apply it.
static <T> Throwable	Operators.onNextInnerError(Throwable error, Context context, Subscription subscriptionForCancel) Find the OnNextFailureStrategy to apply to the calling operator (which could be a local error mode defined in the Context) and apply it.
static <T> RuntimeException	Operators.onNextPollError(T value, Throwable error, Context context) Find the OnNextFailureStrategy to apply to the calling async operator (which could be a local error mode defined in the Context) and apply it.
static Throwable	Operators.onOperatorError(Subscription subscription, Throwable error, Context context) Map an "operator" error given an operator parent Subscription.
static Throwable	Operators.onOperatorError(Subscription subscription, Throwable error, Object dataSignal, Context context) Map an "operator" error given an operator parent Subscription.
static Throwable	Operators.onOperatorError(Subscription subscription, Throwable error, Object dataSignal, Context context) Map an "operator" error given an operator parent Subscription.
static RuntimeException	Operators.onRejectedExecution(Throwable original, Subscription subscription, Throwable suppressed, Object dataSignal, Context context) Return a wrapped RejectedExecutionException which can be thrown by the operator.
static RuntimeException	Operators.onRejectedExecution(Throwable original, Subscription subscription, Throwable suppressed, Object dataSignal, Context context) Return a wrapped RejectedExecutionException which can be thrown by the operator.
static RuntimeException	Operators.onRejectedExecution(Throwable original, Subscription subscription, Throwable suppressed, Object dataSignal, Context context) Return a wrapped RejectedExecutionException which can be thrown by the operator.
void	Operators.MonoSubscriber.setValue(O value) Set the value internally, without impacting request tracking state.
Disposable	Flux.subscribe(Consumer<? super T> consumer, Consumer<? super Throwable> errorConsumer) Subscribe to this Flux with a Consumer that will consume all the elements in the sequence, as well as a Consumer that will handle errors.
Disposable	ParallelFlux.subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError) Subscribes to this ParallelFlux by providing an onNext and onError callback and triggers the execution chain for all 'rails'.
Disposable	Mono.subscribe(Consumer<? super T> consumer, Consumer<? super Throwable> errorConsumer) Subscribe to this Mono with a Consumer that will consume all the elements in the sequence, as well as a Consumer that will handle errors.
Disposable	Flux.subscribe(Consumer<? super T> consumer, Consumer<? super Throwable> errorConsumer, Runnable completeConsumer) Subscribe Consumer to this Flux that will respectively consume all the elements in the sequence, handle errors and react to completion.
Disposable	Flux.subscribe(Consumer<? super T> consumer, Consumer<? super Throwable> errorConsumer, Runnable completeConsumer) Subscribe Consumer to this Flux that will respectively consume all the elements in the sequence, handle errors and react to completion.
Disposable	Flux.subscribe(Consumer<? super T> consumer, Consumer<? super Throwable> errorConsumer, Runnable completeConsumer) Subscribe Consumer to this Flux that will respectively consume all the elements in the sequence, handle errors and react to completion.
Disposable	ParallelFlux.subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError, Runnable onComplete) Subscribes to this ParallelFlux by providing an onNext, onError and onComplete callback and triggers the execution chain for all 'rails'.
Disposable	ParallelFlux.subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError, Runnable onComplete) Subscribes to this ParallelFlux by providing an onNext, onError and onComplete callback and triggers the execution chain for all 'rails'.
Disposable	ParallelFlux.subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError, Runnable onComplete) Subscribes to this ParallelFlux by providing an onNext, onError and onComplete callback and triggers the execution chain for all 'rails'.
Disposable	Mono.subscribe(Consumer<? super T> consumer, Consumer<? super Throwable> errorConsumer, Runnable completeConsumer) Subscribe Consumer to this Mono that will respectively consume all the elements in the sequence, handle errors and react to completion.
Disposable	Mono.subscribe(Consumer<? super T> consumer, Consumer<? super Throwable> errorConsumer, Runnable completeConsumer) Subscribe Consumer to this Mono that will respectively consume all the elements in the sequence, handle errors and react to completion.
Disposable	Mono.subscribe(Consumer<? super T> consumer, Consumer<? super Throwable> errorConsumer, Runnable completeConsumer) Subscribe Consumer to this Mono that will respectively consume all the elements in the sequence, handle errors and react to completion.
Disposable	Flux.subscribe(Consumer<? super T> consumer, Consumer<? super Throwable> errorConsumer, Runnable completeConsumer, Consumer<? super Subscription> subscriptionConsumer) Deprecated. Because users tend to forget to request the subsciption. If the behavior is really needed, consider using Flux.subscribeWith(Subscriber). To be removed in 3.5.
Disposable	Flux.subscribe(Consumer<? super T> consumer, Consumer<? super Throwable> errorConsumer, Runnable completeConsumer, Consumer<? super Subscription> subscriptionConsumer) Deprecated. Because users tend to forget to request the subsciption. If the behavior is really needed, consider using Flux.subscribeWith(Subscriber). To be removed in 3.5.
Disposable	Flux.subscribe(Consumer<? super T> consumer, Consumer<? super Throwable> errorConsumer, Runnable completeConsumer, Consumer<? super Subscription> subscriptionConsumer) Deprecated. Because users tend to forget to request the subsciption. If the behavior is really needed, consider using Flux.subscribeWith(Subscriber). To be removed in 3.5.
Disposable	Flux.subscribe(Consumer<? super T> consumer, Consumer<? super Throwable> errorConsumer, Runnable completeConsumer, Consumer<? super Subscription> subscriptionConsumer) Deprecated. Because users tend to forget to request the subsciption. If the behavior is really needed, consider using Flux.subscribeWith(Subscriber). To be removed in 3.5.
Disposable	ParallelFlux.subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError, Runnable onComplete, Consumer<? super Subscription> onSubscribe) Subscribes to this ParallelFlux by providing an onNext, onError, onComplete and onSubscribe callback and triggers the execution chain for all 'rails'.
Disposable	ParallelFlux.subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError, Runnable onComplete, Consumer<? super Subscription> onSubscribe) Subscribes to this ParallelFlux by providing an onNext, onError, onComplete and onSubscribe callback and triggers the execution chain for all 'rails'.
Disposable	ParallelFlux.subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError, Runnable onComplete, Consumer<? super Subscription> onSubscribe) Subscribes to this ParallelFlux by providing an onNext, onError, onComplete and onSubscribe callback and triggers the execution chain for all 'rails'.
Disposable	ParallelFlux.subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError, Runnable onComplete, Consumer<? super Subscription> onSubscribe) Subscribes to this ParallelFlux by providing an onNext, onError, onComplete and onSubscribe callback and triggers the execution chain for all 'rails'.
Disposable	Mono.subscribe(Consumer<? super T> consumer, Consumer<? super Throwable> errorConsumer, Runnable completeConsumer, Consumer<? super Subscription> subscriptionConsumer) Subscribe Consumer to this Mono that will respectively consume all the elements in the sequence, handle errors, react to completion, and request upon subscription.
Disposable	Mono.subscribe(Consumer<? super T> consumer, Consumer<? super Throwable> errorConsumer, Runnable completeConsumer, Consumer<? super Subscription> subscriptionConsumer) Subscribe Consumer to this Mono that will respectively consume all the elements in the sequence, handle errors, react to completion, and request upon subscription.
Disposable	Mono.subscribe(Consumer<? super T> consumer, Consumer<? super Throwable> errorConsumer, Runnable completeConsumer, Consumer<? super Subscription> subscriptionConsumer) Subscribe Consumer to this Mono that will respectively consume all the elements in the sequence, handle errors, react to completion, and request upon subscription.
Disposable	Mono.subscribe(Consumer<? super T> consumer, Consumer<? super Throwable> errorConsumer, Runnable completeConsumer, Consumer<? super Subscription> subscriptionConsumer) Subscribe Consumer to this Mono that will respectively consume all the elements in the sequence, handle errors, react to completion, and request upon subscription.
Disposable	Flux.subscribe(Consumer<? super T> consumer, Consumer<? super Throwable> errorConsumer, Runnable completeConsumer, Context initialContext) Subscribe Consumer to this Flux that will respectively consume all the elements in the sequence, handle errors and react to completion.
Disposable	Flux.subscribe(Consumer<? super T> consumer, Consumer<? super Throwable> errorConsumer, Runnable completeConsumer, Context initialContext) Subscribe Consumer to this Flux that will respectively consume all the elements in the sequence, handle errors and react to completion.
Disposable	Flux.subscribe(Consumer<? super T> consumer, Consumer<? super Throwable> errorConsumer, Runnable completeConsumer, Context initialContext) Subscribe Consumer to this Flux that will respectively consume all the elements in the sequence, handle errors and react to completion.
Disposable	Flux.subscribe(Consumer<? super T> consumer, Consumer<? super Throwable> errorConsumer, Runnable completeConsumer, Context initialContext) Subscribe Consumer to this Flux that will respectively consume all the elements in the sequence, handle errors and react to completion.
Disposable	ParallelFlux.subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError, Runnable onComplete, Context initialContext) Subscribes to this ParallelFlux by providing an onNext, onError and onComplete callback as well as an initial Context, then trigger the execution chain for all 'rails'.
Disposable	ParallelFlux.subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError, Runnable onComplete, Context initialContext) Subscribes to this ParallelFlux by providing an onNext, onError and onComplete callback as well as an initial Context, then trigger the execution chain for all 'rails'.
Disposable	ParallelFlux.subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError, Runnable onComplete, Context initialContext) Subscribes to this ParallelFlux by providing an onNext, onError and onComplete callback as well as an initial Context, then trigger the execution chain for all 'rails'.
Disposable	ParallelFlux.subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError, Runnable onComplete, Context initialContext) Subscribes to this ParallelFlux by providing an onNext, onError and onComplete callback as well as an initial Context, then trigger the execution chain for all 'rails'.
Disposable	Mono.subscribe(Consumer<? super T> consumer, Consumer<? super Throwable> errorConsumer, Runnable completeConsumer, Context initialContext) Subscribe Consumer to this Mono that will respectively consume all the elements in the sequence, handle errors and react to completion.
Disposable	Mono.subscribe(Consumer<? super T> consumer, Consumer<? super Throwable> errorConsumer, Runnable completeConsumer, Context initialContext) Subscribe Consumer to this Mono that will respectively consume all the elements in the sequence, handle errors and react to completion.
Disposable	Mono.subscribe(Consumer<? super T> consumer, Consumer<? super Throwable> errorConsumer, Runnable completeConsumer, Context initialContext) Subscribe Consumer to this Mono that will respectively consume all the elements in the sequence, handle errors and react to completion.
Disposable	Mono.subscribe(Consumer<? super T> consumer, Consumer<? super Throwable> errorConsumer, Runnable completeConsumer, Context initialContext) Subscribe Consumer to this Mono that will respectively consume all the elements in the sequence, handle errors and react to completion.
void	MonoSink.success(T value) Complete this Mono with the given value.
Mono<T>	Mono.timeout(Duration timeout, Mono<? extends T> fallback, Scheduler timer) Switch to a fallback Mono in case an item doesn't arrive before the given period, as measured on the provided Scheduler.
Flux<T>	Flux.timeout(Duration timeout, Publisher<? extends T> fallback) Switch to a fallback Flux as soon as no item is emitted within the given Duration from the previous emission (or the subscription for the first item).
Flux<T>	Flux.timeout(Duration timeout, Publisher<? extends T> fallback, Scheduler timer) Switch to a fallback Flux as soon as no item is emitted within the given Duration from the previous emission (or the subscription for the first item), as measured on the specified Scheduler.
Iterable<T>	Flux.toIterable(int batchSize, Supplier<Queue<T>> queueProvider) Transform this Flux into a lazy Iterable blocking on Iterator.next() calls.
Sinks.EmitResult	Sinks.One.tryEmitValue(T value) Try to complete the Mono with an element, generating an onNext signal immediately followed by an onComplete signal.
static boolean	Operators.validate(Subscription current, Subscription next) Check Subscription current state and cancel new Subscription if current is set, or return true if ready to subscribe.

Uses of Nullable in reactor.core.scheduler

Method parameters in reactor.core.scheduler with annotations of type Nullable

Modifier and Type	Method and Description
static void	Schedulers.resetFrom(Schedulers.Snapshot snapshot) Replace the current Factory and shared Schedulers with the ones saved in a previously captured snapshot.

Uses of Nullable in reactor.test

Methods in reactor.test with annotations of type Nullable

Modifier and Type	Method and Description
default String	ValueFormatters.Extractor.apply(Object target, Function<Object,String> contentFormatter) Given an arbitrary object and a ValueFormatters.ToStringConverter, if the object passes the ValueFormatters.Extractor.test(Object), extract elements from it and convert them using the ValueFormatters.ToStringConverter, joining the result together to obtain a customized String representation of both the container and its contents.
Context	StepVerifierOptions.getInitialContext()
String	StepVerifierOptions.getScenarioName()
ValueFormatters.ToStringConverter	StepVerifierOptions.getValueFormatter() Get the custom object formatter to use when producing messages.
Supplier<? extends VirtualTimeScheduler>	StepVerifierOptions.getVirtualTimeSchedulerSupplier()

Method parameters in reactor.test with annotations of type Nullable

Modifier and Type	Method and Description
default StepVerifier.FirstStep<T>	StepVerifier.FirstStep.enableConditionalSupport(Predicate<? super T> tryOnNextPredicate) Provide a Predicate that will turn this StepVerifier's subscribers into Fuseable.ConditionalSubscriber and drive the Fuseable.ConditionalSubscriber.tryOnNext(Object) behavior of these subscribers.
StepVerifierOptions	StepVerifierOptions.scenarioName(String scenarioName) Give a name to the whole scenario tested by the configured StepVerifier.
static void	StepVerifier.setDefaultTimeout(Duration timeout) Set the StepVerifier.verify() timeout for all StepVerifier created through the factory methods (StepVerifier.create(Publisher), StepVerifier.withVirtualTime(Supplier), etc.).
StepVerifierOptions	StepVerifierOptions.valueFormatter(ValueFormatters.ToStringConverter valueFormatter) Set up a custom value formatter to be used in error messages when presenting expected and actual values.

Uses of Nullable in reactor.test.publisher

Method parameters in reactor.test.publisher with annotations of type Nullable

Modifier and Type	Method and Description
abstract TestPublisher<T>	TestPublisher.next(T value) Send 1 onNext signal to the subscribers.
TestPublisher<T>	TestPublisher.next(T first, T... rest) Send 1-n onNext signals to the subscribers.

Uses of Nullable in reactor.test.subscriber

Methods in reactor.test.subscriber with annotations of type Nullable

Modifier and Type	Method and Description
Signal<T>	TestSubscriber.getTerminalSignal() Return the terminal Signal if this TestSubscriber TestSubscriber.isTerminated(), or null otherwise.

Uses of Nullable in reactor.util.context

Methods in reactor.util.context with annotations of type Nullable

Modifier and Type	Method and Description
default <T> T	ContextView.getOrDefault(Object key, T defaultValue) Resolve a value given a key within the Context.
<T> T	ReactorContextAccessor.readValue(ContextView sourceContext, Object key)

Method parameters in reactor.util.context with annotations of type Nullable

Modifier and Type	Method and Description
default <T> T	ContextView.getOrDefault(Object key, T defaultValue) Resolve a value given a key within the Context.
default Context	Context.putNonNull(Object key, Object valueOrNull) Create a new Context that contains all current key/value pairs plus the given key/value pair only if the value is not null.

Uses of Nullable in reactor.util.function

Methods in reactor.util.function with annotations of type Nullable

Modifier and Type	Method and Description
Object	Tuple5.get(int index)
Object	Tuple4.get(int index)
Object	Tuple6.get(int index)
Object	Tuple2.get(int index) Get the object at the given index.
Object	Tuple3.get(int index)
Object	Tuple7.get(int index)
Object	Tuple8.get(int index)

Method parameters in reactor.util.function with annotations of type Nullable

Modifier and Type	Method and Description
boolean	Tuple5.equals(Object o)
boolean	Tuple4.equals(Object o)
boolean	Tuple6.equals(Object o)
boolean	Tuple2.equals(Object o)
boolean	Tuple3.equals(Object o)
boolean	Tuple7.equals(Object o)
boolean	Tuple8.equals(Object o)

Uses of Nullable in reactor.util.retry

Method parameters in reactor.util.retry with annotations of type Nullable

Modifier and Type	Method and Description
RetryBackoffSpec	RetryBackoffSpec.scheduler(Scheduler backoffScheduler) Set a Scheduler on which to execute the delays computed by the exponential backoff strategy.