reactor.core.publisher

Class Flux<T>

java.lang.Object

reactor.core.publisher.Flux<T>

Type Parameters:

T - the element type of this Reactive Streams Publisher

All Implemented Interfaces:

Publisher<T>

Direct Known Subclasses:

ConnectableFlux, FluxProcessor, FluxSource, GroupedFlux

public abstract class Flux<T>
extends Object
implements Publisher<T>

A Reactive Streams Publisher with rx operators that emits 0 to N elements, and then completes (successfully or with an error).

It is intended to be used in implementations and return types. Input parameters should keep using raw Publisher as much as possible.

If it is known that the underlying Publisher will emit 0 or 1 element, Mono should be used instead.

Note that using state in the java.util.function / lambdas used within Flux operators should be avoided, as these may be shared between several Subscribers.

Author:

Sebastien Deleuze, Stephane Maldini, David Karnok

See Also:

Mono

Constructor Summary

Constructors

Constructor and Description
Flux()

Method Summary

Modifier and Type	Method and Description
Mono<Boolean>	all(Predicate<? super T> predicate) Emit a single boolean true if all values of this sequence match the Predicate.
Mono<Boolean>	any(Predicate<? super T> predicate) Emit a single boolean true if any of the values of this Flux sequence match the predicate.
<P> P	as(Function<? super Flux<T>,P> transformer) Immediately apply the given transformation to this Flux in order to generate a target type.
Flux<T>	awaitOnSubscribe() Intercepts the onSubscribe call and makes sure calls to Subscription methods only happen after the child Subscriber has returned from its onSubscribe method.
T	blockFirst() Blocks until the upstream signals its first value or completes.
T	blockFirst(Duration d) Blocks until the upstream signals its first value or completes.
T	blockFirstMillis(long timeout) Blocks until the upstream signals its first value or completes.
T	blockLast() Blocks until the upstream completes and return the last emitted value.
T	blockLast(Duration d) Blocks until the upstream completes and return the last emitted value.
T	blockLastMillis(long timeout) Blocks until the upstream completes and return the last emitted value.
Flux<List<T>>	buffer() Collect incoming values into a List that will be pushed into the returned Flux on complete only.
Flux<List<T>>	buffer(Duration timespan) Collect incoming values into multiple List that will be pushed into the returned Flux every timespan.
Flux<List<T>>	buffer(Duration timespan, Duration timeshift) Collect incoming values into multiple List delimited by the given timeshift period.
Flux<List<T>>	buffer(int maxSize) 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.
Flux<List<T>>	buffer(int maxSize, Duration timespan) Deprecated. use bufferTimeout(int, Duration) instead, will be removed in 3.1.0
<C extends Collection<? super T>> Flux<C>	buffer(int maxSize, Duration timespan, Supplier<C> bufferSupplier) Deprecated. use bufferTimeout(int, Duration, Supplier) instead, will be removed in 3.1.0
Flux<List<T>>	buffer(int maxSize, int skip) 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.
<C extends Collection<? super T>> Flux<C>	buffer(int maxSize, int skip, Supplier<C> bufferSupplier) 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.
<C extends Collection<? super T>> Flux<C>	buffer(int maxSize, Supplier<C> bufferSupplier) 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.
Flux<List<T>>	buffer(Publisher<?> other) Collect incoming values into multiple List delimited by the given Publisher signals.
<C extends Collection<? super T>> Flux<C>	buffer(Publisher<?> other, Supplier<C> bufferSupplier) Collect incoming values into multiple Collection delimited by the given Publisher signals.
<U,V> Flux<List<T>>	buffer(Publisher<U> bucketOpening, Function<? super U,? extends Publisher<V>> closeSelector) Collect incoming values into multiple List delimited by the given Publisher signals.
<U,V,C extends Collection<? super T>> Flux<C>	buffer(Publisher<U> bucketOpening, Function<? super U,? extends Publisher<V>> closeSelector, Supplier<C> bufferSupplier) Collect incoming values into multiple Collection delimited by the given Publisher signals.
Flux<List<T>>	bufferMillis(int maxSize, long timespan) Deprecated. use bufferTimeoutMillis(int, long) instead, will be removed in 3.1.0
Flux<List<T>>	bufferMillis(int maxSize, long timespan, TimedScheduler timer) Deprecated. use bufferTimeoutMillis(int, long, TimedScheduler) instead, will be removed in 3.1.0
<C extends Collection<? super T>> Flux<C>	bufferMillis(int maxSize, long timespan, TimedScheduler timer, Supplier<C> bufferSupplier) Deprecated. use bufferTimeoutMillis(int, long, TimedScheduler, Supplier) instead, will be removed in 3.1.0
Flux<List<T>>	bufferMillis(long timespan) Collect incoming values into multiple List that will be pushed into the returned Flux every timespan.
Flux<List<T>>	bufferMillis(long timespan, long timeshift) Collect incoming values into multiple List delimited by the given timeshift period.
Flux<List<T>>	bufferMillis(long timespan, long timeshift, TimedScheduler timer) Collect incoming values into multiple List delimited by the given timeshift period.
Flux<List<T>>	bufferMillis(long timespan, TimedScheduler timer) Collect incoming values into multiple List that will be pushed into the returned Flux every timespan.
Flux<List<T>>	bufferTimeout(int maxSize, Duration timespan) Collect incoming values into a List that will be pushed into the returned Flux every timespan OR maxSize items.
<C extends Collection<? super T>> Flux<C>	bufferTimeout(int maxSize, Duration timespan, Supplier<C> bufferSupplier) Collect incoming values into a Collection that will be pushed into the returned Flux every timespan OR maxSize items.
Flux<List<T>>	bufferTimeoutMillis(int maxSize, long timespan) Collect incoming values into a List that will be pushed into the returned Flux every timespan OR maxSize items.
Flux<List<T>>	bufferTimeoutMillis(int maxSize, long timespan, TimedScheduler timer) Collect incoming values into a List that will be pushed into the returned Flux every timespan OR maxSize items
<C extends Collection<? super T>> Flux<C>	bufferTimeoutMillis(int maxSize, long timespan, TimedScheduler timer, Supplier<C> bufferSupplier) Collect incoming values into a Collection that will be pushed into the returned Flux every timespan OR maxSize items
Flux<List<T>>	bufferUntil(Predicate<? super T> predicate) Collect incoming values into multiple List that will be pushed into the returned Flux each time the given predicate returns true.
Flux<List<T>>	bufferUntil(Predicate<? super T> predicate, boolean cutBefore) Collect incoming values into multiple List that will be pushed into the returned Flux each time the given predicate returns true.
Flux<List<T>>	bufferWhile(Predicate<? super T> predicate) Collect incoming values into multiple List that will be pushed into the returned Flux.
Flux<T>	cache() Turn this Flux into a hot source and cache last emitted signals for further Subscriber.
Flux<T>	cache(Duration ttl) Turn this Flux into a hot source and cache last emitted signals for further Subscriber.
Flux<T>	cache(int history) Turn this Flux into a hot source and cache last emitted signals for further Subscriber.
Flux<T>	cache(int history, Duration ttl) Turn this Flux into a hot source and cache last emitted signals for further Subscriber.
Flux<T>	cancelOn(Scheduler scheduler) Prepare this Flux so that subscribers will cancel from it on a specified Scheduler.
<E> Flux<E>	cast(Class<E> clazz) Cast the current Flux produced type into a target produced type.
Flux<T>	checkpoint() Activate assembly tracing for this particular Flux, in case of an error upstream of the checkpoint.
Flux<T>	checkpoint(String description) 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.
<R,A> Mono<R>	collect(Collector<? super T,A,? extends R> collector) Collect the Flux sequence with the given collector and supplied container on subscribe.
<E> Mono<E>	collect(Supplier<E> containerSupplier, BiConsumer<E,? super T> collector) Collect the Flux sequence with the given collector and supplied container on subscribe.
Mono<List<T>>	collectList() Accumulate this Flux sequence in a List that is emitted to the returned Mono on onComplete.
<K> Mono<Map<K,T>>	collectMap(Function<? super T,? extends K> keyExtractor) 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.
<K,V> Mono<Map<K,V>>	collectMap(Function<? super T,? extends K> keyExtractor, Function<? super T,? extends V> valueExtractor) 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.
<K,V> Mono<Map<K,V>>	collectMap(Function<? super T,? extends K> keyExtractor, Function<? super T,? extends V> valueExtractor, Supplier<Map<K,V>> mapSupplier) 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.
<K> Mono<Map<K,Collection<T>>>	collectMultimap(Function<? super T,? extends K> keyExtractor) 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.
<K,V> Mono<Map<K,Collection<V>>>	collectMultimap(Function<? super T,? extends K> keyExtractor, Function<? super T,? extends V> valueExtractor) 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.
<K,V> Mono<Map<K,Collection<V>>>	collectMultimap(Function<? super T,? extends K> keyExtractor, Function<? super T,? extends V> valueExtractor, Supplier<Map<K,Collection<V>>> mapSupplier) 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.
Mono<List<T>>	collectSortedList() Accumulate and sort this Flux sequence in a List that is emitted to the returned Mono on onComplete.
Mono<List<T>>	collectSortedList(Comparator<? super T> comparator) Accumulate and sort using the given comparator this Flux sequence in a List that is emitted to the returned Mono on onComplete.
static <T,V> Flux<V>	combineLatest(Function<Object[],V> combinator, int prefetch, Publisher<? extends T>... sources) Build a Flux whose data are generated by the combination of the most recent published values from all publishers.
static <T,V> Flux<V>	combineLatest(Function<Object[],V> combinator, Publisher<? extends T>... sources) Build a Flux whose data are generated by the combination of the most recent published values from all publishers.
static <T,V> Flux<V>	combineLatest(Iterable<? extends Publisher<? extends T>> sources, Function<Object[],V> combinator) Build a Flux whose data are generated by the combination of the most recent published values from all publishers.
static <T,V> Flux<V>	combineLatest(Iterable<? extends Publisher<? extends T>> sources, int prefetch, Function<Object[],V> combinator) Build a Flux whose data are generated by the combination of the most recent published values from all publishers.
static <T1,T2,V> Flux<V>	combineLatest(Publisher<? extends T1> source1, Publisher<? extends T2> source2, BiFunction<? super T1,? super T2,? extends V> combinator) Build a Flux whose data are generated by the combination of the most recent published values from all publishers.
static <T1,T2,T3,V> Flux<V>	combineLatest(Publisher<? extends T1> source1, Publisher<? extends T2> source2, Publisher<? extends T3> source3, Function<Object[],V> combinator) Build a Flux whose data are generated by the combination of the most recent published values from all publishers.
static <T1,T2,T3,T4,V> Flux<V>	combineLatest(Publisher<? extends T1> source1, Publisher<? extends T2> source2, Publisher<? extends T3> source3, Publisher<? extends T4> source4, Function<Object[],V> combinator) Build a Flux whose data are generated by the combination of the most recent published values from all publishers.
static <T1,T2,T3,T4,T5,V> Flux<V>	combineLatest(Publisher<? extends T1> source1, Publisher<? extends T2> source2, Publisher<? extends T3> source3, Publisher<? extends T4> source4, Publisher<? extends T5> source5, Function<Object[],V> combinator) Build a Flux whose data are generated by the combination of the most recent published values from all publishers.
static <T1,T2,T3,T4,T5,T6,V> Flux<V>	combineLatest(Publisher<? extends T1> source1, Publisher<? extends T2> source2, Publisher<? extends T3> source3, Publisher<? extends T4> source4, Publisher<? extends T5> source5, Publisher<? extends T6> source6, Function<Object[],V> combinator) Build a Flux whose data are generated by the combination of the most recent published values from all publishers.
<V> Flux<V>	compose(Function<? super Flux<T>,? extends Publisher<V>> transformer) Defer the transformation of this Flux in order to generate a target Flux for each new Subscriber.
static <T> Flux<T>	concat(Iterable<? extends Publisher<? extends T>> sources) 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.
static <T> Flux<T>	concat(Publisher<? extends Publisher<? extends T>> sources) Concat all sources emitted as an onNext signal from a parent Publisher.
static <T> Flux<T>	concat(Publisher<? extends Publisher<? extends T>> sources, int prefetch) Concat all sources emitted as an onNext signal from a parent Publisher.
static <T> Flux<T>	concat(Publisher<? extends T>... sources) Concat all sources pulled from the given Publisher array.
static <T> Flux<T>	concatDelayError(Publisher<? extends Publisher<? extends T>> sources) Concat all sources emitted as an onNext signal from a parent Publisher.
static <T> Flux<T>	concatDelayError(Publisher<? extends Publisher<? extends T>> sources, boolean delayUntilEnd, int prefetch) Concat all sources emitted as an onNext signal from a parent Publisher.
static <T> Flux<T>	concatDelayError(Publisher<? extends Publisher<? extends T>> sources, int prefetch) Concat all sources emitted as an onNext signal from a parent Publisher.
static <T> Flux<T>	concatDelayError(Publisher<? extends T>... sources) Concat all sources pulled from the given Publisher array.
<V> Flux<V>	concatMap(Function<? super T,? extends Publisher<? extends V>> mapper) Bind dynamic sequences given this input sequence like flatMap(Function), but preserve ordering and concatenate emissions instead of merging (no interleave).
<V> Flux<V>	concatMap(Function<? super T,? extends Publisher<? extends V>> mapper, int prefetch) Bind dynamic sequences given this input sequence like flatMap(Function), but preserve ordering and concatenate emissions instead of merging (no interleave).
<V> Flux<V>	concatMapDelayError(Function<? super T,? extends Publisher<? extends V>> mapper, boolean delayUntilEnd, int prefetch) Bind dynamic sequences given this input sequence like flatMap(Function), but preserve ordering and concatenate emissions instead of merging (no interleave).
<V> Flux<V>	concatMapDelayError(Function<? super T,? extends Publisher<? extends V>> mapper, int prefetch) Bind dynamic sequences given this input sequence like flatMap(Function), but preserve ordering and concatenate emissions instead of merging (no interleave).
<V> Flux<V>	concatMapDelayError(Function<? super T,Publisher<? extends V>> mapper) Bind dynamic sequences given this input sequence like flatMap(Function), but preserve ordering and concatenate emissions instead of merging (no interleave).
<R> Flux<R>	concatMapIterable(Function<? super T,? extends Iterable<? extends R>> mapper) Bind Iterable sequences given this input sequence like flatMapIterable(Function), but preserve ordering and concatenate emissions instead of merging (no interleave).
<R> Flux<R>	concatMapIterable(Function<? super T,? extends Iterable<? extends R>> mapper, int prefetch) Bind Iterable sequences given this input sequence like flatMapIterable(Function), but preserve ordering and concatenate emissions instead of merging (no interleave).
Flux<T>	concatWith(Publisher<? extends T> other) Concatenate emissions of this Flux with the provided Publisher (no interleave).
Mono<Long>	count() Counts the number of values in this Flux.
static <T> Flux<T>	create(Consumer<? super FluxSink<T>> emitter) Creates a Flux with multi-emission capabilities (synchronous or asynchronous) through the FluxSink API.
static <T> Flux<T>	create(Consumer<? super FluxSink<T>> emitter, FluxSink.OverflowStrategy backpressure) Creates a Flux with multi-emission capabilities (synchronous or asynchronous) through the FluxSink API.
Flux<T>	defaultIfEmpty(T defaultV) Provide a default unique value if this sequence is completed without any data
static <T> Flux<T>	defer(Supplier<? extends Publisher<T>> supplier) Supply a Publisher everytime subscribe is called on the returned flux.
Flux<T>	delay(Duration delay) Deprecated. will be replaced by delayElements(Duration) in 3.1.0
Flux<T>	delayElements(Duration delay) Delay each of this Flux elements (Subscriber.onNext(T) signals) by a given duration.
Flux<T>	delayElementsMillis(long delay) Delay each of this Flux elements (Subscriber.onNext(T) signals) by a given duration in milliseconds.
Flux<T>	delayElementsMillis(long delay, TimedScheduler timer) Delay each of this Flux elements (Subscriber.onNext(T) signals) by a given duration in milliseconds.
Flux<T>	delayMillis(long delay) Deprecated. will be replaced by delayElementsMillis(long) in 3.1.0
Flux<T>	delayMillis(long delay, TimedScheduler timer) Deprecated. will be replaced by delayElementsMillis(long, TimedScheduler) in 3.1.0
Flux<T>	delaySubscription(Duration delay) Delay the subscription to this Flux source until the given period elapses.
<U> Flux<T>	delaySubscription(Publisher<U> subscriptionDelay) Delay the subscription to the main source until another Publisher signals a value or completes.
Flux<T>	delaySubscriptionMillis(long delay) Delay the subscription to this Flux source until the given period elapses.
Flux<T>	delaySubscriptionMillis(long delay, TimedScheduler timer) Delay the subscription to this Flux source until the given period elapses.
<X> Flux<X>	dematerialize() A "phantom-operator" working only if this Flux is a emits onNext, onError or onComplete Signal.
Flux<T>	distinct() For each Subscriber, tracks this Flux values that have been seen and filters out duplicates.
<V> Flux<T>	distinct(Function<? super T,? extends V> keySelector) For each Subscriber, tracks this Flux values that have been seen and filters out duplicates given the extracted key.
Flux<T>	distinctUntilChanged() Filters out subsequent and repeated elements.
<V> Flux<T>	distinctUntilChanged(Function<? super T,? extends V> keySelector) Filters out subsequent and repeated elements provided a matching extracted key.
Flux<T>	doAfterTerminate(Runnable afterTerminate) Triggered after the Flux terminates, either by completing downstream successfully or with an error.
Flux<T>	doFinally(Consumer<SignalType> onFinally)
Flux<T>	doOnCancel(Runnable onCancel) Triggered when the Flux is cancelled.
Flux<T>	doOnComplete(Runnable onComplete) Triggered when the Flux completes successfully.
Flux<T>	doOnEach(Consumer<? super Signal<T>> signalConsumer) Triggers side-effects when the Flux emits an item, fails with an error or completes successfully.
<E extends Throwable> Flux<T>	doOnError(Class<E> exceptionType, Consumer<? super E> onError) Triggered when the Flux completes with an error matching the given exception type.
Flux<T>	doOnError(Consumer<? super Throwable> onError) Triggered when the Flux completes with an error.
Flux<T>	doOnError(Predicate<? super Throwable> predicate, Consumer<? super Throwable> onError) Triggered when the Flux completes with an error matching the given exception.
Flux<T>	doOnNext(Consumer<? super T> onNext) Triggered when the Flux emits an item.
Flux<T>	doOnRequest(LongConsumer consumer) Attach a LongConsumer to this Flux that will observe any request to this Flux.
Flux<T>	doOnSubscribe(Consumer<? super Subscription> onSubscribe) Triggered when the Flux is subscribed.
Flux<T>	doOnTerminate(Runnable onTerminate) Triggered when the Flux terminates, either by completing successfully or with an error.
Flux<Tuple2<Long,T>>	elapsed() Map this Flux sequence into Tuple2 of T1 Long timemillis and T2 T associated data.
Flux<Tuple2<Long,T>>	elapsed(TimedScheduler scheduler) Map this Flux sequence into Tuple2 of T1 Long timemillis and T2 T associated data.
Mono<T>	elementAt(int index) Emit only the element at the given index position or IndexOutOfBoundsException if the sequence is shorter.
Mono<T>	elementAt(int index, T defaultValue) Emit only the element at the given index position or signals a default value if specified if the sequence is shorter.
static <T> Flux<T>	empty() Create a Flux that completes without emitting any item.
static <T> Flux<T>	error(Throwable error) Create a Flux that completes with the specified error.
static <O> Flux<O>	error(Throwable throwable, boolean whenRequested) Build a Flux that will only emit an error signal to any new subscriber.
Flux<T>	filter(Predicate<? super T> p) Evaluate each accepted value against the given Predicate.
static <I> Flux<I>	firstEmitting(Iterable<? extends Publisher<? extends I>> sources) Select the fastest source who won the "ambiguous" race and emitted first onNext or onComplete or onError
static <I> Flux<I>	firstEmitting(Publisher<? extends I>... sources) Select the fastest source who emitted first onNext or onComplete or onError
Flux<T>	firstEmittingWith(Publisher<? extends T> other) Emit from the fastest first sequence between this publisher and the given publisher
<R> Flux<R>	flatMap(Function<? super T,? extends Publisher<? extends R>> mapper) 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.
<R> Flux<R>	flatMap(Function<? super T,? extends Publisher<? extends R>> mapperOnNext, Function<Throwable,? extends Publisher<? extends R>> mapperOnError, Supplier<? extends Publisher<? extends R>> mapperOnComplete) 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.
<V> Flux<V>	flatMap(Function<? super T,? extends Publisher<? extends V>> mapper, boolean delayError, int concurrency, int prefetch) 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.
<V> Flux<V>	flatMap(Function<? super T,? extends Publisher<? extends V>> mapper, int concurrency) 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.
<V> Flux<V>	flatMap(Function<? super T,? extends Publisher<? extends V>> mapper, int concurrency, int prefetch) 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.
<R> Flux<R>	flatMapIterable(Function<? super T,? extends Iterable<? extends R>> mapper) Transform the items emitted by this Flux into Iterable, then flatten the elements from those by merging them into a single Flux.
<R> Flux<R>	flatMapIterable(Function<? super T,? extends Iterable<? extends R>> mapper, int prefetch) Transform the items emitted by this Flux into Iterable, then flatten the emissions from those by merging them into a single Flux.
<R> Flux<R>	flatMapSequential(Function<? super T,? extends Publisher<? extends R>> mapper) Transform the items emitted by this Flux into Publishers, then flatten the emissions from those by merging them into a single Flux, in order.
<R> Flux<R>	flatMapSequential(Function<? super T,? extends Publisher<? extends R>> mapper, boolean delayError, int maxConcurrency, int prefetch) Transform the items emitted by this Flux into Publishers, then flatten the emissions from those by merging them into a single Flux, in order.
<R> Flux<R>	flatMapSequential(Function<? super T,? extends Publisher<? extends R>> mapper, int maxConcurrency) Transform the items emitted by this Flux into Publishers, then flatten the emissions from those by merging them into a single Flux, in order.
<R> Flux<R>	flatMapSequential(Function<? super T,? extends Publisher<? extends R>> mapper, int maxConcurrency, int prefetch) Transform the items emitted by this Flux into Publishers, then flatten the emissions from those by merging them into a single Flux, in order.
static <T> Flux<T>	from(Publisher<? extends T> source) Expose the specified Publisher with the Flux API.
static <T> Flux<T>	fromArray(T[] array) Create a Flux that emits the items contained in the provided Iterable.
static <T> Flux<T>	fromIterable(Iterable<? extends T> it) Create a Flux that emits the items contained in the provided Iterable.
static <T> Flux<T>	fromStream(Stream<? extends T> s) Create a Flux that emits the items contained in the provided Stream.
static <T,S> Flux<T>	generate(Callable<S> stateSupplier, BiFunction<S,SynchronousSink<T>,S> generator) Generate signals one-by-one via a function callback.
static <T,S> Flux<T>	generate(Callable<S> stateSupplier, BiFunction<S,SynchronousSink<T>,S> generator, Consumer<? super S> stateConsumer) Generate signals one-by-one via a function callback.
static <T> Flux<T>	generate(Consumer<SynchronousSink<T>> generator) Generate signals one-by-one via a consumer callback.
long	getPrefetch() The prefetch configuration of the Flux
<K> Flux<GroupedFlux<K,T>>	groupBy(Function<? super T,? extends K> keyMapper) Re-route this sequence into dynamically created Flux for each unique key evaluated by the given key mapper.
<K,V> Flux<GroupedFlux<K,V>>	groupBy(Function<? super T,? extends K> keyMapper, Function<? super T,? extends V> valueMapper) Re-route this sequence into dynamically created Flux for each unique key evaluated by the given key mapper.
<K,V> Flux<GroupedFlux<K,V>>	groupBy(Function<? super T,? extends K> keyMapper, Function<? super T,? extends V> valueMapper, int prefetch) Re-route this sequence into dynamically created Flux for each unique key evaluated by the given key mapper.
<K> Flux<GroupedFlux<K,T>>	groupBy(Function<? super T,? extends K> keyMapper, int prefetch) Re-route this sequence into dynamically created Flux for each unique key evaluated by the given key mapper.
<TRight,TLeftEnd,TRightEnd,R> Flux<R>	groupJoin(Publisher<? extends TRight> other, Function<? super T,? extends Publisher<TLeftEnd>> leftEnd, Function<? super TRight,? extends Publisher<TRightEnd>> rightEnd, BiFunction<? super T,? super Flux<TRight>,? extends R> resultSelector) Returns a Flux that correlates two Publishers when they overlap in time and groups the results.
<R> Flux<R>	handle(BiConsumer<? super T,SynchronousSink<R>> handler) Handle the items emitted by this Flux by calling a biconsumer with the output sink for each onNext.
Mono<Boolean>	hasElement(T value) Emit a single boolean true if any of the values of this Flux sequence match the constant.
Mono<Boolean>	hasElements() Emit a single boolean true if this Flux sequence has at least one element.
Flux<T>	hide() Hides the identities of this Flux and its Subscription as well.
Mono<T>	ignoreElements() Ignores onNext signals (dropping them) and only reacts on termination.
static Flux<Long>	interval(Duration period) Create a new Flux that emits an ever incrementing long starting with 0 every period on the global timer.
static Flux<Long>	interval(Duration delay, Duration period) Create a new Flux that emits an ever incrementing long starting with 0 every N period of time unit on a global timer.
static Flux<Long>	intervalMillis(long period) Create a new Flux that emits an ever incrementing long starting with 0 every N milliseconds on the given timer.
static Flux<Long>	intervalMillis(long delay, long period) Create a new Flux that emits an ever incrementing long starting with 0 every N period of time unit on a global timer.
static Flux<Long>	intervalMillis(long delay, long period, TimedScheduler timer) Create a new Flux that emits an ever incrementing long starting with 0 every N period of time unit on the given timer.
static Flux<Long>	intervalMillis(long period, TimedScheduler timer) Create a new Flux that emits an ever incrementing long starting with 0 every N milliseconds on the given timer.
<TRight,TLeftEnd,TRightEnd,R> Flux<R>	join(Publisher<? extends TRight> other, Function<? super T,? extends Publisher<TLeftEnd>> leftEnd, Function<? super TRight,? extends Publisher<TRightEnd>> rightEnd, BiFunction<? super T,? super TRight,? extends R> resultSelector) Returns a Flux that correlates two Publishers when they overlap in time and groups the results.
static <T> Flux<T>	just(T... data) Create a new Flux that emits the specified items and then complete.
static <T> Flux<T>	just(T data) Create a new Flux that will only emit the passed data then onComplete.
Mono<T>	last() Signal the last element observed before complete signal or emit NoSuchElementException error if the source was empty.
Mono<T>	last(T defaultValue) Signal the last element observed before complete signal or emit the defaultValue if empty.
Flux<T>	limitRate(int prefetchRate) Ensure that backpressure signals from downstream subscribers are capped at the provided prefetchRate when propagated upstream, effectively rate limiting the upstream Publisher.
Flux<T>	log() Observe all Reactive Streams signals and use Logger support to handle trace implementation.
Flux<T>	log(String category) Observe all Reactive Streams signals and use Logger support to handle trace implementation.
Flux<T>	log(String category, Level level, boolean showOperatorLine, SignalType... options) Observe Reactive Streams signals matching the passed filter options and use Logger support to handle trace implementation.
Flux<T>	log(String category, Level level, SignalType... options) Observe Reactive Streams signals matching the passed filter options and use Logger support to handle trace implementation.
<V> Flux<V>	map(Function<? super T,? extends V> mapper) Transform the items emitted by this Flux by applying a function to each item.
<E extends Throwable> Flux<T>	mapError(Class<E> type, Function<? super E,? extends Throwable> mapper) Transform the error emitted by this Flux by applying a function if the error matches the given type, otherwise let the error flow.
Flux<T>	mapError(Function<? super Throwable,? extends Throwable> mapper) Transform the error emitted by this Flux by applying a function.
Flux<T>	mapError(Predicate<? super Throwable> predicate, Function<? super Throwable,? extends Throwable> mapper) Transform the error emitted by this Flux by applying a function if the error matches the given predicate, otherwise let the error flow.
Flux<Signal<T>>	materialize() Transform the incoming onNext, onError and onComplete signals into Signal.
static <I> Flux<I>	merge(int prefetch, boolean delayError, Publisher<? extends I>... sources) Merge emitted Publisher sequences from the passed Publisher array into an interleaved merged sequence.
static <I> Flux<I>	merge(int prefetch, Publisher<? extends I>... sources) Merge emitted Publisher sequences from the passed Publisher array into an interleaved merged sequence.
static <I> Flux<I>	merge(Iterable<? extends Publisher<? extends I>> sources) Merge emitted Publisher sequences from the passed Iterable into an interleaved merged sequence.
static <I> Flux<I>	merge(Publisher<? extends I>... sources) Merge emitted Publisher sequences from the passed Publisher array into an interleaved merged sequence.
static <T> Flux<T>	merge(Publisher<? extends Publisher<? extends T>> source) Merge emitted Publisher sequences by the passed Publisher into an interleaved merged sequence.
static <T> Flux<T>	merge(Publisher<? extends Publisher<? extends T>> source, int concurrency) Merge emitted Publisher sequences by the passed Publisher into an interleaved merged sequence.
static <T> Flux<T>	merge(Publisher<? extends Publisher<? extends T>> source, int concurrency, int prefetch) Merge emitted Publisher sequences by the passed Publisher into an interleaved merged sequence.
static <I> Flux<I>	mergeSequential(int prefetch, boolean delayError, Publisher<? extends I>... sources) Merge a number of Publisher sequences into an ordered merged sequence.
static <I> Flux<I>	mergeSequential(Iterable<? extends Publisher<? extends I>> sources) Merge Publisher sequences from an Iterable into an ordered merged sequence.
static <I> Flux<I>	mergeSequential(Iterable<? extends Publisher<? extends I>> sources, boolean delayError, int maxConcurrency, int prefetch) Merge Publisher sequences from an Iterable into an ordered merged sequence.
static <I> Flux<I>	mergeSequential(Publisher<? extends I>... sources) Merge a number of Publisher sequences into an ordered merged sequence.
static <T> Flux<T>	mergeSequential(Publisher<? extends Publisher<? extends T>> sources) Merge emitted Publisher sequences by the passed Publisher into an ordered merged sequence.
static <T> Flux<T>	mergeSequential(Publisher<? extends Publisher<? extends T>> sources, boolean delayError, int maxConcurrency, int prefetch) Merge emitted Publisher sequences by the passed Publisher into an ordered merged sequence.
Flux<T>	mergeWith(Publisher<? extends T> other) Merge emissions of this Flux with the provided Publisher, so that they may interleave.
static <T> Flux<T>	never() Create a Flux that will never signal any data, error or completion signal.
Mono<T>	next() Emit only the first item emitted by this Flux.
<U> Flux<U>	ofType(Class<U> clazz) Evaluate each accepted value against the given Class type.
protected static <T> ConnectableFlux<T>	onAssembly(ConnectableFlux<T> source) Invoke Hooks pointcut given a ConnectableFlux and returning an eventually new ConnectableFlux
protected static <T> Flux<T>	onAssembly(Flux<T> source) Invoke Hooks pointcut given a Flux and returning an eventually new Flux
Flux<T>	onBackpressureBuffer() Request an unbounded demand and push the returned Flux, or park the observed elements if not enough demand is requested downstream.
Flux<T>	onBackpressureBuffer(int maxSize) Request an unbounded demand and push the returned Flux, or park the observed elements if not enough demand is requested downstream.
Flux<T>	onBackpressureBuffer(int maxSize, BufferOverflowStrategy bufferOverflowStrategy) 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.
Flux<T>	onBackpressureBuffer(int maxSize, Consumer<? super T> onOverflow) Request an unbounded demand and push the returned Flux, or park the observed elements if not enough demand is requested downstream.
Flux<T>	onBackpressureBuffer(int maxSize, Consumer<? super T> onBufferOverflow, BufferOverflowStrategy bufferOverflowStrategy) 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.
Flux<T>	onBackpressureDrop() Request an unbounded demand and push the returned Flux, or drop the observed elements if not enough demand is requested downstream.
Flux<T>	onBackpressureDrop(Consumer<? super T> onDropped) 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.
Flux<T>	onBackpressureError() Request an unbounded demand and push the returned Flux, or emit onError fom Exceptions.failWithOverflow() if not enough demand is requested downstream.
Flux<T>	onBackpressureLatest() Request an unbounded demand and push the returned Flux, or only keep the most recent observed item if not enough demand is requested downstream.
<E extends Throwable> Flux<T>	onErrorResumeWith(Class<E> type, Function<? super E,? extends Publisher<? extends T>> fallback) Subscribe to a returned fallback publisher when an error matching the given type occurs.
Flux<T>	onErrorResumeWith(Function<? super Throwable,? extends Publisher<? extends T>> fallback) Subscribe to a returned fallback publisher when any error occurs.
Flux<T>	onErrorResumeWith(Predicate<? super Throwable> predicate, Function<? super Throwable,? extends Publisher<? extends T>> fallback) Subscribe to a returned fallback publisher when an error matching the given type occurs.
<E extends Throwable> Flux<T>	onErrorReturn(Class<E> type, T fallbackValue) Fallback to the given value if an error of a given type is observed on this Flux
<E extends Throwable> Flux<T>	onErrorReturn(Predicate<? super Throwable> predicate, T fallbackValue) Fallback to the given value if an error matching the given predicate is observed on this Flux
Flux<T>	onErrorReturn(T fallbackValue) Fallback to the given value if an error is observed on this Flux
Flux<T>	onTerminateDetach() Detaches the both the child Subscriber and the Subscription on termination or cancellation.
ParallelFlux<T>	parallel() Prepare to consume this Flux on number of 'rails' matching number of CPU in round-robin fashion.
ParallelFlux<T>	parallel(int parallelism) Prepare to consume this Flux on parallelism number of 'rails' in round-robin fashion.
ParallelFlux<T>	parallel(int parallelism, int prefetch) 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.
ConnectableFlux<T>	publish() Prepare a ConnectableFlux which shares this Flux sequence and dispatches values to subscribers in a backpressure-aware manner.
<R> Flux<R>	publish(Function<? super Flux<T>,? extends Publisher<? extends R>> transform) 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.
<R> Flux<R>	publish(Function<? super Flux<T>,? extends Publisher<? extends R>> transform, int prefetch) 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.
ConnectableFlux<T>	publish(int prefetch) Prepare a ConnectableFlux which shares this Flux sequence and dispatches values to subscribers in a backpressure-aware manner.
Mono<T>	publishNext() Prepare a Mono which shares this Flux sequence and dispatches the first observed item to subscribers in a backpressure-aware manner.
Flux<T>	publishOn(Scheduler scheduler) Run onNext, onComplete and onError on a supplied Scheduler Scheduler.Worker.
Flux<T>	publishOn(Scheduler scheduler, boolean delayError, int prefetch) Run onNext, onComplete and onError on a supplied Scheduler Scheduler.Worker.
Flux<T>	publishOn(Scheduler scheduler, int prefetch) Run onNext, onComplete and onError on a supplied Scheduler Scheduler.Worker.
static Flux<Integer>	range(int start, int count) Build a Flux that will only emit a sequence of incrementing integer from start to start + count then complete.
<A> Mono<A>	reduce(A initial, BiFunction<A,? super T,A> accumulator) Accumulate the values from this Flux sequence into an object matching an initial value type.
Mono<T>	reduce(BiFunction<T,T,T> aggregator) Aggregate the values from this Flux sequence into an object of the same type than the emitted items.
<A> Mono<A>	reduceWith(Supplier<A> initial, BiFunction<A,? super T,A> accumulator) Accumulate the values from this Flux sequence into an object matching an initial value type.
Flux<T>	repeat() Repeatedly subscribe to the source completion of the previous subscription.
Flux<T>	repeat(BooleanSupplier predicate) Repeatedly subscribe to the source if the predicate returns true after completion of the previous subscription.
Flux<T>	repeat(long numRepeat) Repeatedly subscribe to the source if the predicate returns true after completion of the previous subscription.
Flux<T>	repeat(long numRepeat, BooleanSupplier predicate) Repeatedly subscribe to the source if the predicate returns true after completion of the previous subscription.
Flux<T>	repeatWhen(Function<Flux<Long>,? extends Publisher<?>> whenFactory) Repeatedly subscribe to this Flux when a companion sequence signals a number of emitted elements in response to the flux completion signal.
ConnectableFlux<T>	replay() Turn this Flux into a hot source and cache last emitted signals for further Subscriber.
ConnectableFlux<T>	replay(Duration ttl) Turn this Flux into a connectable hot source and cache last emitted signals for further Subscriber.
ConnectableFlux<T>	replay(int history) Turn this Flux into a connectable hot source and cache last emitted signals for further Subscriber.
ConnectableFlux<T>	replay(int history, Duration ttl) Turn this Flux into a connectable hot source and cache last emitted signals for further Subscriber.
ConnectableFlux<T>	replayMillis(int history, long ttl, TimedScheduler timer) Turn this Flux into a connectable hot source and cache last emitted signals for further Subscriber.
ConnectableFlux<T>	replayMillis(long ttl, TimedScheduler timer) Turn this Flux into a connectable hot source and cache last emitted signals for further Subscriber.
Flux<T>	retry() Re-subscribes to this Flux sequence if it signals any error either indefinitely.
Flux<T>	retry(long numRetries) Re-subscribes to this Flux sequence if it signals any error either indefinitely or a fixed number of times.
Flux<T>	retry(long numRetries, Predicate<Throwable> retryMatcher) 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.
Flux<T>	retry(Predicate<Throwable> retryMatcher) Re-subscribes to this Flux sequence if it signals any error and the given Predicate matches otherwise push the error downstream.
Flux<T>	retryWhen(Function<Flux<Throwable>,? extends Publisher<?>> whenFactory) Retries this Flux when a companion sequence signals an item in response to this Flux error signal
Flux<T>	sample(Duration timespan) Emit latest value for every given period of time.
<U> Flux<T>	sample(Publisher<U> sampler) Sample this Flux and emit its latest value whenever the sampler Publisher signals a value.
Flux<T>	sampleFirst(Duration timespan) Take a value from this Flux then use the duration provided to skip other values.
<U> Flux<T>	sampleFirst(Function<? super T,? extends Publisher<U>> samplerFactory) Take a value from this Flux then use the duration provided by a generated Publisher to skip other values until that sampler Publisher signals.
Flux<T>	sampleFirstMillis(long timespan) Take a value from this Flux then use the duration provided to skip other values.
Flux<T>	sampleMillis(long timespan) Emit latest value for every given period of ti,e.
<U> Flux<T>	sampleTimeout(Function<? super T,? extends Publisher<U>> throttlerFactory) 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.
<U> Flux<T>	sampleTimeout(Function<? super T,? extends Publisher<U>> throttlerFactory, int maxConcurrency) 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.
<A> Flux<A>	scan(A initial, BiFunction<A,? super T,A> accumulator) Aggregate this Flux values with the help of an accumulator BiFunction and emits the intermediate results.
Flux<T>	scan(BiFunction<T,T,T> accumulator) Accumulate this Flux values with an accumulator BiFunction and returns the intermediate results of this function.
<A> Flux<A>	scanWith(Supplier<A> initial, BiFunction<A,? super T,A> accumulator) Aggregate this Flux values with the help of an accumulator BiFunction and emits the intermediate results.
Flux<T>	share() Returns a new Flux that multicasts (shares) the original Flux.
Mono<T>	single() 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.
Mono<T>	single(T defaultValue) 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.
Mono<T>	singleOrEmpty() Expect and emit a zero or single item from this Flux source or IndexOutOfBoundsException for a multi-item source.
Flux<T>	skip(Duration timespan) Skip elements from this Flux for the given time period.
Flux<T>	skip(long skipped) Skip next the specified number of elements from this Flux.
Flux<T>	skipLast(int n) Skip the last specified number of elements from this Flux.
Flux<T>	skipMillis(long timespan) Skip elements from this Flux for the given time period.
Flux<T>	skipMillis(long timespan, TimedScheduler timer) Skip elements from this Flux for the given time period.
Flux<T>	skipUntil(Predicate<? super T> untilPredicate) Skips values from this Flux until a Predicate returns true for the value.
Flux<T>	skipUntilOther(Publisher<?> other) Skip values from this Flux until a specified Publisher signals an onNext or onComplete.
Flux<T>	skipWhile(Predicate<? super T> skipPredicate) Skips values from this Flux while a Predicate returns true for the value.
Flux<T>	sort() Returns a Flux that sorts the events emitted by source Flux.
Flux<T>	sort(Comparator<? super T> sortFunction) Returns a Flux that sorts the events emitted by source Flux given the Comparator function.
Flux<T>	startWith(Iterable<? extends T> iterable) Prepend the given Iterable before this Flux sequence.
Flux<T>	startWith(Publisher<? extends T> publisher) Prepend the given Publisher sequence before this Flux sequence.
Flux<T>	startWith(T... values) Prepend the given values before this Flux sequence.
Disposable	subscribe() Start the chain and request unbounded demand.
Disposable	subscribe(Consumer<? super T> consumer) Subscribe a Consumer to this Flux that will consume all the sequence.
Disposable	subscribe(Consumer<? super T> consumer, Consumer<? super Throwable> errorConsumer) Subscribe Consumer to this Flux that will consume all the sequence.
Disposable	subscribe(Consumer<? super T> consumer, Consumer<? super Throwable> errorConsumer, Runnable completeConsumer) Subscribe Consumer to this Flux that will consume all the sequence.
Disposable	subscribe(Consumer<? super T> consumer, Consumer<? super Throwable> errorConsumer, Runnable completeConsumer, Consumer<? super Subscription> subscriptionConsumer) Subscribe Consumer to this Flux that will consume all the sequence.
Disposable	subscribe(Consumer<? super T> consumer, Consumer<? super Throwable> errorConsumer, Runnable completeConsumer, Consumer<? super Subscription> subscriptionConsumer, int prefetch) Deprecated. prefer using limitRate(prefetch).subscribe(...) to subscribe(..., prefetch)
Disposable	subscribe(Consumer<? super T> consumer, Consumer<? super Throwable> errorConsumer, Runnable completeConsumer, int prefetch) Deprecated. prefer using limitRate(prefetch).subscribe(...) to subscribe(..., prefetch)
Disposable	subscribe(Consumer<? super T> consumer, int prefetch) Subscribe a Consumer to this Flux that will consume all the sequence.
Disposable	subscribe(int prefetch) Deprecated. use limitRate(int)
Flux<T>	subscribeOn(Scheduler scheduler) Run subscribe, onSubscribe and request on a supplied Scheduler
<E extends Subscriber<? super T>> E	subscribeWith(E subscriber) A chaining Publisher.subscribe(Subscriber) alternative to inline composition type conversion to a hot emitter (e.g.
Flux<T>	switchIfEmpty(Publisher<? extends T> alternate) Provide an alternative if this sequence is completed without any data
<V> Flux<V>	switchMap(Function<? super T,Publisher<? extends V>> fn) Switch to a new Publisher generated via a Function whenever this Flux produces an item.
<V> Flux<V>	switchMap(Function<? super T,Publisher<? extends V>> fn, int prefetch) Switch to a new Publisher generated via a Function whenever this Flux produces an item.
<E extends Throwable> Flux<T>	switchOnError(Class<E> type, Publisher<? extends T> fallback) Subscribe to the given fallback Publisher if an error matching the given type is observed on this Flux
Flux<T>	switchOnError(Predicate<? super Throwable> predicate, Publisher<? extends T> fallback) Subscribe to the given fallback Publisher if an error matching the given predicate is observed on this Flux
Flux<T>	switchOnError(Publisher<? extends T> fallback) Subscribe to the given fallback Publisher if an error is observed on this Flux
static <T> Flux<T>	switchOnNext(Publisher<? extends Publisher<? extends T>> mergedPublishers) Build a FluxProcessor whose data are emitted by the most recent emitted Publisher.
static <T> Flux<T>	switchOnNext(Publisher<? extends Publisher<? extends T>> mergedPublishers, int prefetch) Build a FluxProcessor whose data are emitted by the most recent emitted Publisher.
Flux<T>	take(Duration timespan) Relay values from this Flux until the given time period elapses.
Flux<T>	take(long n) Take only the first N values from this Flux.
Flux<T>	takeLast(int n) Emit the last N values this Flux emitted before its completion.
Flux<T>	takeMillis(long timespan) Relay values from this Flux until the given time period elapses.
Flux<T>	takeMillis(long timespan, TimedScheduler timer) Relay values from this Flux until the given time period elapses.
Flux<T>	takeUntil(Predicate<? super T> predicate) Relay values from this Flux until the given Predicate matches.
Flux<T>	takeUntilOther(Publisher<?> other) Relay values from this Flux until the given Publisher emits.
Flux<T>	takeWhile(Predicate<? super T> continuePredicate) Relay values while a predicate returns TRUE for the values (checked before each value is delivered).
Mono<Void>	then() Return a Mono<Void> that completes when this Flux completes.
Mono<Void>	then(Publisher<Void> other) Deprecated. use thenEmpty(Publisher) instead, this alias will be removed in 3.1.0
Mono<Void>	then(Supplier<? extends Publisher<Void>> afterSupplier) Return a Flux that emits the completion signal of the supplied Publisher when this Flux onComplete or onError.
Mono<Void>	thenEmpty(Publisher<Void> other) Return a Mono<Void> that waits for this Flux to complete then for a supplied Publisher<Void> to also complete.
<V> Flux<V>	thenMany(Publisher<V> other) Return a Flux that emits the sequence of the supplied Publisher after this Flux completes, ignoring this flux elements.
<V> Flux<V>	thenMany(Supplier<? extends Publisher<V>> afterSupplier) Return a Flux that emits the sequence of the supplied Publisher after this Flux completes, ignoring this flux elements.
Flux<T>	timeout(Duration timeout) Signal a TimeoutException in case a per-item period fires before the next item arrives from this Flux.
Flux<T>	timeout(Duration timeout, Publisher<? extends T> fallback) Switch to a fallback Publisher in case a per-item period fires before the next item arrives from this Flux.
<U> Flux<T>	timeout(Publisher<U> firstTimeout) Signal a TimeoutException in case a first item from this Flux has not been emitted before the given Publisher emits.
<U,V> Flux<T>	timeout(Publisher<U> firstTimeout, Function<? super T,? extends Publisher<V>> nextTimeoutFactory) Signal a TimeoutException in case a first item from this Flux has not been emitted before the given Publisher emits.
<U,V> Flux<T>	timeout(Publisher<U> firstTimeout, Function<? super T,? extends Publisher<V>> nextTimeoutFactory, Publisher<? extends T> fallback) Switch to a fallback Publisher in case a first item from this Flux has not been emitted before the given Publisher emits.
Flux<T>	timeoutMillis(long timeout) Signal a TimeoutException error in case a per-item period in milliseconds fires before the next item arrives from this Flux.
Flux<T>	timeoutMillis(long timeout, Publisher<? extends T> fallback) Switch to a fallback Publisher in case a per-item period fires before the next item arrives from this Flux.
Flux<T>	timeoutMillis(long timeout, Publisher<? extends T> fallback, TimedScheduler timer) Switch to a fallback Publisher in case a per-item period fires before the next item arrives from this Flux.
Flux<T>	timeoutMillis(long timeout, TimedScheduler timer) Signal a TimeoutException error in case a per-item period in milliseconds fires before the next item arrives from this Flux.
Flux<Tuple2<Long,T>>	timestamp() Emit a Tuple2 pair of T1 Long current system time in millis and T2 T associated data for each item from this Flux
Flux<Tuple2<Long,T>>	timestamp(TimedScheduler scheduler) Emit a Tuple2 pair of T1 Long current system time in millis and T2 T associated data for each item from this Flux
Iterable<T>	toIterable() Transform this Flux into a lazy Iterable blocking on next calls.
Iterable<T>	toIterable(long batchSize) Transform this Flux into a lazy Iterable blocking on next calls.
Iterable<T>	toIterable(long batchSize, Supplier<Queue<T>> queueProvider) Transform this Flux into a lazy Iterable blocking on next calls.
Stream<T>	toStream() Transform this Flux into a lazy Stream blocking on next calls.
Stream<T>	toStream(int batchSize) Transform this Flux into a lazy Stream blocking on next calls.
String	toString()
<V> Flux<V>	transform(Function<? super Flux<T>,? extends Publisher<V>> transformer) Transform this Flux in order to generate a target Flux.
static <T,D> Flux<T>	using(Callable<? extends D> resourceSupplier, Function<? super D,? extends Publisher<? extends T>> sourceSupplier, Consumer<? super D> resourceCleanup) 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.
static <T,D> Flux<T>	using(Callable<? extends D> resourceSupplier, Function<? super D,? extends Publisher<? extends T>> sourceSupplier, Consumer<? super D> resourceCleanup, boolean eager) 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.
Flux<Flux<T>>	window() Deprecated. will be removed in 3.1.0. Prefer using other variants, like window(Publisher),
Flux<Flux<T>>	window(Duration timespan) Split this Flux sequence into continuous, non-overlapping windows delimited by a given period.
Flux<Flux<T>>	window(Duration timespan, Duration timeshift) Split this Flux sequence into multiple Flux delimited by the given timeshift period, starting from the first item.
Flux<Flux<T>>	window(int maxSize) Split this Flux sequence into multiple Flux delimited by the given maxSize count and starting from the first item.
Flux<Flux<T>>	window(int maxSize, Duration timespan) Deprecated. use windowTimeout(int, Duration) instead, will be removed in 3.1.0
Flux<Flux<T>>	window(int maxSize, int skip) Split this Flux sequence into multiple Flux delimited by the given skip count, starting from the first item.
Flux<Flux<T>>	window(Publisher<?> boundary) Split this Flux sequence into continuous, non-overlapping windows where the window boundary is signalled by another Publisher
<U,V> Flux<Flux<T>>	window(Publisher<U> bucketOpening, Function<? super U,? extends Publisher<V>> closeSelector) Split this Flux sequence into potentially overlapping windows controlled by items of a start Publisher and end Publisher derived from the start values.
Flux<Flux<T>>	windowMillis(int maxSize, long timespan) Deprecated. use windowTimeoutMillis(int, long) instead, will be removed in 3.1.0
Flux<Flux<T>>	windowMillis(int maxSize, long timespan, TimedScheduler timer) Deprecated. use windowTimeoutMillis(int, long, TimedScheduler) instead, will be removed in 3.1.0
Flux<Flux<T>>	windowMillis(long timespan) Split this Flux sequence into continuous, non-overlapping windows delimited by a given period.
Flux<Flux<T>>	windowMillis(long timespan, long timeshift, TimedScheduler timer) Split this Flux sequence into multiple Flux delimited by the given timeshift period, starting from the first item.
Flux<Flux<T>>	windowMillis(long timespan, TimedScheduler timer) Split this Flux sequence into continuous, non-overlapping windows delimited by a given period.
Flux<Flux<T>>	windowTimeout(int maxSize, Duration timespan) Split this Flux sequence into multiple Flux delimited by the given maxSize number of items, starting from the first item.
Flux<Flux<T>>	windowTimeoutMillis(int maxSize, long timespan) Split this Flux sequence into multiple Flux delimited by the given maxSize number of items, starting from the first item.
Flux<Flux<T>>	windowTimeoutMillis(int maxSize, long timespan, TimedScheduler timer) Split this Flux sequence into multiple Flux delimited by the given maxSize number of items, starting from the first item.
Flux<GroupedFlux<T,T>>	windowUntil(Predicate<T> boundaryTrigger) Split this Flux sequence into multiple Flux delimited by the given predicate.
Flux<GroupedFlux<T,T>>	windowUntil(Predicate<T> boundaryTrigger, boolean cutBefore) Split this Flux sequence into multiple Flux delimited by the given predicate.
Flux<GroupedFlux<T,T>>	windowUntil(Predicate<T> boundaryTrigger, boolean cutBefore, int prefetch) Split this Flux sequence into multiple Flux delimited by the given predicate and using a prefetch.
Flux<GroupedFlux<T,T>>	windowWhile(Predicate<T> inclusionPredicate) Split this Flux sequence into multiple Flux windows that stay open while a given predicate matches the source elements.
Flux<GroupedFlux<T,T>>	windowWhile(Predicate<T> inclusionPredicate, int prefetch) Split this Flux sequence into multiple Flux windows that stay open while a given predicate matches the source elements.
<U,R> Flux<R>	withLatestFrom(Publisher<? extends U> other, BiFunction<? super T,? super U,? extends R> resultSelector) Combine values from this Flux with values from another Publisher through a BiFunction and emits the result.
static <I,O> Flux<O>	zip(Function<? super Object[],? extends O> combinator, int prefetch, Publisher<? extends I>... sources) "Step-Merge" especially useful in Scatter-Gather scenarios.
static <I,O> Flux<O>	zip(Function<? super Object[],? extends O> combinator, Publisher<? extends I>... sources) "Step-Merge" especially useful in Scatter-Gather scenarios.
static Flux<Tuple2>	zip(Iterable<? extends Publisher<?>> sources) Deprecated. prefer using zip(Iterable, Function), will be removed in 3.1.0
static <O> Flux<O>	zip(Iterable<? extends Publisher<?>> sources, Function<? super Object[],? extends O> combinator) "Step-Merge" especially useful in Scatter-Gather scenarios.
static <O> Flux<O>	zip(Iterable<? extends Publisher<?>> sources, int prefetch, Function<? super Object[],? extends O> combinator) "Step-Merge" especially useful in Scatter-Gather scenarios.
static <TUPLE extends Tuple2,V> Flux<V>	zip(Publisher<? extends Publisher<?>> sources, Function<? super TUPLE,? extends V> combinator) "Step-Merge" especially useful in Scatter-Gather scenarios.
static <T1,T2> Flux<Tuple2<T1,T2>>	zip(Publisher<? extends T1> source1, Publisher<? extends T2> source2) "Step-Merge" especially useful in Scatter-Gather scenarios.
static <T1,T2,O> Flux<O>	zip(Publisher<? extends T1> source1, Publisher<? extends T2> source2, BiFunction<? super T1,? super T2,? extends O> combinator) "Step-Merge" especially useful in Scatter-Gather scenarios.
static <T1,T2,T3> Flux<Tuple3<T1,T2,T3>>	zip(Publisher<? extends T1> source1, Publisher<? extends T2> source2, Publisher<? extends T3> source3) "Step-Merge" especially useful in Scatter-Gather scenarios.
static <T1,T2,T3,T4> Flux<Tuple4<T1,T2,T3,T4>>	zip(Publisher<? extends T1> source1, Publisher<? extends T2> source2, Publisher<? extends T3> source3, Publisher<? extends T4> source4) "Step-Merge" especially useful in Scatter-Gather scenarios.
static <T1,T2,T3,T4,T5> Flux<Tuple5<T1,T2,T3,T4,T5>>	zip(Publisher<? extends T1> source1, Publisher<? extends T2> source2, Publisher<? extends T3> source3, Publisher<? extends T4> source4, Publisher<? extends T5> source5) "Step-Merge" especially useful in Scatter-Gather scenarios.
static <T1,T2,T3,T4,T5,T6> Flux<Tuple6<T1,T2,T3,T4,T5,T6>>	zip(Publisher<? extends T1> source1, Publisher<? extends T2> source2, Publisher<? extends T3> source3, Publisher<? extends T4> source4, Publisher<? extends T5> source5, Publisher<? extends T6> source6) "Step-Merge" especially useful in Scatter-Gather scenarios.
<T2> Flux<Tuple2<T,T2>>	zipWith(Publisher<? extends T2> source2) "Step-Merge" especially useful in Scatter-Gather scenarios.
<T2,V> Flux<V>	zipWith(Publisher<? extends T2> source2, BiFunction<? super T,? super T2,? extends V> combinator) "Step-Merge" especially useful in Scatter-Gather scenarios.
<T2> Flux<Tuple2<T,T2>>	zipWith(Publisher<? extends T2> source2, int prefetch) "Step-Merge" especially useful in Scatter-Gather scenarios.
<T2,V> Flux<V>	zipWith(Publisher<? extends T2> source2, int prefetch, BiFunction<? super T,? super T2,? extends V> combinator) "Step-Merge" especially useful in Scatter-Gather scenarios.
<T2> Flux<Tuple2<T,T2>>	zipWithIterable(Iterable<? extends T2> iterable) Pairwise combines as Tuple2 elements of this Flux and an Iterable sequence.
<T2,V> Flux<V>	zipWithIterable(Iterable<? extends T2> iterable, BiFunction<? super T,? super T2,? extends V> zipper) Pairwise combines elements of this Flux and an Iterable sequence using the given zipper BiFunction.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Methods inherited from interface org.reactivestreams.Publisher

subscribe

Constructor Detail

Flux

public Flux()

Method Detail

combineLatest

@SafeVarargs
public static <T,V> Flux<V> combineLatest(Function<Object[],V> combinator,
                                                       Publisher<? extends T>... sources)

Build a Flux whose data are generated by the combination of the most recent published values from all publishers.

Type Parameters:

T - type of the value from sources

V - The produced output after transformation by the given combinator

Parameters:

sources - The upstreams Publisher to subscribe to.

combinator - The aggregate function that will receive a unique value from each upstream and return the value to signal downstream

Returns:

a Flux based on the produced combinations , 3.0

combineLatest

@SafeVarargs
public static <T,V> Flux<V> combineLatest(Function<Object[],V> combinator,
                                                       int prefetch,
                                                       Publisher<? extends T>... sources)

Build a Flux whose data are generated by the combination of the most recent published values from all publishers.

Type Parameters:

T - type of the value from sources

V - The produced output after transformation by the given combinator

Parameters:

sources - The upstreams Publisher to subscribe to.

prefetch - demand produced to each combined source Publisher

combinator - The aggregate function that will receive a unique value from each upstream and return the value to signal downstream

Returns:

a Flux based on the produced combinations , 3.0

combineLatest

public static <T1,T2,V> Flux<V> combineLatest(Publisher<? extends T1> source1,
                                              Publisher<? extends T2> source2,
                                              BiFunction<? super T1,? super T2,? extends V> combinator)

Build a Flux whose data are generated by the combination of the most recent published values from all publishers.

Type Parameters:

T1 - type of the value from source1

T2 - type of the value from source2

V - The produced output after transformation by the given combinator

Parameters:

source1 - The first upstream Publisher to subscribe to.

source2 - The second upstream Publisher to subscribe to.

combinator - The aggregate function that will receive a unique value from each upstream and return the value to signal downstream

Returns:

a Flux based on the produced value

combineLatest

public static <T1,T2,T3,V> Flux<V> combineLatest(Publisher<? extends T1> source1,
                                                 Publisher<? extends T2> source2,
                                                 Publisher<? extends T3> source3,
                                                 Function<Object[],V> combinator)

Build a Flux whose data are generated by the combination of the most recent published values from all publishers.

Type Parameters:

T1 - type of the value from source1

T2 - type of the value from source2

T3 - type of the value from source3

V - The produced output after transformation by the given combinator

Parameters:

source1 - The first upstream Publisher to subscribe to.

source2 - The second upstream Publisher to subscribe to.

source3 - The third upstream Publisher to subscribe to.

combinator - The aggregate function that will receive a unique value from each upstream and return the value to signal downstream

Returns:

a Flux based on the produced value

combineLatest

public static <T1,T2,T3,T4,V> Flux<V> combineLatest(Publisher<? extends T1> source1,
                                                    Publisher<? extends T2> source2,
                                                    Publisher<? extends T3> source3,
                                                    Publisher<? extends T4> source4,
                                                    Function<Object[],V> combinator)

Build a Flux whose data are generated by the combination of the most recent published values from all publishers.

Type Parameters:

T1 - type of the value from source1

T2 - type of the value from source2

T3 - type of the value from source3

T4 - type of the value from source4

V - The produced output after transformation by the given combinator

Parameters:

source1 - The first upstream Publisher to subscribe to.

source2 - The second upstream Publisher to subscribe to.

source3 - The third upstream Publisher to subscribe to.

source4 - The fourth upstream Publisher to subscribe to.

combinator - The aggregate function that will receive a unique value from each upstream and return the value to signal downstream

Returns:

a Flux based on the produced value

combineLatest

public static <T1,T2,T3,T4,T5,V> Flux<V> combineLatest(Publisher<? extends T1> source1,
                                                       Publisher<? extends T2> source2,
                                                       Publisher<? extends T3> source3,
                                                       Publisher<? extends T4> source4,
                                                       Publisher<? extends T5> source5,
                                                       Function<Object[],V> combinator)

Build a Flux whose data are generated by the combination of the most recent published values from all publishers.

Type Parameters:

T1 - type of the value from source1

T2 - type of the value from source2

T3 - type of the value from source3

T4 - type of the value from source4

T5 - type of the value from source5

V - The produced output after transformation by the given combinator

Parameters:

source1 - The first upstream Publisher to subscribe to.

source2 - The second upstream Publisher to subscribe to.

source3 - The third upstream Publisher to subscribe to.

source4 - The fourth upstream Publisher to subscribe to.

source5 - The fifth upstream Publisher to subscribe to.

combinator - The aggregate function that will receive a unique value from each upstream and return the value to signal downstream

Returns:

a Flux based on the produced value

combineLatest

public static <T1,T2,T3,T4,T5,T6,V> Flux<V> combineLatest(Publisher<? extends T1> source1,
                                                          Publisher<? extends T2> source2,
                                                          Publisher<? extends T3> source3,
                                                          Publisher<? extends T4> source4,
                                                          Publisher<? extends T5> source5,
                                                          Publisher<? extends T6> source6,
                                                          Function<Object[],V> combinator)

Build a Flux whose data are generated by the combination of the most recent published values from all publishers.

Type Parameters:

T1 - type of the value from source1

T2 - type of the value from source2

T3 - type of the value from source3

T4 - type of the value from source4

T5 - type of the value from source5

T6 - type of the value from source6

V - The produced output after transformation by the given combinator

Parameters:

source1 - The first upstream Publisher to subscribe to.

source2 - The second upstream Publisher to subscribe to.

source3 - The third upstream Publisher to subscribe to.

source4 - The fourth upstream Publisher to subscribe to.

source5 - The fifth upstream Publisher to subscribe to.

source6 - The sixth upstream Publisher to subscribe to.

combinator - The aggregate function that will receive a unique value from each upstream and return the value to signal downstream

Returns:

a Flux based on the produced value

combineLatest

public static <T,V> Flux<V> combineLatest(Iterable<? extends Publisher<? extends T>> sources,
                                          Function<Object[],V> combinator)

Build a Flux whose data are generated by the combination of the most recent published values from all publishers.

Type Parameters:

T - The common base type of the source sequences

V - The produced output after transformation by the given combinator

Parameters:

sources - The list of upstream Publisher to subscribe to.

combinator - The aggregate function that will receive a unique value from each upstream and return the value to signal downstream

Returns:

a Flux based on the produced value , 3.0

combineLatest

public static <T,V> Flux<V> combineLatest(Iterable<? extends Publisher<? extends T>> sources,
                                          int prefetch,
                                          Function<Object[],V> combinator)

Build a Flux whose data are generated by the combination of the most recent published values from all publishers.

Type Parameters:

T - The common base type of the source sequences

V - The produced output after transformation by the given combinator

Parameters:

sources - The list of upstream Publisher to subscribe to.

prefetch - demand produced to each combined source Publisher

combinator - The aggregate function that will receive a unique value from each upstream and return the value to signal downstream

Returns:

a Flux based on the produced value , 3.0

concat

public static <T> Flux<T> concat(Iterable<? extends Publisher<? extends T>> sources)

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. A complete signal from each source will delimit the individual sequences and will be eventually passed to the returned Publisher.

Type Parameters:

T - The source type of the data sequence

Parameters:

sources - The Publisher of Publisher to concat

Returns:

a new Flux concatenating all source sequences

concat

public static <T> Flux<T> concat(Publisher<? extends Publisher<? extends T>> sources)

Concat all sources emitted as an onNext signal from a parent Publisher. A complete signal from each source will delimit the individual sequences and will be eventually passed to the returned Publisher which will stop listening if the main sequence has also completed.

Type Parameters:

T - The source type of the data sequence

Parameters:

sources - The Publisher of Publisher to concat

Returns:

a new Flux concatenating all inner sources sequences until complete or error

concat

public static <T> Flux<T> concat(Publisher<? extends Publisher<? extends T>> sources,
                                 int prefetch)

Concat all sources emitted as an onNext signal from a parent Publisher. A complete signal from each source will delimit the individual sequences and will be eventually passed to the returned Publisher which will stop listening if the main sequence has also completed.

Type Parameters:

T - The source type of the data sequence

Parameters:

sources - The Publisher of Publisher to concat

prefetch - the inner source request size

Returns:

a new Flux concatenating all inner sources sequences until complete or error

concat

@SafeVarargs
public static <T> Flux<T> concat(Publisher<? extends T>... sources)

Concat all sources pulled from the given Publisher array. A complete signal from each source will delimit the individual sequences and will be eventually passed to the returned Publisher.

Type Parameters:

T - The source type of the data sequence

Parameters:

sources - The Publisher of Publisher to concat

Returns:

a new Flux concatenating all source sequences

concatDelayError

public static <T> Flux<T> concatDelayError(Publisher<? extends Publisher<? extends T>> sources)

Concat all sources emitted as an onNext signal from a parent Publisher. A complete signal from each source will delimit the individual sequences and will be eventually passed to the returned Publisher which will stop listening if the main sequence has also completed.

Type Parameters:

T - The source type of the data sequence

Parameters:

sources - The Publisher of Publisher to concat

Returns:

a new Flux concatenating all inner sources sequences until complete or error

concatDelayError

public static <T> Flux<T> concatDelayError(Publisher<? extends Publisher<? extends T>> sources,
                                           int prefetch)

Concat all sources emitted as an onNext signal from a parent Publisher. A complete signal from each source will delimit the individual sequences and will be eventually passed to the returned Publisher which will stop listening if the main sequence has also completed.

Type Parameters:

T - The source type of the data sequence

Parameters:

sources - The Publisher of Publisher to concat

prefetch - the inner source request size

Returns:

a new Flux concatenating all inner sources sequences until complete or error

concatDelayError

public static <T> Flux<T> concatDelayError(Publisher<? extends Publisher<? extends T>> sources,
                                           boolean delayUntilEnd,
                                           int prefetch)

Concat all sources emitted as an onNext signal from a parent Publisher. A complete signal from each source will delimit the individual sequences and will be eventually passed to the returned Publisher which will stop listening if the main sequence has also completed. Errors will be delayed after the current concat backlog if delayUntilEnd is false or after all sources if delayUntilEnd is true.

Type Parameters:

T - The source type of the data sequence

Parameters:

sources - The Publisher of Publisher to concat

delayUntilEnd - delay error until all sources have been consumed instead of after the current source

prefetch - the inner source request size

Returns:

a new Flux concatenating all inner sources sequences until complete or error

concatDelayError

@SafeVarargs
public static <T> Flux<T> concatDelayError(Publisher<? extends T>... sources)

Concat all sources pulled from the given Publisher array. A complete signal from each source will delimit the individual sequences and will be eventually passed to the returned Publisher. Any error will be delayed until all sources have been concatenated.

Type Parameters:

T - The source type of the data sequence

Parameters:

sources - The Publisher of Publisher to concat

Returns:

a new Flux concatenating all source sequences

create

public static <T> Flux<T> create(Consumer<? super FluxSink<T>> emitter)

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

This Flux factory is useful if one wants to adapt some other a multi-valued async API and not worry about cancellation and backpressure. For example:

Handles backpressure by buffering all signals if the downstream can't keep up.

 Flux.<String>create(emitter -> {

     ActionListener al = e -> {
         emitter.next(textField.getText());
     };
     // without cancellation support:

     button.addActionListener(al);

     // with cancellation support:

     button.addActionListener(al);
     emitter.setCancellation(() -> {
         button.removeListener(al);
     });
 });
 

Type Parameters:

T - the value type

Parameters:

emitter - the consumer that will receive a FluxSink for each individual Subscriber.

Returns:

a Flux

create

public static <T> Flux<T> create(Consumer<? super FluxSink<T>> emitter,
                                 FluxSink.OverflowStrategy backpressure)

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

This Flux factory is useful if one wants to adapt some other a multi-valued async API and not worry about cancellation and backpressure. For example:

 Flux.<String>create(emitter -> {

     ActionListener al = e -> {
         emitter.next(textField.getText());
     };
     // without cancellation support:

     button.addActionListener(al);

     // with cancellation support:

     button.addActionListener(al);
     emitter.setCancellation(() -> {
         button.removeListener(al);
     });
 }, FluxSink.OverflowStrategy.LATEST);
 

Type Parameters:

T - the value type

Parameters:

backpressure - the backpressure mode, see FluxSink.OverflowStrategy for the available backpressure modes

emitter - the consumer that will receive a FluxSink for each individual Subscriber.

Returns:

a Flux

defer

public static <T> Flux<T> defer(Supplier<? extends Publisher<T>> supplier)

Supply a Publisher everytime subscribe is called on the returned flux. The passed Supplier will be invoked and it's up to the developer to choose to return a new instance of a Publisher or reuse one effectively behaving like from(Publisher).

Type Parameters:

T - the type of values passing through the Flux

Parameters:

supplier - the Publisher Supplier to call on subscribe

Returns:

a deferred Flux

empty

public static <T> Flux<T> empty()

Create a Flux that completes without emitting any item.

Type Parameters:

T - the reified type of the target Subscriber

Returns:

an empty Flux

error

public static <T> Flux<T> error(Throwable error)

Create a Flux that completes with the specified error.

Type Parameters:

T - the reified type of the target Subscriber

Parameters:

error - the error to signal to each Subscriber

Returns:

a new failed Flux

error

public static <O> Flux<O> error(Throwable throwable,
                                boolean whenRequested)

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

Type Parameters:

O - the output type

Parameters:

throwable - the error to signal to each Subscriber

whenRequested - if true, will onError on the first request instead of subscribe().

Returns:

a new failed Flux

firstEmitting

@SafeVarargs
public static <I> Flux<I> firstEmitting(Publisher<? extends I>... sources)

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

Type Parameters:

I - The source type of the data sequence

Parameters:

sources - The competing source publishers

Returns:

a new Flux eventually subscribed to one of the sources or empty

firstEmitting

public static <I> Flux<I> firstEmitting(Iterable<? extends Publisher<? extends I>> sources)

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

Type Parameters:

I - The source type of the data sequence

Parameters:

sources - The competing source publishers

Returns:

a new Flux eventually subscribed to one of the sources or empty

from

public static <T> Flux<T> from(Publisher<? extends T> source)

Expose the specified Publisher with the Flux API.

Type Parameters:

T - the source sequence type

Parameters:

source - the source to decorate

Returns:

a new Flux

fromArray

public static <T> Flux<T> fromArray(T[] array)

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

Type Parameters:

T - the Publisher type to stream

Parameters:

array - the array to read data from

Returns:

a new Flux

fromIterable

public static <T> Flux<T> fromIterable(Iterable<? extends T> it)

Create a Flux that emits the items contained in the provided Iterable. A new iterator will be created for each subscriber.

Type Parameters:

T - the Iterable type to stream

Parameters:

it - the Iterable to read data from

Returns:

a new Flux

fromStream

public static <T> Flux<T> fromStream(Stream<? extends T> s)

Create a Flux that emits the items contained in the provided Stream. A new iterator will be created for each subscriber.

Type Parameters:

T - the Stream type to flux

Parameters:

s - the Stream to read data from

Returns:

a new Flux

generate

public static <T> Flux<T> generate(Consumer<SynchronousSink<T>> generator)

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

Type Parameters:

T - the value type emitted

Parameters:

generator - the consumer called with the SynchronousSink API instance

Returns:

a Reactive Flux publisher ready to be subscribed

generate

public static <T,S> Flux<T> generate(Callable<S> stateSupplier,
                                     BiFunction<S,SynchronousSink<T>,S> generator)

Generate signals one-by-one via a function callback. The stateSupplier may return null.

Type Parameters:

T - the value type emitted

S - the custom state per subscriber

Parameters:

stateSupplier - called for each incoming Supplier to provide the initial state for the generator bifunction

generator - the bifunction called with the current state, the SynchronousSink API instance and is expected to return a (new) state.

Returns:

a Reactive Flux publisher ready to be subscribed

generate

public static <T,S> Flux<T> generate(Callable<S> stateSupplier,
                                     BiFunction<S,SynchronousSink<T>,S> generator,
                                     Consumer<? super S> stateConsumer)

Generate signals one-by-one via a function callback. The stateSupplier may return null but your stateConsumer should be prepared to handle it.

Type Parameters:

T - the value type emitted

S - the custom state per subscriber

Parameters:

stateSupplier - called for each incoming Supplier to provide the initial state for the generator bifunction

generator - the bifunction called with the current state, the SynchronousSink API instance and is expected to return a (new) state.

stateConsumer - called after the generator has terminated or the downstream cancelled, receiving the last state to be handled (i.e., release resources or do other cleanup).

Returns:

a Reactive Flux publisher ready to be subscribed

interval

public static Flux<Long> interval(Duration period)

Create a new Flux that emits an ever incrementing long starting with 0 every period on the global timer. If demand is not produced in time, an onError will be signalled. The Flux will never complete.

Parameters:

period - The duration to wait before the next increment

Returns:

a new timed Flux

interval

public static Flux<Long> interval(Duration delay,
                                  Duration period)

Create a new Flux that emits an ever incrementing long starting with 0 every N period of time unit on a global timer. If demand is not produced in time, an onError will be signalled. The Flux will never complete.

Parameters:

delay - the delay to wait before emitting 0l

period - the period before each following increment

Returns:

a new timed Flux

intervalMillis

public static Flux<Long> intervalMillis(long period)

Create a new Flux that emits an ever incrementing long starting with 0 every N milliseconds on the given timer. If demand is not produced in time, an onError will be signalled. The Flux will never complete.

Parameters:

period - The number of milliseconds to wait before the next increment

Returns:

a new timed Flux

intervalMillis

public static Flux<Long> intervalMillis(long period,
                                        TimedScheduler timer)

Create a new Flux that emits an ever incrementing long starting with 0 every N milliseconds on the given timer. If demand is not produced in time, an onError will be signalled. The Flux will never complete.

Parameters:

period - The duration in milliseconds to wait before the next increment

timer - a TimedScheduler instance

Returns:

a new timed Flux

intervalMillis

public static Flux<Long> intervalMillis(long delay,
                                        long period)

Create a new Flux that emits an ever incrementing long starting with 0 every N period of time unit on a global timer. If demand is not produced in time, an onError will be signalled. The Flux will never complete.

Parameters:

delay - the delay in milliseconds to wait before emitting 0l

period - the period in milliseconds before each following increment

Returns:

a new timed Flux

intervalMillis

public static Flux<Long> intervalMillis(long delay,
                                        long period,
                                        TimedScheduler timer)

Create a new Flux that emits an ever incrementing long starting with 0 every N period of time unit on the given timer. If demand is not produced in time, an onError will be signalled. The Flux will never complete.

Parameters:

delay - the timespan in milliseconds to wait before emitting 0l

period - the period in milliseconds before each following increment

timer - the TimedScheduler to schedule on

Returns:

a new timed Flux

just

@SafeVarargs
public static <T> Flux<T> just(T... data)

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

Type Parameters:

T - the emitted data type

Parameters:

data - the consecutive data objects to emit

Returns:

a new Flux

just

public static <T> Flux<T> just(T data)

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

Type Parameters:

T - the emitted data type

Parameters:

data - the unique data to emit

Returns:

a new Flux

merge

public static <T> Flux<T> merge(Publisher<? extends Publisher<? extends T>> source)

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

Type Parameters:

T - the merged type

Parameters:

source - a Publisher of Publisher sequence to merge

Returns:

a merged Flux

merge

public static <T> Flux<T> merge(Publisher<? extends Publisher<? extends T>> source,
                                int concurrency)

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

Type Parameters:

T - the merged type

Parameters:

source - a Publisher of Publisher sequence to merge

concurrency - the request produced to the main source thus limiting concurrent merge backlog

Returns:

a merged Flux

merge

public static <T> Flux<T> merge(Publisher<? extends Publisher<? extends T>> source,
                                int concurrency,
                                int prefetch)

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

Type Parameters:

T - the merged type

Parameters:

source - a Publisher of Publisher sequence to merge

concurrency - the request produced to the main source thus limiting concurrent merge backlog

prefetch - the inner source request size

Returns:

a merged Flux

merge

public static <I> Flux<I> merge(Iterable<? extends Publisher<? extends I>> sources)

Merge emitted Publisher sequences from the passed Iterable into an interleaved merged sequence. Iterable.iterator() will be called for each Publisher.subscribe(org.reactivestreams.Subscriber<? super T>).

Type Parameters:

I - The source type of the data sequence

Parameters:

sources - the Iterable to lazily iterate on Publisher.subscribe(Subscriber)

Returns:

a fresh Reactive Flux publisher ready to be subscribed

merge

@SafeVarargs
public static <I> Flux<I> merge(Publisher<? extends I>... sources)

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

Type Parameters:

I - The source type of the data sequence

Parameters:

sources - the Publisher array to iterate on Publisher.subscribe(Subscriber)

Returns:

a fresh Reactive Flux publisher ready to be subscribed

merge

@SafeVarargs
public static <I> Flux<I> merge(int prefetch,
                                             Publisher<? extends I>... sources)

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

Type Parameters:

I - The source type of the data sequence

Parameters:

sources - the Publisher array to iterate on Publisher.subscribe(Subscriber)

prefetch - the inner source request size

Returns:

a fresh Reactive Flux publisher ready to be subscribed

merge

@SafeVarargs
public static <I> Flux<I> merge(int prefetch,
                                             boolean delayError,
                                             Publisher<? extends I>... sources)

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

Type Parameters:

I - The source type of the data sequence

Parameters:

sources - the Publisher array to iterate on Publisher.subscribe(Subscriber)

prefetch - the inner source request size

delayError - should any error be delayed after current merge backlog

Returns:

a fresh Reactive Flux publisher ready to be subscribed

mergeSequential

public static <T> Flux<T> mergeSequential(Publisher<? extends Publisher<? extends T>> sources)

Merge emitted Publisher sequences by the passed Publisher into an ordered merged sequence. Unlike concat, the inner publishers are subscribed to eagerly. Unlike merge, their emitted values are merged into the final sequence in subscription order.

Type Parameters:

T - the merged type

Parameters:

sources - a Publisher of Publisher sequence to merge

Returns:

a merged Flux

mergeSequential

public static <T> Flux<T> mergeSequential(Publisher<? extends Publisher<? extends T>> sources,
                                          boolean delayError,
                                          int maxConcurrency,
                                          int prefetch)

Merge emitted Publisher sequences by the passed Publisher into an ordered merged sequence. Unlike concat, the inner publishers are subscribed to eagerly. Unlike merge, their emitted values are merged into the final sequence in subscription order.

Type Parameters:

T - the merged type

Parameters:

sources - a Publisher of Publisher sequence to merge

delayError - should any error be delayed after current merge backlog

prefetch - the inner source request size

maxConcurrency - the request produced to the main source thus limiting concurrent merge backlog

Returns:

a merged Flux

mergeSequential

@SafeVarargs
public static <I> Flux<I> mergeSequential(Publisher<? extends I>... sources)

Merge a number of Publisher sequences into an ordered merged sequence. Unlike concat, the inner publishers are subscribed to eagerly. Unlike merge, their emitted values are merged into the final sequence in subscription order.

Type Parameters:

I - the merged type

Parameters:

sources - a number of Publisher sequences to merge

Returns:

a merged Flux

mergeSequential

@SafeVarargs
public static <I> Flux<I> mergeSequential(int prefetch,
                                                       boolean delayError,
                                                       Publisher<? extends I>... sources)

Merge a number of Publisher sequences into an ordered merged sequence. Unlike concat, the inner publishers are subscribed to eagerly. Unlike merge, their emitted values are merged into the final sequence in subscription order.

Type Parameters:

I - the merged type

Parameters:

delayError - should any error be delayed after current merge backlog

prefetch - the inner source request size

sources - a number of Publisher sequences to merge

Returns:

a merged Flux

mergeSequential

public static <I> Flux<I> mergeSequential(Iterable<? extends Publisher<? extends I>> sources)

Merge Publisher sequences from an Iterable into an ordered merged sequence. Unlike concat, the inner publishers are subscribed to eagerly. Unlike merge, their emitted values are merged into the final sequence in subscription order.

Type Parameters:

I - the merged type

Parameters:

sources - an Iterable of Publisher sequences to merge

Returns:

a merged Flux

mergeSequential

public static <I> Flux<I> mergeSequential(Iterable<? extends Publisher<? extends I>> sources,
                                          boolean delayError,
                                          int maxConcurrency,
                                          int prefetch)

Merge Publisher sequences from an Iterable into an ordered merged sequence. Unlike concat, the inner publishers are subscribed to eagerly. Unlike merge, their emitted values are merged into the final sequence in subscription order.

Type Parameters:

I - the merged type

Parameters:

sources - an Iterable of Publisher sequences to merge

delayError - should any error be delayed after current merge backlog

maxConcurrency - the request produced to the main source thus limiting concurrent merge backlog

prefetch - the inner source request size

Returns:

a merged Flux

never

public static <T> Flux<T> never()

Create a Flux that will never signal any data, error or completion signal.

Type Parameters:

T - the Subscriber type target

Returns:

a never completing Flux

range

public static Flux<Integer> range(int start,
                                  int count)

Build a Flux that will only emit a sequence of incrementing integer from start to start + count then complete.

Parameters:

start - the first integer to be emit

count - the number ot times to emit an increment including the first value

Returns:

a ranged Flux

switchOnNext

public static <T> Flux<T> switchOnNext(Publisher<? extends Publisher<? extends T>> mergedPublishers)

Build a FluxProcessor whose data are emitted by the most recent emitted Publisher. The Flux will complete once both the publishers source and the last switched to Publisher have completed.

Type Parameters:

T - the produced type

Parameters:

mergedPublishers - The Publisher of switching Publisher to subscribe to.

Returns:

a FluxProcessor accepting publishers and producing T

switchOnNext

public static <T> Flux<T> switchOnNext(Publisher<? extends Publisher<? extends T>> mergedPublishers,
                                       int prefetch)

Build a FluxProcessor whose data are emitted by the most recent emitted Publisher. The Flux will complete once both the publishers source and the last switched to Publisher have completed.

Type Parameters:

T - the produced type

Parameters:

mergedPublishers - The Publisher of switching Publisher to subscribe to.

prefetch - the inner source request size

Returns:

a FluxProcessor accepting publishers and producing T

using

public static <T,D> Flux<T> using(Callable<? extends D> resourceSupplier,
                                  Function<? super D,? extends Publisher<? extends T>> sourceSupplier,
                                  Consumer<? super D> resourceCleanup)

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.

Eager resource cleanup happens just before the source termination and exceptions raised by the cleanup Consumer may override the terminal even.

Type Parameters:

T - emitted type

D - resource type

Parameters:

resourceSupplier - a Callable that is called on subscribe

sourceSupplier - a Publisher factory derived from the supplied resource

resourceCleanup - invoked on completion

Returns:

new Flux

using

public static <T,D> Flux<T> using(Callable<? extends D> resourceSupplier,
                                  Function<? super D,? extends Publisher<? extends T>> sourceSupplier,
                                  Consumer<? super D> resourceCleanup,
                                  boolean eager)

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.

• Eager resource cleanup happens just before the source termination and exceptions raised by the cleanup Consumer may override the terminal even.
• Non-eager cleanup will drop any exception.

Type Parameters:

T - emitted type

D - resource type

Parameters:

resourceSupplier - a Callable that is called on subscribe

sourceSupplier - a Publisher factory derived from the supplied resource

resourceCleanup - invoked on completion

eager - true to clean before terminating downstream subscribers

Returns:

new Stream

zip

public static <T1,T2,O> Flux<O> zip(Publisher<? extends T1> source1,
                                    Publisher<? extends T2> source2,
                                    BiFunction<? super T1,? super T2,? extends O> combinator)

"Step-Merge" especially useful in Scatter-Gather scenarios. The operator will forward all combinations produced by the passed combinator function of the most recent items emitted by each source until any of them completes. Errors will immediately be forwarded.

Type Parameters:

T1 - type of the value from source1

T2 - type of the value from source2

O - The produced output after transformation by the combinator

Parameters:

source1 - The first upstream Publisher to subscribe to.

source2 - The second upstream Publisher to subscribe to.

combinator - The aggregate function that will receive a unique value from each upstream and return the value to signal downstream

Returns:

a zipped Flux

zip

public static <T1,T2> Flux<Tuple2<T1,T2>> zip(Publisher<? extends T1> source1,
                                              Publisher<? extends T2> source2)

"Step-Merge" especially useful in Scatter-Gather scenarios. The operator will forward all combinations of the most recent items emitted by each source until any of them completes. Errors will immediately be forwarded.

Type Parameters:

T1 - type of the value from source1

T2 - type of the value from source2

Parameters:

source1 - The first upstream Publisher to subscribe to.

source2 - The second upstream Publisher to subscribe to.

Returns:

a zipped Flux

zip

public static <T1,T2,T3> Flux<Tuple3<T1,T2,T3>> zip(Publisher<? extends T1> source1,
                                                    Publisher<? extends T2> source2,
                                                    Publisher<? extends T3> source3)

"Step-Merge" especially useful in Scatter-Gather scenarios. The operator will forward all combinations of the most recent items emitted by each source until any of them completes. Errors will immediately be forwarded.

Type Parameters:

T1 - type of the value from source1

T2 - type of the value from source2

T3 - type of the value from source3

Parameters:

source1 - The first upstream Publisher to subscribe to.

source2 - The second upstream Publisher to subscribe to.

source3 - The third upstream Publisher to subscribe to.

Returns:

a zipped Flux

zip

public static <T1,T2,T3,T4> Flux<Tuple4<T1,T2,T3,T4>> zip(Publisher<? extends T1> source1,
                                                          Publisher<? extends T2> source2,
                                                          Publisher<? extends T3> source3,
                                                          Publisher<? extends T4> source4)

"Step-Merge" especially useful in Scatter-Gather scenarios. The operator will forward all combinations of the most recent items emitted by each source until any of them completes. Errors will immediately be forwarded.

Type Parameters:

T1 - type of the value from source1

T2 - type of the value from source2

T3 - type of the value from source3

T4 - type of the value from source4

Parameters:

source1 - The first upstream Publisher to subscribe to.

source2 - The second upstream Publisher to subscribe to.

source3 - The third upstream Publisher to subscribe to.

source4 - The fourth upstream Publisher to subscribe to.

Returns:

a zipped Flux

zip

public static <T1,T2,T3,T4,T5> Flux<Tuple5<T1,T2,T3,T4,T5>> zip(Publisher<? extends T1> source1,
                                                                Publisher<? extends T2> source2,
                                                                Publisher<? extends T3> source3,
                                                                Publisher<? extends T4> source4,
                                                                Publisher<? extends T5> source5)

"Step-Merge" especially useful in Scatter-Gather scenarios. The operator will forward all combinations of the most recent items emitted by each source until any of them completes. Errors will immediately be forwarded.

Type Parameters:

T1 - type of the value from source1

T2 - type of the value from source2

T3 - type of the value from source3

T4 - type of the value from source4

T5 - type of the value from source5

Parameters:

source1 - The first upstream Publisher to subscribe to.

source2 - The second upstream Publisher to subscribe to.

source3 - The third upstream Publisher to subscribe to.

source4 - The fourth upstream Publisher to subscribe to.

source5 - The fifth upstream Publisher to subscribe to.

Returns:

a zipped Flux

zip

public static <T1,T2,T3,T4,T5,T6> Flux<Tuple6<T1,T2,T3,T4,T5,T6>> zip(Publisher<? extends T1> source1,
                                                                      Publisher<? extends T2> source2,
                                                                      Publisher<? extends T3> source3,
                                                                      Publisher<? extends T4> source4,
                                                                      Publisher<? extends T5> source5,
                                                                      Publisher<? extends T6> source6)

"Step-Merge" especially useful in Scatter-Gather scenarios. The operator will forward all combinations of the most recent items emitted by each source until any of them completes. Errors will immediately be forwarded.

Type Parameters:

T1 - type of the value from source1

T2 - type of the value from source2

T3 - type of the value from source3

T4 - type of the value from source4

T5 - type of the value from source5

T6 - type of the value from source6

Parameters:

source1 - The first upstream Publisher to subscribe to.

source2 - The second upstream Publisher to subscribe to.

source3 - The third upstream Publisher to subscribe to.

source4 - The fourth upstream Publisher to subscribe to.

source5 - The fifth upstream Publisher to subscribe to.

source6 - The sixth upstream Publisher to subscribe to.

Returns:

a zipped Flux

zip

@Deprecated
public static Flux<Tuple2> zip(Iterable<? extends Publisher<?>> sources)

Deprecated. prefer using zip(Iterable, Function), will be removed in 3.1.0

"Step-Merge" especially useful in Scatter-Gather scenarios. The operator will forward all combinations of the most recent items emitted by each source until any of them completes. Errors will immediately be forwarded. The Iterable.iterator() will be called on each Publisher.subscribe(Subscriber).

Note that this version is very limited compared to the alternatives where you either provide a fixed number of sources or a more meaningful combinator. Here we default to combining into Tuples, which limits us to up to 8 sources (Tuple8). Additionally, since a Tuple2 is returned, the usage will probably be limited to iterating over the Tuple (or casting to the correct TupleN, but if you can do that you're better off using the fixed size signatures like zip(Publisher, Publisher, Publisher)). Consider using zip(Iterable, Function) instead, with Arrays.asList(Object[]) as a combinator, if you really don't know the number of sources or if it can grow beyond 8.

Parameters:

sources - the Iterable to iterate on Publisher.subscribe(Subscriber)

Returns:

a zipped Flux

See Also:

zip(Publisher, Publisher, Publisher), zip(Iterable, Function)

zip

public static <O> Flux<O> zip(Iterable<? extends Publisher<?>> sources,
                              Function<? super Object[],? extends O> combinator)

"Step-Merge" especially useful in Scatter-Gather scenarios. The operator will forward all combinations produced by the passed combinator function of the most recent items emitted by each source until any of them completes. Errors will immediately be forwarded. The Iterable.iterator() will be called on each Publisher.subscribe(Subscriber).

Type Parameters:

O - the combined produced type

Parameters:

sources - the Iterable to iterate on Publisher.subscribe(Subscriber)

combinator - The aggregate function that will receive a unique value from each upstream and return the value to signal downstream

Returns:

a zipped Flux

zip

public static <O> Flux<O> zip(Iterable<? extends Publisher<?>> sources,
                              int prefetch,
                              Function<? super Object[],? extends O> combinator)

"Step-Merge" especially useful in Scatter-Gather scenarios. The operator will forward all combinations produced by the passed combinator function of the most recent items emitted by each source until any of them completes. Errors will immediately be forwarded. The Iterable.iterator() will be called on each Publisher.subscribe(Subscriber).

Type Parameters:

O - the combined produced type

Parameters:

sources - the Iterable to iterate on Publisher.subscribe(Subscriber)

prefetch - the inner source request size

combinator - The aggregate function that will receive a unique value from each upstream and return the value to signal downstream

Returns:

a zipped Flux

zip

@SafeVarargs
public static <I,O> Flux<O> zip(Function<? super Object[],? extends O> combinator,
                                             Publisher<? extends I>... sources)

"Step-Merge" especially useful in Scatter-Gather scenarios. The operator will forward all combinations produced by the passed combinator function of the most recent items emitted by each source until any of them completes. Errors will immediately be forwarded.

Type Parameters:

I - the type of the input sources

O - the combined produced type

Parameters:

combinator - The aggregate function that will receive a unique value from each upstream and return the value to signal downstream

sources - the Publisher array to iterate on Publisher.subscribe(Subscriber)

Returns:

a zipped Flux

zip

@SafeVarargs
public static <I,O> Flux<O> zip(Function<? super Object[],? extends O> combinator,
                                             int prefetch,
                                             Publisher<? extends I>... sources)

"Step-Merge" especially useful in Scatter-Gather scenarios. The operator will forward all combinations produced by the passed combinator function of the most recent items emitted by each source until any of them completes. Errors will immediately be forwarded.

Type Parameters:

I - the type of the input sources

O - the combined produced type

Parameters:

combinator - The aggregate function that will receive a unique value from each upstream and return the value to signal downstream

prefetch - individual source request size

sources - the Publisher array to iterate on Publisher.subscribe(Subscriber)

Returns:

a zipped Flux

zip

public static <TUPLE extends Tuple2,V> Flux<V> zip(Publisher<? extends Publisher<?>> sources,
                                                   Function<? super TUPLE,? extends V> combinator)

"Step-Merge" especially useful in Scatter-Gather scenarios. The Publisher of Publisher will accumulate into a list until completion before starting zip operation. The operator will forward all combinations of the most recent items emitted by each published source until any of them completes. Errors will immediately be forwarded.

Type Parameters:

TUPLE - the raw tuple type

V - The produced output after transformation by the given combinator

Parameters:

sources - The publisher of upstream Publisher to subscribe to.

combinator - The aggregate function that will receive a unique value from each upstream and return the value to signal downstream

Returns:

a Flux based on the produced value

all

public final Mono<Boolean> all(Predicate<? super T> predicate)

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

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

Parameters:

predicate - the Predicate to match all emitted items

Returns:

a Mono of all evaluations

any

public final Mono<Boolean> any(Predicate<? super T> predicate)

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.

Parameters:

predicate - predicate tested upon values

Returns:

a new Flux with true if any value satisfies a predicate and false otherwise

as

public final <P> P as(Function<? super Flux<T>,P> transformer)

Immediately apply the given transformation to this Flux in order to generate a target type. flux.as(Mono::from).subscribe()

Type Parameters:

P - the returned type

Parameters:

transformer - the Function to immediately map this Flux into a target type instance.

Returns:

a an instance of P

See Also:

for a bounded conversion to {@link Publisher}

awaitOnSubscribe

public final Flux<T> awaitOnSubscribe()

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

This helps with child Subscribers that don't expect a recursive call from onSubscribe into their onNext because, for example, they request immediately from their onSubscribe but don't finish their preparation before that and onNext runs into a half-prepared state. This can happen with non Reactor mentality based Subscribers.

Returns:

non reentrant onSubscribe Flux

blockFirst

public final T blockFirst()

Blocks until the upstream signals its first value or completes.

Returns:

the first value or null

blockFirst

public final T blockFirst(Duration d)

Blocks until the upstream signals its first value or completes.

Parameters:

d - max duration timeout to wait for.

Returns:

the first value or null

blockFirstMillis

public final T blockFirstMillis(long timeout)

Blocks until the upstream signals its first value or completes.

Parameters:

timeout - max duration timeout in millis to wait for.

Returns:

the first value or null

blockLast

public final T blockLast()

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

Returns:

the last value or null

blockLast

public final T blockLast(Duration d)

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

Parameters:

d - max duration timeout to wait for.

Returns:

the last value or null

blockLastMillis

public final T blockLastMillis(long timeout)

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

Parameters:

timeout - max duration timeout in millis to wait for.

Returns:

the last value or null

buffer

public final Flux<List<T>> buffer()

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

Returns:

a buffered Flux of at most one List

See Also:

for an alternative collecting algorithm returning {@link Mono}

buffer

public final Flux<List<T>> buffer(int maxSize)

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.

Parameters:

maxSize - the maximum collected size

Returns:

a microbatched Flux of List

buffer

public final <C extends Collection<? super T>> Flux<C> buffer(int maxSize,
                                                              Supplier<C> bufferSupplier)

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.

Type Parameters:

C - the supplied Collection type

Parameters:

maxSize - the maximum collected size

bufferSupplier - the collection to use for each data segment

Returns:

a microbatched Flux of Collection

buffer

public final Flux<List<T>> buffer(int maxSize,
                                  int skip)

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. A new container List 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

Parameters:

skip - the number of items to skip before creating a new bucket

maxSize - the max collected size

Returns:

a microbatched Flux of possibly overlapped or gapped List

buffer

public final <C extends Collection<? super T>> Flux<C> buffer(int maxSize,
                                                              int skip,
                                                              Supplier<C> bufferSupplier)

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. A new container Collection 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

Type Parameters:

C - the supplied Collection type

Parameters:

skip - the number of items to skip before creating a new bucket

maxSize - the max collected size

bufferSupplier - the collection to use for each data segment

Returns:

a microbatched Flux of possibly overlapped or gapped Collection

buffer

public final Flux<List<T>> buffer(Publisher<?> other)

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

Parameters:

other - the other Publisher to subscribe to for emiting and recycling receiving bucket

Returns:

a microbatched Flux of List delimited by a Publisher

buffer

public final <C extends Collection<? super T>> Flux<C> buffer(Publisher<?> other,
                                                              Supplier<C> bufferSupplier)

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

Type Parameters:

C - the supplied Collection type

Parameters:

other - the other Publisher to subscribe to for emitting and recycling receiving bucket

bufferSupplier - the collection to use for each data segment

Returns:

a microbatched Flux of Collection delimited by a Publisher

buffer

public final <U,V> Flux<List<T>> buffer(Publisher<U> bucketOpening,
                                        Function<? super U,? extends Publisher<V>> closeSelector)

Collect incoming values into multiple List delimited by the given Publisher signals. Each List 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

Type Parameters:

U - the element type of the bucket-opening sequence

V - the element type of the bucket-closing sequence

Parameters:

bucketOpening - a Publisher to subscribe to for creating new receiving bucket signals.

closeSelector - a Publisher factory provided the opening signal and returning a Publisher to subscribe to for emitting relative bucket.

Returns:

a microbatched Flux of List delimited by an opening Publisher and a relative closing Publisher

buffer

public final <U,V,C extends Collection<? super T>> Flux<C> buffer(Publisher<U> bucketOpening,
                                                                  Function<? super U,? extends Publisher<V>> closeSelector,
                                                                  Supplier<C> bufferSupplier)

Collect incoming values into multiple Collection delimited by the given Publisher signals. Each Collection 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

Type Parameters:

U - the element type of the bucket-opening sequence

V - the element type of the bucket-closing sequence

C - the supplied Collection type

Parameters:

bucketOpening - a Publisher to subscribe to for creating new receiving bucket signals.

closeSelector - a Publisher factory provided the opening signal and returning a Publisher to subscribe to for emitting relative bucket.

bufferSupplier - the collection to use for each data segment

Returns:

a microbatched Flux of Collection delimited by an opening Publisher and a relative closing Publisher

buffer

public final Flux<List<T>> buffer(Duration timespan)

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

Parameters:

timespan - the duration to use to release a buffered list

Returns:

a microbatched Flux of List delimited by the given period

buffer

public final Flux<List<T>> buffer(Duration timespan,
                                  Duration timeshift)

Collect incoming values into multiple List delimited by the given timeshift period. Each List 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

Parameters:

timespan - the duration to use to release buffered lists

timeshift - the duration to use to create a new bucket

Returns:

a microbatched Flux of List delimited by the given period timeshift and sized by timespan

buffer

@Deprecated
public final Flux<List<T>> buffer(int maxSize,
                                              Duration timespan)

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

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

Parameters:

maxSize - the max collected size

timespan - the timeout to use to release a buffered list

Returns:

a microbatched Flux of List delimited by given size or a given period timeout

buffer

@Deprecated
public final <C extends Collection<? super T>> Flux<C> buffer(int maxSize,
                                                                          Duration timespan,
                                                                          Supplier<C> bufferSupplier)

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

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

Type Parameters:

C - the supplied Collection type

Parameters:

maxSize - the max collected size

timespan - the timeout to use to release a buffered list

bufferSupplier - the collection to use for each data segment

Returns:

a microbatched Flux of Collection delimited by given size or a given period timeout

bufferTimeout

public final Flux<List<T>> bufferTimeout(int maxSize,
                                         Duration timespan)

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

Parameters:

maxSize - the max collected size

timespan - the timeout to use to release a buffered list

Returns:

a microbatched Flux of List delimited by given size or a given period timeout

bufferTimeout

public final <C extends Collection<? super T>> Flux<C> bufferTimeout(int maxSize,
                                                                     Duration timespan,
                                                                     Supplier<C> bufferSupplier)

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

Type Parameters:

C - the supplied Collection type

Parameters:

maxSize - the max collected size

timespan - the timeout to use to release a buffered list

bufferSupplier - the collection to use for each data segment

Returns:

a microbatched Flux of Collection delimited by given size or a given period timeout

bufferMillis

public final Flux<List<T>> bufferMillis(long timespan)

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

Parameters:

timespan - the duration to use to release a buffered list in milliseconds

Returns:

a microbatched Flux of List delimited by the given period

bufferMillis

public final Flux<List<T>> bufferMillis(long timespan,
                                        TimedScheduler timer)

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

Parameters:

timespan - theduration to use to release a buffered list in milliseconds

timer - the TimedScheduler to run on

Returns:

a microbatched Flux of List delimited by the given period

bufferMillis

public final Flux<List<T>> bufferMillis(long timespan,
                                        long timeshift)

Collect incoming values into multiple List delimited by the given timeshift period. Each List 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

Parameters:

timespan - the duration to use to release buffered lists

timeshift - the duration to use to create a new bucket

Returns:

a microbatched Flux of List delimited by the given period timeshift and sized by timespan

bufferMillis

public final Flux<List<T>> bufferMillis(long timespan,
                                        long timeshift,
                                        TimedScheduler timer)

Collect incoming values into multiple List delimited by the given timeshift period. Each List 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

Parameters:

timespan - the duration to use to release buffered lists

timeshift - the duration to use to create a new bucket

timer - the TimedScheduler to run on

Returns:

a microbatched Flux of List delimited by the given period timeshift and sized by timespan

bufferMillis

@Deprecated
public final Flux<List<T>> bufferMillis(int maxSize,
                                                    long timespan)

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

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

Parameters:

maxSize - the max collected size

timespan - the timeout in milliseconds to use to release a buffered list

Returns:

a microbatched Flux of List delimited by given size or a given period timeout

bufferMillis

@Deprecated
public final Flux<List<T>> bufferMillis(int maxSize,
                                                    long timespan,
                                                    TimedScheduler timer)

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

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

Parameters:

maxSize - the max collected size

timespan - the timeout to use to release a buffered list

timer - the TimedScheduler to run on

Returns:

a microbatched Flux of List delimited by given size or a given period timeout

bufferMillis

@Deprecated
public final <C extends Collection<? super T>> Flux<C> bufferMillis(int maxSize,
                                                                                long timespan,
                                                                                TimedScheduler timer,
                                                                                Supplier<C> bufferSupplier)

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

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

Type Parameters:

C - the supplied Collection type

Parameters:

maxSize - the max collected size

timespan - the timeout to use to release a buffered collection

timer - the TimedScheduler to run on

bufferSupplier - the collection to use for each data segment

Returns:

a microbatched Flux of Collection delimited by given size or a given period timeout

bufferTimeoutMillis

public final Flux<List<T>> bufferTimeoutMillis(int maxSize,
                                               long timespan)

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

Parameters:

maxSize - the max collected size

timespan - the timeout in milliseconds to use to release a buffered list

Returns:

a microbatched Flux of List delimited by given size or a given period timeout

bufferTimeoutMillis

public final Flux<List<T>> bufferTimeoutMillis(int maxSize,
                                               long timespan,
                                               TimedScheduler timer)

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

Parameters:

maxSize - the max collected size

timespan - the timeout to use to release a buffered list

timer - the TimedScheduler to run on

Returns:

a microbatched Flux of List delimited by given size or a given period timeout

bufferTimeoutMillis

public final <C extends Collection<? super T>> Flux<C> bufferTimeoutMillis(int maxSize,
                                                                           long timespan,
                                                                           TimedScheduler timer,
                                                                           Supplier<C> bufferSupplier)

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

Type Parameters:

C - the supplied Collection type

Parameters:

maxSize - the max collected size

timespan - the timeout to use to release a buffered collection

timer - the TimedScheduler to run on

bufferSupplier - the collection to use for each data segment

Returns:

a microbatched Flux of Collection delimited by given size or a given period timeout

bufferUntil

public final Flux<List<T>> bufferUntil(Predicate<? super T> predicate)

Collect incoming values into multiple List 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.

Parameters:

predicate - a predicate that triggers the next buffer when it becomes true.

Returns:

a microbatched Flux of List

bufferUntil

public final Flux<List<T>> bufferUntil(Predicate<? super T> predicate,
                                       boolean cutBefore)

Collect incoming values into multiple List 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 bufferUntil(Predicate)).

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.

Parameters:

predicate - a predicate that triggers the next buffer when it becomes true.

cutBefore - set to true to include the triggering element in the new buffer rather than the old.

Returns:

a microbatched Flux of List

bufferWhile

public final Flux<List<T>> bufferWhile(Predicate<? super T> predicate)

Collect incoming values into multiple List 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.

Parameters:

predicate - a predicate that triggers the next buffer when it becomes false.

Returns:

a microbatched Flux of List

cache

public final Flux<T> cache()

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.

Returns:

a replaying Flux

cache

public final Flux<T> cache(int history)

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.

Parameters:

history - number of events retained in history excluding complete and error

Returns:

a replaying Flux

cache

public final Flux<T> cache(Duration ttl)

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.

Parameters:

ttl - Time-to-live for each cached item.

Returns:

a replaying Flux

cache

public final Flux<T> cache(int history,
                           Duration ttl)

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.

Parameters:

history - number of events retained in history excluding complete and error

ttl - Time-to-live for each cached item.

Returns:

a replaying Flux

cast

public final <E> Flux<E> cast(Class<E> clazz)

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

Type Parameters:

E - the Flux output type

Parameters:

clazz - the target class to cast to

Returns:

a casted Flux

cancelOn

public final Flux<T> cancelOn(Scheduler scheduler)

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

Parameters:

scheduler - the Scheduler to signal cancel on

Returns:

a scheduled cancel Flux

checkpoint

public final Flux<T> checkpoint()

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.

Returns:

the assembly tracing Flux.

checkpoint

public final Flux<T> checkpoint(String description)

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.

Parameters:

description - a description to include in the assembly traceback.

Returns:

the assembly tracing Flux.

collect

public final <E> Mono<E> collect(Supplier<E> containerSupplier,
                                 BiConsumer<E,? super T> collector)

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

Type Parameters:

E - the Flux collected container type

Parameters:

containerSupplier - the supplier of the container instance for each Subscriber

collector - the consumer of both the container instance and the current value

Returns:

a Mono sequence of the collected value on complete

collect

public final <R,A> Mono<R> collect(Collector<? super T,A,? extends R> collector)

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

Type Parameters:

A - The mutable accumulation type

R - the Flux collected container type

Parameters:

collector - the Collector

Returns:

a Mono sequence of the collected value on complete

collectList

public final Mono<List<T>> collectList()

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

Returns:

a Mono of all values from this Flux

collectMap

public final <K> Mono<Map<K,T>> collectMap(Function<? super T,? extends K> keyExtractor)

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.

Type Parameters:

K - the key extracted from each value of this Flux instance

Parameters:

keyExtractor - a Function to route items into a keyed Collection

Returns:

a Mono of all last matched key-values from this Flux

collectMap

public final <K,V> Mono<Map<K,V>> collectMap(Function<? super T,? extends K> keyExtractor,
                                             Function<? super T,? extends V> valueExtractor)

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.

Type Parameters:

K - the key extracted from each value of this Flux instance

V - the value extracted from each value of this Flux instance

Parameters:

keyExtractor - a Function to route items into a keyed Collection

valueExtractor - a Function to select the data to store from each item

Returns:

a Mono of all last matched key-values from this Flux

collectMap

public final <K,V> Mono<Map<K,V>> collectMap(Function<? super T,? extends K> keyExtractor,
                                             Function<? super T,? extends V> valueExtractor,
                                             Supplier<Map<K,V>> mapSupplier)

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.

Type Parameters:

K - the key extracted from each value of this Flux instance

V - the value extracted from each value of this Flux instance

Parameters:

keyExtractor - a Function to route items into a keyed Collection

valueExtractor - a Function to select the data to store from each item

mapSupplier - a Map factory called for each Subscriber

Returns:

a Mono of all last matched key-values from this Flux

collectMultimap

public final <K> Mono<Map<K,Collection<T>>> collectMultimap(Function<? super T,? extends K> keyExtractor)

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.

Type Parameters:

K - the key extracted from each value of this Flux instance

Parameters:

keyExtractor - a Function to route items into a keyed Collection

Returns:

a Mono of all matched key-values from this Flux

collectMultimap

public final <K,V> Mono<Map<K,Collection<V>>> collectMultimap(Function<? super T,? extends K> keyExtractor,
                                                              Function<? super T,? extends V> valueExtractor)

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.

Type Parameters:

K - the key extracted from each value of this Flux instance

V - the value extracted from each value of this Flux instance

Parameters:

keyExtractor - a Function to route items into a keyed Collection

valueExtractor - a Function to select the data to store from each item

Returns:

a Mono of all matched key-values from this Flux

collectMultimap

public final <K,V> Mono<Map<K,Collection<V>>> collectMultimap(Function<? super T,? extends K> keyExtractor,
                                                              Function<? super T,? extends V> valueExtractor,
                                                              Supplier<Map<K,Collection<V>>> mapSupplier)

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.

Type Parameters:

K - the key extracted from each value of this Flux instance

V - the value extracted from each value of this Flux instance

Parameters:

keyExtractor - a Function to route items into a keyed Collection

valueExtractor - a Function to select the data to store from each item

mapSupplier - a Map factory called for each Subscriber

Returns:

a Mono of all matched key-values from this Flux

collectSortedList

public final Mono<List<T>> collectSortedList()

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

Returns:

a Mono of all sorted values from this Flux

collectSortedList

public final Mono<List<T>> collectSortedList(Comparator<? super T> comparator)

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

Parameters:

comparator - a Comparator to sort the items of this sequences

Returns:

a Mono of all sorted values from this Flux

compose

public final <V> Flux<V> compose(Function<? super Flux<T>,? extends Publisher<V>> transformer)

Defer the transformation of this Flux in order to generate a target Flux for each new Subscriber. flux.compose(Mono::from).subscribe()

Type Parameters:

V - the item type in the returned Publisher

Parameters:

transformer - the Function to map this Flux into a target Publisher instance for each new subscriber

Returns:

a new Flux

See Also:

for immmediate transformation of {@link Flux}, for a loose conversion to an arbitrary type

concatMap

public final <V> Flux<V> concatMap(Function<? super T,? extends Publisher<? extends V>> mapper)

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

Type Parameters:

V - the produced concatenated type

Parameters:

mapper - the function to transform this sequence of T into concatenated sequences of V

Returns:

a concatenated Flux

concatMap

public final <V> Flux<V> concatMap(Function<? super T,? extends Publisher<? extends V>> mapper,
                                   int prefetch)

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

Type Parameters:

V - the produced concatenated type

Parameters:

mapper - the function to transform this sequence of T into concatenated sequences of V

prefetch - the inner source produced demand

Returns:

a concatenated Flux

concatMapDelayError

public final <V> Flux<V> concatMapDelayError(Function<? super T,Publisher<? extends V>> mapper)

Bind dynamic sequences given this input sequence like flatMap(Function), but preserve ordering and concatenate emissions instead of merging (no interleave). Errors will be delayed after the current concat backlog.

Type Parameters:

V - the produced concatenated type

Parameters:

mapper - the function to transform this sequence of T into concatenated sequences of V

Returns:

a concatenated Flux

concatMapDelayError

public final <V> Flux<V> concatMapDelayError(Function<? super T,? extends Publisher<? extends V>> mapper,
                                             int prefetch)

Bind dynamic sequences given this input sequence like flatMap(Function), but preserve ordering and concatenate emissions instead of merging (no interleave). Errors will be delayed after all concated sources terminate.

Type Parameters:

V - the produced concatenated type

Parameters:

mapper - the function to transform this sequence of T into concatenated sequences of V

prefetch - the inner source produced demand

Returns:

a concatenated Flux

concatMapDelayError

public final <V> Flux<V> concatMapDelayError(Function<? super T,? extends Publisher<? extends V>> mapper,
                                             boolean delayUntilEnd,
                                             int prefetch)

Bind dynamic sequences given this input sequence like flatMap(Function), 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.

Type Parameters:

V - the produced concatenated type

Parameters:

mapper - the function to transform this sequence of T into concatenated sequences of V

delayUntilEnd - delay error until all sources have been consumed instead of after the current source

prefetch - the inner source produced demand

Returns:

a concatenated Flux

concatMapIterable

public final <R> Flux<R> concatMapIterable(Function<? super T,? extends Iterable<? extends R>> mapper)

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

Errors will be delayed after the current concat backlog.

Type Parameters:

R - the produced concatenated type

Parameters:

mapper - the function to transform this sequence of T into concatenated sequences of R

Returns:

a concatenated Flux

concatMapIterable

public final <R> Flux<R> concatMapIterable(Function<? super T,? extends Iterable<? extends R>> mapper,
                                           int prefetch)

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

Errors will be delayed after the current concat backlog.

Type Parameters:

R - the produced concatenated type

Parameters:

mapper - the function to transform this sequence of T into concatenated sequences of R

prefetch - the inner source produced demand

Returns:

a concatenated Flux

concatWith

public final Flux<T> concatWith(Publisher<? extends T> other)

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

Parameters:

other - the Publisher sequence to concat after this Flux

Returns:

a concatenated Flux

count

public final Mono<Long> count()

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

Returns:

a new Mono of Long count

defaultIfEmpty

public final Flux<T> defaultIfEmpty(T defaultV)

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

Parameters:

defaultV - the alternate value if this sequence is empty

Returns:

a new Flux

delay

@Deprecated
public final Flux<T> delay(Duration delay)

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

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

Parameters:

delay - duration to delay each Subscriber.onNext(T) signal

Returns:

a delayed Flux

See Also:

delaySubscription to introduce a delay at the beginning of the sequence only

delayElements

public final Flux<T> delayElements(Duration delay)

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

Parameters:

delay - duration to delay each Subscriber.onNext(T) signal

Returns:

a delayed Flux

See Also:

delaySubscription to introduce a delay at the beginning of the sequence only

delayMillis

@Deprecated
public final Flux<T> delayMillis(long delay)

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

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

Parameters:

delay - period to delay each Subscriber.onNext(T) signal, in milliseconds

Returns:

a delayed Flux

delayElementsMillis

public final Flux<T> delayElementsMillis(long delay)

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

Parameters:

delay - period to delay each Subscriber.onNext(T) signal, in milliseconds

Returns:

a delayed Flux

delayMillis

@Deprecated
public final Flux<T> delayMillis(long delay,
                                             TimedScheduler timer)

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

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

Parameters:

delay - period to delay each Subscriber.onNext(T) signal, in milliseconds

timer - the timed scheduler to use for delaying each signal

Returns:

a delayed Flux

delayElementsMillis

public final Flux<T> delayElementsMillis(long delay,
                                         TimedScheduler timer)

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

Parameters:

delay - period to delay each Subscriber.onNext(T) signal, in milliseconds

timer - the timed scheduler to use for delaying each signal

Returns:

a delayed Flux

delaySubscription

public final Flux<T> delaySubscription(Duration delay)

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

Parameters:

delay - duration before subscribing this Flux

Returns:

a delayed Flux

delaySubscription

public final <U> Flux<T> delaySubscription(Publisher<U> subscriptionDelay)

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

Type Parameters:

U - the other source type

Parameters:

subscriptionDelay - a Publisher to signal by next or complete this Publisher.subscribe(Subscriber)

Returns:

a delayed Flux

delaySubscriptionMillis

public final Flux<T> delaySubscriptionMillis(long delay)

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

Parameters:

delay - period in milliseconds before subscribing this Flux

Returns:

a delayed Flux

delaySubscriptionMillis

public final Flux<T> delaySubscriptionMillis(long delay,
                                             TimedScheduler timer)

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

Parameters:

delay - period in milliseconds before subscribing this Flux

timer - the TimedScheduler to run on

Returns:

a delayed Flux

dematerialize

public final <X> Flux<X> dematerialize()

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

Type Parameters:

X - the dematerialized type

Returns:

a dematerialized Flux

distinct

public final Flux<T> distinct()

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

Returns:

a filtering Flux with unique values

distinct

public final <V> Flux<T> distinct(Function<? super T,? extends V> keySelector)

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

Type Parameters:

V - the type of the key extracted from each value in this sequence

Parameters:

keySelector - function to compute comparison key for each element

Returns:

a filtering Flux with values having distinct keys

distinctUntilChanged

public final Flux<T> distinctUntilChanged()

Filters out subsequent and repeated elements.

Returns:

a filtering Flux with conflated repeated elements

distinctUntilChanged

public final <V> Flux<T> distinctUntilChanged(Function<? super T,? extends V> keySelector)

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

Type Parameters:

V - the type of the key extracted from each value in this sequence

Parameters:

keySelector - function to compute comparison key for each element

Returns:

a filtering Flux with conflated repeated elements given a comparison key

doAfterTerminate

public final Flux<T> doAfterTerminate(Runnable afterTerminate)

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

Parameters:

afterTerminate - the callback to call after Subscriber.onComplete() or Subscriber.onError(java.lang.Throwable)

Returns:

an observed Flux

doOnCancel

public final Flux<T> doOnCancel(Runnable onCancel)

Triggered when the Flux is cancelled.

Parameters:

onCancel - the callback to call on Subscription.cancel()

Returns:

an observed Flux

doOnComplete

public final Flux<T> doOnComplete(Runnable onComplete)

Triggered when the Flux completes successfully.

Parameters:

onComplete - the callback to call on Subscriber.onComplete()

Returns:

an observed Flux

doOnEach

public final Flux<T> doOnEach(Consumer<? super Signal<T>> signalConsumer)

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.

Parameters:

signalConsumer - the mandatory callback to call on Subscriber.onNext(Object), Subscriber.onError(Throwable) and Subscriber.onComplete()

Returns:

an observed Flux

See Also:

doOnNext(Consumer), doOnError(Consumer), doOnComplete(Runnable), materialize(), Signal

doOnError

public final Flux<T> doOnError(Consumer<? super Throwable> onError)

Triggered when the Flux completes with an error.

Parameters:

onError - the callback to call on Subscriber.onError(java.lang.Throwable)

Returns:

an observed Flux

doOnError

public final <E extends Throwable> Flux<T> doOnError(Class<E> exceptionType,
                                                     Consumer<? super E> onError)

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

Type Parameters:

E - type of the error to handle

Parameters:

exceptionType - the type of exceptions to handle

onError - the error handler for each error

Returns:

an observed Flux

doOnError

public final Flux<T> doOnError(Predicate<? super Throwable> predicate,
                               Consumer<? super Throwable> onError)

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

Parameters:

predicate - the matcher for exceptions to handle

onError - the error handler for each error

Returns:

an observed Flux

doOnNext

public final Flux<T> doOnNext(Consumer<? super T> onNext)

Triggered when the Flux emits an item.

Parameters:

onNext - the callback to call on Subscriber.onNext(T)

Returns:

an observed Flux

doOnRequest

public final Flux<T> doOnRequest(LongConsumer consumer)

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

Parameters:

consumer - the consumer to invoke on each request

Returns:

an observed Flux

doOnSubscribe

public final Flux<T> doOnSubscribe(Consumer<? super Subscription> onSubscribe)

Triggered when the Flux is subscribed.

Parameters:

onSubscribe - the callback to call on Subscriber.onSubscribe(org.reactivestreams.Subscription)

Returns:

an observed Flux

doOnTerminate

public final Flux<T> doOnTerminate(Runnable onTerminate)

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

Parameters:

onTerminate - the callback to call on Subscriber.onComplete() or Subscriber.onError(java.lang.Throwable)

Returns:

an observed Flux

doFinally

public final Flux<T> doFinally(Consumer<SignalType> onFinally)

elapsed

public final Flux<Tuple2<Long,T>> elapsed()

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.

Returns:

a transforming Flux that emits tuples of time elapsed in milliseconds and matching data

elapsed

public final Flux<Tuple2<Long,T>> elapsed(TimedScheduler scheduler)

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.

Parameters:

scheduler - the TimedScheduler to read time from

Returns:

a transforming Flux that emits tuples of time elapsed in milliseconds and matching data

elementAt

public final Mono<T> elementAt(int index)

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

Parameters:

index - index of an item

Returns:

a Mono of the item at a specified index

elementAt

public final Mono<T> elementAt(int index,
                               T defaultValue)

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

Parameters:

index - index of an item

defaultValue - supply a default value if not found

Returns:

a Mono of the item at a specified index or a default value

filter

public final Flux<T> filter(Predicate<? super T> p)

Evaluate each accepted value against the given Predicate. 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.

Parameters:

p - the Predicate to test values against

Returns:

a new Flux containing only values that pass the predicate test

firstEmittingWith

public final Flux<T> firstEmittingWith(Publisher<? extends T> other)

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

Parameters:

other - the Publisher to race with

Returns:

the fastest sequence

See Also:

firstEmitting(org.reactivestreams.Publisher<? extends I>...)

flatMap

public final <R> Flux<R> flatMap(Function<? super T,? extends Publisher<? extends R>> mapper)

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.

Type Parameters:

R - the merged output sequence type

Parameters:

mapper - the Function to transform input sequence into N sequences Publisher

Returns:

a new Flux

flatMap

public final <V> Flux<V> flatMap(Function<? super T,? extends Publisher<? extends V>> mapper,
                                 int concurrency)

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.

Type Parameters:

V - the merged output sequence type

Parameters:

mapper - the Function to transform input sequence into N sequences Publisher

concurrency - the maximum in-flight elements from this Flux sequence

Returns:

a new Flux

flatMap

public final <V> Flux<V> flatMap(Function<? super T,? extends Publisher<? extends V>> mapper,
                                 int concurrency,
                                 int prefetch)

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.

Type Parameters:

V - the merged output sequence type

Parameters:

mapper - the Function to transform input sequence into N sequences Publisher

concurrency - the maximum in-flight elements from this Flux sequence

prefetch - the maximum in-flight elements from each inner Publisher sequence

Returns:

a merged Flux

flatMap

public final <V> Flux<V> flatMap(Function<? super T,? extends Publisher<? extends V>> mapper,
                                 boolean delayError,
                                 int concurrency,
                                 int prefetch)

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.

Type Parameters:

V - the merged output sequence type

Parameters:

mapper - the Function to transform input sequence into N sequences Publisher

delayError - should any error be delayed after current merge backlog

concurrency - the maximum in-flight elements from this Flux sequence

prefetch - the maximum in-flight elements from each inner Publisher sequence

Returns:

a merged Flux

flatMap

public final <R> Flux<R> flatMap(Function<? super T,? extends Publisher<? extends R>> mapperOnNext,
                                 Function<Throwable,? extends Publisher<? extends R>> mapperOnError,
                                 Supplier<? extends Publisher<? extends R>> mapperOnComplete)

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.

Type Parameters:

R - the output Publisher type target

Parameters:

mapperOnNext - the Function to call on next data and returning a sequence to merge

mapperOnError - the Function to call on error signal and returning a sequence to merge

mapperOnComplete - the Function to call on complete signal and returning a sequence to merge

Returns:

a new Flux

flatMapIterable

public final <R> Flux<R> flatMapIterable(Function<? super T,? extends Iterable<? extends R>> mapper)

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.

Type Parameters:

R - the merged output sequence type

Parameters:

mapper - the Function to transform input sequence into N sequences Iterable

Returns:

a merged Flux

flatMapIterable

public final <R> Flux<R> flatMapIterable(Function<? super T,? extends Iterable<? extends R>> mapper,
                                         int prefetch)

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.

Type Parameters:

R - the merged output sequence type

Parameters:

mapper - the Function to transform input sequence into N sequences Iterable

prefetch - the maximum in-flight elements from each inner Iterable sequence

Returns:

a merged Flux

flatMapSequential

public final <R> Flux<R> flatMapSequential(Function<? super T,? extends Publisher<? extends R>> mapper)

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.

Type Parameters:

R - the merged output sequence type

Parameters:

mapper - the Function to transform input sequence into N sequences Publisher

Returns:

a merged Flux

flatMapSequential

public final <R> Flux<R> flatMapSequential(Function<? super T,? extends Publisher<? extends R>> mapper,
                                           int maxConcurrency)

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.

Type Parameters:

R - the merged output sequence type

Parameters:

mapper - the Function to transform input sequence into N sequences Publisher

maxConcurrency - the maximum in-flight elements from this Flux sequence

Returns:

a merged Flux

flatMapSequential

public final <R> Flux<R> flatMapSequential(Function<? super T,? extends Publisher<? extends R>> mapper,
                                           int maxConcurrency,
                                           int prefetch)

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.

Type Parameters:

R - the merged output sequence type

Parameters:

mapper - the Function to transform input sequence into N sequences Publisher

maxConcurrency - the maximum in-flight elements from this Flux sequence

prefetch - the maximum in-flight elements from each inner Publisher sequence

Returns:

a merged Flux

flatMapSequential

public final <R> Flux<R> flatMapSequential(Function<? super T,? extends Publisher<? extends R>> mapper,
                                           boolean delayError,
                                           int maxConcurrency,
                                           int prefetch)

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.

Type Parameters:

R - the merged output sequence type

Parameters:

mapper - the Function to transform input sequence into N sequences Publisher

delayError - should any error be delayed after current merge backlog

maxConcurrency - the maximum in-flight elements from this Flux sequence

prefetch - the maximum in-flight elements from each inner Publisher sequence

Returns:

a merged Flux

getPrefetch

public long getPrefetch()

The prefetch configuration of the Flux

Returns:

the prefetch configuration of the Flux, -1L if unspecified

groupBy

public final <K> Flux<GroupedFlux<K,T>> groupBy(Function<? super T,? extends K> keyMapper)

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

Type Parameters:

K - the key type extracted from each value of this sequence

Parameters:

keyMapper - the key mapping Function that evaluates an incoming data and returns a key.

Returns:

a Flux of GroupedFlux grouped sequences

groupBy

public final <K> Flux<GroupedFlux<K,T>> groupBy(Function<? super T,? extends K> keyMapper,
                                                int prefetch)

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

Type Parameters:

K - the key type extracted from each value of this sequence

Parameters:

keyMapper - the key mapping Function that evaluates an incoming data and returns a key.

prefetch - the number of values to prefetch from the source

Returns:

a Flux of GroupedFlux grouped sequences

groupBy

public final <K,V> Flux<GroupedFlux<K,V>> groupBy(Function<? super T,? extends K> keyMapper,
                                                  Function<? super T,? extends V> valueMapper)

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.

Type Parameters:

K - the key type extracted from each value of this sequence

V - the value type extracted from each value of this sequence

Parameters:

keyMapper - the key mapping function that evaluates an incoming data and returns a key.

valueMapper - the value mapping function that evaluates which data to extract for re-routing.

Returns:

a Flux of GroupedFlux grouped sequences

groupBy

public final <K,V> Flux<GroupedFlux<K,V>> groupBy(Function<? super T,? extends K> keyMapper,
                                                  Function<? super T,? extends V> valueMapper,
                                                  int prefetch)

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.

Type Parameters:

K - the key type extracted from each value of this sequence

V - the value type extracted from each value of this sequence

Parameters:

keyMapper - the key mapping function that evaluates an incoming data and returns a key.

valueMapper - the value mapping function that evaluates which data to extract for re-routing.

prefetch - the number of values to prefetch from the source

Returns:

a Flux of GroupedFlux grouped sequences

groupJoin

public final <TRight,TLeftEnd,TRightEnd,R> Flux<R> groupJoin(Publisher<? extends TRight> other,
                                                             Function<? super T,? extends Publisher<TLeftEnd>> leftEnd,
                                                             Function<? super TRight,? extends Publisher<TRightEnd>> rightEnd,
                                                             BiFunction<? super T,? super Flux<TRight>,? extends R> resultSelector)

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 join(org.reactivestreams.Publisher<? extends TRight>, java.util.function.Function<? super T, ? extends org.reactivestreams.Publisher<TLeftEnd>>, java.util.function.Function<? super TRight, ? extends org.reactivestreams.Publisher<TRightEnd>>, java.util.function.BiFunction<? super T, ? super TRight, ? extends R>), items from the right Publisher will be streamed into the right resultSelector argument Flux.

Type Parameters:

TRight - the type of the right Publisher

TLeftEnd - this Flux timeout type

TRightEnd - the right Publisher timeout type

R - the combined result type

Parameters:

other - the other Publisher to correlate items from the source Publisher with

leftEnd - a function that returns a Publisher whose emissions indicate the duration of the values of the source Publisher

rightEnd - a function that returns a Publisher whose emissions indicate the duration of the values of the right Publisher

resultSelector - a function that takes an item emitted by each Publisher and returns the value to be emitted by the resulting Publisher

Returns:

a joining Flux

handle

public final <R> Flux<R> handle(BiConsumer<? super T,SynchronousSink<R>> handler)

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

Type Parameters:

R - the transformed type

Parameters:

handler - the handling BiConsumer

Returns:

a transformed Flux

hasElement

public final Mono<Boolean> hasElement(T value)

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.

Parameters:

value - constant compared to incoming signals

Returns:

a new Flux with true if any value satisfies a predicate and false otherwise

hasElements

public final Mono<Boolean> hasElements()

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.

Returns:

a new Mono with true if any value is emitted and false otherwise

hide

public final Flux<T> hide()

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

Returns:

a new Flux defeating any Publisher / Subscription feature-detection

ignoreElements

public final Mono<T> ignoreElements()

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

Returns:

a new completable Mono.

join

public final <TRight,TLeftEnd,TRightEnd,R> Flux<R> join(Publisher<? extends TRight> other,
                                                        Function<? super T,? extends Publisher<TLeftEnd>> leftEnd,
                                                        Function<? super TRight,? extends Publisher<TRightEnd>> rightEnd,
                                                        BiFunction<? super T,? super TRight,? extends R> resultSelector)

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.

Type Parameters:

TRight - the type of the right Publisher

TLeftEnd - this Flux timeout type

TRightEnd - the right Publisher timeout type

R - the combined result type

Parameters:

other - the other Publisher to correlate items from the source Publisher with

leftEnd - a function that returns a Publisher whose emissions indicate the duration of the values of the source Publisher

rightEnd - a function that returns a Publisher whose emissions indicate the duration of the values of the right Publisher

resultSelector - a function that takes an item emitted by each Publisher and returns the value to be emitted by the resulting Publisher

Returns:

a joining Flux

last

public final Mono<T> last()

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

Returns:

a limited Flux

last

public final Mono<T> last(T defaultValue)

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

Parameters:

defaultValue - a single fallback item if this Flux is empty

Returns:

a limited Flux

limitRate

public final Flux<T> limitRate(int prefetchRate)

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

Parameters:

prefetchRate - the limit to apply to downstream's backpressure

Returns:

a Flux limiting downstream's backpressure

See Also:

publishOn(Scheduler, int)

log

public final Flux<T> log()

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

Returns:

a new unaltered Flux

log

public final Flux<T> log(String category)

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.

Parameters:

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

Returns:

a new unaltered Flux

log

public final Flux<T> log(String category,
                         Level level,
                         SignalType... options)

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)
 

 
 

