com.aol.cyclops.reactor.hkt

Class FluxType<T>

java.lang.Object

com.aol.cyclops.reactor.hkt.FluxType<T>

Type Parameters:

T - Data type stored within the Flux

All Implemented Interfaces:

com.aol.cyclops.hkt.alias.Convert<com.aol.cyclops.hkt.alias.Higher<FluxType.µ,T>>, com.aol.cyclops.hkt.alias.Higher<FluxType.µ,T>, org.derive4j.hkt.__<FluxType.µ,T>, org.reactivestreams.Publisher<T>

public final class FluxType<T>
extends java.lang.Object
implements com.aol.cyclops.hkt.alias.Higher<FluxType.µ,T>, org.reactivestreams.Publisher<T>

Simulates Higher Kinded Types for Reactor Flux's FluxType is a Flux and a Higher Kinded Type (FluxType.µ,T)

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	FluxType.µ Witness type

Constructor Summary

Constructors

Constructor and Description
FluxType()

Method Summary

Modifier and Type	Method and Description
reactor.core.publisher.Mono<java.lang.Boolean>	all(java.util.function.Predicate<? super T> predicate)
reactor.core.publisher.Mono<java.lang.Boolean>	any(java.util.function.Predicate<? super T> predicate)
<P> P	as(java.util.function.Function<? super reactor.core.publisher.Flux<T>,P> transformer)
reactor.core.publisher.Flux<T>	awaitOnSubscribe()
T	blockFirst()
T	blockFirst(java.time.Duration d)
T	blockFirstMillis(long timeout)
T	blockLast()
T	blockLast(java.time.Duration d)
T	blockLastMillis(long timeout)
reactor.core.publisher.Flux<java.util.List<T>>	buffer()
reactor.core.publisher.Flux<java.util.List<T>>	buffer(java.time.Duration timespan)
reactor.core.publisher.Flux<java.util.List<T>>	buffer(java.time.Duration timespan, java.time.Duration timeshift)
reactor.core.publisher.Flux<java.util.List<T>>	buffer(int maxSize)
reactor.core.publisher.Flux<java.util.List<T>>	buffer(int maxSize, java.time.Duration timespan)
<C extends java.util.Collection<? super T>> reactor.core.publisher.Flux<C>	buffer(int maxSize, java.time.Duration timespan, java.util.function.Supplier<C> bufferSupplier)
reactor.core.publisher.Flux<java.util.List<T>>	buffer(int maxSize, int skip)
<C extends java.util.Collection<? super T>> reactor.core.publisher.Flux<C>	buffer(int maxSize, int skip, java.util.function.Supplier<C> bufferSupplier)
<C extends java.util.Collection<? super T>> reactor.core.publisher.Flux<C>	buffer(int maxSize, java.util.function.Supplier<C> bufferSupplier)
reactor.core.publisher.Flux<java.util.List<T>>	buffer(org.reactivestreams.Publisher<?> other)
<C extends java.util.Collection<? super T>> reactor.core.publisher.Flux<C>	buffer(org.reactivestreams.Publisher<?> other, java.util.function.Supplier<C> bufferSupplier)
<U,V> reactor.core.publisher.Flux<java.util.List<T>>	buffer(org.reactivestreams.Publisher<U> bucketOpening, java.util.function.Function<? super U,? extends org.reactivestreams.Publisher<V>> closeSelector)
<U,V,C extends java.util.Collection<? super T>> reactor.core.publisher.Flux<C>	buffer(org.reactivestreams.Publisher<U> bucketOpening, java.util.function.Function<? super U,? extends org.reactivestreams.Publisher<V>> closeSelector, java.util.function.Supplier<C> bufferSupplier)
reactor.core.publisher.Flux<java.util.List<T>>	bufferMillis(int maxSize, long timespan)
reactor.core.publisher.Flux<java.util.List<T>>	bufferMillis(int maxSize, long timespan, reactor.core.scheduler.TimedScheduler timer)
<C extends java.util.Collection<? super T>> reactor.core.publisher.Flux<C>	bufferMillis(int maxSize, long timespan, reactor.core.scheduler.TimedScheduler timer, java.util.function.Supplier<C> bufferSupplier)
reactor.core.publisher.Flux<java.util.List<T>>	bufferMillis(long timespan)
reactor.core.publisher.Flux<java.util.List<T>>	bufferMillis(long timespan, long timeshift)
reactor.core.publisher.Flux<java.util.List<T>>	bufferMillis(long timespan, long timeshift, reactor.core.scheduler.TimedScheduler timer)
reactor.core.publisher.Flux<java.util.List<T>>	bufferMillis(long timespan, reactor.core.scheduler.TimedScheduler timer)
reactor.core.publisher.Flux<T>	cache()
reactor.core.publisher.Flux<T>	cache(java.time.Duration ttl)
reactor.core.publisher.Flux<T>	cache(int history)
reactor.core.publisher.Flux<T>	cache(int history, java.time.Duration ttl)
reactor.core.publisher.Flux<T>	cancelOn(reactor.core.scheduler.Scheduler scheduler)
<E> reactor.core.publisher.Flux<E>	cast(java.lang.Class<E> clazz)
<R,A> reactor.core.publisher.Mono<R>	collect(java.util.stream.Collector<T,A,R> collector)
<E> reactor.core.publisher.Mono<E>	collect(java.util.function.Supplier<E> containerSupplier, java.util.function.BiConsumer<E,? super T> collector)
reactor.core.publisher.Mono<java.util.List<T>>	collectList()
<K> reactor.core.publisher.Mono<java.util.Map<K,T>>	collectMap(java.util.function.Function<? super T,? extends K> keyExtractor)
<K,V> reactor.core.publisher.Mono<java.util.Map<K,V>>	collectMap(java.util.function.Function<? super T,? extends K> keyExtractor, java.util.function.Function<? super T,? extends V> valueExtractor)
<K,V> reactor.core.publisher.Mono<java.util.Map<K,V>>	collectMap(java.util.function.Function<? super T,? extends K> keyExtractor, java.util.function.Function<? super T,? extends V> valueExtractor, java.util.function.Supplier<java.util.Map<K,V>> mapSupplier)
<K> reactor.core.publisher.Mono<java.util.Map<K,java.util.Collection<T>>>	collectMultimap(java.util.function.Function<? super T,? extends K> keyExtractor)
<K,V> reactor.core.publisher.Mono<java.util.Map<K,java.util.Collection<V>>>	collectMultimap(java.util.function.Function<? super T,? extends K> keyExtractor, java.util.function.Function<? super T,? extends V> valueExtractor)
<K,V> reactor.core.publisher.Mono<java.util.Map<K,java.util.Collection<V>>>	collectMultimap(java.util.function.Function<? super T,? extends K> keyExtractor, java.util.function.Function<? super T,? extends V> valueExtractor, java.util.function.Supplier<java.util.Map<K,java.util.Collection<V>>> mapSupplier)
reactor.core.publisher.Mono<java.util.List<T>>	collectSortedList()
reactor.core.publisher.Mono<java.util.List<T>>	collectSortedList(java.util.Comparator<? super T> comparator)
<V> reactor.core.publisher.Flux<V>	compose(java.util.function.Function<? super reactor.core.publisher.Flux<T>,? extends org.reactivestreams.Publisher<V>> transformer)
<V> reactor.core.publisher.Flux<V>	concatMap(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends V>> mapper)
<V> reactor.core.publisher.Flux<V>	concatMap(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends V>> mapper, int prefetch)
<V> reactor.core.publisher.Flux<V>	concatMapDelayError(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends V>> mapper, boolean delayUntilEnd, int prefetch)
<V> reactor.core.publisher.Flux<V>	concatMapDelayError(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends V>> mapper, int prefetch)
<V> reactor.core.publisher.Flux<V>	concatMapDelayError(java.util.function.Function<? super T,org.reactivestreams.Publisher<? extends V>> mapper)
<R> reactor.core.publisher.Flux<R>	concatMapIterable(java.util.function.Function<? super T,? extends java.lang.Iterable<? extends R>> mapper)
<R> reactor.core.publisher.Flux<R>	concatMapIterable(java.util.function.Function<? super T,? extends java.lang.Iterable<? extends R>> mapper, int prefetch)
reactor.core.publisher.Flux<T>	concatWith(org.reactivestreams.Publisher<? extends T> other)
reactor.core.publisher.Mono<java.lang.Long>	count()
reactor.core.publisher.Flux<T>	defaultIfEmpty(T defaultV)
reactor.core.publisher.Flux<T>	delay(java.time.Duration delay)
reactor.core.publisher.Flux<T>	delayMillis(long delay)
reactor.core.publisher.Flux<T>	delayMillis(long delay, reactor.core.scheduler.TimedScheduler timer)
reactor.core.publisher.Flux<T>	delaySubscription(java.time.Duration delay)
<U> reactor.core.publisher.Flux<T>	delaySubscription(org.reactivestreams.Publisher<U> subscriptionDelay)
reactor.core.publisher.Flux<T>	delaySubscriptionMillis(long delay)
reactor.core.publisher.Flux<T>	delaySubscriptionMillis(long delay, reactor.core.scheduler.TimedScheduler timer)
<X> reactor.core.publisher.Flux<X>	dematerialize()
reactor.core.publisher.Flux<T>	distinct()
<V> reactor.core.publisher.Flux<T>	distinct(java.util.function.Function<? super T,? extends V> keySelector)
reactor.core.publisher.Flux<T>	distinctUntilChanged()
<V> reactor.core.publisher.Flux<T>	distinctUntilChanged(java.util.function.Function<? super T,? extends V> keySelector)
reactor.core.publisher.Flux<T>	doAfterTerminate(java.lang.Runnable afterTerminate)
reactor.core.publisher.Flux<T>	doOnCancel(java.lang.Runnable onCancel)
reactor.core.publisher.Flux<T>	doOnComplete(java.lang.Runnable onComplete)
<E extends java.lang.Throwable> reactor.core.publisher.Flux<T>	doOnError(java.lang.Class<E> exceptionType, java.util.function.Consumer<? super E> onError)
reactor.core.publisher.Flux<T>	doOnError(java.util.function.Consumer<? super java.lang.Throwable> onError)
reactor.core.publisher.Flux<T>	doOnError(java.util.function.Predicate<? super java.lang.Throwable> predicate, java.util.function.Consumer<? super java.lang.Throwable> onError)
reactor.core.publisher.Flux<T>	doOnNext(java.util.function.Consumer<? super T> onNext)
reactor.core.publisher.Flux<T>	doOnRequest(java.util.function.LongConsumer consumer)
reactor.core.publisher.Flux<T>	doOnSubscribe(java.util.function.Consumer<? super org.reactivestreams.Subscription> onSubscribe)
reactor.core.publisher.Flux<T>	doOnTerminate(java.lang.Runnable onTerminate)
reactor.core.publisher.Flux<reactor.util.function.Tuple2<java.lang.Long,T>>	elapsed()
reactor.core.publisher.Flux<reactor.util.function.Tuple2<java.lang.Long,T>>	elapsed(reactor.core.scheduler.TimedScheduler scheduler)
reactor.core.publisher.Mono<T>	elementAt(int index)
reactor.core.publisher.Mono<T>	elementAt(int index, T defaultValue)
static <T> FluxType<T>	empty()
boolean	equals(java.lang.Object obj)
reactor.core.publisher.Flux<T>	filter(java.util.function.Predicate<? super T> p)
reactor.core.publisher.Flux<T>	firstEmittingWith(org.reactivestreams.Publisher<? extends T> other)
<R> reactor.core.publisher.Flux<R>	flatMap(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper)
<R> reactor.core.publisher.Flux<R>	flatMap(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapperOnNext, java.util.function.Function<java.lang.Throwable,? extends org.reactivestreams.Publisher<? extends R>> mapperOnError, java.util.function.Supplier<? extends org.reactivestreams.Publisher<? extends R>> mapperOnComplete)
<V> reactor.core.publisher.Flux<V>	flatMap(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends V>> mapper, boolean delayError, int concurrency, int prefetch)
<V> reactor.core.publisher.Flux<V>	flatMap(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends V>> mapper, int concurrency)
<V> reactor.core.publisher.Flux<V>	flatMap(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends V>> mapper, int concurrency, int prefetch)
<R> reactor.core.publisher.Flux<R>	flatMapIterable(java.util.function.Function<? super T,? extends java.lang.Iterable<? extends R>> mapper)
<R> reactor.core.publisher.Flux<R>	flatMapIterable(java.util.function.Function<? super T,? extends java.lang.Iterable<? extends R>> mapper, int prefetch)
long	getPrefetch()
<K> reactor.core.publisher.Flux<reactor.core.publisher.GroupedFlux<K,T>>	groupBy(java.util.function.Function<? super T,? extends K> keyMapper)
<K,V> reactor.core.publisher.Flux<reactor.core.publisher.GroupedFlux<K,V>>	groupBy(java.util.function.Function<? super T,? extends K> keyMapper, java.util.function.Function<? super T,? extends V> valueMapper)
<TRight,TLeftEnd,TRightEnd,R> reactor.core.publisher.Flux<R>	groupJoin(org.reactivestreams.Publisher<? extends TRight> other, java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<TLeftEnd>> leftEnd, java.util.function.Function<? super TRight,? extends org.reactivestreams.Publisher<TRightEnd>> rightEnd, java.util.function.BiFunction<? super T,? super reactor.core.publisher.Flux<TRight>,? extends R> resultSelector)
<R> reactor.core.publisher.Flux<R>	handle(java.util.function.BiConsumer<? super T,reactor.core.publisher.SynchronousSink<R>> handler)
reactor.core.publisher.Mono<java.lang.Boolean>	hasElement(T value)
reactor.core.publisher.Mono<java.lang.Boolean>	hasElements()
int	hashCode()
reactor.core.publisher.Flux<T>	hide()
reactor.core.publisher.Mono<T>	ignoreElements()
<TRight,TLeftEnd,TRightEnd,R> reactor.core.publisher.Flux<R>	join(org.reactivestreams.Publisher<? extends TRight> other, java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<TLeftEnd>> leftEnd, java.util.function.Function<? super TRight,? extends org.reactivestreams.Publisher<TRightEnd>> rightEnd, java.util.function.BiFunction<? super T,? super TRight,? extends R> resultSelector)
static <T> FluxType<T>	just(T... values)
static <T> FluxType<T>	just(T value) Construct a HKT encoded completed Flux
reactor.core.publisher.Mono<T>	last()
reactor.core.publisher.Mono<T>	last(T defaultValue)
reactor.core.publisher.Flux<T>	log()
reactor.core.publisher.Flux<T>	log(java.lang.String category)
reactor.core.publisher.Flux<T>	log(java.lang.String category, java.util.logging.Level level, boolean showOperatorLine, reactor.core.publisher.SignalType... options)
reactor.core.publisher.Flux<T>	log(java.lang.String category, java.util.logging.Level level, reactor.core.publisher.SignalType... options)
<V> reactor.core.publisher.Flux<V>	map(java.util.function.Function<? super T,? extends V> mapper)
<E extends java.lang.Throwable> reactor.core.publisher.Flux<T>	mapError(java.lang.Class<E> type, java.util.function.Function<? super E,? extends java.lang.Throwable> mapper)
reactor.core.publisher.Flux<T>	mapError(java.util.function.Function<? super java.lang.Throwable,? extends java.lang.Throwable> mapper)
reactor.core.publisher.Flux<T>	mapError(java.util.function.Predicate<? super java.lang.Throwable> predicate, java.util.function.Function<? super java.lang.Throwable,? extends java.lang.Throwable> mapper)
reactor.core.publisher.Flux<reactor.core.publisher.Signal<T>>	materialize()
reactor.core.publisher.Flux<T>	mergeWith(org.reactivestreams.Publisher<? extends T> other)
reactor.core.publisher.Flux<T>	narrow()
static <T> reactor.core.publisher.Flux<T>	narrow(com.aol.cyclops.hkt.alias.Higher<FluxType.µ,T> completableFlux) Convert the HigherKindedType definition for a Flux into
static <T> FluxType<T>	narrowK(com.aol.cyclops.hkt.alias.Higher<FluxType.µ,T> future) Convert the raw Higher Kinded Type for FluxType types into the FluxType type definition class
reactor.core.publisher.Mono<T>	next()
<U> reactor.core.publisher.Flux<U>	ofType(java.lang.Class<U> clazz)
reactor.core.publisher.Flux<T>	onBackpressureBuffer()
reactor.core.publisher.Flux<T>	onBackpressureBuffer(int maxSize)
reactor.core.publisher.Flux<T>	onBackpressureBuffer(int maxSize, java.util.function.Consumer<? super T> onOverflow)
reactor.core.publisher.Flux<T>	onBackpressureDrop()
reactor.core.publisher.Flux<T>	onBackpressureDrop(java.util.function.Consumer<? super T> onDropped)
reactor.core.publisher.Flux<T>	onBackpressureError()
reactor.core.publisher.Flux<T>	onBackpressureLatest()
<E extends java.lang.Throwable> reactor.core.publisher.Flux<T>	onErrorResumeWith(java.lang.Class<E> type, java.util.function.Function<? super E,? extends org.reactivestreams.Publisher<? extends T>> fallback)
reactor.core.publisher.Flux<T>	onErrorResumeWith(java.util.function.Function<? super java.lang.Throwable,? extends org.reactivestreams.Publisher<? extends T>> fallback)
reactor.core.publisher.Flux<T>	onErrorResumeWith(java.util.function.Predicate<? super java.lang.Throwable> predicate, java.util.function.Function<? super java.lang.Throwable,? extends org.reactivestreams.Publisher<? extends T>> fallback)
<E extends java.lang.Throwable> reactor.core.publisher.Flux<T>	onErrorReturn(java.lang.Class<E> type, T fallbackValue)
<E extends java.lang.Throwable> reactor.core.publisher.Flux<T>	onErrorReturn(java.util.function.Predicate<? super java.lang.Throwable> predicate, T fallbackValue)
reactor.core.publisher.Flux<T>	onErrorReturn(T fallbackValue)
reactor.core.publisher.Flux<T>	onTerminateDetach()
reactor.core.publisher.ParallelFlux<T>	parallel()
reactor.core.publisher.ParallelFlux<T>	parallel(int parallelism)
reactor.core.publisher.ParallelFlux<T>	parallel(int parallelism, int prefetch)
reactor.core.publisher.ConnectableFlux<T>	publish()
<R> reactor.core.publisher.Flux<R>	publish(java.util.function.Function<? super reactor.core.publisher.Flux<T>,? extends org.reactivestreams.Publisher<? extends R>> transform)
<R> reactor.core.publisher.Flux<R>	publish(java.util.function.Function<? super reactor.core.publisher.Flux<T>,? extends org.reactivestreams.Publisher<? extends R>> transform, int prefetch)
reactor.core.publisher.ConnectableFlux<T>	publish(int prefetch)
reactor.core.publisher.Mono<T>	publishNext()
reactor.core.publisher.Flux<T>	publishOn(reactor.core.scheduler.Scheduler scheduler)
reactor.core.publisher.Flux<T>	publishOn(reactor.core.scheduler.Scheduler scheduler, int prefetch)
<A> reactor.core.publisher.Mono<A>	reduce(A initial, java.util.function.BiFunction<A,? super T,A> accumulator)
reactor.core.publisher.Mono<T>	reduce(java.util.function.BiFunction<T,T,T> aggregator)
<A> reactor.core.publisher.Mono<A>	reduceWith(java.util.function.Supplier<A> initial, java.util.function.BiFunction<A,? super T,A> accumulator)
reactor.core.publisher.Flux<T>	repeat()
reactor.core.publisher.Flux<T>	repeat(java.util.function.BooleanSupplier predicate)
reactor.core.publisher.Flux<T>	repeat(long numRepeat)
reactor.core.publisher.Flux<T>	repeat(long numRepeat, java.util.function.BooleanSupplier predicate)
reactor.core.publisher.Flux<T>	repeatWhen(java.util.function.Function<reactor.core.publisher.Flux<java.lang.Long>,? extends org.reactivestreams.Publisher<?>> whenFactory)
reactor.core.publisher.ConnectableFlux<T>	replay()
reactor.core.publisher.ConnectableFlux<T>	replay(java.time.Duration ttl)
reactor.core.publisher.ConnectableFlux<T>	replay(int history)
reactor.core.publisher.ConnectableFlux<T>	replay(int history, java.time.Duration ttl)
reactor.core.publisher.ConnectableFlux<T>	replayMillis(int history, long ttl, reactor.core.scheduler.TimedScheduler timer)
reactor.core.publisher.ConnectableFlux<T>	replayMillis(long ttl, reactor.core.scheduler.TimedScheduler timer)
reactor.core.publisher.Flux<T>	retry()
reactor.core.publisher.Flux<T>	retry(long numRetries)
reactor.core.publisher.Flux<T>	retry(long numRetries, java.util.function.Predicate<java.lang.Throwable> retryMatcher)
reactor.core.publisher.Flux<T>	retry(java.util.function.Predicate<java.lang.Throwable> retryMatcher)
reactor.core.publisher.Flux<T>	retryWhen(java.util.function.Function<reactor.core.publisher.Flux<java.lang.Throwable>,? extends org.reactivestreams.Publisher<?>> whenFactory)
reactor.core.publisher.Flux<T>	sample(java.time.Duration timespan)
<U> reactor.core.publisher.Flux<T>	sample(org.reactivestreams.Publisher<U> sampler)
reactor.core.publisher.Flux<T>	sampleFirst(java.time.Duration timespan)
<U> reactor.core.publisher.Flux<T>	sampleFirst(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<U>> samplerFactory)
reactor.core.publisher.Flux<T>	sampleFirstMillis(long timespan)
reactor.core.publisher.Flux<T>	sampleMillis(long timespan)
<U> reactor.core.publisher.Flux<T>	sampleTimeout(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<U>> throttlerFactory)
<U> reactor.core.publisher.Flux<T>	sampleTimeout(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<U>> throttlerFactory, int maxConcurrency)
<A> reactor.core.publisher.Flux<A>	scan(A initial, java.util.function.BiFunction<A,? super T,A> accumulator)
reactor.core.publisher.Flux<T>	scan(java.util.function.BiFunction<T,T,T> accumulator)
<A> reactor.core.publisher.Flux<A>	scanWith(java.util.function.Supplier<A> initial, java.util.function.BiFunction<A,? super T,A> accumulator)
reactor.core.publisher.Flux<T>	share()
reactor.core.publisher.Mono<T>	single()
reactor.core.publisher.Mono<T>	single(T defaultValue)
reactor.core.publisher.Mono<T>	singleOrEmpty()
reactor.core.publisher.Flux<T>	skip(java.time.Duration timespan)
reactor.core.publisher.Flux<T>	skip(long skipped)
reactor.core.publisher.Flux<T>	skipLast(int n)
reactor.core.publisher.Flux<T>	skipMillis(long timespan)
reactor.core.publisher.Flux<T>	skipMillis(long timespan, reactor.core.scheduler.TimedScheduler timer)
reactor.core.publisher.Flux<T>	skipUntil(java.util.function.Predicate<? super T> untilPredicate)
reactor.core.publisher.Flux<T>	skipUntilOther(org.reactivestreams.Publisher<?> other)
reactor.core.publisher.Flux<T>	skipWhile(java.util.function.Predicate<? super T> skipPredicate)
reactor.core.publisher.Flux<T>	sort()
reactor.core.publisher.Flux<T>	sort(java.util.Comparator<? super T> sortFunction)
reactor.core.publisher.Flux<T>	startWith(java.lang.Iterable<? extends T> iterable)
reactor.core.publisher.Flux<T>	startWith(org.reactivestreams.Publisher<? extends T> publisher)
reactor.core.publisher.Flux<T>	startWith(T... values)
reactor.core.Cancellation	subscribe()
reactor.core.Cancellation	subscribe(java.util.function.Consumer<? super T> consumer)
reactor.core.Cancellation	subscribe(java.util.function.Consumer<? super T> consumer, java.util.function.Consumer<? super java.lang.Throwable> errorConsumer)
reactor.core.Cancellation	subscribe(java.util.function.Consumer<? super T> consumer, java.util.function.Consumer<? super java.lang.Throwable> errorConsumer, java.lang.Runnable completeConsumer)
reactor.core.Cancellation	subscribe(java.util.function.Consumer<? super T> consumer, java.util.function.Consumer<? super java.lang.Throwable> errorConsumer, java.lang.Runnable completeConsumer, int prefetch)
reactor.core.Cancellation	subscribe(java.util.function.Consumer<? super T> consumer, int prefetch)
reactor.core.Cancellation	subscribe(int prefetch)
void	subscribe(org.reactivestreams.Subscriber<? super T> s)
reactor.core.publisher.Flux<T>	subscribeOn(reactor.core.scheduler.Scheduler scheduler)
<E extends org.reactivestreams.Subscriber<? super T>> E	subscribeWith(E subscriber)
reactor.core.publisher.Flux<T>	switchIfEmpty(org.reactivestreams.Publisher<? extends T> alternate)
<V> reactor.core.publisher.Flux<V>	switchMap(java.util.function.Function<? super T,org.reactivestreams.Publisher<? extends V>> fn)
<V> reactor.core.publisher.Flux<V>	switchMap(java.util.function.Function<? super T,org.reactivestreams.Publisher<? extends V>> fn, int prefetch)
<E extends java.lang.Throwable> reactor.core.publisher.Flux<T>	switchOnError(java.lang.Class<E> type, org.reactivestreams.Publisher<? extends T> fallback)
reactor.core.publisher.Flux<T>	switchOnError(java.util.function.Predicate<? super java.lang.Throwable> predicate, org.reactivestreams.Publisher<? extends T> fallback)
reactor.core.publisher.Flux<T>	switchOnError(org.reactivestreams.Publisher<? extends T> fallback)
reactor.core.publisher.Flux<T>	take(java.time.Duration timespan)
reactor.core.publisher.Flux<T>	take(long n)
reactor.core.publisher.Flux<T>	takeLast(int n)
reactor.core.publisher.Flux<T>	takeMillis(long timespan)
reactor.core.publisher.Flux<T>	takeMillis(long timespan, reactor.core.scheduler.TimedScheduler timer)
reactor.core.publisher.Flux<T>	takeUntil(java.util.function.Predicate<? super T> predicate)
reactor.core.publisher.Flux<T>	takeUntilOther(org.reactivestreams.Publisher<?> other)
reactor.core.publisher.Flux<T>	takeWhile(java.util.function.Predicate<? super T> continuePredicate)
reactor.core.publisher.Mono<java.lang.Void>	then()
reactor.core.publisher.Mono<java.lang.Void>	then(org.reactivestreams.Publisher<java.lang.Void> other)
reactor.core.publisher.Mono<java.lang.Void>	then(java.util.function.Supplier<? extends org.reactivestreams.Publisher<java.lang.Void>> afterSupplier)
<V> reactor.core.publisher.Flux<V>	thenMany(org.reactivestreams.Publisher<V> other)
<V> reactor.core.publisher.Flux<V>	thenMany(java.util.function.Supplier<? extends org.reactivestreams.Publisher<V>> afterSupplier)
reactor.core.publisher.Flux<T>	timeout(java.time.Duration timeout)
reactor.core.publisher.Flux<T>	timeout(java.time.Duration timeout, org.reactivestreams.Publisher<? extends T> fallback)
<U> reactor.core.publisher.Flux<T>	timeout(org.reactivestreams.Publisher<U> firstTimeout)
<U,V> reactor.core.publisher.Flux<T>	timeout(org.reactivestreams.Publisher<U> firstTimeout, java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<V>> nextTimeoutFactory)
<U,V> reactor.core.publisher.Flux<T>	timeout(org.reactivestreams.Publisher<U> firstTimeout, java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<V>> nextTimeoutFactory, org.reactivestreams.Publisher<? extends T> fallback)
reactor.core.publisher.Flux<T>	timeoutMillis(long timeout)
reactor.core.publisher.Flux<T>	timeoutMillis(long timeout, org.reactivestreams.Publisher<? extends T> fallback)
reactor.core.publisher.Flux<T>	timeoutMillis(long timeout, org.reactivestreams.Publisher<? extends T> fallback, reactor.core.scheduler.TimedScheduler timer)
reactor.core.publisher.Flux<T>	timeoutMillis(long timeout, reactor.core.scheduler.TimedScheduler timer)
reactor.core.publisher.Flux<reactor.util.function.Tuple2<java.lang.Long,T>>	timestamp()
reactor.core.publisher.Flux<reactor.util.function.Tuple2<java.lang.Long,T>>	timestamp(reactor.core.scheduler.TimedScheduler scheduler)
java.lang.Iterable<T>	toIterable()
java.lang.Iterable<T>	toIterable(long batchSize)
java.lang.Iterable<T>	toIterable(long batchSize, java.util.function.Supplier<java.util.Queue<T>> queueProvider)
ReactiveSeq<T>	toReactiveSeq()
java.util.stream.Stream<T>	toStream()
java.util.stream.Stream<T>	toStream(int batchSize)
java.lang.String	toString()
<V> reactor.core.publisher.Flux<V>	transform(java.util.function.Function<? super reactor.core.publisher.Flux<T>,? extends org.reactivestreams.Publisher<V>> transformer)
static <T> FluxType<T>	widen(reactor.core.publisher.Flux<T> completableFlux) Convert a Flux to a simulated HigherKindedType that captures Flux nature and Flux element data type separately.
static <T> FluxType<T>	widen(org.reactivestreams.Publisher<T> completableFlux)
static <C2,T> com.aol.cyclops.hkt.alias.Higher<C2,com.aol.cyclops.hkt.alias.Higher<FluxType.µ,T>>	widen2(com.aol.cyclops.hkt.alias.Higher<C2,FluxType<T>> flux) Widen a FluxType nested inside another HKT encoded type
reactor.core.publisher.Flux<reactor.core.publisher.Flux<T>>	window()
reactor.core.publisher.Flux<reactor.core.publisher.Flux<T>>	window(java.time.Duration timespan)
reactor.core.publisher.Flux<reactor.core.publisher.Flux<T>>	window(java.time.Duration timespan, java.time.Duration timeshift)
reactor.core.publisher.Flux<reactor.core.publisher.Flux<T>>	window(int maxSize)
reactor.core.publisher.Flux<reactor.core.publisher.Flux<T>>	window(int maxSize, java.time.Duration timespan)
reactor.core.publisher.Flux<reactor.core.publisher.Flux<T>>	window(int maxSize, int skip)
reactor.core.publisher.Flux<reactor.core.publisher.Flux<T>>	window(org.reactivestreams.Publisher<?> boundary)
<U,V> reactor.core.publisher.Flux<reactor.core.publisher.Flux<T>>	window(org.reactivestreams.Publisher<U> bucketOpening, java.util.function.Function<? super U,? extends org.reactivestreams.Publisher<V>> closeSelector)
reactor.core.publisher.Flux<reactor.core.publisher.Flux<T>>	windowMillis(int maxSize, long timespan)
reactor.core.publisher.Flux<reactor.core.publisher.Flux<T>>	windowMillis(int maxSize, long timespan, reactor.core.scheduler.TimedScheduler timer)
reactor.core.publisher.Flux<reactor.core.publisher.Flux<T>>	windowMillis(long timespan)
reactor.core.publisher.Flux<reactor.core.publisher.Flux<T>>	windowMillis(long timespan, long timeshift, reactor.core.scheduler.TimedScheduler timer)
reactor.core.publisher.Flux<reactor.core.publisher.Flux<T>>	windowMillis(long timespan, reactor.core.scheduler.TimedScheduler timer)
<U,R> reactor.core.publisher.Flux<R>	withLatestFrom(org.reactivestreams.Publisher<? extends U> other, java.util.function.BiFunction<? super T,? super U,? extends R> resultSelector)
<T2> reactor.core.publisher.Flux<reactor.util.function.Tuple2<T,T2>>	zipWith(org.reactivestreams.Publisher<? extends T2> source2)
<T2,V> reactor.core.publisher.Flux<V>	zipWith(org.reactivestreams.Publisher<? extends T2> source2, java.util.function.BiFunction<? super T,? super T2,? extends V> combinator)
<T2> reactor.core.publisher.Flux<reactor.util.function.Tuple2<T,T2>>	zipWith(org.reactivestreams.Publisher<? extends T2> source2, int prefetch)
<T2,V> reactor.core.publisher.Flux<V>	zipWith(org.reactivestreams.Publisher<? extends T2> source2, int prefetch, java.util.function.BiFunction<? super T,? super T2,? extends V> combinator)
<T2> reactor.core.publisher.Flux<reactor.util.function.Tuple2<T,T2>>	zipWithIterable(java.lang.Iterable<? extends T2> iterable)
<T2,V> reactor.core.publisher.Flux<V>	zipWithIterable(java.lang.Iterable<? extends T2> iterable, java.util.function.BiFunction<? super T,? super T2,? extends V> zipper)

