io.servicetalk.concurrent.api (servicetalk-concurrent-api 0.41.11 API)

Interface Summary
Interface	Description
AsyncCloseable	Used to close/shutdown a resource.
AsyncCloseables.CloseableResource	A resource that can be converted to an `AsyncCloseable`.
AsyncContextMap	The key-value map stored in the `AsyncContext`.
AsyncContextMapHolder	Interface for setting and getting a `AsyncContextMap`.
BiIntFunction<T,R>	A special function that takes an `int` and a custom argument and returns the result.
BiIntPredicate<T>	A special predicate that takes an `int` and a custom argument to evaluate.
BlockingProcessorSignalsHolder<T>	A holder of items for a `BlockingIterable.Processor`.
BufferStrategy<T,BC extends BufferStrategy.Accumulator<T,B>,B>	A strategy for `buffering` items emitted from a `Publisher`.
BufferStrategy.Accumulator<T,B>	An intermediate mutable object that holds items till it is `finished`.
CompletableOperator	An operator contract for a `Completable`.
CompositeCloseable	A `AsyncCloseable` and `Closeable` that allows for adding new `AsyncCloseable`s till it is closed.
Executor	A general abstraction to execute immediate and delayed tasks.
Function3<T1,T2,T3,R>	A functional interface that accepts 3 arguments and generates a return value.
Function4<T1,T2,T3,T4,R>	A functional interface that accepts 4 arguments and generates a return value.
GroupedPublisher.QueueSizeProvider	Provide the maximum queue size to use for a particular `GroupedPublisher` key.
ListenableAsyncCloseable	Provides a way to subscribe when `AsyncCloseable.closeAsync()` is completed.
ProcessorSignalsConsumer<T>	Consumer of items from a `PublisherProcessorSignalsHolder` or `BlockingProcessorSignalsHolder`.
PublisherOperator<T,R>	An operator contract for a `Publisher`.
PublisherProcessorSignalsHolder<T>	A holder of items for a `PublisherSource.Processor`.
PublisherToSingleOperator<T,R>	An operator contract for a `Publisher` to `Single` conversion.
ScanWithLifetimeMapper<T,R>	Provides the ability to transform (aka map) signals emitted via the `Publisher.scanWithLifetime(Supplier)` operator, as well as the ability to cleanup state via `ScanWithLifetimeMapper.afterFinally()`.
ScanWithMapper<T,R>	Provides the ability to transform (aka map) signals emitted via the `Publisher.scanWith(Supplier)` operator.
SingleOperator<T,R>	An operator contract for a `Single`.
SingleTerminalSignalConsumer<T>	A contract that provides discrete callbacks for various ways in which a `SingleSource.Subscriber` can terminate.
TerminalSignalConsumer	A contract that provides discrete callbacks for various ways in which a `PublisherSource.Subscriber` or a `CompletableSource.Subscriber` can terminate.

Class Summary
Class	Description
AsyncCloseables	A utility class to create `AsyncCloseable`s.
AsyncContext	Presents a static interface to retain state in an asynchronous environment.
AsyncContextMap.Key<T>	A key identifies a specific object in a `AsyncContextMap`.
AutoCloseables	A utility class for methods related to `AutoCloseable`.
BufferStrategies	A static factory of `BufferStrategy` instances.
Completable	An asynchronous computation that does not emit any data.
DefaultThreadFactory	A `ThreadFactory` implementation.
DelegatingExecutor	An `Executor` that simply delegates all calls to another `Executor`.
Executors	Utility methods to create various `Executor`s.
GroupedPublisher<Key,T>	A group as emitted by `Publisher.groupBy(Function, int)` or its variants.
Processors	Static factory methods for creating processor instances for different type of sources.
Publisher<T>	An asynchronous computation that produces 0, 1 or more elements and may or may not terminate successfully or with an error.
RepeatStrategies	A set of strategies to use for repeating with `Publisher.repeatWhen(IntFunction)`, `Single.repeatWhen(IntFunction)` and `Completable.repeatWhen(IntFunction)` or in general.
RetryStrategies	A set of strategies to use for retrying with `Publisher.retryWhen(BiIntFunction)`, `Single.retryWhen(BiIntFunction)`, and `Completable.retryWhen(BiIntFunction)` or in general.
RunnableCompletable	Deprecated Use `Completable.fromRunnable(Runnable)`.
Single<T>	An asynchronous computation that either completes with success giving the result or completes with an error.
SourceAdapters	A set of adapter methods to convert an asynchronous source in this module to a corresponding source in `io.servicetalk.concurrent` module.

Exception Summary
Exception Description

RepeatStrategies.TerminateRepeatException
An Exception instance used to indicate termination of repeats.

Exception Summary
Exception	Description
RepeatStrategies.TerminateRepeatException	An `Exception` instance used to indicate termination of repeats.

Package io.servicetalk.concurrent.api Description

ServiceTalk concurrent APIs which follow Reactive Streams semantics.