Parameters:

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

level - the Level to enforce for this tracing Flux (only FINEST, FINE, INFO, WARNING and SEVERE are taken into account)

options - a vararg SignalType option to filter log messages

Returns:

a new unaltered Flux

log

public final Flux<T> log(String category,
                         Level level,
                         boolean showOperatorLine,
                         SignalType... options)

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)

 

Parameters:

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

level - the Level to enforce for this tracing Flux (only FINEST, FINE, INFO, WARNING and SEVERE are taken into account)

showOperatorLine - capture the current stack to display operator class/line number.

options - a vararg SignalType option to filter log messages

Returns:

a new unaltered Flux

map

public final <V> Flux<V> map(Function<? super T,? extends V> mapper)

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

Type Parameters:

V - the transformed type

Parameters:

mapper - the transforming Function

Returns:

a transformed Flux

mapError

public final Flux<T> mapError(Function<? super Throwable,? extends Throwable> mapper)

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

Parameters:

mapper - the error transforming Function

Returns:

a transformed Flux

mapError

public final <E extends Throwable> Flux<T> mapError(Class<E> type,
                                                    Function<? super E,? extends Throwable> mapper)

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

Type Parameters:

E - the error type

Parameters:

type - the class of the exception type to react to

mapper - the error transforming Function