Methods inherited from class java.lang.Object

clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface com.aol.cyclops.hkt.alias.Higher

apply_, apply, then

Methods inherited from interface com.aol.cyclops.hkt.alias.Convert

convert

Constructor Detail

FluxType

public FluxType()

Method Detail

just

public static <T> FluxType<T> just(T value)

Construct a HKT encoded completed Flux

Parameters:

value - To encode inside a HKT encoded Flux

Returns:

Completed HKT encoded FFlux

just

public static <T> FluxType<T> just(T... values)

empty

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

widen

public static <T> FluxType<T> widen(reactor.core.publisher.Flux<T> completableFlux)

Convert a Flux to a simulated HigherKindedType that captures Flux nature and Flux element data type separately. Recover via @see FluxType#narrow If the supplied Flux implements FluxType it is returned already, otherwise it is wrapped into a Flux implementation that does implement FluxType

Parameters:

Flux - Flux to widen to a FluxType

Returns:

FluxType encoding HKT info about Fluxs

widen2

public static <C2,T> com.aol.cyclops.hkt.alias.Higher<C2,com.aol.cyclops.hkt.alias.Higher<FluxType.µ,T>> widen2(com.aol.cyclops.hkt.alias.Higher<C2,FluxType<T>> flux)

Widen a FluxType nested inside another HKT encoded type

