Emit a single boolean true if all values of this sequence match the given predicate.

The implementation uses short-circuit logic and completes with false if the predicate doesn't match a value.

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

The implementation uses short-circuit logic and completes with true if the predicate matches a value.

Immediately apply the given transformation to this Flux in order to generate a target type.

flux.as(Mono::from).subscribe()

Blocks until the upstream signals its first value or completes.

Blocks until the upstream signals its first value or completes.

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

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

Collect incoming values into multiple Seq delimited by the given timeshift period. Each Seq bucket will last until the timespan has elapsed, thus releasing the bucket to the returned Flux.

When timeshift > timespan : dropping buffers

When timeshift < timespan : overlapping buffers

When timeshift == timespan : exact buffers

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

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

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

Collect incoming values into multiple mutable.Seq that will be pushed into the returned Flux when the given max size is reached or onComplete is received. A new container mutable.Seq will be created every given skip count.

When Skip > Max Size : dropping buffers

When Skip < Max Size : overlapping buffers

When Skip == Max Size : exact buffers

Collect incoming values into multiple Seq that will be pushed into the returned Flux when the given max size is reached or onComplete is received. A new container Seq will be created every given skip count.

When Skip > Max Size : dropping buffers

When Skip < Max Size : overlapping buffers

When Skip == Max Size : exact buffers

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

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

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

Return the processor buffer capacity if any or Int.MaxValue

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

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

Collect incoming values into multiple Seq that will be pushed into the returned Flux each time the given predicate returns true. Note that the buffer into which the element that triggers the predicate to return true (and thus closes a buffer) is included depends on the cutBefore parameter: set it to true to include the boundary element in the newly opened buffer, false to include it in the closed buffer (as in Flux.bufferUntil).

On completion, if the latest buffer is non-empty and has not been closed it is emitted. However, such a "partial" buffer isn't emitted in case of onError termination.

Collect incoming values into multiple Seq that will be pushed into the returned Flux each time the given predicate returns true. Note that the element that triggers the predicate to return true (and thus closes a buffer) is included as last element in the emitted buffer.

On completion, if the latest buffer is non-empty and has not been closed it is emitted. However, such a "partial" buffer isn't emitted in case of onError termination.

Collect incoming values into multiple Seq delimited by the given Publisher signals. Each Seq bucket will last until the mapped Publisher receiving the boundary signal emits, thus releasing the bucket to the returned Flux.

When Open signal is strictly not overlapping Close signal : dropping buffers

When Open signal is strictly more frequent than Close signal : overlapping buffers

When Open signal is exactly coordinated with Close signal : exact buffers

Collect incoming values into multiple Seq delimited by the given Publisher signals. Each Seq bucket will last until the mapped Publisher receiving the boundary signal emits, thus releasing the bucket to the returned Flux.

When Open signal is strictly not overlapping Close signal : dropping buffers

When Open signal is strictly more frequent than Close signal : overlapping buffers

When Open signal is exactly coordinated with Close signal : exact buffers

Collect incoming values into multiple Seq that will be pushed into the returned Flux. Each buffer continues aggregating values while the given predicate returns true, and a new buffer is created as soon as the predicate returns false... Note that the element that triggers the predicate to return false (and thus closes a buffer) is NOT included in any emitted buffer.

On completion, if the latest buffer is non-empty and has not been closed it is emitted. However, such a "partial" buffer isn't emitted in case of onError termination.

Turn this Flux into a hot source and cache last emitted signals for further Subscriber. Will retain up to the given history size with per-item expiry timeout.

Turn this Flux into a hot source and cache last emitted signals for further Subscriber. Will retain an unbounded history with per-item expiry timeout Completion and Error will also be replayed.

Turn this Flux into a hot source and cache last emitted signals for further Subscriber. Will retain up to the given history size onNext signals. Completion and Error will also be replayed.

Turn this Flux into a hot source and cache last emitted signals for further Subscriber. Will retain up an unbounded volume of onNext signals. Completion and Error will also be replayed.

Prepare this Flux so that subscribers will cancel from it on a specified Scheduler.

Cast the current Flux produced type into a target produced type.

Activate assembly tracing for this particular Flux and give it a description that will be reflected in the assembly traceback in case of an error upstream of the checkpoint.

It should be placed towards the end of the reactive chain, as errors triggered downstream of it cannot be observed and augmented with assembly trace.

The description could for example be a meaningful name for the assembled flux or a wider correlation ID.