Returns:

a transformed Flux

mapError

public final Flux<T> mapError(Predicate<? super Throwable> predicate,
                              Function<? super Throwable,? extends Throwable> mapper)

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

Parameters:

predicate - the error predicate

mapper - the error transforming Function

Returns:

a transformed Flux

materialize

public final Flux<Signal<T>> materialize()

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.

Returns:

a Flux of materialized Signal

mergeWith

public final Flux<T> mergeWith(Publisher<? extends T> other)

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

Parameters:

other - the Publisher to merge with

Returns:

a new Flux

next

public final Mono<T> next()

Emit only the first item emitted by this Flux.

Returns:

a new Mono

ofType

public final <U> Flux<U> ofType(Class<U> clazz)

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.

Parameters:

clazz - the Class type to test values against

Returns:

a new Flux reduced to items converted to the matched type

onBackpressureBuffer

public final Flux<T> onBackpressureBuffer()

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.

Returns:

a buffering Flux

onBackpressureBuffer

public final Flux<T> onBackpressureBuffer(int maxSize)

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.

Parameters:

maxSize - maximum buffer backlog size before immediate error

Returns:

a buffering Flux

onBackpressureBuffer

public final Flux<T> onBackpressureBuffer(int maxSize,
                                          Consumer<? super T> onOverflow)

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 Consumer will be immediately invoked.