Parameters:

flux - HTK encoded type containing a Flux to widen

Returns:

HKT encoded type with a widened Flux

widen

public static <T> FluxType<T> widen(org.reactivestreams.Publisher<T> completableFlux)

narrowK

public static <T> FluxType<T> narrowK(com.aol.cyclops.hkt.alias.Higher<FluxType.µ,T> future)

Convert the raw Higher Kinded Type for FluxType types into the FluxType type definition class

Parameters:

future - HKT encoded list into a FluxType

Returns:

FluxType

narrow

public static <T> reactor.core.publisher.Flux<T> narrow(com.aol.cyclops.hkt.alias.Higher<FluxType.µ,T> completableFlux)

Convert the HigherKindedType definition for a Flux into

Parameters:

Flux - Type Constructor to convert back into narrowed type

Returns:

Flux from Higher Kinded Type

narrow

public reactor.core.publisher.Flux<T> narrow()

Returns:

wrapped Flux

toReactiveSeq

public ReactiveSeq<T> toReactiveSeq()

subscribe

public void subscribe(org.reactivestreams.Subscriber<? super T> s)

Specified by:

subscribe in interface org.reactivestreams.Publisher<T>

Parameters:

s -

See Also:

Publisher.subscribe(org.reactivestreams.Subscriber)

hashCode

public int hashCode()

Overrides:

hashCode in class java.lang.Object

Returns:

See Also:

Object.hashCode()

equals

public boolean equals(java.lang.Object obj)

Overrides:

equals in class java.lang.Object

Parameters:

obj -

Returns:

See Also:

Object.equals(java.lang.Object)

toString

public java.lang.String toString()

Overrides:

toString in class java.lang.Object

Returns:

See Also:

Flux.toString()

all

public final reactor.core.publisher.Mono<java.lang.Boolean> all(java.util.function.Predicate<? super T> predicate)

Parameters:

predicate -

Returns:

See Also:

Flux.all(java.util.function.Predicate)

any

public final reactor.core.publisher.Mono<java.lang.Boolean> any(java.util.function.Predicate<? super T> predicate)

Parameters:

predicate -

Returns:

See Also:

Flux.any(java.util.function.Predicate)

as

public final <P> P as(java.util.function.Function<? super reactor.core.publisher.Flux<T>,P> transformer)

Parameters:

transformer -

Returns:

See Also:

Flux.as(java.util.function.Function)

awaitOnSubscribe

public final reactor.core.publisher.Flux<T> awaitOnSubscribe()

Returns:

See Also:

Flux.awaitOnSubscribe()

blockFirst

public final T blockFirst()

Returns:

See Also:

Flux.blockFirst()

blockFirst

public final T blockFirst(java.time.Duration d)

Parameters:

d -

Returns:

See Also:

Flux.blockFirst(java.time.Duration)

blockFirstMillis

public final T blockFirstMillis(long timeout)

Parameters:

timeout -

Returns:

See Also:

