Index (reactor-core 3.3.5.RELEASE)

A B C D E F G H I J K L M N O P Q R S T U V W X Z

A

accept(Subscriber<? super T>) - Method in interface reactor.core.publisher.Signal: Propagate the signal represented by this Signal instance to a given Subscriber.
actual - Variable in class reactor.core.publisher.Operators.MonoSubscriber
actual() - Method in class reactor.core.publisher.Operators.MonoSubscriber
actual() - Method in class reactor.core.publisher.UnicastProcessor
ACTUAL - Static variable in class reactor.core.Scannable.Attr: The direct dependent component downstream reference if any.
ACTUAL_METADATA - Static variable in class reactor.core.Scannable.Attr: Indicate that for some purposes a Scannable should be used as additional source of information about a contiguous Scannable in the chain.
actuals() - Method in interface reactor.core.Scannable: Return a Stream navigating the Subscriber chain (downward).
add(Disposable) - Method in interface reactor.core.Disposable.Composite: Add a Disposable to this container, if it is not disposed.
add(T) - Method in interface reactor.core.Fuseable.QueueSubscription
addAll(Collection<? extends Disposable>) - Method in interface reactor.core.Disposable.Composite: Adds the given collection of Disposables to the container or disposes them all if the container has been disposed.
addAll(Collection<? extends T>) - Method in interface reactor.core.Fuseable.QueueSubscription
addCap(long, long) - Static method in class reactor.core.publisher.Operators: Cap an addition to Long.MAX_VALUE
addCap(AtomicLongFieldUpdater<T>, T, long) - Static method in class reactor.core.publisher.Operators: Concurrent addition bound to Long.MAX_VALUE.
addExecutorServiceDecorator(String, BiFunction<Scheduler, ScheduledExecutorService, ScheduledExecutorService>) - Static method in class reactor.core.scheduler.Schedulers: Set up an additional ScheduledExecutorService decorator for a given key only if that key is not already present.
addSuppressed(RuntimeException, Throwable) - Static method in class reactor.core.Exceptions: Safely suppress a Throwable on a RuntimeException.
addSuppressed(Throwable, Throwable) - Static method in class reactor.core.Exceptions: Safely suppress a Throwable on an original Throwable.
addThrowable(AtomicReferenceFieldUpdater<T, Throwable>, T, Throwable) - Static method in class reactor.core.Exceptions: Update an empty atomic reference with the given exception, or combine further added exceptions together as suppressed exceptions under a root Throwable with the "Multiple exceptions" message, if the atomic reference already holds one.
all(Predicate<? super T>) - Method in class reactor.core.publisher.Flux: Emit a single boolean true if all values of this sequence match the Predicate.
and(Publisher<?>) - Method in class reactor.core.publisher.Mono: Join the termination signals from this mono and another source into the returned void mono
ANY - Static variable in interface reactor.core.Fuseable: Indicates the QueueSubscription should decide what fusion it performs (input only).
any(Predicate<? super T>) - Method in class reactor.core.publisher.Flux: Emit a single boolean true if any of the values of this Flux sequence match the predicate.
apply(Object) - Method in class reactor.util.function.Tuples
as(Function<? super Flux<T>, P>) - Method in class reactor.core.publisher.Flux: Transform this Flux into a target type.
as(Function<? super Mono<T>, P>) - Method in class reactor.core.publisher.Mono: Transform this Mono into a target type.
as(Subscription) - Static method in class reactor.core.publisher.Operators: Returns the subscription as QueueSubscription if possible or null.
as(Function<? super ParallelFlux<T>, U>) - Method in class reactor.core.publisher.ParallelFlux: Perform a fluent transformation to a value via a converter function which receives this ParallelFlux.
ASYNC - Static variable in interface reactor.core.Fuseable: Indicates the QueueSubscription can perform only async-fusion.
Attr(T) - Constructor for class reactor.core.Scannable.Attr
Attr(T, Function<Object, ? extends T>) - Constructor for class reactor.core.Scannable.Attr
autoConnect() - Method in class reactor.core.publisher.ConnectableFlux: Connects this ConnectableFlux to the upstream source when the first Subscriber subscribes.
autoConnect(int) - Method in class reactor.core.publisher.ConnectableFlux: Connects this ConnectableFlux to the upstream source when the specified amount of Subscriber subscribes.
autoConnect(int, Consumer<? super Disposable>) - Method in class reactor.core.publisher.ConnectableFlux: Connects this ConnectableFlux to the upstream source when the specified amount of Subscriber subscribes and calls the supplied consumer with a Disposable that allows disconnecting.

B

backoff(long, Duration) - Static method in class reactor.util.retry.Retry: A RetryBackoffSpec preconfigured for exponential backoff strategy with jitter, given a maximum number of retry attempts and a minimum Duration for the backoff.
backoffSchedulerSupplier - Variable in class reactor.util.retry.RetryBackoffSpec: The configured Supplier of Scheduler on which to execute backoffs.
BACKPRESSURE_ERROR_QUEUE_FULL - Static variable in class reactor.core.Exceptions: A common error message used when a reactive streams source doesn't seem to respect backpressure signals, resulting in an operator's internal queue to be full.
BaseSubscriber<T> - Class in reactor.core.publisher: A simple base class for a Subscriber implementation that lets the user perform a BaseSubscriber.request(long) and BaseSubscriber.cancel() on it directly.
BaseSubscriber() - Constructor for class reactor.core.publisher.BaseSubscriber
block() - Method in class reactor.core.publisher.Mono: Subscribe to this Mono and block indefinitely until a next signal is received.
block(Duration) - Method in class reactor.core.publisher.Mono: Subscribe to this Mono and block until a next signal is received or a timeout expires.
block() - Method in class reactor.core.publisher.MonoProcessor: Block the calling thread indefinitely, waiting for the completion of this MonoProcessor.
block(Duration) - Method in class reactor.core.publisher.MonoProcessor: Block the calling thread for the specified time, waiting for the completion of this MonoProcessor.
blockFirst() - Method in class reactor.core.publisher.Flux: Subscribe to this Flux and block indefinitely until the upstream signals its first value or completes.
blockFirst(Duration) - Method in class reactor.core.publisher.Flux: Subscribe to this Flux and block until the upstream signals its first value, completes or a timeout expires.
blockLast() - Method in class reactor.core.publisher.Flux: Subscribe to this Flux and block indefinitely until the upstream signals its last value or completes.
blockLast(Duration) - Method in class reactor.core.publisher.Flux: Subscribe to this Flux and block until the upstream signals its last value, completes or a timeout expires.
blockOptional() - Method in class reactor.core.publisher.Mono: Subscribe to this Mono and block indefinitely until a next signal is received or the Mono completes empty.
blockOptional(Duration) - Method in class reactor.core.publisher.Mono: Subscribe to this Mono and block until a next signal is received, the Mono completes empty or a timeout expires.
boundedElastic() - Static method in class reactor.core.scheduler.Schedulers: Scheduler that dynamically creates a bounded number of ExecutorService-based Workers, reusing them once the Workers have been shut down.
bubble(Throwable) - Static method in class reactor.core.Exceptions: Prepare an unchecked RuntimeException that will bubble upstream if thrown by an operator.
buffer() - Method in class reactor.core.publisher.Flux: Collect all incoming values into a single List buffer that will be emitted by the returned Flux once this Flux completes.
buffer(int) - Method in class reactor.core.publisher.Flux: Collect incoming values into multiple List buffers that will be emitted by the returned Flux each time the given max size is reached or once this Flux completes.
buffer(int, Supplier<C>) - Method in class reactor.core.publisher.Flux: Collect incoming values into multiple user-defined Collection buffers that will be emitted by the returned Flux each time the given max size is reached or once this Flux completes.
buffer(int, int) - Method in class reactor.core.publisher.Flux: Collect incoming values into multiple List buffers that will be emitted by the returned Flux each time the given max size is reached or once this Flux completes.
buffer(int, int, Supplier<C>) - Method in class reactor.core.publisher.Flux: Collect incoming values into multiple user-defined Collection buffers that will be emitted by the returned Flux each time the given max size is reached or once this Flux completes.
buffer(Publisher<?>) - Method in class reactor.core.publisher.Flux: Collect incoming values into multiple List buffers, as delimited by the signals of a companion Publisher this operator will subscribe to.
buffer(Publisher<?>, Supplier<C>) - Method in class reactor.core.publisher.Flux: Collect incoming values into multiple user-defined Collection buffers, as delimited by the signals of a companion Publisher this operator will subscribe to.
buffer(Duration) - Method in class reactor.core.publisher.Flux: Collect incoming values into multiple List buffers that will be emitted by the returned Flux every bufferingTimespan.
buffer(Duration, Duration) - Method in class reactor.core.publisher.Flux: Collect incoming values into multiple List buffers created at a given openBufferEvery period.
buffer(Duration, Scheduler) - Method in class reactor.core.publisher.Flux: Collect incoming values into multiple List buffers that will be emitted by the returned Flux every bufferingTimespan, as measured on the provided Scheduler.
buffer(Duration, Duration, Scheduler) - Method in class reactor.core.publisher.Flux: Collect incoming values into multiple List buffers created at a given openBufferEvery period, as measured on the provided Scheduler.
BUFFERED - Static variable in class reactor.core.Scannable.Attr: A Integer attribute implemented by components with a backlog capacity.
BufferOverflowStrategy - Enum in reactor.core.publisher: Strategies to deal with overflow of a buffer during backpressure buffering.
bufferTimeout(int, Duration) - Method in class reactor.core.publisher.Flux: Collect incoming values into multiple List buffers that will be emitted by the returned Flux each time the buffer reaches a maximum size OR the maxTime Duration elapses.
bufferTimeout(int, Duration, Supplier<C>) - Method in class reactor.core.publisher.Flux: Collect incoming values into multiple user-defined Collection buffers that will be emitted by the returned Flux each time the buffer reaches a maximum size OR the maxTime Duration elapses.
bufferTimeout(int, Duration, Scheduler) - Method in class reactor.core.publisher.Flux: Collect incoming values into multiple List buffers that will be emitted by the returned Flux each time the buffer reaches a maximum size OR the maxTime Duration elapses, as measured on the provided Scheduler.
bufferTimeout(int, Duration, Scheduler, Supplier<C>) - Method in class reactor.core.publisher.Flux: Collect incoming values into multiple user-defined Collection buffers that will be emitted by the returned Flux each time the buffer reaches a maximum size OR the maxTime Duration elapses, as measured on the provided Scheduler.
bufferUntil(Predicate<? super T>) - Method in class reactor.core.publisher.Flux: Collect incoming values into multiple List buffers that will be emitted by the resulting Flux each time the given predicate returns true.
bufferUntil(Predicate<? super T>, boolean) - Method in class reactor.core.publisher.Flux: Collect incoming values into multiple List buffers that will be emitted by the resulting Flux each time the given predicate returns true.
bufferUntilChanged() - Method in class reactor.core.publisher.Flux: Collect subsequent repetitions of an element (that is, if they arrive right after one another) into multiple List buffers that will be emitted by the resulting Flux.
bufferUntilChanged(Function<? super T, ? extends V>) - Method in class reactor.core.publisher.Flux: Collect subsequent repetitions of an element (that is, if they arrive right after one another), as compared by a key extracted through the user provided Function, into multiple List buffers that will be emitted by the resulting Flux.
bufferUntilChanged(Function<? super T, ? extends V>, BiPredicate<? super V, ? super V>) - Method in class reactor.core.publisher.Flux: Collect subsequent repetitions of an element (that is, if they arrive right after one another), as compared by a key extracted through the user provided Function and compared using a supplied BiPredicate, into multiple List buffers that will be emitted by the resulting Flux.
bufferWhen(Publisher, Function<? super U, ? extends Publisher<V>>) - Method in class reactor.core.publisher.Flux: Collect incoming values into multiple List buffers started each time an opening companion Publisher emits.
bufferWhen(Publisher, Function<? super U, ? extends Publisher<V>>, Supplier<C>) - Method in class reactor.core.publisher.Flux: Collect incoming values into multiple user-defined Collection buffers started each time an opening companion Publisher emits.
bufferWhile(Predicate<? super T>) - Method in class reactor.core.publisher.Flux: Collect incoming values into multiple List buffers that will be emitted by the resulting Flux.

C

cache() - Method in class reactor.core.publisher.Flux: Turn this Flux into a hot source and cache last emitted signals for further Subscriber.
cache(int) - Method in class reactor.core.publisher.Flux: Turn this Flux into a hot source and cache last emitted signals for further Subscriber.
cache(Duration) - Method in class reactor.core.publisher.Flux: Turn this Flux into a hot source and cache last emitted signals for further Subscriber.
cache(Duration, Scheduler) - Method in class reactor.core.publisher.Flux: Turn this Flux into a hot source and cache last emitted signals for further Subscriber.
cache(int, Duration) - Method in class reactor.core.publisher.Flux: Turn this Flux into a hot source and cache last emitted signals for further Subscriber.
cache(int, Duration, Scheduler) - Method in class reactor.core.publisher.Flux: Turn this Flux into a hot source and cache last emitted signals for further Subscriber.
cache() - Method in class reactor.core.publisher.Mono: Turn this Mono into a hot source and cache last emitted signals for further Subscriber.
cache(Duration) - Method in class reactor.core.publisher.Mono: Turn this Mono into a hot source and cache last emitted signals for further Subscriber, with an expiry timeout.
cache(Duration, Scheduler) - Method in class reactor.core.publisher.Mono: Turn this Mono into a hot source and cache last emitted signals for further Subscriber, with an expiry timeout.
cache(Function<? super T, Duration>, Function<Throwable, Duration>, Supplier<Duration>) - Method in class reactor.core.publisher.Mono: Turn this Mono into a hot source and cache last emitted signal for further Subscriber, with an expiry timeout (TTL) that depends on said signal.
cacheLast() - Static method in class reactor.core.publisher.ReplayProcessor: Create a ReplayProcessor that caches the last element it has pushed, replaying it to late subscribers.
cacheLastOrDefault(T) - Static method in class reactor.core.publisher.ReplayProcessor: Create a ReplayProcessor that caches the last element it has pushed, replaying it to late subscribers.
canAppearAfterOnSubscribe(Subscription) - Static method in class reactor.core.publisher.Operators: Check whether the provided Subscription is the one used to satisfy Spec's §1.9 rule before signalling an error.
cancel() - Method in class reactor.core.publisher.BaseSubscriber
cancel() - Method in class reactor.core.publisher.MonoProcessor
cancel() - Method in class reactor.core.publisher.Operators.DeferredSubscription
cancel() - Method in class reactor.core.publisher.Operators.MonoSubscriber
cancel() - Method in class reactor.core.publisher.UnicastProcessor
CANCELLED - Static variable in class reactor.core.Scannable.Attr: A Boolean attribute indicating whether or not a downstream component has interrupted consuming this scanned component, e.g., a cancelled subscription.
cancelledSubscription() - Static method in class reactor.core.publisher.Operators: A singleton Subscription that represents a cancelled subscription instance and should not be leaked to clients as it represents a terminal state.
cancelOn(Scheduler) - Method in class reactor.core.publisher.Flux: Prepare this Flux so that subscribers will cancel from it on a specified Scheduler.
cancelOn(Scheduler) - Method in class reactor.core.publisher.Mono: Prepare this Mono so that subscribers will cancel from it on a specified Scheduler.
CAPACITY - Static variable in class reactor.core.Scannable.Attr: Return an an Integer capacity when no Scannable.Attr.PREFETCH is defined or when an arbitrary maximum limit is applied to the backlog capacity of the scanned component.
capacity(Queue) - Static method in class reactor.util.concurrent.Queues: Return the capacity of a given Queue in a best effort fashion.
CAPACITY_UNSURE - Static variable in class reactor.util.concurrent.Queues
cast(Class<E>) - Method in class reactor.core.publisher.Flux: Cast the current Flux produced type into a target produced type.
cast(Class<E>) - Method in class reactor.core.publisher.Mono: Cast the current Mono produced type into a target produced type.
ceilingNextPowerOfTwo(int) - Static method in class reactor.util.concurrent.Queues: Calculate the next power of 2, greater than or equal to x.
checkpoint() - Method in class reactor.core.publisher.Flux: Activate traceback (full assembly tracing) for this particular Flux, in case of an error upstream of the checkpoint.
checkpoint(String) - Method in class reactor.core.publisher.Flux: Activate traceback (assembly marker) for this particular Flux by giving it a description that will be reflected in the assembly traceback in case of an error upstream of the checkpoint.
checkpoint(String, boolean) - Method in class reactor.core.publisher.Flux: Activate traceback (full assembly tracing or the lighter assembly marking depending on the forceStackTrace option).
checkpoint() - Method in class reactor.core.publisher.Mono: Activate traceback (full assembly tracing) for this particular Mono, in case of an error upstream of the checkpoint.
checkpoint(String) - Method in class reactor.core.publisher.Mono: Activate traceback (assembly marker) for this particular Mono by giving it a description that will be reflected in the assembly traceback in case of an error upstream of the checkpoint.
checkpoint(String, boolean) - Method in class reactor.core.publisher.Mono: Activate traceback (full assembly tracing or the lighter assembly marking depending on the forceStackTrace option).
checkpoint() - Method in class reactor.core.publisher.ParallelFlux: Activate traceback (full assembly tracing) for this particular ParallelFlux, in case of an error upstream of the checkpoint.
checkpoint(String) - Method in class reactor.core.publisher.ParallelFlux: Activate traceback (assembly marker) for this particular ParallelFlux by giving it a description that will be reflected in the assembly traceback in case of an error upstream of the checkpoint.
checkpoint(String, boolean) - Method in class reactor.core.publisher.ParallelFlux: Activate traceback (full assembly tracing or the lighter assembly marking depending on the forceStackTrace option).
clear() - Method in class reactor.core.publisher.Operators.MonoSubscriber
clear() - Method in class reactor.core.publisher.UnicastProcessor
collect(Supplier<E>, BiConsumer<E, ? super T>) - Method in class reactor.core.publisher.Flux: Collect all elements emitted by this Flux into a user-defined container, by applying a collector BiConsumer taking the container and each element.
collect(Collector<? super T, A, ? extends R>) - Method in class reactor.core.publisher.Flux: Collect all elements emitted by this Flux into a container, by applying a Java 8 Stream API Collector The collected result will be emitted when this sequence completes.
collect(Supplier<? extends C>, BiConsumer<? super C, ? super T>) - Method in class reactor.core.publisher.ParallelFlux: Collect the elements in each rail into a collection supplied via a collectionSupplier and collected into with a collector action, emitting the collection at the end.
collectList() - Method in class reactor.core.publisher.Flux: Collect all elements emitted by this Flux into a List that is emitted by the resulting Mono when this sequence completes.
collectMap(Function<? super T, ? extends K>) - Method in class reactor.core.publisher.Flux: Collect all elements emitted by this Flux into a hashed Map that is emitted by the resulting Mono when this sequence completes.
collectMap(Function<? super T, ? extends K>, Function<? super T, ? extends V>) - Method in class reactor.core.publisher.Flux: Collect all elements emitted by this Flux into a hashed Map that is emitted by the resulting Mono when this sequence completes.
collectMap(Function<? super T, ? extends K>, Function<? super T, ? extends V>, Supplier<Map<K, V>>) - Method in class reactor.core.publisher.Flux: Collect all elements emitted by this Flux into a user-defined Map that is emitted by the resulting Mono when this sequence completes.
collectMultimap(Function<? super T, ? extends K>) - Method in class reactor.core.publisher.Flux: Collect all elements emitted by this Flux into a multimap that is emitted by the resulting Mono when this sequence completes.
collectMultimap(Function<? super T, ? extends K>, Function<? super T, ? extends V>) - Method in class reactor.core.publisher.Flux: Collect all elements emitted by this Flux into a multimap that is emitted by the resulting Mono when this sequence completes.
collectMultimap(Function<? super T, ? extends K>, Function<? super T, ? extends V>, Supplier<Map<K, Collection<V>>>) - Method in class reactor.core.publisher.Flux: Collect all elements emitted by this Flux into a user-defined multimap that is emitted by the resulting Mono when this sequence completes.
collectSortedList() - Method in class reactor.core.publisher.Flux: Collect all elements emitted by this Flux until this sequence completes, and then sort them in natural order into a List that is emitted by the resulting Mono.
collectSortedList(Comparator<? super T>) - Method in class reactor.core.publisher.Flux: 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.
collectSortedList(Comparator<? super T>) - Method in class reactor.core.publisher.ParallelFlux: Sorts the 'rails' according to the comparator and returns a full sorted list as a Publisher.
collectSortedList(Comparator<? super T>, int) - Method in class reactor.core.publisher.ParallelFlux: Sorts the 'rails' according to the comparator and returns a full sorted list as a Publisher.
combineLatest(Function<Object[], V>, Publisher<? extends T>...) - Static method in class reactor.core.publisher.Flux: Build a Flux whose data are generated by the combination of the most recently published value from each of the Publisher sources.
combineLatest(Function<Object[], V>, int, Publisher<? extends T>...) - Static method in class reactor.core.publisher.Flux: Build a Flux whose data are generated by the combination of the most recently published value from each of the Publisher sources.
combineLatest(Publisher<? extends T1>, Publisher<? extends T2>, BiFunction<? super T1, ? super T2, ? extends V>) - Static method in class reactor.core.publisher.Flux: Build a Flux whose data are generated by the combination of the most recently published value from each of two Publisher sources.
combineLatest(Publisher<? extends T1>, Publisher<? extends T2>, Publisher<? extends T3>, Function<Object[], V>) - Static method in class reactor.core.publisher.Flux: Build a Flux whose data are generated by the combination of the most recently published value from each of three Publisher sources.
combineLatest(Publisher<? extends T1>, Publisher<? extends T2>, Publisher<? extends T3>, Publisher<? extends T4>, Function<Object[], V>) - Static method in class reactor.core.publisher.Flux: Build a Flux whose data are generated by the combination of the most recently published value from each of four Publisher sources.
combineLatest(Publisher<? extends T1>, Publisher<? extends T2>, Publisher<? extends T3>, Publisher<? extends T4>, Publisher<? extends T5>, Function<Object[], V>) - Static method in class reactor.core.publisher.Flux: Build a Flux whose data are generated by the combination of the most recently published value from each of five Publisher sources.
combineLatest(Publisher<? extends T1>, Publisher<? extends T2>, Publisher<? extends T3>, Publisher<? extends T4>, Publisher<? extends T5>, Publisher<? extends T6>, Function<Object[], V>) - Static method in class reactor.core.publisher.Flux: Build a Flux whose data are generated by the combination of the most recently published value from each of six Publisher sources.
combineLatest(Iterable<? extends Publisher<? extends T>>, Function<Object[], V>) - Static method in class reactor.core.publisher.Flux: Build a Flux whose data are generated by the combination of the most recently published value from each of the Publisher sources provided in an Iterable.
combineLatest(Iterable<? extends Publisher<? extends T>>, int, Function<Object[], V>) - Static method in class reactor.core.publisher.Flux: Build a Flux whose data are generated by the combination of the most recently published value from each of the Publisher sources provided in an Iterable.
complete() - Method in interface reactor.core.publisher.FluxSink
complete(Subscriber<?>) - Static method in class reactor.core.publisher.Operators: Calls onSubscribe on the target Subscriber with the empty instance followed by a call to onComplete.
complete(O) - Method in class reactor.core.publisher.Operators.MonoSubscriber: Tries to emit the value and complete the underlying subscriber or stores the value away until there is a request for it.
complete() - Static method in interface reactor.core.publisher.Signal: Creates and returns a Signal of variety Type.COMPLETE.
complete(Context) - Static method in interface reactor.core.publisher.Signal: Creates and returns a Signal of variety Type.COMPLETE, associated with a specific Context.
complete() - Method in interface reactor.core.publisher.SynchronousSink
composite() - Static method in class reactor.core.Disposables: Create a new empty Disposable.Composite with atomic guarantees on all mutative operations.
composite(Disposable...) - Static method in class reactor.core.Disposables: Create and initialize a new Disposable.Composite with atomic guarantees on all mutative operations.
composite(Iterable<? extends Disposable>) - Static method in class reactor.core.Disposables: Create and initialize a new Disposable.Composite with atomic guarantees on all mutative operations.
concat(Iterable<? extends Publisher<? extends T>>) - Static method in class reactor.core.publisher.Flux: Concatenate all sources provided in an Iterable, forwarding elements emitted by the sources downstream.
concat(Publisher<? extends Publisher<? extends T>>) - Static method in class reactor.core.publisher.Flux: Concatenate all sources emitted as an onNext signal from a parent Publisher, forwarding elements emitted by the sources downstream.
concat(Publisher<? extends Publisher<? extends T>>, int) - Static method in class reactor.core.publisher.Flux: Concatenate all sources emitted as an onNext signal from a parent Publisher, forwarding elements emitted by the sources downstream.
concat(Publisher<? extends T>...) - Static method in class reactor.core.publisher.Flux: Concatenate all sources provided as a vararg, forwarding elements emitted by the sources downstream.
concatDelayError(Publisher<? extends Publisher<? extends T>>) - Static method in class reactor.core.publisher.Flux: Concatenate all sources emitted as an onNext signal from a parent Publisher, forwarding elements emitted by the sources downstream.
concatDelayError(Publisher<? extends Publisher<? extends T>>, int) - Static method in class reactor.core.publisher.Flux: Concatenate all sources emitted as an onNext signal from a parent Publisher, forwarding elements emitted by the sources downstream.
concatDelayError(Publisher<? extends Publisher<? extends T>>, boolean, int) - Static method in class reactor.core.publisher.Flux: Concatenate all sources emitted as an onNext signal from a parent Publisher, forwarding elements emitted by the sources downstream.
concatDelayError(Publisher<? extends T>...) - Static method in class reactor.core.publisher.Flux: Concatenate all sources provided as a vararg, forwarding elements emitted by the sources downstream.
concatMap(Function<? super T, ? extends Publisher<? extends V>>) - Method in class reactor.core.publisher.Flux: Transform the elements emitted by this Flux asynchronously into Publishers, then flatten these inner publishers into a single Flux, sequentially and preserving order using concatenation.
concatMap(Function<? super T, ? extends Publisher<? extends V>>, int) - Method in class reactor.core.publisher.Flux: Transform the elements emitted by this Flux asynchronously into Publishers, then flatten these inner publishers into a single Flux, sequentially and preserving order using concatenation.
concatMap(Function<? super T, ? extends Publisher<? extends R>>) - Method in class reactor.core.publisher.ParallelFlux: Generates and concatenates Publishers on each 'rail', signalling errors immediately and generating 2 publishers upfront.
concatMap(Function<? super T, ? extends Publisher<? extends R>>, int) - Method in class reactor.core.publisher.ParallelFlux: Generates and concatenates Publishers on each 'rail', signalling errors immediately and using the given prefetch amount for generating Publishers upfront.
concatMapDelayError(Function<? super T, ? extends Publisher<? extends V>>) - Method in class reactor.core.publisher.Flux: Transform the elements emitted by this Flux asynchronously into Publishers, then flatten these inner publishers into a single Flux, sequentially and preserving order using concatenation.
concatMapDelayError(Function<? super T, ? extends Publisher<? extends V>>, int) - Method in class reactor.core.publisher.Flux: Transform the elements emitted by this Flux asynchronously into Publishers, then flatten these inner publishers into a single Flux, sequentially and preserving order using concatenation.
concatMapDelayError(Function<? super T, ? extends Publisher<? extends V>>, boolean, int) - Method in class reactor.core.publisher.Flux: Transform the elements emitted by this Flux asynchronously into Publishers, then flatten these inner publishers into a single Flux, sequentially and preserving order using concatenation.
concatMapDelayError(Function<? super T, ? extends Publisher<? extends R>>) - Method in class reactor.core.publisher.ParallelFlux: Generates and concatenates Publishers on each 'rail', delaying errors and generating 2 publishers upfront.
concatMapIterable(Function<? super T, ? extends Iterable<? extends R>>) - Method in class reactor.core.publisher.Flux: Transform the items emitted by this Flux into Iterable, then flatten the elements from those by concatenating them into a single Flux.
concatMapIterable(Function<? super T, ? extends Iterable<? extends R>>, int) - Method in class reactor.core.publisher.Flux: Transform the items emitted by this Flux into Iterable, then flatten the emissions from those by concatenating them into a single Flux.
concatWith(Publisher<? extends T>) - Method in class reactor.core.publisher.Flux: Concatenate emissions of this Flux with the provided Publisher (no interleave).
concatWith(Publisher<? extends T>) - Method in class reactor.core.publisher.Mono: Concatenate emissions of this Mono with the provided Publisher (no interleave).
concatWithValues(T...) - Method in class reactor.core.publisher.Flux: Concatenates the values to the end of the Flux
connect() - Method in class reactor.core.publisher.ConnectableFlux: Connect this ConnectableFlux to its source and return a Disposable that can be used for disconnecting.
connect(Consumer<? super Disposable>) - Method in class reactor.core.publisher.ConnectableFlux: Connects this ConnectableFlux to its source and sends a Disposable to a callback that can be used for disconnecting.
ConnectableFlux<T> - Class in reactor.core.publisher: The abstract base class for connectable publishers that let subscribers pile up before they connect to their data source.
ConnectableFlux() - Constructor for class reactor.core.publisher.ConnectableFlux
contains(Object) - Method in interface reactor.core.Fuseable.QueueSubscription
containsAll(Collection<?>) - Method in interface reactor.core.Fuseable.QueueSubscription
Context - Interface in reactor.util.context: A key/value store that is propagated between components such as operators via the context protocol.
convertToFluxBypassingHooks(Publisher<T>) - Static method in class reactor.core.publisher.Hooks: Utility method to convert a Publisher to a Flux without applying Hooks.
convertToMonoBypassingHooks(Publisher<T>, boolean) - Static method in class reactor.core.publisher.Hooks: Utility method to convert a Publisher to a Mono without applying Hooks.
copy() - Method in interface reactor.util.retry.Retry.RetrySignal: Return an immutable copy of this Retry.RetrySignal which is guaranteed to give a consistent view of the state at the time at which this method is invoked.
CorePublisher<T> - Interface in reactor.core: A CoreSubscriber aware publisher.
CoreSubscriber<T> - Interface in reactor.core: A Context aware subscriber which has relaxed rules for §1.3 and §3.9 compared to the original Subscriber from Reactive Streams.
count() - Method in class reactor.core.publisher.Flux: Counts the number of values in this Flux.
create() - Static method in class reactor.core.publisher.DirectProcessor: Create a new DirectProcessor
create() - Static method in class reactor.core.publisher.EmitterProcessor: Create a new EmitterProcessor using Queues.SMALL_BUFFER_SIZE backlog size and auto-cancel.
create(boolean) - Static method in class reactor.core.publisher.EmitterProcessor: Create a new EmitterProcessor using Queues.SMALL_BUFFER_SIZE backlog size and the provided auto-cancel.
create(int) - Static method in class reactor.core.publisher.EmitterProcessor: Create a new EmitterProcessor using the provided backlog size, with auto-cancel.
create(int, boolean) - Static method in class reactor.core.publisher.EmitterProcessor: Create a new EmitterProcessor using the provided backlog size and auto-cancellation.
create(Consumer<? super FluxSink<T>>) - Static method in class reactor.core.publisher.Flux: Programmatically create a Flux with the capability of emitting multiple elements in a synchronous or asynchronous manner through the FluxSink API.
create(Consumer<? super FluxSink<T>>, FluxSink.OverflowStrategy) - Static method in class reactor.core.publisher.Flux: Programmatically create a Flux with the capability of emitting multiple elements in a synchronous or asynchronous manner through the FluxSink API.
create(Consumer<MonoSink<T>>) - Static method in class reactor.core.publisher.Mono: Creates a deferred emitter that can be used with callback-based APIs to signal at most one value, a complete or an error signal.
create() - Static method in class reactor.core.publisher.MonoProcessor: Create a MonoProcessor that will eagerly request 1 on MonoProcessor.onSubscribe(Subscription), cache and emit the eventual result for 1 or N subscribers.
create() - Static method in class reactor.core.publisher.ReplayProcessor: Create a new ReplayProcessor that replays an unbounded number of elements, using a default internal Queue.
create(int) - Static method in class reactor.core.publisher.ReplayProcessor: Create a new ReplayProcessor that replays up to historySize elements.
create(int, boolean) - Static method in class reactor.core.publisher.ReplayProcessor: Create a new ReplayProcessor that either replay all the elements or a limited amount of elements depending on the unbounded parameter.
create() - Static method in class reactor.core.publisher.UnicastProcessor: Create a new UnicastProcessor that will buffer on an internal queue in an unbounded fashion.
create(Queue<E>) - Static method in class reactor.core.publisher.UnicastProcessor: Create a new UnicastProcessor that will buffer on a provided queue in an unbounded fashion.
create(Queue<E>, Disposable) - Static method in class reactor.core.publisher.UnicastProcessor: Create a new UnicastProcessor that will buffer on a provided queue in an unbounded fashion.
create(Queue<E>, Consumer<? super E>, Disposable) - Static method in class reactor.core.publisher.UnicastProcessor: Create a new UnicastProcessor that will buffer on a provided queue in an unbounded fashion.
createSizeAndTimeout(int, Duration) - Static method in class reactor.core.publisher.ReplayProcessor: Creates a time- and size-bounded replay processor.
createSizeAndTimeout(int, Duration, Scheduler) - Static method in class reactor.core.publisher.ReplayProcessor: Creates a time- and size-bounded replay processor.
createTimeout(Duration) - Static method in class reactor.core.publisher.ReplayProcessor: Creates a time-bounded replay processor.
createTimeout(Duration, Scheduler) - Static method in class reactor.core.publisher.ReplayProcessor: Creates a time-bounded replay processor.
createWorker() - Method in interface reactor.core.scheduler.Scheduler: Creates a worker of this Scheduler.
currentContext() - Method in interface reactor.core.CoreSubscriber: Request a Context from dependent components which can include downstream operators during subscribing or a terminal Subscriber.
currentContext() - Method in class reactor.core.publisher.FluxProcessor
currentContext() - Method in interface reactor.core.publisher.FluxSink: Return the current subscriber Context.
currentContext() - Method in class reactor.core.publisher.MonoProcessor
currentContext() - Method in interface reactor.core.publisher.MonoSink: Return the current subscriber Context.
currentContext() - Method in class reactor.core.publisher.ReplayProcessor
currentContext() - Method in interface reactor.core.publisher.SynchronousSink: Return the current subscriber Context.
currentContext() - Method in class reactor.core.publisher.UnicastProcessor