Parameters:

maxSize - maximum buffer backlog size before overflow callback is called

onOverflow - callback to invoke on overflow

Returns:

a buffering Flux

onBackpressureBuffer

public final Flux<T> onBackpressureBuffer(int maxSize,
                                          BufferOverflowStrategy bufferOverflowStrategy)

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.

Parameters:

maxSize - maximum buffer backlog size before overflow strategy is applied

bufferOverflowStrategy - strategy to apply to overflowing elements

Returns:

a buffering Flux

onBackpressureBuffer

public final Flux<T> onBackpressureBuffer(int maxSize,
                                          Consumer<? super T> onBufferOverflow,
                                          BufferOverflowStrategy bufferOverflowStrategy)

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.

Parameters:

maxSize - maximum buffer backlog size before overflow callback is called

onBufferOverflow - callback to invoke on overflow

bufferOverflowStrategy - strategy to apply to overflowing elements

Returns:

a buffering Flux

onBackpressureDrop

public final Flux<T> onBackpressureDrop()

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

Returns:

a dropping Flux

onBackpressureDrop

public final Flux<T> onBackpressureDrop(Consumer<? super T> onDropped)

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.

Parameters:

onDropped - the Consumer called when an value gets dropped due to lack of downstream requests

Returns:

a dropping Flux