Flux.blockFirstMillis(long)

blockLast

public final T blockLast()

Returns:

See Also:

Flux.blockLast()

blockLast

public final T blockLast(java.time.Duration d)

Parameters:

d -

Returns:

See Also:

Flux.blockLast(java.time.Duration)

blockLastMillis

public final T blockLastMillis(long timeout)

Parameters:

timeout -

Returns:

See Also:

Flux.blockLastMillis(long)

buffer

public final reactor.core.publisher.Flux<java.util.List<T>> buffer()

Returns:

See Also:

Flux.buffer()

buffer

public final reactor.core.publisher.Flux<java.util.List<T>> buffer(int maxSize)

Parameters:

maxSize -

Returns:

See Also:

Flux.buffer(int)

buffer

public final <C extends java.util.Collection<? super T>> reactor.core.publisher.Flux<C> buffer(int maxSize,
                                                                                               java.util.function.Supplier<C> bufferSupplier)

Parameters:

maxSize -

bufferSupplier -

Returns:

See Also:

Flux.buffer(int, java.util.function.Supplier)

buffer

public final reactor.core.publisher.Flux<java.util.List<T>> buffer(int maxSize,
                                                                   int skip)

Parameters:

maxSize -

skip -

Returns:

See Also:

Flux.buffer(int, int)

buffer

public final <C extends java.util.Collection<? super T>> reactor.core.publisher.Flux<C> buffer(int maxSize,
                                                                                               int skip,
                                                                                               java.util.function.Supplier<C> bufferSupplier)

Parameters:

maxSize -

skip -

bufferSupplier -

Returns:

See Also:

Flux.buffer(int, int, java.util.function.Supplier)

buffer

public final reactor.core.publisher.Flux<java.util.List<T>> buffer(org.reactivestreams.Publisher<?> other)

Parameters:

other -

Returns:

See Also:

Flux.buffer(org.reactivestreams.Publisher)

buffer

public final <C extends java.util.Collection<? super T>> reactor.core.publisher.Flux<C> buffer(org.reactivestreams.Publisher<?> other,
                                                                                               java.util.function.Supplier<C> bufferSupplier)

Parameters:

other -

bufferSupplier -

Returns:

See Also:

Flux.buffer(org.reactivestreams.Publisher, java.util.function.Supplier)

buffer

public final <U,V> reactor.core.publisher.Flux<java.util.List<T>> buffer(org.reactivestreams.Publisher<U> bucketOpening,
                                                                         java.util.function.Function<? super U,? extends org.reactivestreams.Publisher<V>> closeSelector)

Parameters:

bucketOpening -

closeSelector -

Returns:

See Also:

Flux.buffer(org.reactivestreams.Publisher, java.util.function.Function)

buffer

public final <U,V,C extends java.util.Collection<? super T>> reactor.core.publisher.Flux<C> buffer(org.reactivestreams.Publisher<U> bucketOpening,
                                                                                                   java.util.function.Function<? super U,? extends org.reactivestreams.Publisher<V>> closeSelector,
                                                                                                   java.util.function.Supplier<C> bufferSupplier)

Parameters:

bucketOpening -

closeSelector -

bufferSupplier -

Returns:

See Also:

Flux.buffer(org.reactivestreams.Publisher, java.util.function.Function, java.util.function.Supplier)

buffer

public final reactor.core.publisher.Flux<java.util.List<T>> buffer(java.time.Duration timespan)

Parameters:

timespan -

Returns:

See Also:

Flux.buffer(java.time.Duration)

buffer

public final reactor.core.publisher.Flux<java.util.List<T>> buffer(java.time.Duration timespan,
                                                                   java.time.Duration timeshift)

Parameters:

timespan -

timeshift -

Returns:

See Also:

Flux.buffer(java.time.Duration, java.time.Duration)

buffer

public final reactor.core.publisher.Flux<java.util.List<T>> buffer(int maxSize,
                                                                   java.time.Duration timespan)

Parameters:

maxSize -

timespan -

Returns:

See Also:

Flux.buffer(int, java.time.Duration)

buffer

public final <C extends java.util.Collection<? super T>> reactor.core.publisher.Flux<C> buffer(int maxSize,
                                                                                               java.time.Duration timespan,
                                                                                               java.util.function.Supplier<C> bufferSupplier)

Parameters:

maxSize -

timespan -

bufferSupplier -

Returns:

See Also:

Flux.buffer(int, java.time.Duration, java.util.function.Supplier)

bufferMillis

public final reactor.core.publisher.Flux<java.util.List<T>> bufferMillis(long timespan)

Parameters:

timespan -

Returns:

See Also:

Flux.bufferMillis(long)

bufferMillis

public final reactor.core.publisher.Flux<java.util.List<T>> bufferMillis(long timespan,
                                                                         reactor.core.scheduler.TimedScheduler timer)

Parameters:

timespan -

timer -

Returns:

See Also:

Flux.bufferMillis(long, reactor.core.scheduler.TimedScheduler)

bufferMillis

public final reactor.core.publisher.Flux<java.util.List<T>> bufferMillis(long timespan,
                                                                         long timeshift)

Parameters:

timespan -

timeshift -

Returns:

See Also:

Flux.bufferMillis(long, long)

bufferMillis

public final reactor.core.publisher.Flux<java.util.List<T>> bufferMillis(long timespan,
                                                                         long timeshift,
                                                                         reactor.core.scheduler.TimedScheduler timer)

Parameters:

timespan -

timeshift -

timer -

Returns:

See Also:

Flux.bufferMillis(long, long, reactor.core.scheduler.TimedScheduler)

bufferMillis

public final reactor.core.publisher.Flux<java.util.List<T>> bufferMillis(int maxSize,
                                                                         long timespan)

Parameters:

maxSize -

timespan -

Returns:

See Also:

Flux.bufferMillis(int, long)

bufferMillis

public final reactor.core.publisher.Flux<java.util.List<T>> bufferMillis(int maxSize,
                                                                         long timespan,
                                                                         reactor.core.scheduler.TimedScheduler timer)

Parameters:

maxSize -

timespan -

timer -

Returns:

See Also:

Flux.bufferMillis(int, long, reactor.core.scheduler.TimedScheduler)

bufferMillis

public final <C extends java.util.Collection<? super T>> reactor.core.publisher.Flux<C> bufferMillis(int maxSize,
                                                                                                     long timespan,
                                                                                                     reactor.core.scheduler.TimedScheduler timer,
                                                                                                     java.util.function.Supplier<C> bufferSupplier)

Parameters:

maxSize -

timespan -

timer -

bufferSupplier -

Returns:

See Also:

Flux.bufferMillis(int, long, reactor.core.scheduler.TimedScheduler, java.util.function.Supplier)

cache

public final reactor.core.publisher.Flux<T> cache()

Returns:

See Also:

Flux.cache()

cache

public final reactor.core.publisher.Flux<T> cache(int history)

Parameters:

history -

Returns:

See Also:

Flux.cache(int)

cache

public final reactor.core.publisher.Flux<T> cache(java.time.Duration ttl)

Parameters:

ttl -

Returns:

See Also:

Flux.cache(java.time.Duration)

cache

public final reactor.core.publisher.Flux<T> cache(int history,
                                                  java.time.Duration ttl)

Parameters:

history -

ttl -

Returns:

See Also:

Flux.cache(int, java.time.Duration)

cast

public final <E> reactor.core.publisher.Flux<E> cast(java.lang.Class<E> clazz)

Parameters:

clazz -

Returns:

See Also:

Flux.cast(java.lang.Class)

cancelOn

public final reactor.core.publisher.Flux<T> cancelOn(reactor.core.scheduler.Scheduler scheduler)

Parameters:

scheduler -

Returns:

See Also:

Flux.cancelOn(reactor.core.scheduler.Scheduler)

collect

public final <E> reactor.core.publisher.Mono<E> collect(java.util.function.Supplier<E> containerSupplier,
                                                        java.util.function.BiConsumer<E,? super T> collector)

Parameters:

containerSupplier -

collector -

Returns:

See Also:

Flux.collect(java.util.function.Supplier, java.util.function.BiConsumer)

collect

public final <R,A> reactor.core.publisher.Mono<R> collect(java.util.stream.Collector<T,A,R> collector)

Parameters:

collector -

Returns:

See Also:

Flux.collect(java.util.stream.Collector)

collectList

public final reactor.core.publisher.Mono<java.util.List<T>> collectList()

Returns:

See Also:

Flux.collectList()

collectMap

public final <K> reactor.core.publisher.Mono<java.util.Map<K,T>> collectMap(java.util.function.Function<? super T,? extends K> keyExtractor)

Parameters:

keyExtractor -

Returns:

See Also:

Flux.collectMap(java.util.function.Function)

collectMap

public final <K,V> reactor.core.publisher.Mono<java.util.Map<K,V>> collectMap(java.util.function.Function<? super T,? extends K> keyExtractor,
                                                                              java.util.function.Function<? super T,? extends V> valueExtractor)

Parameters:

keyExtractor -

valueExtractor -

Returns:

See Also:

Flux.collectMap(java.util.function.Function, java.util.function.Function)

collectMap

public final <K,V> reactor.core.publisher.Mono<java.util.Map<K,V>> collectMap(java.util.function.Function<? super T,? extends K> keyExtractor,
                                                                              java.util.function.Function<? super T,? extends V> valueExtractor,
                                                                              java.util.function.Supplier<java.util.Map<K,V>> mapSupplier)

Parameters:

keyExtractor -

valueExtractor -

mapSupplier -

Returns:

See Also:

Flux.collectMap(java.util.function.Function, java.util.function.Function, java.util.function.Supplier)

collectMultimap

public final <K> reactor.core.publisher.Mono<java.util.Map<K,java.util.Collection<T>>> collectMultimap(java.util.function.Function<? super T,? extends K> keyExtractor)

Parameters:

keyExtractor -

Returns:

See Also:

Flux.collectMultimap(java.util.function.Function)

collectMultimap

public final <K,V> reactor.core.publisher.Mono<java.util.Map<K,java.util.Collection<V>>> collectMultimap(java.util.function.Function<? super T,? extends K> keyExtractor,
                                                                                                         java.util.function.Function<? super T,? extends V> valueExtractor)

Parameters:

keyExtractor -

valueExtractor -

Returns:

See Also:

Flux.collectMultimap(java.util.function.Function, java.util.function.Function)

collectMultimap

public final <K,V> reactor.core.publisher.Mono<java.util.Map<K,java.util.Collection<V>>> collectMultimap(java.util.function.Function<? super T,? extends K> keyExtractor,
                                                                                                         java.util.function.Function<? super T,? extends V> valueExtractor,
                                                                                                         java.util.function.Supplier<java.util.Map<K,java.util.Collection<V>>> mapSupplier)

Parameters:

keyExtractor -

valueExtractor -

mapSupplier -

Returns:

See Also:

Flux.collectMultimap(java.util.function.Function, java.util.function.Function, java.util.function.Supplier)

collectSortedList

public final reactor.core.publisher.Mono<java.util.List<T>> collectSortedList()

Returns:

See Also:

Flux.collectSortedList()

collectSortedList

public final reactor.core.publisher.Mono<java.util.List<T>> collectSortedList(java.util.Comparator<? super T> comparator)

Parameters:

comparator -

Returns:

See Also:

Flux.collectSortedList(java.util.Comparator)

compose

public final <V> reactor.core.publisher.Flux<V> compose(java.util.function.Function<? super reactor.core.publisher.Flux<T>,? extends org.reactivestreams.Publisher<V>> transformer)

Parameters:

transformer -

Returns:

See Also:

Flux.compose(java.util.function.Function)

concatMap

public final <V> reactor.core.publisher.Flux<V> concatMap(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends V>> mapper)

Parameters:

mapper -

Returns:

See Also:

Flux.concatMap(java.util.function.Function)

concatMap

public final <V> reactor.core.publisher.Flux<V> concatMap(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends V>> mapper,
                                                          int prefetch)

Parameters:

mapper -

prefetch -

Returns:

See Also:

Flux.concatMap(java.util.function.Function, int)

concatMapDelayError

public final <V> reactor.core.publisher.Flux<V> concatMapDelayError(java.util.function.Function<? super T,org.reactivestreams.Publisher<? extends V>> mapper)

Parameters:

mapper -

Returns:

See Also:

Flux.concatMapDelayError(java.util.function.Function)

concatMapDelayError

public final <V> reactor.core.publisher.Flux<V> concatMapDelayError(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends V>> mapper,
                                                                    int prefetch)