Activate assembly tracing for this particular Flux, in case of an error upstream of the checkpoint.

It should be placed towards the end of the reactive chain, as errors triggered downstream of it cannot be observed and augmented with assembly trace.

Collect the Flux sequence with the given collector and supplied container on subscribe. The collected result will be emitted when this sequence completes.

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.

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.

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

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.

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.

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.

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

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

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

Defer the transformation of this Flux in order to generate a target Flux for each new Subscriber.

flux.compose(Mono::from).subscribe()

Bind dynamic sequences given this input sequence like Flux.flatMap, but preserve ordering and concatenate emissions instead of merging (no interleave). Errors will immediately short circuit current concat backlog.

Bind dynamic sequences given this input sequence like Flux.flatMap, but preserve ordering and concatenate emissions instead of merging (no interleave). Errors will immediately short circuit current concat backlog.

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

Errors will be delayed after the current concat backlog if delayUntilEnd is false or after all sources if delayUntilEnd is true.

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

Errors will be delayed after all concated sources terminate.

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

Errors will be delayed after the current concat backlog.

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

Errors will be delayed after the current concat backlog.

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

Errors will be delayed after the current concat backlog.

Concatenate emissions of this Flux with the provided Publisher (no interleave).

Counts the number of values in this Flux. The count will be emitted when onComplete is observed.

Provide a default unique value if this sequence is completed without any data

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

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

Shift this Flux forward in time by a given Duration. Unlike with Flux.delayElements(Duration), elements are shifted forward in time as they are emitted, always resulting in the delay between two elements being the same as in the source (only the first element is visibly delayed from the previous event, that is the subscription). Signals are delayed and continue on an user-specified Scheduler, but empty sequences or immediate error signals are not delayed.

With this operator, a source emitting at 10Hz with a delaySequence Duration of 1s will still emit at 10Hz, with an initial "hiccup" of 1s. On the other hand, Flux.delayElements(Duration) would end up emitting at 1Hz.

This is closer to Flux.delaySubscription(Duration), except the source is subscribed to immediately.

Shift this Flux forward in time by a given Duration. Unlike with Flux.delayElements(Duration), elements are shifted forward in time as they are emitted, always resulting in the delay between two elements being the same as in the source (only the first element is visibly delayed from the previous event, that is the subscription). Signals are delayed and continue on the parallel Scheduler, but empty sequences or immediate error signals are not delayed.

With this operator, a source emitting at 10Hz with a delaySequence Duration of 1s will still emit at 10Hz, with an initial "hiccup" of 1s. On the other hand, Flux.delayElements(Duration) would end up emitting at 1Hz.

This is closer to Flux.delaySubscription(Duration), except the source is subscribed to immediately.

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

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

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

A "phantom-operator" working only if this Flux is a emits onNext, onError or onComplete reactor.core.publisher.Signal. The relative Subscriber callback will be invoked, error reactor.core.publisher.Signal will trigger onError and complete reactor.core.publisher.Signal will trigger onComplete.

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

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

Filter out subsequent repetitions of an element (that is, if they arrive right after one another), as compared by a key extracted through the user provided Function1 and then comparing keys with the supplied Function2.

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

Filters out subsequent and repeated elements.

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

Triggered when the Flux is cancelled.

Triggered when the Flux completes successfully.

Triggers side-effects when the Flux emits an item, fails with an error or completes successfully. All these events are represented as a Signal that is passed to the side-effect callback. Note that this is an advanced operator, typically used for monitoring of a Flux.

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

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

Triggered when the Flux completes with an error.

Triggered when the Flux emits an item.

Attach a Long customer to this Flux that will observe any request to this Flux.

Triggered when the Flux is subscribed.

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

Return the number of active Subscriber or -1 if untracked.

Map this Flux sequence into Tuple2 of T1 Long timemillis and T2 T associated data. The timemillis corresponds to the elapsed time between the subscribe and the first next signal OR between two next signals.

Map this Flux sequence into Tuple2 of T1 Long timemillis and T2 T associated data. The timemillis corresponds to the elapsed time between the subscribe and the first next signal OR between two next signals.

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

Emit only the element at the given index position or IndexOutOfBoundsException if the sequence is shorter.

Current error if any, default to None

Recursively expand elements into a graph and emit all the resulting element using a breadth-first traversal strategy.

That is: emit the values from this Flux first, then expand each at a first level of recursion and emit all of the resulting values, then expand all of these at a second level and so on..