onBackpressureError

public final Flux<T> onBackpressureError()

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

Returns:

an erroring Flux on backpressure

onBackpressureLatest

public final Flux<T> onBackpressureLatest()

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

Returns:

a dropping Flux that will only keep a reference to the last observed item

onErrorResumeWith

public final Flux<T> onErrorResumeWith(Function<? super Throwable,? extends Publisher<? extends T>> fallback)

Subscribe to a returned fallback publisher when any error occurs.

Parameters:

fallback - the Function mapping the error to a new Publisher sequence

Returns:

a new Flux

onErrorResumeWith

public final <E extends Throwable> Flux<T> onErrorResumeWith(Class<E> type,
                                                             Function<? super E,? extends Publisher<? extends T>> fallback)

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

Type Parameters:

E - the error type

Parameters:

type - the error type to match

fallback - the Function mapping the error to a new Publisher sequence

Returns:

a new Flux

onErrorResumeWith

public final Flux<T> onErrorResumeWith(Predicate<? super Throwable> predicate,
                                       Function<? super Throwable,? extends Publisher<? extends T>> fallback)

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

Parameters:

predicate - the error predicate to match

fallback - the Function mapping the error to a new Publisher sequence

Returns:

a new Flux

onErrorReturn

public final Flux<T> onErrorReturn(T fallbackValue)

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