Parameters:

mapper -

prefetch -

Returns:

See Also:

Flux.concatMapDelayError(java.util.function.Function, int)

concatMapDelayError

public final <V> reactor.core.publisher.Flux<V> concatMapDelayError(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends V>> mapper,
                                                                    boolean delayUntilEnd,
                                                                    int prefetch)

Parameters:

mapper -

delayUntilEnd -

prefetch -

Returns:

See Also:

Flux.concatMapDelayError(java.util.function.Function, boolean, int)

concatMapIterable

public final <R> reactor.core.publisher.Flux<R> concatMapIterable(java.util.function.Function<? super T,? extends java.lang.Iterable<? extends R>> mapper)

Parameters:

mapper -

Returns:

See Also:

Flux.concatMapIterable(java.util.function.Function)

concatMapIterable

public final <R> reactor.core.publisher.Flux<R> concatMapIterable(java.util.function.Function<? super T,? extends java.lang.Iterable<? extends R>> mapper,
                                                                  int prefetch)

Parameters:

mapper -

prefetch -

Returns:

See Also:

Flux.concatMapIterable(java.util.function.Function, int)

concatWith

public final reactor.core.publisher.Flux<T> concatWith(org.reactivestreams.Publisher<? extends T> other)

Parameters:

other -

Returns:

See Also:

Flux.concatWith(org.reactivestreams.Publisher)

count

public final reactor.core.publisher.Mono<java.lang.Long> count()

Returns:

See Also:

Flux.count()

defaultIfEmpty

public final reactor.core.publisher.Flux<T> defaultIfEmpty(T defaultV)

Parameters:

defaultV -

Returns:

See Also:

Flux.defaultIfEmpty(java.lang.Object)

delay

public final reactor.core.publisher.Flux<T> delay(java.time.Duration delay)

Parameters:

delay -

Returns:

See Also:

Flux.delay(java.time.Duration)

delayMillis

public final reactor.core.publisher.Flux<T> delayMillis(long delay)

Parameters:

delay -

Returns:

See Also:

Flux.delayMillis(long)

delayMillis

public final reactor.core.publisher.Flux<T> delayMillis(long delay,
                                                        reactor.core.scheduler.TimedScheduler timer)

Parameters:

delay -

timer -

Returns:

See Also:

Flux.delayMillis(long, reactor.core.scheduler.TimedScheduler)

delaySubscription

public final reactor.core.publisher.Flux<T> delaySubscription(java.time.Duration delay)

Parameters:

delay -

Returns:

See Also:

Flux.delaySubscription(java.time.Duration)

delaySubscription

public final <U> reactor.core.publisher.Flux<T> delaySubscription(org.reactivestreams.Publisher<U> subscriptionDelay)

Parameters:

subscriptionDelay -

Returns:

See Also:

Flux.delaySubscription(org.reactivestreams.Publisher)

delaySubscriptionMillis

public final reactor.core.publisher.Flux<T> delaySubscriptionMillis(long delay)

Parameters:

delay -

Returns:

See Also:

Flux.delaySubscriptionMillis(long)

delaySubscriptionMillis

public final reactor.core.publisher.Flux<T> delaySubscriptionMillis(long delay,
                                                                    reactor.core.scheduler.TimedScheduler timer)

Parameters:

delay -

timer -

Returns:

See Also:

Flux.delaySubscriptionMillis(long, reactor.core.scheduler.TimedScheduler)

dematerialize

public final <X> reactor.core.publisher.Flux<X> dematerialize()

Returns:

See Also:

Flux.dematerialize()

distinct

public final reactor.core.publisher.Flux<T> distinct()

Returns:

See Also:

Flux.distinct()

distinct

public final <V> reactor.core.publisher.Flux<T> distinct(java.util.function.Function<? super T,? extends V> keySelector)

Parameters:

keySelector -

Returns:

See Also:

Flux.distinct(java.util.function.Function)

distinctUntilChanged

public final reactor.core.publisher.Flux<T> distinctUntilChanged()

Returns:

See Also:

Flux.distinctUntilChanged()

distinctUntilChanged

public final <V> reactor.core.publisher.Flux<T> distinctUntilChanged(java.util.function.Function<? super T,? extends V> keySelector)

Parameters:

keySelector -

Returns:

See Also:

Flux.distinctUntilChanged(java.util.function.Function)

doAfterTerminate

public final reactor.core.publisher.Flux<T> doAfterTerminate(java.lang.Runnable afterTerminate)

Parameters:

afterTerminate -

Returns:

See Also:

Flux.doAfterTerminate(java.lang.Runnable)

doOnCancel

public final reactor.core.publisher.Flux<T> doOnCancel(java.lang.Runnable onCancel)

Parameters:

onCancel -

Returns:

See Also:

Flux.doOnCancel(java.lang.Runnable)

doOnComplete

public final reactor.core.publisher.Flux<T> doOnComplete(java.lang.Runnable onComplete)

Parameters:

onComplete -

Returns:

See Also:

Flux.doOnComplete(java.lang.Runnable)

doOnError

public final reactor.core.publisher.Flux<T> doOnError(java.util.function.Consumer<? super java.lang.Throwable> onError)

Parameters:

onError -

Returns:

See Also:

Flux.doOnError(java.util.function.Consumer)

doOnError

public final <E extends java.lang.Throwable> reactor.core.publisher.Flux<T> doOnError(java.lang.Class<E> exceptionType,
                                                                                      java.util.function.Consumer<? super E> onError)

Parameters:

exceptionType -

onError -

Returns:

See Also:

Flux.doOnError(java.lang.Class, java.util.function.Consumer)

doOnError

public final reactor.core.publisher.Flux<T> doOnError(java.util.function.Predicate<? super java.lang.Throwable> predicate,
                                                      java.util.function.Consumer<? super java.lang.Throwable> onError)

Parameters:

predicate -

onError -

Returns:

See Also:

Flux.doOnError(java.util.function.Predicate, java.util.function.Consumer)

doOnNext

public final reactor.core.publisher.Flux<T> doOnNext(java.util.function.Consumer<? super T> onNext)

Parameters:

onNext -

Returns:

See Also:

Flux.doOnNext(java.util.function.Consumer)

doOnRequest

public final reactor.core.publisher.Flux<T> doOnRequest(java.util.function.LongConsumer consumer)

Parameters:

consumer -

Returns:

See Also:

Flux.doOnRequest(java.util.function.LongConsumer)

doOnSubscribe

public final reactor.core.publisher.Flux<T> doOnSubscribe(java.util.function.Consumer<? super org.reactivestreams.Subscription> onSubscribe)

Parameters:

onSubscribe -

Returns:

See Also:

Flux.doOnSubscribe(java.util.function.Consumer)

doOnTerminate

public final reactor.core.publisher.Flux<T> doOnTerminate(java.lang.Runnable onTerminate)

Parameters:

onTerminate -

Returns:

See Also:

Flux.doOnTerminate(java.lang.Runnable)

elapsed

public final reactor.core.publisher.Flux<reactor.util.function.Tuple2<java.lang.Long,T>> elapsed()

Returns:

See Also:

Flux.elapsed()

elapsed

public final reactor.core.publisher.Flux<reactor.util.function.Tuple2<java.lang.Long,T>> elapsed(reactor.core.scheduler.TimedScheduler scheduler)

Parameters:

scheduler -

Returns:

See Also:

Flux.elapsed(reactor.core.scheduler.TimedScheduler)

elementAt

public final reactor.core.publisher.Mono<T> elementAt(int index)

Parameters:

index -

Returns:

See Also:

Flux.elementAt(int)

elementAt

public final reactor.core.publisher.Mono<T> elementAt(int index,
                                                      T defaultValue)

Parameters:

index -

defaultValue -

Returns:

See Also:

Flux.elementAt(int, java.lang.Object)

filter

public final reactor.core.publisher.Flux<T> filter(java.util.function.Predicate<? super T> p)

Parameters:

p -

Returns:

See Also:

Flux.filter(java.util.function.Predicate)

firstEmittingWith

public final reactor.core.publisher.Flux<T> firstEmittingWith(org.reactivestreams.Publisher<? extends T> other)

Parameters:

other -

Returns:

See Also:

Flux.firstEmittingWith(org.reactivestreams.Publisher)

flatMap

public final <R> reactor.core.publisher.Flux<R> flatMap(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper)

Parameters:

mapper -

Returns:

See Also:

Flux.flatMap(java.util.function.Function)

flatMap

public final <V> reactor.core.publisher.Flux<V> flatMap(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends V>> mapper,
                                                        int concurrency)

Parameters:

mapper -

concurrency -

Returns:

See Also:

Flux.flatMap(java.util.function.Function, int)

flatMap

public final <V> reactor.core.publisher.Flux<V> flatMap(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends V>> mapper,
                                                        int concurrency,
                                                        int prefetch)

Parameters:

mapper -

concurrency -

prefetch -

Returns:

See Also:

Flux.flatMap(java.util.function.Function, int, int)

flatMap

public final <V> reactor.core.publisher.Flux<V> flatMap(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends V>> mapper,
                                                        boolean delayError,
                                                        int concurrency,
                                                        int prefetch)

Parameters:

mapper -

delayError -

concurrency -

prefetch -

Returns:

See Also:

Flux.flatMap(java.util.function.Function, boolean, int, int)

flatMap

public final <R> reactor.core.publisher.Flux<R> flatMap(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapperOnNext,
                                                        java.util.function.Function<java.lang.Throwable,? extends org.reactivestreams.Publisher<? extends R>> mapperOnError,
                                                        java.util.function.Supplier<? extends org.reactivestreams.Publisher<? extends R>> mapperOnComplete)

Parameters:

mapperOnNext -

mapperOnError -

mapperOnComplete -

Returns:

See Also:

Flux.flatMap(java.util.function.Function, java.util.function.Function, java.util.function.Supplier)

flatMapIterable

public final <R> reactor.core.publisher.Flux<R> flatMapIterable(java.util.function.Function<? super T,? extends java.lang.Iterable<? extends R>> mapper)

Parameters:

mapper -

Returns:

See Also:

Flux.flatMapIterable(java.util.function.Function)

flatMapIterable

public final <R> reactor.core.publisher.Flux<R> flatMapIterable(java.util.function.Function<? super T,? extends java.lang.Iterable<? extends R>> mapper,
                                                                int prefetch)

Parameters:

mapper -

prefetch -

Returns:

See Also:

Flux.flatMapIterable(java.util.function.Function, int)

getPrefetch

public long getPrefetch()

Returns:

See Also:

Flux.getPrefetch()

groupBy

public final <K> reactor.core.publisher.Flux<reactor.core.publisher.GroupedFlux<K,T>> groupBy(java.util.function.Function<? super T,? extends K> keyMapper)

Parameters:

keyMapper -

Returns:

See Also:

Flux.groupBy(java.util.function.Function)

groupBy

public final <K,V> reactor.core.publisher.Flux<reactor.core.publisher.GroupedFlux<K,V>> groupBy(java.util.function.Function<? super T,? extends K> keyMapper,
                                                                                                java.util.function.Function<? super T,? extends V> valueMapper)

Parameters:

keyMapper -

valueMapper -

Returns:

See Also:

Flux.groupBy(java.util.function.Function, java.util.function.Function)

groupJoin

public final <TRight,TLeftEnd,TRightEnd,R> reactor.core.publisher.Flux<R> groupJoin(org.reactivestreams.Publisher<? extends TRight> other,
                                                                                    java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<TLeftEnd>> leftEnd,
                                                                                    java.util.function.Function<? super TRight,? extends org.reactivestreams.Publisher<TRightEnd>> rightEnd,
                                                                                    java.util.function.BiFunction<? super T,? super reactor.core.publisher.Flux<TRight>,? extends R> resultSelector)

Parameters:

other -

leftEnd -

rightEnd -

resultSelector -

Returns:

See Also:

Flux.groupJoin(org.reactivestreams.Publisher, java.util.function.Function, java.util.function.Function, java.util.function.BiFunction)

handle

public final <R> reactor.core.publisher.Flux<R> handle(java.util.function.BiConsumer<? super T,reactor.core.publisher.SynchronousSink<R>> handler)

Parameters:

handler -

Returns:

See Also:

Flux.handle(java.util.function.BiConsumer)

hasElement

public final reactor.core.publisher.Mono<java.lang.Boolean> hasElement(T value)

Parameters:

value -

Returns:

See Also:

Flux.hasElement(java.lang.Object)

hasElements

