All Classes and Interfaces
Class
Description
A convenient base class for a subscriber and subscription to extend in tests and that manages the subscription and
requests.
A
Multi Flow.Subscriber for testing purposes that comes with useful assertion helpers.The back pressure strategies.
Implementation of
Flow.Processor that broadcast all subsequently observed items to its current
Flow.Subscribers.Intercept user callbacks.
An implementation of
Exception collecting several causes.A context allows sharing key / value entries along with a subscriber in a Mutiny pipeline, so all operators can
share implicit data for a given subscription.
Interface for subscribers and types that provide a
Context.Interface for
Multi demand pacers and the Multi.paceDemand() operator.A demand request.
A handle to control a pausable stream without holding a direct reference to the stream itself.
SPI allowing customizing the default executor.
A demand pacer with a fixed delay / fixed demand.
A consumer taking 3 parameters.
A Gatherer operator transforms a stream of items by accumulating them into an accumulator and extracting
items from that accumulator when certain conditions are met.
Builder for creating a
Gatherer.An extraction result containing the next accumulator and the next item to emit.
The second step in the builder to gather items emitted by a
Multi into an accumulator.The third step in the builder to gather items emitted by a
Multi into an accumulator.The first step in the builder to gather items emitted by a
Multi into an accumulator.Factory interface for creating
Gatherer instances.Default implementation of the
Gatherer interface.Interface for
Multi generators, where items are being generated on subscription requests.A specialization of
Multi used by the group operation.An operator logger for
Multi.log(String) and Uni.log(String).Models an item flowing along a Mutiny pipeline with its subscriber context attached.
Makes the upstream
Multi be able to broadcast its events (items, failure, and
completion) to multiple subscribers.Collects / aggregates items from the upstream and send the resulting collection / structure when the
upstream completes.
Converts the upstream into another reactive type.
Group methods allowing to create
Multi instances from various sources.Allows the creation of instances of
Multi by merging/combining/concatenating multiple upstreams.Configures a pausable
Multi stream.An object allowing to send signals to the downstream
Multi.The object to tune the flatMap operation
Configures the failure handler.
A builder to gather items emitted by a
Multi into an accumulator.The second step in the builder to gather items emitted by a
Multi into an accumulator.The last step in the builder to gather items emitted by a
Multi into an accumulator.The first step in the builder to gather items emitted by a
Multi into an accumulator.Group to configure the action to execute when the observed
Multi sends a Flow.Subscription.Group to configure replaying a
Multi to multiple subscribers.Allows configuring a finalizer to close the resource attached to the stream.
Allows configuring a finalizer to close the resource attached to the stream.
Selects items from the upstream
Multi.Skips items from the upstream
Multi.A
Flow.Subscriber receiving calls to Flow.Subscriber.onSubscribe(Subscription) once after passing an instance of
Flow.Subscriber to Flow.Publisher.subscribe(Subscriber).Thin adapter of a
Flow.Subscriber to a Mutiny MultiSubscriber.Implementation of
ScheduledThreadPoolExecutor delegating the execution of the task to a configured
Executor.A cancellation signal.
A onFailure signal.
A onItem signal.
A onSubscribe signal.
Interface for controlling a pausable Multi stream.
Wraps another Subscriber and ensures all onXXX methods conform the protocol
(except the requirement for serialized access).
Wraps a processor into a serialized version of this processor.
Subscriber that makes sure signals are delivered sequentially in case the onNext, onError or onComplete methods are
called concurrently.
An implementation of
Flow.Subscription that allows switching the upstream, dealing with the requests accordingly.Exception thrown when an operation times out.
A tuple containing two items.
A set of methods to create
Tuple instances from lists.Provides wrapper to handle functions / consumers / suppliers that throw checked exceptions.
Represents an operation that accepts two input arguments and returns no
result.
Represents a function that accepts two arguments and produces a result.
Represents an operation that accepts a single input argument and returns no
result.
Represents a function that accepts one argument and produces a result.
Represents a supplier of items.
A
Uni represents a lazy asynchronous action.Configures the combination of 2
unis.A
Uni UniSubscriber for testing purposes that comes with useful assertion helpers.Waits and returns the item emitted by the
Uni.Implementation of a processor using a queue to store items and allows a single subscriber to receive
these items.
Group methods allowing to create
Uni instances from various sources.An object allowing to send signals to the downstream
Uni.Join multiple
Unis.Defines how to deal with failures while joining
Uni references with UniJoin.all(List).Terminal interface for
UniJoin.all(List)Defines how to deal with failures while joining
Uni references with UniJoin.first(List)}.Terminal interface for
UniJoin.first(List)Configures the failure handler.
Configures the delay applied to the item emission.
Group to configure the action to execute when the observed
Uni sends a UniSubscription.An implementation of
UniSubscriber and UniSubscription making sure event handlers are only called once.A signal: onSubscribe, onItem, onFailure or cancel.
Allow subscribing to a
Uni to be notified of the different events coming from upstream.Will receive call to
UniSubscriber.onSubscribe(UniSubscription) once after passing an instance of this UniSubscriber
to UniSubscribe.withSubscriber(UniSubscriber) retrieved from Uni.subscribe().A
Flow.Subscription for the Uni type.