Parameters:

fallbackValue - alternate value on fallback

Returns:

a new Flux

onErrorReturn

public final <E extends Throwable> Flux<T> onErrorReturn(Class<E> type,
                                                         T fallbackValue)

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

Type Parameters:

E - the error type

Parameters:

type - the error type to match

fallbackValue - alternate value on fallback

Returns:

a new Flux

onErrorReturn

public final <E extends Throwable> Flux<T> onErrorReturn(Predicate<? super Throwable> predicate,
                                                         T fallbackValue)

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

Type Parameters:

E - the error type

Parameters:

predicate - the error predicate to match

fallbackValue - alternate value on fallback

Returns:

a new Flux

onTerminateDetach

public final Flux<T> onTerminateDetach()

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.

Returns:

a detachable Flux

parallel

public final ParallelFlux<T> parallel()

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

Returns:

a new ParallelFlux instance

parallel

public final ParallelFlux<T> parallel(int parallelism)

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

Parameters:

parallelism - the number of parallel rails

Returns:

a new ParallelFlux instance

parallel

public final ParallelFlux<T> parallel(int parallelism,
                                      int prefetch)

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.

Parameters:

parallelism - the number of parallel rails

prefetch - the number of values to prefetch from the source

Returns:

a new ParallelFlux instance

publish

public final ConnectableFlux<T> publish()

Prepare a ConnectableFlux which shares this Flux sequence and dispatches values to subscribers in a backpressure-aware manner. Prefetch will default to QueueSupplier.SMALL_BUFFER_SIZE. This will effectively turn any type of sequence into a hot sequence.

Backpressure will be coordinated on Subscription.request(long) and if any Subscriber is missing demand (requested = 0), multicast will pause pushing/pulling.

Returns:

a new ConnectableFlux

publish

public final ConnectableFlux<T> publish(int prefetch)

Prepare a ConnectableFlux which shares this Flux sequence and dispatches values to subscribers in a backpressure-aware manner. This will effectively turn any type of sequence into a hot sequence.

Backpressure will be coordinated on Subscription.request(long) and if any Subscriber is missing demand (requested = 0), multicast will pause pushing/pulling.

Parameters:

prefetch - bounded requested demand

Returns:

a new ConnectableFlux

publish

public final <R> Flux<R> publish(Function<? super Flux<T>,? extends Publisher<? extends R>> transform)

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.

Type Parameters:

R - the output value type

Parameters:

transform - the transformation function

Returns:

a new Flux

publish

public final <R> Flux<R> publish(Function<? super Flux<T>,? extends Publisher<? extends R>> transform,
                                 int prefetch)

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.

Type Parameters:

R - the output value type

Parameters:

transform - the transformation function

prefetch - the request size

Returns:

a new Flux

publishNext

public final Mono<T> publishNext()

Prepare a Mono which shares this Flux sequence and dispatches the first observed item to subscribers in a backpressure-aware manner. This will effectively turn any type of sequence into a hot sequence when the first Subscriber subscribes.

Returns:

a new Mono

publishOn

public final Flux<T> publishOn(Scheduler scheduler)

Run onNext, onComplete and onError on a supplied Scheduler Scheduler.Worker.

Typically used for fast publisher, slow consumer(s) scenarios.

flux.publishOn(Schedulers.single()).subscribe()

Parameters:

scheduler - a checked Scheduler.Worker factory

Returns:

a Flux producing asynchronously

publishOn

public final Flux<T> publishOn(Scheduler scheduler,
                               int prefetch)

Run onNext, onComplete and onError on a supplied Scheduler Scheduler.Worker.

Typically used for fast publisher, slow consumer(s) scenarios.

flux.publishOn(Schedulers.single()).subscribe()

Parameters:

scheduler - a checked Scheduler.Worker factory

prefetch - the asynchronous boundary capacity

Returns:

a Flux producing asynchronously

publishOn

public final Flux<T> publishOn(Scheduler scheduler,
                               boolean delayError,
                               int prefetch)

Run onNext, onComplete and onError on a supplied Scheduler Scheduler.Worker.

Typically used for fast publisher, slow consumer(s) scenarios.

flux.publishOn(Schedulers.single()).subscribe()

Parameters:

scheduler - a checked Scheduler.Worker factory

delayError - should the buffer be consumed before forwarding any error

prefetch - the asynchronous boundary capacity

Returns:

a Flux producing asynchronously

reduce

public final Mono<T> reduce(BiFunction<T,T,T> aggregator)

Aggregate the values from this Flux sequence into an object of the same type than the emitted items. The left/right BiFunction arguments are the N-1 and N item, ignoring sequence with 0 or 1 element only.

Parameters:

aggregator - the aggregating BiFunction

Returns:

a reduced Flux

reduce

public final <A> Mono<A> reduce(A initial,
                                BiFunction<A,? super T,A> accumulator)

Accumulate the values from this Flux sequence into an object matching an initial value type. The arguments are the N-1 or initial value and N current item .

Type Parameters:

A - the type of the initial and reduced object

Parameters:

accumulator - the reducing BiFunction

initial - the initial left argument to pass to the reducing BiFunction

Returns:

a reduced Flux

reduceWith

public final <A> Mono<A> reduceWith(Supplier<A> initial,
                                    BiFunction<A,? super T,A> accumulator)

Accumulate the values from this Flux sequence into an object matching an initial value type. The arguments are the N-1 or initial value and N current item .

Type Parameters:

A - the type of the initial and reduced object

Parameters:

accumulator - the reducing BiFunction

initial - the initial left argument supplied on subscription to the reducing BiFunction

Returns:

a reduced Flux

repeat

public final Flux<T> repeat()

Repeatedly subscribe to the source completion of the previous subscription.

Returns:

an indefinitely repeated Flux on onComplete

repeat

public final Flux<T> repeat(BooleanSupplier predicate)

Repeatedly subscribe to the source if the predicate returns true after completion of the previous subscription.

Parameters:

predicate - the boolean to evaluate on onComplete.

Returns:

an eventually repeated Flux on onComplete

repeat

public final Flux<T> repeat(long numRepeat)

Repeatedly subscribe to the source if the predicate returns true after completion of the previous subscription.

Parameters:

numRepeat - the number of times to re-subscribe on onComplete

Returns:

an eventually repeated Flux on onComplete up to number of repeat specified

repeat

public final Flux<T> repeat(long numRepeat,
                            BooleanSupplier predicate)

Repeatedly subscribe to the source if the predicate returns true after completion of the previous subscription. A specified maximum of repeat will limit the number of re-subscribe.

Parameters:

numRepeat - the number of times to re-subscribe on complete

predicate - the boolean to evaluate on onComplete

Returns:

an eventually repeated Flux on onComplete up to number of repeat specified OR matching predicate