public final reactor.core.publisher.Mono<java.lang.Boolean> hasElements()

Returns:

See Also:

Flux.hasElements()

hide

public final reactor.core.publisher.Flux<T> hide()

Returns:

See Also:

Flux.hide()

ignoreElements

public final reactor.core.publisher.Mono<T> ignoreElements()

Returns:

See Also:

Flux.ignoreElements()

join

public final <TRight,TLeftEnd,TRightEnd,R> reactor.core.publisher.Flux<R> join(org.reactivestreams.Publisher<? extends TRight> other,
                                                                               java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<TLeftEnd>> leftEnd,
                                                                               java.util.function.Function<? super TRight,? extends org.reactivestreams.Publisher<TRightEnd>> rightEnd,
                                                                               java.util.function.BiFunction<? super T,? super TRight,? extends R> resultSelector)

Parameters:

other -

leftEnd -

rightEnd -

resultSelector -

Returns:

See Also:

Flux.join(org.reactivestreams.Publisher, java.util.function.Function, java.util.function.Function, java.util.function.BiFunction)

last

public final reactor.core.publisher.Mono<T> last()

Returns:

See Also:

Flux.last()

last

public final reactor.core.publisher.Mono<T> last(T defaultValue)

Parameters:

defaultValue -

Returns:

See Also:

Flux.last(java.lang.Object)

log

public final reactor.core.publisher.Flux<T> log()

Returns:

See Also:

Flux.log()

log

public final reactor.core.publisher.Flux<T> log(java.lang.String category)

Parameters:

category -

Returns:

See Also:

Flux.log(java.lang.String)

log

public final reactor.core.publisher.Flux<T> log(java.lang.String category,
                                                java.util.logging.Level level,
                                                reactor.core.publisher.SignalType... options)

Parameters:

category -

level -

options -

Returns:

See Also:

Flux.log(java.lang.String, java.util.logging.Level, reactor.core.publisher.SignalType[])

log

public final reactor.core.publisher.Flux<T> log(java.lang.String category,
                                                java.util.logging.Level level,
                                                boolean showOperatorLine,
                                                reactor.core.publisher.SignalType... options)

Parameters:

category -

level -

showOperatorLine -

options -

Returns:

See Also:

Flux.log(java.lang.String, java.util.logging.Level, boolean, reactor.core.publisher.SignalType[])

map

public final <V> reactor.core.publisher.Flux<V> map(java.util.function.Function<? super T,? extends V> mapper)

Parameters:

mapper -

Returns:

See Also:

Flux.map(java.util.function.Function)

mapError

public final reactor.core.publisher.Flux<T> mapError(java.util.function.Function<? super java.lang.Throwable,? extends java.lang.Throwable> mapper)

Parameters:

mapper -

Returns:

See Also:

Flux.mapError(java.util.function.Function)

mapError

public final <E extends java.lang.Throwable> reactor.core.publisher.Flux<T> mapError(java.lang.Class<E> type,
                                                                                     java.util.function.Function<? super E,? extends java.lang.Throwable> mapper)

Parameters:

type -

mapper -

Returns:

See Also:

Flux.mapError(java.lang.Class, java.util.function.Function)

mapError

public final reactor.core.publisher.Flux<T> mapError(java.util.function.Predicate<? super java.lang.Throwable> predicate,
                                                     java.util.function.Function<? super java.lang.Throwable,? extends java.lang.Throwable> mapper)

Parameters:

predicate -

mapper -

Returns:

See Also:

Flux.mapError(java.util.function.Predicate, java.util.function.Function)

materialize

public final reactor.core.publisher.Flux<reactor.core.publisher.Signal<T>> materialize()

Returns:

See Also:

Flux.materialize()

mergeWith

public final reactor.core.publisher.Flux<T> mergeWith(org.reactivestreams.Publisher<? extends T> other)

Parameters:

other -

Returns:

See Also:

Flux.mergeWith(org.reactivestreams.Publisher)

next

public final reactor.core.publisher.Mono<T> next()

Returns:

See Also:

Flux.next()

ofType

public final <U> reactor.core.publisher.Flux<U> ofType(java.lang.Class<U> clazz)

Parameters:

clazz -

Returns:

See Also:

Flux.ofType(java.lang.Class)

onBackpressureBuffer

public final reactor.core.publisher.Flux<T> onBackpressureBuffer()

Returns:

See Also:

Flux.onBackpressureBuffer()

onBackpressureBuffer

public final reactor.core.publisher.Flux<T> onBackpressureBuffer(int maxSize)

Parameters:

maxSize -

Returns:

See Also:

Flux.onBackpressureBuffer(int)

onBackpressureBuffer

public final reactor.core.publisher.Flux<T> onBackpressureBuffer(int maxSize,
                                                                 java.util.function.Consumer<? super T> onOverflow)

Parameters:

maxSize -

onOverflow -

Returns:

See Also:

Flux.onBackpressureBuffer(int, java.util.function.Consumer)

onBackpressureDrop

public final reactor.core.publisher.Flux<T> onBackpressureDrop()

Returns:

See Also:

Flux.onBackpressureDrop()

onBackpressureDrop

public final reactor.core.publisher.Flux<T> onBackpressureDrop(java.util.function.Consumer<? super T> onDropped)

Parameters:

onDropped -

Returns:

See Also:

Flux.onBackpressureDrop(java.util.function.Consumer)

onBackpressureError

public final reactor.core.publisher.Flux<T> onBackpressureError()

Returns:

See Also:

Flux.onBackpressureError()

onBackpressureLatest

public final reactor.core.publisher.Flux<T> onBackpressureLatest()

Returns:

See Also:

Flux.onBackpressureLatest()

onErrorResumeWith

public final reactor.core.publisher.Flux<T> onErrorResumeWith(java.util.function.Function<? super java.lang.Throwable,? extends org.reactivestreams.Publisher<? extends T>> fallback)

Parameters:

fallback -

Returns:

See Also:

Flux.onErrorResumeWith(java.util.function.Function)

onErrorResumeWith

public final <E extends java.lang.Throwable> reactor.core.publisher.Flux<T> onErrorResumeWith(java.lang.Class<E> type,
                                                                                              java.util.function.Function<? super E,? extends org.reactivestreams.Publisher<? extends T>> fallback)

Parameters:

type -

fallback -

Returns:

See Also:

Flux.onErrorResumeWith(java.lang.Class, java.util.function.Function)

onErrorResumeWith

public final reactor.core.publisher.Flux<T> onErrorResumeWith(java.util.function.Predicate<? super java.lang.Throwable> predicate,
                                                              java.util.function.Function<? super java.lang.Throwable,? extends org.reactivestreams.Publisher<? extends T>> fallback)

Parameters:

predicate -

fallback -

Returns:

See Also:

Flux.onErrorResumeWith(java.util.function.Predicate, java.util.function.Function)

onErrorReturn

public final reactor.core.publisher.Flux<T> onErrorReturn(T fallbackValue)

Parameters:

fallbackValue -

Returns:

See Also:

Flux.onErrorReturn(java.lang.Object)

onErrorReturn

public final <E extends java.lang.Throwable> reactor.core.publisher.Flux<T> onErrorReturn(java.lang.Class<E> type,
                                                                                          T fallbackValue)

Parameters:

type -

fallbackValue -

Returns:

See Also:

Flux.onErrorReturn(java.lang.Class, java.lang.Object)

onErrorReturn

public final <E extends java.lang.Throwable> reactor.core.publisher.Flux<T> onErrorReturn(java.util.function.Predicate<? super java.lang.Throwable> predicate,
                                                                                          T fallbackValue)

Parameters:

predicate -

fallbackValue -

Returns:

See Also:

Flux.onErrorReturn(java.util.function.Predicate, java.lang.Object)

onTerminateDetach

public final reactor.core.publisher.Flux<T> onTerminateDetach()

Returns:

See Also:

Flux.onTerminateDetach()

parallel

public final reactor.core.publisher.ParallelFlux<T> parallel()

Returns:

See Also:

Flux.parallel()

parallel

public final reactor.core.publisher.ParallelFlux<T> parallel(int parallelism)

Parameters:

parallelism -

Returns:

See Also:

Flux.parallel(int)

parallel

public final reactor.core.publisher.ParallelFlux<T> parallel(int parallelism,
                                                             int prefetch)

Parameters:

parallelism -

prefetch -

Returns:

See Also:

Flux.parallel(int, int)

publish

public final reactor.core.publisher.ConnectableFlux<T> publish()

Returns:

See Also:

Flux.publish()

publish

public final reactor.core.publisher.ConnectableFlux<T> publish(int prefetch)

Parameters:

prefetch -

Returns:

See Also:

Flux.publish(int)

publish

public final <R> reactor.core.publisher.Flux<R> publish(java.util.function.Function<? super reactor.core.publisher.Flux<T>,? extends org.reactivestreams.Publisher<? extends R>> transform)

Parameters:

transform -

Returns:

See Also:

Flux.publish(java.util.function.Function)

publish

public final <R> reactor.core.publisher.Flux<R> publish(java.util.function.Function<? super reactor.core.publisher.Flux<T>,? extends org.reactivestreams.Publisher<? extends R>> transform,
                                                        int prefetch)

Parameters:

transform -

prefetch -

Returns:

See Also:

Flux.publish(java.util.function.Function, int)

publishNext

public final reactor.core.publisher.Mono<T> publishNext()

Returns:

See Also:

Flux.publishNext()

publishOn

public final reactor.core.publisher.Flux<T> publishOn(reactor.core.scheduler.Scheduler scheduler)

Parameters:

scheduler -

Returns:

See Also:

Flux.publishOn(reactor.core.scheduler.Scheduler)

publishOn

public final reactor.core.publisher.Flux<T> publishOn(reactor.core.scheduler.Scheduler scheduler,
                                                      int prefetch)

Parameters:

scheduler -

prefetch -

Returns:

See Also:

Flux.publishOn(reactor.core.scheduler.Scheduler, int)

reduce

public final reactor.core.publisher.Mono<T> reduce(java.util.function.BiFunction<T,T,T> aggregator)

Parameters:

aggregator -

Returns:

See Also:

Flux.reduce(java.util.function.BiFunction)

reduce

public final <A> reactor.core.publisher.Mono<A> reduce(A initial,
                                                       java.util.function.BiFunction<A,? super T,A> accumulator)

Parameters:

initial -

accumulator -

Returns:

See Also:

Flux.reduce(java.lang.Object, java.util.function.BiFunction)

reduceWith

public final <A> reactor.core.publisher.Mono<A> reduceWith(java.util.function.Supplier<A> initial,
                                                           java.util.function.BiFunction<A,? super T,A> accumulator)

Parameters:

initial -

accumulator -

Returns:

See Also:

Flux.reduceWith(java.util.function.Supplier, java.util.function.BiFunction)

repeat

public final reactor.core.publisher.Flux<T> repeat()

Returns:

See Also:

Flux.repeat()

repeat

public final reactor.core.publisher.Flux<T> repeat(java.util.function.BooleanSupplier predicate)

Parameters:

predicate -

Returns:

See Also:

Flux.repeat(java.util.function.BooleanSupplier)

repeat

public final reactor.core.publisher.Flux<T> repeat(long numRepeat)

Parameters:

numRepeat -

Returns:

See Also:

Flux.repeat(long)

repeat

public final reactor.core.publisher.Flux<T> repeat(long numRepeat,
                                                   java.util.function.BooleanSupplier predicate)

Parameters:

numRepeat -

predicate -

Returns:

See Also:

Flux.repeat(long, java.util.function.BooleanSupplier)

repeatWhen

public final reactor.core.publisher.Flux<T> repeatWhen(java.util.function.Function<reactor.core.publisher.Flux<java.lang.Long>,? extends org.reactivestreams.Publisher<?>> whenFactory)

Parameters:

whenFactory -

Returns:

See Also:

Flux.repeatWhen(java.util.function.Function)

replay

public final reactor.core.publisher.ConnectableFlux<T> replay()

Returns:

See Also:

Flux.replay()

replay

public final reactor.core.publisher.ConnectableFlux<T> replay(int history)

Parameters:

history -

Returns:

See Also:

Flux.replay(int)

replay

public final reactor.core.publisher.ConnectableFlux<T> replay(java.time.Duration ttl)

Parameters:

ttl -

Returns:

See Also:

Flux.replay(java.time.Duration)

replay

public final reactor.core.publisher.ConnectableFlux<T> replay(int history,
                                                              java.time.Duration ttl)

Parameters:

history -

ttl -