For example, given the hierarchical structure

A
  - AA
    - aa1
B
  - BB
    - bb1

Expands Flux.just(A, B) into

A
B
AA
AB
aa1
bb1

Recursively expand elements into a graph and emit all the resulting element using a breadth-first traversal strategy.

That is: emit the values from this Flux first, then expand each at a first level of recursion and emit all of the resulting values, then expand all of these at a second level and so on..

For example, given the hierarchical structure

A
  - AA
    - aa1
B
  - BB
    - bb1

Expands Flux.just(A, B) into

A
B
AA
AB
aa1
bb1

Recursively expand elements into a graph and emit all the resulting element, in a depth-first traversal order.

That is: emit one value from this Flux, expand it and emit the first value at this first level of recursion, and so on... When no more recursion is possible, backtrack to the previous level and re-apply the strategy.

For example, given the hierarchical structure

A
  - AA
    - aa1
B
  - BB
    - bb1

Expands Flux.just(A, B) into

A
AA
aa1
B
BB
bb1

Recursively expand elements into a graph and emit all the resulting element, in a depth-first traversal order.

That is: emit one value from this Flux, expand it and emit the first value at this first level of recursion, and so on... When no more recursion is possible, backtrack to the previous level and re-apply the strategy.

For example, given the hierarchical structure

A
  - AA
    - aa1
B
  - BB
    - bb1

Expands Flux.just(A, B) into

A
AA
aa1
B
BB
bb1

Evaluate each accepted value against the given predicate T => Boolean. If the predicate test succeeds, the value is passed into the new Flux. If the predicate test fails, the value is ignored and a request of 1 is emitted.

Test each value emitted by this Flux asynchronously using a generated Publisher[Boolean] test. A value is replayed if the first item emitted by its corresponding test is true. It is dropped if its test is either empty or its first emitted value is false.

Note that only the first value of the test publisher is considered, and unless it is a Mono, test will be cancelled after receiving that first value. Test publishers are generated and subscribed to in sequence.

Test each value emitted by this Flux asynchronously using a generated Publisher[Boolean] test. A value is replayed if the first item emitted by its corresponding test is true. It is dropped if its test is either empty or its first emitted value is false.

Note that only the first value of the test publisher is considered, and unless it is a Mono, test will be cancelled after receiving that first value. Test publishers are generated and subscribed to in sequence.

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. OnError will be transformed into completion signal after its mapping callback has been applied.

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. The concurrency argument allows to control how many merged Publisher can happen in parallel. The prefetch argument allows to give an arbitrary prefetch size to the merged Publisher.

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. The concurrency argument allows to control how many merged Publisher can happen in parallel.

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.

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. The concurrency argument allows to control how many merged Publisher can happen in parallel. The prefetch argument allows to give an arbitrary prefetch size to the merged Publisher. This variant will delay any error until after the rest of the flatMap backlog has been processed.

Transform the items emitted by this Flux into Iterable, then flatten the emissions from those by merging them into a single Flux. The prefetch argument allows to give an arbitrary prefetch size to the merged Iterable.

Transform the items emitted by this Flux into Iterable, then flatten the elements from those by merging them into a single Flux. The prefetch argument allows to give an arbitrary prefetch size to the merged Iterable.

Transform the items emitted by this Flux into Publishers, then flatten the emissions from those by merging them into a single Flux, in order. Unlike concatMap, transformed inner Publishers are subscribed to eagerly. Unlike flatMap, their emitted elements are merged respecting the order of the original sequence. The concurrency argument allows to control how many merged Publisher can happen in parallel. The prefetch argument allows to give an arbitrary prefetch size to the merged Publisher.

Transform the items emitted by this Flux Flux} into Publishers, then flatten the emissions from those by merging them into a single Flux, in order. Unlike concatMap, transformed inner Publishers are subscribed to eagerly. Unlike flatMap, their emitted elements are merged respecting the order of the original sequence. The concurrency argument allows to control how many merged Publisher can happen in parallel.

Transform the items emitted by this Flux into Publishers, then flatten the emissions from those by merging them into a single Flux, in order. Unlike concatMap, transformed inner Publishers are subscribed to eagerly. Unlike flatMap, their emitted elements are merged respecting the order of the original sequence.