repeatWhen

public final Flux<T> repeatWhen(Function<Flux<Long>,? extends Publisher<?>> whenFactory)

Repeatedly subscribe to this Flux when a companion sequence signals a number of emitted elements in response to the flux completion signal.

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

Parameters:

whenFactory - the Function providing a Flux signalling an exclusive number of emitted elements on onComplete and returning a Publisher companion.

Returns:

an eventually repeated Flux on onComplete when the companion Publisher produces an onNext signal

replay

public final ConnectableFlux<T> replay()

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

Returns:

a replaying ConnectableFlux

replay

public final ConnectableFlux<T> replay(int history)

Turn this Flux into a connectable 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.

Parameters:

history - number of events retained in history excluding complete and error

Returns:

a replaying ConnectableFlux

replay

public final ConnectableFlux<T> replay(Duration ttl)

Turn this Flux into a connectable hot source and cache last emitted signals for further Subscriber. Will retain each onNext up to the given per-item expiry timeout. Completion and Error will also be replayed.

Parameters:

ttl - Per-item timeout duration

Returns:

a replaying ConnectableFlux

replay

public final ConnectableFlux<T> replay(int history,
                                       Duration ttl)

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

Parameters:

history - number of events retained in history excluding complete and error

ttl - Per-item timeout duration

Returns:

a replaying ConnectableFlux

replayMillis

public final ConnectableFlux<T> replayMillis(long ttl,
                                             TimedScheduler timer)

Turn this Flux into a connectable 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.

Parameters:

ttl - Per-item timeout duration in milliseconds

timer - TimedScheduler to read current time from

Returns:

a replaying ConnectableFlux

replayMillis

public final ConnectableFlux<T> replayMillis(int history,
                                             long ttl,
                                             TimedScheduler timer)

Turn this Flux into a connectable 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.

Parameters:

history - number of events retained in history excluding complete and error

ttl - Per-item timeout duration in milliseconds

timer - TimedScheduler to read current time from

Returns:

a replaying ConnectableFlux

retry

public final Flux<T> retry()

Re-subscribes to this Flux sequence if it signals any error either indefinitely.

The times == Long.MAX_VALUE is treated as infinite retry.

Returns:

a re-subscribing Flux on onError

retry

public final Flux<T> retry(long numRetries)

Re-subscribes to this Flux sequence if it signals any error either indefinitely or a fixed number of times.

The times == Long.MAX_VALUE is treated as infinite retry.

Parameters:

numRetries - the number of times to tolerate an error

Returns:

a re-subscribing Flux on onError up to the specified number of retries.

retry

public final Flux<T> retry(Predicate<Throwable> retryMatcher)

Re-subscribes to this Flux sequence if it signals any error and the given Predicate matches otherwise push the error downstream.

Parameters:

retryMatcher - the predicate to evaluate if retry should occur based on a given error signal

Returns:

a re-subscribing Flux on onError if the predicates matches.

retry

public final Flux<T> retry(long numRetries,
                           Predicate<Throwable> retryMatcher)

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.

Parameters:

numRetries - the number of times to tolerate an error

retryMatcher - the predicate to evaluate if retry should occur based on a given error signal

Returns:

a re-subscribing Flux on onError up to the specified number of retries and if the predicate matches.

retryWhen

public final Flux<T> retryWhen(Function<Flux<Throwable>,? extends Publisher<?>> whenFactory)

Retries this Flux when a companion sequence signals an item in response to this Flux error signal

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

Parameters:

whenFactory - the Function providing a Flux signalling any error from the source sequence and returning a Publisher companion.

Returns:

a re-subscribing Flux on onError when the companion Publisher produces an onNext signal

sample

public final Flux<T> sample(Duration timespan)

Emit latest value for every given period of time.

Parameters:

timespan - the duration to emit the latest observed item

Returns:

a sampled Flux by last item over a period of time

sample

public final <U> Flux<T> sample(Publisher<U> sampler)

Sample this Flux and emit its latest value whenever the sampler Publisher signals a value.

Termination of either Publisher will result in termination for the Subscriber as well.

Both Publisher will run in unbounded mode because the backpressure would interfere with the sampling precision.

Type Parameters:

U - the type of the sampler sequence

Parameters:

sampler - the sampler Publisher

Returns:

a sampled Flux by last item observed when the sampler Publisher signals

sampleFirst

public final Flux<T> sampleFirst(Duration timespan)

Take a value from this Flux then use the duration provided to skip other values.

Parameters:

timespan - the duration to exclude others values from this sequence

Returns:

a sampled Flux by first item over a period of time

sampleFirst

public final <U> Flux<T> sampleFirst(Function<? super T,? extends Publisher<U>> samplerFactory)

Take a value from this Flux then use the duration provided by a generated Publisher to skip other values until that sampler Publisher signals.

Type Parameters:

U - the companion reified type

Parameters:

samplerFactory - select a Publisher companion to signal onNext or onComplete to stop excluding others values from this sequence

Returns:

a sampled Flux by last item observed when the sampler signals

sampleFirstMillis

public final Flux<T> sampleFirstMillis(long timespan)

Take a value from this Flux then use the duration provided to skip other values.

Parameters:

timespan - the period in milliseconds to exclude others values from this sequence

Returns:

a sampled Flux by first item over a period of time

sampleMillis

public final Flux<T> sampleMillis(long timespan)

Emit latest value for every given period of ti,e.

Parameters:

timespan - the period in second to emit the latest observed item

Returns:

a sampled Flux by last item over a period of time

sampleTimeout

public final <U> Flux<T> sampleTimeout(Function<? super T,? extends Publisher<U>> throttlerFactory)

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.

Type Parameters:

U - the companion reified type

Parameters:

throttlerFactory - select a Publisher companion to signal onNext or onComplete to stop checking others values from this sequence and emit the selecting item

Returns:

a sampled Flux by last single item observed before a companion Publisher emits

sampleTimeout

public final <U> Flux<T> sampleTimeout(Function<? super T,? extends Publisher<U>> throttlerFactory,
                                       int maxConcurrency)

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.

The provided maxConcurrency will keep a bounded maximum of concurrent timeouts and drop any new items until at least one timeout terminates.

Type Parameters:

U - the throttling type

Parameters:

throttlerFactory - select a Publisher companion to signal onNext or onComplete to stop checking others values from this sequence and emit the selecting item

maxConcurrency - the maximum number of concurrent timeouts

Returns:

a sampled Flux by last single item observed before a companion Publisher emits

scan

public final Flux<T> scan(BiFunction<T,T,T> accumulator)

Accumulate this Flux values with an accumulator BiFunction and returns the intermediate results of this function.

Unlike scan(Object, BiFunction), this operator doesn't take an initial value but treats the first Flux value as initial value.
The accumulation works as follows:

 result[0] = accumulator(source[0], source[1])
 result[1] = accumulator(result[0], source[2])
 result[2] = accumulator(result[1], source[3])
 ...
 

Parameters:

accumulator - the accumulating BiFunction

Returns:

an accumulating Flux

scan

public final <A> Flux<A> scan(A initial,
                              BiFunction<A,? super T,A> accumulator)

Aggregate this Flux values with the help of an accumulator BiFunction and emits the intermediate results.

The accumulation works as follows:

 result[0] = initialValue;
 result[1] = accumulator(result[0], source[0])
 result[2] = accumulator(result[1], source[1])
 result[3] = accumulator(result[2], source[2])
 ...
 

Type Parameters:

A - the accumulated type

Parameters:

initial - the initial argument to pass to the reduce function

accumulator - the accumulating BiFunction

Returns:

an accumulating Flux starting with initial state

scanWith

public final <A> Flux<A> scanWith(Supplier<A> initial,
                                  BiFunction<A,? super T,A> accumulator)

Aggregate this Flux values with the help of an accumulator BiFunction and emits the intermediate results.

The accumulation works as follows:

 result[0] = initialValue;
 result[1] = accumulator(result[0], source[0])
 result[2] = accumulator(result[1], source[1])
 result[3] = accumulator(result[2], source[2])
 ...
 

Type Parameters:

A - the accumulated type

Parameters:

initial - the initial supplier to init the first value to pass to the reduce function

accumulator - the accumulating BiFunction

Returns:

an accumulating Flux starting with initial state

share

public final Flux<T> share()

Returns a new Flux that multicasts (shares) the original Flux. As long as there is at least one Subscriber this Flux will be subscribed and emitting data. When all subscribers have cancelled it will cancel the source Flux.

This is an alias for publish().ConnectableFlux.refCount().

Returns:

a Flux that upon first subcribe causes the source Flux to subscribe once only, late subscribers might therefore miss items.

single

public final Mono<T> single()

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.

Returns:

a Mono with the eventual single item or an error signal

single

public final Mono<T> single(T defaultValue)

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.

Parameters:

defaultValue - a single fallback item if this Flux is empty

Returns:

a Mono with the eventual single item or a supplied default value

singleOrEmpty

public final Mono<T> singleOrEmpty()

Expect and emit a zero or single item from this Flux source or IndexOutOfBoundsException for a multi-item source.

Returns:

a Mono with the eventual single item or no item

skip

public final Flux<T> skip(long skipped)

Skip next the specified number of elements from this Flux.

Parameters:

skipped - the number of times to drop

Returns:

a dropping Flux until the specified skipped number of elements

skip

public final Flux<T> skip(Duration timespan)

Skip elements from this Flux for the given time period.

Parameters:

timespan - the time window to exclude next signals

Returns:

a dropping Flux until the end of the given timespan

skipLast

public final Flux<T> skipLast(int n)

Skip the last specified number of elements from this Flux.

Parameters:

n - the number of elements to ignore before completion

Returns:

a dropping Flux for the specified skipped number of elements before termination

skipMillis

public final Flux<T> skipMillis(long timespan)

Skip elements from this Flux for the given time period.

Parameters:

timespan - the time window to exclude next signals

Returns:

a dropping Flux until the end of the given timespan

skipMillis

public final Flux<T> skipMillis(long timespan,
                                TimedScheduler timer)

Skip elements from this Flux for the given time period.

Parameters:

timespan - the time window to exclude next signals

timer - the TimedScheduler to run on

Returns:

a dropping Flux until the end of the given timespan

skipUntil

public final Flux<T> skipUntil(Predicate<? super T> untilPredicate)

Skips values from this Flux until a Predicate returns true for the value. Will include the matched value.

Parameters:

untilPredicate - the Predicate evaluating to true to stop skipping.

Returns:

a dropping Flux until the Predicate matches

skipUntilOther

public final Flux<T> skipUntilOther(Publisher<?> other)

Skip values from this Flux until a specified Publisher signals an onNext or onComplete.

Parameters:

other - the Publisher companion to coordinate with to stop skipping

Returns:

a dropping Flux until the other Publisher emits

skipWhile

public final Flux<T> skipWhile(Predicate<? super T> skipPredicate)

Skips values from this Flux while a Predicate returns true for the value.

Parameters:

skipPredicate - the Predicate evaluating to true to keep skipping.

Returns:

a dropping Flux while the Predicate matches

sort

public final Flux<T> sort()

Returns a Flux that sorts the events emitted by source Flux. Each item emitted by the Flux must implement Comparable with respect to all other items in the sequence.

Note that calling sort with long, non-terminating or infinite sources might cause OutOfMemoryError. Use sequence splitting like window() to sort batches in that case.

Returns:

a sorting Flux

Throws:

ClassCastException - if any item emitted by the Flux does not implement Comparable with respect to all other items emitted by the Flux

sort

public final Flux<T> sort(Comparator<? super T> sortFunction)

Returns a Flux that sorts the events emitted by source Flux given the Comparator function.

Note that calling sorted with long, non-terminating or infinite sources might cause OutOfMemoryError

Parameters:

sortFunction - a function that compares two items emitted by this Flux that indicates their sort order

Returns:

a sorting Flux

startWith

public final Flux<T> startWith(Iterable<? extends T> iterable)

Prepend the given Iterable before this Flux sequence.

Parameters:

iterable - the sequence of values to start the sequence with

Returns:

a prefixed Flux with given Iterable

startWith

@SafeVarargs
public final Flux<T> startWith(T... values)

Prepend the given values before this Flux sequence.

Parameters:

values - the array of values to start with

Returns:

a prefixed Flux with given values

startWith

public final Flux<T> startWith(Publisher<? extends T> publisher)

Prepend the given Publisher sequence before this Flux sequence.

Parameters:

publisher - the Publisher whose values to prepend

Returns:

a prefixed Flux with given Publisher sequence

subscribe

public final Disposable subscribe()

Start the chain and request unbounded demand.

Returns:

a Disposable task to execute to dispose and cancel the underlying Subscription

subscribe

@Deprecated
public final Disposable subscribe(int prefetch)

Deprecated. use limitRate(int)

Start the chain and request prefetch demand

For a version that gives you more control over backpressure and the request, see Publisher.subscribe(Subscriber) with a BaseSubscriber.

Parameters:

prefetch - an arbitrary value

Returns:

a Disposable task to execute to dispose and cancel the underlying Subscription

subscribe

public final Disposable subscribe(Consumer<? super T> consumer)

Subscribe a Consumer to this Flux that will consume all the sequence. It will request an unbounded demand.

For a passive version that observe and forward incoming data see doOnNext(java.util.function.Consumer).

For a version that gives you more control over backpressure and the request, see Publisher.subscribe(Subscriber) with a BaseSubscriber.

Parameters:

consumer - the consumer to invoke on each value

Returns:

a new Disposable to dispose the Subscription

subscribe

public final Disposable subscribe(Consumer<? super T> consumer,
                                  int prefetch)

Subscribe a Consumer to this Flux that will consume all the sequence.

If prefetch is != Long.MAX_VALUE, the Subscriber will use it as a prefetch strategy: first request N, then when 25% of N is left to be received on onNext, request N x 0.75.

For a passive version that observe and forward incoming data see doOnNext(java.util.function.Consumer).

For a version that gives you more control over backpressure and the request, see Publisher.subscribe(Subscriber) with a BaseSubscriber.

Parameters:

consumer - the consumer to invoke on each value

prefetch - the the prefetch amount, positive

Returns:

a new Disposable to dispose the Subscription

subscribe

public final Disposable subscribe(Consumer<? super T> consumer,
                                  Consumer<? super Throwable> errorConsumer)

Subscribe Consumer to this Flux that will consume all the sequence. It will request unbounded demand Long.MAX_VALUE. For a passive version that observe and forward incoming data see doOnNext(java.util.function.Consumer) and doOnError(java.util.function.Consumer).

For a version that gives you more control over backpressure and the request, see Publisher.subscribe(Subscriber) with a BaseSubscriber.

Parameters:

consumer - the consumer to invoke on each next signal

errorConsumer - the consumer to invoke on error signal

Returns:

a new Disposable to dispose the Subscription

subscribe

public final Disposable subscribe(Consumer<? super T> consumer,
                                  Consumer<? super Throwable> errorConsumer,
                                  Runnable completeConsumer)

Subscribe Consumer to this Flux that will consume all the sequence. It will request unbounded demand Long.MAX_VALUE. For a passive version that observe and forward incoming data see doOnNext(java.util.function.Consumer), doOnError(java.util.function.Consumer) and doOnComplete(Runnable).

For a version that gives you more control over backpressure and the request, see Publisher.subscribe(Subscriber) with a BaseSubscriber.

Parameters:

consumer - the consumer to invoke on each value

errorConsumer - the consumer to invoke on error signal

completeConsumer - the consumer to invoke on complete signal

Returns:

a new Disposable to dispose the Subscription

subscribe

public final Disposable subscribe(Consumer<? super T> consumer,
                                  Consumer<? super Throwable> errorConsumer,
                                  Runnable completeConsumer,
                                  Consumer<? super Subscription> subscriptionConsumer)

Subscribe Consumer to this Flux that will consume all the sequence. It will let the provided subscriptionConsumer request the adequate amount of data, or request unbounded demand Long.MAX_VALUE if no such consumer is provided.

For a passive version that observe and forward incoming data see doOnNext(java.util.function.Consumer), doOnError(java.util.function.Consumer), doOnComplete(Runnable) and doOnSubscribe(Consumer).

For a version that gives you more control over backpressure and the request, see Publisher.subscribe(Subscriber) with a BaseSubscriber.

Parameters:

consumer - the consumer to invoke on each value

errorConsumer - the consumer to invoke on error signal

completeConsumer - the consumer to invoke on complete signal

subscriptionConsumer - the consumer to invoke on subscribe signal, to be used for the initial request, or null for max request

Returns:

a new Disposable to dispose the Subscription

subscribe

@Deprecated
public final Disposable subscribe(Consumer<? super T> consumer,
                                              Consumer<? super Throwable> errorConsumer,
                                              Runnable completeConsumer,
                                              int prefetch)

Deprecated. prefer using limitRate(prefetch).subscribe(...) to subscribe(..., prefetch)

Subscribe Consumer to this Flux that will consume all the sequence.

If prefetch is != Long.MAX_VALUE, the Subscriber will use it as a prefetch strategy: first request N, then when 25% of N is left to be received on onNext, request N x 0.75.

For a passive version that observe and forward incoming data see doOnNext(java.util.function.Consumer), doOnError(java.util.function.Consumer), doOnComplete(Runnable) and doOnSubscribe(Consumer).

For a version that gives you more control over backpressure and the request, see Publisher.subscribe(Subscriber) with a BaseSubscriber.

Parameters:

consumer - the consumer to invoke on each value

errorConsumer - the consumer to invoke on error signal

completeConsumer - the consumer to invoke on complete signal

prefetch - the demand to produce to this Flux

Returns:

a new Disposable to dispose the Subscription

See Also:

limitRate(int), subscribe(Consumer, Consumer, Runnable)

subscribe

@Deprecated
public final Disposable subscribe(Consumer<? super T> consumer,
                                              Consumer<? super Throwable> errorConsumer,
                                              Runnable completeConsumer,
                                              Consumer<? super Subscription> subscriptionConsumer,
                                              int prefetch)

Deprecated. prefer using limitRate(prefetch).subscribe(...) to subscribe(..., prefetch)

Subscribe Consumer to this Flux that will consume all the sequence.

If prefetch is != Long.MAX_VALUE, the Subscriber will use it as a prefetch strategy: first request N, then when 25% of N is left to be received on onNext, request N x 0.75.

For a passive version that observe and forward incoming data see doOnNext(java.util.function.Consumer), doOnError(java.util.function.Consumer) and doOnComplete(Runnable).

For a version that gives you more control over backpressure and the request, see Publisher.subscribe(Subscriber) with a BaseSubscriber.

Parameters:

consumer - the consumer to invoke on each value

errorConsumer - the consumer to invoke on error signal

completeConsumer - the consumer to invoke on complete signal

subscriptionConsumer - the consumer to invoke on subscribe signal, to be used for the initial request, or null for max request

prefetch - the demand to produce to this Flux (deprecated)

Returns:

a new Disposable to dispose the Subscription

See Also:

limitRate(int), subscribe(Consumer, Consumer, Runnable, Consumer)

subscribeOn

public final Flux<T> subscribeOn(Scheduler scheduler)

Run subscribe, onSubscribe and request on a supplied Scheduler

Typically used for slow publisher e.g., blocking IO, fast consumer(s) scenarios.

flux.subscribeOn(Schedulers.single()).subscribe()

Parameters:

scheduler - a checked Scheduler.Worker factory

Returns:

a Flux requesting asynchronously

subscribeWith

public final <E extends Subscriber<? super T>> E subscribeWith(E subscriber)

A chaining Publisher.subscribe(Subscriber) alternative to inline composition type conversion to a hot emitter (e.g. FluxProcessor or MonoProcessor). flux.subscribeWith(WorkQueueProcessor.create()).subscribe()

If you need more control over backpressure and the request, use a BaseSubscriber.

Type Parameters:

E - the reified type from the input/output subscriber

Parameters:

subscriber - the Subscriber to subscribe and return

Returns:

the passed Subscriber

switchIfEmpty

public final Flux<T> switchIfEmpty(Publisher<? extends T> alternate)

Provide an alternative if this sequence is completed without any data

Parameters:

alternate - the alternate publisher if this sequence is empty

Returns:

an alternating Flux on source onComplete without elements

switchMap

public final <V> Flux<V> switchMap(Function<? super T,Publisher<? extends V>> fn)

Switch to a new Publisher generated via a Function whenever this Flux produces an item.

Type Parameters:

V - the type of the return value of the transformation function

Parameters:

fn - the transformation function

Returns:

an alternating Flux on source onNext

switchMap

public final <V> Flux<V> switchMap(Function<? super T,Publisher<? extends V>> fn,
                                   int prefetch)

Switch to a new Publisher generated via a Function whenever this Flux produces an item.

Type Parameters:

V - the type of the return value of the transformation function

Parameters:

fn - the transformation function

prefetch - the produced demand for inner sources

Returns:

an alternating Flux on source onNext

switchOnError

public final <E extends Throwable> Flux<T> switchOnError(Class<E> type,
                                                         Publisher<? extends T> fallback)

Subscribe to the given fallback Publisher if an error matching the given type is observed on this Flux

Type Parameters:

E - the error type

Parameters:

type - the error type to match to fallback

fallback - the alternate Publisher

Returns:

an alternating Flux on source onError

switchOnError

public final Flux<T> switchOnError(Predicate<? super Throwable> predicate,
                                   Publisher<? extends T> fallback)

Subscribe to the given fallback Publisher if an error matching the given predicate is observed on this Flux

Parameters:

predicate - the predicate to match an error

fallback - the alternate Publisher

Returns:

an alternating Flux on source onError

switchOnError

public final Flux<T> switchOnError(Publisher<? extends T> fallback)

Subscribe to the given fallback Publisher if an error is observed on this Flux

Parameters:

fallback - the alternate Publisher

Returns:

an alternating Flux on source onError

take

public final Flux<T> take(long n)

Take only the first N values from this Flux.

If N is zero, the Subscriber gets completed if this Flux completes, signals an error or signals its first value (which is not not relayed though).

Parameters:

n - the number of items to emit from this Flux

Returns:

a size limited Flux

take

public final Flux<T> take(Duration timespan)

Relay values from this Flux until the given time period elapses.

If the time period is zero, the Subscriber gets completed if this Flux completes, signals an error or signals its first value (which is not not relayed though).

Parameters:

timespan - the time window of items to emit from this Flux

Returns:

a time limited Flux

takeLast

public final Flux<T> takeLast(int n)

Emit the last N values this Flux emitted before its completion.

Parameters:

n - the number of items from this Flux to retain and emit on onComplete

Returns:

a terminating Flux sub-sequence

takeMillis

public final Flux<T> takeMillis(long timespan)

Relay values from this Flux until the given time period elapses.

If the time period is zero, the Subscriber gets completed if this Flux completes, signals an error or signals its first value (which is not not relayed though).

Parameters:

timespan - the time window of items to emit from this Flux

Returns:

a time limited Flux

takeMillis

public final Flux<T> takeMillis(long timespan,
                                TimedScheduler timer)

Relay values from this Flux until the given time period elapses.

If the time period is zero, the Subscriber gets completed if this Flux completes, signals an error or signals its first value (which is not not relayed though).

Parameters:

timespan - the time window of items to emit from this Flux

timer - the TimedScheduler to run on

Returns:

a time limited Flux

takeUntil

public final Flux<T> takeUntil(Predicate<? super T> predicate)

Relay values from this Flux until the given Predicate matches. Unlike takeWhile(java.util.function.Predicate<? super T>), this will include the matched data.

Parameters:

predicate - the Predicate to signal when to stop replaying signal from this Flux

Returns:

an eventually limited Flux

takeUntilOther

public final Flux<T> takeUntilOther(Publisher<?> other)

Relay values from this Flux until the given Publisher emits.

Parameters:

other - the Publisher to signal when to stop replaying signal from this Flux

Returns:

an eventually limited Flux

takeWhile

public final Flux<T> takeWhile(Predicate<? super T> continuePredicate)

Relay values while a predicate returns TRUE for the values (checked before each value is delivered). Unlike takeUntil(java.util.function.Predicate<? super T>), this will exclude the matched data.

