Uses of Interface
io.smallrye.mutiny.Multi

Packages that use Multi

Package	Description
io.smallrye.mutiny
io.smallrye.mutiny.converters
io.smallrye.mutiny.converters.multi
io.smallrye.mutiny.groups
io.smallrye.mutiny.helpers
io.smallrye.mutiny.infrastructure
io.smallrye.mutiny.operators
io.smallrye.mutiny.operators.multi
io.smallrye.mutiny.operators.multi.builders
io.smallrye.mutiny.operators.multi.multicast
io.smallrye.mutiny.operators.multi.overflow
io.smallrye.mutiny.operators.multi.processors

Uses of Multi in io.smallrye.mutiny

Subinterfaces of Multi in io.smallrye.mutiny

Modifier and Type	Interface and Description
interface	GroupedMulti<K,T> A specialization of Multi used by the group operation.

Methods in io.smallrye.mutiny that return Multi

Modifier and Type	Method and Description
Multi<T>	Multi.cache() Creates a new Multi that subscribes to this upstream and caches all of its events and replays them, to all the downstream subscribers.
default <O> Multi<O>	Multi.concatMap(Function<? super T,? extends org.reactivestreams.Publisher<? extends O>> mapper) Produces a Multi containing the items from Publisher produced by the mapper for each item emitted by this Multi.
Multi<T>	Multi.emitOn(Executor executor) Produces a new Multi invoking the onItem, onFailure and onCompletion methods on the supplied Executor.
default Multi<T>	Multi.filter(Predicate<? super T> predicate) Produces a new Multi with items from the upstream Multi matching the predicate.
default <O> Multi<O>	Multi.flatMap(Function<? super T,? extends org.reactivestreams.Publisher<? extends O>> mapper) Produces a Multi containing the items from Publisher produced by the mapper for each item emitted by this Multi.
default Multi<T>	Multi.invoke(Consumer<? super T> callback) Produces a new Multi invoking the given callback when an item event is fired by the upstream.
default Multi<T>	Multi.invokeUni(Function<? super T,? extends Uni<?>> action) Produces a new Multi invoking the given @{code action} when an item event is received.
default <O> Multi<O>	Multi.map(Function<? super T,? extends O> mapper) Produces a new Multi invoking the given function for each item emitted by the upstream Multi.
Multi<T>	Multi.runSubscriptionOn(Executor executor) When a subscriber subscribes to this Multi, execute the subscription to the upstream Multi on a thread from the given executor.
default Multi<T>	Multi.subscribeOn(Executor executor) Deprecated. Use runSubscriptionOn(Executor) instead.
Multi<T>	Uni.toMulti() Creates an instance of Multi from this Uni.

Method parameters in io.smallrye.mutiny with type arguments of type Multi

Modifier and Type	Method and Description
default <O> O	Multi.stage(Function<Multi<T>,O> stage) Allows structuring the pipeline by creating a logic separation:
default <O> O	Multi.then(Function<Multi<T>,O> stage) Deprecated. use stage(Function)

Uses of Multi in io.smallrye.mutiny.converters

Methods in io.smallrye.mutiny.converters that return Multi

Modifier and Type	Method and Description
Multi<T>	MultiConverter.from(I instance) Convert from type to Multi.

Uses of Multi in io.smallrye.mutiny.converters.multi

Methods in io.smallrye.mutiny.converters.multi that return Multi

Modifier and Type	Method and Description
Multi<T>	FromCompletionStage.from(CompletionStage<T> instance)

Uses of Multi in io.smallrye.mutiny.groups

Methods in io.smallrye.mutiny.groups that return Multi

