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

TraceFlux

class TraceFlux<T : Any, O : Any>(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>)

Properties

Link copied to clipboard
open override val prefetch: Int

Functions

Link copied to clipboard
fun all(predicate: Predicate<in O>): Mono<Boolean>
Link copied to clipboard
fun any(predicate: Predicate<in O>): Mono<Boolean>
Link copied to clipboard
fun <P : Any> as(transformer: Function<in Flux<O>, P>): P
Link copied to clipboard
fun blockFirst(): @Nullable O?
fun blockFirst(timeout: Duration): @Nullable O?
Link copied to clipboard
fun blockLast(): @Nullable O?
fun blockLast(timeout: Duration): @Nullable O?
Link copied to clipboard
fun buffer(): Flux<List<O>>
fun buffer(bufferingTimespan: Duration): Flux<List<O>>
fun buffer(maxSize: Int): Flux<List<O>>
fun buffer(other: Publisher<*>): Flux<List<O>>
fun buffer(bufferingTimespan: Duration, openBufferEvery: Duration): Flux<List<O>>
fun buffer(bufferingTimespan: Duration, timer: Scheduler): Flux<List<O>>
fun <C : MutableCollection<in O>> buffer(maxSize: Int, bufferSupplier: Supplier<C>): Flux<C>
fun buffer(maxSize: Int, skip: Int): Flux<List<O>>
fun <C : MutableCollection<in O>> buffer(other: Publisher<*>, bufferSupplier: Supplier<C>): Flux<C>
fun buffer(bufferingTimespan: Duration, openBufferEvery: Duration, timer: Scheduler): Flux<List<O>>
fun <C : MutableCollection<in O>> buffer(maxSize: Int, skip: Int, bufferSupplier: Supplier<C>): Flux<C>
Link copied to clipboard
fun bufferTimeout(maxSize: Int, maxTime: Duration): Flux<List<O>>
fun <C : MutableCollection<in O>> bufferTimeout(maxSize: Int, maxTime: Duration, bufferSupplier: Supplier<C>): Flux<C>
fun bufferTimeout(maxSize: Int, maxTime: Duration, fairBackpressure: Boolean): Flux<List<O>>
fun bufferTimeout(maxSize: Int, maxTime: Duration, timer: Scheduler): Flux<List<O>>
fun <C : MutableCollection<in O>> bufferTimeout(maxSize: Int, maxTime: Duration, bufferSupplier: Supplier<C>, fairBackpressure: Boolean): Flux<C>
fun <C : MutableCollection<in O>> bufferTimeout(maxSize: Int, maxTime: Duration, timer: Scheduler, bufferSupplier: Supplier<C>): Flux<C>
fun bufferTimeout(maxSize: Int, maxTime: Duration, timer: Scheduler, fairBackpressure: Boolean): Flux<List<O>>
fun <C : MutableCollection<in O>> bufferTimeout(maxSize: Int, maxTime: Duration, timer: Scheduler, bufferSupplier: Supplier<C>, fairBackpressure: Boolean): Flux<C>
Link copied to clipboard
fun bufferUntil(predicate: Predicate<in O>): Flux<List<O>>
fun bufferUntil(predicate: Predicate<in O>, cutBefore: Boolean): Flux<List<O>>
Link copied to clipboard
fun bufferUntilChanged(): Flux<List<O>>
fun <V : Any> bufferUntilChanged(keySelector: Function<in O, out V>): Flux<List<O>>
fun <V : Any> bufferUntilChanged(keySelector: Function<in O, out V>, keyComparator: BiPredicate<in V, in V>): Flux<List<O>>
Link copied to clipboard
fun <U : Any, V : Any> bufferWhen(bucketOpening: Publisher<U>, closeSelector: Function<in U, out Publisher<V>>): Flux<List<O>>
fun <U : Any, V : Any, C : MutableCollection<in O>> bufferWhen(bucketOpening: Publisher<U>, closeSelector: Function<in U, out Publisher<V>>, bufferSupplier: Supplier<C>): Flux<C>
Link copied to clipboard
fun bufferWhile(predicate: Predicate<in O>): Flux<List<O>>
Link copied to clipboard
fun cache(): Flux<O>
fun cache(ttl: Duration): Flux<O>
fun cache(history: Int): Flux<O>
fun cache(ttl: Duration, timer: Scheduler): Flux<O>
fun cache(history: Int, ttl: Duration): Flux<O>
fun cache(history: Int, ttl: Duration, timer: Scheduler): Flux<O>
Link copied to clipboard
fun cancelOn(scheduler: Scheduler): Flux<O>
Link copied to clipboard
fun <E : Any> cast(clazz: Class<E>): Flux<E>
Link copied to clipboard
fun checkpoint(): Flux<O>
fun checkpoint(description: String): Flux<O>
fun checkpoint(description: @Nullable String?, forceStackTrace: Boolean): Flux<O>
Link copied to clipboard
fun <R : Any, A : Any> collect(collector: Collector<in O, A, out R>): Mono<R>
fun <E : Any> collect(containerSupplier: Supplier<E>, collector: BiConsumer<E, in O>): Mono<E>
Link copied to clipboard
fun collectList(): Mono<List<O>>
Link copied to clipboard
fun <K : Any> collectMap(keyExtractor: Function<in O, out K>): Mono<Map<K, O>>
fun <K : Any, V : Any> collectMap(keyExtractor: Function<in O, out K>, valueExtractor: Function<in O, out V>): Mono<Map<K, V>>
fun <K : Any, V : Any> collectMap(keyExtractor: Function<in O, out K>, valueExtractor: Function<in O, out V>, mapSupplier: Supplier<Map<K, V>>): Mono<Map<K, V>>
Link copied to clipboard
fun <K : Any> collectMultimap(keyExtractor: Function<in O, out K>): Mono<Map<K, Collection<O>>>
fun <K : Any, V : Any> collectMultimap(keyExtractor: Function<in O, out K>, valueExtractor: Function<in O, out V>): Mono<Map<K, Collection<V>>>
fun <K : Any, V : Any> collectMultimap(keyExtractor: Function<in O, out K>, valueExtractor: Function<in O, out V>, mapSupplier: Supplier<Map<K, Collection<V>>>): Mono<Map<K, Collection<V>>>
Link copied to clipboard
fun collectSortedList(): Mono<List<O>>
fun collectSortedList(comparator: @Nullable Comparator<in O>?): Mono<List<O>>
Link copied to clipboard
fun <V : Any> concatMap(mapper: Function<in O, out Publisher<out V>>): Flux<V>
fun <V : Any> concatMap(mapper: Function<in O, out Publisher<out V>>, prefetch: Int): Flux<V>
Link copied to clipboard
fun <V : Any> concatMapDelayError(mapper: Function<in O, out Publisher<out V>>): Flux<V>
fun <V : Any> concatMapDelayError(mapper: Function<in O, out Publisher<out V>>, prefetch: Int): Flux<V>
fun <V : Any> concatMapDelayError(mapper: Function<in O, out Publisher<out V>>, delayUntilEnd: Boolean, prefetch: Int): Flux<V>
Link copied to clipboard
fun <R : Any> concatMapIterable(mapper: Function<in O, out Iterable<out R>>): Flux<R>
fun <R : Any> concatMapIterable(mapper: Function<in O, out Iterable<out R>>, prefetch: Int): Flux<R>
Link copied to clipboard
fun concatWith(other: Publisher<out O>): Flux<O>
Link copied to clipboard
@SafeVarargs
fun concatWithValues(vararg values: O): Flux<O>
Link copied to clipboard
fun contextCapture(): Flux<O>
Link copied to clipboard
fun contextWrite(contextModifier: Function<Context, Context>): Flux<O>
fun contextWrite(contextToAppend: ContextView): Flux<O>
Link copied to clipboard
fun count(): Mono<Long>
Link copied to clipboard
fun defaultIfEmpty(defaultV: O): Flux<O>
Link copied to clipboard
fun delayElements(delay: Duration): Flux<O>
fun delayElements(delay: Duration, timer: Scheduler): Flux<O>
Link copied to clipboard
fun delaySequence(delay: Duration): Flux<O>
fun delaySequence(delay: Duration, timer: Scheduler): Flux<O>
Link copied to clipboard
fun delaySubscription(delay: Duration): Flux<O>
fun <U : Any> delaySubscription(subscriptionDelay: Publisher<U>): Flux<O>
fun delaySubscription(delay: Duration, timer: Scheduler): Flux<O>
Link copied to clipboard
fun delayUntil(triggerProvider: 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(keySelector: Function<in O, out V>): Flux<O>
fun <V : Any, C : MutableCollection<in V>> distinct(keySelector: Function<in O, out V>, distinctCollectionSupplier: Supplier<C>): Flux<O>
fun <V : Any, C : Any> distinct(keySelector: Function<in O, out V>, distinctStoreSupplier: Supplier<C>, distinctPredicate: BiPredicate<C, V>, cleanup: Consumer<C>): Flux<O>
Link copied to clipboard
fun distinctUntilChanged(): Flux<O>
fun <V : Any> distinctUntilChanged(keySelector: Function<in O, out V>): Flux<O>
fun <V : Any> distinctUntilChanged(keySelector: Function<in O, out V>, keyComparator: BiPredicate<in V, in V>): Flux<O>
Link copied to clipboard
fun doAfterTerminate(afterTerminate: Runnable): Flux<O>
Link copied to clipboard
fun doFinally(onFinally: Consumer<SignalType>): Flux<O>
Link copied to clipboard
fun doFirst(onFirst: Runnable): Flux<O>
Link copied to clipboard
fun doOnCancel(onCancel: Runnable): Flux<O>
Link copied to clipboard
fun doOnComplete(onComplete: Runnable): Flux<O>
Link copied to clipboard
fun <R : Any> doOnDiscard(type: Class<R>, discardHook: Consumer<in R>): Flux<O>
Link copied to clipboard
fun doOnEach(signalConsumer: Consumer<in Signal<O>>): Flux<O>
Link copied to clipboard
fun doOnError(onError: Consumer<in Throwable>): Flux<O>
fun <E : Throwable> doOnError(exceptionType: Class<E>, onError: Consumer<in E>): Flux<O>
fun doOnError(predicate: Predicate<in Throwable>, onError: Consumer<in Throwable>): Flux<O>
Link copied to clipboard
fun doOnNext(onNext: Consumer<in O>): Flux<O>
Link copied to clipboard
fun doOnRequest(consumer: LongConsumer): Flux<O>
Link copied to clipboard
fun doOnSubscribe(onSubscribe: Consumer<in Subscription>): Flux<O>
Link copied to clipboard
fun doOnTerminate(onTerminate: Runnable): Flux<O>
Link copied to clipboard
fun elapsed(): Flux<Tuple2<Long, O>>
fun elapsed(scheduler: Scheduler): Flux<Tuple2<Long, O>>
Link copied to clipboard
fun elementAt(index: Int): Mono<O>
fun elementAt(index: Int, defaultValue: O): Mono<O>
Link copied to clipboard
fun expand(expander: Function<in O, out Publisher<out O>>): Flux<O>
fun expand(expander: Function<in O, out Publisher<out O>>, capacityHint: Int): Flux<O>
Link copied to clipboard
fun expandDeep(expander: Function<in O, out Publisher<out O>>): Flux<O>
fun expandDeep(expander: Function<in O, out Publisher<out O>>, capacityHint: Int): Flux<O>
Link copied to clipboard
fun filter(p: Predicate<in O>): Flux<O>
Link copied to clipboard
fun filterWhen(asyncPredicate: Function<in O, out Publisher<Boolean>>): Flux<O>
fun filterWhen(asyncPredicate: Function<in O, out Publisher<Boolean>>, bufferSize: Int): Flux<O>
Link copied to clipboard
fun <R : Any> flatMap(mapper: Function<in O, out Publisher<out R>>): Flux<R>
fun <V : Any> flatMap(mapper: Function<in O, out Publisher<out V>>, concurrency: Int): Flux<V>
fun <V : Any> flatMap(mapper: Function<in O, out Publisher<out V>>, concurrency: Int, prefetch: Int): Flux<V>
fun <R : Any> flatMap(mapperOnNext: @Nullable Function<in O, out Publisher<out R>>?, mapperOnError: @Nullable Function<in Throwable, out Publisher<out R>>?, mapperOnComplete: @Nullable Supplier<out Publisher<out R>>?): Flux<R>
Link copied to clipboard
fun <V : Any> flatMapDelayError(mapper: Function<in O, out Publisher<out V>>, concurrency: Int, prefetch: Int): Flux<V>
Link copied to clipboard
fun <R : Any> flatMapIterable(mapper: Function<in O, out Iterable<out R>>): Flux<R>
fun <R : Any> flatMapIterable(mapper: Function<in O, out Iterable<out R>>, prefetch: Int): Flux<R>
Link copied to clipboard
fun <R : Any> flatMapSequential(mapper: Function<in O, out Publisher<out R>>): Flux<R>
fun <R : Any> flatMapSequential(mapper: Function<in O, out Publisher<out R>>, maxConcurrency: Int): Flux<R>
fun <R : Any> flatMapSequential(mapper: Function<in O, out Publisher<out R>>, maxConcurrency: Int, prefetch: Int): Flux<R>
Link copied to clipboard
fun <R : Any> flatMapSequentialDelayError(mapper: Function<in O, out Publisher<out R>>, maxConcurrency: Int, prefetch: Int): Flux<R>
Link copied to clipboard
fun <K : Any> groupBy(keyMapper: Function<in O, out K>): Flux<GroupedFlux<K, O>>
fun <K : Any, V : Any> groupBy(keyMapper: Function<in O, out K>, valueMapper: Function<in O, out V>): Flux<GroupedFlux<K, V>>
fun <K : Any> groupBy(keyMapper: Function<in O, out K>, prefetch: Int): Flux<GroupedFlux<K, O>>
fun <K : Any, V : Any> groupBy(keyMapper: Function<in O, out K>, valueMapper: Function<in O, out V>, prefetch: Int): Flux<GroupedFlux<K, V>>
Link copied to clipboard
fun <TRight : Any, TLeftEnd : Any, TRightEnd : Any, R : Any> groupJoin(other: Publisher<out TRight>, leftEnd: Function<in O, out Publisher<TLeftEnd>>, rightEnd: Function<in TRight, out Publisher<TRightEnd>>, resultSelector: BiFunction<in O, in Flux<TRight>, out R>): Flux<R>
Link copied to clipboard
fun <R : Any> handle(handler: BiConsumer<in O, SynchronousSink<R>>): Flux<R>
Link copied to clipboard
fun hasElement(value: 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(indexMapper: BiFunction<in Long, in O, out I>): Flux<I>
Link copied to clipboard
fun <TRight : Any, TLeftEnd : Any, TRightEnd : Any, R : Any> join(other: Publisher<out TRight>, leftEnd: Function<in O, out Publisher<TLeftEnd>>, rightEnd: Function<in TRight, out Publisher<TRightEnd>>, resultSelector: BiFunction<in O, in TRight, out R>): Flux<R>
Link copied to clipboard
fun last(): Mono<O>
fun last(defaultValue: O): Mono<O>
Link copied to clipboard
fun limitRate(prefetchRate: Int): Flux<O>
fun limitRate(highTide: Int, lowTide: Int): Flux<O>
Link copied to clipboard
fun limitRequest(n: Long): Flux<O>
Link copied to clipboard
fun log(): Flux<O>
fun log(category: String): Flux<O>
fun log(logger: Logger): Flux<O>
fun log(category: @Nullable String?, level: Level, vararg options: SignalType): Flux<O>
fun log(category: @Nullable String?, level: Level, showOperatorLine: Boolean, vararg options: SignalType): Flux<O>
fun log(logger: Logger, level: Level, showOperatorLine: Boolean, vararg options: SignalType): Flux<O>
Link copied to clipboard
fun <V : Any> map(mapper: Function<in O, out V>): Flux<V>
Link copied to clipboard
fun <V : Any> mapNotNull(mapper: Function<in O, out @Nullable V?>): Flux<V>
Link copied to clipboard
fun materialize(): Flux<Signal<O>>
Link copied to clipboard
fun mergeComparingWith(other: Publisher<out O>, otherComparator: Comparator<in O>): Flux<O>
Link copied to clipboard
fun mergeOrderedWith(other: Publisher<out O>, otherComparator: Comparator<in O>): Flux<O>
Link copied to clipboard
fun mergeWith(other: Publisher<out O>): Flux<O>
Link copied to clipboard
fun metrics(): Flux<O>
Link copied to clipboard
fun name(name: String): Flux<O>
Link copied to clipboard
operator fun next(): Mono<O>
Link copied to clipboard
fun <U : Any> ofType(clazz: Class<U>): Flux<U>
Link copied to clipboard
fun onBackpressureBuffer(): Flux<O>
fun onBackpressureBuffer(maxSize: Int): Flux<O>
fun onBackpressureBuffer(maxSize: Int, onOverflow: Consumer<in O>): Flux<O>
fun onBackpressureBuffer(maxSize: Int, bufferOverflowStrategy: BufferOverflowStrategy): Flux<O>
fun onBackpressureBuffer(ttl: Duration, maxSize: Int, onBufferEviction: Consumer<in O>): Flux<O>
fun onBackpressureBuffer(maxSize: Int, onBufferOverflow: Consumer<in O>, bufferOverflowStrategy: BufferOverflowStrategy): Flux<O>
fun onBackpressureBuffer(ttl: Duration, maxSize: Int, onBufferEviction: Consumer<in O>, scheduler: Scheduler): Flux<O>
Link copied to clipboard
fun onBackpressureDrop(): Flux<O>
fun onBackpressureDrop(onDropped: 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(type: Class<out Throwable>): Flux<O>
fun onErrorComplete(predicate: Predicate<in Throwable>): Flux<O>
Link copied to clipboard
fun onErrorContinue(errorConsumer: BiConsumer<Throwable, Any>): Flux<O>
fun <E : Throwable> onErrorContinue(type: Class<E>, errorConsumer: BiConsumer<Throwable, Any>): Flux<O>
fun <E : Throwable> onErrorContinue(errorPredicate: Predicate<E>, errorConsumer: BiConsumer<Throwable, Any>): Flux<O>
Link copied to clipboard
fun onErrorMap(mapper: Function<in Throwable, out Throwable>): Flux<O>
fun <E : Throwable> onErrorMap(type: Class<E>, mapper: Function<in E, out Throwable>): Flux<O>
fun onErrorMap(predicate: Predicate<in Throwable>, mapper: Function<in Throwable, out Throwable>): Flux<O>
Link copied to clipboard
fun onErrorResume(fallback: Function<in Throwable, out Publisher<out O>>): Flux<O>
fun <E : Throwable> onErrorResume(type: Class<E>, fallback: Function<in E, out Publisher<out O>>): Flux<O>
fun onErrorResume(predicate: Predicate<in Throwable>, fallback: Function<in Throwable, out Publisher<out O>>): Flux<O>
Link copied to clipboard
fun onErrorReturn(fallbackValue: O): Flux<O>
fun <E : Throwable> onErrorReturn(type: Class<E>, fallbackValue: O): Flux<O>
fun onErrorReturn(predicate: Predicate<in Throwable>, fallbackValue: 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(other: Publisher<out O>): Flux<O>
Link copied to clipboard
fun parallel(): ParallelFlux<O>
fun parallel(parallelism: Int): ParallelFlux<O>
fun parallel(parallelism: Int, prefetch: Int): ParallelFlux<O>
Link copied to clipboard
fun publish(): ConnectableFlux<O>
fun <R : Any> publish(transform: Function<in Flux<O>, out Publisher<out R>>): Flux<R>
fun publish(prefetch: Int): ConnectableFlux<O>
fun <R : Any> publish(transform: Function<in Flux<O>, out Publisher<out R>>, prefetch: Int): Flux<R>
Link copied to clipboard
fun publishNext(): Mono<O>
Link copied to clipboard
fun publishOn(scheduler: Scheduler): Flux<O>
fun publishOn(scheduler: Scheduler, prefetch: Int): Flux<O>
fun publishOn(scheduler: Scheduler, delayError: Boolean, prefetch: Int): Flux<O>
Link copied to clipboard
fun reduce(aggregator: BiFunction<O, O, O>): Mono<O>
fun <A : Any> reduce(initial: A, accumulator: BiFunction<A, in O, A>): Mono<A>
Link copied to clipboard
fun <A : Any> reduceWith(initial: Supplier<A>, accumulator: BiFunction<A, in O, A>): Mono<A>
Link copied to clipboard
fun repeat(): Flux<O>
fun repeat(predicate: BooleanSupplier): Flux<O>
fun repeat(numRepeat: Long): Flux<O>
fun repeat(numRepeat: Long, predicate: BooleanSupplier): Flux<O>
Link copied to clipboard
fun repeatWhen(repeatFactory: Function<Flux<Long>, out Publisher<*>>): Flux<O>
Link copied to clipboard
fun replay(): ConnectableFlux<O>
fun replay(ttl: Duration): ConnectableFlux<O>
fun replay(history: Int): ConnectableFlux<O>
fun replay(ttl: Duration, timer: Scheduler): ConnectableFlux<O>
fun replay(history: Int, ttl: Duration): ConnectableFlux<O>
fun replay(history: Int, ttl: Duration, timer: Scheduler): ConnectableFlux<O>
Link copied to clipboard
fun retry(): Flux<O>
fun retry(numRetries: Long): Flux<O>
Link copied to clipboard
fun retryWhen(retrySpec: Retry): Flux<O>
Link copied to clipboard
fun sample(timespan: Duration): Flux<O>
fun <U : Any> sample(sampler: Publisher<U>): Flux<O>
Link copied to clipboard
fun sampleFirst(timespan: Duration): Flux<O>
fun <U : Any> sampleFirst(samplerFactory: Function<in O, out Publisher<U>>): Flux<O>
Link copied to clipboard
fun <U : Any> sampleTimeout(throttlerFactory: Function<in O, out Publisher<U>>): Flux<O>
fun <U : Any> sampleTimeout(throttlerFactory: Function<in O, out Publisher<U>>, maxConcurrency: Int): Flux<O>
Link copied to clipboard
fun scan(accumulator: BiFunction<O, O, O>): Flux<O>
fun <A : Any> scan(initial: A, accumulator: BiFunction<A, in O, A>): Flux<A>
Link copied to clipboard
fun <A : Any> scanWith(initial: Supplier<A>, accumulator: 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(defaultValue: O): Mono<O>
Link copied to clipboard
fun singleOrEmpty(): Mono<O>
Link copied to clipboard
fun skip(timespan: Duration): Flux<O>
fun skip(skipped: Long): Flux<O>
fun skip(timespan: Duration, timer: Scheduler): Flux<O>
Link copied to clipboard
fun skipLast(n: Int): Flux<O>
Link copied to clipboard
fun skipUntil(untilPredicate: Predicate<in O>): Flux<O>
Link copied to clipboard
fun skipUntilOther(other: Publisher<*>): Flux<O>
Link copied to clipboard
fun skipWhile(skipPredicate: Predicate<in O>): Flux<O>
Link copied to clipboard
fun sort(): Flux<O>
fun sort(sortFunction: Comparator<in O>): Flux<O>
Link copied to clipboard
@SafeVarargs
fun startWith(vararg values: O): Flux<O>
fun startWith(iterable: Iterable<out O>): Flux<O>
fun startWith(publisher: Publisher<out O>): Flux<O>
Link copied to clipboard
open override fun subscribe(actual: CoreSubscriber<in O>)
fun subscribe(actual: Subscriber<in O>)
fun subscribe(): Disposable
fun subscribe(consumer: Consumer<in O>): Disposable
fun subscribe(consumer: @Nullable Consumer<in O>?, errorConsumer: Consumer<in Throwable>): Disposable
fun subscribe(consumer: @Nullable Consumer<in O>?, errorConsumer: @Nullable Consumer<in Throwable>?, completeConsumer: @Nullable Runnable?): Disposable
fun subscribe(consumer: @Nullable Consumer<in O>?, errorConsumer: @Nullable Consumer<in Throwable>?, completeConsumer: @Nullable Runnable?, subscriptionConsumer: @Nullable Consumer<in Subscription>?): Disposable
fun subscribe(consumer: @Nullable Consumer<in O>?, errorConsumer: @Nullable Consumer<in Throwable>?, completeConsumer: @Nullable Runnable?, initialContext: @Nullable Context?): Disposable
Link copied to clipboard
fun subscribeOn(scheduler: Scheduler): Flux<O>
fun subscribeOn(scheduler: Scheduler, requestOnSeparateThread: Boolean): Flux<O>
Link copied to clipboard
fun <E : Subscriber<in O>> subscribeWith(subscriber: E): E
Link copied to clipboard
fun switchIfEmpty(alternate: Publisher<out O>): Flux<O>
Link copied to clipboard
fun <V : Any> switchMap(fn: Function<in O, Publisher<out V>>): Flux<V>
fun <V : Any> switchMap(fn: Function<in O, Publisher<out V>>, prefetch: Int): Flux<V>
Link copied to clipboard
fun <V : Any> switchOnFirst(transformer: BiFunction<Signal<out O>, Flux<O>, Publisher<out V>>): Flux<V>
fun <V : Any> switchOnFirst(transformer: BiFunction<Signal<out O>, Flux<O>, Publisher<out V>>, cancelSourceOnComplete: Boolean): Flux<V>
Link copied to clipboard
fun tag(key: String, value: String): Flux<O>
Link copied to clipboard
fun take(timespan: Duration): Flux<O>
fun take(n: Long): Flux<O>
fun take(timespan: Duration, timer: Scheduler): Flux<O>
fun take(n: Long, limitRequest: Boolean): Flux<O>
Link copied to clipboard
fun takeLast(n: Int): Flux<O>
Link copied to clipboard
fun takeUntil(predicate: Predicate<in O>): Flux<O>
Link copied to clipboard
fun takeUntilOther(other: Publisher<*>): Flux<O>
Link copied to clipboard
fun takeWhile(continuePredicate: Predicate<in O>): Flux<O>
Link copied to clipboard
fun tap(listenerGenerator: Function<ContextView, SignalListener<O>>): Flux<O>
fun tap(simpleListenerGenerator: Supplier<SignalListener<O>>): Flux<O>
fun tap(listenerFactory: SignalListenerFactory<O, *>): Flux<O>
Link copied to clipboard
fun then(): Mono<Void>
fun <V : Any> then(other: Mono<V>): Mono<V>
Link copied to clipboard
fun thenEmpty(other: Publisher<Void>): Mono<Void>
Link copied to clipboard
fun <V : Any> thenMany(other: Publisher<V>): Flux<V>
Link copied to clipboard
fun timed(): Flux<Timed<O>>
fun timed(clock: Scheduler): Flux<Timed<O>>
Link copied to clipboard
fun timeout(timeout: Duration): Flux<O>
fun <U : Any> timeout(firstTimeout: Publisher<U>): Flux<O>
fun timeout(timeout: Duration, fallback: @Nullable Publisher<out O>?): Flux<O>
fun timeout(timeout: Duration, timer: Scheduler): Flux<O>
fun <U : Any, V : Any> timeout(firstTimeout: Publisher<U>, nextTimeoutFactory: Function<in O, out Publisher<V>>): Flux<O>
fun timeout(timeout: Duration, fallback: @Nullable Publisher<out O>?, timer: Scheduler): Flux<O>
fun <U : Any, V : Any> timeout(firstTimeout: Publisher<U>, nextTimeoutFactory: Function<in O, out Publisher<V>>, fallback: Publisher<out O>): Flux<O>
Link copied to clipboard
fun timestamp(): Flux<Tuple2<Long, O>>
fun timestamp(scheduler: Scheduler): Flux<Tuple2<Long, O>>
Link copied to clipboard
fun toIterable(): Iterable<O>
fun toIterable(batchSize: Int): Iterable<O>
fun toIterable(batchSize: Int, queueProvider: @Nullable Supplier<Queue<O>>?): Iterable<O>
Link copied to clipboard
fun toStream(): Stream<O>
fun toStream(batchSize: Int): Stream<O>
Link copied to clipboard
fun <V : Any> transform(transformer: Function<in Flux<O>, out Publisher<V>>): Flux<V>
Link copied to clipboard
fun <V : Any> transformDeferred(transformer: Function<in Flux<O>, out Publisher<V>>): Flux<V>
Link copied to clipboard
fun <V : Any> transformDeferredContextual(transformer: BiFunction<in Flux<O>, in ContextView, out Publisher<V>>): Flux<V>
Link copied to clipboard
fun window(windowingTimespan: Duration): Flux<Flux<O>>
fun window(maxSize: Int): Flux<Flux<O>>
fun window(boundary: Publisher<*>): Flux<Flux<O>>
fun window(windowingTimespan: Duration, openWindowEvery: Duration): Flux<Flux<O>>
fun window(windowingTimespan: Duration, timer: Scheduler): Flux<Flux<O>>
fun window(maxSize: Int, skip: Int): Flux<Flux<O>>
fun window(windowingTimespan: Duration, openWindowEvery: Duration, timer: Scheduler): Flux<Flux<O>>
Link copied to clipboard
fun windowTimeout(maxSize: Int, maxTime: Duration): Flux<Flux<O>>
fun windowTimeout(maxSize: Int, maxTime: Duration, fairBackpressure: Boolean): Flux<Flux<O>>
fun windowTimeout(maxSize: Int, maxTime: Duration, timer: Scheduler): Flux<Flux<O>>
fun windowTimeout(maxSize: Int, maxTime: Duration, timer: Scheduler, fairBackpressure: Boolean): Flux<Flux<O>>
Link copied to clipboard
fun windowUntil(boundaryTrigger: Predicate<O>): Flux<Flux<O>>
fun windowUntil(boundaryTrigger: Predicate<O>, cutBefore: Boolean): Flux<Flux<O>>
fun windowUntil(boundaryTrigger: Predicate<O>, cutBefore: Boolean, prefetch: Int): Flux<Flux<O>>
Link copied to clipboard
fun windowUntilChanged(): Flux<Flux<O>>
fun <V : Any> windowUntilChanged(keySelector: Function<in O, in V>): Flux<Flux<O>>
fun <V : Any> windowUntilChanged(keySelector: Function<in O, out V>, keyComparator: BiPredicate<in V, in V>): Flux<Flux<O>>
Link copied to clipboard
fun <U : Any, V : Any> windowWhen(bucketOpening: Publisher<U>, closeSelector: Function<in U, out Publisher<V>>): Flux<Flux<O>>
Link copied to clipboard
fun windowWhile(inclusionPredicate: Predicate<O>): Flux<Flux<O>>
fun windowWhile(inclusionPredicate: Predicate<O>, prefetch: Int): Flux<Flux<O>>
Link copied to clipboard
fun <U : Any, R : Any> withLatestFrom(other: Publisher<out U>, resultSelector: BiFunction<in O, in U, out R>): Flux<R>
Link copied to clipboard
fun <T2 : Any> zipWith(source2: Publisher<out T2>): Flux<Tuple2<O, T2>>
fun <T2 : Any, V : Any> zipWith(source2: Publisher<out T2>, combinator: BiFunction<in O, in T2, out V>): Flux<V>
fun <T2 : Any> zipWith(source2: Publisher<out T2>, prefetch: Int): Flux<Tuple2<O, T2>>
fun <T2 : Any, V : Any> zipWith(source2: Publisher<out T2>, prefetch: Int, combinator: BiFunction<in O, in T2, out V>): Flux<V>
Link copied to clipboard
fun <T2 : Any> zipWithIterable(iterable: Iterable<out T2>): Flux<Tuple2<O, T2>>
fun <T2 : Any, V : Any> zipWithIterable(iterable: Iterable<out T2>, zipper: BiFunction<in O, in T2, out V>): Flux<V>
Generated by Dokka
© 2026 Copyright