Parameters:

continuePredicate - the Predicate invoked each onNext returning FALSE to terminate

Returns:

an eventually limited Flux

then

public final Mono<Void> then()

Return a Mono<Void> that completes when this Flux completes. This will actively ignore the sequence and only replay completion or error signals.

Returns:

a new Mono

then

@Deprecated
public final Mono<Void> then(Publisher<Void> other)

Deprecated. use thenEmpty(Publisher) instead, this alias will be removed in 3.1.0

Return a Mono<Void> that waits for this Flux to complete then for a supplied Publisher<Void> to also complete. The second completion signal is replayed, or any error signal that occurs instead.

Parameters:

other - a Publisher to wait for after this Flux's termination

Returns:

a new Mono completing when both publishers have completed in sequence

thenEmpty

public final Mono<Void> thenEmpty(Publisher<Void> other)

Return a Mono<Void> that waits for this Flux to complete then for a supplied Publisher<Void> to also complete. The second completion signal is replayed, or any error signal that occurs instead.

Parameters:

other - a Publisher to wait for after this Flux's termination

Returns:

a new Mono completing when both publishers have completed in sequence

then

public final Mono<Void> then(Supplier<? extends Publisher<Void>> afterSupplier)

Return a Flux that emits the completion signal of the supplied Publisher when this Flux onComplete or onError. If an error occur, the error signal is replayed after the supplied Publisher is terminated.

Parameters:

afterSupplier - a Supplier of Publisher to wait for after this Flux termination

Returns:

a new Flux emitting eventually from the supplied Publisher

thenMany

public final <V> Flux<V> thenMany(Publisher<V> other)

Return a Flux that emits the sequence of the supplied Publisher after this Flux completes, ignoring this flux elements. If an error occurs it immediately terminates the resulting flux.

Type Parameters:

V - the supplied produced type

Parameters:

other - a Publisher to emit from after termination

Returns:

a new Flux emitting eventually from the supplied Publisher

thenMany

public final <V> Flux<V> thenMany(Supplier<? extends Publisher<V>> afterSupplier)

Return a Flux that emits the sequence of the supplied Publisher after this Flux completes, ignoring this flux elements. If an error occurs it immediately terminates the resulting flux.

Type Parameters:

V - the supplied produced type

Parameters:

afterSupplier - a Supplier of Publisher to emit from after termination

Returns:

a new Flux emitting eventually from the supplied Publisher

timeout

public final Flux<T> timeout(Duration timeout)

Signal a TimeoutException in case a per-item period fires before the next item arrives from this Flux.

Parameters:

timeout - the timeout between two signals from this Flux

Returns:

a per-item expirable Flux

timeout

public final Flux<T> timeout(Duration timeout,
                             Publisher<? extends T> fallback)

Switch to a fallback Publisher in case a per-item period fires before the next item arrives from this Flux.

If the given Publisher is null, signal a TimeoutException.

Parameters:

timeout - the timeout between two signals from this Flux

fallback - the fallback Publisher to subscribe when a timeout occurs

Returns:

a per-item expirable Flux with a fallback Publisher

timeout

public final <U> Flux<T> timeout(Publisher<U> firstTimeout)

Signal a TimeoutException in case a first item from this Flux has not been emitted before the given Publisher emits.

Type Parameters:

U - the type of the timeout Publisher

Parameters:

firstTimeout - the timeout Publisher that must not emit before the first signal from this Flux

Returns:

an expirable Flux if the first item does not come before a Publisher signal

timeout

public final <U,V> Flux<T> timeout(Publisher<U> firstTimeout,
                                   Function<? super T,? extends Publisher<V>> nextTimeoutFactory)

Signal a TimeoutException in case a first item from this Flux has not been emitted before the given Publisher emits. The following items will be individually timed via the factory provided Publisher.

Type Parameters:

U - the type of the elements of the first timeout Publisher

V - the type of the elements of the subsequent timeout Publishers

Parameters:

firstTimeout - the timeout Publisher that must not emit before the first signal from this Flux

nextTimeoutFactory - the timeout Publisher factory for each next item

Returns:

a first then per-item expirable Flux

timeout

public final <U,V> Flux<T> timeout(Publisher<U> firstTimeout,
                                   Function<? super T,? extends Publisher<V>> nextTimeoutFactory,
                                   Publisher<? extends T> fallback)

Switch to a fallback Publisher in case a first item from this Flux has not been emitted before the given Publisher emits. The following items will be individually timed via the factory provided Publisher.

Type Parameters:

U - the type of the elements of the first timeout Publisher

V - the type of the elements of the subsequent timeout Publishers

Parameters:

firstTimeout - the timeout Publisher that must not emit before the first signal from this Flux

nextTimeoutFactory - the timeout Publisher factory for each next item

fallback - the fallback Publisher to subscribe when a timeout occurs

Returns:

a first then per-item expirable Flux with a fallback Publisher

timeoutMillis

public final Flux<T> timeoutMillis(long timeout)

Signal a TimeoutException error in case a per-item period in milliseconds fires before the next item arrives from this Flux.

Parameters:

timeout - the timeout in milliseconds between two signals from this Flux

Returns:

a per-item expirable Flux

timeoutMillis

public final Flux<T> timeoutMillis(long timeout,
                                   TimedScheduler timer)

Signal a TimeoutException error in case a per-item period in milliseconds fires before the next item arrives from this Flux.

Parameters:

timeout - the timeout in milliseconds between two signals from this Flux

timer - the TimedScheduler to run on

Returns:

a per-item expirable Flux

timeoutMillis

public final Flux<T> timeoutMillis(long timeout,
                                   Publisher<? extends T> fallback)

Switch to a fallback Publisher in case a per-item period fires before the next item arrives from this Flux.

If the given Publisher is null, signal a TimeoutException.

Parameters:

timeout - the timeout between two signals from this Flux in milliseconds

fallback - the fallback Publisher to subscribe when a timeout occurs

Returns:

a per-item expirable Flux with a fallback Publisher

timeoutMillis

public final Flux<T> timeoutMillis(long timeout,
                                   Publisher<? extends T> fallback,
                                   TimedScheduler timer)

Switch to a fallback Publisher in case a per-item period fires before the next item arrives from this Flux.

If the given Publisher is null, signal a TimeoutException.

Parameters:

timeout - the timeout between two signals from this Flux in milliseconds

fallback - the fallback Publisher to subscribe when a timeout occurs

timer - the TimedScheduler to run on

Returns:

a per-item expirable Flux with a fallback Publisher

timestamp

public final Flux<Tuple2<Long,T>> timestamp()

Emit a Tuple2 pair of T1 Long current system time in millis and T2 T associated data for each item from this Flux

Returns:

a timestamped Flux

timestamp

public final Flux<Tuple2<Long,T>> timestamp(TimedScheduler scheduler)

Emit a Tuple2 pair of T1 Long current system time in millis and T2 T associated data for each item from this Flux

Parameters:

scheduler - the TimedScheduler to read time from

Returns:

a timestamped Flux

toIterable

public final Iterable<T> toIterable()

Transform this Flux into a lazy Iterable blocking on next calls.

Returns:

a blocking Iterable

toIterable

public final Iterable<T> toIterable(long batchSize)

Transform this Flux into a lazy Iterable blocking on next calls.

Parameters:

batchSize - the bounded capacity to produce to this Flux or Integer.MAX_VALUE for unbounded

Returns:

a blocking Iterable

toIterable

public final Iterable<T> toIterable(long batchSize,
                                    Supplier<Queue<T>> queueProvider)

Transform this Flux into a lazy Iterable blocking on next calls.

Parameters:

batchSize - the bounded capacity to produce to this Flux or Integer.MAX_VALUE for unbounded

queueProvider - the supplier of the queue implementation to be used for transferring elements across threads.

Returns:

a blocking Iterable

toStream

public Stream<T> toStream()

Transform this Flux into a lazy Stream blocking on next calls.

Returns:

a Stream of unknown size with onClose attached to Subscription.cancel()

toStream

public Stream<T> toStream(int batchSize)

Transform this Flux into a lazy Stream blocking on next calls.

Parameters:

batchSize - the bounded capacity to produce to this Flux or Integer.MAX_VALUE for unbounded

Returns:

a Stream of unknown size with onClose attached to Subscription.cancel()

transform

public final <V> Flux<V> transform(Function<? super Flux<T>,? extends Publisher<V>> transformer)

Transform this Flux in order to generate a target Flux. Unlike compose(Function), the provided function is executed as part of assembly. Function<Flux, Flux> applySchedulers = flux -> flux.subscribeOn(Schedulers.elastic()).publishOn(Schedulers.parallel()); flux.transform(applySchedulers).map(v -> v * v).subscribe()

Type Parameters:

V - the item type in the returned Flux

Parameters:

transformer - the Function to immediately map this Flux into a target Flux instance.

Returns:

a new Flux

See Also:

for deferred composition of {@link Flux} for each {@link Subscriber}, for a loose conversion to an arbitrary type

window

@Deprecated
public final Flux<Flux<T>> window()

Deprecated. will be removed in 3.1.0. Prefer using other variants, like window(Publisher),

Split this Flux sequence into multiple Flux delimited by cancel signals they receive. e.g. window().flatMap(w -> w.take(3)) will delimit window every 3.

Returns:

a windowing Flux of Flux buckets delimited by cancel signals

window

public final Flux<Flux<T>> window(int maxSize)

Split this Flux sequence into multiple Flux delimited by the given maxSize count and starting from the first item. Each Flux bucket will onComplete after maxSize items have been routed.

Parameters:

maxSize - the maximum routed items before emitting onComplete per Flux bucket

Returns:

a windowing Flux of sized Flux buckets

window

public final Flux<Flux<T>> window(int maxSize,
                                  int skip)

Split this Flux sequence into multiple Flux delimited by the given skip count, starting from the first item. Each Flux bucket will onComplete after maxSize items have been routed.

When skip > maxSize : dropping windows

When maxSize < skip : overlapping windows

When skip == maxSize : exact windows

Parameters:

maxSize - the maximum routed items per Flux

skip - the number of items to count before emitting a new bucket Flux

Returns:

a windowing Flux of sized Flux buckets every skip count

window

public final Flux<Flux<T>> window(Publisher<?> boundary)

Split this Flux sequence into continuous, non-overlapping windows where the window boundary is signalled by another Publisher

Parameters:

boundary - a Publisher to emit any item for a split signal and complete to terminate

Returns:

a windowing Flux delimiting its sub-sequences by a given Publisher

window

public final <U,V> Flux<Flux<T>> window(Publisher<U> bucketOpening,
                                        Function<? super U,? extends Publisher<V>> closeSelector)

Split this Flux sequence into potentially overlapping windows controlled by items of a start Publisher and end Publisher derived from the start values.

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

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

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

Type Parameters:

U - the type of the sequence opening windows

V - the type of the sequence closing windows opened by the bucketOpening Publisher's elements

Parameters:

bucketOpening - a Publisher to emit any item for a split signal and complete to terminate

closeSelector - a Function given an opening signal and returning a Publisher that emits to complete the window

Returns:

a windowing Flux delimiting its sub-sequences by a given Publisher and lasting until a selected Publisher emits

window

public final Flux<Flux<T>> window(Duration timespan)

Split this Flux sequence into continuous, non-overlapping windows delimited by a given period.

Parameters:

timespan - the duration to delimit Flux windows

Returns:

a windowing Flux of timed Flux buckets

window

public final Flux<Flux<T>> window(Duration timespan,
                                  Duration timeshift)

Split this Flux sequence into multiple Flux delimited by the given timeshift period, starting from the first item. Each Flux bucket will onComplete after timespan period has elpased.

When timeshift > timespan : dropping windows

When timeshift < timespan : overlapping windows

When timeshift == timespan : exact windows

Parameters:

timespan - the maximum Flux window duration

timeshift - the period of time to create new Flux windows

Returns:

a windowing Flux of Flux buckets delimited by an opening Publisher and a selected closing Publisher

window

@Deprecated
public final Flux<Flux<T>> window(int maxSize,
                                              Duration timespan)

Deprecated. use windowTimeout(int, Duration) instead, will be removed in 3.1.0

Split this Flux sequence into multiple Flux delimited by the given maxSize number of items, starting from the first item. Flux windows will onComplete after a given timespan occurs and the number of items has not be counted.

Parameters:

maxSize - the maximum Flux window items to count before onComplete

timespan - the timeout to use to onComplete a given window if size is not counted yet

Returns:

a windowing Flux of sized or timed Flux buckets

windowTimeout

public final Flux<Flux<T>> windowTimeout(int maxSize,
                                         Duration timespan)

Split this Flux sequence into multiple Flux delimited by the given maxSize number of items, starting from the first item. Flux windows will onComplete after a given timespan occurs and the number of items has not be counted.

Parameters:

maxSize - the maximum Flux window items to count before onComplete

timespan - the timeout to use to onComplete a given window if size is not counted yet

Returns:

a windowing Flux of sized or timed Flux buckets

windowMillis

public final Flux<Flux<T>> windowMillis(long timespan)

Split this Flux sequence into continuous, non-overlapping windows delimited by a given period.

Parameters:

timespan - the duration in milliseconds to delimit Flux windows

Returns:

a windowing Flux of timed Flux buckets

windowMillis

public final Flux<Flux<T>> windowMillis(long timespan,
                                        TimedScheduler timer)

Split this Flux sequence into continuous, non-overlapping windows delimited by a given period.

Parameters:

timespan - the duration in milliseconds to delimit Flux windows

timer - the TimedScheduler to run on

Returns:

a windowing Flux of timed Flux buckets

windowMillis

public final Flux<Flux<T>> windowMillis(long timespan,
                                        long timeshift,
                                        TimedScheduler timer)

Split this Flux sequence into multiple Flux delimited by the given timeshift period, starting from the first item. Each Flux bucket will onComplete after timespan period has elpased.

When timeshift > timespan : dropping windows

When timeshift < timespan : overlapping windows

When timeshift == timespan : exact windows

Parameters:

timespan - the maximum Flux window duration in milliseconds

timeshift - the period of time in milliseconds to create new Flux windows

timer - the TimedScheduler to run on

Returns:

a windowing Flux of Flux buckets delimited by an opening Publisher and a selected closing Publisher

windowMillis

@Deprecated
public final Flux<Flux<T>> windowMillis(int maxSize,
                                                    long timespan)

Deprecated. use windowTimeoutMillis(int, long) instead, will be removed in 3.1.0

Split this Flux sequence into multiple Flux delimited by the given maxSize number of items, starting from the first item. Flux windows will onComplete after a given timespan occurs and the number of items has not be counted.

Parameters:

maxSize - the maximum Flux window items to count before onComplete

timespan - the timeout to use to onComplete a given window if size is not counted yet

Returns:

a windowing Flux of sized or timed Flux buckets

windowMillis

@Deprecated
public final Flux<Flux<T>> windowMillis(int maxSize,
                                                    long timespan,
                                                    TimedScheduler timer)

Deprecated. use windowTimeoutMillis(int, long, TimedScheduler) instead, will be removed in 3.1.0

Split this Flux sequence into multiple Flux delimited by the given maxSize number of items, starting from the first item. Flux windows will onComplete after a given timespan occurs and the number of items has not be counted.

Parameters:

maxSize - the maximum Flux window items to count before onComplete

timespan - the timeout to use to onComplete a given window if size is not counted yet

timer - the TimedScheduler to run on

Returns:

a windowing Flux of sized or timed Flux buckets

windowTimeoutMillis

public final Flux<Flux<T>> windowTimeoutMillis(int maxSize,
                                               long timespan)

Split this Flux sequence into multiple Flux delimited by the given maxSize number of items, starting from the first item. Flux windows will onComplete after a given timespan occurs and the number of items has not be counted.

Parameters:

maxSize - the maximum Flux window items to count before onComplete

timespan - the timeout to use to onComplete a given window if size is not counted yet

Returns:

a windowing Flux of sized or timed Flux buckets

windowTimeoutMillis

public final Flux<Flux<T>> windowTimeoutMillis(int maxSize,
                                               long timespan,
                                               TimedScheduler timer)

Split this Flux sequence into multiple Flux delimited by the given maxSize number of items, starting from the first item. Flux windows will onComplete after a given timespan occurs and the number of items has not be counted.

Parameters:

maxSize - the maximum Flux window items to count before onComplete

timespan - the timeout to use to onComplete a given window if size is not counted yet

timer - the TimedScheduler to run on

Returns:

a windowing Flux of sized or timed Flux buckets

windowUntil

public final Flux<GroupedFlux<T,T>> windowUntil(Predicate<T> boundaryTrigger)

Split this Flux sequence into multiple Flux delimited by the given predicate. A new window is opened each time the predicate returns true, at which point the previous window will receive the triggering element then onComplete.

Parameters:

boundaryTrigger - a predicate that triggers the next window when it becomes true.

Returns:

a windowing Flux of GroupedFlux windows, bounded depending on the predicate and keyed with the value that triggered the new window.

windowUntil

public final Flux<GroupedFlux<T,T>> windowUntil(Predicate<T> boundaryTrigger,
                                                boolean cutBefore)

Split this Flux sequence into multiple Flux delimited by the given predicate. A new window is opened each time the predicate returns true.

If cutBefore is true, the old window will onComplete and the triggering element will be emitted in the new window. Note it can mean that an empty window is sometimes emitted, eg. if the first element in the sequence immediately matches the predicate.

Otherwise, the triggering element will be emitted in the old window before it does onComplete, similar to windowUntil(Predicate).

Parameters:

boundaryTrigger - a predicate that triggers the next window when it becomes true.

cutBefore - set to true to include the triggering element in the new window rather than the old.

Returns:

a windowing Flux of GroupedFlux windows, bounded depending on the predicate and keyed with the value that triggered the new window.

windowUntil

public final Flux<GroupedFlux<T,T>> windowUntil(Predicate<T> boundaryTrigger,
                                                boolean cutBefore,
                                                int prefetch)

Split this Flux sequence into multiple Flux delimited by the given predicate and using a prefetch. A new window is opened each time the predicate returns true.

If cutBefore is true, the old window will onComplete and the triggering element will be emitted in the new window. Note it can mean that an empty window is sometimes emitted, eg. if the first element in the sequence immediately matches the predicate.

Otherwise, the triggering element will be emitted in the old window before it does onComplete, similar to windowUntil(Predicate).

Parameters:

boundaryTrigger - a predicate that triggers the next window when it becomes true.

cutBefore - set to true to include the triggering element in the new window rather than the old.

prefetch - the request size to use for this Flux.

Returns:

a windowing Flux of GroupedFlux windows, bounded depending on the predicate and keyed with the value that triggered the new window.

windowWhile

public final Flux<GroupedFlux<T,T>> windowWhile(Predicate<T> inclusionPredicate)

Split this Flux sequence into multiple Flux windows that stay open while a given predicate matches the source elements. Once the predicate returns false, the window closes with an onComplete and the triggering element is discarded.

Note that for a sequence starting with a separator, or having several subsequent separators anywhere in the sequence, each occurrence will lead to an empty window.

Parameters:

inclusionPredicate - a predicate that triggers the next window when it becomes false.

Returns:

a windowing Flux of GroupedFlux windows, each containing subsequent elements that all passed a predicate, and keyed with a separator element.

windowWhile

public final Flux<GroupedFlux<T,T>> windowWhile(Predicate<T> inclusionPredicate,
                                                int prefetch)

Split this Flux sequence into multiple Flux windows that stay open while a given predicate matches the source elements. Once the predicate returns false, the window closes with an onComplete and the triggering element is discarded.

Note that for a sequence starting with a separator, or having several subsequent separators anywhere in the sequence, each occurrence will lead to an empty window.

Parameters:

inclusionPredicate - a predicate that triggers the next window when it becomes false.

prefetch - the request size to use for this Flux.

Returns:

a windowing Flux of GroupedFlux windows, each containing subsequent elements that all passed a predicate, and keyed with a separator element.

withLatestFrom

public final <U,R> Flux<R> withLatestFrom(Publisher<? extends U> other,
                                          BiFunction<? super T,? super U,? extends R> resultSelector)

Combine values from this Flux with values from another Publisher through a BiFunction and emits the result.

The operator will drop values from this Flux until the other Publisher produces any value.

If the other Publisher completes without any value, the sequence is completed.

Type Parameters:

U - the other Publisher sequence type

R - the result type

Parameters:

other - the Publisher to combine with

resultSelector - the bi-function called with each pair of source and other elements that should return a single value to be emitted

Returns:

a combined Flux gated by another Publisher

zipWith

public final <T2> Flux<Tuple2<T,T2>> zipWith(Publisher<? extends T2> source2)

"Step-Merge" especially useful in Scatter-Gather scenarios. The operator will forward all combinations of the most recent items emitted by each source until any of them completes. Errors will immediately be forwarded.

Type Parameters:

T2 - type of the value from source2

Parameters:

source2 - The second upstream Publisher to subscribe to.

Returns:

a zipped Flux

zipWith

public final <T2,V> Flux<V> zipWith(Publisher<? extends T2> source2,
                                    BiFunction<? super T,? super T2,? extends V> combinator)

"Step-Merge" especially useful in Scatter-Gather scenarios. The operator will forward all combinations produced by the passed combinator from the most recent items emitted by each source until any of them completes. Errors will immediately be forwarded.

Type Parameters:

T2 - type of the value from source2

V - The produced output after transformation by the combinator

Parameters:

source2 - The second upstream Publisher to subscribe to.

combinator - The aggregate function that will receive a unique value from each upstream and return the value to signal downstream

Returns:

a zipped Flux

zipWith

public final <T2,V> Flux<V> zipWith(Publisher<? extends T2> source2,
                                    int prefetch,
                                    BiFunction<? super T,? super T2,? extends V> combinator)

"Step-Merge" especially useful in Scatter-Gather scenarios. The operator will forward all combinations produced by the passed combinator from the most recent items emitted by each source until any of them completes. Errors will immediately be forwarded.

Type Parameters:

T2 - type of the value from source2

V - The produced output after transformation by the combinator

Parameters:

source2 - The second upstream Publisher to subscribe to.

prefetch - the request size to use for this Flux and the other Publisher

combinator - The aggregate function that will receive a unique value from each upstream and return the value to signal downstream

Returns:

a zipped Flux

zipWith

public final <T2> Flux<Tuple2<T,T2>> zipWith(Publisher<? extends T2> source2,
                                             int prefetch)

"Step-Merge" especially useful in Scatter-Gather scenarios. The operator will forward all combinations of the most recent items emitted by each source until any of them completes. Errors will immediately be forwarded.

Type Parameters:

T2 - type of the value from source2

Parameters:

source2 - The second upstream Publisher to subscribe to.

prefetch - the request size to use for this Flux and the other Publisher

Returns:

a zipped Flux

zipWithIterable

public final <T2> Flux<Tuple2<T,T2>> zipWithIterable(Iterable<? extends T2> iterable)

Pairwise combines as Tuple2 elements of this Flux and an Iterable sequence.

Type Parameters:

T2 - the value type of the other iterable sequence

Parameters:

iterable - the Iterable to pair with

Returns:

a zipped Flux

zipWithIterable

public final <T2,V> Flux<V> zipWithIterable(Iterable<? extends T2> iterable,
                                            BiFunction<? super T,? super T2,? extends V> zipper)

Pairwise combines elements of this Flux and an Iterable sequence using the given zipper BiFunction.

Type Parameters:

T2 - the value type of the other iterable sequence

V - the result type

Parameters:

iterable - the Iterable to pair with

zipper - the BiFunction combinator

Returns:

a zipped Flux

onAssembly

protected static <T> Flux<T> onAssembly(Flux<T> source)

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

Type Parameters:

T - the value type

Parameters:

source - the source to wrap

Returns:

the potentially wrapped source

onAssembly

protected static <T> ConnectableFlux<T> onAssembly(ConnectableFlux<T> source)

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

Type Parameters:

T - the value type

Parameters:

source - the source to wrap

Returns:

the potentially wrapped source

toString

public String toString()

Overrides:

toString in class Object