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

A

accept(E) - Method in class reactor.core.publisher.BlockingSink

accept(Subscriber<? super T>) - Method in class reactor.core.publisher.Signal

actual - Variable in class reactor.core.publisher.Operators.MonoSubscriber

add(T) - Method in interface reactor.core.Fuseable.QueueSubscription

add(T) - Method in class reactor.util.concurrent.OpenHashSet

addAll(Collection<? extends T>) - Method in interface reactor.core.Fuseable.QueueSubscription

addAndGet(AtomicLong, long) - Static method in class reactor.core.publisher.Operators

Deprecated.

This util is neither used by Core nor consistent with the other `addAndGet` methods present which use AtomicLongFieldUpdater. In an effort to keep Operators API consistent, this util will not be supported anymore and users need to port over its body under their app code.

addAndGet(AtomicLongFieldUpdater<T>, T, long) - Static method in class reactor.core.publisher.Operators

Concurrent addition bound to Long.MAX_VALUE.

addCap(long, long) - Static method in class reactor.core.publisher.Operators

Cap an addition to Long.MAX_VALUE

addThrowable(AtomicReferenceFieldUpdater<T, Throwable>, T, Throwable) - Static method in class reactor.core.Exceptions

alert() - Static method in class reactor.util.concurrent.WaitStrategy

Throw an Alert signal exception (singleton) that can be checked against WaitStrategy.isAlert(Throwable)

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(Mono<? extends T2>) - Method in class reactor.core.publisher.Mono

Combine the result from this mono and another into a Tuple2.