Transform the items emitted by this Flux into Publishers, then flatten the emissions from those by merging them into a single Flux, in order. Unlike concatMap, transformed inner Publishers are subscribed to eagerly. Unlike flatMap, their emitted elements are merged respecting the order of the original sequence. The concurrency argument allows to control how many merged Publisher can happen in parallel. The prefetch argument allows to give an arbitrary prefetch size to the merged Publisher. This variant will delay any error until after the rest of the flatMap backlog has been processed.

Bind dynamic sequences given this input sequence like Flux.flatMap, but preserve ordering and concatenate emissions instead of merging (no interleave). Errors will immediately short circuit current concat backlog.

Alias for concatMap.

The prefetch configuration of the Flux

Re-route this sequence into dynamically created Flux for each unique key evaluated by the given key mapper. It will use the given value mapper to extract the element to route.

Re-route this sequence into dynamically created Flux for each unique key evaluated by the given key mapper. It will use the given value mapper to extract the element to route.

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

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

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

There are no guarantees in what order the items get combined when multiple items from one or both source Publishers overlap.

Unlike Flux.join, items from the right Publisher will be streamed into the right resultSelector argument Flux.

Handle the items emitted by this Flux by calling a biconsumer with the output sink for each onNext. At most one SynchronousSink.next call must be performed and/or 0 or 1 SynchronousSink.error or SynchronousSink.complete.

Return true if terminated with onComplete

Return true if any Subscriber is actively subscribed

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

The implementation uses short-circuit logic and completes with true if the constant matches a value.

Emit a single boolean true if this Flux sequence has at least one element.

The implementation uses short-circuit logic and completes with true on onNext.

Return true if terminated with onError

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

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

Keep information about the order in which source values were received by indexing them internally with a 0-based incrementing long then combining this information with the source value into a I using the provided Function2 , returning a Flux[I].

Typical usage would be to produce a scala.Tuple2 similar to Flux.index(), but 1-based instead of 0-based:

index((i, v) => (i+1, v))

Keep information about the order in which source values were received by indexing them with a 0-based incrementing long, returning a Flux of value

Return true if this FluxProcessor supports multithread producing

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

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

There are no guarantees in what order the items get combined when multiple items from one or both source Publishers overlap.

Signal the last element observed before complete signal or emit the defaultValue if empty. For a passive version use Flux.takeLast

Signal the last element observed before complete signal or emit NoSuchElementException error if the source was empty. For a passive version use Flux.takeLast

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

Typically used for scenarios where consumer(s) request a large amount of data (eg. Long.MaxValue) but the data source behaves better or can be optimized with smaller requests (eg. database paging, etc...). All data is still processed.

Equivalent to flux.publishOn(Schedulers.immediate(), prefetchRate).subscribe()

Observe Reactive Streams signals matching the passed filter options and use Logger support to handle trace implementation. Default will use the passed Level and java.util.logging. If SLF4J is available, it will be used instead.

Options allow fine grained filtering of the traced signal, for instance to only capture onNext and onError:

    flux.log("category", Level.INFO, SignalType.ON_NEXT, SignalType.ON_ERROR)



@param category         to be mapped into logger configuration (e.g. org.springframework
                        .reactor). If category ends with "." like "reactor.", a generated operator
                        suffix will complete, e.g. "reactor.Flux.Map".
@param level            the [[Level]] to enforce for this tracing Flux (only FINEST, FINE,
                        INFO, WARNING and SEVERE are taken into account)
@param showOperatorLine capture the current stack to display operator
                        class/line number.
@param options          a vararg [[SignalType]] option to filter log messages
@return a new unaltered [[Flux]]

Observe Reactive Streams signals matching the passed filter options and use Logger support to handle trace implementation. Default will use the passed Level and java.util.logging. If SLF4J is available, it will be used instead.

Options allow fine grained filtering of the traced signal, for instance to only capture onNext and onError:

    flux.log("category", Level.INFO, SignalType.ON_NEXT, SignalType.ON_ERROR)








@param category to be mapped into logger configuration (e.g. org.springframework
                .reactor). If category ends with "." like "reactor.", a generated operator
                suffix will complete, e.g. "reactor.Flux.Map".
@param level    the [[Level]] to enforce for this tracing Flux (only FINEST, FINE,
                INFO, WARNING and SEVERE are taken into account)
@param options  a vararg [[SignalType]] option to filter log messages
@return a new unaltered [[Flux]]

Observe all Reactive Streams signals and use Logger support to handle trace implementation. Default will use Level.INFO and java.util.logging. If SLF4J is available, it will be used instead.