Returns:

See Also:

Flux.replay(int, java.time.Duration)

replayMillis

public final reactor.core.publisher.ConnectableFlux<T> replayMillis(long ttl,
                                                                    reactor.core.scheduler.TimedScheduler timer)

Parameters:

ttl -

timer -

Returns:

See Also:

Flux.replayMillis(long, reactor.core.scheduler.TimedScheduler)

replayMillis

public final reactor.core.publisher.ConnectableFlux<T> replayMillis(int history,
                                                                    long ttl,
                                                                    reactor.core.scheduler.TimedScheduler timer)

Parameters:

history -

ttl -

timer -

Returns:

See Also:

Flux.replayMillis(int, long, reactor.core.scheduler.TimedScheduler)

retry

public final reactor.core.publisher.Flux<T> retry()

Returns:

See Also:

Flux.retry()

retry

public final reactor.core.publisher.Flux<T> retry(long numRetries)

Parameters:

numRetries -

Returns:

See Also:

Flux.retry(long)

retry

public final reactor.core.publisher.Flux<T> retry(java.util.function.Predicate<java.lang.Throwable> retryMatcher)

Parameters:

retryMatcher -

Returns:

See Also:

Flux.retry(java.util.function.Predicate)

retry

public final reactor.core.publisher.Flux<T> retry(long numRetries,
                                                  java.util.function.Predicate<java.lang.Throwable> retryMatcher)

Parameters:

numRetries -

retryMatcher -

Returns:

See Also:

Flux.retry(long, java.util.function.Predicate)

retryWhen

public final reactor.core.publisher.Flux<T> retryWhen(java.util.function.Function<reactor.core.publisher.Flux<java.lang.Throwable>,? extends org.reactivestreams.Publisher<?>> whenFactory)

Parameters:

whenFactory -

Returns:

See Also:

Flux.retryWhen(java.util.function.Function)

sample

public final reactor.core.publisher.Flux<T> sample(java.time.Duration timespan)

Parameters:

timespan -

Returns:

See Also:

Flux.sample(java.time.Duration)

sample

public final <U> reactor.core.publisher.Flux<T> sample(org.reactivestreams.Publisher<U> sampler)

Parameters:

sampler -

Returns:

See Also:

Flux.sample(org.reactivestreams.Publisher)

sampleFirst

public final reactor.core.publisher.Flux<T> sampleFirst(java.time.Duration timespan)

Parameters:

timespan -

Returns:

See Also:

Flux.sampleFirst(java.time.Duration)

sampleFirst

public final <U> reactor.core.publisher.Flux<T> sampleFirst(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<U>> samplerFactory)

Parameters:

samplerFactory -

Returns:

See Also:

Flux.sampleFirst(java.util.function.Function)

sampleFirstMillis

public final reactor.core.publisher.Flux<T> sampleFirstMillis(long timespan)

Parameters:

timespan -

Returns:

See Also:

Flux.sampleFirstMillis(long)

sampleMillis

public final reactor.core.publisher.Flux<T> sampleMillis(long timespan)

Parameters:

timespan -

Returns:

See Also:

Flux.sampleMillis(long)

sampleTimeout

public final <U> reactor.core.publisher.Flux<T> sampleTimeout(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<U>> throttlerFactory)

Parameters:

throttlerFactory -

Returns:

See Also:

Flux.sampleTimeout(java.util.function.Function)

sampleTimeout

public final <U> reactor.core.publisher.Flux<T> sampleTimeout(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<U>> throttlerFactory,
                                                              int maxConcurrency)

Parameters:

throttlerFactory -

maxConcurrency -

Returns:

See Also:

Flux.sampleTimeout(java.util.function.Function, int)

scan

public final reactor.core.publisher.Flux<T> scan(java.util.function.BiFunction<T,T,T> accumulator)

Parameters:

accumulator -

Returns:

See Also:

Flux.scan(java.util.function.BiFunction)

scan

public final <A> reactor.core.publisher.Flux<A> scan(A initial,
                                                     java.util.function.BiFunction<A,? super T,A> accumulator)

Parameters:

initial -

accumulator -

Returns:

See Also:

Flux.scan(java.lang.Object, java.util.function.BiFunction)

scanWith

public final <A> reactor.core.publisher.Flux<A> scanWith(java.util.function.Supplier<A> initial,
                                                         java.util.function.BiFunction<A,? super T,A> accumulator)

Parameters:

initial -

accumulator -

Returns:

See Also:

Flux.scanWith(java.util.function.Supplier, java.util.function.BiFunction)

share

public final reactor.core.publisher.Flux<T> share()

Returns:

See Also:

Flux.share()

single

public final reactor.core.publisher.Mono<T> single()

Returns:

See Also:

Flux.single()

single

public final reactor.core.publisher.Mono<T> single(T defaultValue)

Parameters:

defaultValue -

Returns:

See Also:

Flux.single(java.lang.Object)

singleOrEmpty

public final reactor.core.publisher.Mono<T> singleOrEmpty()

Returns:

See Also:

Flux.singleOrEmpty()

skip

public final reactor.core.publisher.Flux<T> skip(long skipped)

Parameters:

skipped -

Returns:

See Also:

Flux.skip(long)

skip

public final reactor.core.publisher.Flux<T> skip(java.time.Duration timespan)

Parameters:

timespan -

Returns:

See Also:

Flux.skip(java.time.Duration)

skipLast

public final reactor.core.publisher.Flux<T> skipLast(int n)

Parameters:

n -

Returns:

See Also:

Flux.skipLast(int)

skipMillis

public final reactor.core.publisher.Flux<T> skipMillis(long timespan)

Parameters:

timespan -

Returns:

See Also:

Flux.skipMillis(long)

skipMillis

public final reactor.core.publisher.Flux<T> skipMillis(long timespan,
                                                       reactor.core.scheduler.TimedScheduler timer)

Parameters:

timespan -

timer -

Returns:

See Also:

Flux.skipMillis(long, reactor.core.scheduler.TimedScheduler)

skipUntil

public final reactor.core.publisher.Flux<T> skipUntil(java.util.function.Predicate<? super T> untilPredicate)

Parameters:

untilPredicate -

Returns:

See Also:

Flux.skipUntil(java.util.function.Predicate)

skipUntilOther

public final reactor.core.publisher.Flux<T> skipUntilOther(org.reactivestreams.Publisher<?> other)

Parameters:

other -

Returns:

See Also:

Flux.skipUntilOther(org.reactivestreams.Publisher)

skipWhile

public final reactor.core.publisher.Flux<T> skipWhile(java.util.function.Predicate<? super T> skipPredicate)

Parameters:

skipPredicate -

Returns:

See Also:

Flux.skipWhile(java.util.function.Predicate)

sort

public final reactor.core.publisher.Flux<T> sort()

Returns:

See Also:

Flux.sort()

sort

public final reactor.core.publisher.Flux<T> sort(java.util.Comparator<? super T> sortFunction)

Parameters:

sortFunction -

Returns:

See Also:

Flux.sort(java.util.Comparator)

startWith

public final reactor.core.publisher.Flux<T> startWith(java.lang.Iterable<? extends T> iterable)

Parameters:

iterable -

Returns:

See Also:

Flux.startWith(java.lang.Iterable)

startWith

public final reactor.core.publisher.Flux<T> startWith(T... values)

Parameters:

values -

Returns:

See Also:

Flux.startWith(java.lang.Object[])

startWith

public final reactor.core.publisher.Flux<T> startWith(org.reactivestreams.Publisher<? extends T> publisher)

Parameters:

publisher -

Returns:

See Also:

Flux.startWith(org.reactivestreams.Publisher)

subscribe

public final reactor.core.Cancellation subscribe()

Returns:

See Also:

Flux.subscribe()

subscribe

public final reactor.core.Cancellation subscribe(int prefetch)

Parameters:

prefetch -

Returns:

See Also:

Flux.subscribe(int)

subscribe

public final reactor.core.Cancellation subscribe(java.util.function.Consumer<? super T> consumer)

Parameters:

consumer -

Returns:

See Also:

Flux.subscribe(java.util.function.Consumer)

subscribe

public final reactor.core.Cancellation subscribe(java.util.function.Consumer<? super T> consumer,
                                                 int prefetch)

Parameters:

consumer -

prefetch -

Returns:

See Also:

Flux.subscribe(java.util.function.Consumer, int)

subscribe

public final reactor.core.Cancellation subscribe(java.util.function.Consumer<? super T> consumer,
                                                 java.util.function.Consumer<? super java.lang.Throwable> errorConsumer)

Parameters:

consumer -

errorConsumer -

Returns:

See Also:

Flux.subscribe(java.util.function.Consumer, java.util.function.Consumer)

subscribe

public final reactor.core.Cancellation subscribe(java.util.function.Consumer<? super T> consumer,
                                                 java.util.function.Consumer<? super java.lang.Throwable> errorConsumer,
                                                 java.lang.Runnable completeConsumer)

Parameters:

consumer -

errorConsumer -

completeConsumer -

Returns:

See Also:

Flux.subscribe(java.util.function.Consumer, java.util.function.Consumer, java.lang.Runnable)

subscribe

public final reactor.core.Cancellation subscribe(java.util.function.Consumer<? super T> consumer,
                                                 java.util.function.Consumer<? super java.lang.Throwable> errorConsumer,
                                                 java.lang.Runnable completeConsumer,
                                                 int prefetch)

Parameters:

consumer -

errorConsumer -

completeConsumer -

prefetch -

Returns:

See Also:

Flux.subscribe(java.util.function.Consumer, java.util.function.Consumer, java.lang.Runnable, int)

subscribeOn

public final reactor.core.publisher.Flux<T> subscribeOn(reactor.core.scheduler.Scheduler scheduler)

Parameters:

scheduler -

Returns:

See Also:

Flux.subscribeOn(reactor.core.scheduler.Scheduler)

subscribeWith

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

Parameters:

subscriber -

Returns:

See Also:

Flux.subscribeWith(org.reactivestreams.Subscriber)

switchIfEmpty

public final reactor.core.publisher.Flux<T> switchIfEmpty(org.reactivestreams.Publisher<? extends T> alternate)

Parameters:

alternate -

Returns:

See Also:

Flux.switchIfEmpty(org.reactivestreams.Publisher)

switchMap

public final <V> reactor.core.publisher.Flux<V> switchMap(java.util.function.Function<? super T,org.reactivestreams.Publisher<? extends V>> fn)

Parameters:

fn -

Returns:

See Also:

Flux.switchMap(java.util.function.Function)

switchMap

public final <V> reactor.core.publisher.Flux<V> switchMap(java.util.function.Function<? super T,org.reactivestreams.Publisher<? extends V>> fn,
                                                          int prefetch)

Parameters:

fn -

prefetch -

Returns:

See Also:

Flux.switchMap(java.util.function.Function, int)

switchOnError

public final <E extends java.lang.Throwable> reactor.core.publisher.Flux<T> switchOnError(java.lang.Class<E> type,
                                                                                          org.reactivestreams.Publisher<? extends T> fallback)

Parameters:

type -

fallback -

Returns:

See Also:

Flux.switchOnError(java.lang.Class, org.reactivestreams.Publisher)

switchOnError

public final reactor.core.publisher.Flux<T> switchOnError(java.util.function.Predicate<? super java.lang.Throwable> predicate,
                                                          org.reactivestreams.Publisher<? extends T> fallback)

Parameters:

predicate -

fallback -

Returns:

See Also:

Flux.switchOnError(java.util.function.Predicate, org.reactivestreams.Publisher)

switchOnError

public final reactor.core.publisher.Flux<T> switchOnError(org.reactivestreams.Publisher<? extends T> fallback)

Parameters:

fallback -

Returns:

See Also:

Flux.switchOnError(org.reactivestreams.Publisher)

take

public final reactor.core.publisher.Flux<T> take(long n)

Parameters:

n -

Returns:

See Also:

Flux.take(long)

take

public final reactor.core.publisher.Flux<T> take(java.time.Duration timespan)

Parameters:

timespan -

Returns:

See Also:

Flux.take(java.time.Duration)

takeLast

public final reactor.core.publisher.Flux<T> takeLast(int n)

Parameters:

n -

Returns:

See Also:

Flux.takeLast(int)

takeMillis

public final reactor.core.publisher.Flux<T> takeMillis(long timespan)

Parameters:

timespan -

Returns:

See Also:

Flux.takeMillis(long)

takeMillis

public final reactor.core.publisher.Flux<T> takeMillis(long timespan,
                                                       reactor.core.scheduler.TimedScheduler timer)