and(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.

and(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.

and(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.

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

argumentIsNullException() - Static method in class reactor.core.Exceptions

as(Function<? super Flux<T>, P>) - Method in class reactor.core.publisher.Flux

Immediately apply the given transformation to this Flux in order to generate 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.

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 runnable that allows disconnecting.

awaitOnSubscribe() - Method in class reactor.core.publisher.Flux

Intercepts the onSubscribe call and makes sure calls to Subscription methods only happen after the child Subscriber has returned from its onSubscribe method.

awaitOnSubscribe() - Method in class reactor.core.publisher.Mono

Intercepts the onSubscribe call and makes sure calls to Subscription methods only happen after the child Subscriber has returned from its onSubscribe method.

B

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

Block until a next signal is received, will return null if onComplete, T if onNext, throw a Exceptions.DownstreamException if checked error or origin RuntimeException if unchecked.

block(Duration) - Method in class reactor.core.publisher.Mono

Block until a next signal is received, will return null if onComplete, T if onNext, throw a Exceptions.DownstreamException if checked error or origin RuntimeException if unchecked.

block() - Method in class reactor.core.publisher.MonoProcessor

blockFirst() - Method in class reactor.core.publisher.Flux

Blocks until the upstream signals its first value or completes.

blockFirst(Duration) - Method in class reactor.core.publisher.Flux

Blocks until the upstream signals its first value or completes.

blockFirstMillis(long) - Method in class reactor.core.publisher.Flux

Blocks until the upstream signals its first value or completes.

blocking() - Static method in class reactor.util.concurrent.WaitStrategy

Blocking strategy that uses a lock and condition variable for consumer waiting on a barrier.

BlockingSink<E> - Class in reactor.core.publisher

A "hot" sequence source to decorate any Subscriber or Processor.

BlockingSink(Subscriber<? super E>) - Constructor for class reactor.core.publisher.BlockingSink

BlockingSink.Emission - Enum in reactor.core.publisher

An acknowledgement signal returned by BlockingSink.emit(E).

blockLast() - Method in class reactor.core.publisher.Flux

Blocks until the upstream completes and return the last emitted value.

blockLast(Duration) - Method in class reactor.core.publisher.Flux

Blocks until the upstream completes and return the last emitted value.

blockLastMillis(long) - Method in class reactor.core.publisher.Flux

Blocks until the upstream completes and return the last emitted value.

blockMillis(long) - Method in class reactor.core.publisher.Mono

Block until a next signal is received, will return null if onComplete, T if onNext, throw a Exceptions.DownstreamException if checked error or origin RuntimeException if unchecked.

blockMillis(long) - Method in class reactor.core.publisher.MonoProcessor

Block the calling thread for the specified time, waiting for the completion of this MonoProcessor.

bubble(Throwable) - Static method in class reactor.core.Exceptions

Return an unchecked RuntimeException to be thrown that will bubble upstream.

buffer() - Method in class reactor.core.publisher.Flux

Collect incoming values into a List that will be pushed into the returned Flux on complete only.

buffer(int) - Method in class reactor.core.publisher.Flux

Collect incoming values into multiple List buckets that will be pushed into the returned Flux when the given max size is reached or onComplete is received.

buffer(int, Supplier<C>) - Method in class reactor.core.publisher.Flux

Collect incoming values into multiple Collection buckets that will be pushed into the returned Flux when the given max size is reached or onComplete is received.

buffer(int, int) - Method in class reactor.core.publisher.Flux

Collect incoming values into multiple List that will be pushed into the returned Flux when the given max size is reached or onComplete is received.

buffer(int, int, Supplier<C>) - Method in class reactor.core.publisher.Flux

Collect incoming values into multiple Collection that will be pushed into the returned Flux when the given max size is reached or onComplete is received.

buffer(Publisher<?>) - Method in class reactor.core.publisher.Flux

Collect incoming values into multiple List delimited by the given Publisher signals.

buffer(Publisher<?>, Supplier<C>) - Method in class reactor.core.publisher.Flux

Collect incoming values into multiple Collection delimited by the given Publisher signals.

buffer(Publisher<U>, Function<? super U, ? extends Publisher<V>>) - Method in class reactor.core.publisher.Flux

Collect incoming values into multiple List delimited by the given Publisher signals.

buffer(Publisher<U>, Function<? super U, ? extends Publisher<V>>, Supplier<C>) - Method in class reactor.core.publisher.Flux

Collect incoming values into multiple Collection delimited by the given Publisher signals.

buffer(Duration) - Method in class reactor.core.publisher.Flux

Collect incoming values into multiple List that will be pushed into the returned Flux every timespan.

buffer(Duration, Duration) - Method in class reactor.core.publisher.Flux

Collect incoming values into multiple List delimited by the given timeshift period.

buffer(int, Duration) - Method in class reactor.core.publisher.Flux

Deprecated.

use Flux.bufferTimeout(int, Duration) instead, will be removed in 3.1.0

buffer(int, Duration, Supplier<C>) - Method in class reactor.core.publisher.Flux

Deprecated.

use Flux.bufferTimeout(int, Duration, Supplier) instead, will be removed in 3.1.0

bufferMillis(long) - Method in class reactor.core.publisher.Flux

Collect incoming values into multiple List that will be pushed into the returned Flux every timespan.

bufferMillis(long, TimedScheduler) - Method in class reactor.core.publisher.Flux

Collect incoming values into multiple List that will be pushed into the returned Flux every timespan.

bufferMillis(long, long) - Method in class reactor.core.publisher.Flux

Collect incoming values into multiple List delimited by the given timeshift period.

bufferMillis(long, long, TimedScheduler) - Method in class reactor.core.publisher.Flux

Collect incoming values into multiple List delimited by the given timeshift period.

bufferMillis(int, long) - Method in class reactor.core.publisher.Flux

Deprecated.

use Flux.bufferTimeoutMillis(int, long) instead, will be removed in 3.1.0

bufferMillis(int, long, TimedScheduler) - Method in class reactor.core.publisher.Flux

Deprecated.

use Flux.bufferTimeoutMillis(int, long, TimedScheduler) instead, will be removed in 3.1.0

bufferMillis(int, long, TimedScheduler, Supplier<C>) - Method in class reactor.core.publisher.Flux

Deprecated.

use Flux.bufferTimeoutMillis(int, long, TimedScheduler, Supplier) instead, will be removed in 3.1.0

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 a List that will be pushed into the returned Flux every timespan OR maxSize items.

bufferTimeout(int, Duration, Supplier<C>) - Method in class reactor.core.publisher.Flux

Collect incoming values into a Collection that will be pushed into the returned Flux every timespan OR maxSize items.

bufferTimeoutMillis(int, long) - Method in class reactor.core.publisher.Flux

Collect incoming values into a List that will be pushed into the returned Flux every timespan OR maxSize items.

bufferTimeoutMillis(int, long, TimedScheduler) - Method in class reactor.core.publisher.Flux

Collect incoming values into a List that will be pushed into the returned Flux every timespan OR maxSize items

bufferTimeoutMillis(int, long, TimedScheduler, Supplier<C>) - Method in class reactor.core.publisher.Flux

Collect incoming values into a Collection that will be pushed into the returned Flux every timespan OR maxSize items

bufferUntil(Predicate<? super T>) - Method in class reactor.core.publisher.Flux

Collect incoming values into multiple List that will be pushed into the returned 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 that will be pushed into the returned Flux each time the given predicate returns true.

bufferWhile(Predicate<? super T>) - Method in class reactor.core.publisher.Flux

Collect incoming values into multiple List that will be pushed into the returned Flux.

busySpin() - Static method in class reactor.util.concurrent.WaitStrategy

Busy Spin strategy that uses a busy spin loop for consumers waiting on a barrier.

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(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() - Method in class reactor.core.publisher.Mono

Turn this Mono into a hot source and cache last emitted signals for further Subscriber.

cacheLast() - Static method in class reactor.core.publisher.ReplayProcessor

Create a ReplayProcessor from hot-cold ReplayProcessor that will not propagate cancel upstream if Subscription has been set.

cacheLastOrDefault(T) - Static method in class reactor.core.publisher.ReplayProcessor

Create a ReplayProcessor from hot-cold ReplayProcessor that will not propagate cancel upstream if Subscription has been set.

call() - Method in interface reactor.core.Fuseable.ScalarCallable

cancel() - Method in class reactor.core.publisher.BaseSubscriber

cancel() - Method in class reactor.core.publisher.BlockingSink

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.Operators.SubscriberAdapter

cancel() - Method in class reactor.core.publisher.UnicastProcessor

CANCEL_STACKTRACE - Static variable in class reactor.core.Exceptions

Deprecated.

Cancel stacktrace is always turned on given the exceptional frequency and the critical info it can provide

Cancellation - Interface in reactor.core

Deprecated.

use Disposable, will be removed in 3.1.0

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.

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.QueueSupplier

Calculate the next power of 2, greater than or equal to x.

checkpoint() - Method in class reactor.core.publisher.Flux

Activate 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 assembly tracing for this particular Flux and give it a description that will be reflected in the assembly traceback in case of an error upstream of the checkpoint.

checkpoint() - Method in class reactor.core.publisher.Mono

Activate 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 assembly tracing for this particular Mono and give it a description that will be reflected in the assembly traceback, in case of an error upstream of the checkpoint.

checkpoint() - Method in class reactor.core.publisher.ParallelFlux

Activate 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 assembly tracing for this particular ParallelFlux and give it a description that will be reflected in the assembly traceback, in case of an error upstream of the checkpoint.

checkRequest(long) - Static method in class reactor.core.publisher.Operators

Throws an exception if request is 0 or negative as specified in rule 3.09 of Reactive Streams

checkRequest(long, Subscriber<?>) - Static method in class reactor.core.publisher.Operators

Throws an exception if request is 0 or negative as specified in rule 3.09 of Reactive Streams

clear() - Method in class reactor.core.publisher.Operators.MonoSubscriber

clear() - Method in class reactor.core.publisher.UnicastProcessor

clear(Consumer<? super T>) - Method in class reactor.util.concurrent.OpenHashSet

close() - Method in class reactor.core.publisher.BlockingSink

collect(Supplier<E>, BiConsumer<E, ? super T>) - Method in class reactor.core.publisher.Flux

Collect the Flux sequence with the given collector and supplied container on subscribe.

collect(Collector<? super T, A, ? extends R>) - Method in class reactor.core.publisher.Flux

Collect the Flux sequence with the given collector and supplied container on subscribe.

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

Accumulate this Flux sequence in a List that is emitted to the returned Mono on onComplete.

collectMap(Function<? super T, ? extends K>) - Method in class reactor.core.publisher.Flux

Convert all this Flux sequence into a hashed map where the key is extracted by the given Function and the value will be the most recent emitted item for this key.

collectMap(Function<? super T, ? extends K>, Function<? super T, ? extends V>) - Method in class reactor.core.publisher.Flux

Convert all this Flux sequence into a hashed map where the key is extracted by the given function and the value will be the most recent extracted item for this key.

collectMap(Function<? super T, ? extends K>, Function<? super T, ? extends V>, Supplier<Map<K, V>>) - Method in class reactor.core.publisher.Flux

Convert all this Flux sequence into a supplied map where the key is extracted by the given function and the value will be the most recent extracted item for this key.

collectMultimap(Function<? super T, ? extends K>) - Method in class reactor.core.publisher.Flux

Convert this Flux sequence into a hashed map where the key is extracted by the given function and the value will be all the emitted item for this key.

collectMultimap(Function<? super T, ? extends K>, Function<? super T, ? extends V>) - Method in class reactor.core.publisher.Flux

Convert this Flux sequence into a hashed map where the key is extracted by the given function and the value will be all the extracted items for this key.

collectMultimap(Function<? super T, ? extends K>, Function<? super T, ? extends V>, Supplier<Map<K, Collection<V>>>) - Method in class reactor.core.publisher.Flux

Convert this Flux sequence into a supplied map where the key is extracted by the given function and the value will be all the extracted items for this key.

collectSortedList() - Method in class reactor.core.publisher.Flux

Accumulate and sort this Flux sequence in a List that is emitted to the returned Mono on onComplete.

collectSortedList(Comparator<? super T>) - Method in class reactor.core.publisher.Flux

Accumulate and sort using the given comparator this Flux sequence in a List that is emitted to the returned Mono on onComplete.

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 recent published values from all publishers.

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 recent published values from all publishers.

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 recent published values from all publishers.

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 recent published values from all publishers.

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 recent published values from all publishers.

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 recent published values from all publishers.

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 recent published values from all publishers.

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 recent published values from all publishers.

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 recent published values from all publishers.

complete() - Method in class reactor.core.publisher.BlockingSink

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 class reactor.core.publisher.Signal

Creates and returns a Signal of variety Type.COMPLETE.

complete() - Method in interface reactor.core.publisher.SynchronousSink

compose(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 for each new Subscriber.

compose(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.

composeGroup(Function<? super GroupedFlux<Integer, T>, ? extends Publisher<? extends U>>) - Method in class reactor.core.publisher.ParallelFlux

Allows composing operators off the 'rails', as individual GroupedFlux instances keyed by the zero based rail's index.

concat(Iterable<? extends Publisher<? extends T>>) - Static method in class reactor.core.publisher.Flux

Concat all sources pulled from the supplied Iterator on Publisher.subscribe(org.reactivestreams.Subscriber<? super T>) from the passed Iterable until Iterator.hasNext() returns false.

concat(Publisher<? extends Publisher<? extends T>>) - Static method in class reactor.core.publisher.Flux

Concat all sources emitted as an onNext signal from a parent Publisher.

concat(Publisher<? extends Publisher<? extends T>>, int) - Static method in class reactor.core.publisher.Flux

Concat all sources emitted as an onNext signal from a parent Publisher.

concat(Publisher<? extends T>...) - Static method in class reactor.core.publisher.Flux

Concat all sources pulled from the given Publisher array.

concatDelayError(Publisher<? extends Publisher<? extends T>>) - Static method in class reactor.core.publisher.Flux

Concat all sources emitted as an onNext signal from a parent Publisher.

concatDelayError(Publisher<? extends Publisher<? extends T>>, int) - Static method in class reactor.core.publisher.Flux

Concat all sources emitted as an onNext signal from a parent Publisher.

concatDelayError(Publisher<? extends Publisher<? extends T>>, boolean, int) - Static method in class reactor.core.publisher.Flux

Concat all sources emitted as an onNext signal from a parent Publisher.

concatDelayError(Publisher<? extends T>...) - Static method in class reactor.core.publisher.Flux

Concat all sources pulled from the given Publisher array.

concatMap(Function<? super T, ? extends Publisher<? extends V>>) - Method in class reactor.core.publisher.Flux

Bind dynamic sequences given this input sequence like Flux.flatMap(Function), but preserve ordering and concatenate emissions instead of merging (no interleave).

concatMap(Function<? super T, ? extends Publisher<? extends V>>, int) - Method in class reactor.core.publisher.Flux

Bind dynamic sequences given this input sequence like Flux.flatMap(Function), but preserve ordering and concatenate emissions instead of merging (no interleave).

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, Publisher<? extends V>>) - Method in class reactor.core.publisher.Flux

Bind dynamic sequences given this input sequence like Flux.flatMap(Function), but preserve ordering and concatenate emissions instead of merging (no interleave).

concatMapDelayError(Function<? super T, ? extends Publisher<? extends V>>, int) - Method in class reactor.core.publisher.Flux

Bind dynamic sequences given this input sequence like Flux.flatMap(Function), but preserve ordering and concatenate emissions instead of merging (no interleave).

concatMapDelayError(Function<? super T, ? extends Publisher<? extends V>>, boolean, int) - Method in class reactor.core.publisher.Flux

Bind dynamic sequences given this input sequence like Flux.flatMap(Function), but preserve ordering and concatenate emissions instead of merging (no interleave).

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

Bind Iterable sequences given this input sequence like Flux.flatMapIterable(Function), but preserve ordering and concatenate emissions instead of merging (no interleave).

concatMapIterable(Function<? super T, ? extends Iterable<? extends R>>, int) - Method in class reactor.core.publisher.Flux

Bind Iterable sequences given this input sequence like Flux.flatMapIterable(Function), but preserve ordering and concatenate emissions instead of merging (no interleave).

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

connect() - Method in class reactor.core.publisher.ConnectableFlux

Connect this ConnectableFlux to its source and return a Runnable 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.

connect() - Method in class reactor.core.publisher.EmitterProcessor

connect() - Method in class reactor.core.publisher.FluxProcessor

Trigger onSubscribe with a stateless subscription to signal this subscriber it can start receiving onNext, onComplete and onError calls.

connect() - Method in class reactor.core.publisher.ReplayProcessor

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

connectedInput() - Method in interface reactor.core.Loopback

connectedOutput() - Method in interface reactor.core.Loopback

connectSink() - Method in class reactor.core.publisher.FluxProcessor

Create a BlockingSink and attach it via Subscriber.onSubscribe(Subscription).

connectSink(boolean) - Method in class reactor.core.publisher.FluxProcessor

Prepare a BlockingSink and pass it to Subscriber.onSubscribe(Subscription) if the autostart flag is set to true.

contains(Object) - Method in interface reactor.core.Fuseable.QueueSubscription

containsAll(Collection<?>) - Method in interface reactor.core.Fuseable.QueueSubscription

count() - Method in class reactor.core.publisher.Flux

Counts the number of values in this Flux.

create(Subscriber<? super E>, boolean) - Static method in class reactor.core.publisher.BlockingSink

Create a BlockingSink to safely signal a target Subscriber or Processor.

create(Subscriber<? super E>) - Static method in class reactor.core.publisher.BlockingSink

Create a BlockingSink to safely signal a target Subscriber or Processor.

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 QueueSupplier.SMALL_BUFFER_SIZE backlog size, blockingWait Strategy and auto-cancel.

create(boolean) - Static method in class reactor.core.publisher.EmitterProcessor

Create a new EmitterProcessor using QueueSupplier.SMALL_BUFFER_SIZE backlog size, blockingWait Strategy and auto-cancel.

create(int) - Static method in class reactor.core.publisher.EmitterProcessor

Create a new EmitterProcessor using QueueSupplier.SMALL_BUFFER_SIZE backlog size, blockingWait Strategy and auto-cancel.

create(int, int) - Static method in class reactor.core.publisher.EmitterProcessor

Create a new EmitterProcessor using QueueSupplier.SMALL_BUFFER_SIZE backlog size, blockingWait Strategy and auto-cancel.

create(int, boolean) - Static method in class reactor.core.publisher.EmitterProcessor

Create a new EmitterProcessor using QueueSupplier.SMALL_BUFFER_SIZE backlog size, blockingWait Strategy and auto-cancel.

create(int, int, boolean) - Static method in class reactor.core.publisher.EmitterProcessor

Create a new EmitterProcessor using QueueSupplier.SMALL_BUFFER_SIZE backlog size, blockingWait Strategy and auto-cancel.

create(Consumer<? super FluxSink<T>>) - Static method in class reactor.core.publisher.Flux

Creates a Flux with multi-emission capabilities (synchronous or asynchronous) through the FluxSink API.

create(Consumer<? super FluxSink<T>>, FluxSink.OverflowStrategy) - Static method in class reactor.core.publisher.Flux

Creates a Flux with multi-emission capabilities (synchronous or asynchronous) 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(WaitStrategy) - 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 using QueueSupplier.SMALL_BUFFER_SIZE backlog size, blockingWait Strategy and auto-cancel.

create(int) - Static method in class reactor.core.publisher.ReplayProcessor

Create a new ReplayProcessor using a provided backlog size, blockingWait Strategy and auto-cancel.

create(int, boolean) - Static method in class reactor.core.publisher.ReplayProcessor

Create a new ReplayProcessor using a provided backlog size, blockingWait Strategy and auto-cancel.

create() - Static method in class reactor.core.publisher.TopicProcessor

Create a new TopicProcessor using QueueSupplier.SMALL_BUFFER_SIZE backlog size, blockingWait Strategy and auto-cancel.

create(String) - Static method in class reactor.core.publisher.TopicProcessor

Create a new TopicProcessor using QueueSupplier.SMALL_BUFFER_SIZE backlog size, blockingWait Strategy and auto-cancel.

create(boolean) - Static method in class reactor.core.publisher.TopicProcessor

Create a new TopicProcessor using QueueSupplier.SMALL_BUFFER_SIZE backlog size, blockingWait Strategy and the passed auto-cancel setting.

create(ExecutorService) - Static method in class reactor.core.publisher.TopicProcessor

Create a new TopicProcessor using QueueSupplier.SMALL_BUFFER_SIZE backlog size, blockingWait Strategy and auto-cancel.

create(ExecutorService, boolean) - Static method in class reactor.core.publisher.TopicProcessor

Create a new TopicProcessor using QueueSupplier.SMALL_BUFFER_SIZE backlog size, blockingWait Strategy and the passed auto-cancel setting.

create(String, int) - Static method in class reactor.core.publisher.TopicProcessor

Create a new TopicProcessor using QueueSupplier.SMALL_BUFFER_SIZE backlog size, blockingWait Strategy and the passed auto-cancel setting.

create(String, int, boolean) - Static method in class reactor.core.publisher.TopicProcessor

Create a new TopicProcessor using the blockingWait Strategy, passed backlog size, and auto-cancel settings.

create(ExecutorService, int) - Static method in class reactor.core.publisher.TopicProcessor

Create a new TopicProcessor using passed backlog size, blockingWait Strategy and will auto-cancel.

create(ExecutorService, int, boolean) - Static method in class reactor.core.publisher.TopicProcessor

Create a new TopicProcessor using passed backlog size, blockingWait Strategy and the auto-cancel argument.

create(String, int, WaitStrategy) - Static method in class reactor.core.publisher.TopicProcessor

Create a new TopicProcessor using passed backlog size, wait strategy and will auto-cancel.

create(String, int, WaitStrategy, Supplier<E>) - Static method in class reactor.core.publisher.TopicProcessor

Create a new TopicProcessor using passed backlog size, wait strategy, signal supplier.

create(String, int, WaitStrategy, boolean) - Static method in class reactor.core.publisher.TopicProcessor

Create a new TopicProcessor using passed backlog size, wait strategy and auto-cancel settings.

create(ExecutorService, int, WaitStrategy) - Static method in class reactor.core.publisher.TopicProcessor

Create a new TopicProcessor using passed backlog size, wait strategy and will auto-cancel.

create(ExecutorService, int, WaitStrategy, boolean) - Static method in class reactor.core.publisher.TopicProcessor

Create a new TopicProcessor using passed backlog size, wait strategy and auto-cancel settings.

create() - Static method in class reactor.core.publisher.UnicastProcessor

Create a unicast FluxProcessor that will buffer on a given queue in an unbounded fashion.

create(Queue<T>) - Static method in class reactor.core.publisher.UnicastProcessor

Create a unicast FluxProcessor that will buffer on a given queue in an unbounded fashion.

create(Queue<T>, Disposable) - Static method in class reactor.core.publisher.UnicastProcessor

Create a unicast FluxProcessor that will buffer on a given queue in an unbounded fashion.

create(Queue<T>, Consumer<? super T>, Disposable) - Static method in class reactor.core.publisher.UnicastProcessor

Create a unicast FluxProcessor that will buffer on a given queue in an unbounded fashion.

create() - Static method in class reactor.core.publisher.WorkQueueProcessor

Create a new WorkQueueProcessor using QueueSupplier.SMALL_BUFFER_SIZE backlog size, blockingWait Strategy and auto-cancel.

create(boolean) - Static method in class reactor.core.publisher.WorkQueueProcessor

Create a new WorkQueueProcessor using QueueSupplier.SMALL_BUFFER_SIZE backlog size, blockingWait Strategy and the passed auto-cancel setting.

create(ExecutorService) - Static method in class reactor.core.publisher.WorkQueueProcessor

Create a new WorkQueueProcessor using QueueSupplier.SMALL_BUFFER_SIZE backlog size, blockingWait Strategy and auto-cancel.

create(ExecutorService, boolean) - Static method in class reactor.core.publisher.WorkQueueProcessor

Create a new WorkQueueProcessor using QueueSupplier.SMALL_BUFFER_SIZE backlog size, blockingWait Strategy and the passed auto-cancel setting.

create(String) - Static method in class reactor.core.publisher.WorkQueueProcessor

Create a new TopicProcessor using the default buffer size 32, blockingWait Strategy and auto-cancel.

create(String, int) - Static method in class reactor.core.publisher.WorkQueueProcessor

Create a new TopicProcessor using the passed buffer size, blockingWait Strategy and auto-cancel.

create(String, int, boolean) - Static method in class reactor.core.publisher.WorkQueueProcessor

Create a new TopicProcessor using the passed buffer size, blockingWait Strategy and the passed auto-cancel setting.

create(ExecutorService, int) - Static method in class reactor.core.publisher.WorkQueueProcessor

Create a new TopicProcessor using the passed buffer size, blockingWait Strategy and auto-cancel.

create(ExecutorService, int, boolean) - Static method in class reactor.core.publisher.WorkQueueProcessor

Create a new WorkQueueProcessor using the passed buffer size, blockingWait Strategy and auto-cancel.

create(String, int, WaitStrategy) - Static method in class reactor.core.publisher.WorkQueueProcessor

Create a new WorkQueueProcessor using the passed buffer size, blockingWait Strategy and auto-cancel.

create(String, int, WaitStrategy, boolean) - Static method in class reactor.core.publisher.WorkQueueProcessor

Create a new WorkQueueProcessor using the passed buffer size, blockingWait Strategy and auto-cancel settings.

create(ExecutorService, int, WaitStrategy) - Static method in class reactor.core.publisher.WorkQueueProcessor

Create a new WorkQueueProcessor using the passed buffer size and blockingWait Strategy settings but will auto-cancel.

create(ExecutorService, int, WaitStrategy, boolean) - Static method in class reactor.core.publisher.WorkQueueProcessor

Create a new WorkQueueProcessor using the passed buffer size, wait strategy and auto-cancel settings.

createSizeAndTimeout(int, Duration) - Static method in class reactor.core.publisher.ReplayProcessor

Creates a time- and size-bounded replay processor.

createSizeAndTimeoutMillis(int, long, TimedScheduler) - 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.

createTimeoutMillis(long, TimedScheduler) - 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 that executed task in a strict FIFO order, guaranteed non-concurrently with each other.

createWorker() - Method in interface reactor.core.scheduler.TimedScheduler

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(String, Supplier<? extends ExecutorService>) - Static method in class reactor.core.scheduler.Schedulers

decorateExecutorService(String, Supplier<? extends ExecutorService>) - Method in interface reactor.core.scheduler.Schedulers.Factory

decorateScheduledExecutorService(String, Supplier<? extends ScheduledExecutorService>) - Static method in class reactor.core.scheduler.Schedulers

decorateScheduledExecutorService(String, Supplier<? extends ScheduledExecutorService>) - Method in interface reactor.core.scheduler.Schedulers.Factory

DEFAULT_POOL_SIZE - Static variable in class reactor.core.scheduler.Schedulers

Default number of processors available to the runtime on init (min 4)

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 unique value if this mono is completed without any data

defer(Supplier<? extends Publisher<T>>) - Static method in class reactor.core.publisher.Flux

Supply a Publisher everytime subscribe is called on the returned flux.

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

delay(Duration) - Method in class reactor.core.publisher.Flux

Deprecated.

will be replaced by Flux.delayElements(Duration) in 3.1.0

delay(Duration) - Static method in class reactor.core.publisher.Mono

Create a Mono which delays an onNext signal of duration of given unit and complete on the global timer.

delayElement(Duration) - Method in class reactor.core.publisher.Mono

Delay this Flux element (Subscriber.onNext(T) signal) by a given duration.

delayElementMillis(long) - Method in class reactor.core.publisher.Mono

Delay this Flux element (Subscriber.onNext(T) signal) by a given duration, in milliseconds.

delayElementMillis(long, TimedScheduler) - Method in class reactor.core.publisher.Mono

Delay this Flux element (Subscriber.onNext(T) signal) by a given duration, in milliseconds.

delayElements(Duration) - Method in class reactor.core.publisher.Flux

Delay each of this Flux elements (Subscriber.onNext(T) signals) by a given duration.

delayElementsMillis(long) - Method in class reactor.core.publisher.Flux

Delay each of this Flux elements (Subscriber.onNext(T) signals) by a given duration in milliseconds.

delayElementsMillis(long, TimedScheduler) - Method in class reactor.core.publisher.Flux

Delay each of this Flux elements (Subscriber.onNext(T) signals) by a given duration in milliseconds.

delayMillis(long) - Method in class reactor.core.publisher.Flux

Deprecated.

will be replaced by Flux.delayElementsMillis(long) in 3.1.0

delayMillis(long, TimedScheduler) - Method in class reactor.core.publisher.Flux

Deprecated.

will be replaced by Flux.delayElementsMillis(long, TimedScheduler) in 3.1.0

delayMillis(long) - Static method in class reactor.core.publisher.Mono

Create a Mono which delays an onNext signal of duration milliseconds and complete.

delayMillis(long, TimedScheduler) - Static method in class reactor.core.publisher.Mono

Create a Mono which delays an onNext signal of duration milliseconds and complete.

delaySubscription(Duration) - Method in class reactor.core.publisher.Flux

Delay the subscription to this Flux source until the given period elapses.

delaySubscription(Publisher<U>) - Method in class reactor.core.publisher.Flux

Delay the subscription to the main 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(Publisher<U>) - Method in class reactor.core.publisher.Mono

Delay the subscription to this Mono until another Publisher signals a value or completes.

delaySubscriptionMillis(long) - Method in class reactor.core.publisher.Flux

Delay the subscription to this Flux source until the given period elapses.

delaySubscriptionMillis(long, TimedScheduler) - Method in class reactor.core.publisher.Flux

Delay the subscription to this Flux source until the given period elapses.

delaySubscriptionMillis(long) - Method in class reactor.core.publisher.Mono

Delay the subscription to this Mono source until the given period elapses.

delaySubscriptionMillis(long, TimedScheduler) - Method in class reactor.core.publisher.Mono

Delay the subscription to this Mono source until the given period elapses.

dematerialize() - Method in class reactor.core.publisher.Flux

A "phantom-operator" working only if this Flux is a emits onNext, onError or onComplete Signal.

dematerialize() - Method in class reactor.core.publisher.Mono

A "phantom-operator" working only if this Mono is a emits onNext, onError or onComplete Signal.

DirectProcessor<T> - Class in reactor.core.publisher

Dispatches onNext, onError and onComplete signals to zero-to-many Subscribers.

Disposable - Interface in reactor.core

Indicates that a task or resource can be cancelled/disposed.

dispose() - Method in interface reactor.core.Cancellation

Deprecated.

Cancel or dispose the underlying task or resource.

dispose() - Method in interface reactor.core.Disposable

Cancel or dispose the underlying task or resource.

dispose() - Method in class reactor.core.publisher.BaseSubscriber

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.

dispose() - Method in interface reactor.core.scheduler.Scheduler.Worker

Instructs this worker to cancel all pending tasks, all running tasks in a best-effort manner, reject new tasks and release any resources associated with it.

distinct() - Method in class reactor.core.publisher.Flux

For each Subscriber, tracks this Flux values that have been seen and filters out duplicates.

distinct(Function<? super T, ? extends V>) - Method in class reactor.core.publisher.Flux

For each Subscriber, tracks this Flux values that have been seen and filters out duplicates given the extracted key.

distinctUntilChanged() - Method in class reactor.core.publisher.Flux

Filters out subsequent and repeated elements.

distinctUntilChanged(Function<? super T, ? extends V>) - Method in class reactor.core.publisher.Flux

Filters out subsequent and repeated elements provided a matching extracted key.

doAfterTerminate(Runnable) - Method in class reactor.core.publisher.Flux

Triggered after the Flux terminates, either by completing downstream successfully or with an error.

doAfterTerminate(BiConsumer<? super T, Throwable>) - Method in class reactor.core.publisher.Mono

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.

doCancel() - Method in class reactor.core.publisher.Operators.SubscriberAdapter

doComplete() - Method in class reactor.core.publisher.Operators.SubscriberAdapter

doComplete() - Method in class reactor.core.publisher.TopicProcessor

doComplete() - Method in class reactor.core.publisher.WorkQueueProcessor

doError(Throwable) - Method in class reactor.core.publisher.Operators.SubscriberAdapter

doError(Throwable) - Method in class reactor.core.publisher.TopicProcessor

doError(Throwable) - Method in class reactor.core.publisher.WorkQueueProcessor

doFinally(Consumer<SignalType>) - Method in class reactor.core.publisher.Flux

doFinally(Consumer<SignalType>) - Method in class reactor.core.publisher.Mono

doNext(I) - Method in class reactor.core.publisher.Operators.SubscriberAdapter

doOnCancel(Runnable) - Method in class reactor.core.publisher.Flux

Triggered when the Flux is cancelled.

doOnCancel(Runnable) - Method in class reactor.core.publisher.Mono

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

Triggered when the Flux completes successfully.

doOnComplete(Runnable) - Method in class reactor.core.publisher.ParallelFlux

Run the specified runnable when a 'rail' completes.

doOnEach(Consumer<? super Signal<T>>) - Method in class reactor.core.publisher.Flux

Triggers side-effects when the Flux emits an item, fails with an error or completes successfully.

doOnEach(Consumer<? super T>, Consumer<? super Throwable>, Runnable, Runnable) - Method in class reactor.core.publisher.Hooks.OperatorHook

Peek into sequence signals.

doOnEach(Consumer<? super Signal<T>>) - Method in class reactor.core.publisher.Mono

Triggers side-effects 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

Triggered when the Flux completes with an error.

doOnError(Class<E>, Consumer<? super E>) - Method in class reactor.core.publisher.Flux

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

Triggered when the Flux completes with an error matching the given exception.

doOnError(Consumer<? super Throwable>) - Method in class reactor.core.publisher.Mono

Triggered when the Mono completes with an error.

doOnError(Class<E>, Consumer<? super E>) - Method in class reactor.core.publisher.Mono

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

Triggered when the Mono completes with an error matching the given exception.

doOnError(Consumer<? super Throwable>) - Method in class reactor.core.publisher.ParallelFlux

Call the specified consumer with the exception passing through any 'rail'.

doOnLifecycle(Consumer<? super Subscription>, LongConsumer, Runnable) - Method in class reactor.core.publisher.Hooks.OperatorHook

Peek into lifecycle signals.

doOnNext(Consumer<? super T>) - Method in class reactor.core.publisher.Flux

Triggered when the Flux emits an item.

doOnNext(Consumer<? super T>) - Method in class reactor.core.publisher.Mono

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

Attach a LongConsumer to this Flux that will observe any request to this Flux.

doOnRequest(LongConsumer) - Method in class reactor.core.publisher.Mono

Attach a LongConsumer to this Mono that will observe any request to this Mono.

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

Triggered when the Flux is subscribed.

doOnSubscribe(Consumer<? super Subscription>) - Method in class reactor.core.publisher.Mono

Triggered when the Mono is subscribed.

doOnSubscribe(Subscription) - Method in class reactor.core.publisher.Operators.SubscriberAdapter

Hook for further processing of onSubscribe's 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.

doOnSubscriberError(Throwable) - Method in class reactor.core.publisher.Operators.SubscriberAdapter

doOnSuccess(Consumer<? super T>) - Method in class reactor.core.publisher.Mono

Triggered when the Mono completes successfully.

doOnTerminate(Runnable) - Method in class reactor.core.publisher.Flux

Triggered when the Flux terminates, either by completing successfully or with an error.

doOnTerminate(BiConsumer<? super T, Throwable>) - Method in class reactor.core.publisher.Mono

Triggered when the Mono terminates, either by completing successfully or 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.

doRequest(long) - Method in class reactor.core.publisher.Operators.SubscriberAdapter

downstream() - Method in interface reactor.core.Producer

Return the direct data receiver.

downstream() - Method in class reactor.core.publisher.BlockingSink

downstream() - Method in class reactor.core.publisher.MonoProcessor

downstream() - Method in class reactor.core.publisher.Operators.MonoSubscriber

downstream() - Method in class reactor.core.publisher.Operators.SubscriberAdapter

downstream() - Method in class reactor.core.publisher.UnicastProcessor

downstreamCount() - Method in interface reactor.core.MultiProducer

the number of downstream receivers

downstreamCount() - Method in class reactor.core.publisher.DirectProcessor

downstreamCount() - Method in class reactor.core.publisher.EmitterProcessor

downstreamCount() - Method in class reactor.core.publisher.MonoProcessor

downstreamCount() - Method in class reactor.core.publisher.ReplayProcessor

downstreams() - Method in interface reactor.core.MultiProducer

the connected data receivers

downstreams() - Method in class reactor.core.publisher.DirectProcessor

downstreams() - Method in class reactor.core.publisher.EmitterProcessor

downstreams() - Method in class reactor.core.publisher.MonoProcessor

downstreams() - Method in class reactor.core.publisher.ReplayProcessor

drain() - Method in class reactor.core.publisher.TopicProcessor

drain() - Method in class reactor.core.publisher.WorkQueueProcessor

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 sequence into Tuple2 of T1 Long timemillis and T2 T associated data.

elapsed(TimedScheduler) - Method in class reactor.core.publisher.Flux

Map this Flux sequence into Tuple2 of T1 Long timemillis and T2 T associated data.

elapsed() - Method in class reactor.core.publisher.Mono

Map this Mono sequence into Tuple2 of T1 Long timemillis and T2 T associated data.

elapsed(TimedScheduler) - Method in class reactor.core.publisher.Mono

Map this Mono sequence into Tuple2 of T1 Long timemillis and T2 T associated 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 signals a default value if specified if the sequence is shorter.

emit(E) - Method in class reactor.core.publisher.BlockingSink

A non-blocking Subscriber.onNext(Object) that will return a status BlockingSink.Emission.

EmitterProcessor<T> - Class in reactor.core.publisher

An implementation of a RingBuffer backed 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(Publisher<T>) - Static method in class reactor.core.publisher.Mono

Create a new Mono that ignores onNext (dropping them) and only react on Completion signal.

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.

equals(Object) - Method in class reactor.core.publisher.Signal

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) - Method in class reactor.core.publisher.BlockingSink

Try calling Subscriber.onError(Throwable) on the delegate Subscriber.

error(Throwable) - Static method in class reactor.core.publisher.Flux

Create a Flux that completes with the specified error.

error(Throwable, boolean) - Static method in class reactor.core.publisher.Flux

Build a Flux that will only emit an error signal to any new subscriber.

error(Throwable) - Method in interface reactor.core.publisher.FluxSink

error(Throwable) - Static method in class reactor.core.publisher.Mono

Create a Mono that completes with the specified error immediately after onSubscribe.

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 class reactor.core.publisher.Signal

Creates and returns a Signal of variety Type.FAILED, and assigns it an error.

error(Throwable) - Method in interface reactor.core.publisher.SynchronousSink

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

Exceptions - Class in reactor.core

Global Reactor Core Exception handling and utils to operate on.

expectedFromUpstream() - Method in class reactor.core.publisher.EmitterProcessor

expectedFromUpstream() - Method in class reactor.core.publisher.MonoProcessor

expectedFromUpstream() - Method in interface reactor.core.Trackable

F

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

filter(Predicate<? super T>) - Method in class reactor.core.publisher.Flux

Evaluate each accepted value against the given Predicate.

filter(Predicate<? super T>) - Method in class reactor.core.publisher.Mono

Test the result if any of this Mono 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'.

finish() - Method in class reactor.core.publisher.BlockingSink

Try emitting BlockingSink.complete() to the decorated Subscriber.

first(Mono<? extends T>...) - Static method in class reactor.core.publisher.Mono

Pick the first result coming from any of the given monos and populate a new Mono.

first(Iterable<? extends Mono<? extends T>>) - Static method in class reactor.core.publisher.Mono

Pick the first result coming from any of the given monos and populate a new Mono.

firstEmitting(Publisher<? extends I>...) - Static method in class reactor.core.publisher.Flux

Select the fastest source who emitted first onNext or onComplete or onError

firstEmitting(Iterable<? extends Publisher<? extends I>>) - Static method in class reactor.core.publisher.Flux

Select the fastest source who won the "ambiguous" race and emitted first onNext or onComplete or onError

firstEmittingWith(Publisher<? extends T>) - Method in class reactor.core.publisher.Flux

Emit from the fastest first sequence between this publisher and the given publisher

flatMap(Function<? super T, ? extends Publisher<? extends R>>) - Method in class reactor.core.publisher.Flux

Transform the items emitted by this Flux into Publishers, then flatten the emissions from those by merging them into a single Flux, so that they may interleave.

flatMap(Function<? super T, ? extends Publisher<? extends V>>, int) - Method in class reactor.core.publisher.Flux

Transform the items emitted by this Flux into Publishers, then flatten the emissions from those by merging them into a single Flux, so that they may interleave.

flatMap(Function<? super T, ? extends Publisher<? extends V>>, int, int) - Method in class reactor.core.publisher.Flux

Transform the items emitted by this Flux into Publishers, then flatten the emissions from those by merging them into a single Flux, so that they may interleave.

flatMap(Function<? super T, ? extends Publisher<? extends V>>, boolean, int, int) - Method in class reactor.core.publisher.Flux

Transform the items emitted by this Flux into Publishers, then flatten the emissions from those by merging them into a single Flux, so that they may interleave.

flatMap(Function<? super T, ? extends Publisher<? extends R>>, Function<Throwable, ? extends Publisher<? extends R>>, Supplier<? extends Publisher<? extends R>>) - Method in class reactor.core.publisher.Flux

Transform the signals emitted by this Flux into Publishers, then flatten the emissions from those by merging them into a single Flux, so that they may interleave.

flatMap(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.

flatMap(Function<? super T, ? extends Publisher<? extends R>>, Function<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 a Publisher, then forward its emissions into the returned Flux.

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.

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.

flatMapSequential(Function<? super T, ? extends Publisher<? extends R>>) - Method in class reactor.core.publisher.Flux

Transform the items emitted by this Flux into Publishers, then flatten the emissions from those by merging them into a single Flux, in order.

flatMapSequential(Function<? super T, ? extends Publisher<? extends R>>, int) - Method in class reactor.core.publisher.Flux

Transform the items emitted by this Flux into Publishers, then flatten the emissions from those by merging them into a single Flux, in order.

flatMapSequential(Function<? super T, ? extends Publisher<? extends R>>, int, int) - Method in class reactor.core.publisher.Flux

Transform the items emitted by this Flux into Publishers, then flatten the emissions from those by merging them into a single Flux, in order.

flatMapSequential(Function<? super T, ? extends Publisher<? extends R>>, boolean, int, int) - Method in class reactor.core.publisher.Flux

Transform the items emitted by this Flux into Publishers, then flatten the emissions from those by merging them into a single Flux, in order.

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

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.

FluxSource<I,O> - Class in reactor.core.publisher

A connecting Flux Publisher (right-to-left from a composition chain perspective)

FluxSource(Publisher<? extends I>) - Constructor for class reactor.core.publisher.FluxSource

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

Expose 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' (number of CPUs) 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 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 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.

fromArray(T[]) - Static method in class reactor.core.publisher.Flux

Create a Flux that emits the items contained in the provided Iterable.

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 the value for the Mono using the given supplier.

fromCompletionStage(CompletionStage<? extends T>) - Static method in class reactor.core.publisher.Mono

Create a Mono producing the value for the Mono using the given CompletionStage.

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, boolean) - 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 the value for the Mono using the given CompletableFuture.

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 only producing a completion signal after using the given runnable.

fromStream(Stream<? extends T>) - Static method in class reactor.core.publisher.Flux

Create a Flux that emits the items contained in the provided Stream.

fromSupplier(Supplier<? extends T>) - Static method in class reactor.core.publisher.Mono

Create a Mono producing the value for the Mono using the given 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, avoiding the usual request(1) for dropped values.

Fuseable.QueueSubscription<T> - Interface in reactor.core

Contract queue-fusion based optimizations for supporting subscriptions.

Fuseable.ScalarCallable<T> - Interface in reactor.core

Marker interface indicating that the target can return a value or null 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 its 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

Generate signals one-by-one via a consumer callback.

generate(Callable<S>, BiFunction<S, SynchronousSink<T>, S>) - Static method in class reactor.core.publisher.Flux

Generate signals one-by-one via a function callback.

generate(Callable<S>, BiFunction<S, SynchronousSink<T>, S>, Consumer<? super S>) - Static method in class reactor.core.publisher.Flux

Generate signals one-by-one via a function callback.

get() - Method in class reactor.core.publisher.MutableNextSignal

get() - Method in class reactor.core.publisher.Signal

Retrieves the item associated with this (onNext) signal.

get(int) - Static method in class reactor.util.concurrent.QueueSupplier

get() - Method in class reactor.util.concurrent.QueueSupplier

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

getAndAddCap(AtomicLongFieldUpdater<T>, T, long) - Static method in class reactor.core.publisher.Operators

Concurrent addition bound to Long.MAX_VALUE.

getAsLong() - Method in class reactor.core.publisher.MonoProcessor

Returns the internal state from -1 Cancelled to 5 errored, beyond 3 included is fulfilled.

getCapacity() - Method in class reactor.core.publisher.BlockingSink

getCapacity() - Method in class reactor.core.publisher.EmitterProcessor

getCapacity() - Method in class reactor.core.publisher.FluxProcessor

getCapacity() - Method in class reactor.core.publisher.Operators.SubscriberAdapter

getCapacity() - Method in class reactor.core.publisher.ReplayProcessor

getCapacity() - Method in class reactor.core.publisher.UnicastProcessor

getCapacity() - Method in interface reactor.core.Trackable

Return defined element capacity

getError() - Method in class reactor.core.publisher.BlockingSink

getError() - Method in class reactor.core.publisher.DirectProcessor

getError() - Method in class reactor.core.publisher.EmitterProcessor

getError() - Method in class reactor.core.publisher.MonoProcessor

getError() - Method in class reactor.core.publisher.UnicastProcessor

getError() - Method in interface reactor.core.Trackable

Current error if any, default to null

getLogger(String) - Static method in class reactor.util.Loggers

Try getting an appropriate Logger whether SLF4J is not present on the classpath or fallback to Logger.

getLogger(Class<?>) - Static method in class reactor.util.Loggers

Try getting an appropriate Logger whether SLF4J is not present on the classpath or fallback to Logger.

getName() - Method in interface reactor.util.Logger

Return the name of this Logger instance.

getPending() - Method in class reactor.core.publisher.EmitterProcessor

getPending() - Method in class reactor.core.publisher.MonoProcessor

getPending() - Method in class reactor.core.publisher.Operators.SubscriberAdapter

getPending() - Method in class reactor.core.publisher.TopicProcessor

getPending() - Method in class reactor.core.publisher.WorkQueueProcessor

getPending() - Method in interface reactor.core.Trackable

Return current used space in buffer

getPrefetch() - Method in class reactor.core.publisher.DirectProcessor

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 class reactor.core.publisher.MutableNextSignal

getSubscription() - Method in class 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 class reactor.core.publisher.MutableNextSignal

getThrowable() - Method in class reactor.core.publisher.Signal

Read the error associated with this (onError) signal.

getType() - Method in class reactor.core.publisher.MutableNextSignal

getType() - Method in class reactor.core.publisher.Signal

Read the type of this signal: Subscribe, Next, Error, or Complete

groupBy(Function<? super T, ? extends K>) - Method in class reactor.core.publisher.Flux

Re-route this sequence into dynamically created Flux for each unique key evaluated by the given key mapper.

groupBy(Function<? super T, ? extends K>, int) - Method in class reactor.core.publisher.Flux

Re-route this sequence into dynamically created Flux for each unique key evaluated by the given key mapper.

groupBy(Function<? super T, ? extends K>, Function<? super T, ? extends V>) - Method in class reactor.core.publisher.Flux

Re-route this sequence into dynamically created Flux for each unique key evaluated by the given key mapper.

groupBy(Function<? super T, ? extends K>, Function<? super T, ? extends V>, int) - Method in class reactor.core.publisher.Flux

Re-route this sequence into dynamically created Flux for each unique key evaluated by the given key mapper.

GroupedFlux<K,V> - Class in reactor.core.publisher

Represents a sequence of events with 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

Returns a Flux that correlates two Publishers when they overlap in time and groups the results.

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.DirectProcessor

hasDownstreams() - Method in interface reactor.core.MultiProducer

Has any Subscriber attached to this multi-producer ?

hasDownstreams() - Method in class reactor.core.publisher.DirectProcessor

hasDownstreams() - Method in class reactor.core.publisher.MonoProcessor

hasElement(T) - Method in class reactor.core.publisher.Flux

Emit a single boolean true if any of the values of this Flux sequence match the constant.

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.DirectProcessor

hasError() - Method in class reactor.core.publisher.Signal

Read whether this signal is on error and carries the cause.

hasFailed() - Method in class reactor.core.publisher.BlockingSink

hashCode() - Method in class reactor.core.publisher.Signal

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

hasRequested() - Method in class reactor.core.publisher.BlockingSink

hasValue() - Method in class reactor.core.publisher.Signal

Has this signal an item associated with it ?

hide() - Method in class reactor.core.publisher.Flux

Hides the identities of this Flux and its Subscription as well.

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

Allows for various lifecycle override

Hooks.OperatorHook<T> - Class in reactor.core.publisher

Filtering and Handling options to apply on a given Publisher

I

ifFlux() - Method in class reactor.core.publisher.Hooks.OperatorHook

Apply hook only if Hooks.OperatorHook.publisher() is Flux

ifMono() - Method in class reactor.core.publisher.Hooks.OperatorHook

Apply hook only if Hooks.OperatorHook.publisher() is Mono

ifName(String...) - Method in class reactor.core.publisher.Hooks.OperatorHook

Apply hook only if Hooks.OperatorHook.publisher() if operator name match the type name (case insensitive, without Mono/Flux prefix or Fuseable suffix.

ifNameContains(String...) - Method in class reactor.core.publisher.Hooks.OperatorHook

Apply hook only if Hooks.OperatorHook.publisher() if operator name match the type name (case insensitive, without Mono/Flux prefix or Fuseable suffix.

ifParallelFlux() - Method in class reactor.core.publisher.Hooks.OperatorHook

Apply hook only if Hooks.OperatorHook.publisher() is ParallelFlux

ignore() - Method in class reactor.core.publisher.Hooks.OperatorHook

Discard all Hooks.OperatorHook applied to the current Hooks.OperatorHook.publisher()

ignoreElement() - Method in class reactor.core.publisher.Mono

Ignores onNext signal (dropping it) and only reacts on termination.

ignoreElements() - Method in class reactor.core.publisher.Flux

Ignores onNext signals (dropping them) and only reacts on termination.

ignoreElements(Publisher<T>) - Static method in class reactor.core.publisher.Mono

Create a new Mono that ignores onNext (dropping them) and only react on Completion signal.

immediate() - Static method in class reactor.core.scheduler.Schedulers

Executes tasks on the caller's thread immediately.

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.

innerToString() - Method in class reactor.util.function.Tuple2

innerToString() - Method in class reactor.util.function.Tuple3

innerToString() - Method in class reactor.util.function.Tuple4

innerToString() - Method in class reactor.util.function.Tuple5

innerToString() - Method in class reactor.util.function.Tuple6

innerToString() - Method in class reactor.util.function.Tuple7

innerToString() - Method in class reactor.util.function.Tuple8

interval(Duration) - Static method in class reactor.core.publisher.Flux

Create a new Flux that emits an ever incrementing long starting with 0 every period on the global timer.

interval(Duration, Duration) - Static method in class reactor.core.publisher.Flux

Create a new Flux that emits an ever incrementing long starting with 0 every N period of time unit on a global timer.

intervalMillis(long) - Static method in class reactor.core.publisher.Flux

Create a new Flux that emits an ever incrementing long starting with 0 every N milliseconds on the given timer.

intervalMillis(long, TimedScheduler) - Static method in class reactor.core.publisher.Flux

Create a new Flux that emits an ever incrementing long starting with 0 every N milliseconds on the given timer.

intervalMillis(long, long) - Static method in class reactor.core.publisher.Flux

Create a new Flux that emits an ever incrementing long starting with 0 every N period of time unit on a global timer.

intervalMillis(long, long, TimedScheduler) - Static method in class reactor.core.publisher.Flux

Create a new Flux that emits an ever incrementing long starting with 0 every N period of time unit on the given timer.

isAlert(Throwable) - Static method in class reactor.util.concurrent.WaitStrategy

Test if exception is alert

isBackpressured() - Method in enum reactor.core.publisher.BlockingSink.Emission

isBubbling(Throwable) - Static method in class reactor.core.Exceptions

Check if the given error 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 enum reactor.core.publisher.BlockingSink.Emission

isCancelled() - Method in class reactor.core.publisher.BlockingSink

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

isCancelled() - Method in class reactor.core.publisher.Operators.DeferredSubscription

Returns true if this arbiter has been cancelled.

isCancelled() - Method in class reactor.core.publisher.Operators.MonoSubscriber

Returns true if this Subscription has been cancelled.

isCancelled() - Method in class reactor.core.publisher.UnicastProcessor

isCancelled() - Method in interface reactor.core.Trackable

isComplete(Object) - Static method in class reactor.core.publisher.Signal

isDebugEnabled() - Method in interface reactor.util.Logger

Is the logger instance enabled for the DEBUG level?

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

isEmpty() - Method in class reactor.core.publisher.Operators.MonoSubscriber

isEmpty() - Method in class reactor.core.publisher.UnicastProcessor

isEmpty() - Method in class reactor.util.concurrent.OpenHashSet

isError() - Method in class reactor.core.publisher.MonoProcessor

Indicates whether this MonoProcessor has been completed with an error.

isError(Object) - Static method in class reactor.core.publisher.Signal

isErrorCallbackNotImplemented(Throwable) - Static method in class reactor.core.Exceptions

Return an UnsupportedOperationException

isErrorEnabled() - Method in interface reactor.util.Logger

Is the logger instance enabled for the ERROR level?

isFailed() - Method in enum reactor.core.publisher.BlockingSink.Emission

isInfoEnabled() - Method in interface reactor.util.Logger

Is the logger instance enabled for the INFO level?

isOk() - Method in enum reactor.core.publisher.BlockingSink.Emission

isOnComplete() - Method in class reactor.core.publisher.Signal

Indicates whether this signal represents an onComplete event.

isOnError() - Method in class reactor.core.publisher.Signal

Indicates whether this signal represents an onError event.

isOnNext() - Method in class reactor.core.publisher.Signal

Indicates whether this signal represents an onNext event.

isOnSubscribe() - Method in class reactor.core.publisher.Signal

Indicates whether this signal represents an onSubscribe event.

isOrdered() - Method in class reactor.core.publisher.ParallelFlux

Deprecated.

This accessor was initially exposed to introspect the internal ordering scenario for parallel rails. In effect reactor 3.0 and 3.1 only offer non ordered merge at the end and therefore this should always returns false;

isOverflow(Throwable) - Static method in class reactor.core.Exceptions

isPowerOfTwo(int) - Static method in class reactor.util.concurrent.QueueSupplier

isStarted() - Method in class reactor.core.publisher.BaseSubscriber

isStarted() - Method in class reactor.core.publisher.DirectProcessor

isStarted() - Method in class reactor.core.publisher.EmitterProcessor

isStarted() - Method in class reactor.core.publisher.MonoProcessor

isStarted() - Method in class reactor.core.publisher.Operators.DeferredSubscription

isStarted() - Method in class reactor.core.publisher.Operators.MonoSubscriber

isStarted() - Method in class reactor.core.publisher.Operators.SubscriberAdapter

isStarted() - Method in class reactor.core.publisher.ReplayProcessor

isStarted() - Method in class reactor.core.publisher.UnicastProcessor

isStarted() - Method in interface reactor.core.Trackable

Has this upstream started or "onSubscribed" ?

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.BaseSubscriber

isTerminated() - Method in class reactor.core.publisher.DirectProcessor

isTerminated() - Method in class reactor.core.publisher.EmitterProcessor

isTerminated() - Method in class reactor.core.publisher.MonoProcessor

isTerminated() - Method in class reactor.core.publisher.Operators.DeferredSubscription

isTerminated() - Method in class reactor.core.publisher.Operators.MonoSubscriber

isTerminated() - Method in class reactor.core.publisher.Operators.SubscriberAdapter

isTerminated() - Method in class reactor.core.publisher.ReplayProcessor

isTerminated() - Method in class reactor.core.publisher.UnicastProcessor

isTerminated() - Method in interface reactor.core.Trackable

Has this upstream finished or "completed" / "failed" ?

isTraceEnabled() - Method in interface reactor.util.Logger

Is the logger instance enabled for the TRACE level?

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

J

JdkFlowAdapter - Class in reactor.adapter

Convert a Java 9+ Flow.Publisher to/from a Reactive Streams Publisher.

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

Returns a Flux that correlates two Publishers when they overlap in time and groups the results.

just(T...) - Static method in class reactor.core.publisher.Flux

Create a new Flux that emits the specified items and then complete.

just(T) - Static method in class reactor.core.publisher.Flux

Create a new Flux that will only emit the passed data then onComplete.

just(T) - Static method in class reactor.core.publisher.Mono

Create a new Mono that emits the specified item.

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 defined identifier

keys() - Method in class reactor.util.concurrent.OpenHashSet

L

last() - Method in class reactor.core.publisher.Flux

Signal the last element observed before complete signal or emit NoSuchElementException error if the source was empty.

last(T) - Method in class reactor.core.publisher.Flux

Signal the last element observed before complete signal or emit the defaultValue if empty.

limit() - Method in class reactor.core.publisher.EmitterProcessor

limit() - Method in class reactor.core.publisher.MonoProcessor

limit() - Method in interface reactor.core.Trackable

limitRate(int) - Method in class reactor.core.publisher.Flux

Ensure that backpressure signals from downstream subscribers are capped at the provided prefetchRate when propagated upstream, effectively rate limiting the upstream Publisher.

liteBlocking() - Static method in class reactor.util.concurrent.WaitStrategy

Variation of the WaitStrategy.blocking() that attempts to elide conditional wake-ups when the lock is uncontended.

log() - Method in class reactor.core.publisher.Flux

Observe all Reactive Streams signals and use Logger support to handle trace implementation.

log(String) - Method in class reactor.core.publisher.Flux

Observe all Reactive Streams signals and use Logger support to handle trace implementation.

log(String, Level, SignalType...) - Method in class reactor.core.publisher.Flux

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.Flux

Observe Reactive Streams signals matching the passed filter options and use Logger support to handle trace implementation.

log(String, SignalType...) - Method in class reactor.core.publisher.Hooks.OperatorHook

Observe Reactive Streams signals matching the passed filter options and use Logger support to handle trace implementation.

log(String, boolean, SignalType...) - Method in class reactor.core.publisher.Hooks.OperatorHook

Observe Reactive Streams signals matching the passed filter options and use Logger support to handle trace implementation.

log(String, Level, SignalType...) - Method in class reactor.core.publisher.Hooks.OperatorHook

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.Hooks.OperatorHook

Observe Reactive Streams signals matching the passed filter options and use Logger support to handle trace implementation.

log() - Method in class reactor.core.publisher.Mono

Observe all Reactive Streams signals and use Logger support to handle trace implementation.

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() - 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 (SLF4J or Logger).

Loopback - Interface in reactor.core

A component that is forking to a sub-flow given a delegate input and that is consuming from a given delegate output

M

map(Function<? super T, ? extends V>) - Method in class reactor.core.publisher.Flux

Transform the items emitted by this Flux by applying a 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 function to item emitted.

map(Function<? super T, ? extends U>) - Method in class reactor.core.publisher.ParallelFlux

Maps the source values on each 'rail' to another value.

mapError(Function<? super Throwable, ? extends Throwable>) - Method in class reactor.core.publisher.Flux

Transform the error emitted by this Flux by applying a function.

mapError(Class<E>, Function<? super E, ? extends Throwable>) - Method in class reactor.core.publisher.Flux

Transform the error emitted by this Flux by applying a function if the error matches the given type, otherwise let the error flow.

mapError(Predicate<? super Throwable>, Function<? super Throwable, ? extends Throwable>) - Method in class reactor.core.publisher.Flux

Transform the error emitted by this Flux by applying a function if the error matches the given predicate, otherwise let the error flow.

mapError(Function<Throwable, ? extends Throwable>) - Method in class reactor.core.publisher.Mono

Transform the error emitted by this Mono by applying a function.

mapError(Class<E>, Function<? super E, ? extends Throwable>) - Method in class reactor.core.publisher.Mono

Transform the error emitted by this Mono by applying a function if the error matches the given type, otherwise let the error flow.

mapError(Predicate<? super Throwable>, Function<? super Throwable, ? extends Throwable>) - Method in class reactor.core.publisher.Mono

Transform the error emitted by this Mono by applying a function if the error matches the given predicate, otherwise let the error flow.

materialize() - Method in class reactor.core.publisher.Flux

Transform the incoming onNext, onError and onComplete signals into Signal.

materialize() - Method in class reactor.core.publisher.Mono

Transform the incoming onNext, onError and onComplete signals into Signal.

merge(Publisher<? extends Publisher<? extends T>>) - Static method in class reactor.core.publisher.Flux

Merge emitted Publisher sequences 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 emitted Publisher sequences 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 emitted Publisher sequences by the passed Publisher into an interleaved merged sequence.

merge(Iterable<? extends Publisher<? extends I>>) - Static method in class reactor.core.publisher.Flux

Merge emitted Publisher sequences from the passed Iterable into an interleaved merged sequence.

merge(Publisher<? extends I>...) - Static method in class reactor.core.publisher.Flux

Merge emitted Publisher sequences from the passed Publisher array into an interleaved merged sequence.

merge(int, Publisher<? extends I>...) - Static method in class reactor.core.publisher.Flux

Merge emitted Publisher sequences from the passed Publisher array into an interleaved merged sequence.

merge(int, boolean, Publisher<? extends I>...) - Static method in class reactor.core.publisher.Flux

Merge emitted Publisher sequences from the passed Publisher array into an interleaved merged sequence.

mergeSequential(Publisher<? extends Publisher<? extends T>>) - Static method in class reactor.core.publisher.Flux

Merge emitted Publisher sequences by the passed Publisher into an ordered merged sequence.

mergeSequential(Publisher<? extends Publisher<? extends T>>, boolean, int, int) - Static method in class reactor.core.publisher.Flux

Merge emitted Publisher sequences by the passed Publisher into an ordered merged sequence.

mergeSequential(Publisher<? extends I>...) - Static method in class reactor.core.publisher.Flux

Merge a number of Publisher sequences into an ordered merged sequence.

mergeSequential(int, boolean, Publisher<? extends I>...) - Static method in class reactor.core.publisher.Flux

Merge a number of Publisher sequences into an ordered merged sequence.

mergeSequential(Iterable<? extends Publisher<? extends I>>) - Static method in class reactor.core.publisher.Flux

Merge Publisher sequences from an Iterable into an ordered merged sequence.

mergeSequential(Iterable<? extends Publisher<? extends I>>, boolean, int, int) - Static method in class reactor.core.publisher.Flux

Merge Publisher sequences from an Iterable into an ordered merged sequence.

mergeWith(Publisher<? extends T>) - Method in class reactor.core.publisher.Flux

Merge emissions of this Flux with the provided Publisher, so that they may interleave.

mergeWith(Publisher<? extends T>) - Method in class reactor.core.publisher.Mono

Merge emissions of this Mono with the provided Publisher.

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

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

MonoSource<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, e.g.

MonoSource(Publisher<? extends I>) - Constructor for class reactor.core.publisher.MonoSource

MonoSubscriber(Subscriber<? super O>) - Constructor for class reactor.core.publisher.Operators.MonoSubscriber

multiplyCap(long, long) - Static method in class reactor.core.publisher.Operators

Cap a multiplication to Long.MAX_VALUE

MultiProducer - Interface in reactor.core

A component that will emit events to N downstreams.

MultiReceiver - Interface in reactor.core

A component that is linked to N upstreams producers.

MutableNextSignal<T> - Class in reactor.core.publisher

A Signal flavour that is dedicated to the ON_NEXT signal type and is mutable, allowing to minimize the number of Signal instances created.

mutate(T) - Method in class reactor.core.publisher.MutableNextSignal

Mutate this Signal instance with a new value as an alternative to creating a new instance.

N

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.

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.

newTimer(ThreadFactory) - Method in interface reactor.core.scheduler.Schedulers.Factory

Create a new TimedScheduler backed by a dedicated resource.

newTimer(String) - Static method in class reactor.core.scheduler.Schedulers

Create a new TimedScheduler backed by a single threaded ScheduledExecutorService.

newTimer(String, boolean) - Static method in class reactor.core.scheduler.Schedulers

Create a new TimedScheduler backed by a single threaded ScheduledExecutorService.

newTimer(ThreadFactory) - Static method in class reactor.core.scheduler.Schedulers

Create a new TimedScheduler backed by a single threaded ScheduledExecutorService.

next(E) - Method in class reactor.core.publisher.BlockingSink

Try emitting, might throw an unchecked exception.

next() - Method in class reactor.core.publisher.Flux

Emit only the first item emitted by this Flux.

next(T) - Method in interface reactor.core.publisher.FluxSink

Try emitting, might throw an unchecked exception.

next(T) - Static method in class reactor.core.publisher.Signal

Creates and returns a Signal of variety Type.NEXT, and assigns it a value.

next(T) - Method in interface reactor.core.publisher.SynchronousSink

Try emitting, might throw an unchecked exception.

NONE - Static variable in interface reactor.core.Fuseable

Indicates the QueueSubscription can't support the requested mode.

now(TimeUnit) - Method in interface reactor.core.scheduler.TimedScheduler

Returns the "current time" notion of this scheduler.

now(TimeUnit) - Method in interface reactor.core.scheduler.TimedScheduler.TimedWorker

Returns the "current time" notion of this scheduler.

nullOrNegativeRequestException(long) - Static method in class reactor.core.Exceptions

O

of(T) - Static method in class reactor.core.publisher.MutableNextSignal

Create a new MutableNextSignal with an initial value.

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<U>) - Method in class reactor.core.publisher.Flux

Evaluate each accepted value against the given Class type.

ofType(Class<U>) - Method in class reactor.core.publisher.Mono

Evaluate the accepted value against the given Class type.

onAssembly(Flux<T>) - Static method in class reactor.core.publisher.Flux

Invoke Hooks pointcut given a Flux and returning an eventually new Flux

onAssembly(ConnectableFlux<T>) - Static method in class reactor.core.publisher.Flux

Invoke Hooks pointcut given a ConnectableFlux and returning an eventually new ConnectableFlux

onAssembly(Mono<T>) - Static method in class reactor.core.publisher.Mono

Invoke Hooks pointcut given a Mono and returning an eventually 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 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 the returned Flux, or park the observed elements if not enough demand is requested downstream.

onBackpressureBuffer(int, Consumer<? super T>) - Method in class reactor.core.publisher.Flux

Request an unbounded demand and push the returned Flux, or park the observed elements if not enough demand is requested downstream.

onBackpressureBuffer(int, BufferOverflowStrategy) - Method in class reactor.core.publisher.Flux

Request an unbounded demand and push 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 the returned Flux, or park the observed elements if not enough demand is requested downstream, within a maxSize limit.

onBackpressureDrop() - Method in class reactor.core.publisher.Flux

Request an unbounded demand and push 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 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 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 the returned Flux, or only keep the most recent observed item if not enough demand is requested downstream.

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.Operators.SubscriberAdapter

onComplete() - Method in class reactor.core.publisher.ReplayProcessor

onComplete() - Method in class reactor.core.publisher.UnicastProcessor

one() - Static method in class reactor.util.concurrent.QueueSupplier

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.Operators.SubscriberAdapter

onError(Throwable) - Method in class reactor.core.publisher.ReplayProcessor

onError(Throwable) - Method in class reactor.core.publisher.UnicastProcessor

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, Throwable) - Static method in class reactor.core.publisher.Operators

Take an unsignalled exception that is masking anowher one due to callback failure.

onErrorDropped(Throwable) - Static method in class reactor.core.publisher.Operators

Take an unsignalled exception that is masking another one due to callback failure.

onErrorResumeWith(Function<? super Throwable, ? extends Publisher<? extends T>>) - Method in class reactor.core.publisher.Flux

Subscribe to a returned fallback publisher when any error occurs.

onErrorResumeWith(Class<E>, Function<? super E, ? extends Publisher<? extends T>>) - Method in class reactor.core.publisher.Flux

Subscribe to a returned fallback publisher when an error matching the given type occurs.

onErrorResumeWith(Predicate<? super Throwable>, Function<? super Throwable, ? extends Publisher<? extends T>>) - Method in class reactor.core.publisher.Flux

Subscribe to a returned fallback publisher when an error matching the given type occurs.

onErrorReturn(T) - Method in class reactor.core.publisher.Flux

Fallback to the given value if an error is observed on this Flux

onErrorReturn(Class<E>, T) - Method in class reactor.core.publisher.Flux

Fallback to the given value if an error of a given type is observed on this Flux

onErrorReturn(Predicate<? super Throwable>, T) - Method in class reactor.core.publisher.Flux

Fallback to the given value if an error matching the given predicate is observed on this Flux

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.

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(I) - Method in class reactor.core.publisher.Operators.SubscriberAdapter

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 throw Exceptions.failWithCancel()

onNextDropped(T) - Static method in class reactor.core.publisher.Operators

An unexpected event is about to be dropped.

onOperator(Function<? super Hooks.OperatorHook<T>, ? extends Hooks.OperatorHook<T>>) - Static method in class reactor.core.publisher.Hooks

Set a global "assembly" hook to intercept signals produced by the passed Publisher (Flux or Mono).

onOperatorError(BiFunction<? super Throwable, Object, ? extends Throwable>) - Static method in class reactor.core.publisher.Hooks

Override global operator error mapping which by default add as suppressed exception either data driven exception or error driven exception.

onOperatorError(Throwable) - Static method in class reactor.core.publisher.Operators

Map an "operator" error.

onOperatorError(Subscription, Throwable) - Static method in class reactor.core.publisher.Operators

Map an "operator" error given an operator parent Subscription.

onOperatorError(Subscription, Throwable, Object) - Static method in class reactor.core.publisher.Operators

Map an "operator" error given an operator parent Subscription.

onRejectedExecution() - Static method in class reactor.core.publisher.Operators

Return a wrapped RejectedExecutionException which can be thrown by the operator.

onRejectedExecution(Subscription, Throwable, Object) - Static method in class reactor.core.publisher.Operators

Return a wrapped RejectedExecutionException which can be thrown by the operator.

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.Operators.SubscriberAdapter

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 the both the child Subscriber and the Subscription on termination or cancellation.

onTerminateDetach() - Method in class reactor.core.publisher.Mono

Detaches the both the child Subscriber and the Subscription on termination or cancellation.

OpenHashSet<T> - Class in reactor.util.concurrent

A simple open hash set with add, remove and clear capabilities only.

OpenHashSet() - Constructor for class reactor.util.concurrent.OpenHashSet

OpenHashSet(int, float) - Constructor for class reactor.util.concurrent.OpenHashSet

Operators - Class in reactor.core.publisher

An 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 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.

Operators.SubscriberAdapter<I,O> - Class in reactor.core.publisher

A Subscriber with an asymetric typed wrapped subscriber.

operatorStacktrace() - Method in class reactor.core.publisher.Hooks.OperatorHook

Enable operator stack recorder and capture declaration stack.

or(Mono<? extends T>) - Method in class reactor.core.publisher.Mono

Emit the any of the result from this mono or from the given mono

otherwise(Function<? super Throwable, ? extends Mono<? extends T>>) - Method in class reactor.core.publisher.Mono

Subscribe to a returned fallback publisher when any error occurs.

otherwise(Class<E>, Function<? super E, ? extends Mono<? extends T>>) - Method in class reactor.core.publisher.Mono

Subscribe to a returned fallback publisher when an error matching the given type occurs.

otherwise(Predicate<? super Throwable>, Function<? super Throwable, ? extends Mono<? extends T>>) - Method in class reactor.core.publisher.Mono

Subscribe to a returned fallback publisher when an error matching the given type occurs.

otherwiseIfEmpty(Mono<? extends T>) - Method in class reactor.core.publisher.Mono

Provide an alternative Mono if this mono is completed without data

otherwiseReturn(T) - Method in class reactor.core.publisher.Mono

Subscribe to a returned fallback value when any error occurs.

otherwiseReturn(Class<E>, T) - Method in class reactor.core.publisher.Mono

Fallback to the given value if an error of a given type is observed on this Mono

otherwiseReturn(Predicate<? super Throwable>, T) - Method in class reactor.core.publisher.Mono

Fallback to the given value if an error matching the given predicate is observed on this Mono

P

parallel() - Method in class reactor.core.publisher.Flux

Prepare to consume this Flux on number of 'rails' matching number of CPU in round-robin fashion.

parallel(int) - Method in class reactor.core.publisher.Flux

Prepare to consume this Flux on parallelism number of 'rails' in round-robin fashion.

parallel(int, int) - Method in class reactor.core.publisher.Flux

Prepare to consume this Flux on parallelism number of 'rails' in round-robin fashion and use 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.

parking() - Static method in class reactor.util.concurrent.WaitStrategy

Parking strategy that initially spins, then uses a Thread.yield(), and eventually sleep (LockSupport.parkNanos(1)) for the minimum number of nanos the OS and JVM will allow while the consumers are waiting on a barrier.

parking(int) - Static method in class reactor.util.concurrent.WaitStrategy

Parking strategy that initially spins, then uses a Thread.yield(), and eventually sleep (LockSupport.parkNanos(1)) for the minimum number of nanos the OS and JVM will allow while the consumers are waiting on a barrier.

peek() - Method in interface reactor.core.Fuseable.QueueSubscription

peek() - Method in class reactor.core.publisher.MonoProcessor

Returns the value that completed this MonoProcessor.

phasedOff(long, long, TimeUnit, WaitStrategy) - Static method in class reactor.util.concurrent.WaitStrategy

Phased wait strategy for waiting consumers on a barrier.

phasedOffLiteLock(long, long, TimeUnit) - Static method in class reactor.util.concurrent.WaitStrategy

Block with wait/notifyAll semantics

phasedOffLock(long, long, TimeUnit) - Static method in class reactor.util.concurrent.WaitStrategy

Block with wait/notifyAll semantics

phasedOffSleep(long, long, TimeUnit) - Static method in class reactor.util.concurrent.WaitStrategy

Block by parking in a loop

poll() - Method in class reactor.core.publisher.Operators.MonoSubscriber

poll() - Method in class reactor.core.publisher.UnicastProcessor

produced(AtomicLongFieldUpdater<T>, T, long) - Static method in class reactor.core.publisher.Operators

Concurrent substraction bound to 0.

Producer - Interface in reactor.core

A component that will emit events to a downstream.

propagate(Throwable) - Static method in class reactor.core.Exceptions

Return an unchecked RuntimeException to be thrown that will 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

Shares 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.

publisher() - Method in class reactor.core.publisher.Hooks.OperatorHook

The current publisher to decorate

publisherToFlowPublisher(Publisher<T>) - Static method in class reactor.adapter.JdkFlowAdapter

Return a Flux from a java Flow.Publisher

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

Q

QueueSupplier<T> - Class in reactor.util.concurrent

Provide a 1-producer/1-consumer ready queue adapted for a given capacity.

R

range(int, int) - Static method in class reactor.core.publisher.Flux

Build a Flux that will only emit a sequence of incrementing integer from start to start + count then complete.

reactor.adapter - package reactor.adapter

Adapt Publisher to Java 9+ Flow.Publisher.

reactor.core - package reactor.core

Core components of the Loggers framework supporting 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 and TimedScheduler contract and static factory methods in Schedulers.

reactor.util - package reactor.util

Miscellaneous utility classes, such as loggers, tuples or queue suppliers and implementations.

reactor.util.concurrent - package reactor.util.concurrent

Queue suppliers and busy spin utils WaitStrategy.

reactor.util.function - package reactor.util.function

Tuples provide a type-safe way to specify multiple parameters.

Receiver - Interface in reactor.core

A component that is linked to a source producer.

reduce(BiFunction<T, T, T>) - Method in class reactor.core.publisher.Flux

Aggregate the values from this Flux sequence into an object of the same type than the emitted items.

reduce(A, BiFunction<A, ? super T, A>) - Method in class reactor.core.publisher.Flux

Accumulate the values from this Flux sequence into an object matching an initial value type.

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

Accumulate the values from this Flux sequence into an object matching an initial value type.

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.

REJECTED - Static variable in interface reactor.core.scheduler.Scheduler

Returned by the schedule() methods if the Scheduler or the Worker has ben shut down.

remove() - Method in interface reactor.core.Fuseable.QueueSubscription

remove(Object) - Method in interface reactor.core.Fuseable.QueueSubscription

remove(T) - Method in class reactor.util.concurrent.OpenHashSet

removeAll(Collection<?>) - Method in interface reactor.core.Fuseable.QueueSubscription

repeat() - Method in class reactor.core.publisher.Flux

Repeatedly subscribe to the source 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 if the predicate returns true after completion of the previous subscription.

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 subscribe to the source 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 if the predicate returns true after completion of the previous subscription.

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 signals a number of emitted 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 signals a number of emitted 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 until there is an onNext signal when a companion sequence signals a number of emitted elements.

repeatWhenEmpty(int, Function<Flux<Long>, ? extends Publisher<?>>) - Method in class reactor.core.publisher.Mono

Repeatedly subscribe to this Mono until there is an onNext signal when a companion sequence signals a number of emitted elements.

replace(AtomicReferenceFieldUpdater<F, Subscription>, F, Subscription) - Static method in class reactor.core.publisher.Operators

A generic utility to atomically replace a subscription or cancel if marked by a singleton subscription.

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.

replayMillis(long, TimedScheduler) - Method in class reactor.core.publisher.Flux

Turn this Flux into a connectable hot source and cache last emitted signals for further Subscriber.

replayMillis(int, long, TimedScheduler) - 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

Throw IllegalArgumentException

reportMoreProduced() - Static method in class reactor.core.publisher.Operators

Throw IllegalStateException

reportSubscriptionSet() - Static method in class reactor.core.publisher.Operators

Log reportedSubscriptions

request(long) - Method in class reactor.core.publisher.BaseSubscriber

request(long) - Method in class reactor.core.publisher.BlockingSink

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.Operators.SubscriberAdapter

request(long) - Method in class reactor.core.publisher.UnicastProcessor

requestedFromDownstream() - Method in class reactor.core.publisher.BlockingSink

requestedFromDownstream() - Method in interface reactor.core.publisher.FluxSink

The current outstanding request amount.

requestedFromDownstream() - Method in class reactor.core.publisher.Operators.DeferredSubscription

requestedFromDownstream() - Method in class reactor.core.publisher.UnicastProcessor

requestedFromDownstream() - Method in interface reactor.core.Trackable

Return defined element capacity, used to drive new Subscription request needs.

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

requestTask(Subscription) - Method in class reactor.core.publisher.TopicProcessor

requestTask(Subscription) - Method in class reactor.core.publisher.WorkQueueProcessor

resetFactory() - Static method in class reactor.core.scheduler.Schedulers

Re-apply default factory to Schedulers

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.

resetOnNextDropped() - Static method in class reactor.core.publisher.Hooks

Reset global data dropped strategy to throwing via Exceptions.failWithCancel()

resetOnOperator() - Static method in class reactor.core.publisher.Hooks

Reset global "assembly" hook tracking

resetOnOperatorError() - Static method in class reactor.core.publisher.Hooks

Reset global operator error mapping to adding as suppressed exception either data driven exception or error driven exception.

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 either indefinitely.

retry(long) - Method in class reactor.core.publisher.Flux

Re-subscribes to this Flux sequence if it signals any error either indefinitely or a fixed number of times.

retry(Predicate<Throwable>) - Method in class reactor.core.publisher.Flux

Re-subscribes to this Flux sequence if it signals any error and the given Predicate matches otherwise push the error downstream.

retry(long, Predicate<Throwable>) - Method in class reactor.core.publisher.Flux

Re-subscribes to this Flux sequence up to the specified number of retries if it signals any error and the given Predicate matches otherwise push the error downstream.

retry() - Method in class reactor.core.publisher.Mono

Re-subscribes to this Mono sequence if it signals any error either indefinitely.

retry(long) - Method in class reactor.core.publisher.Mono

Re-subscribes to this Mono sequence if it signals any error either indefinitely or a fixed number of times.

retry(Predicate<Throwable>) - Method in class reactor.core.publisher.Mono

Re-subscribes to this Mono sequence if it signals any error and the given Predicate matches otherwise push the error downstream.

retry(long, Predicate<Throwable>) - Method in class reactor.core.publisher.Mono

Re-subscribes to this Mono sequence up to the specified number of retries if it signals any error and the given Predicate matches otherwise push the error downstream.

retryWhen(Function<Flux<Throwable>, ? extends Publisher<?>>) - Method in class reactor.core.publisher.Flux

Retries this Flux when a companion sequence signals an item in response to this Flux error signal

retryWhen(Function<Flux<Throwable>, ? extends Publisher<?>>) - Method in class reactor.core.publisher.Mono

Retries this Mono when a companion sequence signals an item in response to this Mono error signal

run() - Method in class reactor.core.publisher.TopicProcessor

run() - Method in class reactor.core.publisher.WorkQueueProcessor

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

Emit latest value for every given period of time.

sample(Publisher<U>) - Method in class reactor.core.publisher.Flux

Sample this Flux and emit its latest value whenever the sampler Publisher signals a value.

sampleFirst(Duration) - Method in class reactor.core.publisher.Flux

Take a value from this Flux then use the duration provided to skip other values.

sampleFirst(Function<? super T, ? extends Publisher<U>>) - Method in class reactor.core.publisher.Flux

Take a value from this Flux then use the duration provided by a generated Publisher to skip other values until that sampler Publisher signals.

sampleFirstMillis(long) - Method in class reactor.core.publisher.Flux

Take a value from this Flux then use the duration provided to skip other values.

sampleMillis(long) - Method in class reactor.core.publisher.Flux

Emit latest value for every given period of ti,e.

sampleTimeout(Function<? super T, ? extends Publisher<U>>) - Method in class reactor.core.publisher.Flux

Emit the last value from this Flux only if there were no new values emitted during the time window provided by a publisher for that particular last value.

sampleTimeout(Function<? super T, ? extends Publisher<U>>, int) - Method in class reactor.core.publisher.Flux

Emit the last value from this Flux only if there were no newer values emitted during the time window provided by a publisher for that particular last value.

scalarSubscription(Subscriber<? 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

Accumulate this Flux values with an accumulator BiFunction and returns the intermediate results of this function.

scan(A, BiFunction<A, ? super T, A>) - Method in class reactor.core.publisher.Flux

Aggregate this Flux values with the help of an accumulator BiFunction and emits the intermediate results.

scanWith(Supplier<A>, BiFunction<A, ? super T, A>) - Method in class reactor.core.publisher.Flux

Aggregate this Flux values with the help of an accumulator BiFunction and emits the intermediate results.

schedule(Runnable) - Method in interface reactor.core.scheduler.Scheduler

Schedules the given task on this scheduler non-delayed execution.

schedule(Runnable) - Method in interface reactor.core.scheduler.Scheduler.Worker

Schedules the task on this worker.

schedule(Runnable, long, TimeUnit) - Method in interface reactor.core.scheduler.TimedScheduler

Schedules the execution of the given task with the given delay amount.

schedule(Runnable, long, TimeUnit) - Method in interface reactor.core.scheduler.TimedScheduler.TimedWorker

Schedules the execution of the given task with the given delay amount.

schedulePeriodically(Runnable, long, long, TimeUnit) - Method in interface reactor.core.scheduler.TimedScheduler

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.TimedScheduler.TimedWorker

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.Worker - Interface in reactor.core.scheduler

A worker representing an asynchronous boundary that executes tasks in a FIFO order, guaranteed non-concurrently with respect to each other.

Schedulers - Class in reactor.core.scheduler

Schedulers provide various Scheduler generator useable 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() - Method in interface reactor.core.publisher.FluxSink

Ensures that calls to next, error and complete are properly serialized.

serialize(Subscriber<? super T>) - Static method in class reactor.core.publisher.Operators

Safely gate a Subscriber by a serializing Subscriber.

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 if marked by a singleton subscription or concurrently set before.

setCancellation(Cancellation) - Method in interface reactor.core.publisher.FluxSink

Associate a cancellation-based resource with this FluxSink that will be disposed in case the downstream cancels the sequence via Subscription.cancel().

setCancellation(Cancellation) - Method in interface reactor.core.publisher.MonoSink

Sets a cancellation callback triggered by downstreams cancel().

setFactory(Schedulers.Factory) - Static method in class reactor.core.scheduler.Schedulers

Override Schedulers finite signatures of Schedulers.newParallel(java.lang.String), Schedulers.newSingle(java.lang.String), Schedulers.newTimer(java.lang.String) and Schedulers.newElastic(java.lang.String) factory using the matching method signature in the target class.

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

share() - Method in class reactor.core.publisher.Flux

Returns a new Flux that multicasts (shares) the original Flux.

share(boolean) - Static method in class reactor.core.publisher.TopicProcessor

Create a new TopicProcessor using QueueSupplier.SMALL_BUFFER_SIZE backlog size, blockingWait Strategy and the passed auto-cancel setting.

share(ExecutorService) - Static method in class reactor.core.publisher.TopicProcessor

Create a new TopicProcessor using QueueSupplier.SMALL_BUFFER_SIZE backlog size, blockingWait Strategy and auto-cancel.

share(ExecutorService, boolean) - Static method in class reactor.core.publisher.TopicProcessor

Create a new TopicProcessor using QueueSupplier.SMALL_BUFFER_SIZE backlog size, blockingWait Strategy and the passed auto-cancel setting.

share(String, int) - Static method in class reactor.core.publisher.TopicProcessor

Create a new TopicProcessor using QueueSupplier.SMALL_BUFFER_SIZE backlog size, blockingWait Strategy and the passed auto-cancel setting.

share(String, int, boolean) - Static method in class reactor.core.publisher.TopicProcessor

Create a new TopicProcessor using the blockingWait Strategy, passed backlog size, and auto-cancel settings.

share(ExecutorService, int) - Static method in class reactor.core.publisher.TopicProcessor

Create a new TopicProcessor using passed backlog size, blockingWait Strategy and will auto-cancel.

share(ExecutorService, int, boolean) - Static method in class reactor.core.publisher.TopicProcessor

Create a new TopicProcessor using passed backlog size, blockingWait Strategy and the auto-cancel argument.

share(String, int, WaitStrategy) - Static method in class reactor.core.publisher.TopicProcessor

Create a new TopicProcessor using passed backlog size, wait strategy and will auto-cancel.

share(String, int, Supplier<E>) - Static method in class reactor.core.publisher.TopicProcessor

Create a new TopicProcessor using passed backlog size, wait strategy and signal supplier.

share(String, int, WaitStrategy, Supplier<E>) - Static method in class reactor.core.publisher.TopicProcessor

Create a new TopicProcessor using passed backlog size, wait strategy and signal supplier.

share(String, int, WaitStrategy, boolean) - Static method in class reactor.core.publisher.TopicProcessor

Create a new TopicProcessor using passed backlog size, wait strategy and auto-cancel settings.

share(ExecutorService, int, WaitStrategy) - Static method in class reactor.core.publisher.TopicProcessor

Create a new TopicProcessor using passed backlog size, wait strategy and will auto-cancel.

share(ExecutorService, int, WaitStrategy, boolean) - Static method in class reactor.core.publisher.TopicProcessor

Create a new TopicProcessor using passed backlog size, wait strategy and auto-cancel settings.

share(boolean) - Static method in class reactor.core.publisher.WorkQueueProcessor

Create a new WorkQueueProcessor using QueueSupplier.SMALL_BUFFER_SIZE backlog size, blockingWait Strategy and the passed auto-cancel setting.

share(ExecutorService) - Static method in class reactor.core.publisher.WorkQueueProcessor

Create a new WorkQueueProcessor using QueueSupplier.SMALL_BUFFER_SIZE backlog size, blockingWait Strategy and auto-cancel.

share(ExecutorService, boolean) - Static method in class reactor.core.publisher.WorkQueueProcessor

Create a new WorkQueueProcessor using QueueSupplier.SMALL_BUFFER_SIZE backlog size, blockingWait Strategy and the passed auto-cancel setting.

share(String, int) - Static method in class reactor.core.publisher.WorkQueueProcessor

Create a new TopicProcessor using the passed buffer size, blockingWait Strategy and auto-cancel.

share(String, int, boolean) - Static method in class reactor.core.publisher.WorkQueueProcessor

Create a new TopicProcessor using the passed buffer size, blockingWait Strategy and the passed auto-cancel setting.

share(ExecutorService, int) - Static method in class reactor.core.publisher.WorkQueueProcessor

Create a new TopicProcessor using the passed buffer size, blockingWait Strategy and auto-cancel.

share(ExecutorService, int, boolean) - Static method in class reactor.core.publisher.WorkQueueProcessor

Create a new WorkQueueProcessor using the passed buffer size, blockingWait Strategy and auto-cancel.

share(String, int, WaitStrategy) - Static method in class reactor.core.publisher.WorkQueueProcessor

Create a new WorkQueueProcessor using the passed buffer size, blockingWait Strategy and auto-cancel.

share(String, int, WaitStrategy, boolean) - Static method in class reactor.core.publisher.WorkQueueProcessor

Create a new WorkQueueProcessor using the passed buffer size, blockingWait Strategy and auto-cancel settings.

share(ExecutorService, int, WaitStrategy) - Static method in class reactor.core.publisher.WorkQueueProcessor

Create a new WorkQueueProcessor using the passed buffer size and blockingWait Strategy settings but will auto-cancel.

share(ExecutorService, int, WaitStrategy, boolean) - Static method in class reactor.core.publisher.WorkQueueProcessor

Create a new WorkQueueProcessor using the passed buffer size, wait strategy and auto-cancel settings.

shutdown() - Method in interface reactor.core.scheduler.Scheduler

Deprecated.

move the implementation to Scheduler.dispose() and call dispose from shutdown. Will be removed in 3.1.0

shutdown() - Method in interface reactor.core.scheduler.Scheduler.Worker

Deprecated.

move the implementation to Scheduler.Worker.dispose() and call dispose from shutdown. Will be removed in 3.1.0

shutdownNow() - Static method in class reactor.core.scheduler.Schedulers

Clear any cached Scheduler and call dispose on them.

Signal<T> - Class in reactor.core.publisher

A domain representation of a Reactive Stream signal.

Signal() - Constructor for class reactor.core.publisher.Signal

signalAllWhenBlocking() - Method in class reactor.util.concurrent.WaitStrategy

Implementations should signal the waiting consumers that the cursor has advanced.

SignalType - Enum in reactor.core.publisher

Reactive Stream notification type

single() - Method in class reactor.core.publisher.Flux

Expect and emit a single item from this Flux source or signal NoSuchElementException (or a default generated value) for empty source, IndexOutOfBoundsException for a multi-item source.

single(T) - Method in class reactor.core.publisher.Flux

Expect and emit a single item from this Flux source or signal NoSuchElementException (or a default value) for empty source, IndexOutOfBoundsException for a multi-item 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 worker of some other Scheduler and provides Scheduler.Worker services on top of it.

singleOrEmpty() - Method in class reactor.core.publisher.Flux

Expect and emit a zero or single item from this Flux source or IndexOutOfBoundsException for a multi-item source.

size() - Method in class reactor.core.publisher.Operators.MonoSubscriber

size() - Method in class reactor.core.publisher.UnicastProcessor

size() - Method in class reactor.util.concurrent.OpenHashSet

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 next the specified number of elements from this Flux.

skip(Duration) - Method in class reactor.core.publisher.Flux

Skip elements from this Flux for the given time period.

skipLast(int) - Method in class reactor.core.publisher.Flux

Skip the last specified number of elements from this Flux.

skipMillis(long) - Method in class reactor.core.publisher.Flux

Skip elements from this Flux for the given time period.

skipMillis(long, TimedScheduler) - Method in class reactor.core.publisher.Flux

Skip elements from this Flux for the given time period.

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.

sleeping() - Static method in class reactor.util.concurrent.WaitStrategy

Yielding strategy that uses a Thread.sleep(1) for consumers waiting on a barrier after an initially spinning.

small() - Static method in class reactor.util.concurrent.QueueSupplier

SMALL_BUFFER_SIZE - Static variable in class reactor.util.concurrent.QueueSupplier

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

Returns a Flux that sorts the events emitted by source Flux.

sort(Comparator<? super T>) - Method in class reactor.core.publisher.Flux

Returns a Flux that sorts the events emitted by source Flux given the Comparator function.

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.FluxSource

source - Variable in class reactor.core.publisher.MonoSource

start() - Method in class reactor.core.publisher.BlockingSink

Subscribe the decorated actual Subscriber.onSubscribe(Subscription).

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 before this Flux sequence.

stop() - Method in class reactor.core.publisher.BlockingSink

Marks the emitter as terminated without completing downstream

submit(E) - Method in class reactor.core.publisher.BlockingSink

Blocking Subscriber.onNext(Object) call with an infinite wait on backpressure.

submit(E, long) - Method in class reactor.core.publisher.BlockingSink

Blocking Subscriber.onNext(Object) call with a timed wait on backpressure.

submit(E, long, Predicate<E>) - Method in class reactor.core.publisher.BlockingSink

Blocking Subscriber.onNext(Object) call with a timed wait on backpressure.

submit(E, long, TimeUnit) - Method in class reactor.core.publisher.BlockingSink

Blocking Subscriber.onNext(Object) call with a timed wait on backpressure.

submit(E, long, TimeUnit, Predicate<E>) - Method in class reactor.core.publisher.BlockingSink

Blocking Subscriber.onNext(Object) call with a timed wait on backpressure.

subOrZero(long, long) - Static method in class reactor.core.publisher.Operators

Cap a substraction to 0

subscribe(Subscriber<? super T>) - Method in class reactor.core.publisher.DirectProcessor

subscribe(Subscriber<? super T>) - Method in class reactor.core.publisher.EmitterProcessor

subscribe() - Method in class reactor.core.publisher.Flux

Start the chain and request unbounded demand.

subscribe(int) - Method in class reactor.core.publisher.Flux

Deprecated.

use Flux.limitRate(int)

subscribe(Consumer<? super T>) - Method in class reactor.core.publisher.Flux

Subscribe a Consumer to this Flux that will consume all the sequence.

subscribe(Consumer<? super T>, int) - Method in class reactor.core.publisher.Flux

Subscribe a Consumer to this Flux that will consume all the sequence.

subscribe(Consumer<? super T>, Consumer<? super Throwable>) - Method in class reactor.core.publisher.Flux

Subscribe Consumer to this Flux that will consume all the sequence.

subscribe(Consumer<? super T>, Consumer<? super Throwable>, Runnable) - Method in class reactor.core.publisher.Flux

Subscribe Consumer to this Flux that will consume all the sequence.

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 consume all the sequence.

subscribe(Consumer<? super T>, Consumer<? super Throwable>, Runnable, int) - Method in class reactor.core.publisher.Flux

Deprecated.

prefer using limitRate(prefetch).subscribe(...) to subscribe(..., prefetch)

subscribe(Consumer<? super T>, Consumer<? super Throwable>, Runnable, Consumer<? super Subscription>, int) - Method in class reactor.core.publisher.Flux

Deprecated.

prefer using limitRate(prefetch).subscribe(...) to subscribe(..., prefetch)

subscribe(Subscriber<? super OUT>) - Method in class reactor.core.publisher.FluxProcessor

subscribe(Subscriber<? super O>) - Method in class reactor.core.publisher.FluxSource

Default is delegating and decorating with Flux API

subscribe() - Method in class reactor.core.publisher.Mono

Start the chain 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 Consumer to this Mono that will consume all the sequence.

subscribe(Consumer<? super T>, Consumer<? super Throwable>, Runnable) - Method in class reactor.core.publisher.Mono

Subscribe Consumer to this Mono that will consume all the sequence.

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 consume all the sequence.

subscribe(Subscriber<? super O>) - Method in class reactor.core.publisher.MonoProcessor

subscribe(Subscriber<? super O>) - Method in class reactor.core.publisher.MonoSource

Default is delegating and decorating with Mono API

subscribe(Subscriber<? 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(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(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(Subscriber<? super T>) - Method in class reactor.core.publisher.ReplayProcessor

subscribe(Subscription) - Static method in class reactor.core.publisher.Signal

Creates and returns a Signal of variety Type.ON_SUBSCRIBE.

subscribe(Subscriber<? super E>) - Method in class reactor.core.publisher.TopicProcessor

subscribe(Subscriber<? super T>) - Method in class reactor.core.publisher.UnicastProcessor

subscribe(Subscriber<? super E>) - Method in class reactor.core.publisher.WorkQueueProcessor

subscribeOn(Scheduler) - Method in class reactor.core.publisher.Flux

Run subscribe, onSubscribe and request on a supplied Scheduler

subscribeOn(Scheduler) - Method in class reactor.core.publisher.Mono

Run the requests to this Publisher Mono on a given worker assigned by the supplied Scheduler.

subscriber - Variable in class reactor.core.publisher.Operators.SubscriberAdapter

SubscriberAdapter(Subscriber<? super O>) - Constructor for class reactor.core.publisher.Operators.SubscriberAdapter

subscribeWith(E) - Method in class reactor.core.publisher.Flux

A chaining Publisher.subscribe(Subscriber) alternative to inline composition type conversion to a hot emitter (e.g.

subscribeWith(E) - Method in class reactor.core.publisher.Mono

Subscribe the Mono with the givne Subscriber and return it.

subscription - Variable in class reactor.core.publisher.Operators.SubscriberAdapter

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.

switchIfEmpty(Publisher<? extends T>) - Method in class reactor.core.publisher.Flux

Provide an alternative if this sequence is completed without any 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.

switchOnError(Class<E>, Publisher<? extends T>) - Method in class reactor.core.publisher.Flux

Subscribe to the given fallback Publisher if an error matching the given type is observed on this Flux

switchOnError(Predicate<? super Throwable>, Publisher<? extends T>) - Method in class reactor.core.publisher.Flux

Subscribe to the given fallback Publisher if an error matching the given predicate is observed on this Flux

switchOnError(Publisher<? extends T>) - Method in class reactor.core.publisher.Flux

Subscribe to the given fallback Publisher if an error is observed on this Flux

switchOnNext(Publisher<? extends Publisher<? extends T>>) - Static method in class reactor.core.publisher.Flux

Build a FluxProcessor whose data are emitted by the most recent emitted Publisher.

switchOnNext(Publisher<? extends Publisher<? extends T>>, int) - Static method in class reactor.core.publisher.Flux

Build a FluxProcessor whose data are emitted by the most recent emitted Publisher.

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 generate signals to a bridged Subscriber.

T

take(long) - Method in class reactor.core.publisher.Flux

Take only the first N values from this Flux.

take(Duration) - Method in class reactor.core.publisher.Flux

Relay values from this Flux until the given time period elapses.

takeLast(int) - Method in class reactor.core.publisher.Flux

Emit the last N values this Flux emitted before its completion.

takeMillis(long) - Method in class reactor.core.publisher.Flux

Relay values from this Flux until the given time period elapses.

takeMillis(long, TimedScheduler) - Method in class reactor.core.publisher.Flux

Relay values from this Flux until the given time period elapses.

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.

takeWhile(Predicate<? super T>) - Method in class reactor.core.publisher.Flux

Relay values 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!

then() - Method in class reactor.core.publisher.Flux

Return a Mono<Void> that completes when this Flux completes.

then(Publisher<Void>) - Method in class reactor.core.publisher.Flux

Deprecated.

use Flux.thenEmpty(Publisher) instead, this alias will be removed in 3.1.0

then(Supplier<? extends Publisher<Void>>) - Method in class reactor.core.publisher.Flux

Return a Flux that emits the completion signal of the supplied Publisher when this Flux onComplete or onError.

then() - Method in class reactor.core.publisher.Mono

Return a Mono<Void> which only replays complete and error signals from this Mono.

then(Function<? super T, ? extends Mono<? extends R>>) - Method in class reactor.core.publisher.Mono

Convert the value of Mono to another Mono possibly with another value type.

then(Mono<V>) - Method in class reactor.core.publisher.Mono

Ignore element from this Mono and transform its completion signal into the emission and completion signal of a provided Mono<V>.

then(Supplier<? extends Mono<V>>) - Method in class reactor.core.publisher.Mono

Ignore element from this Mono and transform its completion signal into the emission and completion signal of a supplied Mono<V>.

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

Return a Flux that emits the sequence of the supplied Publisher after this Flux completes, ignoring this flux elements.

thenMany(Supplier<? extends Publisher<V>>) - Method in class reactor.core.publisher.Flux

Return a Flux that emits the sequence of the supplied Publisher after this Flux completes, ignoring this flux elements.

thenMany(Publisher<V>) - Method in class reactor.core.publisher.Mono

Ignore element from this mono and transform the completion signal into a Flux<V> that will emit elements from the provided Publisher.

thenMany(Supplier<? extends Publisher<V>>) - Method in class reactor.core.publisher.Mono

Ignore element from this mono and transform the completion signal into a Flux<V> that will emit elements from the supplier-provided Publisher.

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.

throwAlert() - Static method in class reactor.util.concurrent.WaitStrategy

Deprecated.

duplicate to WaitStrategy.alert()

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.

TimedScheduler - Interface in reactor.core.scheduler

Provides an abstract, timed asynchronous boundary to operators.

TimedScheduler.TimedWorker - Interface in reactor.core.scheduler

timeout(Duration) - Method in class reactor.core.publisher.Flux

Signal a TimeoutException in case a per-item period fires before the next item arrives from this Flux.

timeout(Duration, Publisher<? extends T>) - Method in class reactor.core.publisher.Flux

Switch to a fallback Publisher in case a per-item period fires before the next item arrives from this Flux.

timeout(Publisher<U>) - Method in class reactor.core.publisher.Flux

Signal a TimeoutException in case a first item from this Flux has not been emitted before the given Publisher emits.

timeout(Publisher<U>, Function<? super T, ? extends Publisher<V>>) - Method in class reactor.core.publisher.Flux

Signal a TimeoutException in case a first item from this Flux has not been emitted before the given Publisher emits.

timeout(Publisher<U>, Function<? super T, ? extends Publisher<V>>, Publisher<? extends T>) - Method in class reactor.core.publisher.Flux

Switch to a fallback Publisher in case a first item from this Flux has not been emitted before the given Publisher emits.

timeout(Duration) - Method in class reactor.core.publisher.Mono

Signal a TimeoutException in case an item doesn't arrive before the given period.

timeout(Duration, Mono<? extends T>) - Method in class reactor.core.publisher.Mono

Switch to a fallback Mono in case an item doesn't arrive before the given period.

timeout(Publisher<U>) - 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<U>, 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.

timeoutMillis(long) - Method in class reactor.core.publisher.Flux

Signal a TimeoutException error in case a per-item period in milliseconds fires before the next item arrives from this Flux.

timeoutMillis(long, TimedScheduler) - Method in class reactor.core.publisher.Flux

Signal a TimeoutException error in case a per-item period in milliseconds fires before the next item arrives from this Flux.

timeoutMillis(long, Publisher<? extends T>) - Method in class reactor.core.publisher.Flux

Switch to a fallback Publisher in case a per-item period fires before the next item arrives from this Flux.

timeoutMillis(long, Publisher<? extends T>, TimedScheduler) - Method in class reactor.core.publisher.Flux

Switch to a fallback Publisher in case a per-item period fires before the next item arrives from this Flux.

timeoutMillis(long) - Method in class reactor.core.publisher.Mono

Signal a TimeoutException error in case an item doesn't arrive before the given period.

timeoutMillis(long, TimedScheduler) - Method in class reactor.core.publisher.Mono

Signal a TimeoutException error in case an item doesn't arrive before the given period.

timeoutMillis(long, Mono<? extends T>) - Method in class reactor.core.publisher.Mono

Switch to a fallback Mono in case an item doesn't arrive before the given period.

timeoutMillis(long, Mono<? extends T>, TimedScheduler) - Method in class reactor.core.publisher.Mono

Switch to a fallback Mono in case an item doesn't arrive before the given period.

timer() - Static method in class reactor.core.scheduler.Schedulers

Create or reuse a hash-wheel based TimedScheduler with a resolution of 50MS All times will rounded up to the closest multiple of this resolution.

timestamp() - Method in class reactor.core.publisher.Flux

Emit a Tuple2 pair of T1 Long current system time in millis and T2 T associated data for each item from this Flux

timestamp(TimedScheduler) - Method in class reactor.core.publisher.Flux

Emit a Tuple2 pair of T1 Long current system time in millis and T2 T associated data for each item from this Flux

timestamp() - Method in class reactor.core.publisher.Mono

Emit a Tuple2 pair of T1 Long current system time in millis and T2 T associated data for the eventual item from this Mono

timestamp(TimedScheduler) - Method in class reactor.core.publisher.Mono

Emit a Tuple2 pair of T1 Long current system time in millis and T2 T associated data for the eventual item from this Mono

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 Tuples into a plain Object array.

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

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 next calls.

toIterable(long) - Method in class reactor.core.publisher.Flux

Transform this Flux into a lazy Iterable blocking on next calls.

toIterable(long, Supplier<Queue<T>>) - Method in class reactor.core.publisher.Flux

Transform this Flux into a lazy Iterable blocking on next calls.

toList() - Method in class reactor.util.function.Tuple2

Turn this Tuples into a plain Object list.

TopicProcessor<E> - Class in reactor.core.publisher

An implementation of a RingBuffer backed message-passing Processor implementing publish-subscribe with async event loops.

toStream() - Method in class reactor.core.publisher.Flux

Transform this Flux into a lazy Stream blocking on next calls.

toStream(int) - Method in class reactor.core.publisher.Flux

Transform this Flux into a lazy Stream blocking on next calls.

toString() - Method in class reactor.core.publisher.BaseSubscriber

toString() - Method in class reactor.core.publisher.BlockingSink

toString() - Method in class reactor.core.publisher.EmitterProcessor

toString() - Method in class reactor.core.publisher.Flux

toString() - Method in class reactor.core.publisher.FluxSource

toString() - Method in class reactor.core.publisher.Mono

toString() - Method in class reactor.core.publisher.MonoSource

toString() - Method in class reactor.core.publisher.Operators.SubscriberAdapter

toString() - Method in class reactor.core.publisher.Signal

toString() - Method in enum reactor.core.publisher.SignalType

toString() - Method in class reactor.util.function.Tuple2

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.

Trackable - Interface in reactor.core

A lifecycle backed downstream

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<U>>) - 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.

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 values

Tuple3<T1,T2,T3> - Class in reactor.util.function

A tuple that holds three values

Tuple4<T1,T2,T3,T4> - Class in reactor.util.function

A tuple that holds four values

Tuple5<T1,T2,T3,T4,T5> - Class in reactor.util.function

A tuple that holds five 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 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.QueueSupplier

unbounded(int) - Static method in class reactor.util.concurrent.QueueSupplier

Returns an unbounded, linked-array-based Queue.

undefined() - Static method in class reactor.core.publisher.MutableNextSignal

Create a new MutableNextSignal that hasn't had a value set yet.

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

UNSPECIFIED - Static variable in interface reactor.core.Trackable

Returned value when a given component does not provide access to the requested trait

unwrap(Throwable) - Static method in class reactor.core.Exceptions

Unwrap a particular Throwable only if it is a wrapped exception via Exceptions.bubble(java.lang.Throwable) or Exceptions.propagate(java.lang.Throwable).

upstream() - Method in class reactor.core.publisher.BaseSubscriber

upstream() - Method in class reactor.core.publisher.DirectProcessor

upstream() - Method in class reactor.core.publisher.EmitterProcessor

upstream() - Method in class reactor.core.publisher.FluxSource

upstream() - Method in class reactor.core.publisher.MonoProcessor

upstream() - Method in class reactor.core.publisher.MonoSource

upstream() - Method in class reactor.core.publisher.Operators.DeferredSubscription

upstream() - Method in class reactor.core.publisher.Operators.MonoSubscriber

upstream() - Method in class reactor.core.publisher.Operators.SubscriberAdapter

upstream() - Method in class reactor.core.publisher.ReplayProcessor

upstream() - Method in class reactor.core.publisher.UnicastProcessor

upstream() - Method in interface reactor.core.Receiver

Return the direct source of data, Supports reference.

upstreamCount() - Method in interface reactor.core.MultiReceiver

upstreams() - Method in interface reactor.core.MultiReceiver

Return the connected sources of data.

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.

V

validate(Subscription, Subscription) - Static method in class reactor.core.publisher.Operators

Check Subscription current state and cancel new Subscription if different null, returning 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.

value - Variable in class reactor.core.publisher.Operators.MonoSubscriber

valueOf(String) - Static method in enum reactor.core.publisher.BlockingSink.Emission

Returns the enum constant of this type with the specified name.

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.BlockingSink.Emission

Returns an array containing the constants of this enum type, in the order they are declared.

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

waitFor(long, LongSupplier, Runnable) - Method in class reactor.util.concurrent.WaitStrategy

Wait for the given sequence to be available.

WaitStrategy - Class in reactor.util.concurrent

Strategy employed to wait for specific LongSupplier values with various spinning strategies.

WaitStrategy() - Constructor for class reactor.util.concurrent.WaitStrategy

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(Mono<? extends T1>, Mono<? extends T2>) - Static method in class reactor.core.publisher.Mono

Merge given monos into a new a Mono that will be fulfilled when all of the given Monos have been fulfilled.

when(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 a Mono that will be fulfilled when all of the given Monos have been fulfilled.

when(Mono<? extends T1>, Mono<? extends T2>, Mono<? extends T3>) - Static method in class reactor.core.publisher.Mono

Merge given monos into a new a Mono that will be fulfilled when all of the given Monos have been fulfilled.

when(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 a Mono that will be fulfilled when all of the given Monos have been fulfilled.

when(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 a Mono that will be fulfilled when all of the given Monos have been fulfilled.

when(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 a Mono that will be fulfilled when all of the given Monos have been fulfilled.

when(Iterable<? extends Publisher<Void>>) - Static method in class reactor.core.publisher.Mono

Aggregate given void publishers into a new a Mono that will be fulfilled when all of the given Monos have been fulfilled.

when(Iterable<? extends Mono<?>>, Function<? super Object[], ? extends R>) - Static method in class reactor.core.publisher.Mono

Aggregate given monos into a new a Mono that will be fulfilled when all of the given Monos have been fulfilled.

when(Publisher<Void>...) - Static method in class reactor.core.publisher.Mono

Aggregate given void publisher into a new a Mono that will be fulfilled when all of the given Monos have been fulfilled.

when(Function<? super Object[], ? extends R>, Mono<?>...) - Static method in class reactor.core.publisher.Mono

Aggregate given monos into a new a Mono that will be fulfilled when all of the given Monos have been fulfilled.

whenDelayError(Mono<? extends T1>, Mono<? extends T2>) - Static method in class reactor.core.publisher.Mono

Merge given monos into a new a Mono that will be fulfilled when all of the given Monos have been fulfilled.

whenDelayError(Mono<? extends T1>, Mono<? extends T2>, Mono<? extends T3>) - Static method in class reactor.core.publisher.Mono

Merge given monos into a new a Mono that will be fulfilled when all of the given Mono Monos have been fulfilled.

whenDelayError(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 a Mono that will be fulfilled when all of the given Monos have been fulfilled.

whenDelayError(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 a Mono that will be fulfilled when all of the given Monos have been fulfilled.

whenDelayError(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 a Mono that will be fulfilled when all of the given Monos have been fulfilled.

whenDelayError(Publisher<Void>...) - Static method in class reactor.core.publisher.Mono

Merge given void publishers into a new a Mono that will be fulfilled when all of the given Monos have been fulfilled.

whenDelayError(Function<? super Object[], ? extends R>, Mono<?>...) - Static method in class reactor.core.publisher.Mono

Merge given monos into a new a Mono that will be fulfilled when all of the given Monos have been fulfilled.

window() - Method in class reactor.core.publisher.Flux

Deprecated.

will be removed in 3.1.0. Prefer using other variants, like Flux.window(Publisher),

window(int) - Method in class reactor.core.publisher.Flux

Split this Flux sequence into multiple Flux delimited by the given maxSize count and starting from the first item.

window(int, int) - Method in class reactor.core.publisher.Flux

Split this Flux sequence into multiple Flux delimited by the given skip count, starting from the first item.

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(Publisher<U>, 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.

window(Duration) - Method in class reactor.core.publisher.Flux

Split this Flux sequence into continuous, non-overlapping windows delimited by a given period.

window(Duration, Duration) - Method in class reactor.core.publisher.Flux

Split this Flux sequence into multiple Flux delimited by the given timeshift period, starting from the first item.

window(int, Duration) - Method in class reactor.core.publisher.Flux

Deprecated.

use Flux.windowTimeout(int, Duration) instead, will be removed in 3.1.0

windowMillis(long) - Method in class reactor.core.publisher.Flux

Split this Flux sequence into continuous, non-overlapping windows delimited by a given period.

windowMillis(long, TimedScheduler) - Method in class reactor.core.publisher.Flux

Split this Flux sequence into continuous, non-overlapping windows delimited by a given period.

windowMillis(long, long, TimedScheduler) - Method in class reactor.core.publisher.Flux

Split this Flux sequence into multiple Flux delimited by the given timeshift period, starting from the first item.

windowMillis(int, long) - Method in class reactor.core.publisher.Flux

Deprecated.

use Flux.windowTimeoutMillis(int, long) instead, will be removed in 3.1.0

windowMillis(int, long, TimedScheduler) - Method in class reactor.core.publisher.Flux

Deprecated.

use Flux.windowTimeoutMillis(int, long, TimedScheduler) instead, will be removed in 3.1.0

windowTimeout(int, Duration) - Method in class reactor.core.publisher.Flux

Split this Flux sequence into multiple Flux delimited by the given maxSize number of items, starting from the first item.

windowTimeoutMillis(int, long) - Method in class reactor.core.publisher.Flux

Split this Flux sequence into multiple Flux delimited by the given maxSize number of items, starting from the first item.

windowTimeoutMillis(int, long, TimedScheduler) - Method in class reactor.core.publisher.Flux

Split this Flux sequence into multiple Flux delimited by the given maxSize number of items, starting from the first item.

windowUntil(Predicate<T>) - Method in class reactor.core.publisher.Flux

Split this Flux sequence into multiple Flux delimited by the given predicate.

windowUntil(Predicate<T>, boolean) - Method in class reactor.core.publisher.Flux

Split this Flux sequence into multiple Flux delimited by the given predicate.

windowUntil(Predicate<T>, boolean, int) - Method in class reactor.core.publisher.Flux

Split this Flux sequence into multiple Flux delimited by the given predicate and using a prefetch.

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 values from this Flux with values from another Publisher through a BiFunction and emits the result.

WorkQueueProcessor<E> - Class in reactor.core.publisher

An implementation of a RingBuffer backed message-passing Processor implementing work-queue distribution with async event loops.

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.

wrap(Publisher<? extends I>) - Static method in class reactor.core.publisher.FluxSource

Unchecked wrap of Publisher as Flux, supporting Fuseable sources

wrap(Publisher<? extends I>) - Static method in class reactor.core.publisher.MonoSource

Unchecked wrap of Publisher as Mono, supporting Fuseable sources

X

xs() - Static method in class reactor.util.concurrent.QueueSupplier

XS_BUFFER_SIZE - Static variable in class reactor.util.concurrent.QueueSupplier

An allocation friendly default of available slots in a given container, e.g.

Y

yielding() - Static method in class reactor.util.concurrent.WaitStrategy

Yielding strategy that uses a Thread.yield() for consumers waiting on a barrier after an initially spinning.

Z

zip(Publisher<? extends T1>, Publisher<? extends T2>, BiFunction<? super T1, ? super T2, ? extends O>) - Static method in class reactor.core.publisher.Flux

"Step-Merge" especially useful in Scatter-Gather scenarios.

zip(Publisher<? extends T1>, Publisher<? extends T2>) - Static method in class reactor.core.publisher.Flux

"Step-Merge" especially useful in Scatter-Gather scenarios.

zip(Publisher<? extends T1>, Publisher<? extends T2>, Publisher<? extends T3>) - Static method in class reactor.core.publisher.Flux

"Step-Merge" especially useful in Scatter-Gather scenarios.

zip(Publisher<? extends T1>, Publisher<? extends T2>, Publisher<? extends T3>, Publisher<? extends T4>) - Static method in class reactor.core.publisher.Flux

"Step-Merge" especially useful in Scatter-Gather scenarios.

zip(Publisher<? extends T1>, Publisher<? extends T2>, Publisher<? extends T3>, Publisher<? extends T4>, Publisher<? extends T5>) - Static method in class reactor.core.publisher.Flux

"Step-Merge" especially useful in Scatter-Gather scenarios.

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

"Step-Merge" especially useful in Scatter-Gather scenarios.

zip(Iterable<? extends Publisher<?>>) - Static method in class reactor.core.publisher.Flux

Deprecated.

prefer using Flux.zip(Iterable, Function), will be removed in 3.1.0

zip(Iterable<? extends Publisher<?>>, Function<? super Object[], ? extends O>) - Static method in class reactor.core.publisher.Flux

"Step-Merge" especially useful in Scatter-Gather scenarios.

zip(Iterable<? extends Publisher<?>>, int, Function<? super Object[], ? extends O>) - Static method in class reactor.core.publisher.Flux

"Step-Merge" especially useful in Scatter-Gather scenarios.

zip(Function<? super Object[], ? extends O>, Publisher<? extends I>...) - Static method in class reactor.core.publisher.Flux

"Step-Merge" especially useful in Scatter-Gather scenarios.

zip(Function<? super Object[], ? extends O>, int, Publisher<? extends I>...) - Static method in class reactor.core.publisher.Flux

"Step-Merge" especially useful in Scatter-Gather scenarios.

zip(Publisher<? extends Publisher<?>>, Function<? super TUPLE, ? extends V>) - Static method in class reactor.core.publisher.Flux

"Step-Merge" especially useful in Scatter-Gather scenarios.

zip(Function<? super Object[], ? extends V>, Mono<? extends T>...) - Static method in class reactor.core.publisher.Mono

Aggregate given monos into a new a Mono that will be fulfilled when all of the given Monos have been fulfilled.

zip(Function<? super Object[], ? extends V>, Iterable<? extends Mono<? extends T>>) - Static method in class reactor.core.publisher.Mono

Aggregate given monos into a new a Mono that will be fulfilled when all of the given Monos have been fulfilled.

zipWith(Publisher<? extends T2>) - Method in class reactor.core.publisher.Flux

"Step-Merge" especially useful in Scatter-Gather scenarios.

zipWith(Publisher<? extends T2>, BiFunction<? super T, ? super T2, ? extends V>) - Method in class reactor.core.publisher.Flux

"Step-Merge" especially useful in Scatter-Gather scenarios.

zipWith(Publisher<? extends T2>, int, BiFunction<? super T, ? super T2, ? extends V>) - Method in class reactor.core.publisher.Flux

"Step-Merge" especially useful in Scatter-Gather scenarios.

zipWith(Publisher<? extends T2>, int) - Method in class reactor.core.publisher.Flux

"Step-Merge" especially useful in Scatter-Gather scenarios.

zipWithIterable(Iterable<? extends T2>) - Method in class reactor.core.publisher.Flux

Pairwise combines as Tuple2 elements of this Flux and an Iterable sequence.

zipWithIterable(Iterable<? extends T2>, BiFunction<? super T, ? super T2, ? extends V>) - Method in class reactor.core.publisher.Flux

Pairwise combines elements of this Flux and an Iterable sequence 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 Y Z