Modifier and Type	Method and Description
<R> Multi<R>	MultiOnItem.apply(Function<? super T,? extends R> mapper) Deprecated. Use MultiOnItem.transform(Function)
Multi<T>	MultiOnFailure.apply(Function<? super Throwable,? extends Throwable> mapper) Deprecated. use MultiOnFailure.transform(Function)
Multi<T>	MultiRetry.atMost(long numberOfAttempts) Produces a Multi resubscribing to the current Multi at most numberOfAttempts time, until it gets items followed by the completion event.
Multi<T>	UniRepeat.atMost(long times) Generates a stream, containing the items from the upstream Uni, resubscribed at most times times.
Multi<T>	MultiOverflow.buffer() When the downstream cannot keep up with the upstream emissions, instruct to use an unbounded buffer to store the items until they are consumed.
Multi<T>	MultiOverflow.buffer(int size) When the downstream cannot keep up with the upstream emissions, instruct to use a buffer of size size to store the items until they are consumed.
static <T> Multi<T>	MultiOverflow.buffer(Multi<T> upstream, int size)
<K> Multi<GroupedMulti<K,T>>	MultiGroup.by(Function<? super T,? extends K> keyMapper)
<K,V> Multi<GroupedMulti<K,V>>	MultiGroup.by(Function<? super T,? extends K> keyMapper, Function<? super T,? extends V> valueMapper)
Multi<T>	MultiTransform.byDroppingDuplicates()
Multi<T>	MultiTransform.byDroppingRepetitions()
Multi<T>	MultiTransform.byFilteringItemsWith(Predicate<? super T> predicate) Produces a Multi containing the items from this Multi passing the predicate test.
Multi<T>	MultiTransform.byMergingWith(Iterable<org.reactivestreams.Publisher<T>> iterable)
Multi<T>	MultiTransform.byMergingWith(org.reactivestreams.Publisher<T>... publishers)
Multi<T>	MultiTransform.bySkippingFirstItems(long number)
Multi<T>	MultiTransform.bySkippingItemsFor(Duration duration)
Multi<T>	MultiTransform.bySkippingItemsWhile(Predicate<? super T> predicate)
Multi<T>	MultiTransform.bySkippingLastItems(int number)
Multi<T>	MultiTransform.byTakingFirstItems(long number)
Multi<T>	MultiTransform.byTakingItemsFor(Duration duration)
Multi<T>	MultiTransform.byTakingItemsWhile(Predicate<? super T> predicate)
Multi<T>	MultiTransform.byTakingLastItems(int number)
Multi<T>	MultiTransform.byTestingItemsWith(Function<? super T,? extends Uni<Boolean>> tester) Produces a Multi containing the items from this Multi passing the tester asynchronous test.
Multi<T>	MultiOnEvent.cancellation(Runnable callback) Attaches an action executed when a subscription is cancelled.
<O> Multi<O>	MultiOnItem.castTo(Class<O> target) Produces an Multi emitting the item events based on the upstream events but casted to the target class.
Multi<T>	MultiOnEvent.completion(Runnable callback)
<T> Multi<T>	MultiCreate.completionStage(CompletionStage<? extends T> stage) Creates a Multi from the given CompletionStage or CompletableFuture.
<T> Multi<T>	MultiCreate.completionStage(Supplier<? extends CompletionStage<? extends T>> supplier) Creates a Multi from the given CompletionStage or CompletableFuture.
Multi<O>	MultiFlatten.concatenate() Produces a Multi containing the items from Publisher produced by the mapper for each item emitted by this Multi.
Multi<T>	MultiIfEmpty.continueWith(Iterable<T> items) When the upstream Multi completes without having emitted items, continue with the given items.
Multi<T>	MultiOnCompletion.continueWith(Iterable<T> items) When the upstream Multi completes, continue with the given items.
Multi<T>	MultiIfEmpty.continueWith(Supplier<? extends Iterable<? extends T>> supplier) When the upstream Multi completes without having emitted items, continue with the items produced by the given Supplier.
Multi<T>	MultiOnCompletion.continueWith(Supplier<? extends Iterable<? extends T>> supplier) When the upstream Multi completes, continue with the items produced by the given Supplier.
Multi<T>	MultiIfEmpty.continueWith(T... items) When the upstream Multi completes without having emitted items, continue with the given items.
Multi<T>	MultiOnCompletion.continueWith(T... items) When the upstream Multi completes, continue with the given items.
<I,T> Multi<T>	MultiCreate.converter(MultiConverter<I,T> converter, I instance) Creates a new Uni from the passed instance with the passed converter.
<T> Multi<T>	MultiCreate.deferred(Supplier<? extends Multi<? extends T>> supplier) Creates a Multi that supplies an Multi to subscribe to for each Subscriber.
<O> Multi<O>	MultiOnItem.disjoint() Takes the items from the upstream Multi that are either Publisher<O>, O[], Iterable<O> or Multi<O> and disjoint the items to obtain a Multi<O>.
Multi<T>	MultiOverflow.drop() When the downstream cannot keep up with the upstream emissions, instruct to drop the item.
Multi<T>	MultiOverflow.drop(Consumer<T> callback) When the downstream cannot keep up with the upstream emissions, instruct to drop the item.
Multi<T>	MultiOverflow.dropPreviousItems() When the downstream cannot keep up with the upstream emissions, instruct to drop all previously buffered items.
<T> Multi<T>	MultiCreate.emitter(Consumer<MultiEmitter<? super T>> consumer) Like MultiCreate.emitter(Consumer, BackPressureStrategy) with the BackPressureStrategy.BUFFER strategy.
<T> Multi<T>	MultiCreate.emitter(Consumer<MultiEmitter<? super T>> consumer, BackPressureStrategy strategy) Creates a Multi deferring the logic to the given consumer.
<T> Multi<T>	MultiCreate.empty() Creates a Multi that fires the completion event without having emitted any items.
Multi<Multi<T>>	MultiGroupIntoMultis.every(Duration duration) Creates a Multi that emits Multi of items collected from the observed Multi.
Multi<List<T>>	MultiGroupIntoLists.every(Duration duration) Creates a Multi that emits lists of items collected from the observed Multi.
Multi<Long>	MultiTimePeriod.every(Duration duration)
Multi<T>	MultiRetry.expireAt(long expireAt) Produces a Multi resubscribing to the current Multi until expireAt time or until it gets items followed by the completion event.
Multi<T>	MultiRetry.expireIn(long expireIn) Produces a Multi resubscribing to the current Multi until expireIn time or until it gets items followed by the completion event.
Multi<T>	MultiIfEmpty.fail() Like MultiIfEmpty.failWith(Throwable) but using a NoSuchElementException.
Multi<T>	MultiOnCompletion.fail() Like MultiOnCompletion.failWith(Throwable) but using a NoSuchElementException.
<T> Multi<T>	MultiCreate.failure(Supplier<Throwable> supplier) Creates a Multi that emits a failure event produced using the passed supplier immediately after being subscribed to.
<T> Multi<T>	MultiCreate.failure(Throwable failure) Creates a Multi that emits a failure event immediately after being subscribed to.
Multi<T>	MultiIfEmpty.failWith(Supplier<? extends Throwable> supplier) When the current Multi completes without having emitted items, a failure produced by the given Supplier is sent downstream.
Multi<T>	MultiOnCompletion.failWith(Supplier<Throwable> supplier) When the current Multi completes, a failure produced by the given Supplier is sent downstream.
Multi<T>	MultiIfEmpty.failWith(Throwable failure) When the current Multi completes without having emitted items, the passed failure is sent downstream.
Multi<T>	MultiOnCompletion.failWith(Throwable failure) When the current Multi completes, the passed failure is sent downstream.
Multi<Void>	MultiOnItem.ignore() Ignores the passed items.
Multi<T>	MultiRetry.indefinitely() Produces a Multi resubscribing to the current Multi until it gets a items followed by a completion events.
Multi<T>	UniRepeat.indefinitely() Generates an unbounded stream, indefinitely resubscribing to the Uni.
Multi<T>	MultiOnTerminate.invoke(BiConsumer<Throwable,Boolean> callback) Attaches an action that is executed when the Multi emits a completion or a failure or when the subscriber cancels the subscription.
Multi<T>	MultiOnSubscribe.invoke(Consumer<? super org.reactivestreams.Subscription> callback) Produces a new Multi invoking the given callback when the subscription is received.
Multi<T>	MultiOnItem.invoke(Consumer<? super T> callback) Produces a new Multi invoking the given callback when an item event is fired by the upstream.
Multi<T>	MultiOnFailure.invoke(Consumer<Throwable> callback) Produces a new Multi invoking the given callback when the upstream Multi emits a failure (matching the predicate if set).
Multi<T>	MultiOnCompletion.invoke(Runnable callback) Creates a new Multi executing the given action when this Multi completes.
Multi<T>	MultiOnTerminate.invoke(Runnable action) Attaches an action that is executed when the Multi emits a completion or a failure or when the subscriber cancels the subscription.
Multi<T>	MultiOnTerminate.invokeUni(BiFunction<Throwable,Boolean,Uni<?>> mapper) Attaches an action that is executed when the Multi mits a completion or a failure or when the subscriber cancels the subscription.
Multi<T>	MultiOnSubscribe.invokeUni(Function<? super org.reactivestreams.Subscription,Uni<?>> action) Produces a new Multi invoking the given @{code action} when the subscription event is received.
Multi<T>	MultiOnItem.invokeUni(Function<? super T,? extends Uni<?>> action) Produces a new Multi invoking the given @{code action} when an item event is received.
Multi<T>	MultiOnFailure.invokeUni(Function<Throwable,? extends Uni<?>> action) Produces a new Multi invoking the given @{code action} when a failure event is received.
<T> Multi<T>	MultiCreate.item(Supplier<? extends T> supplier) Creates a new Multi that emits an item immediately after being subscribed to with the specified single (potentially null) value.
<T> Multi<T>	MultiCreate.item(T item) Creates a new Multi that emits an item immediately after being subscribed to with the specified single item.
<T> Multi<T>	MultiCreate.items(Stream<T> items) Creates a new Multi that emits the items from the passed Stream individually after being subscribed to (according to the subscriber's request).
<T> Multi<T>	MultiCreate.items(Supplier<? extends Stream<? extends T>> supplier) Creates a new Multi that emits the items immediately after being subscribed to.
<T> Multi<T>	MultiCreate.items(T... items) Creates a new Multi that emits the items individually after being subscribed to (according to the subscriber's request).
<T> Multi<T>	MultiCreate.iterable(Iterable<T> iterable) Creates a new Multi that emits the items individually after being subscribed to (according to the subscriber's request).
Multi<O>	MultiFlatten.merge() Produces a Multi containing the items from Publisher produced by the mapper for each item emitted by this Multi.
Multi<O>	MultiFlatten.merge(int concurrency) Produces a Multi containing the items from Publisher produced by the mapper for each item emitted by this Multi.
<T> Multi<T>	MultiCreate.nothing() Creates a Multi that will never fire any events.
Multi<Multi<T>>	MultiGroupIntoMultis.of(int size) Creates a Multi that emits windows of items collected from the observed Multi.
Multi<List<T>>	MultiGroupIntoLists.of(int size) Creates a Multi that emits lists of items collected from the observed Multi.
Multi<Multi<T>>	MultiGroupIntoMultis.of(int size, int skip) Creates a Multi that emits windows of items collected from the observed Multi.
Multi<List<T>>	MultiGroupIntoLists.of(int size, int skip) Creates a Multi that emits lists of items collected from the observed Multi.
<T> Multi<T>	MultiCreate.optional(Optional<T> optional) Creates a new Multi that emits an item immediately after being subscribed to with the value contained in the given optional if Optional.isPresent() or empty otherwise.
<T> Multi<T>	MultiCreate.optional(Supplier<Optional<T>> supplier) Creates a new Multi that emits an item immediately after being subscribed to with the value contained in the optional supplied by supplier.
<R> Multi<R>	UniOnNotNull.produceMulti(Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper) Deprecated. Use UniOnNotNull.transformToMulti(Function) instead
<R> Multi<R>	UniOnItem.produceMulti(Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper) Deprecated. Use UniOnItem.transformToMulti(Function)
<T> Multi<T>	MultiCreate.publisher(org.reactivestreams.Publisher<T> publisher) Creates a Multi from the passed Publisher.
Multi<Integer>	MultiCreate.range(int startInclusive, int endExclusive) Creates a Multi emitting the sequence of integer from startInclusive to endExclusive.
Multi<T>	MultiOnFailure.recoverWithCompletion() Recovers from the received failure (matching the predicate if set) by completing the stream.
Multi<T>	MultiOnFailure.recoverWithItem(Function<? super Throwable,? extends T> function) Recovers from the received failure (matching the predicate if set) by using a item generated by the given function.
Multi<T>	MultiOnFailure.recoverWithItem(Supplier<T> supplier) Recovers from the received failure (matching the predicate if set) by using a item generated by the given supplier.
Multi<T>	MultiOnFailure.recoverWithItem(T fallback) Recovers from the received failure (matching the predicate if set) by using a fallback item.
Multi<T>	MultiOnFailure.recoverWithMulti(Function<? super Throwable,? extends Multi<? extends T>> function) Recovers from the received failure (matching the predicate if set) with another Multi.
Multi<T>	MultiOnFailure.recoverWithMulti(Multi<? extends T> fallback) Recovers from the received failure (matching the predicate if set) with another given Multi.
Multi<T>	MultiOnFailure.recoverWithMulti(Supplier<? extends Multi<? extends T>> supplier) Recovers from the received failure (matching the predicate if set) with another Multi.
Multi<T>	MultiOnEvent.request(LongConsumer callback)
Multi<T>	MultiOnItem.scan(BinaryOperator<T> accumulator) Produces a Multi that fires results coming from the reduction of the item emitted by this current Multi by the passed accumulator reduction function.
<S> Multi<S>	MultiOnItem.scan(Supplier<S> initialStateProducer, BiFunction<S,? super T,S> accumulator) Produces a Multi that fires items coming from the reduction of the item emitted by this current Multi by the passed accumulator reduction function.
<T> Multi<T>	MultiConcat.streams(Iterable<? extends org.reactivestreams.Publisher<T>> iterable) Creates a new Multi concatenating the items emitted by the given multis / publishers..
<T> Multi<T>	MultiMerge.streams(Iterable<org.reactivestreams.Publisher<T>> iterable) Creates a new Multi merging the items emitted by the given publishers / publishers.
<T> Multi<T>	MultiMerge.streams(org.reactivestreams.Publisher<T>... publishers) Creates a new Multi merging the items emitted by the given multis / publishers.
<T> Multi<T>	MultiConcat.streams(org.reactivestreams.Publisher<T>... publishers) Creates a new Multi concatenating the items emitted by the given multis / publishers.
Multi<T>	MultiOnEvent.subscribed(Consumer<? super org.reactivestreams.Subscription> callback) Deprecated. Use onSubscribe()
Multi<T>	MultiIfEmpty.switchTo(org.reactivestreams.Publisher<? extends T> other) When the upstream Multi completes without having emitted items, it continues with the events fired by the passed Publisher / Multi.
Multi<T>	MultiOnCompletion.switchTo(org.reactivestreams.Publisher<? extends T> other) When the upstream Multi completes, it continues with the events fired by the passed Publisher / Multi.
Multi<T>	MultiIfEmpty.switchTo(Supplier<org.reactivestreams.Publisher<? extends T>> supplier) When the upstream Multi completes without having emitted items, it continues with the events fired by a Publisher produces with the given Supplier.
Multi<T>	MultiOnCompletion.switchTo(Supplier<org.reactivestreams.Publisher<? extends T>> supplier) When the upstream Multi completes, it continues with the events fired by a Publisher produces with the given Supplier.
Multi<T>	MultiIfEmpty.switchToEmitter(Consumer<MultiEmitter<? super T>> consumer) When the upstream Multi completes without having emitted items, it continues with the events fired with the emitter passed to the consumer callback.
Multi<T>	MultiOnCompletion.switchToEmitter(Consumer<MultiEmitter<? super T>> consumer) When the upstream Multi completes, it continues with the events fired with the emitter passed to the consumer callback.
Multi<T>	MultiOnEvent.termination(BiConsumer<Throwable,Boolean> callback) Deprecated. use {onTermination()}
Multi<T>	MultiOnEvent.termination(Runnable action) Deprecated. use {onTermination()}
Multi<T>	MultiBroadcast.toAllSubscribers() Broadcasts the events of the upstream Multi to all the subscribers.
Multi<T>	MultiBroadcast.toAtLeast(int numberOfSubscribers) Broadcasts the events of the upstream Multi to several subscribers.
Multi<T>	MultiTransform.toHotStream() Produces a new Multi transforming the upstream into a hot stream.
<R> Multi<R>	MultiOnItem.transform(Function<? super T,? extends R> mapper) Produces a new Multi invoking the given function for each item emitted by the upstream Multi.
Multi<T>	MultiOnFailure.transform(Function<? super Throwable,? extends Throwable> mapper) Produces a new Multi invoking the given function when the current Multi propagates a failure.
<O> Multi<O>	MultiOnItem.transformToIterable(Function<? super T,? extends Iterable<O>> mapper) On each item received from the upstream, call the given mapper.
<R> Multi<R>	UniOnNotNull.transformToMulti(Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper) When this Uni produces its item (not null), call the given mapper to produce a Publisher.
<R> Multi<R>	UniOnItem.transformToMulti(Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper) When this Uni produces its item (maybe null), call the given mapper to produce a Publisher.
<O> Multi<O>	MultiOnItem.transformToMultiAndConcatenate(Function<? super T,? extends org.reactivestreams.Publisher<? extends O>> mapper) For each items emitted by the upstream, the given mapper is invoked.
<O> Multi<O>	MultiOnItem.transformToMultiAndMerge(Function<? super T,? extends org.reactivestreams.Publisher<? extends O>> mapper) For each items emitted by the upstream, the given mapper is invoked.
<O> Multi<O>	MultiOnItem.transformToUniAndConcatenate(Function<? super T,? extends Uni<? extends O>> mapper) For each items emitted by the upstream, the given mapper is invoked.
<O> Multi<O>	MultiOnItem.transformToUniAndMerge(Function<? super T,? extends Uni<? extends O>> mapper) For each items emitted by the upstream, the given mapper is invoked.
<T> Multi<T>	MultiCreate.uni(Uni<T> uni) Creates an never of Multi from the given Uni.
Multi<T>	MultiRetry.until(Predicate<? super Throwable> predicate) Produces a Multi resubscribing to the current Multi until the given predicate returns false.
Multi<T>	UniRepeat.until(Predicate<T> predicate) Generates a stream, containing the items from the upstream Uni, resubscribed until the given predicate returns true.
Multi<T>	MultiRetry.when(Function<Multi<Throwable>,? extends org.reactivestreams.Publisher<?>> whenStreamFactory) Produces a Multi resubscribing to the current Multi when the Publisher produced by the given method emits an item.
Multi<T>	UniRepeat.whilst(Predicate<T> predicate) Generates a stream, containing the items from the upstream Uni, resubscribed while the given predicate returns true.
Multi<I>	MultiResource.withFinalizer(Consumer<? super R> finalizer) Configures a synchronous finalizer.
Multi<I>	MultiResource.withFinalizer(Function<? super R,Uni<Void>> finalizer) Configures an asynchronous finalizer.
Multi<I>	MultiResource.withFinalizer(Function<? super R,Uni<Void>> onCompletion, BiFunction<? super R,? super Throwable,Uni<Void>> onFailure, Function<? super R,Uni<Void>> onCancellation) Configures asynchronous finalizers distinct for each event.

Methods in io.smallrye.mutiny.groups that return types with arguments of type Multi

Modifier and Type	Method and Description
Multi<Multi<T>>	MultiGroupIntoMultis.every(Duration duration) Creates a Multi that emits Multi of items collected from the observed Multi.
Multi<Multi<T>>	MultiGroupIntoMultis.of(int size) Creates a Multi that emits windows of items collected from the observed Multi.
Multi<Multi<T>>	MultiGroupIntoMultis.of(int size, int skip) Creates a Multi that emits windows of items collected from the observed Multi.

Methods in io.smallrye.mutiny.groups with parameters of type Multi

Modifier and Type	Method and Description
static <T> Multi<T>	MultiOverflow.buffer(Multi<T> upstream, int size)
<T> Uni<T>	UniCreate.multi(Multi<T> multi) Creates a Uni from the given Multi.
Multi<T>	MultiOnFailure.recoverWithMulti(Multi<? extends T> fallback) Recovers from the received failure (matching the predicate if set) with another given Multi.

Method parameters in io.smallrye.mutiny.groups with type arguments of type Multi

Modifier and Type	Method and Description
<T> Multi<T>	MultiCreate.deferred(Supplier<? extends Multi<? extends T>> supplier) Creates a Multi that supplies an Multi to subscribe to for each Subscriber.
Multi<T>	MultiOnFailure.recoverWithMulti(Function<? super Throwable,? extends Multi<? extends T>> function) Recovers from the received failure (matching the predicate if set) with another Multi.
Multi<T>	MultiOnFailure.recoverWithMulti(Supplier<? extends Multi<? extends T>> supplier) Recovers from the received failure (matching the predicate if set) with another Multi.
Multi<T>	MultiRetry.when(Function<Multi<Throwable>,? extends org.reactivestreams.Publisher<?>> whenStreamFactory) Produces a Multi resubscribing to the current Multi when the Publisher produced by the given method emits an item.
Uni<T>	UniRetry.when(Function<Multi<Throwable>,? extends org.reactivestreams.Publisher<?>> whenStreamFactory) Produces a Uni resubscribing to the current Uni when the Publisher produced by the given method emits an item.
<R> R	MultiConvert.with(Function<Multi<T>,R> converter) Transforms this Multi into a type using the provided converter.

Constructors in io.smallrye.mutiny.groups with parameters of type Multi

Constructor and Description
MultiBroadcast(Multi<T> upstream)
MultiCollect(Multi<T> upstream)
MultiConvert(Multi<T> upstream)
MultiGroup(Multi<T> upstream)
MultiGroupIntoLists(Multi<T> upstream)
MultiGroupIntoMultis(Multi<T> upstream)
MultiOnCompletion(Multi<T> upstream)
MultiOnEvent(Multi<T> upstream)
MultiOnFailure(Multi<T> upstream, Predicate<? super Throwable> predicate)
MultiOnItem(Multi<T> upstream)
MultiOnSubscribe(Multi<T> upstream)
MultiOnTerminate(Multi<T> upstream)
MultiOverflow(Multi<T> upstream)
MultiRetry(Multi<T> upstream)
MultiTransform(Multi<T> upstream)

Uses of Multi in io.smallrye.mutiny.helpers

Methods in io.smallrye.mutiny.helpers that return Multi

Modifier and Type	Method and Description
Multi<T>	MultiEmitterProcessor.toMulti()

Methods in io.smallrye.mutiny.helpers that return types with arguments of type Multi

Modifier and Type	Method and Description
static Function<Multi<Throwable>,org.reactivestreams.Publisher<Long>>	ExponentialBackoff.randomExponentialBackoffFunction(long numRetries, Duration firstBackoff, Duration maxBackoff, double jitterFactor, ScheduledExecutorService executor) Computes a method that would delay ticks using an exponential backoff.
static Function<Multi<Throwable>,org.reactivestreams.Publisher<Long>>	ExponentialBackoff.randomExponentialBackoffFunctionExpireAt(long expireAt, Duration firstBackoff, Duration maxBackoff, double jitterFactor, ScheduledExecutorService executor) Computes a method that would delay ticks using an exponential backoff.

Uses of Multi in io.smallrye.mutiny.infrastructure

Methods in io.smallrye.mutiny.infrastructure that return Multi

Modifier and Type	Method and Description
default <T> Multi<T>	MultiInterceptor.onMultiCreation(Multi<T> multi) Method called when a new instance of Multi is created.
static <T> Multi<T>	Infrastructure.onMultiCreation(Multi<T> instance)

Methods in io.smallrye.mutiny.infrastructure with parameters of type Multi

Modifier and Type	Method and Description
default <T> Multi<T>	MultiInterceptor.onMultiCreation(Multi<T> multi) Method called when a new instance of Multi is created.
static <T> Multi<T>	Infrastructure.onMultiCreation(Multi<T> instance)

Uses of Multi in io.smallrye.mutiny.operators

Classes in io.smallrye.mutiny.operators that implement Multi

Modifier and Type	Class and Description
class	AbstractMulti<T>
class	MultiFlatMapOnFailure<T>
class	MultiMapOnFailure<T>
class	MultiOperator<I,O>
class	MultiSwitchOnCompletion<T>
class	MultiSwitchOnEmpty<T>
class	UniOnItemTransformToMulti<I,O>

Methods in io.smallrye.mutiny.operators that return Multi

Modifier and Type	Method and Description
Multi<Tuple3<T1,T2,T3>>	MultiItemCombine3.asTuple()
Multi<Tuple2<T1,T2>>	MultiItemCombine2.asTuple()
Multi<Tuple5<T1,T2,T3,T4,T5>>	MultiItemCombine5.asTuple()
Multi<Tuple6<T1,T2,T3,T4,T5,T6>>	MultiItemCombine6.asTuple()
Multi<Tuple9<T1,T2,T3,T4,T5,T6,T7,T8,T9>>	MultiItemCombine9.asTuple()
Multi<Tuple4<T1,T2,T3,T4>>	MultiItemCombine4.asTuple()
Multi<Tuple7<T1,T2,T3,T4,T5,T6,T7>>	MultiItemCombine7.asTuple()
Multi<Tuple8<T1,T2,T3,T4,T5,T6,T7,T8>>	MultiItemCombine8.asTuple()
Multi<T>	AbstractMulti.cache()
static <T> Multi<T>	MultiTransformation.distinct(Multi<T> upstream)
static <T> Multi<T>	MultiTransformation.dropRepetitions(Multi<T> upstream)
Multi<T>	AbstractMulti.emitOn(Executor executor)
static <T> Multi<List<T>>	MultiCollector.list(Multi<T> upstream, Duration timeWindow)
static <T> Multi<List<T>>	MultiCollector.list(Multi<T> upstream, int size)
static <T> Multi<List<T>>	MultiCollector.list(Multi<T> upstream, int size, int skip)
static <T> Multi<T>	MultiCombine.merge(List<org.reactivestreams.Publisher<T>> participants, boolean collectFailures, int requests, int concurrency)
static <T> Multi<T>	MultiBroadcaster.publish(Multi<T> upstream, int numberOfSubscribers, boolean cancelWhenNoOneIsListening, Duration delayAfterLastDeparture)
Multi<T>	AbstractMulti.runSubscriptionOn(Executor executor)
static <T> Multi<T>	MultiTransformation.skipFirst(Multi<T> upstream, long number)
static <T> Multi<T>	MultiTransformation.skipForDuration(Multi<T> upstream, Duration duration)
static <T> Multi<T>	MultiTransformation.skipLast(Multi<T> upstream, int number)
static <T> Multi<T>	MultiTransformation.skipWhile(Multi<T> upstream, Predicate<? super T> predicate)
static <T> Multi<T>	MultiTransformation.takeFirst(Multi<T> upstream, long number)
static <T> Multi<T>	MultiTransformation.takeForDuration(Multi<T> upstream, Duration duration)
static <T> Multi<T>	MultiTransformation.takeLast(Multi<T> upstream, int number)
static <T> Multi<T>	MultiTransformation.takeWhile(Multi<T> upstream, Predicate<? super T> predicate)
Multi<T>	AbstractUni.toMulti()
Multi<I>	MultiOperator.upstream()
<O> Multi<O>	MultiItemCombine2.using(BiFunction<T1,T2,O> combinator) Creates the resulting Multi.
<O> Multi<O>	MultiItemCombineIterable.using(Function<List<?>,O> combinator) Sets the combination logic as parameter and returns a Multi associating the items from the observed stream using this combinator.
<O> Multi<O>	MultiItemCombine3.using(Functions.Function3<T1,T2,T3,O> combinator) Creates the resulting Multi.
<O> Multi<O>	MultiItemCombine4.using(Functions.Function4<T1,T2,T3,T4,O> combinator) Creates the resulting Multi.
<O> Multi<O>	MultiItemCombine5.using(Functions.Function5<T1,T2,T3,T4,T5,O> combinator) Creates the resulting Multi.
<O> Multi<O>	MultiItemCombine6.using(Functions.Function6<T1,T2,T3,T4,T5,T6,O> combinator) Creates the resulting Multi.
<O> Multi<O>	MultiItemCombine7.using(Functions.Function7<T1,T2,T3,T4,T5,T6,T7,O> combinator) Creates the resulting Multi.
<O> Multi<O>	MultiItemCombine8.using(Functions.Function8<T1,T2,T3,T4,T5,T6,T7,T8,O> combinator) Creates the resulting Multi.
<O> Multi<O>	MultiItemCombine9.using(Functions.Function9<T1,T2,T3,T4,T5,T6,T7,T8,T9,O> combinator) Creates the resulting Multi.

Methods in io.smallrye.mutiny.operators with parameters of type Multi

Modifier and Type	Method and Description
static <R,T> Uni<R>	MultiCollector.collectInto(Multi<T> upstream, Supplier<R> producer, BiConsumer<R,? super T> combinator)
static <T,A,R> Uni<R>	MultiCollector.collector(Multi<T> upstream, Collector<? super T,A,? extends R> collector, boolean acceptNullAsInitialValue)
static <T> Multi<T>	MultiTransformation.distinct(Multi<T> upstream)
static <T> Multi<T>	MultiTransformation.dropRepetitions(Multi<T> upstream)
static <T> Uni<T>	MultiCollector.first(Multi<T> upstream)
static <T> Uni<T>	MultiCollector.last(Multi<T> upstream)
static <T> Uni<List<T>>	MultiCollector.list(Multi<T> upstream)
static <T> Multi<List<T>>	MultiCollector.list(Multi<T> upstream, Duration timeWindow)
static <T> Multi<List<T>>	MultiCollector.list(Multi<T> upstream, int size)
static <T> Multi<List<T>>	MultiCollector.list(Multi<T> upstream, int size, int skip)
static <K,T> Uni<Map<K,T>>	MultiCollector.map(Multi<T> upstream, Function<? super T,? extends K> keyMapper)
static <K,V,T> Uni<Map<K,V>>	MultiCollector.map(Multi<T> upstream, Function<? super T,? extends K> keyMapper, Function<? super T,? extends V> valueMapper)
static <K,V,R> Uni<Map<K,Collection<V>>>	MultiCollector.multimap(Multi<R> upstream, Function<? super R,? extends K> keyMapper, Function<? super R,? extends V> valueMapper)
static <T> Multi<T>	MultiBroadcaster.publish(Multi<T> upstream, int numberOfSubscribers, boolean cancelWhenNoOneIsListening, Duration delayAfterLastDeparture)
static <T> Multi<T>	MultiTransformation.skipFirst(Multi<T> upstream, long number)
static <T> Multi<T>	MultiTransformation.skipForDuration(Multi<T> upstream, Duration duration)
static <T> Multi<T>	MultiTransformation.skipLast(Multi<T> upstream, int number)
static <T> Multi<T>	MultiTransformation.skipWhile(Multi<T> upstream, Predicate<? super T> predicate)
static <T> Multi<T>	MultiTransformation.takeFirst(Multi<T> upstream, long number)
static <T> Multi<T>	MultiTransformation.takeForDuration(Multi<T> upstream, Duration duration)
static <T> Multi<T>	MultiTransformation.takeLast(Multi<T> upstream, int number)
static <T> Multi<T>	MultiTransformation.takeWhile(Multi<T> upstream, Predicate<? super T> predicate)

Constructors in io.smallrye.mutiny.operators with parameters of type Multi

Constructor and Description
MultiFlatMapOnFailure(Multi<T> upstream, Predicate<? super Throwable> predicate, Function<? super Throwable,? extends Multi<? extends T>> mapper)
MultiMapOnFailure(Multi<T> upstream, Predicate<? super Throwable> predicate, Function<? super Throwable,? extends Throwable> mapper)
MultiOperator(Multi<I> upstream)
MultiSwitchOnCompletion(Multi<T> upstream, Supplier<org.reactivestreams.Publisher<? extends T>> supplier)
MultiSwitchOnEmpty(Multi<T> upstream, Supplier<org.reactivestreams.Publisher<? extends T>> supplier)

Constructor parameters in io.smallrye.mutiny.operators with type arguments of type Multi

Constructor and Description
MultiFlatMapOnFailure(Multi<T> upstream, Predicate<? super Throwable> predicate, Function<? super Throwable,? extends Multi<? extends T>> mapper)

Uses of Multi in io.smallrye.mutiny.operators.multi

Classes in io.smallrye.mutiny.operators.multi that implement Multi

Modifier and Type	Class and Description
class	AbstractMultiOperator<I,O> Abstract base class for operators that take an upstream source Multi.
class	MultiBufferOp<T> Buffers a given number of items and emits the groups as a single item downstream.
class	MultiBufferWithTimeoutOp<T> Buffers items from upstream for a given duration and emits the groups as a single item downstream.
class	MultiCacheOp<T> A multi caching the events emitted from upstreams and replaying it to subscribers.
class	MultiCollectorOp<T,A,R>
class	MultiCombineLatestOp<I,O> Combines the latest values from multiple sources through a function.
class	MultiConcatOp<T> Concatenates a fixed set of Publishers.
class	MultiDistinctOp<T> Eliminates the duplicated items from the upstream.
class	MultiDistinctUntilChangedOp<T> Eliminates the duplicated items from the upstream.
class	MultiEmitOnOp<T> Emits events from upstream on a thread managed by the given scheduler.
class	MultiFilterOp<T> Filters out items from the upstream that do NOT pass the given filter.
class	MultiFlatMapOp<I,O>
class	MultiGroupByOp<T,K,V>
class	MultiIgnoreOp<T>
class	MultiLastItemOp<T>
class	MultiMapOp<T,U>
class	MultiOnFailureResumeOp<T>
class	MultiOnSubscribeInvokeOp<T> Execute a given (async) callback on subscription.
class	MultiOnSubscribeInvokeUniOp<T> Execute a given callback on subscription.
class	MultiOnTerminationInvoke<T>
class	MultiOnTerminationInvokeUni<T>
class	MultiRepeatUntilOp<T>
class	MultiRepeatWhilstOp<T>
class	MultiRetryOp<T> Multi operator re-subscribing to the upstream if if receives a failure event.
class	MultiRetryWhenOp<T> Retries a source when a companion stream signals an item in response to the main's failure event.
class	MultiScanOp<T> Scan operator accumulating items of the same type as the upstream.
class	MultiScanWithSeedOp<T,R>
class	MultiSignalConsumerOp<T> Attach consumers to the various events and signals received by this Publisher.
class	MultiSkipLastOp<T> Skips the numberOfItems last items from upstream.
class	MultiSkipOp<T> Skips the first N items from upstream.
class	MultiSkipUntilOp<T> Skips the items from upstream until the passed predicates returns true.
class	MultiSkipUntilPublisherOp<T,U> Skips items emitted by the upstream until the other publisher emits either an item or completes.
class	MultiSubscribeOnOp<T> Subscribes to the upstream asynchronously using the given executor.
class	MultiSwitchOnEmptyOp<T> Switches to another Multi if the upstream is empty (completes without having emitted any items).
class	MultiTakeLastOp<T> Implementation of multi, caching and emitting the last n items from upstream (emitted before the upstream completion).
class	MultiTakeOp<T> Takes the n first items emitted by the upstream, cancelling the subscription after that.
class	MultiTakeUntilOtherOp<T,U> Emits items from upstream until another Publisher signals an event (items, failures or completion).
class	MultiTakeWhileOp<T> Emits the items from upstream while the given predicate returns true for the item.
class	MultiWindowOnDurationOp<T>
class	MultiWindowOp<T> Splits the source sequence by time of reception into potentially overlapping Multi.
class	MultiZipOp<O>

Fields in io.smallrye.mutiny.operators.multi declared as Multi

Modifier and Type	Field and Description
protected Multi<? extends T>	MultiRepeatUntilOp.RepeatProcessor.upstream
protected Multi<? extends I>	AbstractMultiOperator.upstream The upstream Multi.

Methods in io.smallrye.mutiny.operators.multi that return Multi

Modifier and Type	Method and Description
Multi<? extends I>	AbstractMultiOperator.upstream()

Method parameters in io.smallrye.mutiny.operators.multi with type arguments of type Multi

Modifier and Type	Method and Description
void	MultiWindowOp.subscribe(MultiSubscriber<? super Multi<T>> downstream)
void	MultiWindowOnDurationOp.subscribe(MultiSubscriber<? super Multi<T>> actual)

Constructors in io.smallrye.mutiny.operators.multi with parameters of type Multi

Constructor and Description
AbstractMultiOperator(Multi<? extends I> upstream) Creates a new AbstractMultiOperator with the passed Multi as upstream.
MultiBufferOp(Multi<? extends T> upstream, int size, int skip)
MultiBufferWithTimeoutOp(Multi<T> upstream, int size, Duration timeout, ScheduledExecutorService scheduler)
MultiCacheOp(Multi<T> upstream)
MultiCollectorOp(Multi<T> upstream, Collector<? super T,A,? extends R> collector, boolean acceptNullAsInitialValue)
MultiDistinctOp(Multi<? extends T> upstream)
MultiDistinctUntilChangedOp(Multi<? extends T> upstream)
MultiEmitOnOp(Multi<? extends T> upstream, Executor executor)
MultiFilterOp(Multi<? extends T> upstream, Predicate<? super T> predicate)
MultiFlatMapOp(Multi<? extends I> upstream, Function<? super I,? extends org.reactivestreams.Publisher<? extends O>> mapper, boolean postponeFailurePropagation, int maxConcurrency, Supplier<? extends Queue<O>> mainQueueSupplier, Supplier<? extends Queue<O>> innerQueueSupplier)
MultiGroupByOp(Multi<T> upstream, Function<? super T,? extends K> keySelector, Function<? super T,? extends V> valueSelector)
MultiIgnoreOp(Multi<T> upstream)
MultiLastItemOp(Multi<T> upstream)
MultiMapOp(Multi<T> upstream, Function<? super T,? extends U> mapper)
MultiOnFailureResumeOp(Multi<? extends T> upstream, Function<? super Throwable,? extends org.reactivestreams.Publisher<? extends T>> next)
MultiOnSubscribeInvokeOp(Multi<? extends T> upstream, Consumer<? super org.reactivestreams.Subscription> onSubscribe)
MultiOnSubscribeInvokeUniOp(Multi<? extends T> upstream, Function<? super org.reactivestreams.Subscription,Uni<?>> onSubscribe)
MultiOnTerminationInvoke(Multi<? extends T> upstream, BiConsumer<Throwable,Boolean> callback)
MultiOnTerminationInvokeUni(Multi<? extends T> upstream, BiFunction<Throwable,Boolean,Uni<?>> mapper)
MultiRepeatUntilOp(Multi<T> upstream, long times)
MultiRepeatUntilOp(Multi<T> upstream, Predicate<T> predicate)
MultiRepeatWhilstOp(Multi<T> upstream, Predicate<T> predicate)
MultiRetryOp(Multi<? extends T> upstream, long times)
MultiRetryWhenOp(Multi<? extends T> upstream, Function<? super Multi<Throwable>,? extends org.reactivestreams.Publisher<?>> triggerStreamFactory)
MultiScanOp(Multi<? extends T> upstream, BiFunction<T,? super T,T> accumulator)
MultiScanWithSeedOp(Multi<? extends T> upstream, Supplier<R> seed, BiFunction<R,? super T,R> accumulator)
MultiSignalConsumerOp(Multi<? extends T> upstream, Consumer<? super T> onItem, Consumer<? super Throwable> onFailure, Runnable onCompletion, LongConsumer onRequest, Runnable onCancellation)
MultiSkipLastOp(Multi<? extends T> upstream, int numberOfItems)
MultiSkipOp(Multi<? extends T> upstream, long numberOfItems)
MultiSkipUntilOp(Multi<? extends T> upstream, Predicate<? super T> predicate)
MultiSkipUntilPublisherOp(Multi<? extends T> upstream, org.reactivestreams.Publisher<U> other)
MultiSubscribeOnOp(Multi<? extends T> upstream, Executor executor)
MultiSwitchOnEmptyOp(Multi<? extends T> upstream, org.reactivestreams.Publisher<? extends T> alternative)
MultiTakeLastOp(Multi<? extends T> upstream, int numberOfItems)
MultiTakeOp(Multi<? extends T> upstream, long numberOfItems)
MultiTakeUntilOtherOp(Multi<? extends T> upstream, org.reactivestreams.Publisher<U> other)
MultiTakeWhileOp(Multi<? extends T> upstream, Predicate<? super T> predicate)
MultiWindowOnDurationOp(Multi<T> upstream, Duration duration, ScheduledExecutorService executor)
MultiWindowOp(Multi<? extends T> upstream, int size, int skip)
RepeatProcessor(Multi<? extends T> upstream, MultiSubscriber<? super T> downstream, long times, Predicate<T> predicate)

Constructor parameters in io.smallrye.mutiny.operators.multi with type arguments of type Multi

Constructor and Description
MultiRetryWhenOp(Multi<? extends T> upstream, Function<? super Multi<Throwable>,? extends org.reactivestreams.Publisher<?>> triggerStreamFactory)

Uses of Multi in io.smallrye.mutiny.operators.multi.builders

Classes in io.smallrye.mutiny.operators.multi.builders that implement Multi

Modifier and Type	Class and Description
class	CollectionBasedMulti<T>
class	DeferredMulti<T>
class	EmitterBasedMulti<T>
class	EmptyMulti Implements a Publisher which only calls onComplete immediately after subscription.
class	FailedMulti<T> Multi emitting a failures (constant or produced by a supplier) to subscribers.
class	IntervalMulti
class	IterableBasedMulti<T>
class	NeverMulti Represents a publisher that does not emits any signals (items, failures or completion).
class	ResourceMulti<R,I>
class	StreamBasedMulti<T>

Methods in io.smallrye.mutiny.operators.multi.builders that return Multi

Modifier and Type	Method and Description
static <T> Multi<T>	EmptyMulti.empty()
static <T> Multi<T>	NeverMulti.never() Returns a parameterized never of this never Publisher.

Uses of Multi in io.smallrye.mutiny.operators.multi.multicast

Classes in io.smallrye.mutiny.operators.multi.multicast that implement Multi

Modifier and Type	Class and Description
class	ConnectableMulti<T> A ConnectableMulti is similar to a regular Multi, except that it does not begin emitting items (from upstream to downstream) when it is subscribed to, but only when its ConnectableMulti.connect(io.smallrye.mutiny.operators.multi.multicast.ConnectableMultiConnection) method is called.
class	MultiConnectAfter<T> A Multi subscribing upstream when a number of subscribers is reached.
class	MultiPublishOp<T> A connectable observable which shares an underlying source and dispatches source values to subscribers in a back-pressure-aware manner.
class	MultiReferenceCount<T> A Multi stays connected to the source as long as there is at least one subscription.

Fields in io.smallrye.mutiny.operators.multi.multicast declared as Multi

Modifier and Type	Field and Description
protected Multi<T>	ConnectableMulti.upstream

Methods in io.smallrye.mutiny.operators.multi.multicast that return Multi

Modifier and Type	Method and Description
Multi<T>	ConnectableMulti.connectAfter(int numberOfSubscribers) Returns a Multi that connect to the upstream as soon as the numberOfSubscribers subscribers subscribe.
Multi<T>	ConnectableMulti.referenceCount() Returns a Multi that stays connected to this ConnectableMulti as long as there is at least one active subscription.
Multi<T>	ConnectableMulti.referenceCount(int count, Duration duration) Connects to the upstream ConnectableMulti if the number of subscribers reaches the specified amount and disconnect after the specified duration after all subscribers have unsubscribed (cancelled their subscriptions).

Methods in io.smallrye.mutiny.operators.multi.multicast with parameters of type Multi

Modifier and Type	Method and Description
static <T> ConnectableMulti<T>	MultiPublishOp.create(Multi<T> upstream)

Constructors in io.smallrye.mutiny.operators.multi.multicast with parameters of type Multi

Constructor and Description
ConnectableMulti(Multi<T> upstream)

Uses of Multi in io.smallrye.mutiny.operators.multi.overflow

Classes in io.smallrye.mutiny.operators.multi.overflow that implement Multi

Modifier and Type	Class and Description
class	MultiOnOverflowBufferOp<T>
class	MultiOnOverflowDropItemsOp<T>
class	MultiOnOverflowKeepLastOp<T>

Constructors in io.smallrye.mutiny.operators.multi.overflow with parameters of type Multi

Constructor and Description
MultiOnOverflowBufferOp(Multi<T> upstream, int bufferSize, boolean unbounded, boolean postponeFailurePropagation, Consumer<T> onOverflow)
MultiOnOverflowDropItemsOp(Multi<T> upstream)
MultiOnOverflowDropItemsOp(Multi<T> upstream, Consumer<? super T> onItemDrop)
MultiOnOverflowKeepLastOp(Multi<T> upstream)

Uses of Multi in io.smallrye.mutiny.operators.multi.processors

Classes in io.smallrye.mutiny.operators.multi.processors that implement Multi

Modifier and Type	Class and Description
class	BroadcastProcessor<T> Implementation of Processor that broadcast all subsequently observed items to its current Subscribers.
class	UnicastProcessor<T> Implementation of a processor using a queue to store items and allows a single subscriber to receive these items.