Observe all Reactive Streams signals and use Logger support to handle trace implementation. Default will use Level.INFO and java.util.logging. If SLF4J is available, it will be used instead.

The default log category will be "reactor.*", a generated operator suffix will complete, e.g. "reactor.Flux.Map".

Transform the items emitted by this Flux by applying a function to each item.

Transform the incoming onNext, onError and onComplete signals into Signal. Since the error is materialized as a Signal, the propagation will be stopped and onComplete will be emitted. Complete signal will first emit a Signal.complete and then effectively complete the flux.

Merge data from this Flux and a Publisher into an interleaved merged sequence. Unlike {concat, inner sources are subscribed to eagerly.

Note that merge is tailored to work with asynchronous sources or finite sources. When dealing with an infinite source that doesn't already publish on a dedicated Scheduler, you must isolate that source in its own Scheduler, as merge would otherwise attempt to drain it before subscribing to another source.

Give a name to this sequence, which can be retrieved using reactor.core.scala.Scannable.name() as long as this is the first reachable reactor.core.scala.Scannable.parents().

Check this Scannable and its Scannable.parents() for a name an return the first one that is reachable.

Emit only the first item emitted by this Flux.

Evaluate each accepted value against the given Class type. If the predicate test succeeds, the value is passed into the new Flux. If the predicate test fails, the value is ignored and a request of 1 is emitted.

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. Over that limit, the overflow strategy is applied (see BufferOverflowStrategy).

A Consumer is immediately invoked when there is an overflow, receiving the value that was discarded because of the overflow (which can be different from the latest element emitted by the source in case of a DROP_LATEST strategy).

Note that for the ERROR strategy, the overflow error will be delayed after the current backlog is consumed. The consumer is still invoked immediately.

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. Over that limit, the overflow strategy is applied (see BufferOverflowStrategy).

Note that for the ERROR strategy, the overflow error will be delayed after the current backlog is consumed.

Request an unbounded demand and push the returned Flux, or park the observed elements if not enough demand is requested downstream. Overflow error will be delayed after the current backlog is consumed. However the onOverflow will be immediately invoked.

Request an unbounded demand and push the returned Flux, or park the observed elements if not enough demand is requested downstream. Errors will be immediately emitted on overflow regardless of the pending buffer.

Request an unbounded demand and push the returned Flux, or park the observed elements if not enough demand is requested downstream. Errors will be delayed until the buffer gets consumed.

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.

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

Request an unbounded demand and push the returned Flux, or emit onError fom reactor.core.Exceptions.failWithOverflow if not enough demand is requested downstream.

Request an unbounded demand and push the returned Flux, or only keep the most recent observed item if not enough demand is requested downstream.

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

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

<img class="marble" src="https://raw.githubusercontent.com/reactor/reactor-core/v3.1.0.RC1/src/docs/marble/maperror.png"

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

Returns a Flux that mirrors the behavior of the source, unless the source is terminated with an onError, in which case the streaming of events fallbacks to a Flux emitting a single element generated by the backup function.

The created Flux mirrors the behavior of the source in case the source does not end with an error or if the thrown Throwable is not matched.

See onErrorResume for the version that takes a total function as a parameter.

Returns a Flux that mirrors the behavior of the source, unless the source is terminated with an onError, in which case the streaming of events continues with the specified backup sequence generated by the given function.

The created Flux mirrors the behavior of the source in case the source does not end with an error or if the thrown Throwable is not matched.

See onErrorResume for the version that takes a total function as a parameter.

Subscribe to a returned fallback publisher when an error matching the given type occurs.

alt="">

Subscribe to a returned fallback publisher when an error matching the given type occurs.

alt="">

Subscribe to a returned fallback publisher when any error occurs.

Fallback to the given value if an error matching the given predicate is observed on this Flux

Fallback to the given value if an error of a given type is observed on this Flux

Fallback to the given value if an error is observed on this Flux

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

This should help with odd retention scenarios when running with non-reactor Subscriber.

Check this Scannable and its Scannable.parents() for a name an return the first one that is reachable.

Pick the first Publisher between this Flux and another publisher to emit any signal (onNext/onError/onComplete) and replay all signals from that Publisher, effectively behaving like the fastest of these competing sources.

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.

Prepare to consume this Flux on parallelism number of 'rails' in round-robin fashion.

Prepare to consume this Flux on number of 'rails' matching number of CPU in round-robin fashion.

Return a Stream navigating the org.reactivestreams.Subscription chain (upward).