Package reactor.core.publisher

A strategy to evaluate if errors that happens during an operator's onNext call can be recovered from, allowing the sequence to continue.

SourceProducer is a Publisher that is Scannable for the purpose of being tied back to a chain of operators.

Blocks until the upstream signals its first value or completes.

Blocks until the upstream signals its last value or completes.

Blocks assuming the upstream is a Mono, until it signals its value or completes.

Utility class for the call-site extracting on Java 8.

Hide a ConnectableFlux from fusion optimizations while keeping the ConnectableFlux specific API visible.

Utility private class to detect if the context-propagation library is on the classpath and to offer ContextSnapshot support to Flux and Mono.

This Function wrapper is used by operators like Flux#transform(Function) to implement the context loss detection.

Connects to the underlying Flux once the given amount of Subscribers subscribed.

Buffers a certain number of subsequent elements and emits the buffers.

Buffers elements into custom collections where the buffer boundary is determined by a java.util.function.Predicate on the values.

Buffers elements into possibly overlapping buffers whose boundaries are determined by a start Publisher's element and a signal of a derived Publisher

Captures the current stacktrace when this publisher is created and makes it available/visible for debugging purposes from the inner Subscriber.

Combines the latest values from multiple sources through a function.

Concatenates a fixed array of Publishers' values.

Maps each upstream value into a Publisher and concatenates them into one sequence of items.

Emits a scalar value if the source sequence turns out to be empty.

Defers the creation of the actual Publisher the Subscriber will be subscribed to.

Delays the subscription to the main source until another Publisher signals a value or completes.

Detaches both the child Subscriber and the Subscription on termination or cancellation.

For each subscriber, tracks the source values that have been seen and filters out duplicates.

Hook into the lifecycle events and signals of a Flux and execute a provided callback after any of onComplete, onError and cancel events.

Hook into the org.reactivestreams.Publisher#subscribe(Subscriber) of a Fuseable Flux and execute a provided callback before calling org.reactivestreams.Publisher#subscribe(Subscriber) directly with the CoreSubscriber.

Peek into the lifecycle events and signals of a sequence, Fuseable version of FluxDoOnEach.

Represents an empty publisher which only calls onSubscribe and onComplete.

Emits a constant or generated Throwable instance to Subscribers.

A Flux that emits items from upstream and recursively expand them into inner sequences that are also replayed.

Filters out values that make a filter function return false.

Given a set of source Publishers the values of that Publisher is forwarded to the subscriber which responds first with any signal.

Maps a sequence of values each into a Publisher and flattens them back into a single sequence, interleaving events from the various inner Publishers.

A decorating Flux Publisher that exposes Flux API over an arbitrary Publisher.

Groups upstream items into their own Publisher sequence based on a key selector.

Maps the values of the source publisher one-on-one via a handler function as long as the handler function result is not null.

Hides the identities of the upstream Publisher object and its Subscription as well.

A reactor.core.Fuseable version of FluxIndex, an operator that tags the values it passes through with their index in the original sequence, either as their natural long index (0-based) or as a customized index by way of a user-provided BiFunction.

Emits the contents of an Iterable source via its Spliterator successor.

A Stream that emits only one value and then complete.

Peek into the lifecycle events and signals of a sequence.

Maps the values of the source publisher one-on-one via a mapper function.

Maps the values of the source publisher one-on-one via a mapper function.

Merges a fixed array of Publishers.

Maps each upstream value into a Publisher and concatenates them into one sequence of items.

An operator that just bears a name or a set of tags, which can be retrieved via the TAGS attribute.

Captures the current stacktrace when this publisher is created and makes it available/visible for debugging purposes from the inner Subscriber.

Buffers values if the subscriber doesn't request fast enough, bounding the buffer to a chosen size.

Drops values if the subscriber doesn't request fast enough.

Resumes the failed main sequence with another sequence returned by a function for the particular failure exception.

Peek into the lifecycle events and signals of a sequence.

A connectable publisher which shares an underlying source and dispatches source values to subscribers in a backpressure-aware manner.

Emits events on a different thread specified by a scheduler callback.

Connects to the underlying Flux once the given number of Subscribers subscribed to it and disconnects once all Subscribers cancelled their Subscriptions.

Repeatedly subscribes to the source and relays its values either indefinitely or a fixed number of times.

Repeats a source when a companion sequence signals an item in response to the main's completion signal

If the companion sequence signals when the main source is active, the repeat attempt is suppressed and any terminal signal will terminate the main source with the same signal immediately.

Repeatedly subscribes to the source sequence if it signals any error either indefinitely or a fixed number of times.

Samples the main source and emits its latest value whenever the other Publisher signals a value.

Emits the last value from upstream only if there were no newer values emitted during the time window provided by a publisher for that particular last value.

Aggregates the source values with the help of an accumulator function and emits the intermediate results.

Skips the last N elements from the source stream.

Skips values from the main publisher until the other publisher signals an onNext or onComplete.

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

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

Emits the contents of a Stream source.

Executes a Callable and emits its value on the given Scheduler.

Switches to another source if the first source turns out to be empty.

Switches to a new Publisher generated via a function whenever the upstream produces an item.

Takes only the first N values from the source Publisher.

Emits the last N values the source emitted before its completion.

Relays values until a predicate returns true, indicating the sequence should stop (checked after each value has been delivered).

Relays values while a predicate returns true for the values (checked before each value is delivered).

A reactor.core.Fuseable generic per-Subscription side effect Flux that notifies a SignalListener of most events.

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.

Splits the source sequence into possibly overlapping publishers.

Cut a sequence into non-overlapping windows where each window boundary is determined by a Predicate on the values.