D

debug(String) - Method in interface reactor.util.Logger: Log a message at the DEBUG level.
debug(String, Object...) - Method in interface reactor.util.Logger: Log a message at the DEBUG level according to the specified format and arguments.
debug(String, Throwable) - Method in interface reactor.util.Logger: Log an exception (throwable) at the DEBUG level with an accompanying message.
decorateExecutorService(Scheduler, ScheduledExecutorService) - Static method in class reactor.core.scheduler.Schedulers: This method is aimed at Scheduler implementors, enabling custom implementations that are backed by a ScheduledExecutorService to also have said executors decorated (ie.
DEFAULT_BOUNDED_ELASTIC_QUEUESIZE - Static variable in class reactor.core.scheduler.Schedulers: Default maximum number of enqueued tasks PER THREAD for the global Schedulers.boundedElastic() Scheduler, initialized by system property reactor.schedulers.defaultBoundedElasticQueueSize and falls back to a bound of 100 000 tasks per backing thread.
DEFAULT_BOUNDED_ELASTIC_SIZE - Static variable in class reactor.core.scheduler.Schedulers: Default maximum size for the global Schedulers.boundedElastic() Scheduler, initialized by system property reactor.schedulers.defaultBoundedElasticSize and falls back to 10 x number of processors available to the runtime on init.
DEFAULT_POOL_SIZE - Static variable in class reactor.core.scheduler.Schedulers: Default pool size, initialized by system property reactor.schedulers.defaultPoolSize and falls back to the number of processors available to the runtime on init.
defaultIfEmpty(T) - Method in class reactor.core.publisher.Flux: Provide a default unique value if this sequence is completed without any data
defaultIfEmpty(T) - Method in class reactor.core.publisher.Mono: Provide a default single value if this mono is completed without any data
defaultValue() - Method in class reactor.core.Scannable.Attr: Meaningful and always applicable default value for the attribute, returned instead of null when a specific value hasn't been defined for a component.
defer(Supplier<? extends Publisher<T>>) - Static method in class reactor.core.publisher.Flux: Lazily supply a Publisher every time a Subscription is made on the resulting Flux, so the actual source instantiation is deferred until each subscribe and the Supplier can create a subscriber-specific instance.
defer(Supplier<? extends Mono<? extends T>>) - Static method in class reactor.core.publisher.Mono: Create a Mono provider that will supply a target Mono to subscribe to for each Subscriber downstream.
DeferredSubscription() - Constructor for class reactor.core.publisher.Operators.DeferredSubscription
deferWithContext(Function<Context, ? extends Publisher<T>>) - Static method in class reactor.core.publisher.Flux: Lazily supply a Publisher every time a Subscription is made on the resulting Flux, so the actual source instantiation is deferred until each subscribe and the Function can create a subscriber-specific instance.
deferWithContext(Function<Context, ? extends Mono<? extends T>>) - Static method in class reactor.core.publisher.Mono: Create a Mono provider that will supply a target Mono to subscribe to for each Subscriber downstream.
delay(Duration) - Static method in class reactor.core.publisher.Mono: Create a Mono which delays an onNext signal by a given duration on a default Scheduler and completes.
delay(Duration, Scheduler) - Static method in class reactor.core.publisher.Mono: Create a Mono which delays an onNext signal by a given duration on a provided Scheduler and completes.
DELAY_ERROR - Static variable in class reactor.core.Scannable.Attr: Delay_Error exposes a Boolean whether the scanned component actively supports error delaying if it manages a backlog instead of fast error-passing which might drop pending backlog.
delayElement(Duration) - Method in class reactor.core.publisher.Mono: Delay this Mono element (Subscriber.onNext(T) signal) by a given duration.
delayElement(Duration, Scheduler) - Method in class reactor.core.publisher.Mono: Delay this Mono element (Subscriber.onNext(T) signal) by a given Duration, on a particular Scheduler.
delayElements(Duration) - Method in class reactor.core.publisher.Flux: Delay each of this Flux elements (Subscriber.onNext(T) signals) by a given Duration.
delayElements(Duration, Scheduler) - Method in class reactor.core.publisher.Flux: Delay each of this Flux elements (Subscriber.onNext(T) signals) by a given Duration.
delaySequence(Duration) - Method in class reactor.core.publisher.Flux: Shift this Flux forward in time by a given Duration.
delaySequence(Duration, Scheduler) - Method in class reactor.core.publisher.Flux: Shift this Flux forward in time by a given Duration.
delaySubscription(Duration) - Method in class reactor.core.publisher.Flux: Delay the subscription to this Flux source until the given period elapses.
delaySubscription(Duration, Scheduler) - Method in class reactor.core.publisher.Flux: Delay the subscription to this Flux source until the given period elapses, as measured on the user-provided Scheduler.
delaySubscription(Publisher) - Method in class reactor.core.publisher.Flux: Delay the subscription to this Flux source until another Publisher signals a value or completes.
delaySubscription(Duration) - Method in class reactor.core.publisher.Mono: Delay the subscription to this Mono source until the given period elapses.
delaySubscription(Duration, Scheduler) - Method in class reactor.core.publisher.Mono: Delay the subscription to this Mono source until the given Duration elapses.
delaySubscription(Publisher) - Method in class reactor.core.publisher.Mono: Delay the subscription to this Mono until another Publisher signals a value or completes.
delayUntil(Function<? super T, ? extends Publisher<?>>) - Method in class reactor.core.publisher.Flux: Subscribe to this Flux and generate a Publisher from each of this Flux elements, each acting as a trigger for relaying said element.
delayUntil(Function<? super T, ? extends Publisher<?>>) - Method in class reactor.core.publisher.Mono: Subscribe to this Mono and another Publisher that is generated from this Mono's element and which will be used as a trigger for relaying said element.
delete(Object) - Method in interface reactor.util.context.Context: Return a new Context that will resolve all existing keys except the removed one, key.
dematerialize() - Method in class reactor.core.publisher.Flux: An operator working only if this Flux emits onNext, onError or onComplete Signal instances, transforming these materialized signals into real signals on the Subscriber.
dematerialize() - Method in class reactor.core.publisher.Mono: An operator working only if this Mono emits onNext, onError or onComplete Signal instances, transforming these materialized signals into real signals on the Subscriber.
DirectProcessor<T> - Class in reactor.core.publisher: Dispatches onNext, onError and onComplete signals to zero-to-many Subscribers.
disableContextLossTracking() - Static method in class reactor.core.publisher.Hooks: Globally disables the Context loss detection that was previously enabled by Hooks.enableContextLossTracking().
disableMetrics() - Static method in class reactor.core.scheduler.Schedulers: If Schedulers.enableMetrics() has been previously called, removes the decorator.
discard(O) - Method in class reactor.core.publisher.Operators.MonoSubscriber: Discard the given value, generally this.value field.
Disposable - Interface in reactor.core: Indicates that a task or resource can be cancelled/disposed.
Disposable.Composite - Interface in reactor.core: A container of Disposable that is itself Disposable.
Disposable.Swap - Interface in reactor.core: A Disposable container that allows updating/replacing its inner Disposable atomically and with respect of disposing the container itself.
Disposables - Class in reactor.core: A support class that offers factory methods for implementations of the specialized Disposable sub-interfaces (Disposable.Composite, Disposable.Swap).
dispose() - Method in interface reactor.core.Disposable.Composite: Atomically mark the container as disposed, clear it and then dispose all the previously contained Disposables.
dispose() - Method in interface reactor.core.Disposable: Cancel or dispose the underlying task or resource.
dispose() - Method in class reactor.core.publisher.BaseSubscriber: Dispose the Subscription by cancelling it.
dispose() - Method in class reactor.core.publisher.FluxProcessor
dispose() - Method in class reactor.core.publisher.MonoProcessor
dispose() - Method in interface reactor.core.scheduler.Scheduler: Instructs this Scheduler to release all resources and reject any new tasks to be executed.
disposed() - Static method in class reactor.core.Disposables: Return a new Disposable that is already disposed.
distinct() - Method in class reactor.core.publisher.Flux: For each Subscriber, track elements from this Flux that have been seen and filter out duplicates.
distinct(Function<? super T, ? extends V>) - Method in class reactor.core.publisher.Flux: For each Subscriber, track elements from this Flux that have been seen and filter out duplicates, as compared by a key extracted through the user provided Function.
distinct(Function<? super T, ? extends V>, Supplier<C>) - Method in class reactor.core.publisher.Flux: For each Subscriber, track elements from this Flux that have been seen and filter out duplicates, as compared by a key extracted through the user provided Function and by the add method of the Collection supplied (typically a Set).
distinct(Function<? super T, ? extends V>, Supplier<C>, BiPredicate<C, V>, Consumer<C>) - Method in class reactor.core.publisher.Flux: For each Subscriber, track elements from this Flux that have been seen and filter out duplicates, as compared by applying a BiPredicate on an arbitrary user-supplied <C> store and a key extracted through the user provided Function.
distinctUntilChanged() - Method in class reactor.core.publisher.Flux: Filter out subsequent repetitions of an element (that is, if they arrive right after one another).
distinctUntilChanged(Function<? super T, ? extends V>) - Method in class reactor.core.publisher.Flux: Filter out subsequent repetitions of an element (that is, if they arrive right after one another), as compared by a key extracted through the user provided Function using equality.
distinctUntilChanged(Function<? super T, ? extends V>, BiPredicate<? super V, ? super V>) - Method in class reactor.core.publisher.Flux: Filter out subsequent repetitions of an element (that is, if they arrive right after one another), as compared by a key extracted through the user provided Function and then comparing keys with the supplied BiPredicate.
doAfterRetry(Consumer<Retry.RetrySignal>) - Method in class reactor.util.retry.RetryBackoffSpec: Add synchronous behavior to be executed after the retry trigger is emitted in the companion publisher.
doAfterRetry(Consumer<Retry.RetrySignal>) - Method in class reactor.util.retry.RetrySpec: Add synchronous behavior to be executed after the retry trigger is emitted in the companion publisher.
doAfterRetryAsync(Function<Retry.RetrySignal, Mono<Void>>) - Method in class reactor.util.retry.RetryBackoffSpec: Add asynchronous behavior to be executed after the current retry trigger in the companion publisher, thus delaying the resulting retry trigger with the additional Mono.
doAfterRetryAsync(Function<Retry.RetrySignal, Mono<Void>>) - Method in class reactor.util.retry.RetrySpec: Add asynchronous behavior to be executed after the current retry trigger in the companion publisher, thus delaying the resulting retry trigger with the additional Mono.
doAfterTerminate(Runnable) - Method in class reactor.core.publisher.Flux: Add behavior (side-effect) triggered after the Flux terminates, either by completing downstream successfully or with an error.
doAfterTerminate(Runnable) - Method in class reactor.core.publisher.Mono: Add behavior (side-effect) triggered after the Mono terminates, either by completing downstream successfully or with an error.
doAfterTerminate(Runnable) - Method in class reactor.core.publisher.ParallelFlux: Run the specified runnable when a 'rail' completes or signals an error.
doBeforeRetry(Consumer<Retry.RetrySignal>) - Method in class reactor.util.retry.RetryBackoffSpec: Add synchronous behavior to be executed before the retry trigger is emitted in the companion publisher.
doBeforeRetry(Consumer<Retry.RetrySignal>) - Method in class reactor.util.retry.RetrySpec: Add synchronous behavior to be executed before the retry trigger is emitted in the companion publisher.
doBeforeRetryAsync(Function<Retry.RetrySignal, Mono<Void>>) - Method in class reactor.util.retry.RetryBackoffSpec: Add asynchronous behavior to be executed before the current retry trigger in the companion publisher, thus delaying the resulting retry trigger with the additional Mono.
doBeforeRetryAsync(Function<Retry.RetrySignal, Mono<Void>>) - Method in class reactor.util.retry.RetrySpec: Add asynchronous behavior to be executed before the current retry trigger in the companion publisher, thus delaying the resulting retry trigger with the additional Mono.
doFinally(Consumer<SignalType>) - Method in class reactor.core.publisher.Flux: Add behavior (side-effect) triggered after the Flux terminates for any reason, including cancellation.
doFinally(Consumer<SignalType>) - Method in class reactor.core.publisher.Mono: Add behavior triggering after the Mono terminates for any reason, including cancellation.
doFirst(Runnable) - Method in class reactor.core.publisher.Flux: Add behavior (side-effect) triggered before the Flux is subscribed to, which should be the first event after assembly time.
doFirst(Runnable) - Method in class reactor.core.publisher.Mono: Add behavior (side-effect) triggered before the Mono is subscribed to, which should be the first event after assembly time.
doOnCancel(Runnable) - Method in class reactor.core.publisher.Flux: Add behavior (side-effect) triggered when the Flux is cancelled.
doOnCancel(Runnable) - Method in class reactor.core.publisher.Mono: Add behavior triggered when the Mono is cancelled.
doOnCancel(Runnable) - Method in class reactor.core.publisher.ParallelFlux: Run the specified runnable when a 'rail' receives a cancellation.
doOnComplete(Runnable) - Method in class reactor.core.publisher.Flux: Add behavior (side-effect) triggered when the Flux completes successfully.
doOnComplete(Runnable) - Method in class reactor.core.publisher.ParallelFlux: Run the specified runnable when a 'rail' completes.
doOnDiscard(Class<R>, Consumer<? super R>) - Method in class reactor.core.publisher.Flux: Modify the behavior of the whole chain of operators upstream of this one to conditionally clean up elements that get discarded by these operators.
doOnDiscard(Class<R>, Consumer<? super R>) - Method in class reactor.core.publisher.Mono: Modify the behavior of the whole chain of operators upstream of this one to conditionally clean up elements that get discarded by these operators.
doOnEach(Consumer<? super Signal<T>>) - Method in class reactor.core.publisher.Flux: Add behavior (side-effects) triggered when the Flux emits an item, fails with an error or completes successfully.
doOnEach(Consumer<? super Signal<T>>) - Method in class reactor.core.publisher.Mono: Add behavior triggered when the Mono emits an item, fails with an error or completes successfully.
doOnEach(Consumer<? super Signal<T>>) - Method in class reactor.core.publisher.ParallelFlux: Triggers side-effects when the ParallelFlux emits an item, fails with an error or completes successfully.
doOnError(Consumer<? super Throwable>) - Method in class reactor.core.publisher.Flux: Add behavior (side-effect) triggered when the Flux completes with an error.
doOnError(Class<E>, Consumer<? super E>) - Method in class reactor.core.publisher.Flux: Add behavior (side-effect) triggered when the Flux completes with an error matching the given exception type.
doOnError(Predicate<? super Throwable>, Consumer<? super Throwable>) - Method in class reactor.core.publisher.Flux: Add behavior (side-effect) triggered when the Flux completes with an error matching the given exception.
doOnError(Consumer<? super Throwable>) - Method in class reactor.core.publisher.Mono: Add behavior triggered when the Mono completes with an error.
doOnError(Class<E>, Consumer<? super E>) - Method in class reactor.core.publisher.Mono: Add behavior triggered when the Mono completes with an error matching the given exception type.
doOnError(Predicate<? super Throwable>, Consumer<? super Throwable>) - Method in class reactor.core.publisher.Mono: Add behavior triggered when the Mono completes with an error matching the given predicate.
doOnError(Consumer<? super Throwable>) - Method in class reactor.core.publisher.ParallelFlux: Call the specified consumer with the exception passing through any 'rail'.
doOnNext(Consumer<? super T>) - Method in class reactor.core.publisher.Flux: Add behavior (side-effect) triggered when the Flux emits an item.
doOnNext(Consumer<? super T>) - Method in class reactor.core.publisher.Mono: Add behavior triggered when the Mono emits a data successfully.
doOnNext(Consumer<? super T>) - Method in class reactor.core.publisher.ParallelFlux: Call the specified consumer with the current element passing through any 'rail'.
doOnRequest(LongConsumer) - Method in class reactor.core.publisher.Flux: Add behavior (side-effect) triggering a LongConsumer when this Flux receives any request.
doOnRequest(LongConsumer) - Method in class reactor.core.publisher.Mono: Add behavior triggering a LongConsumer when the Mono receives any request.
doOnRequest(LongConsumer) - Method in class reactor.core.publisher.ParallelFlux: Call the specified consumer with the request amount if any rail receives a request.
doOnSubscribe(Consumer<? super Subscription>) - Method in class reactor.core.publisher.Flux: Add behavior (side-effect) triggered when the Flux is done being subscribed, that is to say when a Subscription has been produced by the Publisher and passed to the Subscriber.onSubscribe(Subscription).
doOnSubscribe(Consumer<? super Subscription>) - Method in class reactor.core.publisher.Mono: Add behavior (side-effect) triggered when the Mono is done being subscribed, that is to say when a Subscription has been produced by the Publisher and passed to the Subscriber.onSubscribe(Subscription).
doOnSubscribe(Consumer<? super Subscription>) - Method in class reactor.core.publisher.ParallelFlux: Call the specified callback when a 'rail' receives a Subscription from its upstream.
doOnSuccess(Consumer<? super T>) - Method in class reactor.core.publisher.Mono: Add behavior triggered when the Mono completes successfully.
doOnTerminate(Runnable) - Method in class reactor.core.publisher.Flux: Add behavior (side-effect) triggered when the Flux terminates, either by completing successfully or with an error.
doOnTerminate(Runnable) - Method in class reactor.core.publisher.Mono: Add behavior triggered when the Mono terminates, either by completing with a value, completing empty or completing with an error.
doOnTerminate(Runnable) - Method in class reactor.core.publisher.ParallelFlux: Triggered when the ParallelFlux terminates, either by completing successfully or with an error.
downstreamCount() - Method in class reactor.core.publisher.DirectProcessor
downstreamCount() - Method in class reactor.core.publisher.EmitterProcessor
downstreamCount() - Method in class reactor.core.publisher.FluxProcessor: Return the number of active Subscriber or -1 if untracked.
downstreamCount() - Method in class reactor.core.publisher.MonoProcessor: Return the number of active Subscriber or -1 if untracked.
downstreamCount() - Method in class reactor.core.publisher.ReplayProcessor
downstreamCount() - Method in class reactor.core.publisher.UnicastProcessor
drainSubscriber() - Static method in class reactor.core.publisher.Operators: Return a singleton Subscriber that does not check for double onSubscribe and purely request Long.MAX.
duplicateOnSubscribeException() - Static method in class reactor.core.Exceptions

E

elapsed() - Method in class reactor.core.publisher.Flux: Map this Flux into Tuple2<Long, T> of timemillis and source data.
elapsed(Scheduler) - Method in class reactor.core.publisher.Flux: Map this Flux into Tuple2<Long, T> of timemillis and source data.
elapsed() - Method in class reactor.core.publisher.Mono: Map this Mono into Tuple2<Long, T> of timemillis and source data.
elapsed(Scheduler) - Method in class reactor.core.publisher.Mono: Map this Mono sequence into Tuple2<Long, T> of timemillis and source data.
elastic() - Static method in class reactor.core.scheduler.Schedulers: Scheduler that dynamically creates ExecutorService-based Workers and caches the thread pools, reusing them once the Workers have been shut down.
element() - Method in interface reactor.core.Fuseable.QueueSubscription
elementAt(int) - Method in class reactor.core.publisher.Flux: Emit only the element at the given index position or IndexOutOfBoundsException if the sequence is shorter.
elementAt(int, T) - Method in class reactor.core.publisher.Flux: Emit only the element at the given index position or fall back to a default value if the sequence is shorter.
EmitterProcessor<T> - Class in reactor.core.publisher: An implementation of a message-passing Processor implementing publish-subscribe with synchronous (thread-stealing and happen-before interactions) drain loops.
empty() - Static method in class reactor.core.publisher.Flux: Create a Flux that completes without emitting any item.
empty() - Static method in class reactor.core.publisher.Mono: Create a Mono that completes without emitting any item.
empty() - Static method in class reactor.util.concurrent.Queues: A Supplier for an empty immutable Queue, to be used as a placeholder in methods that require a Queue when one doesn't expect to store any data in said Queue.
empty() - Static method in interface reactor.util.context.Context: Return an empty Context
emptySubscriber() - Static method in class reactor.core.publisher.Operators: A Subscriber that is expected to be used as a placeholder and never actually be called.
emptySubscription() - Static method in class reactor.core.publisher.Operators: A singleton enumeration that represents a no-op Subscription instance that can be freely given out to clients.
enableContextLossTracking() - Static method in class reactor.core.publisher.Hooks: Globally enables the Context loss detection in operators like Flux.transform(java.util.function.Function<? super reactor.core.publisher.Flux<T>, ? extends org.reactivestreams.Publisher<V>>) or Mono.transformDeferred(java.util.function.Function<? super reactor.core.publisher.Mono<T>, ? extends org.reactivestreams.Publisher<V>>) when non-Reactor types are used.
enableMetrics() - Static method in class reactor.core.scheduler.Schedulers: If Micrometer is available, set-up a decorator that will instrument any ExecutorService that backs a Scheduler.
enableOnDiscard(Context, Consumer<?>) - Static method in class reactor.core.publisher.Operators: Utility method to activate the onDiscard feature (see Flux.doOnDiscard(Class, Consumer)) in a target Context.
equals(Object) - Method in class reactor.util.function.Tuple2
equals(Object) - Method in class reactor.util.function.Tuple3
equals(Object) - Method in class reactor.util.function.Tuple4
equals(Object) - Method in class reactor.util.function.Tuple5
equals(Object) - Method in class reactor.util.function.Tuple6
equals(Object) - Method in class reactor.util.function.Tuple7
equals(Object) - Method in class reactor.util.function.Tuple8
error(Throwable) - Static method in class reactor.core.publisher.Flux: Create a Flux that terminates with the specified error immediately after being subscribed to.
error(Supplier<? extends Throwable>) - Static method in class reactor.core.publisher.Flux: Create a Flux that terminates with an error immediately after being subscribed to.
error(Throwable, boolean) - Static method in class reactor.core.publisher.Flux: Create a Flux that terminates with the specified error, either immediately after being subscribed to or after being first requested.
error(Throwable) - Method in interface reactor.core.publisher.FluxSink
error(Throwable) - Static method in class reactor.core.publisher.Mono: Create a Mono that terminates with the specified error immediately after being subscribed to.
error(Supplier<? extends Throwable>) - Static method in class reactor.core.publisher.Mono: Create a Mono that terminates with an error immediately after being subscribed to.
error(Throwable) - Method in interface reactor.core.publisher.MonoSink: Terminate with the give exception
error(Subscriber<?>, Throwable) - Static method in class reactor.core.publisher.Operators: Calls onSubscribe on the target Subscriber with the empty instance followed by a call to onError with the supplied error.
error(Throwable) - Static method in interface reactor.core.publisher.Signal: Creates and returns a Signal of variety Type.FAILED, which holds the error.
error(Throwable, Context) - Static method in interface reactor.core.publisher.Signal: Creates and returns a Signal of variety Type.FAILED, which holds the error and the Context associated with the erroring source.
error(Throwable) - Method in interface reactor.core.publisher.SynchronousSink
ERROR - Static variable in class reactor.core.Scannable.Attr: a Throwable attribute which indicate an error state if the scanned component keeps track of it.
error(String) - Method in interface reactor.util.Logger: Log a message at the ERROR level.
error(String, Object...) - Method in interface reactor.util.Logger: Log a message at the ERROR level according to the specified format and arguments.
error(String, Throwable) - Method in interface reactor.util.Logger: Log an exception (throwable) at the ERROR level with an accompanying message.
errorCallbackNotImplemented(Throwable) - Static method in class reactor.core.Exceptions: Return an UnsupportedOperationException indicating that the error callback on a subscriber was not implemented, yet an error was propagated.
errorFilter - Variable in class reactor.util.retry.RetryBackoffSpec: The configured Predicate to filter which exceptions to retry.
errorFilter - Variable in class reactor.util.retry.RetrySpec: The configured Predicate to filter which exceptions to retry.
Exceptions - Class in reactor.core: Global Reactor Core Exception handling and utils to operate on.
expand(Function<? super T, ? extends Publisher<? extends T>>, int) - Method in class reactor.core.publisher.Flux: Recursively expand elements into a graph and emit all the resulting element using a breadth-first traversal strategy.
expand(Function<? super T, ? extends Publisher<? extends T>>) - Method in class reactor.core.publisher.Flux: Recursively expand elements into a graph and emit all the resulting element using a breadth-first traversal strategy.
expand(Function<? super T, ? extends Publisher<? extends T>>, int) - Method in class reactor.core.publisher.Mono: Recursively expand elements into a graph and emit all the resulting element using a breadth-first traversal strategy.
expand(Function<? super T, ? extends Publisher<? extends T>>) - Method in class reactor.core.publisher.Mono: Recursively expand elements into a graph and emit all the resulting element using a breadth-first traversal strategy.
expandDeep(Function<? super T, ? extends Publisher<? extends T>>, int) - Method in class reactor.core.publisher.Flux: Recursively expand elements into a graph and emit all the resulting element, in a depth-first traversal order.
expandDeep(Function<? super T, ? extends Publisher<? extends T>>) - Method in class reactor.core.publisher.Flux: Recursively expand elements into a graph and emit all the resulting element, in a depth-first traversal order.
expandDeep(Function<? super T, ? extends Publisher<? extends T>>, int) - Method in class reactor.core.publisher.Mono: Recursively expand elements into a graph and emit all the resulting element, in a depth-first traversal order.
expandDeep(Function<? super T, ? extends Publisher<? extends T>>) - Method in class reactor.core.publisher.Mono: Recursively expand elements into a graph and emit all the resulting element, in a depth-first traversal order.

F

failure() - Method in interface reactor.util.retry.Retry.RetrySignal: The current Throwable that needs to be evaluated for retry.
failWithCancel() - Static method in class reactor.core.Exceptions: An exception that is propagated upward and considered as "fatal" as per Reactive Stream limited list of exceptions allowed to bubble.
failWithOverflow() - Static method in class reactor.core.Exceptions: Return an IllegalStateException indicating the receiver is overrun by more signals than expected in case of a bounded queue, or more generally that data couldn't be emitted due to a lack of request
failWithOverflow(String) - Static method in class reactor.core.Exceptions: Return an IllegalStateException indicating the receiver is overrun by more signals than expected in case of a bounded queue or more generally that data couldn't be emitted due to a lack of request
failWithRejected() - Static method in class reactor.core.Exceptions: Return a singleton RejectedExecutionException
failWithRejected(Throwable) - Static method in class reactor.core.Exceptions: Return a new RejectedExecutionException with standard message and cause, unless the cause is already a RejectedExecutionException created via Exceptions.failWithRejected(Throwable) (not the singleton-producing variants).
failWithRejected(String) - Static method in class reactor.core.Exceptions: Return a new RejectedExecutionException with given message.
failWithRejectedNotTimeCapable() - Static method in class reactor.core.Exceptions: Return a singleton RejectedExecutionException with a message indicating the reason is due to the scheduler not being time-capable
FALLBACK_PROPERTY - Static variable in class reactor.util.Loggers: The system property that determines which fallback implementation to use for loggers when SLF4J isn't available.
filter(Predicate<? super T>) - Method in class reactor.core.publisher.Flux: Evaluate each source value against the given Predicate.
filter(Predicate<? super T>) - Method in class reactor.core.publisher.Mono: If this Mono is valued, test the result and replay it if predicate returns true.
filter(Predicate<? super T>) - Method in class reactor.core.publisher.ParallelFlux: Filters the source values on each 'rail'.
filter(Predicate<? super Throwable>) - Method in class reactor.util.retry.RetryBackoffSpec: Set the Predicate that will filter which errors can be retried.
filter(Predicate<? super Throwable>) - Method in class reactor.util.retry.RetrySpec: Set the Predicate that will filter which errors can be retried.
filterWhen(Function<? super T, ? extends Publisher<Boolean>>) - Method in class reactor.core.publisher.Flux: Test each value emitted by this Flux asynchronously using a generated Publisher<Boolean> test.
filterWhen(Function<? super T, ? extends Publisher<Boolean>>, int) - Method in class reactor.core.publisher.Flux: Test each value emitted by this Flux asynchronously using a generated Publisher<Boolean> test.
filterWhen(Function<? super T, ? extends Publisher<Boolean>>) - Method in class reactor.core.publisher.Mono: If this Mono is valued, test the value asynchronously using a generated Publisher<Boolean> test.
first(Publisher<? extends I>...) - Static method in class reactor.core.publisher.Flux: Pick the first Publisher to emit any signal (onNext/onError/onComplete) and replay all signals from that Publisher, effectively behaving like the fastest of these competing sources.
first(Iterable<? extends Publisher<? extends I>>) - Static method in class reactor.core.publisher.Flux: Pick the first Publisher to emit any signal (onNext/onError/onComplete) and replay all signals from that Publisher, effectively behaving like the fastest of these competing sources.
first(Mono<? extends T>...) - Static method in class reactor.core.publisher.Mono: Pick the first Mono to emit any signal (value, empty completion or error) and replay that signal, effectively behaving like the fastest of these competing sources.
first(Iterable<? extends Mono<? extends T>>) - Static method in class reactor.core.publisher.Mono: Pick the first available result coming from any of the given monos and populate a new Mono.
fixedDelay(long, Duration) - Static method in class reactor.util.retry.Retry: A RetryBackoffSpec preconfigured for fixed delays (min backoff equals max backoff, no jitter), given a maximum number of retry attempts and the fixed Duration for the backoff.
flatMap(Function<? super T, ? extends Publisher<? extends R>>) - Method in class reactor.core.publisher.Flux: Transform the elements emitted by this Flux asynchronously into Publishers, then flatten these inner publishers into a single Flux through merging, which allow them to interleave.
flatMap(Function<? super T, ? extends Publisher<? extends V>>, int) - Method in class reactor.core.publisher.Flux: Transform the elements emitted by this Flux asynchronously into Publishers, then flatten these inner publishers into a single Flux through merging, which allow them to interleave.
flatMap(Function<? super T, ? extends Publisher<? extends V>>, int, int) - Method in class reactor.core.publisher.Flux: Transform the elements emitted by this Flux asynchronously into Publishers, then flatten these inner publishers into a single Flux through merging, which allow them to interleave.
flatMap(Function<? super T, ? extends Publisher<? extends R>>, Function<? super Throwable, ? extends Publisher<? extends R>>, Supplier<? extends Publisher<? extends R>>) - Method in class reactor.core.publisher.Flux: 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.
flatMap(Function<? super T, ? extends Mono<? extends R>>) - Method in class reactor.core.publisher.Mono: Transform the item emitted by this Mono asynchronously, returning the value emitted by another Mono (possibly changing the value type).
flatMap(Function<? super T, ? extends Publisher<? extends R>>) - Method in class reactor.core.publisher.ParallelFlux: Generates and flattens Publishers on each 'rail'.
flatMap(Function<? super T, ? extends Publisher<? extends R>>, boolean) - Method in class reactor.core.publisher.ParallelFlux: Generates and flattens Publishers on each 'rail', optionally delaying errors.
flatMap(Function<? super T, ? extends Publisher<? extends R>>, boolean, int) - Method in class reactor.core.publisher.ParallelFlux: Generates and flattens Publishers on each 'rail', optionally delaying errors and having a total number of simultaneous subscriptions to the inner Publishers.
flatMap(Function<? super T, ? extends Publisher<? extends R>>, boolean, int, int) - Method in class reactor.core.publisher.ParallelFlux: Generates and flattens Publishers on each 'rail', optionally delaying errors, having a total number of simultaneous subscriptions to the inner Publishers and using the given prefetch amount for the inner Publishers.
flatMapDelayError(Function<? super T, ? extends Publisher<? extends V>>, int, int) - Method in class reactor.core.publisher.Flux: Transform the elements emitted by this Flux asynchronously into Publishers, then flatten these inner publishers into a single Flux through merging, which allow them to interleave.
flatMapIterable(Function<? super T, ? extends Iterable<? extends R>>) - Method in class reactor.core.publisher.Flux: Transform the items emitted by this Flux into Iterable, then flatten the elements from those by merging them into a single Flux.
flatMapIterable(Function<? super T, ? extends Iterable<? extends R>>, int) - Method in class reactor.core.publisher.Flux: Transform the items emitted by this Flux into Iterable, then flatten the emissions from those by merging them into a single Flux.
flatMapIterable(Function<? super T, ? extends Iterable<? extends R>>) - Method in class reactor.core.publisher.Mono: Transform the item emitted by this Mono into Iterable, then forward its elements into the returned Flux.
flatMapMany(Function<? super T, ? extends Publisher<? extends R>>) - Method in class reactor.core.publisher.Mono: Transform the item emitted by this Mono into a Publisher, then forward its emissions into the returned Flux.
flatMapMany(Function<? super T, ? extends Publisher<? extends R>>, Function<? super Throwable, ? extends Publisher<? extends R>>, Supplier<? extends Publisher<? extends R>>) - Method in class reactor.core.publisher.Mono: Transform the signals emitted by this Mono into signal-specific Publishers, then forward the applicable Publisher's emissions into the returned Flux.
flatMapSequential(Function<? super T, ? extends Publisher<? extends R>>) - Method in class reactor.core.publisher.Flux: Transform the elements emitted by this Flux asynchronously into Publishers, then flatten these inner publishers into a single Flux, but merge them in the order of their source element.
flatMapSequential(Function<? super T, ? extends Publisher<? extends R>>, int) - Method in class reactor.core.publisher.Flux: Transform the elements emitted by this Flux asynchronously into Publishers, then flatten these inner publishers into a single Flux, but merge them in the order of their source element.
flatMapSequential(Function<? super T, ? extends Publisher<? extends R>>, int, int) - Method in class reactor.core.publisher.Flux: Transform the elements emitted by this Flux asynchronously into Publishers, then flatten these inner publishers into a single Flux, but merge them in the order of their source element.
flatMapSequentialDelayError(Function<? super T, ? extends Publisher<? extends R>>, int, int) - Method in class reactor.core.publisher.Flux: Transform the elements emitted by this Flux asynchronously into Publishers, then flatten these inner publishers into a single Flux, but merge them in the order of their source element.
flowPublisherToFlux(Flow.Publisher<T>) - Static method in class reactor.adapter.JdkFlowAdapter: Return a Flux from a java Flow.Publisher
Flux<T> - Class in reactor.core.publisher: A Reactive Streams Publisher with rx operators that emits 0 to N elements, and then completes (successfully or with an error).
Flux() - Constructor for class reactor.core.publisher.Flux
flux() - Method in class reactor.core.publisher.Mono: Convert this Mono to a Flux
FluxOperator<I,O> - Class in reactor.core.publisher: A decorating Flux Publisher that exposes Flux API over an arbitrary Publisher.
FluxOperator(Flux<? extends I>) - Constructor for class reactor.core.publisher.FluxOperator: Build a FluxOperator wrapper around the passed parent Publisher
FluxProcessor<IN,OUT> - Class in reactor.core.publisher: A base processor that exposes Flux API for Processor.
FluxProcessor() - Constructor for class reactor.core.publisher.FluxProcessor
FluxSink<T> - Interface in reactor.core.publisher: Wrapper API around a downstream Subscriber for emitting any number of next signals followed by zero or one onError/onComplete.
FluxSink.OverflowStrategy - Enum in reactor.core.publisher: Enumeration for backpressure handling.
fn2() - Static method in class reactor.util.function.Tuples: A converting function from Object array to Tuple2
fn3() - Static method in class reactor.util.function.Tuples: A converting function from Object array to Tuple3
fn3(Function<Tuple3<T1, T2, T3>, R>) - Static method in class reactor.util.function.Tuples: A converting function from Object array to Tuple3 to R.
fn4() - Static method in class reactor.util.function.Tuples: A converting function from Object array to Tuple4
fn4(Function<Tuple4<T1, T2, T3, T4>, R>) - Static method in class reactor.util.function.Tuples: A converting function from Object array to Tuple4 to R.
fn5() - Static method in class reactor.util.function.Tuples: A converting function from Object array to Tuple5
fn5(Function<Tuple5<T1, T2, T3, T4, T5>, R>) - Static method in class reactor.util.function.Tuples: A converting function from Object array to Tuple4 to R.
fn6() - Static method in class reactor.util.function.Tuples: A converting function from Object array to Tuple6
fn6(Function<Tuple6<T1, T2, T3, T4, T5, T6>, R>) - Static method in class reactor.util.function.Tuples: A converting function from Object array to Tuple6 to R.
fn7() - Static method in class reactor.util.function.Tuples: A converting function from Object array to Tuple7
fn7(Function<Tuple7<T1, T2, T3, T4, T5, T6, T7>, R>) - Static method in class reactor.util.function.Tuples: A converting function from Object array to Tuple7 to R.
fn8() - Static method in class reactor.util.function.Tuples: A converting function from Object array to Tuple8
fn8(Function<Tuple8<T1, T2, T3, T4, T5, T6, T7, T8>, R>) - Static method in class reactor.util.function.Tuples: A converting function from Object array to Tuple8
fnAny() - Static method in class reactor.util.function.Tuples: A converting function from Object array to Tuples
fnAny(Function<Tuple2, R>) - Static method in class reactor.util.function.Tuples: A converting function from Object array to Tuples to R.
from(Publisher<? extends T>) - Static method in class reactor.core.publisher.Flux: Decorate the specified Publisher with the Flux API.
from(Publisher<? extends T>) - Static method in class reactor.core.publisher.Mono: Expose the specified Publisher with the Mono API, and ensure it will emit 0 or 1 item.
from(Publisher<? extends T>) - Static method in class reactor.core.publisher.ParallelFlux: Take a Publisher and prepare to consume it on multiple 'rails' (one per CPU core) in a round-robin fashion.
from(Publisher<? extends T>, int) - Static method in class reactor.core.publisher.ParallelFlux: Take a Publisher and prepare to consume it on parallelism number of 'rails', possibly ordered and in a round-robin fashion.
from(Publisher<? extends T>, int, int, Supplier<Queue<T>>) - Static method in class reactor.core.publisher.ParallelFlux: Take a Publisher and prepare to consume it on parallelism number of 'rails' and in a round-robin fashion and use custom prefetch amount and queue for dealing with the source Publisher's values.
from(Publisher<T>...) - Static method in class reactor.core.publisher.ParallelFlux: Wraps multiple Publishers into a ParallelFlux which runs them in parallel and unordered.
from(Object) - Static method in interface reactor.core.Scannable: Attempt to cast the Object to a Scannable.
from(Function<Flux<Retry.RetrySignal>, Publisher<?>>) - Static method in class reactor.util.retry.Retry: A wrapper around Function to provide Retry by using lambda expressions.
fromArray(T[]) - Static method in class reactor.core.publisher.Flux: Create a Flux that emits the items contained in the provided array.
fromArray(Object[]) - Static method in class reactor.util.function.Tuples: Create a Tuple2 with the given array if it is small enough to fit inside a Tuple2 to Tuple8.
fromCallable(Callable<? extends T>) - Static method in class reactor.core.publisher.Mono: Create a Mono producing its value using the provided Callable.
fromCompletionStage(CompletionStage<? extends T>) - Static method in class reactor.core.publisher.Mono: Create a Mono, producing its value using the provided CompletionStage.
fromCompletionStage(Supplier<? extends CompletionStage<? extends T>>) - Static method in class reactor.core.publisher.Mono: Create a Mono that wraps a CompletionStage on subscription, emitting the value produced by the CompletionStage.
fromDirect(Publisher<? extends I>) - Static method in class reactor.core.publisher.Mono: Convert a Publisher to a Mono without any cardinality check (ie this method doesn't cancel the source past the first element).
fromExecutor(Executor) - Static method in class reactor.core.scheduler.Schedulers: Create a Scheduler which uses a backing Executor to schedule Runnables for async operators.
fromExecutor(Executor, boolean) - Static method in class reactor.core.scheduler.Schedulers: Create a Scheduler which uses a backing Executor to schedule Runnables for async operators.
fromExecutorService(ExecutorService) - Static method in class reactor.core.scheduler.Schedulers: Create a Scheduler which uses a backing ExecutorService to schedule Runnables for async operators.
fromExecutorService(ExecutorService, String) - Static method in class reactor.core.scheduler.Schedulers: Create a Scheduler which uses a backing ExecutorService to schedule Runnables for async operators.
fromFuture(CompletableFuture<? extends T>) - Static method in class reactor.core.publisher.Mono: Create a Mono, producing its value using the provided CompletableFuture.
fromFuture(Supplier<? extends CompletableFuture<? extends T>>) - Static method in class reactor.core.publisher.Mono: Create a Mono that wraps a CompletableFuture on subscription, emitting the value produced by the Future.
fromIterable(Iterable<? extends T>) - Static method in class reactor.core.publisher.Flux: Create a Flux that emits the items contained in the provided Iterable.
fromRunnable(Runnable) - Static method in class reactor.core.publisher.Mono: Create a Mono that completes empty once the provided Runnable has been executed.
fromStream(Stream<? extends T>) - Static method in class reactor.core.publisher.Flux: Create a Flux that emits the items contained in the provided Stream.
fromStream(Supplier<Stream<? extends T>>) - Static method in class reactor.core.publisher.Flux: Create a Flux that emits the items contained in a Stream created by the provided Supplier for each subscription.
fromSupplier(Supplier<? extends T>) - Static method in class reactor.core.publisher.Mono: Create a Mono, producing its value using the provided Supplier.
Fuseable - Interface in reactor.core: A micro API for stream fusion, in particular marks producers that support a Fuseable.QueueSubscription.
Fuseable.ConditionalSubscriber<T> - Interface in reactor.core: A subscriber variant that can immediately tell if it consumed the value or not, directly allowing a new value to be sent if it didn't.
Fuseable.QueueSubscription<T> - Interface in reactor.core: Support contract for queue-fusion based optimizations on subscriptions.
Fuseable.ScalarCallable<T> - Interface in reactor.core: Marker interface indicating that the target can return a value or null, otherwise fail immediately and thus a viable target for assembly-time optimizations.
Fuseable.SynchronousSubscription<T> - Interface in reactor.core: Base class for synchronous sources which have fixed size and can emit their items in a pull fashion, thus avoiding the request-accounting overhead in many cases.

G

generate(Consumer<SynchronousSink<T>>) - Static method in class reactor.core.publisher.Flux: Programmatically create a Flux by generating signals one-by-one via a consumer callback.
generate(Callable<S>, BiFunction<S, SynchronousSink<T>, S>) - Static method in class reactor.core.publisher.Flux: Programmatically create a Flux by generating signals one-by-one via a consumer callback and some state.
generate(Callable<S>, BiFunction<S, SynchronousSink<T>, S>, Consumer<? super S>) - Static method in class reactor.core.publisher.Flux: Programmatically create a Flux by generating signals one-by-one via a consumer callback and some state, with a final cleanup callback.
generateCompanion(Flux<Retry.RetrySignal>) - Method in class reactor.util.retry.Retry: The intent of the functional Retry class is to let users configure how to react to Retry.RetrySignal by providing the operator with a companion publisher.
generateCompanion(Flux<Retry.RetrySignal>) - Method in class reactor.util.retry.RetryBackoffSpec
generateCompanion(Flux<Retry.RetrySignal>) - Method in class reactor.util.retry.RetrySpec
get() - Method in interface reactor.core.publisher.Signal: Retrieves the item associated with this (onNext) signal.
get(int) - Static method in class reactor.util.concurrent.Queues
get(Object) - Method in interface reactor.util.context.Context: Resolve a value given a key that exists within the Context, or throw a NoSuchElementException if the key is not present.
get(Class<T>) - Method in interface reactor.util.context.Context: Resolve a value given a type key within the Context.
get(int) - Method in class reactor.util.function.Tuple2: Get the object at the given index.
get(int) - Method in class reactor.util.function.Tuple3
get(int) - Method in class reactor.util.function.Tuple4
get(int) - Method in class reactor.util.function.Tuple5
get(int) - Method in class reactor.util.function.Tuple6
get(int) - Method in class reactor.util.function.Tuple7
get(int) - Method in class reactor.util.function.Tuple8
getBufferSize() - Method in class reactor.core.publisher.EmitterProcessor
getBufferSize() - Method in class reactor.core.publisher.FluxProcessor: Return the processor buffer capacity if any or Integer.MAX_VALUE
getBufferSize() - Method in class reactor.core.publisher.UnicastProcessor
getContext() - Method in interface reactor.core.publisher.Signal: Return the Context that is accessible by the time this Signal was emitted.
getError() - Method in class reactor.core.publisher.DirectProcessor
getError() - Method in class reactor.core.publisher.EmitterProcessor
getError() - Method in class reactor.core.publisher.FluxProcessor: Current error if any, default to null
getError() - Method in class reactor.core.publisher.MonoProcessor: Return the produced Throwable error if any or null
getError() - Method in class reactor.core.publisher.ReplayProcessor
getError() - Method in class reactor.core.publisher.UnicastProcessor
getLogger(String) - Static method in class reactor.util.Loggers: Get a Logger.
getLogger(Class<?>) - Static method in class reactor.util.Loggers: Get a Logger, backed by SLF4J if present on the classpath or falling back to java.util.logging.Logger.
getName() - Method in interface reactor.util.Logger: Return the name of this Logger instance.
getOrDefault(Object, T) - Method in interface reactor.util.context.Context: Resolve a value given a key within the Context.
getOrEmpty(Object) - Method in interface reactor.util.context.Context: Resolve a value given a key within the Context.
getPending() - Method in class reactor.core.publisher.EmitterProcessor: Return the number of parked elements in the emitter backlog.
getPrefetch() - Method in class reactor.core.publisher.DirectProcessor
getPrefetch() - Method in class reactor.core.publisher.EmitterProcessor
getPrefetch() - Method in class reactor.core.publisher.Flux: The prefetch configuration of the Flux
getPrefetch() - Method in class reactor.core.publisher.ParallelFlux: The prefetch configuration of the component
getPrefetch() - Method in class reactor.core.publisher.ReplayProcessor
getPrefetch() - Method in class reactor.core.publisher.UnicastProcessor
getSubscription() - Method in interface reactor.core.publisher.Signal: Read the subscription associated with this (onSubscribe) signal.
getT1() - Method in class reactor.util.function.Tuple2: Type-safe way to get the fist object of this Tuples.
getT2() - Method in class reactor.util.function.Tuple2: Type-safe way to get the second object of this Tuples.
getT3() - Method in class reactor.util.function.Tuple3: Type-safe way to get the third object of this Tuples.
getT4() - Method in class reactor.util.function.Tuple4: Type-safe way to get the fourth object of this Tuples.
getT5() - Method in class reactor.util.function.Tuple5: Type-safe way to get the fifth object of this Tuples.
getT6() - Method in class reactor.util.function.Tuple6: Type-safe way to get the sixth object of this Tuples.
getT7() - Method in class reactor.util.function.Tuple7: Type-safe way to get the seventh object of this Tuples.
getT8() - Method in class reactor.util.function.Tuple8: Type-safe way to get the eighth object of this Tuples.
getThrowable() - Method in interface reactor.core.publisher.Signal: Read the error associated with this (onError) signal.
getType() - Method in interface reactor.core.publisher.Signal: Read the type of this signal: SignalType.ON_SUBSCRIBE, SignalType.ON_NEXT, SignalType.ON_ERROR, or SignalType.ON_COMPLETE
groupBy(Function<? super T, ? extends K>) - Method in class reactor.core.publisher.Flux: Divide this sequence into dynamically created Flux (or groups) for each unique key, as produced by the provided keyMapper Function.
groupBy(Function<? super T, ? extends K>, int) - Method in class reactor.core.publisher.Flux: Divide this sequence into dynamically created Flux (or groups) for each unique key, as produced by the provided keyMapper Function.
groupBy(Function<? super T, ? extends K>, Function<? super T, ? extends V>) - Method in class reactor.core.publisher.Flux: Divide this sequence into dynamically created Flux (or groups) for each unique key, as produced by the provided keyMapper Function.
groupBy(Function<? super T, ? extends K>, Function<? super T, ? extends V>, int) - Method in class reactor.core.publisher.Flux: Divide this sequence into dynamically created Flux (or groups) for each unique key, as produced by the provided keyMapper Function.
GroupedFlux<K,V> - Class in reactor.core.publisher: Represents a sequence of events which has an associated key.
GroupedFlux() - Constructor for class reactor.core.publisher.GroupedFlux
groupJoin(Publisher<? extends TRight>, Function<? super T, ? extends Publisher<TLeftEnd>>, Function<? super TRight, ? extends Publisher<TRightEnd>>, BiFunction<? super T, ? super Flux<TRight>, ? extends R>) - Method in class reactor.core.publisher.Flux: Map values from two Publishers into time windows and emit combination of values in case their windows overlap.
groups() - Method in class reactor.core.publisher.ParallelFlux: Exposes the 'rails' as individual GroupedFlux instances, keyed by the rail index (zero based).

H

handle(BiConsumer<? super T, SynchronousSink<R>>) - Method in class reactor.core.publisher.Flux: Handle the items emitted by this Flux by calling a biconsumer with the output sink for each onNext.
handle(BiConsumer<? super T, SynchronousSink<R>>) - Method in class reactor.core.publisher.Mono: Handle the items emitted by this Mono by calling a biconsumer with the output sink for each onNext.
hasCompleted() - Method in class reactor.core.publisher.FluxProcessor: Return true if terminated with onComplete
hasDownstreams() - Method in class reactor.core.publisher.DirectProcessor
hasDownstreams() - Method in class reactor.core.publisher.FluxProcessor: Return true if any Subscriber is actively subscribed
hasDownstreams() - Method in class reactor.core.publisher.MonoProcessor: Return true if any Subscriber is actively subscribed
hasDownstreams() - Method in class reactor.core.publisher.UnicastProcessor
hasElement(T) - Method in class reactor.core.publisher.Flux: Emit a single boolean true if any of the elements of this Flux sequence is equal to the provided value.
hasElement() - Method in class reactor.core.publisher.Mono: Emit a single boolean true if this Mono has an element.
hasElements() - Method in class reactor.core.publisher.Flux: Emit a single boolean true if this Flux sequence has at least one element.
hasError() - Method in class reactor.core.publisher.FluxProcessor: Return true if terminated with onError
hasError() - Method in interface reactor.core.publisher.Signal: Read whether this signal is on error and carries the cause.
hashCode() - Method in class reactor.util.function.Tuple2
hashCode() - Method in class reactor.util.function.Tuple3
hashCode() - Method in class reactor.util.function.Tuple4
hashCode() - Method in class reactor.util.function.Tuple5
hashCode() - Method in class reactor.util.function.Tuple6
hashCode() - Method in class reactor.util.function.Tuple7
hashCode() - Method in class reactor.util.function.Tuple8
hasKey(Object) - Method in interface reactor.util.context.Context: Return true if a particular key resolves to a value within the Context.
hasValue() - Method in interface reactor.core.publisher.Signal: Has this signal an item associated with it ? (which only happens if it is an (onNext) signal)
hide() - Method in class reactor.core.publisher.ConnectableFlux
hide() - Method in class reactor.core.publisher.Flux: Hides the identities of this Flux instance.
hide() - Method in class reactor.core.publisher.Mono: Hides the identity of this Mono instance.
hide() - Method in class reactor.core.publisher.ParallelFlux: Hides the identities of this ParallelFlux and its Subscription as well.
hookFinally(SignalType) - Method in class reactor.core.publisher.BaseSubscriber: Optional hook executed after any of the termination events (onError, onComplete, cancel).
hookOnCancel() - Method in class reactor.core.publisher.BaseSubscriber: Optional hook executed when the subscription is cancelled by calling this Subscriber's BaseSubscriber.cancel() method.
hookOnComplete() - Method in class reactor.core.publisher.BaseSubscriber: Optional hook for completion processing.
hookOnError(Throwable) - Method in class reactor.core.publisher.BaseSubscriber: Optional hook for error processing.
hookOnNext(T) - Method in class reactor.core.publisher.BaseSubscriber: Hook for processing of onNext values.
hookOnSubscribe(Subscription) - Method in class reactor.core.publisher.BaseSubscriber: Hook for further processing of onSubscribe's Subscription.
Hooks - Class in reactor.core.publisher: A set of overridable lifecycle hooks that can be used for cross-cutting added behavior on Flux/Mono operators.

I

ignoreElement() - Method in class reactor.core.publisher.Mono: Ignores onNext signal (dropping it) and only propagates termination events.
ignoreElements() - Method in class reactor.core.publisher.Flux: Ignores onNext signals (dropping them) and only propagate termination events.
ignoreElements(Publisher<T>) - Static method in class reactor.core.publisher.Mono: Create a new Mono that ignores elements from the source (dropping them), but completes when the source completes.
immediate() - Static method in class reactor.core.scheduler.Schedulers: Executes tasks immediately instead of scheduling them.
indefinitely() - Static method in class reactor.util.retry.Retry: A RetrySpec preconfigured for the most simplistic retry strategy: retry immediately and indefinitely (similar to Flux.retry()).
index() - Method in class reactor.core.publisher.Flux: Keep information about the order in which source values were received by indexing them with a 0-based incrementing long, returning a Flux of Tuple2<(index, value)>.
index(BiFunction<? super Long, ? super T, ? extends I>) - Method in class reactor.core.publisher.Flux: Keep information about the order in which source values were received by indexing them internally with a 0-based incrementing long then combining this information with the source value into a I using the provided BiFunction, returning a Flux.
info(String) - Method in interface reactor.util.Logger: Log a message at the INFO level.
info(String, Object...) - Method in interface reactor.util.Logger: Log a message at the INFO level according to the specified format and arguments.
info(String, Throwable) - Method in interface reactor.util.Logger: Log an exception (throwable) at the INFO level with an accompanying message.
inners() - Method in class reactor.core.publisher.DirectProcessor
inners() - Method in class reactor.core.publisher.EmitterProcessor
inners() - Method in class reactor.core.publisher.FluxProcessor
inners() - Method in class reactor.core.publisher.MonoProcessor
inners() - Method in class reactor.core.publisher.ReplayProcessor
inners() - Method in interface reactor.core.Scannable: Return a Stream of referenced inners (flatmap, multicast etc)
interval(Duration) - Static method in class reactor.core.publisher.Flux: Create a Flux that emits long values starting with 0 and incrementing at specified time intervals on the global timer.
interval(Duration, Duration) - Static method in class reactor.core.publisher.Flux: Create a Flux that emits long values starting with 0 and incrementing at specified time intervals, after an initial delay, on the global timer.
interval(Duration, Scheduler) - Static method in class reactor.core.publisher.Flux: Create a Flux that emits long values starting with 0 and incrementing at specified time intervals, on the specified Scheduler.
interval(Duration, Duration, Scheduler) - Static method in class reactor.core.publisher.Flux: Create a Flux that emits long values starting with 0 and incrementing at specified time intervals, after an initial delay, on the specified Scheduler.
isBubbling(Throwable) - Static method in class reactor.core.Exceptions: Check if the given exception is a bubbled wrapped exception.
isCancel(Throwable) - Static method in class reactor.core.Exceptions: Check if the given error is a cancel signal.
isCancelled() - Method in class reactor.core.publisher.EmitterProcessor
isCancelled() - Method in interface reactor.core.publisher.FluxSink: Returns true if the downstream cancelled the sequence.
isCancelled() - Method in class reactor.core.publisher.MonoProcessor: Indicates whether this MonoProcessor has been interrupted via cancellation.
isCancelled() - Method in class reactor.core.publisher.Operators.DeferredSubscription
isCancelled() - Method in class reactor.core.publisher.Operators.MonoSubscriber: Returns true if this Subscription has been cancelled.
isComplete(Object) - Static method in interface reactor.core.publisher.Signal: Check if an arbitrary Object represents a COMPLETE Signal.
isDebugEnabled() - Method in interface reactor.util.Logger: Is the logger instance enabled for the DEBUG level?
isDisposed() - Method in interface reactor.core.Disposable.Composite: Indicates if the container has already been disposed.
isDisposed() - Method in interface reactor.core.Disposable: Optionally return true when the resource or task is disposed.
isDisposed() - Method in class reactor.core.publisher.BaseSubscriber
isDisposed() - Method in class reactor.core.publisher.MonoProcessor
isDisposed() - Method in class reactor.core.publisher.UnicastProcessor
isEmpty() - Method in class reactor.core.publisher.Operators.MonoSubscriber
isEmpty() - Method in class reactor.core.publisher.UnicastProcessor
isEmpty() - Method in interface reactor.util.context.Context: Return true if the Context is empty.
isError() - Method in class reactor.core.publisher.MonoProcessor: Indicates whether this MonoProcessor has been completed with an error.
isError(Object) - Static method in interface reactor.core.publisher.Signal: Check if a arbitrary Object represents an ERROR Signal.
isErrorCallbackNotImplemented(Throwable) - Static method in class reactor.core.Exceptions: 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.
isErrorEnabled() - Method in interface reactor.util.Logger: Is the logger instance enabled for the ERROR level?
isInfoEnabled() - Method in interface reactor.util.Logger: Is the logger instance enabled for the INFO level?
isInNonBlockingThread() - Static method in class reactor.core.scheduler.Schedulers: Check if calling a Reactor blocking API in the current Thread is forbidden or not, by checking if the thread implements NonBlocking (in which case it is forbidden and this method returns true).
isInstrumentationAvailable() - Static method in class reactor.util.Metrics: Check if the current runtime supports metrics / instrumentation, by verifying if Micrometer is on the classpath.
isMultiple(Throwable) - Static method in class reactor.core.Exceptions: Check a Throwable to see if it is a composite, as created by Exceptions.multiple(Throwable...).
isNonBlockingThread(Thread) - Static method in class reactor.core.scheduler.Schedulers: Check if calling a Reactor blocking API in the given Thread is forbidden or not, by checking if the thread implements NonBlocking (in which case it is forbidden and this method returns true).
isOnComplete() - Method in interface reactor.core.publisher.Signal: Indicates whether this signal represents an onComplete event.
isOnError() - Method in interface reactor.core.publisher.Signal: Indicates whether this signal represents an onError event.
isOnNext() - Method in interface reactor.core.publisher.Signal: Indicates whether this signal represents an onNext event.
isOnSubscribe() - Method in interface reactor.core.publisher.Signal: Indicates whether this signal represents an onSubscribe event.
isOverflow(Throwable) - Static method in class reactor.core.Exceptions: Check if the given exception represents an overflow.
isPowerOfTwo(int) - Static method in class reactor.util.concurrent.Queues
isRetryExhausted(Throwable) - Static method in class reactor.core.Exceptions: Check a Throwable to see if it indicates too many retry attempts have failed.
isScanAvailable() - Method in interface reactor.core.Scannable: Return true whether the component is available for Scannable.scan(Attr) resolution.
isSerialized() - Method in class reactor.core.publisher.FluxProcessor: Return true if this FluxProcessor supports multithread producing
isSuccess() - Method in class reactor.core.publisher.MonoProcessor: Indicates whether this MonoProcessor has been successfully completed a value.
isTerminated() - Method in class reactor.core.publisher.DirectProcessor
isTerminated() - Method in class reactor.core.publisher.EmitterProcessor
isTerminated() - Method in class reactor.core.publisher.FluxProcessor: Has this upstream finished or "completed" / "failed" ?
isTerminated() - Method in class reactor.core.publisher.MonoProcessor: Indicates whether this MonoProcessor has been terminated by the source producer with a success or an error.
isTerminated() - Method in class reactor.core.publisher.ReplayProcessor
isTerminated() - Method in class reactor.core.publisher.UnicastProcessor
isTraceback(Throwable) - Static method in class reactor.core.Exceptions: Check a Throwable to see if it is a traceback, as created by the checkpoint operator or debug utilities.
isTraceEnabled() - Method in interface reactor.util.Logger: Is the logger instance enabled for the TRACE level?
isTransientErrors - Variable in class reactor.util.retry.RetryBackoffSpec: The configured transient error handling flag.
isTransientErrors - Variable in class reactor.util.retry.RetrySpec: The configured transient error handling flag.
isWarnEnabled() - Method in interface reactor.util.Logger: Is the logger instance enabled for the WARN level?
iterator() - Method in interface reactor.core.Fuseable.QueueSubscription
iterator() - Method in class reactor.util.function.Tuple2: Return an immutable Iterator<Object> around the content of this Tuple.

J

JdkFlowAdapter - Class in reactor.adapter: Convert a Java 9+ Flow.Publisher to/from a Reactive Streams Publisher.
jitter(double) - Method in class reactor.util.retry.RetryBackoffSpec: Set a jitter factor for exponential backoffs that adds randomness to each backoff.
jitterFactor - Variable in class reactor.util.retry.RetryBackoffSpec: The configured jitter factor, as a double.
join(Publisher<? extends TRight>, Function<? super T, ? extends Publisher<TLeftEnd>>, Function<? super TRight, ? extends Publisher<TRightEnd>>, BiFunction<? super T, ? super TRight, ? extends R>) - Method in class reactor.core.publisher.Flux: Combine values from two Publishers in case their windows overlap.
just(T...) - Static method in class reactor.core.publisher.Flux: Create a Flux that emits the provided elements and then completes.
just(T) - Static method in class reactor.core.publisher.Flux: Create a new Flux that will only emit a single element then onComplete.
just(T) - Static method in class reactor.core.publisher.Mono: Create a new Mono that emits the specified item, which is captured at instantiation time.
justOrEmpty(Optional<? extends T>) - Static method in class reactor.core.publisher.Mono: Create a new Mono that emits the specified item if Optional.isPresent() otherwise only emits onComplete.
justOrEmpty(T) - Static method in class reactor.core.publisher.Mono: Create a new Mono that emits the specified item if non null otherwise only emits onComplete.

K

key() - Method in class reactor.core.publisher.GroupedFlux: Return the key of the GroupedFlux.

L

LARGE_BUFFERED - Static variable in class reactor.core.Scannable.Attr: Similar to Scannable.Attr.BUFFERED, but reserved for operators that can hold a backlog of items that can grow beyond Integer.MAX_VALUE.
last() - Method in class reactor.core.publisher.Flux: Emit the last element observed before complete signal as a Mono, or emit NoSuchElementException error if the source was empty.
last(T) - Method in class reactor.core.publisher.Flux: Emit the last element observed before complete signal as a Mono, or emit the defaultValue if the source was empty.
lift(BiFunction<Scannable, ? super CoreSubscriber<? super O>, ? extends CoreSubscriber<? super I>>) - Static method in class reactor.core.publisher.Operators: Create a function that can be used to support a custom operator via CoreSubscriber decoration.
lift(Predicate<Scannable>, BiFunction<Scannable, ? super CoreSubscriber<? super O>, ? extends CoreSubscriber<? super O>>) - Static method in class reactor.core.publisher.Operators: Create a function that can be used to support a custom operator via CoreSubscriber decoration.
liftPublisher(BiFunction<Publisher, ? super CoreSubscriber<? super O>, ? extends CoreSubscriber<? super I>>) - Static method in class reactor.core.publisher.Operators: Create a function that can be used to support a custom operator via CoreSubscriber decoration.
liftPublisher(Predicate<Publisher>, BiFunction<Publisher, ? super CoreSubscriber<? super O>, ? extends CoreSubscriber<? super O>>) - Static method in class reactor.core.publisher.Operators: Create a function that can be used to support a custom operator via CoreSubscriber decoration.
limitRate(int) - Method in class reactor.core.publisher.Flux: Ensure that backpressure signals from downstream subscribers are split into batches capped at the provided prefetchRate when propagated upstream, effectively rate limiting the upstream Publisher.
limitRate(int, int) - Method in class reactor.core.publisher.Flux: Ensure that backpressure signals from downstream subscribers are split into batches capped at the provided highTide first, then replenishing at the provided lowTide, effectively rate limiting the upstream Publisher.
limitRequest(long) - Method in class reactor.core.publisher.Flux: Ensure that the total amount requested upstream is capped at cap.
log() - Method in class reactor.core.publisher.Flux: Observe all Reactive Streams signals and trace them using Logger support.
log(String) - Method in class reactor.core.publisher.Flux: Observe all Reactive Streams signals and trace them using Logger support.
log(String, Level, SignalType...) - Method in class reactor.core.publisher.Flux: Observe Reactive Streams signals matching the passed filter options and trace them using Logger support.
log(String, Level, boolean, SignalType...) - Method in class reactor.core.publisher.Flux: Observe Reactive Streams signals matching the passed filter options and trace them using Logger support.
log(Logger) - Method in class reactor.core.publisher.Flux: Observe Reactive Streams signals matching the passed filter options and trace them using a specific user-provided Logger, at Level.INFO level.
log(Logger, Level, boolean, SignalType...) - Method in class reactor.core.publisher.Flux: Observe Reactive Streams signals matching the passed filter options and trace them using a specific user-provided Logger, at the given Level.
log() - Method in class reactor.core.publisher.Mono: Observe all Reactive Streams signals and trace them using Logger support.
log(String) - Method in class reactor.core.publisher.Mono: Observe all Reactive Streams signals and use Logger support to handle trace implementation.
log(String, Level, SignalType...) - Method in class reactor.core.publisher.Mono: Observe Reactive Streams signals matching the passed flags options and use Logger support to handle trace implementation.
log(String, Level, boolean, SignalType...) - Method in class reactor.core.publisher.Mono: Observe Reactive Streams signals matching the passed filter options and use Logger support to handle trace implementation.
log(Logger) - Method in class reactor.core.publisher.Mono: Observe Reactive Streams signals matching the passed filter options and trace them using a specific user-provided Logger, at Level.INFO level.
log(Logger, Level, boolean, SignalType...) - Method in class reactor.core.publisher.Mono: Observe Reactive Streams signals matching the passed filter options and trace them using a specific user-provided Logger, at the given Level.
log() - Method in class reactor.core.publisher.ParallelFlux: Observe all Reactive Streams signals and use Logger support to handle trace implementation.
log(String) - Method in class reactor.core.publisher.ParallelFlux: Observe all Reactive Streams signals and use Logger support to handle trace implementation.
log(String, Level, SignalType...) - Method in class reactor.core.publisher.ParallelFlux: Observe Reactive Streams signals matching the passed filter options and use Logger support to handle trace implementation.
log(String, Level, boolean, SignalType...) - Method in class reactor.core.publisher.ParallelFlux: Observe Reactive Streams signals matching the passed filter options and use Logger support to handle trace implementation.
Logger - Interface in reactor.util: Logger interface designed for internal Reactor usage.
Loggers - Class in reactor.util: Expose static methods to get a logger depending on the environment.

M

map(Function<? super T, ? extends V>) - Method in class reactor.core.publisher.Flux: Transform the items emitted by this Flux by applying a synchronous function to each item.
map(Function<? super T, ? extends R>) - Method in class reactor.core.publisher.Mono: Transform the item emitted by this Mono by applying a synchronous function to it.
map(Function<? super T, ? extends U>) - Method in class reactor.core.publisher.ParallelFlux: Maps the source values on each 'rail' to another value.
mapT1(Function<T1, R>) - Method in class reactor.util.function.Tuple2: Map the left-hand part (T1) of this Tuple2 into a different value and type, keeping the right-hand part (T2).
mapT1(Function<T1, R>) - Method in class reactor.util.function.Tuple3: Map the 1st part (T1) of this Tuple3 into a different value and type, keeping the other parts.
mapT1(Function<T1, R>) - Method in class reactor.util.function.Tuple4: Map the 1st part (T1) of this Tuple4 into a different value and type, keeping the other parts.
mapT1(Function<T1, R>) - Method in class reactor.util.function.Tuple5: Map the 1st part (T1) of this Tuple5 into a different value and type, keeping the other parts.
mapT1(Function<T1, R>) - Method in class reactor.util.function.Tuple6: Map the 1st part (T1) of this Tuple6 into a different value and type, keeping the other parts.
mapT1(Function<T1, R>) - Method in class reactor.util.function.Tuple7: Map the 1st part (T1) of this Tuple7 into a different value and type, keeping the other parts.
mapT1(Function<T1, R>) - Method in class reactor.util.function.Tuple8: Map the 1st part (T1) of this Tuple8 into a different value and type, keeping the other parts.
mapT2(Function<T2, R>) - Method in class reactor.util.function.Tuple2: Map the right-hand part (T2) of this Tuple2 into a different value and type, keeping the left-hand part (T1).
mapT2(Function<T2, R>) - Method in class reactor.util.function.Tuple3: Map the 2nd part (T2) of this Tuple3 into a different value and type, keeping the other parts.
mapT2(Function<T2, R>) - Method in class reactor.util.function.Tuple4: Map the 2nd part (T2) of this Tuple4 into a different value and type, keeping the other parts.
mapT2(Function<T2, R>) - Method in class reactor.util.function.Tuple5: Map the 2nd part (T2) of this Tuple5 into a different value and type, keeping the other parts.
mapT2(Function<T2, R>) - Method in class reactor.util.function.Tuple6: Map the 2nd part (T2) of this Tuple6 into a different value and type, keeping the other parts.
mapT2(Function<T2, R>) - Method in class reactor.util.function.Tuple7: Map the 2nd part (T2) of this Tuple7 into a different value and type, keeping the other parts.
mapT2(Function<T2, R>) - Method in class reactor.util.function.Tuple8: Map the 2nd part (T2) of this Tuple8 into a different value and type, keeping the other parts.
mapT3(Function<T3, R>) - Method in class reactor.util.function.Tuple3: Map the 3rd part (T3) of this Tuple3 into a different value and type, keeping the other parts.
mapT3(Function<T3, R>) - Method in class reactor.util.function.Tuple4: Map the 3rd part (T3) of this Tuple4 into a different value and type, keeping the other parts.
mapT3(Function<T3, R>) - Method in class reactor.util.function.Tuple5: Map the 3rd part (T3) of this Tuple5 into a different value and type, keeping the other parts.
mapT3(Function<T3, R>) - Method in class reactor.util.function.Tuple6: Map the 3rd part (T3) of this Tuple6 into a different value and type, keeping the other parts.
mapT3(Function<T3, R>) - Method in class reactor.util.function.Tuple7: Map the 3rd part (T3) of this Tuple7 into a different value and type, keeping the other parts.
mapT3(Function<T3, R>) - Method in class reactor.util.function.Tuple8: Map the 3rd part (T3) of this Tuple8 into a different value and type, keeping the other parts.
mapT4(Function<T4, R>) - Method in class reactor.util.function.Tuple4: Map the 4th part (T4) of this Tuple4 into a different value and type, keeping the other parts.
mapT4(Function<T4, R>) - Method in class reactor.util.function.Tuple5: Map the 4th part (T4) of this Tuple5 into a different value and type, keeping the other parts.
mapT4(Function<T4, R>) - Method in class reactor.util.function.Tuple6: Map the 4th part (T4) of this Tuple6 into a different value and type, keeping the other parts.
mapT4(Function<T4, R>) - Method in class reactor.util.function.Tuple7: Map the 4th part (T4) of this Tuple7 into a different value and type, keeping the other parts.
mapT4(Function<T4, R>) - Method in class reactor.util.function.Tuple8: Map the 4th part (T4) of this Tuple8 into a different value and type, keeping the other parts.
mapT5(Function<T5, R>) - Method in class reactor.util.function.Tuple5: Map the 5th part (T5) of this Tuple5 into a different value and type, keeping the other parts.
mapT5(Function<T5, R>) - Method in class reactor.util.function.Tuple6: Map the 5th part (T5) of this Tuple6 into a different value and type, keeping the other parts.
mapT5(Function<T5, R>) - Method in class reactor.util.function.Tuple7: Map the 5th part (T5) of this Tuple7 into a different value and type, keeping the other parts.
mapT5(Function<T5, R>) - Method in class reactor.util.function.Tuple8: Map the 5th part (T5) of this Tuple8 into a different value and type, keeping the other parts.
mapT6(Function<T6, R>) - Method in class reactor.util.function.Tuple6: Map the 6th part (T6) of this Tuple6 into a different value and type, keeping the other parts.
mapT6(Function<T6, R>) - Method in class reactor.util.function.Tuple7: Map the 6th part (T6) of this Tuple7 into a different value and type, keeping the other parts.
mapT6(Function<T6, R>) - Method in class reactor.util.function.Tuple8: Map the 6th part (T6) of this Tuple8 into a different value and type, keeping the other parts.
mapT7(Function<T7, R>) - Method in class reactor.util.function.Tuple7: Map the 7th part (T7) of this Tuple7 into a different value and type, keeping the other parts.
mapT7(Function<T7, R>) - Method in class reactor.util.function.Tuple8: Map the 7th part (T7) of this Tuple8 into a different value and type, keeping the other parts.
mapT8(Function<T8, R>) - Method in class reactor.util.function.Tuple8: Map the 8th part (t8) of this Tuple8 into a different value and type, keeping the other parts.
materialize() - Method in class reactor.core.publisher.Flux: Transform incoming onNext, onError and onComplete signals into Signal instances, materializing these signals.
materialize() - Method in class reactor.core.publisher.Mono: Transform incoming onNext, onError and onComplete signals into Signal instances, materializing these signals.
max(long) - Static method in class reactor.util.retry.Retry: A RetrySpec preconfigured for a simple strategy with maximum number of retry attempts.
maxAttempts - Variable in class reactor.util.retry.RetryBackoffSpec: The configured maximum for retry attempts.
maxAttempts(long) - Method in class reactor.util.retry.RetryBackoffSpec: Set the maximum number of retry attempts allowed.
maxAttempts - Variable in class reactor.util.retry.RetrySpec: The configured maximum for retry attempts.
maxAttempts(long) - Method in class reactor.util.retry.RetrySpec: Set the maximum number of retry attempts allowed.
maxBackoff - Variable in class reactor.util.retry.RetryBackoffSpec: The configured maximum backoff Duration.
maxBackoff(Duration) - Method in class reactor.util.retry.RetryBackoffSpec: Set a hard maximum Duration for exponential backoffs.
maxInARow(long) - Static method in class reactor.util.retry.Retry: A RetrySpec preconfigured for a simple strategy with maximum number of retry attempts over subsequent transient errors.
merge(Publisher<? extends Publisher<? extends T>>) - Static method in class reactor.core.publisher.Flux: Merge data from Publisher sequences emitted by the passed Publisher into an interleaved merged sequence.
merge(Publisher<? extends Publisher<? extends T>>, int) - Static method in class reactor.core.publisher.Flux: Merge data from Publisher sequences emitted by the passed Publisher into an interleaved merged sequence.
merge(Publisher<? extends Publisher<? extends T>>, int, int) - Static method in class reactor.core.publisher.Flux: Merge data from Publisher sequences emitted by the passed Publisher into an interleaved merged sequence.
merge(Iterable<? extends Publisher<? extends I>>) - Static method in class reactor.core.publisher.Flux: Merge data from Publisher sequences contained in an Iterable into an interleaved merged sequence.
merge(Publisher<? extends I>...) - Static method in class reactor.core.publisher.Flux: Merge data from Publisher sequences contained in an array / vararg into an interleaved merged sequence.
merge(int, Publisher<? extends I>...) - Static method in class reactor.core.publisher.Flux: Merge data from Publisher sequences contained in an array / vararg into an interleaved merged sequence.
mergeDelayError(int, Publisher<? extends I>...) - Static method in class reactor.core.publisher.Flux: Merge data from Publisher sequences contained in an array / vararg into an interleaved merged sequence.
mergeOrdered(Publisher<? extends I>...) - Static method in class reactor.core.publisher.Flux: Merge data from provided Publisher sequences into an ordered merged sequence, by picking the smallest values from each source (as defined by their natural order).
mergeOrdered(Comparator<? super T>, Publisher<? extends T>...) - Static method in class reactor.core.publisher.Flux: Merge data from provided Publisher sequences into an ordered merged sequence, by picking the smallest values from each source (as defined by the provided Comparator).
mergeOrdered(int, Comparator<? super T>, Publisher<? extends T>...) - Static method in class reactor.core.publisher.Flux: Merge data from provided Publisher sequences into an ordered merged sequence, by picking the smallest values from each source (as defined by the provided Comparator).
mergeOrderedWith(Publisher<? extends T>, Comparator<? super T>) - Method in class reactor.core.publisher.Flux: Merge data from this Flux and a Publisher into a reordered merge sequence, by picking the smallest value from each sequence as defined by a provided Comparator.
mergeSequential(Publisher<? extends Publisher<? extends T>>) - Static method in class reactor.core.publisher.Flux: Merge data from Publisher sequences emitted by the passed Publisher into an ordered merged sequence.
mergeSequential(Publisher<? extends Publisher<? extends T>>, int, int) - Static method in class reactor.core.publisher.Flux: Merge data from Publisher sequences emitted by the passed Publisher into an ordered merged sequence.
mergeSequential(Publisher<? extends I>...) - Static method in class reactor.core.publisher.Flux: Merge data from Publisher sequences provided in an array/vararg into an ordered merged sequence.
mergeSequential(int, Publisher<? extends I>...) - Static method in class reactor.core.publisher.Flux: Merge data from Publisher sequences provided in an array/vararg into an ordered merged sequence.
mergeSequential(Iterable<? extends Publisher<? extends I>>) - Static method in class reactor.core.publisher.Flux: Merge data from Publisher sequences provided in an Iterable into an ordered merged sequence.
mergeSequential(Iterable<? extends Publisher<? extends I>>, int, int) - Static method in class reactor.core.publisher.Flux: Merge data from Publisher sequences provided in an Iterable into an ordered merged sequence.
mergeSequentialDelayError(Publisher<? extends Publisher<? extends T>>, int, int) - Static method in class reactor.core.publisher.Flux: Merge data from Publisher sequences emitted by the passed Publisher into an ordered merged sequence.
mergeSequentialDelayError(int, Publisher<? extends I>...) - Static method in class reactor.core.publisher.Flux: Merge data from Publisher sequences provided in an array/vararg into an ordered merged sequence.
mergeSequentialDelayError(Iterable<? extends Publisher<? extends I>>, int, int) - Static method in class reactor.core.publisher.Flux: Merge data from Publisher sequences provided in an Iterable into an ordered merged sequence.
mergeWith(Publisher<? extends T>) - Method in class reactor.core.publisher.Flux: Merge data from this Flux and a Publisher into an interleaved merged sequence.
mergeWith(Publisher<? extends T>) - Method in class reactor.core.publisher.Mono: Merge emissions of this Mono with the provided Publisher.
metrics() - Method in class reactor.core.publisher.Flux: Activate metrics for this sequence, provided there is an instrumentation facade on the classpath (otherwise this method is a pure no-op).
metrics() - Method in class reactor.core.publisher.Mono: Activate metrics for this sequence, provided there is an instrumentation facade on the classpath (otherwise this method is a pure no-op).
Metrics - Class in reactor.util: Utilities around instrumentation and metrics with Micrometer.
Metrics() - Constructor for class reactor.util.Metrics
minBackoff - Variable in class reactor.util.retry.RetryBackoffSpec: The configured minimum backoff Duration.
minBackoff(Duration) - Method in class reactor.util.retry.RetryBackoffSpec: Set the minimum Duration for the first backoff.
modifyErrorFilter(Function<Predicate<Throwable>, Predicate<? super Throwable>>) - Method in class reactor.util.retry.RetryBackoffSpec: Allows to augment a previously set Predicate with a new condition to allow retries of some exception or not.
modifyErrorFilter(Function<Predicate<Throwable>, Predicate<? super Throwable>>) - Method in class reactor.util.retry.RetrySpec: Allows to augment a previously set Predicate with a new condition to allow retries of some exception or not.
Mono<T> - Class in reactor.core.publisher: A Reactive Streams Publisher with basic rx operators that completes successfully by emitting an element, or with an error.
Mono() - Constructor for class reactor.core.publisher.Mono
MonoOperator<I,O> - Class in reactor.core.publisher: A decorating Mono Publisher that exposes Mono API over an arbitrary Publisher Useful to create operators which return a Mono.
MonoOperator(Mono<? extends I>) - Constructor for class reactor.core.publisher.MonoOperator: Build a MonoOperator wrapper around the passed parent Publisher
MonoProcessor<O> - Class in reactor.core.publisher: A MonoProcessor is a Mono extension that implements stateful semantics.
MonoSink<T> - Interface in reactor.core.publisher: Wrapper API around an actual downstream Subscriber for emitting nothing, a single value or an error (mutually exclusive).
MonoSubscriber(CoreSubscriber<? super O>) - Constructor for class reactor.core.publisher.Operators.MonoSubscriber
multiple(Throwable...) - Static method in class reactor.core.Exceptions: Create a composite exception that wraps the given Throwable(s), as suppressed exceptions.
multiple(Iterable<Throwable>) - Static method in class reactor.core.Exceptions: Create a composite exception that wraps the given Throwable(s), as suppressed exceptions.
multiplyCap(long, long) - Static method in class reactor.core.publisher.Operators: Cap a multiplication to Long.MAX_VALUE

N

name(String) - Method in class reactor.core.publisher.Flux: Give a name to this sequence, which can be retrieved using Scannable.name() as long as this is the first reachable Scannable.parents().
name(String) - Method in class reactor.core.publisher.Mono: Give a name to this sequence, which can be retrieved using Scannable.name() as long as this is the first reachable Scannable.parents().
name(String) - Method in class reactor.core.publisher.ParallelFlux: Give a name to this sequence, which can be retrieved using Scannable.name() as long as this is the first reachable Scannable.parents().
NAME - Static variable in class reactor.core.Scannable.Attr: An arbitrary name given to the operator component.
name() - Method in interface reactor.core.Scannable: Check this Scannable and its Scannable.parents() for a user-defined name and return the first one that is reachable, or default to this Scannable Scannable.stepName() if none.
never() - Static method in class reactor.core.Disposables: Return a new Disposable that can never be disposed.
never() - Static method in class reactor.core.publisher.Flux: Create a Flux that will never signal any data, error or completion signal.
never() - Static method in class reactor.core.publisher.Mono: Return a Mono that will never signal any data, error or completion signal, essentially running indefinitely.
newBoundedElastic(int, int, ThreadFactory, int) - Method in interface reactor.core.scheduler.Schedulers.Factory: Scheduler that dynamically creates a bounded number of ExecutorService-based Workers, reusing them once the Workers have been shut down.
newBoundedElastic(int, int, String) - Static method in class reactor.core.scheduler.Schedulers: Scheduler that dynamically creates a bounded number of ExecutorService-based Workers, reusing them once the Workers have been shut down.
newBoundedElastic(int, int, String, int) - Static method in class reactor.core.scheduler.Schedulers: Scheduler that dynamically creates a bounded number of ExecutorService-based Workers, reusing them once the Workers have been shut down.
newBoundedElastic(int, int, String, int, boolean) - Static method in class reactor.core.scheduler.Schedulers: Scheduler that dynamically creates a bounded number of ExecutorService-based Workers, reusing them once the Workers have been shut down.
newBoundedElastic(int, int, ThreadFactory, int) - Static method in class reactor.core.scheduler.Schedulers: Scheduler that dynamically creates a bounded number of ExecutorService-based Workers, reusing them once the Workers have been shut down.
newElastic(int, ThreadFactory) - Method in interface reactor.core.scheduler.Schedulers.Factory: Scheduler that dynamically creates Workers resources and caches eventually, reusing them once the Workers have been shut down.
newElastic(String) - Static method in class reactor.core.scheduler.Schedulers: Scheduler that dynamically creates ExecutorService-based Workers and caches the thread pools, reusing them once the Workers have been shut down.
newElastic(String, int) - Static method in class reactor.core.scheduler.Schedulers: Scheduler that dynamically creates ExecutorService-based Workers and caches the thread pools, reusing them once the Workers have been shut down.
newElastic(String, int, boolean) - Static method in class reactor.core.scheduler.Schedulers: Scheduler that dynamically creates ExecutorService-based Workers and caches the thread pools, reusing them once the Workers have been shut down.
newElastic(int, ThreadFactory) - Static method in class reactor.core.scheduler.Schedulers: Scheduler that dynamically creates ExecutorService-based Workers and caches the thread pools, reusing them once the Workers have been shut down.
newParallel(int, ThreadFactory) - Method in interface reactor.core.scheduler.Schedulers.Factory: Scheduler that hosts a fixed pool of workers and is suited for parallel work.
newParallel(String) - Static method in class reactor.core.scheduler.Schedulers: Scheduler that hosts a fixed pool of single-threaded ExecutorService-based workers and is suited for parallel work.
newParallel(String, int) - Static method in class reactor.core.scheduler.Schedulers: Scheduler that hosts a fixed pool of single-threaded ExecutorService-based workers and is suited for parallel work.
newParallel(String, int, boolean) - Static method in class reactor.core.scheduler.Schedulers: Scheduler that hosts a fixed pool of single-threaded ExecutorService-based workers and is suited for parallel work.
newParallel(int, ThreadFactory) - Static method in class reactor.core.scheduler.Schedulers: Scheduler that hosts a fixed pool of single-threaded ExecutorService-based workers and is suited for parallel work.
newSingle(ThreadFactory) - Method in interface reactor.core.scheduler.Schedulers.Factory: Scheduler that hosts a single worker and is suited for non-blocking work.
newSingle(String) - Static method in class reactor.core.scheduler.Schedulers: Scheduler that hosts a single-threaded ExecutorService-based worker and is suited for parallel work.
newSingle(String, boolean) - Static method in class reactor.core.scheduler.Schedulers: Scheduler that hosts a single-threaded ExecutorService-based worker and is suited for parallel work.
newSingle(ThreadFactory) - Static method in class reactor.core.scheduler.Schedulers: Scheduler that hosts a single-threaded ExecutorService-based worker and is suited for parallel work.
next() - Method in class reactor.core.publisher.Flux: Emit only the first item emitted by this Flux, into a new Mono.
next(T) - Method in interface reactor.core.publisher.FluxSink: Try emitting, might throw an unchecked exception.
next(T) - Static method in interface reactor.core.publisher.Signal: Creates and returns a Signal of variety Type.NEXT, which holds the value.
next(T, Context) - Static method in interface reactor.core.publisher.Signal: Creates and returns a Signal of variety Type.NEXT, which holds the value and the Context associated with the emitting source.
next(T) - Method in interface reactor.core.publisher.SynchronousSink: Try emitting, might throw an unchecked exception.
NonBlocking - Interface in reactor.core.scheduler: A marker interface that is detected on Threads while executing Reactor blocking APIs, resulting in these calls throwing an exception.
NONE - Static variable in interface reactor.core.Fuseable: Indicates the QueueSubscription can't support the requested mode.
NonNull - Annotation Type in reactor.util.annotation: A common Reactor annotation (similar to Spring ones) to declare that annotated elements cannot be null.
NonNullApi - Annotation Type in reactor.util.annotation: A common Reactor annotation (similar to Spring one) to declare that parameters and return values are to be considered as non-nullable by default for a given package.
NOT_SUPPORTED_MESSAGE - Static variable in interface reactor.core.Fuseable.QueueSubscription
now(TimeUnit) - Method in interface reactor.core.scheduler.Scheduler: Returns the "current time" notion of this scheduler.
Nullable - Annotation Type in reactor.util.annotation: A common Reactor annotation (similar to Spring ones) to declare that annotated elements can be null under some circumstance.
nullOrNegativeRequestException(long) - Static method in class reactor.core.Exceptions

O

of(Object, Object) - Static method in interface reactor.util.context.Context: Create a Context pre-initialized with one key-value pair.
of(Object, Object, Object, Object) - Static method in interface reactor.util.context.Context: Create a Context pre-initialized with two key-value pairs.
of(Object, Object, Object, Object, Object, Object) - Static method in interface reactor.util.context.Context: Create a Context pre-initialized with three key-value pairs.
of(Object, Object, Object, Object, Object, Object, Object, Object) - Static method in interface reactor.util.context.Context: Create a Context pre-initialized with four key-value pairs.
of(Object, Object, Object, Object, Object, Object, Object, Object, Object, Object) - Static method in interface reactor.util.context.Context: Create a Context pre-initialized with five key-value pairs.
of(Map<?, ?>) - Static method in interface reactor.util.context.Context: Create a Context out of a Map.
of(T1, T2) - Static method in class reactor.util.function.Tuples: Create a Tuple2 with the given objects.
of(T1, T2, T3) - Static method in class reactor.util.function.Tuples: Create a Tuple3 with the given objects.
of(T1, T2, T3, T4) - Static method in class reactor.util.function.Tuples: Create a Tuple4 with the given objects.
of(T1, T2, T3, T4, T5) - Static method in class reactor.util.function.Tuples: Create a Tuple5 with the given objects.
of(T1, T2, T3, T4, T5, T6) - Static method in class reactor.util.function.Tuples: Create a Tuple6 with the given objects.
of(T1, T2, T3, T4, T5, T6, T7) - Static method in class reactor.util.function.Tuples: Create a Tuple7 with the given objects.
of(T1, T2, T3, T4, T5, T6, T7, T8) - Static method in class reactor.util.function.Tuples: Create a Tuple8 with the given objects.
offer(T) - Method in interface reactor.core.Fuseable.QueueSubscription
ofType(Class) - Method in class reactor.core.publisher.Flux: Evaluate each accepted value against the given Class type.
ofType(Class) - Method in class reactor.core.publisher.Mono: Evaluate the emitted value against the given Class type.
onAssembly(Flux<T>) - Static method in class reactor.core.publisher.Flux: To be used by custom operators: invokes assembly Hooks pointcut given a Flux, potentially returning a new Flux.
onAssembly(ConnectableFlux<T>) - Static method in class reactor.core.publisher.Flux: To be used by custom operators: invokes assembly Hooks pointcut given a ConnectableFlux, potentially returning a new ConnectableFlux.
onAssembly(Mono<T>) - Static method in class reactor.core.publisher.Mono: To be used by custom operators: invokes assembly Hooks pointcut given a Mono, potentially returning a new Mono.
onAssembly(ParallelFlux<T>) - Static method in class reactor.core.publisher.ParallelFlux: Invoke Hooks pointcut given a ParallelFlux and returning an eventually new ParallelFlux
onBackpressureBuffer() - Method in class reactor.core.publisher.Flux: Request an unbounded demand and push to the returned Flux, or park the observed elements if not enough demand is requested downstream.
onBackpressureBuffer(int) - Method in class reactor.core.publisher.Flux: Request an unbounded demand and push to the returned Flux, or park up to maxSize elements when not enough demand is requested downstream.
onBackpressureBuffer(int, Consumer<? super T>) - Method in class reactor.core.publisher.Flux: Request an unbounded demand and push to the returned Flux, or park up to maxSize elements when not enough demand is requested downstream.
onBackpressureBuffer(int, BufferOverflowStrategy) - Method in class reactor.core.publisher.Flux: Request an unbounded demand and push to the returned Flux, or park the observed elements if not enough demand is requested downstream, within a maxSize limit.
onBackpressureBuffer(int, Consumer<? super T>, BufferOverflowStrategy) - Method in class reactor.core.publisher.Flux: Request an unbounded demand and push to the returned Flux, or park the observed elements if not enough demand is requested downstream, within a maxSize limit.
onBackpressureBuffer(Duration, int, Consumer<? super T>) - Method in class reactor.core.publisher.Flux: Request an unbounded demand and push to the returned Flux, or park the observed elements if not enough demand is requested downstream, within a maxSize limit and for a maximum Duration of ttl (as measured on the parallel Scheduler).
onBackpressureBuffer(Duration, int, Consumer<? super T>, Scheduler) - Method in class reactor.core.publisher.Flux: Request an unbounded demand and push to the returned Flux, or park the observed elements if not enough demand is requested downstream, within a maxSize limit and for a maximum Duration of ttl (as measured on the provided Scheduler).
onBackpressureDrop() - Method in class reactor.core.publisher.Flux: Request an unbounded demand and push to the returned Flux, or drop the observed elements if not enough demand is requested downstream.
onBackpressureDrop(Consumer<? super T>) - Method in class reactor.core.publisher.Flux: Request an unbounded demand and push to the returned Flux, or drop and notify dropping Consumer with the observed elements if not enough demand is requested downstream.
onBackpressureError() - Method in class reactor.core.publisher.Flux: Request an unbounded demand and push to the returned Flux, or emit onError fom Exceptions.failWithOverflow() if not enough demand is requested downstream.
onBackpressureLatest() - Method in class reactor.core.publisher.Flux: Request an unbounded demand and push to the returned Flux, or only keep the most recent observed item if not enough demand is requested downstream.
onCancel(Disposable) - Method in interface reactor.core.publisher.FluxSink: Attach a Disposable as a callback for when this FluxSink is cancelled.
onCancel(Disposable) - Method in interface reactor.core.publisher.MonoSink: Attach a Disposable as a callback for when this MonoSink is cancelled.
onComplete() - Method in class reactor.core.publisher.BaseSubscriber
onComplete() - Method in class reactor.core.publisher.DirectProcessor
onComplete() - Method in class reactor.core.publisher.EmitterProcessor
onComplete() - Method in class reactor.core.publisher.MonoProcessor
onComplete() - Method in class reactor.core.publisher.Operators.MonoSubscriber
onComplete() - Method in class reactor.core.publisher.ReplayProcessor
onComplete() - Method in class reactor.core.publisher.UnicastProcessor
onDiscard(T, Context) - Static method in class reactor.core.publisher.Operators: Invoke a (local or global) hook that processes elements that get discarded.
onDiscardMultiple(Stream<?>, Context) - Static method in class reactor.core.publisher.Operators: Invoke a (local or global) hook that processes elements that get discarded en masse.
onDiscardMultiple(Collection<?>, Context) - Static method in class reactor.core.publisher.Operators: Invoke a (local or global) hook that processes elements that get discarded en masse.
onDiscardMultiple(Iterator<?>, boolean, Context) - Static method in class reactor.core.publisher.Operators: Invoke a (local or global) hook that processes elements that remains in an Iterator.
onDiscardQueueWithClear(Queue<T>, Context, Function<T, Stream<?>>) - Static method in class reactor.core.publisher.Operators: Invoke a (local or global) hook that processes elements that get discarded en masse after having been enqueued, due to cancellation or error.
onDispose(Disposable) - Method in interface reactor.core.publisher.FluxSink: Attach a Disposable as a callback for when this FluxSink is effectively disposed, that is it cannot be used anymore.
onDispose(Disposable) - Method in interface reactor.core.publisher.MonoSink: Attach a Disposable as a callback for when this MonoSink is effectively disposed, that is it cannot be used anymore.
one() - Static method in class reactor.util.concurrent.Queues
onEachOperator(Function<? super Publisher<Object>, ? extends Publisher<Object>>) - Static method in class reactor.core.publisher.Hooks: Add a Publisher operator interceptor for each operator created (Flux or Mono).
onEachOperator(String, Function<? super Publisher<Object>, ? extends Publisher<Object>>) - Static method in class reactor.core.publisher.Hooks: Add or replace a named Publisher operator interceptor for each operator created (Flux or Mono).
onError(Throwable) - Method in class reactor.core.publisher.BaseSubscriber
onError(Throwable) - Method in class reactor.core.publisher.DirectProcessor
onError(Throwable) - Method in class reactor.core.publisher.EmitterProcessor
onError(Throwable) - Method in class reactor.core.publisher.MonoProcessor
onError(Throwable) - Method in class reactor.core.publisher.Operators.MonoSubscriber
onError(Throwable) - Method in class reactor.core.publisher.ReplayProcessor
onError(Throwable) - Method in class reactor.core.publisher.UnicastProcessor
onErrorContinue(BiConsumer<Throwable, Object>) - Method in class reactor.core.publisher.Flux: Let compatible operators upstream recover from errors by dropping the incriminating element from the sequence and continuing with subsequent elements.
onErrorContinue(Class<E>, BiConsumer<Throwable, Object>) - Method in class reactor.core.publisher.Flux: Let compatible operators upstream recover from errors by dropping the incriminating element from the sequence and continuing with subsequent elements.
onErrorContinue(Predicate<E>, BiConsumer<Throwable, Object>) - Method in class reactor.core.publisher.Flux: Let compatible operators upstream recover from errors by dropping the incriminating element from the sequence and continuing with subsequent elements.
onErrorContinue(BiConsumer<Throwable, Object>) - Method in class reactor.core.publisher.Mono: Let compatible operators upstream recover from errors by dropping the incriminating element from the sequence and continuing with subsequent elements.
onErrorContinue(Class<E>, BiConsumer<Throwable, Object>) - Method in class reactor.core.publisher.Mono: Let compatible operators upstream recover from errors by dropping the incriminating element from the sequence and continuing with subsequent elements.
onErrorContinue(Predicate<E>, BiConsumer<Throwable, Object>) - Method in class reactor.core.publisher.Mono: Let compatible operators upstream recover from errors by dropping the incriminating element from the sequence and continuing with subsequent elements.
onErrorDropped(Consumer<? super Throwable>) - Static method in class reactor.core.publisher.Hooks: Override global error dropped strategy which by default bubble back the error.
onErrorDropped(Throwable, Context) - Static method in class reactor.core.publisher.Operators: An unexpected exception is about to be dropped.
onErrorMap(Function<? super Throwable, ? extends Throwable>) - Method in class reactor.core.publisher.Flux: Transform any error emitted by this Flux by synchronously applying a function to it.
onErrorMap(Class<E>, Function<? super E, ? extends Throwable>) - Method in class reactor.core.publisher.Flux: Transform an error emitted by this Flux by synchronously applying a function to it if the error matches the given type.
onErrorMap(Predicate<? super Throwable>, Function<? super Throwable, ? extends Throwable>) - Method in class reactor.core.publisher.Flux: Transform an error emitted by this Flux by synchronously applying a function to it if the error matches the given predicate.
onErrorMap(Predicate<? super Throwable>, Function<? super Throwable, ? extends Throwable>) - Method in class reactor.core.publisher.Mono: Transform an error emitted by this Mono by synchronously applying a function to it if the error matches the given predicate.
onErrorMap(Function<? super Throwable, ? extends Throwable>) - Method in class reactor.core.publisher.Mono: Transform any error emitted by this Mono by synchronously applying a function to it.
onErrorMap(Class<E>, Function<? super E, ? extends Throwable>) - Method in class reactor.core.publisher.Mono: Transform an error emitted by this Mono by synchronously applying a function to it if the error matches the given type.
onErrorResume(Function<? super Throwable, ? extends Publisher<? extends T>>) - Method in class reactor.core.publisher.Flux: Subscribe to a returned fallback publisher when any error occurs, using a function to choose the fallback depending on the error.
onErrorResume(Class<E>, Function<? super E, ? extends Publisher<? extends T>>) - Method in class reactor.core.publisher.Flux: Subscribe to a fallback publisher when an error matching the given type occurs, using a function to choose the fallback depending on the error.
onErrorResume(Predicate<? super Throwable>, Function<? super Throwable, ? extends Publisher<? extends T>>) - Method in class reactor.core.publisher.Flux: Subscribe to a fallback publisher when an error matching a given predicate occurs.
onErrorResume(Function<? super Throwable, ? extends Mono<? extends T>>) - Method in class reactor.core.publisher.Mono: Subscribe to a fallback publisher when any error occurs, using a function to choose the fallback depending on the error.
onErrorResume(Class<E>, Function<? super E, ? extends Mono<? extends T>>) - Method in class reactor.core.publisher.Mono: Subscribe to a fallback publisher when an error matching the given type occurs, using a function to choose the fallback depending on the error.
onErrorResume(Predicate<? super Throwable>, Function<? super Throwable, ? extends Mono<? extends T>>) - Method in class reactor.core.publisher.Mono: Subscribe to a fallback publisher when an error matching a given predicate occurs.
onErrorReturn(T) - Method in class reactor.core.publisher.Flux: Simply emit a captured fallback value when any error is observed on this Flux.
onErrorReturn(Class<E>, T) - Method in class reactor.core.publisher.Flux: Simply emit a captured fallback value when an error of the specified type is observed on this Flux.
onErrorReturn(Predicate<? super Throwable>, T) - Method in class reactor.core.publisher.Flux: Simply emit a captured fallback value when an error matching the given predicate is observed on this Flux.
onErrorReturn(T) - Method in class reactor.core.publisher.Mono: Simply emit a captured fallback value when any error is observed on this Mono.
onErrorReturn(Class<E>, T) - Method in class reactor.core.publisher.Mono: Simply emit a captured fallback value when an error of the specified type is observed on this Mono.
onErrorReturn(Predicate<? super Throwable>, T) - Method in class reactor.core.publisher.Mono: Simply emit a captured fallback value when an error matching the given predicate is observed on this Mono.
onErrorStop() - Method in class reactor.core.publisher.Flux: If an Flux.onErrorContinue(BiConsumer) variant has been used downstream, reverts to the default 'STOP' mode where errors are terminal events upstream.
onErrorStop() - Method in class reactor.core.publisher.Mono: If an Mono.onErrorContinue(BiConsumer) variant has been used downstream, reverts to the default 'STOP' mode where errors are terminal events upstream.
onHandleError(BiConsumer<Thread, ? super Throwable>) - Static method in class reactor.core.scheduler.Schedulers: Define a hook that is executed when a Scheduler has handled an error.
onLastAssembly(CorePublisher<T>) - Static method in class reactor.core.publisher.Operators: Applies the hooks registered with Hooks.onLastOperator(java.util.function.Function<? super org.reactivestreams.Publisher<java.lang.Object>, ? extends org.reactivestreams.Publisher<java.lang.Object>>) and returns CorePublisher ready to be subscribed on.
onLastOperator(Function<? super Publisher<Object>, ? extends Publisher<Object>>) - Static method in class reactor.core.publisher.Hooks: Add a Publisher operator interceptor for the last operator created in every flow (Flux or Mono).
onLastOperator(String, Function<? super Publisher<Object>, ? extends Publisher<Object>>) - Static method in class reactor.core.publisher.Hooks: Add or replace a named Publisher operator interceptor for the last operator created in every flow (Flux or Mono).
onNext(T) - Method in class reactor.core.publisher.BaseSubscriber
onNext(T) - Method in class reactor.core.publisher.DirectProcessor
onNext(T) - Method in class reactor.core.publisher.EmitterProcessor
onNext(O) - Method in class reactor.core.publisher.MonoProcessor
onNext(I) - Method in class reactor.core.publisher.Operators.MonoSubscriber
onNext(T) - Method in class reactor.core.publisher.ReplayProcessor
onNext(T) - Method in class reactor.core.publisher.UnicastProcessor
onNextDropped(Consumer<Object>) - Static method in class reactor.core.publisher.Hooks: Override global data dropped strategy which by default logs at DEBUG level.
onNextDropped(T, Context) - Static method in class reactor.core.publisher.Operators: An unexpected event is about to be dropped.
onNextDroppedFail() - Static method in class reactor.core.publisher.Hooks: Resets onNextDropped hook(s) and apply a strategy of throwing Exceptions.failWithCancel() instead.
onNextError(BiFunction<? super Throwable, Object, ? extends Throwable>) - Static method in class reactor.core.publisher.Hooks: Set the custom global error mode hook for operators that support resuming during an error in their Subscriber.onNext(Object).
onNextError(T, Throwable, Context, Subscription) - Static method in class reactor.core.publisher.Operators: Find the OnNextFailureStrategy to apply to the calling operator (which could be a local error mode defined in the Context) and apply it.
onNextError(T, Throwable, Context) - Static method in class reactor.core.publisher.Operators: Find the OnNextFailureStrategy to apply to the calling async operator (which could be a local error mode defined in the Context) and apply it.
onNextErrorFunction(Context) - Static method in class reactor.core.publisher.Operators
onNextInnerError(Throwable, Context, Subscription) - Static method in class reactor.core.publisher.Operators: Find the OnNextFailureStrategy to apply to the calling operator (which could be a local error mode defined in the Context) and apply it.
onNextPollError(T, Throwable, Context) - Static method in class reactor.core.publisher.Operators: Find the OnNextFailureStrategy to apply to the calling async operator (which could be a local error mode defined in the Context) and apply it.
onOperatorDebug() - Static method in class reactor.core.publisher.Hooks: Enable operator stack recorder that captures a declaration stack whenever an operator is instantiated.
onOperatorError(BiFunction<? super Throwable, Object, ? extends Throwable>) - Static method in class reactor.core.publisher.Hooks: Add a custom error mapping, overriding the default one.
onOperatorError(String, BiFunction<? super Throwable, Object, ? extends Throwable>) - Static method in class reactor.core.publisher.Hooks: Add or replace a named custom error mapping, overriding the default one.
onOperatorError(Throwable, Context) - Static method in class reactor.core.publisher.Operators: Map an "operator" error.
onOperatorError(Subscription, Throwable, Context) - Static method in class reactor.core.publisher.Operators: Map an "operator" error given an operator parent Subscription.
onOperatorError(Subscription, Throwable, Object, Context) - Static method in class reactor.core.publisher.Operators: Map an "operator" error given an operator parent Subscription.
onRejectedExecution(Throwable, Context) - Static method in class reactor.core.publisher.Operators: Return a wrapped RejectedExecutionException which can be thrown by the operator.
onRejectedExecution(Throwable, Subscription, Throwable, Object, Context) - Static method in class reactor.core.publisher.Operators: Return a wrapped RejectedExecutionException which can be thrown by the operator.
onRequest(LongConsumer) - Method in interface reactor.core.publisher.FluxSink: Attaches a LongConsumer to this FluxSink that will be notified of any request to this sink.
onRequest(LongConsumer) - Method in interface reactor.core.publisher.MonoSink: Attaches a LongConsumer to this MonoSink that will be notified of any request to this sink.
onRetryExhaustedThrow(BiFunction<RetryBackoffSpec, Retry.RetrySignal, Throwable>) - Method in class reactor.util.retry.RetryBackoffSpec: Set the generator for the Exception to be propagated when the maximum amount of retries is exhausted.
onRetryExhaustedThrow(BiFunction<RetrySpec, Retry.RetrySignal, Throwable>) - Method in class reactor.util.retry.RetrySpec: Set the generator for the Exception to be propagated when the maximum amount of retries is exhausted.
onSchedule(Runnable) - Static method in class reactor.core.scheduler.Schedulers: Applies the hooks registered with Schedulers.onScheduleHook(String, Function).
onScheduleHook(String, Function<Runnable, Runnable>) - Static method in class reactor.core.scheduler.Schedulers: Add or replace a named scheduling decorator.
onSubscribe(Subscription) - Method in interface reactor.core.CoreSubscriber: Implementors should initialize any state used by Subscriber.onNext(Object) before calling Subscription.request(long).
onSubscribe(Subscription) - Method in class reactor.core.publisher.BaseSubscriber
onSubscribe(Subscription) - Method in class reactor.core.publisher.DirectProcessor
onSubscribe(Subscription) - Method in class reactor.core.publisher.EmitterProcessor
onSubscribe(Subscription) - Method in class reactor.core.publisher.MonoProcessor
onSubscribe(Subscription) - Method in class reactor.core.publisher.Operators.MonoSubscriber
onSubscribe(Subscription) - Method in class reactor.core.publisher.ReplayProcessor
onSubscribe(Subscription) - Method in class reactor.core.publisher.UnicastProcessor
onTerminateDetach() - Method in class reactor.core.publisher.Flux: Detaches both the child Subscriber and the Subscription on termination or cancellation.
onTerminateDetach() - Method in class reactor.core.publisher.Mono: Detaches both the child Subscriber and the Subscription on termination or cancellation.
OPERATOR_NAME_UNRELATED_WORDS_PATTERN - Static variable in interface reactor.core.Scannable: The pattern for matching words unrelated to operator name.
Operators - Class in reactor.core.publisher: A helper to support "Operator" writing, handle noop subscriptions, validate request size and to cap concurrent additive operations to Long.MAX_VALUE, which is generic to Subscription.request(long) handling.
Operators.DeferredSubscription - Class in reactor.core.publisher: Base class for Subscribers that will receive their Subscriptions at any time, yet they might also need to be cancelled or requested at any time.
Operators.MonoSubscriber<I,O> - Class in reactor.core.publisher: A Subscriber/Subscription barrier that holds a single value at most and properly gates asynchronous behaviors resulting from concurrent request or cancel and onXXX signals.
or(Publisher<? extends T>) - Method in class reactor.core.publisher.Flux: Pick the first Publisher between this Flux and another publisher to emit any signal (onNext/onError/onComplete) and replay all signals from that Publisher, effectively behaving like the fastest of these competing sources.
or(Mono<? extends T>) - Method in class reactor.core.publisher.Mono: Emit the first available result from this mono or the other mono.
ordered(Comparator<? super T>) - Method in class reactor.core.publisher.ParallelFlux: Merges the values from each 'rail', but choose which one to merge by way of a provided Comparator, picking the smallest of all rails.
ordered(Comparator<? super T>, int) - Method in class reactor.core.publisher.ParallelFlux: Merges the values from each 'rail', but choose which one to merge by way of a provided Comparator, picking the smallest of all rails.

P

parallel() - Method in class reactor.core.publisher.Flux: Prepare this Flux by dividing data on a number of 'rails' matching the number of CPU cores, in a round-robin fashion.
parallel(int) - Method in class reactor.core.publisher.Flux: Prepare this Flux by dividing data on a number of 'rails' matching the provided parallelism parameter, in a round-robin fashion.
parallel(int, int) - Method in class reactor.core.publisher.Flux: Prepare this Flux by dividing data on a number of 'rails' matching the provided parallelism parameter, in a round-robin fashion and using a custom prefetch amount and queue for dealing with the source Flux's values.
parallel() - Static method in class reactor.core.scheduler.Schedulers: Scheduler that hosts a fixed pool of single-threaded ExecutorService-based workers and is suited for parallel work.
ParallelFlux<T> - Class in reactor.core.publisher: A ParallelFlux publishes to an array of Subscribers, in parallel 'rails' (or 'groups').
ParallelFlux() - Constructor for class reactor.core.publisher.ParallelFlux
parallelism() - Method in class reactor.core.publisher.ParallelFlux: Returns the number of expected parallel Subscribers.
PARENT - Static variable in class reactor.core.Scannable.Attr: Parent key exposes the direct upstream relationship of the scanned component.
parents() - Method in interface reactor.core.Scannable: Return a Stream navigating the Subscription chain (upward).
peek() - Method in interface reactor.core.Fuseable.QueueSubscription
peek() - Method in class reactor.core.publisher.MonoProcessor: Returns the value that completed this MonoProcessor.
poll() - Method in class reactor.core.publisher.Operators.MonoSubscriber
poll() - Method in class reactor.core.publisher.UnicastProcessor
PREFETCH - Static variable in class reactor.core.Scannable.Attr: Prefetch is an Integer attribute defining the rate of processing in a component which has capacity to request and hold a backlog of data.
produced(AtomicLongFieldUpdater<T>, T, long) - Static method in class reactor.core.publisher.Operators: Concurrent subtraction bound to 0, mostly used to decrement a request tracker by the amount produced by the operator.
propagate(Throwable) - Static method in class reactor.core.Exceptions: Prepare an unchecked RuntimeException that should be propagated downstream through Subscriber.onError(Throwable).
publish() - Method in class reactor.core.publisher.Flux: Prepare a ConnectableFlux which shares this Flux sequence and dispatches values to subscribers in a backpressure-aware manner.
publish(int) - Method in class reactor.core.publisher.Flux: Prepare a ConnectableFlux which shares this Flux sequence and dispatches values to subscribers in a backpressure-aware manner.
publish(Function<? super Flux<T>, ? extends Publisher<? extends R>>) - Method in class reactor.core.publisher.Flux: Shares a sequence for the duration of a function that may transform it and consume it as many times as necessary without causing multiple subscriptions to the upstream.
publish(Function<? super Flux<T>, ? extends Publisher<? extends R>>, int) - Method in class reactor.core.publisher.Flux: Shares a sequence for the duration of a function that may transform it and consume it as many times as necessary without causing multiple subscriptions to the upstream.
publish(Function<? super Mono<T>, ? extends Mono<? extends R>>) - Method in class reactor.core.publisher.Mono: Share a Mono for the duration of a function that may transform it and consume it as many times as necessary without causing multiple subscriptions to the upstream.
publisherToFlowPublisher(Publisher<T>) - Static method in class reactor.adapter.JdkFlowAdapter: Return a java Flow.Publisher from a Flux
publishNext() - Method in class reactor.core.publisher.Flux: Prepare a Mono which shares this Flux sequence and dispatches the first observed item to subscribers in a backpressure-aware manner.
publishOn(Scheduler) - Method in class reactor.core.publisher.Flux: Run onNext, onComplete and onError on a supplied Scheduler Worker.
publishOn(Scheduler, int) - Method in class reactor.core.publisher.Flux: Run onNext, onComplete and onError on a supplied Scheduler Scheduler.Worker.
publishOn(Scheduler, boolean, int) - Method in class reactor.core.publisher.Flux: Run onNext, onComplete and onError on a supplied Scheduler Scheduler.Worker.
publishOn(Scheduler) - Method in class reactor.core.publisher.Mono: Run onNext, onComplete and onError on a supplied Scheduler Worker.
push(Consumer<? super FluxSink<T>>) - Static method in class reactor.core.publisher.Flux: Programmatically create a Flux with the capability of emitting multiple elements from a single-threaded producer through the FluxSink API.
push(Consumer<? super FluxSink<T>>, FluxSink.OverflowStrategy) - Static method in class reactor.core.publisher.Flux: Programmatically create a Flux with the capability of emitting multiple elements from a single-threaded producer through the FluxSink API.
put(Object, Object) - Method in interface reactor.util.context.Context: Create a new Context that contains all current key/value pairs plus the given key/value pair.
putAll(Context) - Method in interface reactor.util.context.Context: Create a new Context by merging the content of this context and a given Context.
putNonNull(Object, Object) - Method in interface reactor.util.context.Context: Create a new Context that contains all current key/value pairs plus the given key/value pair only if the value is not null.

Q

Queues - Class in reactor.util.concurrent: Queue utilities and suppliers for 1-producer/1-consumer ready queues adapted for various given capacities.

R

range(int, int) - Static method in class reactor.core.publisher.Flux: Build a Flux that will only emit a sequence of count incrementing integers, starting from start.
reactor.adapter - package reactor.adapter: Adapt Publisher to Java 9+ Flow.Publisher.
reactor.core - package reactor.core: Core components of the framework supporting extensions to the Reactive Stream programming model.
reactor.core.publisher - package reactor.core.publisher: Provide for Flux, Mono composition API and Processor implementations
reactor.core.scheduler - package reactor.core.scheduler: Scheduler contract and static registry and factory methods in Schedulers.
reactor.util - package reactor.util: Miscellaneous utility classes, such as loggers, tuples or queue suppliers and implementations.
reactor.util.annotation - package reactor.util.annotation
reactor.util.concurrent - package reactor.util.concurrent: Queue suppliers and utilities Used for operational serialization (serializing threads) or buffering (asynchronous boundary).
reactor.util.context - package reactor.util.context: Miscellaneous utility classes, such as loggers, tuples or queue suppliers and implementations.
reactor.util.function - package reactor.util.function: Tuples provide a type-safe way to specify multiple parameters.
reactor.util.retry - package reactor.util.retry
reduce(BiFunction<T, T, T>) - Method in class reactor.core.publisher.Flux: Reduce the values from this Flux sequence into a single object of the same type than the emitted items.
reduce(A, BiFunction<A, ? super T, A>) - Method in class reactor.core.publisher.Flux: Reduce the values from this Flux sequence into a single object matching the type of a seed value.
reduce(BiFunction<T, T, T>) - Method in class reactor.core.publisher.ParallelFlux: Reduces all values within a 'rail' and across 'rails' with a reducer function into a single sequential value.
reduce(Supplier<R>, BiFunction<R, ? super T, R>) - Method in class reactor.core.publisher.ParallelFlux: Reduces all values within a 'rail' to a single value (with a possibly different type) via a reducer function that is initialized on each rail from an initialSupplier value.
reduceWith(Supplier<A>, BiFunction<A, ? super T, A>) - Method in class reactor.core.publisher.Flux: Reduce the values from this Flux sequence into a single object matching the type of a lazily supplied seed value.
refCount() - Method in class reactor.core.publisher.ConnectableFlux: Connects to the upstream source when the first Subscriber subscribes and disconnects when all Subscribers cancelled or the upstream source completed.
refCount(int) - Method in class reactor.core.publisher.ConnectableFlux: Connects to the upstream source when the given number of Subscriber subscribes and disconnects when all Subscribers cancelled or the upstream source completed.
refCount(int, Duration) - Method in class reactor.core.publisher.ConnectableFlux: Connects to the upstream source when the given number of Subscriber subscribes.
refCount(int, Duration, Scheduler) - Method in class reactor.core.publisher.ConnectableFlux: Connects to the upstream source when the given number of Subscriber subscribes.
remove(Disposable) - Method in interface reactor.core.Disposable.Composite: Delete the Disposable from this container, without disposing it.
remove() - Method in interface reactor.core.Fuseable.QueueSubscription
remove(Object) - Method in interface reactor.core.Fuseable.QueueSubscription
removeAll(Collection<?>) - Method in interface reactor.core.Fuseable.QueueSubscription
removeExecutorServiceDecorator(String) - Static method in class reactor.core.scheduler.Schedulers: Remove an existing ScheduledExecutorService decorator if it has been set up via Schedulers.addExecutorServiceDecorator(String, BiFunction).
repeat() - Method in class reactor.core.publisher.Flux: Repeatedly and indefinitely subscribe to the source upon completion of the previous subscription.
repeat(BooleanSupplier) - Method in class reactor.core.publisher.Flux: Repeatedly subscribe to the source if the predicate returns true after completion of the previous subscription.
repeat(long) - Method in class reactor.core.publisher.Flux: Repeatedly subscribe to the source numRepeat times.
repeat(long, BooleanSupplier) - Method in class reactor.core.publisher.Flux: Repeatedly subscribe to the source if the predicate returns true after completion of the previous subscription.
repeat() - Method in class reactor.core.publisher.Mono: Repeatedly and indefinitely subscribe to the source upon completion of the previous subscription.
repeat(BooleanSupplier) - Method in class reactor.core.publisher.Mono: Repeatedly subscribe to the source if the predicate returns true after completion of the previous subscription.
repeat(long) - Method in class reactor.core.publisher.Mono: Repeatedly subscribe to the source numRepeat times.
repeat(long, BooleanSupplier) - Method in class reactor.core.publisher.Mono: Repeatedly subscribe to the source if the predicate returns true after completion of the previous subscription.
repeatWhen(Function<Flux<Long>, ? extends Publisher<?>>) - Method in class reactor.core.publisher.Flux: Repeatedly subscribe to this Flux when a companion sequence emits elements in response to the flux completion signal.
repeatWhen(Function<Flux<Long>, ? extends Publisher<?>>) - Method in class reactor.core.publisher.Mono: Repeatedly subscribe to this Mono when a companion sequence emits elements in response to the flux completion signal.
repeatWhenEmpty(Function<Flux<Long>, ? extends Publisher<?>>) - Method in class reactor.core.publisher.Mono: Repeatedly subscribe to this Mono as long as the current subscription to this Mono completes empty and the companion Publisher produces an onNext signal.
repeatWhenEmpty(int, Function<Flux<Long>, ? extends Publisher<?>>) - Method in class reactor.core.publisher.Mono: Repeatedly subscribe to this Mono as long as the current subscription to this Mono completes empty and the companion Publisher produces an onNext signal.
replace(Disposable) - Method in interface reactor.core.Disposable.Swap: Atomically set the next Disposable on this container but don't dispose the previous one (if any).
replace(AtomicReferenceFieldUpdater<F, Subscription>, F, Subscription) - Static method in class reactor.core.publisher.Operators: A generic utility to atomically replace a subscription or cancel the replacement if the current subscription is marked as already cancelled (as in Operators.cancelledSubscription()).
replay() - Method in class reactor.core.publisher.Flux: Turn this Flux into a hot source and cache last emitted signals for further Subscriber.
replay(int) - Method in class reactor.core.publisher.Flux: Turn this Flux into a connectable hot source and cache last emitted signals for further Subscriber.
replay(Duration) - Method in class reactor.core.publisher.Flux: Turn this Flux into a connectable hot source and cache last emitted signals for further Subscriber.
replay(int, Duration) - Method in class reactor.core.publisher.Flux: Turn this Flux into a connectable hot source and cache last emitted signals for further Subscriber.
replay(Duration, Scheduler) - Method in class reactor.core.publisher.Flux: Turn this Flux into a connectable hot source and cache last emitted signals for further Subscriber.
replay(int, Duration, Scheduler) - Method in class reactor.core.publisher.Flux: Turn this Flux into a connectable hot source and cache last emitted signals for further Subscriber.
ReplayProcessor<T> - Class in reactor.core.publisher: Replays all or the last N items to Subscribers.
reportBadRequest(long) - Static method in class reactor.core.publisher.Operators: Log an IllegalArgumentException if the request is null or negative.
reportMoreProduced() - Static method in class reactor.core.publisher.Operators: Log an IllegalStateException that indicates more than the requested amount was produced.
reportSubscriptionSet() - Static method in class reactor.core.publisher.Operators: Log a duplicate subscription error.
reportThrowInSubscribe(CoreSubscriber<?>, Throwable) - Static method in class reactor.core.publisher.Operators
request(long) - Method in class reactor.core.publisher.BaseSubscriber
request(long) - Method in class reactor.core.publisher.MonoProcessor
request(long) - Method in class reactor.core.publisher.Operators.DeferredSubscription
request(long) - Method in class reactor.core.publisher.Operators.MonoSubscriber
request(long) - Method in class reactor.core.publisher.UnicastProcessor
REQUESTED_FROM_DOWNSTREAM - Static variable in class reactor.core.Scannable.Attr: A Long attribute exposing the current pending demand of a downstream component.
requestedFromDownstream() - Method in interface reactor.core.publisher.FluxSink: The current outstanding request amount.
requestFusion(int) - Method in interface reactor.core.Fuseable.QueueSubscription: Request a specific fusion mode from this QueueSubscription.
requestFusion(int) - Method in interface reactor.core.Fuseable.SynchronousSubscription
requestFusion(int) - Method in class reactor.core.publisher.Operators.MonoSubscriber
requestFusion(int) - Method in class reactor.core.publisher.UnicastProcessor
requestUnbounded() - Method in class reactor.core.publisher.BaseSubscriber: Request an unbounded amount.
resetFactory() - Static method in class reactor.core.scheduler.Schedulers: Re-apply default factory to Schedulers
resetLoggerFactory() - Static method in class reactor.util.Loggers: Attempt to activate the best reactor Logger factory, by first attempting to use the SLF4J one, then falling back to either Console logging or java.util.logging.Logger).
resetOnEachOperator(String) - Static method in class reactor.core.publisher.Hooks: Remove the sub-hook with key key from the onEachOperator hook.
resetOnEachOperator() - Static method in class reactor.core.publisher.Hooks: Reset global "assembly" hook tracking
resetOnErrorDropped() - Static method in class reactor.core.publisher.Hooks: Reset global error dropped strategy to bubbling back the error.
resetOnHandleError() - Static method in class reactor.core.scheduler.Schedulers: Reset the Schedulers.onHandleError(BiConsumer) hook to the default no-op behavior.
resetOnLastOperator(String) - Static method in class reactor.core.publisher.Hooks: Remove the sub-hook with key key from the onLastOperator hook.
resetOnLastOperator() - Static method in class reactor.core.publisher.Hooks: Reset global "subscriber" hook tracking
resetOnNextDropped() - Static method in class reactor.core.publisher.Hooks: Reset global data dropped strategy to throwing via Exceptions.failWithCancel()
resetOnNextError() - Static method in class reactor.core.publisher.Hooks: Reset global onNext error handling strategy to terminating the sequence with an onError and cancelling upstream (OnNextFailureStrategy.STOP).
resetOnOperatorDebug() - Static method in class reactor.core.publisher.Hooks: Reset global operator debug.
resetOnOperatorError(String) - Static method in class reactor.core.publisher.Hooks: Remove the sub-hook with key key from the onOperatorError hook.
resetOnOperatorError() - Static method in class reactor.core.publisher.Hooks: Reset global operator error mapping to the default behavior.
resetOnScheduleHook(String) - Static method in class reactor.core.scheduler.Schedulers: Reset a specific onScheduleHook sub-hook if it has been set up via Schedulers.onScheduleHook(String, Function).
resetOnScheduleHooks() - Static method in class reactor.core.scheduler.Schedulers: Remove all onScheduleHook sub-hooks.
retainAll(Collection<?>) - Method in interface reactor.core.Fuseable.QueueSubscription
retry() - Method in class reactor.core.publisher.Flux: Re-subscribes to this Flux sequence if it signals any error, indefinitely.
retry(long) - Method in class reactor.core.publisher.Flux: Re-subscribes to this Flux sequence if it signals any error, for a fixed number of times.
retry() - Method in class reactor.core.publisher.Mono: Re-subscribes to this Mono sequence if it signals any error, indefinitely.
retry(long) - Method in class reactor.core.publisher.Mono: Re-subscribes to this Mono sequence if it signals any error, for a fixed number of times.
Retry - Class in reactor.util.retry: Base abstract class for a strategy to decide when to retry given a companion Flux of Retry.RetrySignal, for use with Flux.retryWhen(Retry) and Mono.retryWhen(Retry).
Retry() - Constructor for class reactor.util.retry.Retry
Retry.RetrySignal - Interface in reactor.util.retry: State for a Flux.retryWhen(Retry) Flux retry} or Mono retry.
RetryBackoffSpec - Class in reactor.util.retry: A Retry strategy based on exponential backoffs, with configurable features.
retryExhausted(String, Throwable) - Static method in class reactor.core.Exceptions: Return a new RuntimeException that represents too many failures on retry.
RetrySpec - Class in reactor.util.retry: A simple count-based Retry strategy with configurable features.
retryWhen(Retry) - Method in class reactor.core.publisher.Flux: Retries this Flux in response to signals emitted by a companion Publisher.
retryWhen(Retry) - Method in class reactor.core.publisher.Mono: Retries this Mono in response to signals emitted by a companion Publisher.
RUN_ON - Static variable in class reactor.core.Scannable.Attr: A key that links a Scannable to another Scannable it runs on.
runOn(Scheduler) - Method in class reactor.core.publisher.ParallelFlux: Specifies where each 'rail' will observe its incoming values with no work-stealing and default prefetch amount.
runOn(Scheduler, int) - Method in class reactor.core.publisher.ParallelFlux: Specifies where each 'rail' will observe its incoming values with possibly work-stealing and a given prefetch amount.