Parameters:

timespan -

timer -

Returns:

See Also:

Flux.takeMillis(long, reactor.core.scheduler.TimedScheduler)

takeUntil

public final reactor.core.publisher.Flux<T> takeUntil(java.util.function.Predicate<? super T> predicate)

Parameters:

predicate -

Returns:

See Also:

Flux.takeUntil(java.util.function.Predicate)

takeUntilOther

public final reactor.core.publisher.Flux<T> takeUntilOther(org.reactivestreams.Publisher<?> other)

Parameters:

other -

Returns:

See Also:

Flux.takeUntilOther(org.reactivestreams.Publisher)

takeWhile

public final reactor.core.publisher.Flux<T> takeWhile(java.util.function.Predicate<? super T> continuePredicate)

Parameters:

continuePredicate -

Returns:

See Also:

Flux.takeWhile(java.util.function.Predicate)

then

public final reactor.core.publisher.Mono<java.lang.Void> then()

Returns:

See Also:

Flux.then()

then

public final reactor.core.publisher.Mono<java.lang.Void> then(org.reactivestreams.Publisher<java.lang.Void> other)

Parameters:

other -

Returns:

See Also:

Flux.then(org.reactivestreams.Publisher)

then

public final reactor.core.publisher.Mono<java.lang.Void> then(java.util.function.Supplier<? extends org.reactivestreams.Publisher<java.lang.Void>> afterSupplier)

Parameters:

afterSupplier -

Returns:

See Also:

Flux.then(java.util.function.Supplier)

thenMany

public final <V> reactor.core.publisher.Flux<V> thenMany(org.reactivestreams.Publisher<V> other)

Parameters:

other -

Returns:

See Also:

Flux.thenMany(org.reactivestreams.Publisher)

thenMany

public final <V> reactor.core.publisher.Flux<V> thenMany(java.util.function.Supplier<? extends org.reactivestreams.Publisher<V>> afterSupplier)

Parameters:

afterSupplier -

Returns:

See Also:

Flux.thenMany(java.util.function.Supplier)

timeout

public final reactor.core.publisher.Flux<T> timeout(java.time.Duration timeout)

Parameters:

timeout -

Returns:

See Also:

Flux.timeout(java.time.Duration)

timeout

public final reactor.core.publisher.Flux<T> timeout(java.time.Duration timeout,
                                                    org.reactivestreams.Publisher<? extends T> fallback)

Parameters:

timeout -

fallback -

Returns:

See Also:

Flux.timeout(java.time.Duration, org.reactivestreams.Publisher)

timeout

public final <U> reactor.core.publisher.Flux<T> timeout(org.reactivestreams.Publisher<U> firstTimeout)

Parameters:

firstTimeout -

Returns:

See Also:

Flux.timeout(org.reactivestreams.Publisher)

timeout

public final <U,V> reactor.core.publisher.Flux<T> timeout(org.reactivestreams.Publisher<U> firstTimeout,
                                                          java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<V>> nextTimeoutFactory)

Parameters:

firstTimeout -

nextTimeoutFactory -

Returns:

See Also:

Flux.timeout(org.reactivestreams.Publisher, java.util.function.Function)

timeout

public final <U,V> reactor.core.publisher.Flux<T> timeout(org.reactivestreams.Publisher<U> firstTimeout,
                                                          java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<V>> nextTimeoutFactory,
                                                          org.reactivestreams.Publisher<? extends T> fallback)

Parameters:

firstTimeout -

nextTimeoutFactory -

fallback -

Returns:

See Also:

Flux.timeout(org.reactivestreams.Publisher, java.util.function.Function, org.reactivestreams.Publisher)

timeoutMillis

public final reactor.core.publisher.Flux<T> timeoutMillis(long timeout)

Parameters:

timeout -

Returns:

See Also:

Flux.timeoutMillis(long)

timeoutMillis

public final reactor.core.publisher.Flux<T> timeoutMillis(long timeout,
                                                          reactor.core.scheduler.TimedScheduler timer)

Parameters:

timeout -

timer -

Returns:

See Also:

Flux.timeoutMillis(long, reactor.core.scheduler.TimedScheduler)

timeoutMillis

public final reactor.core.publisher.Flux<T> timeoutMillis(long timeout,
                                                          org.reactivestreams.Publisher<? extends T> fallback)

Parameters:

timeout -

fallback -

Returns:

See Also:

Flux.timeoutMillis(long, org.reactivestreams.Publisher)

timeoutMillis

public final reactor.core.publisher.Flux<T> timeoutMillis(long timeout,
                                                          org.reactivestreams.Publisher<? extends T> fallback,
                                                          reactor.core.scheduler.TimedScheduler timer)

Parameters:

timeout -

fallback -

timer -

Returns:

See Also:

Flux.timeoutMillis(long, org.reactivestreams.Publisher, reactor.core.scheduler.TimedScheduler)

timestamp

public final reactor.core.publisher.Flux<reactor.util.function.Tuple2<java.lang.Long,T>> timestamp()

Returns:

See Also:

Flux.timestamp()

timestamp

public final reactor.core.publisher.Flux<reactor.util.function.Tuple2<java.lang.Long,T>> timestamp(reactor.core.scheduler.TimedScheduler scheduler)

Parameters:

scheduler -

Returns:

See Also:

Flux.timestamp(reactor.core.scheduler.TimedScheduler)

toIterable

public final java.lang.Iterable<T> toIterable()

Returns:

See Also:

Flux.toIterable()

toIterable

public final java.lang.Iterable<T> toIterable(long batchSize)

Parameters:

batchSize -

Returns:

See Also:

Flux.toIterable(long)

toIterable

public final java.lang.Iterable<T> toIterable(long batchSize,
                                              java.util.function.Supplier<java.util.Queue<T>> queueProvider)

Parameters:

batchSize -

queueProvider -

Returns:

See Also:

Flux.toIterable(long, java.util.function.Supplier)

toStream

public java.util.stream.Stream<T> toStream()

Returns:

See Also:

Flux.toStream()

toStream

public java.util.stream.Stream<T> toStream(int batchSize)

Parameters:

batchSize -

Returns:

See Also:

Flux.toStream(int)

transform

public final <V> reactor.core.publisher.Flux<V> transform(java.util.function.Function<? super reactor.core.publisher.Flux<T>,? extends org.reactivestreams.Publisher<V>> transformer)

Parameters:

transformer -

Returns:

See Also:

Flux.transform(java.util.function.Function)

window

public final reactor.core.publisher.Flux<reactor.core.publisher.Flux<T>> window()

Returns:

See Also:

Flux.window()

window

public final reactor.core.publisher.Flux<reactor.core.publisher.Flux<T>> window(int maxSize)

Parameters:

maxSize -

Returns:

See Also:

Flux.window(int)

window

public final reactor.core.publisher.Flux<reactor.core.publisher.Flux<T>> window(int maxSize,
                                                                                int skip)

Parameters:

maxSize -

skip -

Returns:

See Also:

Flux.window(int, int)

window

public final reactor.core.publisher.Flux<reactor.core.publisher.Flux<T>> window(org.reactivestreams.Publisher<?> boundary)

Parameters:

boundary -

Returns:

See Also:

Flux.window(org.reactivestreams.Publisher)

window

public final <U,V> reactor.core.publisher.Flux<reactor.core.publisher.Flux<T>> window(org.reactivestreams.Publisher<U> bucketOpening,
                                                                                      java.util.function.Function<? super U,? extends org.reactivestreams.Publisher<V>> closeSelector)

Parameters:

bucketOpening -

closeSelector -

Returns:

See Also:

Flux.window(org.reactivestreams.Publisher, java.util.function.Function)

window

public final reactor.core.publisher.Flux<reactor.core.publisher.Flux<T>> window(java.time.Duration timespan)

Parameters:

timespan -

Returns:

See Also:

Flux.window(java.time.Duration)

window

public final reactor.core.publisher.Flux<reactor.core.publisher.Flux<T>> window(java.time.Duration timespan,
                                                                                java.time.Duration timeshift)

Parameters:

timespan -

timeshift -

Returns:

See Also:

Flux.window(java.time.Duration, java.time.Duration)

window

public final reactor.core.publisher.Flux<reactor.core.publisher.Flux<T>> window(int maxSize,
                                                                                java.time.Duration timespan)

Parameters:

maxSize -

timespan -

Returns:

See Also:

Flux.window(int, java.time.Duration)

windowMillis

public final reactor.core.publisher.Flux<reactor.core.publisher.Flux<T>> windowMillis(long timespan)

Parameters:

timespan -

Returns:

See Also:

Flux.windowMillis(long)

windowMillis

public final reactor.core.publisher.Flux<reactor.core.publisher.Flux<T>> windowMillis(long timespan,
                                                                                      reactor.core.scheduler.TimedScheduler timer)

Parameters:

timespan -

timer -

Returns:

See Also:

Flux.windowMillis(long, reactor.core.scheduler.TimedScheduler)

windowMillis

public final reactor.core.publisher.Flux<reactor.core.publisher.Flux<T>> windowMillis(long timespan,
                                                                                      long timeshift,
                                                                                      reactor.core.scheduler.TimedScheduler timer)

Parameters:

timespan -

timeshift -

timer -

Returns:

See Also:

Flux.windowMillis(long, long, reactor.core.scheduler.TimedScheduler)

windowMillis

public final reactor.core.publisher.Flux<reactor.core.publisher.Flux<T>> windowMillis(int maxSize,
                                                                                      long timespan)

Parameters:

maxSize -

timespan -

Returns:

See Also:

Flux.windowMillis(int, long)

windowMillis

public final reactor.core.publisher.Flux<reactor.core.publisher.Flux<T>> windowMillis(int maxSize,
                                                                                      long timespan,
                                                                                      reactor.core.scheduler.TimedScheduler timer)

Parameters:

maxSize -

timespan -

timer -

Returns:

See Also:

Flux.windowMillis(int, long, reactor.core.scheduler.TimedScheduler)

withLatestFrom

public final <U,R> reactor.core.publisher.Flux<R> withLatestFrom(org.reactivestreams.Publisher<? extends U> other,
                                                                 java.util.function.BiFunction<? super T,? super U,? extends R> resultSelector)

Parameters:

other -

resultSelector -

Returns:

See Also:

Flux.withLatestFrom(org.reactivestreams.Publisher, java.util.function.BiFunction)

zipWith

public final <T2,V> reactor.core.publisher.Flux<V> zipWith(org.reactivestreams.Publisher<? extends T2> source2,
                                                           java.util.function.BiFunction<? super T,? super T2,? extends V> combinator)

Parameters:

source2 -

combinator -

Returns:

See Also:

Flux.zipWith(org.reactivestreams.Publisher, java.util.function.BiFunction)

zipWith

public final <T2,V> reactor.core.publisher.Flux<V> zipWith(org.reactivestreams.Publisher<? extends T2> source2,
                                                           int prefetch,
                                                           java.util.function.BiFunction<? super T,? super T2,? extends V> combinator)

Parameters:

source2 -

prefetch -

combinator -

Returns:

See Also:

Flux.zipWith(org.reactivestreams.Publisher, int, java.util.function.BiFunction)

zipWith

public final <T2> reactor.core.publisher.Flux<reactor.util.function.Tuple2<T,T2>> zipWith(org.reactivestreams.Publisher<? extends T2> source2)

Parameters:

source2 -

Returns:

See Also:

Flux.zipWith(org.reactivestreams.Publisher)

zipWith

public final <T2> reactor.core.publisher.Flux<reactor.util.function.Tuple2<T,T2>> zipWith(org.reactivestreams.Publisher<? extends T2> source2,
                                                                                          int prefetch)

Parameters:

source2 -

prefetch -

Returns:

See Also:

Flux.zipWith(org.reactivestreams.Publisher, int)

zipWithIterable

public final <T2> reactor.core.publisher.Flux<reactor.util.function.Tuple2<T,T2>> zipWithIterable(java.lang.Iterable<? extends T2> iterable)

Parameters:

iterable -

Returns:

See Also:

Flux.zipWithIterable(java.lang.Iterable)

zipWithIterable

public final <T2,V> reactor.core.publisher.Flux<V> zipWithIterable(java.lang.Iterable<? extends T2> iterable,
                                                                   java.util.function.BiFunction<? super T,? super T2,? extends V> zipper)

Parameters:

iterable -

zipper -

Returns:

See Also:

Flux.zipWithIterable(java.lang.Iterable, java.util.function.BiFunction)