wow-opentelemetry/me.ahoo.wow.opentelemetry/TraceFlux

TraceFlux

class TraceFlux<T : Any, O>(parentContext: Context, instrumenter: Instrumenter<T, Unit>, request: T, source: Flux<O>) : Flux<O>

Constructors

Link copied to clipboard
constructor(parentContext: Context, instrumenter: Instrumenter<T, Unit>, request: T, source: Flux<O>)

Functions

Link copied to clipboard
fun all(p0: Predicate<in O>): Mono<Boolean>
Link copied to clipboard
fun any(p0: Predicate<in O>): Mono<Boolean>
Link copied to clipboard
fun <P : Any> as(p0: Function<in Flux<O>, P>): P
Link copied to clipboard
@Nullable
fun blockFirst(): O
@Nullable
fun blockFirst(p0: Duration): O
Link copied to clipboard
@Nullable
fun blockLast(): O
@Nullable
fun blockLast(p0: Duration): O
Link copied to clipboard
fun buffer(): Flux<MutableList<O>>
fun buffer(p0: Duration): Flux<MutableList<O>>
fun buffer(p0: Int): Flux<MutableList<O>>
fun buffer(p0: Publisher<*>): Flux<MutableList<O>>
fun buffer(p0: Duration, p1: Duration): Flux<MutableList<O>>
fun buffer(p0: Duration, p1: Scheduler): Flux<MutableList<O>>
fun <C : MutableCollection<in O>> buffer(p0: Int, p1: Supplier<C>): Flux<C>
fun buffer(p0: Int, p1: Int): Flux<MutableList<O>>
fun <C : MutableCollection<in O>> buffer(p0: Publisher<*>, p1: Supplier<C>): Flux<C>
fun buffer(p0: Duration, p1: Duration, p2: Scheduler): Flux<MutableList<O>>
fun <C : MutableCollection<in O>> buffer(p0: Int, p1: Int, p2: Supplier<C>): Flux<C>
Link copied to clipboard
fun bufferTimeout(p0: Int, p1: Duration): Flux<MutableList<O>>
fun <C : MutableCollection<in O>> bufferTimeout(p0: Int, p1: Duration, p2: Supplier<C>): Flux<C>
fun bufferTimeout(p0: Int, p1: Duration, p2: Boolean): Flux<MutableList<O>>
fun bufferTimeout(p0: Int, p1: Duration, p2: Scheduler): Flux<MutableList<O>>
fun <C : MutableCollection<in O>> bufferTimeout(p0: Int, p1: Duration, p2: Supplier<C>, p3: Boolean): Flux<C>
fun <C : MutableCollection<in O>> bufferTimeout(p0: Int, p1: Duration, p2: Scheduler, p3: Supplier<C>): Flux<C>
fun bufferTimeout(p0: Int, p1: Duration, p2: Scheduler, p3: Boolean): Flux<MutableList<O>>
fun <C : MutableCollection<in O>> bufferTimeout(p0: Int, p1: Duration, p2: Scheduler, p3: Supplier<C>, p4: Boolean): Flux<C>
Link copied to clipboard
fun bufferUntil(p0: Predicate<in O>): Flux<MutableList<O>>
fun bufferUntil(p0: Predicate<in O>, p1: Boolean): Flux<MutableList<O>>
Link copied to clipboard
fun bufferUntilChanged(): Flux<MutableList<O>>
fun <V : Any> bufferUntilChanged(p0: Function<in O, out V>): Flux<MutableList<O>>
fun <V : Any> bufferUntilChanged(p0: Function<in O, out V>, p1: BiPredicate<in V, in V>): Flux<MutableList<O>>
Link copied to clipboard
fun <U : Any, V : Any> bufferWhen(p0: Publisher<U>, p1: Function<in U, out Publisher<V>>): Flux<MutableList<O>>
fun <U : Any, V : Any, C : MutableCollection<in O>> bufferWhen(p0: Publisher<U>, p1: Function<in U, out Publisher<V>>, p2: Supplier<C>): Flux<C>
Link copied to clipboard
fun bufferWhile(p0: Predicate<in O>): Flux<MutableList<O>>
Link copied to clipboard
fun cache(): Flux<O>
fun cache(p0: Duration): Flux<O>
fun cache(p0: Int): Flux<O>
fun cache(p0: Duration, p1: Scheduler): Flux<O>
fun cache(p0: Int, p1: Duration): Flux<O>
fun cache(p0: Int, p1: Duration, p2: Scheduler): Flux<O>
Link copied to clipboard
fun cancelOn(p0: Scheduler): Flux<O>
Link copied to clipboard
fun <E : Any> cast(p0: Class<E>): Flux<E>
Link copied to clipboard
fun checkpoint(): Flux<O>
fun checkpoint(p0: String): Flux<O>
fun checkpoint(@Nullable p0: String, p1: Boolean): Flux<O>
Link copied to clipboard
fun <R : Any, A : Any> collect(p0: Collector<in O, A, out R>): Mono<R>
fun <E : Any> collect(p0: Supplier<E>, p1: BiConsumer<E, in O>): Mono<E>
Link copied to clipboard
fun collectList(): Mono<MutableList<O>>
Link copied to clipboard
fun <K : Any> collectMap(p0: Function<in O, out K>): Mono<MutableMap<K, O>>
fun <K : Any, V : Any> collectMap(p0: Function<in O, out K>, p1: Function<in O, out V>): Mono<MutableMap<K, V>>
fun <K : Any, V : Any> collectMap(p0: Function<in O, out K>, p1: Function<in O, out V>, p2: Supplier<MutableMap<K, V>>): Mono<MutableMap<K, V>>
Link copied to clipboard
fun <K : Any> collectMultimap(p0: Function<in O, out K>): Mono<MutableMap<K, MutableCollection<O>>>
fun <K : Any, V : Any> collectMultimap(p0: Function<in O, out K>, p1: Function<in O, out V>): Mono<MutableMap<K, MutableCollection<V>>>
fun <K : Any, V : Any> collectMultimap(p0: Function<in O, out K>, p1: Function<in O, out V>, p2: Supplier<MutableMap<K, MutableCollection<V>>>): Mono<MutableMap<K, MutableCollection<V>>>
Link copied to clipboard
fun collectSortedList(): Mono<MutableList<O>>
fun collectSortedList(@Nullable p0: Comparator<in O>): Mono<MutableList<O>>
Link copied to clipboard
fun <V : Any> concatMap(p0: Function<in O, out Publisher<out V>>): Flux<V>
fun <V : Any> concatMap(p0: Function<in O, out Publisher<out V>>, p1: Int): Flux<V>
Link copied to clipboard
fun <V : Any> concatMapDelayError(p0: Function<in O, out Publisher<out V>>): Flux<V>
fun <V : Any> concatMapDelayError(p0: Function<in O, out Publisher<out V>>, p1: Int): Flux<V>
fun <V : Any> concatMapDelayError(p0: Function<in O, out Publisher<out V>>, p1: Boolean, p2: Int): Flux<V>
Link copied to clipboard
fun <R : Any> concatMapIterable(p0: Function<in O, out MutableIterable<R>>): Flux<R>
fun <R : Any> concatMapIterable(p0: Function<in O, out MutableIterable<R>>, p1: Int): Flux<R>
Link copied to clipboard
fun concatWith(p0: Publisher<out O>): Flux<O>
Link copied to clipboard
@SafeVarargs
fun concatWithValues(vararg p0: O): Flux<O>
Link copied to clipboard
fun contextCapture(): Flux<O>
Link copied to clipboard
fun contextWrite(p0: Function<Context, Context>): Flux<O>
fun contextWrite(p0: ContextView): Flux<O>
Link copied to clipboard
fun count(): Mono<Long>
Link copied to clipboard
fun defaultIfEmpty(p0: O): Flux<O>
Link copied to clipboard
fun delayElements(p0: Duration): Flux<O>
fun delayElements(p0: Duration, p1: Scheduler): Flux<O>
Link copied to clipboard
fun delaySequence(p0: Duration): Flux<O>
fun delaySequence(p0: Duration, p1: Scheduler): Flux<O>
Link copied to clipboard
fun delaySubscription(p0: Duration): Flux<O>
fun <U : Any> delaySubscription(p0: Publisher<U>): Flux<O>
fun delaySubscription(p0: Duration, p1: Scheduler): Flux<O>
Link copied to clipboard
fun delayUntil(p0: Function<in O, out Publisher<*>>): Flux<O>
Link copied to clipboard
fun <X : Any> dematerialize(): Flux<X>
Link copied to clipboard
fun distinct(): Flux<O>
fun <V : Any> distinct(p0: Function<in O, out V>): Flux<O>
fun <V : Any, C : MutableCollection<in V>> distinct(p0: Function<in O, out V>, p1: Supplier<C>): Flux<O>
fun <V : Any, C : Any> distinct(p0: Function<in O, out V>, p1: Supplier<C>, p2: BiPredicate<C, V>, p3: Consumer<C>): Flux<O>
Link copied to clipboard
fun distinctUntilChanged(): Flux<O>
fun <V : Any> distinctUntilChanged(p0: Function<in O, out V>): Flux<O>
fun <V : Any> distinctUntilChanged(p0: Function<in O, out V>, p1: BiPredicate<in V, in V>): Flux<O>
Link copied to clipboard
fun doAfterTerminate(p0: Runnable): Flux<O>
Link copied to clipboard
fun doFinally(p0: Consumer<SignalType>): Flux<O>
Link copied to clipboard
fun doFirst(p0: Runnable): Flux<O>
Link copied to clipboard
fun doOnCancel(p0: Runnable): Flux<O>
Link copied to clipboard
fun doOnComplete(p0: Runnable): Flux<O>
Link copied to clipboard
fun <R : Any> doOnDiscard(p0: Class<R>, p1: Consumer<in R>): Flux<O>
Link copied to clipboard
fun doOnEach(p0: Consumer<in Signal<O>>): Flux<O>
Link copied to clipboard
fun doOnError(p0: Consumer<in Throwable>): Flux<O>
fun <E : Throwable> doOnError(p0: Class<E>, p1: Consumer<in E>): Flux<O>
fun doOnError(p0: Predicate<in Throwable>, p1: Consumer<in Throwable>): Flux<O>
Link copied to clipboard
fun doOnNext(p0: Consumer<in O>): Flux<O>
Link copied to clipboard
fun doOnRequest(p0: LongConsumer): Flux<O>
Link copied to clipboard
fun doOnSubscribe(p0: Consumer<in Subscription>): Flux<O>
Link copied to clipboard
fun doOnTerminate(p0: Runnable): Flux<O>
Link copied to clipboard
fun elapsed(): Flux<Tuple2<Long, O>>
fun elapsed(p0: Scheduler): Flux<Tuple2<Long, O>>
Link copied to clipboard
fun elementAt(p0: Int): Mono<O>
fun elementAt(p0: Int, p1: O): Mono<O>
Link copied to clipboard
fun expand(p0: Function<in O, out Publisher<out O>>): Flux<O>
fun expand(p0: Function<in O, out Publisher<out O>>, p1: Int): Flux<O>
Link copied to clipboard
fun expandDeep(p0: Function<in O, out Publisher<out O>>): Flux<O>
fun expandDeep(p0: Function<in O, out Publisher<out O>>, p1: Int): Flux<O>
Link copied to clipboard
fun filter(p0: Predicate<in O>): Flux<O>
Link copied to clipboard
fun filterWhen(p0: Function<in O, out Publisher<Boolean>>): Flux<O>
fun filterWhen(p0: Function<in O, out Publisher<Boolean>>, p1: Int): Flux<O>
Link copied to clipboard
fun <R : Any> flatMap(p0: Function<in O, out Publisher<out R>>): Flux<R>
fun <V : Any> flatMap(p0: Function<in O, out Publisher<out V>>, p1: Int): Flux<V>
fun <R : Any> flatMap(@Nullable p0: Function<in O, out Publisher<out R>>, @Nullable p1: Function<in Throwable, out Publisher<out R>>, @Nullable p2: Supplier<out Publisher<out R>>): Flux<R>
fun <V : Any> flatMap(p0: Function<in O, out Publisher<out V>>, p1: Int, p2: Int): Flux<V>
Link copied to clipboard
fun <V : Any> flatMapDelayError(p0: Function<in O, out Publisher<out V>>, p1: Int, p2: Int): Flux<V>
Link copied to clipboard
fun <R : Any> flatMapIterable(p0: Function<in O, out MutableIterable<R>>): Flux<R>
fun <R : Any> flatMapIterable(p0: Function<in O, out MutableIterable<R>>, p1: Int): Flux<R>
Link copied to clipboard
fun <R : Any> flatMapSequential(p0: Function<in O, out Publisher<out R>>): Flux<R>
fun <R : Any> flatMapSequential(p0: Function<in O, out Publisher<out R>>, p1: Int): Flux<R>
fun <R : Any> flatMapSequential(p0: Function<in O, out Publisher<out R>>, p1: Int, p2: Int): Flux<R>
Link copied to clipboard
fun <R : Any> flatMapSequentialDelayError(p0: Function<in O, out Publisher<out R>>, p1: Int, p2: Int): Flux<R>
Link copied to clipboard
open fun getPrefetch(): Int
Link copied to clipboard
fun <K : Any> groupBy(p0: Function<in O, out K>): Flux<GroupedFlux<K, O>>
fun <K : Any, V : Any> groupBy(p0: Function<in O, out K>, p1: Function<in O, out V>): Flux<GroupedFlux<K, V>>
fun <K : Any> groupBy(p0: Function<in O, out K>, p1: Int): Flux<GroupedFlux<K, O>>
fun <K : Any, V : Any> groupBy(p0: Function<in O, out K>, p1: Function<in O, out V>, p2: Int): Flux<GroupedFlux<K, V>>
Link copied to clipboard
fun <TRight : Any, TLeftEnd : Any, TRightEnd : Any, R : Any> groupJoin(p0: Publisher<out TRight>, p1: Function<in O, out Publisher<TLeftEnd>>, p2: Function<in TRight, out Publisher<TRightEnd>>, p3: BiFunction<in O, in Flux<TRight>, out R>): Flux<R>
Link copied to clipboard
fun <R : Any> handle(p0: BiConsumer<in O, SynchronousSink<R>>): Flux<R>
Link copied to clipboard
fun hasElement(p0: O): Mono<Boolean>
Link copied to clipboard
fun hasElements(): Mono<Boolean>
Link copied to clipboard
open fun hide(): Flux<O>
Link copied to clipboard
fun ignoreElements(): Mono<O>
Link copied to clipboard
fun index(): Flux<Tuple2<Long, O>>
fun <I : Any> index(p0: BiFunction<in Long, in O, out I>): Flux<I>
Link copied to clipboard
fun <TRight : Any, TLeftEnd : Any, TRightEnd : Any, R : Any> join(p0: Publisher<out TRight>, p1: Function<in O, out Publisher<TLeftEnd>>, p2: Function<in TRight, out Publisher<TRightEnd>>, p3: BiFunction<in O, in TRight, out R>): Flux<R>
Link copied to clipboard
fun last(): Mono<O>
fun last(p0: O): Mono<O>
Link copied to clipboard
fun limitRate(p0: Int): Flux<O>
fun limitRate(p0: Int, p1: Int): Flux<O>
Link copied to clipboard
fun limitRequest(p0: Long): Flux<O>
Link copied to clipboard
fun log(): Flux<O>
fun log(p0: String): Flux<O>
fun log(p0: Logger): Flux<O>
fun log(@Nullable p0: String, p1: Level, vararg p2: SignalType): Flux<O>
fun log(@Nullable p0: String, p1: Level, p2: Boolean, vararg p3: SignalType): Flux<O>
fun log(p0: Logger, p1: Level, p2: Boolean, vararg p3: SignalType): Flux<O>
Link copied to clipboard
fun <V : Any> map(p0: Function<in O, out V>): Flux<V>
Link copied to clipboard
fun <V : Any> mapNotNull(p0: Function<in O, out V>): Flux<V>
Link copied to clipboard
fun materialize(): Flux<Signal<O>>
Link copied to clipboard
fun mergeComparingWith(p0: Publisher<out O>, p1: Comparator<in O>): Flux<O>
Link copied to clipboard
fun mergeOrderedWith(p0: Publisher<out O>, p1: Comparator<in O>): Flux<O>
Link copied to clipboard
fun mergeWith(p0: Publisher<out O>): Flux<O>
Link copied to clipboard
fun metrics(): Flux<O>
Link copied to clipboard
fun name(p0: String): Flux<O>
Link copied to clipboard
operator fun next(): Mono<O>
Link copied to clipboard
fun <U : Any> ofType(p0: Class<U>): Flux<U>
Link copied to clipboard
fun onBackpressureBuffer(): Flux<O>
fun onBackpressureBuffer(p0: Int): Flux<O>
fun onBackpressureBuffer(p0: Int, p1: Consumer<in O>): Flux<O>
fun onBackpressureBuffer(p0: Int, p1: BufferOverflowStrategy): Flux<O>
fun onBackpressureBuffer(p0: Duration, p1: Int, p2: Consumer<in O>): Flux<O>
fun onBackpressureBuffer(p0: Int, p1: Consumer<in O>, p2: BufferOverflowStrategy): Flux<O>
fun onBackpressureBuffer(p0: Duration, p1: Int, p2: Consumer<in O>, p3: Scheduler): Flux<O>
Link copied to clipboard
fun onBackpressureDrop(): Flux<O>
fun onBackpressureDrop(p0: Consumer<in O>): Flux<O>
Link copied to clipboard
fun onBackpressureError(): Flux<O>
Link copied to clipboard
fun onBackpressureLatest(): Flux<O>
Link copied to clipboard
fun onErrorComplete(): Flux<O>
fun onErrorComplete(p0: Class<out Throwable>): Flux<O>
fun onErrorComplete(p0: Predicate<in Throwable>): Flux<O>
Link copied to clipboard
Link copied to clipboard
fun onErrorMap(p0: Function<in Throwable, out Throwable>): Flux<O>
fun <E : Throwable> onErrorMap(p0: Class<E>, p1: Function<in E, out Throwable>): Flux<O>
fun onErrorMap(p0: Predicate<in Throwable>, p1: Function<in Throwable, out Throwable>): Flux<O>
Link copied to clipboard
fun onErrorResume(p0: Function<in Throwable, out Publisher<out O>>): Flux<O>
fun <E : Throwable> onErrorResume(p0: Class<E>, p1: Function<in E, out Publisher<out O>>): Flux<O>
fun onErrorResume(p0: Predicate<in Throwable>, p1: Function<in Throwable, out Publisher<out O>>): Flux<O>
Link copied to clipboard
fun onErrorReturn(p0: O): Flux<O>
fun <E : Throwable> onErrorReturn(p0: Class<E>, p1: O): Flux<O>
fun onErrorReturn(p0: Predicate<in Throwable>, p1: O): Flux<O>
Link copied to clipboard
fun onErrorStop(): Flux<O>
Link copied to clipboard
fun onTerminateDetach(): Flux<O>
Link copied to clipboard
fun or(p0: Publisher<out O>): Flux<O>
Link copied to clipboard
fun parallel(): ParallelFlux<O>
fun parallel(p0: Int): ParallelFlux<O>
fun parallel(p0: Int, p1: Int): ParallelFlux<O>
Link copied to clipboard
fun publish(): ConnectableFlux<O>
fun <R : Any> publish(p0: Function<in Flux<O>, out Publisher<out R>>): Flux<R>
fun publish(p0: Int): ConnectableFlux<O>
fun <R : Any> publish(p0: Function<in Flux<O>, out Publisher<out R>>, p1: Int): Flux<R>
Link copied to clipboard
fun publishNext(): Mono<O>
Link copied to clipboard
fun publishOn(p0: Scheduler): Flux<O>
fun publishOn(p0: Scheduler, p1: Int): Flux<O>
fun publishOn(p0: Scheduler, p1: Boolean, p2: Int): Flux<O>
Link copied to clipboard
fun reduce(p0: BiFunction<O, O, O>): Mono<O>
fun <A : Any> reduce(p0: A, p1: BiFunction<A, in O, A>): Mono<A>
Link copied to clipboard
fun <A : Any> reduceWith(p0: Supplier<A>, p1: BiFunction<A, in O, A>): Mono<A>
Link copied to clipboard
fun repeat(): Flux<O>
fun repeat(p0: BooleanSupplier): Flux<O>
fun repeat(p0: Long): Flux<O>
fun repeat(p0: Long, p1: BooleanSupplier): Flux<O>
Link copied to clipboard
fun repeatWhen(p0: Function<Flux<Long>, out Publisher<*>>): Flux<O>
Link copied to clipboard
fun replay(): ConnectableFlux<O>
fun replay(p0: Duration): ConnectableFlux<O>
fun replay(p0: Int): ConnectableFlux<O>
fun replay(p0: Duration, p1: Scheduler): ConnectableFlux<O>
fun replay(p0: Int, p1: Duration): ConnectableFlux<O>
fun replay(p0: Int, p1: Duration, p2: Scheduler): ConnectableFlux<O>
Link copied to clipboard
fun retry(): Flux<O>
fun retry(p0: Long): Flux<O>
Link copied to clipboard
fun retryWhen(p0: Retry): Flux<O>
Link copied to clipboard
fun sample(p0: Duration): Flux<O>
fun <U : Any> sample(p0: Publisher<U>): Flux<O>
Link copied to clipboard
fun sampleFirst(p0: Duration): Flux<O>
fun <U : Any> sampleFirst(p0: Function<in O, out Publisher<U>>): Flux<O>
Link copied to clipboard
fun <U : Any> sampleTimeout(p0: Function<in O, out Publisher<U>>): Flux<O>
fun <U : Any> sampleTimeout(p0: Function<in O, out Publisher<U>>, p1: Int): Flux<O>
Link copied to clipboard
fun scan(p0: BiFunction<O, O, O>): Flux<O>
fun <A : Any> scan(p0: A, p1: BiFunction<A, in O, A>): Flux<A>
Link copied to clipboard
fun <A : Any> scanWith(p0: Supplier<A>, p1: BiFunction<A, in O, A>): Flux<A>
Link copied to clipboard
fun share(): Flux<O>
Link copied to clipboard
fun shareNext(): Mono<O>
Link copied to clipboard
fun single(): Mono<O>
fun single(p0: O): Mono<O>
Link copied to clipboard
fun singleOrEmpty(): Mono<O>
Link copied to clipboard
fun skip(p0: Duration): Flux<O>
fun skip(p0: Long): Flux<O>
fun skip(p0: Duration, p1: Scheduler): Flux<O>
Link copied to clipboard
fun skipLast(p0: Int): Flux<O>
Link copied to clipboard
fun skipUntil(p0: Predicate<in O>): Flux<O>
Link copied to clipboard
fun skipUntilOther(p0: Publisher<*>): Flux<O>
Link copied to clipboard
fun skipWhile(p0: Predicate<in O>): Flux<O>
Link copied to clipboard
fun sort(): Flux<O>
fun sort(p0: Comparator<in O>): Flux<O>
Link copied to clipboard
@SafeVarargs
fun startWith(vararg p0: O): Flux<O>
fun startWith(p0: MutableIterable<O>): Flux<O>
fun startWith(p0: Publisher<out O>): Flux<O>
Link copied to clipboard
open override fun subscribe(actual: CoreSubscriber<in O>)
fun subscribe(): Disposable
fun subscribe(p0: Consumer<in O>): Disposable
override fun subscribe(p0: Subscriber<in O>)
fun subscribe(@Nullable p0: Consumer<in O>, p1: Consumer<in Throwable>): Disposable
fun subscribe(@Nullable p0: Consumer<in O>, @Nullable p1: Consumer<in Throwable>, @Nullable p2: Runnable): Disposable
fun subscribe(@Nullable p0: Consumer<in O>, @Nullable p1: Consumer<in Throwable>, @Nullable p2: Runnable, @Nullable p3: Consumer<in Subscription>): Disposable
fun subscribe(@Nullable p0: Consumer<in O>, @Nullable p1: Consumer<in Throwable>, @Nullable p2: Runnable, @Nullable p3: Context): Disposable
Link copied to clipboard
fun subscribeOn(p0: Scheduler): Flux<O>
fun subscribeOn(p0: Scheduler, p1: Boolean): Flux<O>
Link copied to clipboard
fun <E : Subscriber<in O>> subscribeWith(p0: E): E
Link copied to clipboard
fun switchIfEmpty(p0: Publisher<out O>): Flux<O>
Link copied to clipboard
fun <V : Any> switchMap(p0: Function<in O, Publisher<out V>>): Flux<V>
fun <V : Any> switchMap(p0: Function<in O, Publisher<out V>>, p1: Int): Flux<V>
Link copied to clipboard
fun <V : Any> switchOnFirst(p0: BiFunction<Signal<out O>, Flux<O>, Publisher<out V>>): Flux<V>
fun <V : Any> switchOnFirst(p0: BiFunction<Signal<out O>, Flux<O>, Publisher<out V>>, p1: Boolean): Flux<V>
Link copied to clipboard
fun tag(p0: String, p1: String): Flux<O>
Link copied to clipboard
fun take(p0: Duration): Flux<O>
fun take(p0: Long): Flux<O>
fun take(p0: Duration, p1: Scheduler): Flux<O>
fun take(p0: Long, p1: Boolean): Flux<O>
Link copied to clipboard
fun takeLast(p0: Int): Flux<O>
Link copied to clipboard
fun takeUntil(p0: Predicate<in O>): Flux<O>
Link copied to clipboard
fun takeUntilOther(p0: Publisher<*>): Flux<O>
Link copied to clipboard
fun takeWhile(p0: Predicate<in O>): Flux<O>
Link copied to clipboard
fun tap(p0: Function<ContextView, SignalListener<O>>): Flux<O>
fun tap(p0: Supplier<SignalListener<O>>): Flux<O>
fun tap(p0: SignalListenerFactory<O, *>): Flux<O>
Link copied to clipboard
fun then(): Mono<Void>
fun <V : Any> then(p0: Mono<V>): Mono<V>
Link copied to clipboard
fun thenEmpty(p0: Publisher<Void>): Mono<Void>
Link copied to clipboard
fun <V : Any> thenMany(p0: Publisher<V>): Flux<V>
Link copied to clipboard
fun timed(): Flux<Timed<O>>
fun timed(p0: Scheduler): Flux<Timed<O>>
Link copied to clipboard
fun timeout(p0: Duration): Flux<O>
fun <U : Any> timeout(p0: Publisher<U>): Flux<O>
fun timeout(p0: Duration, @Nullable p1: Publisher<out O>): Flux<O>
fun timeout(p0: Duration, p1: Scheduler): Flux<O>
fun <U : Any, V : Any> timeout(p0: Publisher<U>, p1: Function<in O, out Publisher<V>>): Flux<O>
fun timeout(p0: Duration, @Nullable p1: Publisher<out O>, p2: Scheduler): Flux<O>
fun <U : Any, V : Any> timeout(p0: Publisher<U>, p1: Function<in O, out Publisher<V>>, p2: Publisher<out O>): Flux<O>
Link copied to clipboard
fun timestamp(): Flux<Tuple2<Long, O>>
fun timestamp(p0: Scheduler): Flux<Tuple2<Long, O>>
Link copied to clipboard
Link copied to clipboard
fun toStream(): Stream<O>
fun toStream(p0: Int): Stream<O>
Link copied to clipboard
open override fun toString(): String
Link copied to clipboard
fun <V : Any> transform(p0: Function<in Flux<O>, out Publisher<V>>): Flux<V>
Link copied to clipboard
fun <V : Any> transformDeferred(p0: Function<in Flux<O>, out Publisher<V>>): Flux<V>
Link copied to clipboard
fun <V : Any> transformDeferredContextual(p0: BiFunction<in Flux<O>, in ContextView, out Publisher<V>>): Flux<V>
Link copied to clipboard
fun window(p0: Duration): Flux<Flux<O>>
fun window(p0: Int): Flux<Flux<O>>
fun window(p0: Publisher<*>): Flux<Flux<O>>
fun window(p0: Duration, p1: Duration): Flux<Flux<O>>
fun window(p0: Duration, p1: Scheduler): Flux<Flux<O>>
fun window(p0: Int, p1: Int): Flux<Flux<O>>
fun window(p0: Duration, p1: Duration, p2: Scheduler): Flux<Flux<O>>
Link copied to clipboard
fun windowTimeout(p0: Int, p1: Duration): Flux<Flux<O>>
fun windowTimeout(p0: Int, p1: Duration, p2: Boolean): Flux<Flux<O>>
fun windowTimeout(p0: Int, p1: Duration, p2: Scheduler): Flux<Flux<O>>
fun windowTimeout(p0: Int, p1: Duration, p2: Scheduler, p3: Boolean): Flux<Flux<O>>
Link copied to clipboard
fun windowUntil(p0: Predicate<O>): Flux<Flux<O>>
fun windowUntil(p0: Predicate<O>, p1: Boolean): Flux<Flux<O>>
fun windowUntil(p0: Predicate<O>, p1: Boolean, p2: Int): Flux<Flux<O>>
Link copied to clipboard
fun windowUntilChanged(): Flux<Flux<O>>
fun <V : Any> windowUntilChanged(p0: Function<in O, in V>): Flux<Flux<O>>
fun <V : Any> windowUntilChanged(p0: Function<in O, out V>, p1: BiPredicate<in V, in V>): Flux<Flux<O>>
Link copied to clipboard
fun <U : Any, V : Any> windowWhen(p0: Publisher<U>, p1: Function<in U, out Publisher<V>>): Flux<Flux<O>>
Link copied to clipboard
fun windowWhile(p0: Predicate<O>): Flux<Flux<O>>
fun windowWhile(p0: Predicate<O>, p1: Int): Flux<Flux<O>>
Link copied to clipboard
fun <U : Any, R : Any> withLatestFrom(p0: Publisher<out U>, p1: BiFunction<in O, in U, out R>): Flux<R>
Link copied to clipboard
fun <T2 : Any> zipWith(p0: Publisher<out T2>): Flux<Tuple2<O, T2>>
fun <T2 : Any, V : Any> zipWith(p0: Publisher<out T2>, p1: BiFunction<in O, in T2, out V>): Flux<V>
fun <T2 : Any> zipWith(p0: Publisher<out T2>, p1: Int): Flux<Tuple2<O, T2>>
fun <T2 : Any, V : Any> zipWith(p0: Publisher<out T2>, p1: Int, p2: BiFunction<in O, in T2, out V>): Flux<V>
Link copied to clipboard
fun <T2 : Any> zipWithIterable(p0: MutableIterable<T2>): Flux<Tuple2<O, T2>>
fun <T2 : Any, V : Any> zipWithIterable(p0: MutableIterable<T2>, p1: BiFunction<in O, in T2, out V>): Flux<V>