S

sample(Duration) - Method in class reactor.core.publisher.Flux: Sample this Flux by periodically emitting an item corresponding to that Flux latest emitted value within the periodical time window.
sample(Publisher) - Method in class reactor.core.publisher.Flux: Sample this Flux by emitting an item corresponding to that Flux latest emitted value whenever a companion sampler Publisher signals a value.
sampleFirst(Duration) - Method in class reactor.core.publisher.Flux: Repeatedly take a value from this Flux then skip the values that follow within a given duration.
sampleFirst(Function<? super T, ? extends Publisher>) - Method in class reactor.core.publisher.Flux: Repeatedly take a value from this Flux then skip the values that follow before the next signal from a companion sampler Publisher.
sampleTimeout(Function<? super T, ? extends Publisher>) - Method in class reactor.core.publisher.Flux: Emit the latest value from this Flux only if there were no new values emitted during the window defined by a companion Publisher derived from that particular value.
sampleTimeout(Function<? super T, ? extends Publisher>, int) - Method in class reactor.core.publisher.Flux: Emit the latest value from this Flux only if there were no new values emitted during the window defined by a companion Publisher derived from that particular value.
scalarSubscription(CoreSubscriber<? super T>, T) - Static method in class reactor.core.publisher.Operators: Represents a fuseable Subscription that emits a single constant value synchronously to a Subscriber or consumer.
scan(BiFunction<T, T, T>) - Method in class reactor.core.publisher.Flux: Reduce this Flux values with an accumulator BiFunction and also emit the intermediate results of this function.
scan(A, BiFunction<A, ? super T, A>) - Method in class reactor.core.publisher.Flux: Reduce this Flux values with an accumulator BiFunction and also emit the intermediate results of this function.
scan(Scannable.Attr<T>) - Method in interface reactor.core.Scannable: 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.
Scannable - Interface in reactor.core: A Scannable component exposes state in a non strictly memory consistent way and results should be understood as best-effort hint of the underlying state.
Scannable.Attr<T> - Class in reactor.core: Base class for Scannable attributes, which all can define a meaningful default.
scanOrDefault(Scannable.Attr<T>, T) - Method in interface reactor.core.Scannable: Introspect a component's specific state attribute.
scanUnsafe(Scannable.Attr) - Method in class reactor.core.publisher.EmitterProcessor
scanUnsafe(Scannable.Attr) - Method in class reactor.core.publisher.FluxOperator
scanUnsafe(Scannable.Attr) - Method in class reactor.core.publisher.FluxProcessor
scanUnsafe(Scannable.Attr) - Method in class reactor.core.publisher.MonoOperator
scanUnsafe(Scannable.Attr) - Method in class reactor.core.publisher.MonoProcessor
scanUnsafe(Scannable.Attr) - Method in class reactor.core.publisher.Operators.DeferredSubscription
scanUnsafe(Scannable.Attr) - Method in class reactor.core.publisher.Operators.MonoSubscriber
scanUnsafe(Scannable.Attr) - Method in class reactor.core.publisher.ReplayProcessor
scanUnsafe(Scannable.Attr) - Method in class reactor.core.publisher.UnicastProcessor
scanUnsafe(Scannable.Attr) - Method in interface reactor.core.Scannable: This method is used internally by components to define their key-value mappings in a single place.
scanWith(Supplier<A>, BiFunction<A, ? super T, A>) - Method in class reactor.core.publisher.Flux: Reduce this Flux values with the help of an accumulator BiFunction and also emits the intermediate results.
schedule(Runnable) - Method in interface reactor.core.scheduler.Scheduler: Schedules the non-delayed execution of the given task on this scheduler.
schedule(Runnable, long, TimeUnit) - Method in interface reactor.core.scheduler.Scheduler: Schedules the execution of the given task with the given delay amount.
schedule(Runnable) - Method in interface reactor.core.scheduler.Scheduler.Worker: Schedules the task for immediate execution on this worker.
schedule(Runnable, long, TimeUnit) - Method in interface reactor.core.scheduler.Scheduler.Worker: Schedules the execution of the given task with the given delay amount.
schedulePeriodically(Runnable, long, long, TimeUnit) - Method in interface reactor.core.scheduler.Scheduler: Schedules a periodic execution of the given task with the given initial delay and period.
schedulePeriodically(Runnable, long, long, TimeUnit) - Method in interface reactor.core.scheduler.Scheduler.Worker: Schedules a periodic execution of the given task with the given initial delay and period.
Scheduler - Interface in reactor.core.scheduler: Provides an abstract asynchronous boundary to operators.
scheduler(Scheduler) - Method in class reactor.util.retry.RetryBackoffSpec: Set a Scheduler on which to execute the delays computed by the exponential backoff strategy.
Scheduler.Worker - Interface in reactor.core.scheduler: A worker representing an asynchronous boundary that executes tasks.
Schedulers - Class in reactor.core.scheduler: Schedulers provides various Scheduler flavors usable by publishOn or subscribeOn :
Schedulers() - Constructor for class reactor.core.scheduler.Schedulers
Schedulers.Factory - Interface in reactor.core.scheduler: Public factory hook to override Schedulers behavior globally
sequenceEqual(Publisher<? extends T>, Publisher<? extends T>) - Static method in class reactor.core.publisher.Mono: Returns a Mono that emits a Boolean value that indicates whether two Publisher sequences are the same by comparing the items emitted by each Publisher pairwise.
sequenceEqual(Publisher<? extends T>, Publisher<? extends T>, BiPredicate<? super T, ? super T>) - Static method in class reactor.core.publisher.Mono: Returns a Mono that emits a Boolean value that indicates whether two Publisher sequences are the same by comparing the items emitted by each Publisher pairwise based on the results of a specified equality function.
sequenceEqual(Publisher<? extends T>, Publisher<? extends T>, BiPredicate<? super T, ? super T>, int) - Static method in class reactor.core.publisher.Mono: Returns a Mono that emits a Boolean value that indicates whether two Publisher sequences are the same by comparing the items emitted by each Publisher pairwise based on the results of a specified equality function.
sequential() - Method in class reactor.core.publisher.ParallelFlux: Merges the values from each 'rail' in a round-robin or same-order fashion and exposes it as a regular Publisher sequence, running with a default prefetch value for the rails.
sequential(int) - Method in class reactor.core.publisher.ParallelFlux: Merges the values from each 'rail' in a round-robin or same-order fashion and exposes it as a regular Publisher sequence, running with a give prefetch value for the rails.
serialize() - Method in class reactor.core.publisher.FluxProcessor: Create a FluxProcessor that safely gates multi-threaded producer Subscriber.onNext(Object).
serialize(CoreSubscriber<? super T>) - Static method in class reactor.core.publisher.Operators: Safely gate a Subscriber by making sure onNext signals are delivered sequentially (serialized).
serializeAlways() - Method in class reactor.core.publisher.FluxProcessor: Returns serialization strategy.
set(Subscription) - Method in class reactor.core.publisher.Operators.DeferredSubscription: Atomically sets the single subscription and requests the missed amount from it.
set(AtomicReferenceFieldUpdater<F, Subscription>, F, Subscription) - Static method in class reactor.core.publisher.Operators: A generic utility to atomically replace a subscription or cancel the replacement if current subscription is marked as cancelled (as in Operators.cancelledSubscription()) or was concurrently updated before.
setExecutorServiceDecorator(String, BiFunction<Scheduler, ScheduledExecutorService, ScheduledExecutorService>) - Static method in class reactor.core.scheduler.Schedulers: Set up an additional ScheduledExecutorService decorator for a given key, even if that key is already present.
setFactory(Schedulers.Factory) - Static method in class reactor.core.scheduler.Schedulers: Replace Schedulers factories (newParallel, newSingle and newElastic).
setOnce(AtomicReferenceFieldUpdater<F, Subscription>, F, Subscription) - Static method in class reactor.core.publisher.Operators: Sets the given subscription once and returns true if successful, false if the field has a subscription already or has been cancelled.
setValue(O) - Method in class reactor.core.publisher.Operators.MonoSubscriber: Set the value internally, without impacting request tracking state.
share() - Method in class reactor.core.publisher.Flux: Returns a new Flux that multicasts (shares) the original Flux.
shutdownNow() - Static method in class reactor.core.scheduler.Schedulers: Clear any cached Scheduler and call dispose on them.
Signal<T> - Interface in reactor.core.publisher: A domain representation of a Reactive Stream signal.
SignalType - Enum in reactor.core.publisher: Reactive Stream signal types
single() - Static method in class reactor.core.Disposables: Return a new simple Disposable instance that is initially not disposed but can be by calling Disposable.dispose().
single() - Method in class reactor.core.publisher.Flux: Expect and emit a single item from this Flux source or signal NoSuchElementException for an empty source, or IndexOutOfBoundsException for a source with more than one element.
single(T) - Method in class reactor.core.publisher.Flux: Expect and emit a single item from this Flux source and emit a default value for an empty source, but signal an IndexOutOfBoundsException for a source with more than one element.
single() - Method in class reactor.core.publisher.Mono: Expect exactly one item from this Mono source or signal NoSuchElementException for an empty source.
single() - Static method in class reactor.core.scheduler.Schedulers: Scheduler that hosts a single-threaded ExecutorService-based worker and is suited for parallel work.
single(Scheduler) - Static method in class reactor.core.scheduler.Schedulers: Wraps a single Scheduler.Worker from some other Scheduler and provides Scheduler.Worker services on top of it.
singleOrEmpty() - Method in class reactor.core.publisher.Flux: Expect and emit a single item from this Flux source, and accept an empty source but signal an IndexOutOfBoundsException for a source with more than one element.
sink() - Method in class reactor.core.publisher.FluxProcessor: Create a FluxSink that safely gates multi-threaded producer Subscriber.onNext(Object).
sink(FluxSink.OverflowStrategy) - Method in class reactor.core.publisher.FluxProcessor: Create a FluxSink that safely gates multi-threaded producer Subscriber.onNext(Object).
size() - Method in interface reactor.core.Disposable.Composite: Returns the number of currently held Disposables.
size() - Method in class reactor.core.publisher.Operators.MonoSubscriber
size() - Method in class reactor.core.publisher.UnicastProcessor
size() - Method in interface reactor.util.context.Context: Return the size of this Context, the number of immutable key/value pairs stored inside it.
size() - Method in class reactor.util.function.Tuple2: Return the number of elements in this Tuples.
size() - Method in class reactor.util.function.Tuple3
size() - Method in class reactor.util.function.Tuple4
size() - Method in class reactor.util.function.Tuple5
size() - Method in class reactor.util.function.Tuple6
size() - Method in class reactor.util.function.Tuple7
size() - Method in class reactor.util.function.Tuple8
skip(long) - Method in class reactor.core.publisher.Flux: Skip the specified number of elements from the beginning of this Flux then emit the remaining elements.
skip(Duration) - Method in class reactor.core.publisher.Flux: Skip elements from this Flux emitted within the specified initial duration.
skip(Duration, Scheduler) - Method in class reactor.core.publisher.Flux: Skip elements from this Flux emitted within the specified initial duration, as measured on the provided Scheduler.
skipLast(int) - Method in class reactor.core.publisher.Flux: Skip a specified number of elements at the end of this Flux sequence.
skipUntil(Predicate<? super T>) - Method in class reactor.core.publisher.Flux: Skips values from this Flux until a Predicate returns true for the value.
skipUntilOther(Publisher<?>) - Method in class reactor.core.publisher.Flux: Skip values from this Flux until a specified Publisher signals an onNext or onComplete.
skipWhile(Predicate<? super T>) - Method in class reactor.core.publisher.Flux: Skips values from this Flux while a Predicate returns true for the value.
small() - Static method in class reactor.util.concurrent.Queues
SMALL_BUFFER_SIZE - Static variable in class reactor.util.concurrent.Queues: A small default of available slots in a given container, compromise between intensive pipelines, small subscribers numbers and memory use.
sort() - Method in class reactor.core.publisher.Flux: Sort elements from this Flux by collecting and sorting them in the background then emitting the sorted sequence once this sequence completes.
sort(Comparator<? super T>) - Method in class reactor.core.publisher.Flux: Sort elements from this Flux using a Comparator function, by collecting and sorting elements in the background then emitting the sorted sequence once this sequence completes.
sorted(Comparator<? super T>) - Method in class reactor.core.publisher.ParallelFlux: Sorts the 'rails' of this ParallelFlux and returns a Publisher that sequentially picks the smallest next value from the rails.
sorted(Comparator<? super T>, int) - Method in class reactor.core.publisher.ParallelFlux: Sorts the 'rails' of this ParallelFlux and returns a Publisher that sequentially picks the smallest next value from the rails.
source - Variable in class reactor.core.publisher.FluxOperator
source - Variable in class reactor.core.publisher.MonoOperator
start() - Method in interface reactor.core.scheduler.Scheduler: Instructs this Scheduler to prepare itself for running tasks directly or through its Workers.
startWith(Iterable<? extends T>) - Method in class reactor.core.publisher.Flux: Prepend the given Iterable before this Flux sequence.
startWith(T...) - Method in class reactor.core.publisher.Flux: Prepend the given values before this Flux sequence.
startWith(Publisher<? extends T>) - Method in class reactor.core.publisher.Flux: Prepend the given Publisher sequence to this Flux sequence.
stepName() - Method in interface reactor.core.Scannable: Return a meaningful String representation of this Scannable in its chain of Scannable.parents() and Scannable.actuals().
steps() - Method in interface reactor.core.Scannable: List the step names in the chain of Scannable (including the current element), in their assembly order.
stream() - Method in interface reactor.util.context.Context: Stream key/value pairs from this Context
subOrZero(long, long) - Static method in class reactor.core.publisher.Operators: Cap a subtraction to 0
subscribe(CoreSubscriber<? super T>) - Method in interface reactor.core.CorePublisher: An internal Publisher.subscribe(Subscriber) that will bypass Hooks.onLastOperator(Function) pointcut.
subscribe(CoreSubscriber<? super T>) - Method in class reactor.core.publisher.DirectProcessor
subscribe(CoreSubscriber<? super T>) - Method in class reactor.core.publisher.EmitterProcessor
subscribe() - Method in class reactor.core.publisher.Flux: Subscribe to this Flux and request unbounded demand.
subscribe(Consumer<? super T>) - Method in class reactor.core.publisher.Flux: Subscribe a Consumer to this Flux that will consume all the elements in the sequence.
subscribe(Consumer<? super T>, Consumer<? super Throwable>) - Method in class reactor.core.publisher.Flux: 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.
subscribe(Consumer<? super T>, Consumer<? super Throwable>, Runnable) - Method in class reactor.core.publisher.Flux: Subscribe Consumer to this Flux that will respectively consume all the elements in the sequence, handle errors and react to completion.
subscribe(Consumer<? super T>, Consumer<? super Throwable>, Runnable, Consumer<? super Subscription>) - Method in class reactor.core.publisher.Flux: Subscribe Consumer to this Flux that will respectively consume all the elements in the sequence, handle errors, react to completion, and request upon subscription.
subscribe(Consumer<? super T>, Consumer<? super Throwable>, Runnable, Context) - Method in class reactor.core.publisher.Flux: Subscribe Consumer to this Flux that will respectively consume all the elements in the sequence, handle errors and react to completion.
subscribe(Subscriber<? super T>) - Method in class reactor.core.publisher.Flux
subscribe(CoreSubscriber<? super T>) - Method in class reactor.core.publisher.Flux: An internal Publisher.subscribe(Subscriber) that will bypass Hooks.onLastOperator(Function) pointcut.
subscribe() - Method in class reactor.core.publisher.Mono: Subscribe to this Mono and request unbounded demand.
subscribe(Consumer<? super T>) - Method in class reactor.core.publisher.Mono: Subscribe a Consumer to this Mono that will consume all the sequence.
subscribe(Consumer<? super T>, Consumer<? super Throwable>) - Method in class reactor.core.publisher.Mono: 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.
subscribe(Consumer<? super T>, Consumer<? super Throwable>, Runnable) - Method in class reactor.core.publisher.Mono: Subscribe Consumer to this Mono that will respectively consume all the elements in the sequence, handle errors and react to completion.
subscribe(Consumer<? super T>, Consumer<? super Throwable>, Runnable, Consumer<? super Subscription>) - Method in class reactor.core.publisher.Mono: Subscribe Consumer to this Mono that will respectively consume all the elements in the sequence, handle errors, react to completion, and request upon subscription.
subscribe(Consumer<? super T>, Consumer<? super Throwable>, Runnable, Context) - Method in class reactor.core.publisher.Mono: Subscribe Consumer to this Mono that will respectively consume all the elements in the sequence, handle errors and react to completion.
subscribe(Subscriber<? super T>) - Method in class reactor.core.publisher.Mono
subscribe(CoreSubscriber<? super T>) - Method in class reactor.core.publisher.Mono: An internal Publisher.subscribe(Subscriber) that will bypass Hooks.onLastOperator(Function) pointcut.
subscribe(CoreSubscriber<? super O>) - Method in class reactor.core.publisher.MonoProcessor
subscribe(CoreSubscriber<? super T>[]) - Method in class reactor.core.publisher.ParallelFlux: Subscribes an array of Subscribers to this ParallelFlux and triggers the execution chain for all 'rails'.
subscribe() - Method in class reactor.core.publisher.ParallelFlux: Subscribes to this ParallelFlux and triggers the execution chain for all 'rails'.
subscribe(Consumer<? super T>) - Method in class reactor.core.publisher.ParallelFlux: Subscribes to this ParallelFlux by providing an onNext callback and triggers the execution chain for all 'rails'.
subscribe(Consumer<? super T>, Consumer<? super Throwable>) - Method in class reactor.core.publisher.ParallelFlux: Subscribes to this ParallelFlux by providing an onNext and onError callback and triggers the execution chain for all 'rails'.
subscribe(Consumer<? super T>, Consumer<? super Throwable>, Runnable) - Method in class reactor.core.publisher.ParallelFlux: Subscribes to this ParallelFlux by providing an onNext, onError and onComplete callback and triggers the execution chain for all 'rails'.
subscribe(CoreSubscriber<? super T>) - Method in class reactor.core.publisher.ParallelFlux
subscribe(Consumer<? super T>, Consumer<? super Throwable>, Runnable, Consumer<? super Subscription>) - Method in class reactor.core.publisher.ParallelFlux: Subscribes to this ParallelFlux by providing an onNext, onError, onComplete and onSubscribe callback and triggers the execution chain for all 'rails'.
subscribe(Subscriber<? super T>) - Method in class reactor.core.publisher.ParallelFlux: Merge the rails into a ParallelFlux.sequential() Flux and subscribe to said Flux.
subscribe(CoreSubscriber<? super T>) - Method in class reactor.core.publisher.ReplayProcessor
subscribe(Subscription) - Static method in interface reactor.core.publisher.Signal: Creates and returns a Signal of variety Type.ON_SUBSCRIBE.
subscribe(Subscription, Context) - Static method in interface reactor.core.publisher.Signal: Creates and returns a Signal of variety Type.ON_SUBSCRIBE, that holds the Context associated with the subscribed source.
subscribe(CoreSubscriber<? super T>) - Method in class reactor.core.publisher.UnicastProcessor
subscribeOn(Scheduler) - Method in class reactor.core.publisher.Flux: Run subscribe, onSubscribe and request on a specified Scheduler's Scheduler.Worker.
subscribeOn(Scheduler, boolean) - Method in class reactor.core.publisher.Flux: Run subscribe and onSubscribe on a specified Scheduler's Scheduler.Worker.
subscribeOn(Scheduler) - Method in class reactor.core.publisher.Mono: Run subscribe, onSubscribe and request on a specified Scheduler's Scheduler.Worker.
subscriberContext(Context) - Method in class reactor.core.publisher.Flux: Enrich a potentially empty downstream Context by adding all values from the given Context, producing a new Context that is propagated upstream.
subscriberContext(Function<Context, Context>) - Method in class reactor.core.publisher.Flux: Enrich a potentially empty downstream Context by applying a Function to it, producing a new Context that is propagated upstream.
subscriberContext() - Static method in class reactor.core.publisher.Mono: Create a Mono emitting the Context available on subscribe.
subscriberContext(Context) - Method in class reactor.core.publisher.Mono: Enrich a potentially empty downstream Context by adding all values from the given Context, producing a new Context that is propagated upstream.
subscriberContext(Function<Context, Context>) - Method in class reactor.core.publisher.Mono: Enrich a potentially empty downstream Context by applying a Function to it, producing a new Context that is propagated upstream.
subscribeWith(E) - Method in class reactor.core.publisher.Flux: Subscribe the given Subscriber to this Flux and return said Subscriber (eg.
subscribeWith(E) - Method in class reactor.core.publisher.Mono: Subscribe the given Subscriber to this Mono and return said Subscriber (eg.
success() - Method in interface reactor.core.publisher.MonoSink: Complete without any value.
success(T) - Method in interface reactor.core.publisher.MonoSink: Complete with the given value.
swap() - Static method in class reactor.core.Disposables: Create a new empty Disposable.Swap with atomic guarantees on all mutative operations.
switchIfEmpty(Publisher<? extends T>) - Method in class reactor.core.publisher.Flux: Switch to an alternative Publisher if this sequence is completed without any data.
switchIfEmpty(Mono<? extends T>) - Method in class reactor.core.publisher.Mono: Fallback to an alternative Mono if this mono is completed without data
switchMap(Function<? super T, Publisher<? extends V>>) - Method in class reactor.core.publisher.Flux: Switch to a new Publisher generated via a Function whenever this Flux produces an item.
switchMap(Function<? super T, Publisher<? extends V>>, int) - Method in class reactor.core.publisher.Flux: Switch to a new Publisher generated via a Function whenever this Flux produces an item.
switchOnFirst(BiFunction<Signal<? extends T>, Flux<T>, Publisher<? extends V>>) - Method in class reactor.core.publisher.Flux: Transform the current Flux once it emits its first element, making a conditional transformation possible.
switchOnFirst(BiFunction<Signal<? extends T>, Flux<T>, Publisher<? extends V>>, boolean) - Method in class reactor.core.publisher.Flux: Transform the current Flux once it emits its first element, making a conditional transformation possible.
switchOnNext(Publisher<? extends Publisher<? extends T>>) - Static method in class reactor.core.publisher.Flux: Creates a Flux that mirrors the most recently emitted Publisher, forwarding its data until a new Publisher comes in in the source.
switchOnNext(Publisher<? extends Publisher<? extends T>>, int) - Static method in class reactor.core.publisher.Flux: Creates a Flux that mirrors the most recently emitted Publisher, forwarding its data until a new Publisher comes in in the source.
switchOnNext() - Static method in class reactor.core.publisher.FluxProcessor: Build a FluxProcessor whose data are emitted by the most recent emitted Publisher.
SYNC - Static variable in interface reactor.core.Fuseable: Indicates the QueueSubscription can perform sync-fusion.
SynchronousSink<T> - Interface in reactor.core.publisher: Interface to produce synchronously "one signal" to an underlying Subscriber.

T

tag(String, String) - Method in class reactor.core.publisher.Flux: Tag this flux with a key/value pair.
tag(String, String) - Method in class reactor.core.publisher.Mono: Tag this mono with a key/value pair.
tag(String, String) - Method in class reactor.core.publisher.ParallelFlux: Tag this ParallelFlux with a key/value pair.
TAGS - Static variable in class reactor.core.Scannable.Attr: A Stream of Tuple2 representing key/value pairs for tagged components.
tags() - Method in interface reactor.core.Scannable: Visit this Scannable and its Scannable.parents() and stream all the observed tags
take(long) - Method in class reactor.core.publisher.Flux: Take only the first N values from this Flux, if available.
take(Duration) - Method in class reactor.core.publisher.Flux: Relay values from this Flux until the specified Duration elapses.
take(Duration, Scheduler) - Method in class reactor.core.publisher.Flux: Relay values from this Flux until the specified Duration elapses, as measured on the specified Scheduler.
take(Duration) - Method in class reactor.core.publisher.Mono: Give this Mono a chance to resolve within a specified time frame but complete if it doesn't.
take(Duration, Scheduler) - Method in class reactor.core.publisher.Mono: Give this Mono a chance to resolve within a specified time frame but complete if it doesn't.
takeLast(int) - Method in class reactor.core.publisher.Flux: Emit the last N values this Flux emitted before its completion.
takeUntil(Predicate<? super T>) - Method in class reactor.core.publisher.Flux: Relay values from this Flux until the given Predicate matches.
takeUntilOther(Publisher<?>) - Method in class reactor.core.publisher.Flux: Relay values from this Flux until the given Publisher emits.
takeUntilOther(Publisher<?>) - Method in class reactor.core.publisher.Mono: Give this Mono a chance to resolve before a companion Publisher emits.
takeWhile(Predicate<? super T>) - Method in class reactor.core.publisher.Flux: Relay values from this Flux while a predicate returns TRUE for the values (checked before each value is delivered).
terminate(AtomicReferenceFieldUpdater<T, Throwable>, T) - Static method in class reactor.core.Exceptions: Atomic utility to safely mark a volatile throwable reference with a terminal marker.
terminate(AtomicReferenceFieldUpdater<F, Subscription>, F) - Static method in class reactor.core.publisher.Operators: Atomically terminates the subscription if it is not already a Operators.cancelledSubscription(), cancelling the subscription and setting the field to the singleton Operators.cancelledSubscription().
TERMINATED - Static variable in class reactor.core.Exceptions: A singleton instance of a Throwable indicating a terminal state for exceptions, don't leak this!
TERMINATED - Static variable in class reactor.core.Scannable.Attr: A Boolean attribute indicating whether or not an upstream component terminated this scanned component.
then() - Method in class reactor.core.publisher.Flux: Return a Mono<Void> that completes when this Flux completes.
then(Mono<V>) - Method in class reactor.core.publisher.Flux: Let this Flux complete then play signals from a provided Mono.
then() - Method in class reactor.core.publisher.Mono: Return a Mono<Void> which only replays complete and error signals from this Mono.
then(Mono<V>) - Method in class reactor.core.publisher.Mono: Let this Mono complete then play another Mono.
then() - Method in class reactor.core.publisher.ParallelFlux: Emit an onComplete or onError signal once all values across 'rails' have been observed.
thenEmpty(Publisher<Void>) - Method in class reactor.core.publisher.Flux: Return a Mono<Void> that waits for this Flux to complete then for a supplied Publisher<Void> to also complete.
thenEmpty(Publisher<Void>) - Method in class reactor.core.publisher.Mono: Return a Mono<Void> that waits for this Mono to complete then for a supplied Publisher<Void> to also complete.
thenMany(Publisher<V>) - Method in class reactor.core.publisher.Flux: Let this Flux complete then play another Publisher.
thenMany(Publisher<V>) - Method in class reactor.core.publisher.Mono: Let this Mono complete then play another Publisher.
thenReturn(V) - Method in class reactor.core.publisher.Mono: Let this Mono complete then emit the provided value.
THREAD_BARRIER - Static variable in interface reactor.core.Fuseable: Indicates that the queue will be drained from another thread thus any queue-exit computation may be invalid at that point.
throwIfFatal(Throwable) - Static method in class reactor.core.Exceptions: Throws a particular Throwable only if it belongs to a set of "fatal" error varieties.
throwIfJvmFatal(Throwable) - Static method in class reactor.core.Exceptions: Throws a particular Throwable only if it belongs to a set of "fatal" error varieties native to the JVM.
timeout(Duration) - Method in class reactor.core.publisher.Flux: Propagate a TimeoutException as soon as no item is emitted within the given Duration from the previous emission (or the subscription for the first item).
timeout(Duration, Publisher<? extends T>) - Method in class reactor.core.publisher.Flux: 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).
timeout(Duration, Scheduler) - Method in class reactor.core.publisher.Flux: Propagate a TimeoutException as soon as no item is emitted within the given Duration from the previous emission (or the subscription for the first item), as measured by the specified Scheduler.
timeout(Duration, Publisher<? extends T>, Scheduler) - Method in class reactor.core.publisher.Flux: 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.
timeout(Publisher) - Method in class reactor.core.publisher.Flux: Signal a TimeoutException in case the first item from this Flux has not been emitted before the given Publisher emits.
timeout(Publisher, Function<? super T, ? extends Publisher<V>>) - Method in class reactor.core.publisher.Flux: Signal a TimeoutException in case the first item from this Flux has not been emitted before the firstTimeout Publisher emits, and whenever each subsequent elements is not emitted before a Publisher generated from the latest element signals.
timeout(Publisher, Function<? super T, ? extends Publisher<V>>, Publisher<? extends T>) - Method in class reactor.core.publisher.Flux: Switch to a fallback Publisher in case the first item from this Flux has not been emitted before the firstTimeout Publisher emits, and whenever each subsequent elements is not emitted before a Publisher generated from the latest element signals.
timeout(Duration) - Method in class reactor.core.publisher.Mono: Propagate a TimeoutException in case no item arrives within the given Duration.
timeout(Duration, Mono<? extends T>) - Method in class reactor.core.publisher.Mono: Switch to a fallback Mono in case no item arrives within the given Duration.
timeout(Duration, Scheduler) - Method in class reactor.core.publisher.Mono: Signal a TimeoutException error in case an item doesn't arrive before the given period, as measured on the provided Scheduler.
timeout(Duration, Mono<? extends T>, Scheduler) - Method in class reactor.core.publisher.Mono: Switch to a fallback Mono in case an item doesn't arrive before the given period, as measured on the provided Scheduler.
timeout(Publisher) - Method in class reactor.core.publisher.Mono: Signal a TimeoutException in case the item from this Mono has not been emitted before the given Publisher emits.
timeout(Publisher, Mono<? extends T>) - Method in class reactor.core.publisher.Mono: Switch to a fallback Publisher in case the item from this Mono has not been emitted before the given Publisher emits.
timestamp() - Method in class reactor.core.publisher.Flux: Emit a Tuple2 pair of T1 the current clock time in millis (as a Long measured by the parallel Scheduler) and T2 the emitted data (as a T), for each item from this Flux.
timestamp(Scheduler) - Method in class reactor.core.publisher.Flux: Emit a Tuple2 pair of T1 the current clock time in millis (as a Long measured by the provided Scheduler) and T2 the emitted data (as a T), for each item from this Flux.
timestamp() - Method in class reactor.core.publisher.Mono: If this Mono is valued, emit a Tuple2 pair of T1 the current clock time in millis (as a Long measured by the parallel Scheduler) and T2 the emitted data (as a T).
timestamp(Scheduler) - Method in class reactor.core.publisher.Mono: If this Mono is valued, emit a Tuple2 pair of T1 the current clock time in millis (as a Long measured by the provided Scheduler) and T2 the emitted data (as a T).
toArray() - Method in interface reactor.core.Fuseable.QueueSubscription
toArray(T1[]) - Method in interface reactor.core.Fuseable.QueueSubscription
toArray() - Method in class reactor.util.function.Tuple2: Turn this Tuple into a plain Object[].
toArray() - Method in class reactor.util.function.Tuple3
toArray() - Method in class reactor.util.function.Tuple4
toArray() - Method in class reactor.util.function.Tuple5
toArray() - Method in class reactor.util.function.Tuple6
toArray() - Method in class reactor.util.function.Tuple7
toArray() - Method in class reactor.util.function.Tuple8
toConditionalSubscriber(CoreSubscriber<? super T>) - Static method in class reactor.core.publisher.Operators: If the actual CoreSubscriber is not Fuseable.ConditionalSubscriber, it will apply an adapter which directly maps all Fuseable.ConditionalSubscriber#tryOnNext(T) to CoreSubscriber#onNext(T) and always returns true as the result
toCoreSubscriber(Subscriber<? super T>) - Static method in class reactor.core.publisher.Operators: If the actual Subscriber is not a CoreSubscriber, it will apply safe strict wrapping to apply all reactive streams rules including the ones relaxed by internal operators based on CoreSubscriber.
toFuture() - Method in class reactor.core.publisher.Mono: Transform this Mono into a CompletableFuture completing on onNext or onComplete and failing on onError.
toIterable() - Method in class reactor.core.publisher.Flux: Transform this Flux into a lazy Iterable blocking on Iterator.next() calls.
toIterable(int) - Method in class reactor.core.publisher.Flux: Transform this Flux into a lazy Iterable blocking on Iterator.next() calls.
toIterable(int, Supplier<Queue<T>>) - Method in class reactor.core.publisher.Flux: Transform this Flux into a lazy Iterable blocking on Iterator.next() calls.
toList() - Method in class reactor.util.function.Tuple2: Turn this Tuple into a List<Object>.
toProcessor() - Method in class reactor.core.publisher.Mono: Wrap this Mono into a MonoProcessor (turning it hot and allowing to block, cancel, as well as many other operations).
toStream() - Method in class reactor.core.publisher.Flux: Transform this Flux into a lazy Stream blocking for each source onNext call.
toStream(int) - Method in class reactor.core.publisher.Flux: Transform this Flux into a lazy Stream blocking for each source onNext call.
toString() - Method in class reactor.core.publisher.BaseSubscriber
toString() - Method in class reactor.core.publisher.Flux
toString() - Method in class reactor.core.publisher.Mono
toString() - Method in class reactor.core.publisher.ParallelFlux
toString() - Method in enum reactor.core.publisher.SignalType
toString() - Method in class reactor.util.function.Tuple2: A Tuple String representation is the comma separated list of values, enclosed in square brackets.
totalRetries() - Method in interface reactor.util.retry.Retry.RetrySignal: The ZERO BASED index number of this error (can also be read as how many retries have occurred so far), since the source was first subscribed to.
totalRetriesInARow() - Method in interface reactor.util.retry.Retry.RetrySignal: The ZERO BASED index number of this error since the beginning of the current burst of errors.
trace(String) - Method in interface reactor.util.Logger: Log a message at the TRACE level.
trace(String, Object...) - Method in interface reactor.util.Logger: Log a message at the TRACE level according to the specified format and arguments.
trace(String, Throwable) - Method in interface reactor.util.Logger: Log an exception (throwable) at the TRACE level with an accompanying message.
transform(Function<? super Flux<T>, ? extends Publisher<V>>) - Method in class reactor.core.publisher.Flux: Transform this Flux in order to generate a target Flux.
transform(Function<? super Mono<T>, ? extends Publisher<V>>) - Method in class reactor.core.publisher.Mono: Transform this Mono in order to generate a target Mono.
transform(Function<? super ParallelFlux<T>, ParallelFlux>) - Method in class reactor.core.publisher.ParallelFlux: Allows composing operators, in assembly time, on top of this ParallelFlux and returns another ParallelFlux with composed features.
transformDeferred(Function<? super Flux<T>, ? extends Publisher<V>>) - Method in class reactor.core.publisher.Flux: Defer the transformation of this Flux in order to generate a target Flux type.
transformDeferred(Function<? super Mono<T>, ? extends Publisher<V>>) - Method in class reactor.core.publisher.Mono: Defer the given transformation to this Mono in order to generate a target Mono type.
transformGroups(Function<? super GroupedFlux<Integer, T>, ? extends Publisher<? extends U>>) - Method in class reactor.core.publisher.ParallelFlux: Allows composing operators off the groups (or 'rails'), as individual GroupedFlux instances keyed by the zero based rail's index.
transientErrors(boolean) - Method in class reactor.util.retry.RetryBackoffSpec: Set the transient error mode, indicating that the strategy being built should use RetrySignal#totalRetriesInARow() rather than RetrySignal#totalRetries().
transientErrors(boolean) - Method in class reactor.util.retry.RetrySpec: Set the transient error mode, indicating that the strategy being built should use RetrySignal#totalRetriesInARow() rather than RetrySignal#totalRetries().
tryOnNext(T) - Method in interface reactor.core.Fuseable.ConditionalSubscriber: Try consuming the value and return true if successful.
Tuple2<T1,T2> - Class in reactor.util.function: A tuple that holds two non-null values.
Tuple3<T1,T2,T3> - Class in reactor.util.function: A tuple that holds three non-null values.
Tuple4<T1,T2,T3,T4> - Class in reactor.util.function: A tuple that holds four non-null values
Tuple5<T1,T2,T3,T4,T5> - Class in reactor.util.function: A tuple that holds five non-null values
Tuple6<T1,T2,T3,T4,T5,T6> - Class in reactor.util.function: A tuple that holds six values
Tuple7<T1,T2,T3,T4,T5,T6,T7> - Class in reactor.util.function: A tuple that holds seven non-null values
Tuple8<T1,T2,T3,T4,T5,T6,T7,T8> - Class in reactor.util.function: A tuple that holds eight values
Tuples - Class in reactor.util.function: A Tuples is an immutable Collection of objects, each of which can be of an arbitrary type.

U

unbounded() - Static method in class reactor.util.concurrent.Queues
unbounded(int) - Static method in class reactor.util.concurrent.Queues: Returns an unbounded, linked-array-based Queue.
unboundedMultiproducer() - Static method in class reactor.util.concurrent.Queues: Returns an unbounded queue suitable for multi-producer/single-consumer (MPSC) scenarios.
UnicastProcessor<T> - Class in reactor.core.publisher: A Processor implementation that takes a custom queue and allows only a single subscriber.
UnicastProcessor(Queue<T>) - Constructor for class reactor.core.publisher.UnicastProcessor
UnicastProcessor(Queue<T>, Disposable) - Constructor for class reactor.core.publisher.UnicastProcessor
UnicastProcessor(Queue<T>, Consumer<? super T>, Disposable) - Constructor for class reactor.core.publisher.UnicastProcessor
unwrap(Throwable) - Static method in class reactor.core.Exceptions: Unwrap a particular Throwable only if it is was wrapped via bubble or propagate.
unwrapMultiple(Throwable) - Static method in class reactor.core.Exceptions: Attempt to unwrap a Throwable into a List of Throwables.
unwrapMultipleExcludingTracebacks(Throwable) - Static method in class reactor.core.Exceptions: Attempt to unwrap a Throwable into a List of Throwables, excluding instances that are tracebacks.
update(Disposable) - Method in interface reactor.core.Disposable.Swap: Atomically set the next Disposable on this container and dispose the previous one (if any).
upstream() - Method in class reactor.core.publisher.BaseSubscriber: Return current Subscription
useConsoleLoggers() - Static method in class reactor.util.Loggers: Force the usage of Console-based Loggers, even if SLF4J is available on the classpath.
useCustomLoggers(Function<String, ? extends Logger>) - Static method in class reactor.util.Loggers: Use a custom type of Logger created through the provided Function, which takes a logger name as input.
useJdkLoggers() - Static method in class reactor.util.Loggers: Force the usage of JDK-based Loggers, even if SLF4J is available on the classpath.
useSl4jLoggers() - Static method in class reactor.util.Loggers: Force the usage of SL4J-based Loggers, throwing an exception if SLF4J isn't available on the classpath.
useVerboseConsoleLoggers() - Static method in class reactor.util.Loggers: Force the usage of Console-based Loggers, even if SLF4J is available on the classpath.
using(Callable<? extends D>, Function<? super D, ? extends Publisher<? extends T>>, Consumer<? super D>) - Static method in class reactor.core.publisher.Flux: Uses a resource, generated by a supplier for each individual Subscriber, while streaming the values from a Publisher derived from the same resource and makes sure the resource is released if the sequence terminates or the Subscriber cancels.
using(Callable<? extends D>, Function<? super D, ? extends Publisher<? extends T>>, Consumer<? super D>, boolean) - Static method in class reactor.core.publisher.Flux: Uses a resource, generated by a supplier for each individual Subscriber, while streaming the values from a Publisher derived from the same resource and makes sure the resource is released if the sequence terminates or the Subscriber cancels.
using(Callable<? extends D>, Function<? super D, ? extends Mono<? extends T>>, Consumer<? super D>, boolean) - Static method in class reactor.core.publisher.Mono: Uses a resource, generated by a supplier for each individual Subscriber, while streaming the value from a Mono derived from the same resource and makes sure the resource is released if the sequence terminates or the Subscriber cancels.
using(Callable<? extends D>, Function<? super D, ? extends Mono<? extends T>>, Consumer<? super D>) - Static method in class reactor.core.publisher.Mono: Uses a resource, generated by a supplier for each individual Subscriber, while streaming the value from a Mono derived from the same resource and makes sure the resource is released if the sequence terminates or the Subscriber cancels.
usingWhen(Publisher<D>, Function<? super D, ? extends Publisher<? extends T>>, Function<? super D, ? extends Publisher<?>>) - Static method in class reactor.core.publisher.Flux: Uses a resource, generated by a Publisher for each individual Subscriber, while streaming the values from a Publisher derived from the same resource.
usingWhen(Publisher<D>, Function<? super D, ? extends Publisher<? extends T>>, Function<? super D, ? extends Publisher<?>>, BiFunction<? super D, ? super Throwable, ? extends Publisher<?>>, Function<? super D, ? extends Publisher<?>>) - Static method in class reactor.core.publisher.Flux: Uses a resource, generated by a Publisher for each individual Subscriber, while streaming the values from a Publisher derived from the same resource.
usingWhen(Publisher<D>, Function<? super D, ? extends Mono<? extends T>>, Function<? super D, ? extends Publisher<?>>) - Static method in class reactor.core.publisher.Mono: Uses a resource, generated by a Publisher for each individual Subscriber, to derive a Mono.
usingWhen(Publisher<D>, Function<? super D, ? extends Mono<? extends T>>, Function<? super D, ? extends Publisher<?>>, BiFunction<? super D, ? super Throwable, ? extends Publisher<?>>, Function<? super D, ? extends Publisher<?>>) - Static method in class reactor.core.publisher.Mono: Uses a resource, generated by a Publisher for each individual Subscriber, to derive a Mono.Note that all steps of the operator chain that would need the resource to be in an open stable state need to be described inside the resourceClosure Function.

V

validate(Subscription, Subscription) - Static method in class reactor.core.publisher.Operators: Check Subscription current state and cancel new Subscription if current is set, or return true if ready to subscribe.
validate(long) - Static method in class reactor.core.publisher.Operators: Evaluate if a request is strictly positive otherwise Operators.reportBadRequest(long)
validate(Subscriber<?>[]) - Method in class reactor.core.publisher.ParallelFlux: Validates the number of subscribers and returns true if their number matches the parallelism level of this ParallelFlux.
validateArguments() - Method in class reactor.util.retry.RetryBackoffSpec
value - Variable in class reactor.core.publisher.Operators.MonoSubscriber
valueOf(String) - Static method in enum reactor.core.publisher.BufferOverflowStrategy: Returns the enum constant of this type with the specified name.
valueOf(String) - Static method in enum reactor.core.publisher.FluxSink.OverflowStrategy: Returns the enum constant of this type with the specified name.
valueOf(String) - Static method in enum reactor.core.publisher.SignalType: Returns the enum constant of this type with the specified name.
values() - Static method in enum reactor.core.publisher.BufferOverflowStrategy: Returns an array containing the constants of this enum type, in the order they are declared.
values() - Static method in enum reactor.core.publisher.FluxSink.OverflowStrategy: Returns an array containing the constants of this enum type, in the order they are declared.
values() - Static method in enum reactor.core.publisher.SignalType: Returns an array containing the constants of this enum type, in the order they are declared.

W

warn(String) - Method in interface reactor.util.Logger: Log a message at the WARN level.
warn(String, Object...) - Method in interface reactor.util.Logger: Log a message at the WARN level according to the specified format and arguments.
warn(String, Throwable) - Method in interface reactor.util.Logger: Log an exception (throwable) at the WARN level with an accompanying message.
when(Publisher<?>...) - Static method in class reactor.core.publisher.Mono: Aggregate given publishers into a new Mono that will be fulfilled when all of the given sources have completed.
when(Iterable<? extends Publisher<?>>) - Static method in class reactor.core.publisher.Mono: Aggregate given publishers into a new Mono that will be fulfilled when all of the given Publishers have completed.
whenDelayError(Iterable<? extends Publisher<?>>) - Static method in class reactor.core.publisher.Mono: Aggregate given publishers into a new Mono that will be fulfilled when all of the given sources have completed.
whenDelayError(Publisher<?>...) - Static method in class reactor.core.publisher.Mono: Merge given publishers into a new Mono that will be fulfilled when all of the given sources have completed.
window(int) - Method in class reactor.core.publisher.Flux: Split this Flux sequence into multiple Flux windows containing maxSize elements (or less for the final window) and starting from the first item.
window(int, int) - Method in class reactor.core.publisher.Flux: Split this Flux sequence into multiple Flux windows of size maxSize, that each open every skip elements in the source.
window(Publisher<?>) - Method in class reactor.core.publisher.Flux: Split this Flux sequence into continuous, non-overlapping windows where the window boundary is signalled by another Publisher
window(Duration) - Method in class reactor.core.publisher.Flux: Split this Flux sequence into continuous, non-overlapping windows that open for a windowingTimespan Duration (as measured on the parallel Scheduler).
window(Duration, Duration) - Method in class reactor.core.publisher.Flux: Split this Flux sequence into multiple Flux windows that open for a given windowingTimespan Duration, after which it closes with onComplete.
window(Duration, Scheduler) - Method in class reactor.core.publisher.Flux: Split this Flux sequence into continuous, non-overlapping windows that open for a windowingTimespan Duration (as measured on the provided Scheduler).
window(Duration, Duration, Scheduler) - Method in class reactor.core.publisher.Flux: Split this Flux sequence into multiple Flux windows that open for a given windowingTimespan Duration, after which it closes with onComplete.
windowTimeout(int, Duration) - Method in class reactor.core.publisher.Flux: Split this Flux sequence into multiple Flux windows containing maxSize elements (or less for the final window) and starting from the first item.
windowTimeout(int, Duration, Scheduler) - Method in class reactor.core.publisher.Flux: Split this Flux sequence into multiple Flux windows containing maxSize elements (or less for the final window) and starting from the first item.
windowUntil(Predicate<T>) - Method in class reactor.core.publisher.Flux: Split this Flux sequence into multiple Flux windows delimited by the given predicate.
windowUntil(Predicate<T>, boolean) - Method in class reactor.core.publisher.Flux: Split this Flux sequence into multiple Flux windows delimited by the given predicate.
windowUntil(Predicate<T>, boolean, int) - Method in class reactor.core.publisher.Flux: Split this Flux sequence into multiple Flux windows delimited by the given predicate and using a prefetch.
windowUntilChanged() - Method in class reactor.core.publisher.Flux: Collect subsequent repetitions of an element (that is, if they arrive right after one another) into multiple Flux windows.
windowUntilChanged(Function<? super T, ? super V>) - Method in class reactor.core.publisher.Flux: Collect subsequent repetitions of an element (that is, if they arrive right after one another), as compared by a key extracted through the user provided Function, into multiple Flux windows.
windowUntilChanged(Function<? super T, ? extends V>, BiPredicate<? super V, ? super V>) - Method in class reactor.core.publisher.Flux: Collect subsequent repetitions of an element (that is, if they arrive right after one another), as compared by a key extracted through the user provided Function and compared using a supplied BiPredicate, into multiple Flux windows.
windowWhen(Publisher, Function<? super U, ? extends Publisher<V>>) - Method in class reactor.core.publisher.Flux: Split this Flux sequence into potentially overlapping windows controlled by items of a start Publisher and end Publisher derived from the start values.
windowWhile(Predicate<T>) - Method in class reactor.core.publisher.Flux: Split this Flux sequence into multiple Flux windows that stay open while a given predicate matches the source elements.
windowWhile(Predicate<T>, int) - Method in class reactor.core.publisher.Flux: Split this Flux sequence into multiple Flux windows that stay open while a given predicate matches the source elements.
withLatestFrom(Publisher<? extends U>, BiFunction<? super T, ? super U, ? extends R>) - Method in class reactor.core.publisher.Flux: Combine the most recently emitted values from both this Flux and another Publisher through a BiFunction and emits the result.
wrap(Subscriber<IN>, Publisher<OUT>) - Static method in class reactor.core.publisher.FluxProcessor: Transform a receiving Subscriber and a producing Publisher in a logical FluxProcessor.

X

xs() - Static method in class reactor.util.concurrent.Queues
XS_BUFFER_SIZE - Static variable in class reactor.util.concurrent.Queues: An allocation friendly default of available slots in a given container, e.g.

Z

zip(Publisher<? extends T1>, Publisher<? extends T2>, BiFunction<? super T1, ? super T2, ? extends O>) - Static method in class reactor.core.publisher.Flux: Zip two sources together, that is to say wait for all the sources to emit one element and combine these elements once into an output value (constructed by the provided combinator).
zip(Publisher<? extends T1>, Publisher<? extends T2>) - Static method in class reactor.core.publisher.Flux: Zip two sources together, that is to say wait for all the sources to emit one element and combine these elements once into a Tuple2.
zip(Publisher<? extends T1>, Publisher<? extends T2>, Publisher<? extends T3>) - Static method in class reactor.core.publisher.Flux: Zip three sources together, that is to say wait for all the sources to emit one element and combine these elements once into a Tuple3.
zip(Publisher<? extends T1>, Publisher<? extends T2>, Publisher<? extends T3>, Publisher<? extends T4>) - Static method in class reactor.core.publisher.Flux: Zip four sources together, that is to say wait for all the sources to emit one element and combine these elements once into a Tuple4.
zip(Publisher<? extends T1>, Publisher<? extends T2>, Publisher<? extends T3>, Publisher<? extends T4>, Publisher<? extends T5>) - Static method in class reactor.core.publisher.Flux: Zip five sources together, that is to say wait for all the sources to emit one element and combine these elements once into a Tuple5.
zip(Publisher<? extends T1>, Publisher<? extends T2>, Publisher<? extends T3>, Publisher<? extends T4>, Publisher<? extends T5>, Publisher<? extends T6>) - Static method in class reactor.core.publisher.Flux: Zip six sources together, that is to say wait for all the sources to emit one element and combine these elements once into a Tuple6.
zip(Publisher<? extends T1>, Publisher<? extends T2>, Publisher<? extends T3>, Publisher<? extends T4>, Publisher<? extends T5>, Publisher<? extends T6>, Publisher<? extends T7>) - Static method in class reactor.core.publisher.Flux: Zip seven sources together, that is to say wait for all the sources to emit one element and combine these elements once into a Tuple7.
zip(Publisher<? extends T1>, Publisher<? extends T2>, Publisher<? extends T3>, Publisher<? extends T4>, Publisher<? extends T5>, Publisher<? extends T6>, Publisher<? extends T7>, Publisher<? extends T8>) - Static method in class reactor.core.publisher.Flux: Zip eight sources together, that is to say wait for all the sources to emit one element and combine these elements once into a Tuple8.
zip(Iterable<? extends Publisher<?>>, Function<? super Object[], ? extends O>) - Static method in class reactor.core.publisher.Flux: Zip multiple sources together, that is to say wait for all the sources to emit one element and combine these elements once into an output value (constructed by the provided combinator).
zip(Iterable<? extends Publisher<?>>, int, Function<? super Object[], ? extends O>) - Static method in class reactor.core.publisher.Flux: Zip multiple sources together, that is to say wait for all the sources to emit one element and combine these elements once into an output value (constructed by the provided combinator).
zip(Function<? super Object[], ? extends O>, Publisher<? extends I>...) - Static method in class reactor.core.publisher.Flux: Zip multiple sources together, that is to say wait for all the sources to emit one element and combine these elements once into an output value (constructed by the provided combinator).
zip(Function<? super Object[], ? extends O>, int, Publisher<? extends I>...) - Static method in class reactor.core.publisher.Flux: Zip multiple sources together, that is to say wait for all the sources to emit one element and combine these elements once into an output value (constructed by the provided combinator).
zip(Publisher<? extends Publisher<?>>, Function<? super TUPLE, ? extends V>) - Static method in class reactor.core.publisher.Flux: Zip multiple sources together, that is to say wait for all the sources to emit one element and combine these elements once into an output value (constructed by the provided combinator).
zip(Mono<? extends T1>, Mono<? extends T2>) - Static method in class reactor.core.publisher.Mono: Merge given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item, aggregating their values into a Tuple2.
zip(Mono<? extends T1>, Mono<? extends T2>, BiFunction<? super T1, ? super T2, ? extends O>) - Static method in class reactor.core.publisher.Mono: Merge given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item, aggregating their values as defined by the combinator function.
zip(Mono<? extends T1>, Mono<? extends T2>, Mono<? extends T3>) - Static method in class reactor.core.publisher.Mono: Merge given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item, aggregating their values into a Tuple3.
zip(Mono<? extends T1>, Mono<? extends T2>, Mono<? extends T3>, Mono<? extends T4>) - Static method in class reactor.core.publisher.Mono: Merge given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item, aggregating their values into a Tuple4.
zip(Mono<? extends T1>, Mono<? extends T2>, Mono<? extends T3>, Mono<? extends T4>, Mono<? extends T5>) - Static method in class reactor.core.publisher.Mono: Merge given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item, aggregating their values into a Tuple5.
zip(Mono<? extends T1>, Mono<? extends T2>, Mono<? extends T3>, Mono<? extends T4>, Mono<? extends T5>, Mono<? extends T6>) - Static method in class reactor.core.publisher.Mono: Merge given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item, aggregating their values into a Tuple6.
zip(Mono<? extends T1>, Mono<? extends T2>, Mono<? extends T3>, Mono<? extends T4>, Mono<? extends T5>, Mono<? extends T6>, Mono<? extends T7>) - Static method in class reactor.core.publisher.Mono: Merge given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item, aggregating their values into a Tuple7.
zip(Mono<? extends T1>, Mono<? extends T2>, Mono<? extends T3>, Mono<? extends T4>, Mono<? extends T5>, Mono<? extends T6>, Mono<? extends T7>, Mono<? extends T8>) - Static method in class reactor.core.publisher.Mono: Merge given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item, aggregating their values into a Tuple8.
zip(Iterable<? extends Mono<?>>, Function<? super Object[], ? extends R>) - Static method in class reactor.core.publisher.Mono: Aggregate given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item, aggregating their values according to the provided combinator function.
zip(Function<? super Object[], ? extends R>, Mono<?>...) - Static method in class reactor.core.publisher.Mono: Aggregate given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item, aggregating their values according to the provided combinator function.
zipDelayError(Mono<? extends T1>, Mono<? extends T2>) - Static method in class reactor.core.publisher.Mono: Merge given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item, aggregating their values into a Tuple2 and delaying errors.
zipDelayError(Mono<? extends T1>, Mono<? extends T2>, Mono<? extends T3>) - Static method in class reactor.core.publisher.Mono: Merge given monos into a new Mono that will be fulfilled when all of the given Mono Monos have produced an item, aggregating their values into a Tuple3 and delaying errors.
zipDelayError(Mono<? extends T1>, Mono<? extends T2>, Mono<? extends T3>, Mono<? extends T4>) - Static method in class reactor.core.publisher.Mono: Merge given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item, aggregating their values into a Tuple4 and delaying errors.
zipDelayError(Mono<? extends T1>, Mono<? extends T2>, Mono<? extends T3>, Mono<? extends T4>, Mono<? extends T5>) - Static method in class reactor.core.publisher.Mono: Merge given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item, aggregating their values into a Tuple5 and delaying errors.
zipDelayError(Mono<? extends T1>, Mono<? extends T2>, Mono<? extends T3>, Mono<? extends T4>, Mono<? extends T5>, Mono<? extends T6>) - Static method in class reactor.core.publisher.Mono: Merge given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item, aggregating their values into a Tuple6 and delaying errors.
zipDelayError(Mono<? extends T1>, Mono<? extends T2>, Mono<? extends T3>, Mono<? extends T4>, Mono<? extends T5>, Mono<? extends T6>, Mono<? extends T7>) - Static method in class reactor.core.publisher.Mono: Merge given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item, aggregating their values into a Tuple7 and delaying errors.
zipDelayError(Mono<? extends T1>, Mono<? extends T2>, Mono<? extends T3>, Mono<? extends T4>, Mono<? extends T5>, Mono<? extends T6>, Mono<? extends T7>, Mono<? extends T8>) - Static method in class reactor.core.publisher.Mono: Merge given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item, aggregating their values into a Tuple8 and delaying errors.
zipDelayError(Iterable<? extends Mono<?>>, Function<? super Object[], ? extends R>) - Static method in class reactor.core.publisher.Mono: Aggregate given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item.
zipDelayError(Function<? super Object[], ? extends R>, Mono<?>...) - Static method in class reactor.core.publisher.Mono: Merge given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item, aggregating their values according to the provided combinator function and delaying errors.
zipWhen(Function<T, Mono<? extends T2>>) - Method in class reactor.core.publisher.Mono: Wait for the result from this mono, use it to create a second mono via the provided rightGenerator function and combine both results into a Tuple2.
zipWhen(Function<T, Mono<? extends T2>>, BiFunction<T, T2, O>) - Method in class reactor.core.publisher.Mono: Wait for the result from this mono, use it to create a second mono via the provided rightGenerator function and combine both results into an arbitrary O object, as defined by the provided combinator function.
zipWith(Publisher<? extends T2>) - Method in class reactor.core.publisher.Flux: Zip this Flux with another Publisher source, that is to say wait for both to emit one element and combine these elements once into a Tuple2.
zipWith(Publisher<? extends T2>, BiFunction<? super T, ? super T2, ? extends V>) - Method in class reactor.core.publisher.Flux: Zip this Flux with another Publisher source, that is to say wait for both to emit one element and combine these elements using a combinator BiFunction The operator will continue doing so until any of the sources completes.
zipWith(Publisher<? extends T2>, int, BiFunction<? super T, ? super T2, ? extends V>) - Method in class reactor.core.publisher.Flux: Zip this Flux with another Publisher source, that is to say wait for both to emit one element and combine these elements using a combinator BiFunction The operator will continue doing so until any of the sources completes.
zipWith(Publisher<? extends T2>, int) - Method in class reactor.core.publisher.Flux: Zip this Flux with another Publisher source, that is to say wait for both to emit one element and combine these elements once into a Tuple2.
zipWith(Mono<? extends T2>) - Method in class reactor.core.publisher.Mono: Combine the result from this mono and another into a Tuple2.
zipWith(Mono<? extends T2>, BiFunction<? super T, ? super T2, ? extends O>) - Method in class reactor.core.publisher.Mono: Combine the result from this mono and another into an arbitrary O object, as defined by the provided combinator function.
zipWithIterable(Iterable<? extends T2>) - Method in class reactor.core.publisher.Flux: Zip elements from this Flux with the content of an Iterable, that is to say combine one element from each, pairwise, into a Tuple2.
zipWithIterable(Iterable<? extends T2>, BiFunction<? super T, ? super T2, ? extends V>) - Method in class reactor.core.publisher.Flux: Zip elements from this Flux with the content of an Iterable, that is to say combine one element from each, pairwise, using the given zipper BiFunction.

A B C D E F G H I J K L M N O P Q R S T U V W X Z