Splits the source sequence into potentially overlapping windowEnds controlled by items of a start Publisher and end Publishers derived from the start values.

Repeatedly takes one item from all source Publishers and runs it through a function to produce the output item.

The common implementation of a Signal (serializable and immutable).

An unbounded Java Lambda adapter to Subscriber

Emits a single boolean true if all values of the source sequence match the predicate.

Utilities to avoid vararg array copying overhead when relaying vararg parameters to underlying Java methods from their corresponding Kotlin functions.

A caching operator that uses a companion Mono as a trigger to invalidate the cached value.

Executes a Callable function and emits a single value to each individual Subscriber.

Buffers all values from the source Publisher and emits it as a single List.

Counts the number of values in the source sequence.

Defers the creation of the actual Publisher the Subscriber will be subscribed to.

Emits a single 0L value delayed by some time amount with a help of a ScheduledExecutorService instance or a generic function callback that wraps other form of async-delayed execution of tasks.

Delays the subscription to the main source until another Publisher signals a value or completes.

Hook into the lifecycle events and signals of a Mono and execute a provided callback after any of onComplete, onError and cancel events.

Hook into the org.reactivestreams.Publisher#subscribe(Subscriber) of a Mono and execute a provided callback before calling org.reactivestreams.Publisher#subscribe(Subscriber) directly with the CoreSubscriber.

Peek into the lifecycle events and signals of a sequence, reactor.core.Fuseable version of MonoDoOnEach.

Emits only the element at the given index position or signals a default value if specified or IndexOutOfBoundsException if the sequence is shorter.

Emits a constant or generated Throwable instance to Subscribers.

A Flux that emits the item from a Mono and recursively expand it into inner sequences that are also replayed.

Filters out values that make a filter function return false.

Given a set of source Publishers the values of that Publisher is forwarded to the actual which responds first with any signal.

Given a Mono source, applies a function on its single item and continues with that Mono instance, emitting its final result.

Concatenates values from Iterable sequences generated via a mapper function.

Emits a single item at most from the source.

Maps the values of the source publisher one-on-one via a mapper function.

Ignores normal values and passes only the terminal signals along.

Ignores normal values and passes only the terminal signals along.

Peek into the lifecycle events and signals of a sequence.

Maps the values of the source publisher one-on-one via a mapper function.

An operator that just bears a name or a set of tags, which can be retrieved via the TAGS attribute.

Represents an never publisher which only calls onSubscribe.

Captures the current stacktrace when this publisher is created and makes it available/visible for debugging purposes from the inner Subscriber.

See FluxOnErrorReturn.

Peeks out values that make a filter function return false.

Peeks the value of a Mono and execute terminal callbacks accordingly, allowing to distinguish between cases where the Mono was empty, valued or errored.

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.

Aggregates the source items with an aggregator function and returns the last result.

Repeatedly subscribes to the source and relays its values either indefinitely or a fixed number of times.

Repeats a source when a companion sequence signals an item in response to the main's completion signal

If the companion sequence signals when the main source is active, the repeat attempt is suppressed and any terminal signal will terminate the main source with the same signal immediately.

retries a source when a companion sequence signals an item in response to the main's error signal

If the companion sequence signals when the main source is active, the repeat attempt is suppressed and any terminal signal will terminate the main source with the same signal immediately.

Expects and emits a single item from the source Callable or signals NoSuchElementException for empty source.

Emits a single item from the source wrapped into an Optional, emits an empty Optional instead for empty source.

A decorating Mono Publisher that exposes Mono API over an arbitrary Publisher Useful to create operators which return a Mono, e.g. : flux.as(Mono::fromDirect) .then(d -> Mono.delay(Duration.ofSeconds(1)) .block();

Collects the values from the source sequence into a java.util.stream.Collector instance.

Executes a Callable and emits its value on the given Scheduler.

Executes a Supplier function and emits a single value to each individual Subscriber.

Take the very last value from a Publisher source and and emit that one.

A generic per-Subscription side effect Mono that notifies a SignalListener of most events.

A generic per-Subscription side effect Mono that notifies a SignalListener of most events.

Signals a timeout (or switches to another sequence) in case a per-item generated Publisher source fires an item or completes before the next item arrives from the main source.

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.

Waits for all Mono sources to produce a value or terminate, and if all of them produced a value, emit a Tuples of those values; otherwise terminate.

Reduce the sequence of values in each 'rail' to a single value.

Execute a Consumer in each 'rail' for the current element passing through.

Flattens the generated Publishers on each rail.

Hides the identities of the upstream Publisher object and its Subscription as well.

Captures the current stacktrace when this connectable publisher is created and makes it available/visible for debugging purposes from the inner Subscriber.

Exposes the 'rails' as individual GroupedFlux instances, keyed by the rail index (zero based).

Maps each 'rail' of the source ParallelFlux with a mapper function.

Reduces all 'rails' into a single value which then gets reduced into a single Publisher sequence.

Given sorted rail sequences (according to the provided comparator) as List emit the smallest item from these parallel Lists to the Subscriber.

Reduce the sequence of values in each 'rail' to a single value.

Dispatches the values from upstream in a round robin fashion to subscribers which are ready to consume elements.

Abstract base class for subscribers that hold another subscriber, a queue and requires queue-drain behavior.

Pads away the wip from the other fields.

Pads away the requested from the other fields.

A logging interceptor that intercepts all reactive calls and trace them.

An implementation of a Sinks.ManyWithUpstream implementing publish-subscribe with synchronous (thread-stealing and happen-before interactions) drain loops.

Reactive Streams Commons safe exit