Index (Reactor Core 3.0.4.BUILD-SNAPSHOT)

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: Concurrent addition bound to Long.MAX_VALUE.
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, 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, 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: Collect incoming values into a List that will be pushed into the returned Flux every timespan OR maxSize items.
buffer(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.
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: Collect incoming values into a List that will be pushed into the returned Flux every timespan OR maxSize items.
bufferMillis(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
bufferMillis(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
BufferOverflowStrategy - Enum in reactor.core.publisher: Strategies to deal with overflow of a buffer during backpressure buffering.
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 false.
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 false.
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
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.
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<T, A, R>) - Method in class reactor.core.publisher.Flux: Collect the Flux sequence with the given collector and supplied container on subscribe.
collect(Supplier<C>, BiConsumer<C, 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.
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
connectedOutput() - Method in class reactor.core.publisher.Operators.MonoSubscriber
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.
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: Delay this Flux signals to Subscriber.onNext(T) until the given period elapses.
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.
delayMillis(long) - Method in class reactor.core.publisher.Flux: Delay this Flux signals to Subscriber.onNext(T) until the given period in milliseconds elapses.
delayMillis(long, TimedScheduler) - Method in class reactor.core.publisher.Flux: Delay this Flux signals to Subscriber.onNext(T) until the given period in milliseconds elapses.
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) - 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) - 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 class reactor.core.scheduler.RejectedDisposable
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.
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
downstreamCount() - Method in class reactor.core.publisher.TopicProcessor
downstreamCount() - Method in class reactor.core.publisher.WorkQueueProcessor
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
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 Tuples with the given object.
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.
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>, 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.
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.
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: Returns true if the parallel sequence has to be ordered when joining back.
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
iterator() - Method in class reactor.util.function.Tuple3
iterator() - Method in class reactor.util.function.Tuple4
iterator() - Method in class reactor.util.function.Tuple5
iterator() - Method in class reactor.util.function.Tuple6
iterator() - Method in class reactor.util.function.Tuple7
iterator() - Method in class reactor.util.function.Tuple8

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 flows.
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 flows.
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 flows.
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 flows.
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) - Method in class reactor.core.publisher.Flux: Evaluate each accepted value against the given Class type.
ofType(Class) - Method in class reactor.core.publisher.Mono: Evaluate the 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: Abstract base class for Parallel publishers that take an array of Subscribers.
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) - 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, 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.
RejectedDisposable - Class in reactor.core.scheduler
RejectedDisposable() - Constructor for class reactor.core.scheduler.RejectedDisposable
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) - 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>) - 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>) - 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>, 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: Start the chain and request prefetch demand
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
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: Throw a signal singleton exception that can be checked against WaitStrategy.isAlert(Throwable)
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) - 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, 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, 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) - Method in class reactor.core.publisher.Mono: Signal a TimeoutException in case the item from this Mono has not been emitted before the given Publisher emits.
timeout(Publisher, Mono<? extends T>) - Method in class reactor.core.publisher.Mono: Switch to a fallback Publisher in case the item from this Mono has not been emitted before the given Publisher emits.
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.core.scheduler.RejectedDisposable
toString() - Method in class reactor.util.function.Tuple2
toString() - Method in class reactor.util.function.Tuple3
toString() - Method in class reactor.util.function.Tuple4
toString() - Method in class reactor.util.function.Tuple5
toString() - Method in class reactor.util.function.Tuple6
toString() - Method in class reactor.util.function.Tuple7
toString() - Method in class reactor.util.function.Tuple8
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>) - 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: Split this Flux sequence into multiple Flux delimited by cancel signals they receive.
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, 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: Split this Flux sequence into multiple Flux delimited by the given maxSize number of items, starting from the first item.
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: Split this Flux sequence into multiple Flux delimited by the given maxSize number of items, starting from the first item.
windowMillis(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.
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: "Step-Merge" especially useful in Scatter-Gather scenarios.
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