Package | Description |
---|---|
reactor.core.processor |
This package offers a suite of asynchronous
Processor with backpressure support. |
reactor.core.reactivestreams | |
reactor.io.net |
Reactive network components are located in this package scope implementing the following exposed contract:
A
ReactorPeer NetServer/NetClient is a Publisher of
ReactorChannel that are themselves Publisher of input data. |
reactor.io.net.http |
Components for writing HTTP-based clients and servers using Reactor abstractions.
|
reactor.io.net.impl.netty |
Implementations of the various TCP abstractions based on Netty.
|
reactor.io.net.impl.netty.http | |
reactor.io.net.impl.zmq | |
reactor.rx |
Streams are reactive components derived from Reactive Extensions and implementing Reactive Streams specification.
|
reactor.rx.action |
Actions are Reactive Streams components derived from Reactive Extensions and beyond.
|
reactor.rx.action.aggregation | |
reactor.rx.action.combination | |
reactor.rx.action.conditional | |
reactor.rx.action.control | |
reactor.rx.action.error | |
reactor.rx.action.filter | |
reactor.rx.action.metrics | |
reactor.rx.action.pair | |
reactor.rx.action.passive | |
reactor.rx.action.support | |
reactor.rx.action.terminal | |
reactor.rx.action.transformation | |
reactor.rx.broadcast |
Broadcasters are akin to Reactive Extensions Subject.
|
reactor.rx.stream | |
reactor.rx.stream.io |
Stream implementations that provide for IO access, for instance read/read-write persisting streams |
Modifier and Type | Class and Description |
---|---|
class |
ExecutorPoweredProcessor<IN,OUT>
A base processor used by executor backed processors to take care of their ExecutorService
|
class |
ReactorProcessor<IN,OUT>
A base processor
|
class |
RingBufferProcessor<E>
An implementation of a RingBuffer backed message-passing Processor.
|
class |
RingBufferWorkProcessor<E>
An implementation of a RingBuffer backed message-passing WorkProcessor.
|
Modifier and Type | Class and Description |
---|---|
class |
SerializedSubscriber<T>
Enforces single-threaded, serialized, ordered execution of
SerializedSubscriber.onNext(T) , SerializedSubscriber.onComplete() ,
SerializedSubscriber.onError(java.lang.Throwable) , SerializedSubscriber.request(long) and SerializedSubscriber.cancel() . |
class |
SubscriberBarrier<I,O>
A
Subscriber with an asymetric typed wrapped subscriber. |
Modifier and Type | Class and Description |
---|---|
class |
ChannelStream<IN,OUT>
An abstract
ReactorChannel implementation that handles the basic interaction and behave as a Stream . |
Modifier and Type | Class and Description |
---|---|
class |
HttpChannel<IN,OUT>
A Request/Response
ChannelStream extension that provides for several helpers to control HTTP behavior and
observe its metadata. |
Modifier and Type | Class and Description |
---|---|
class |
NettyChannelStream<IN,OUT>
ReactorChannel implementation that delegates to Netty. |
Modifier and Type | Class and Description |
---|---|
class |
NettyHttpChannel<IN,OUT> |
Modifier and Type | Class and Description |
---|---|
class |
ZeroMQChannelStream<IN,OUT> |
Modifier and Type | Class and Description |
---|---|
class |
Promise<O>
A
Promise is a stateful event container that accepts a single value or error. |
class |
Stream<O>
Base class for components designed to provide a succinct API for working with future values.
|
Modifier and Type | Class and Description |
---|---|
class |
Action<I,O>
An Action is a reactive component to subscribe to a
Publisher and in particular
to a Stream . |
class |
CompositeAction<E,O>
Create a Processor where a given head/tail couple is provided as a Stream (Input upstream) and Action (Output
downstream).
|
Modifier and Type | Class and Description |
---|---|
class |
BatchAction<T,V> |
class |
BufferAction<T> |
class |
BufferShiftAction<T> |
class |
BufferShiftWhenAction<T> |
class |
BufferWhenAction<T> |
class |
CacheAction<T> |
class |
LastAction<T> |
class |
SampleAction<T> |
class |
SortAction<T> |
class |
WindowAction<T>
WindowAction is forwarding events on a steam until is reached,
after that streams collected events further, complete it and create a fresh new stream.
|
class |
WindowShiftAction<T>
WindowAction is forwarding events on a steam until is reached,
after that streams collected events further, complete it and create a fresh new stream.
|
class |
WindowShiftWhenAction<T>
WindowAction is forwarding events on a steam until is reached,
after that streams collected events further, complete it and create a fresh new stream.
|
class |
WindowWhenAction<T>
WindowAction is forwarding events on a steam until returned stream emits a signal,
after that streams collected events further, complete it and create a fresh new stream.
|
Modifier and Type | Class and Description |
---|---|
class |
CombineLatestAction<O,V,TUPLE extends Tuple> |
static class |
CombineLatestAction.InnerSubscriber<O,V> |
class |
ConcatAction<T> |
class |
DynamicMergeAction<I,O> |
class |
FanInAction<I,E,O,SUBSCRIBER extends FanInAction.InnerSubscriber<I,E,O>>
The best moment of my life so far, not.
|
static class |
FanInAction.InnerSubscriber<I,E,O> |
class |
MergeAction<O> |
static class |
MergeAction.InnerSubscriber<I> |
class |
SwitchAction<T> |
class |
SwitchAction.SwitchSubscriber |
class |
ZipAction<O,V,TUPLE extends Tuple> |
static class |
ZipAction.InnerSubscriber<O,V> |
Modifier and Type | Class and Description |
---|---|
class |
ExistsAction<T> |
Modifier and Type | Class and Description |
---|---|
class |
DispatcherAction<T> |
class |
FlowControlAction<O> |
class |
RepeatAction<T> |
class |
RepeatWhenAction<T> |
class |
ThrottleRequestAction<T> |
class |
ThrottleRequestWhenAction<T> |
Modifier and Type | Class and Description |
---|---|
class |
ErrorAction<T,E extends Throwable> |
class |
ErrorReturnAction<T,E extends Throwable> |
class |
ErrorWithValueAction<T,E extends Throwable> |
class |
FallbackAction<T> |
class |
IgnoreErrorAction<T> |
class |
RetryAction<T> |
class |
RetryWhenAction<T> |
class |
TimeoutAction<T> |
Modifier and Type | Class and Description |
---|---|
class |
DistinctAction<T,V> |
class |
DistinctUntilChangedAction<T,V> |
class |
ElementAtAction<T> |
class |
FilterAction<T> |
class |
SkipAction<T> |
class |
SkipUntilTimeout<T> |
class |
TakeAction<T> |
class |
TakeUntilTimeout<T> |
class |
TakeWhileAction<T> |
Modifier and Type | Class and Description |
---|---|
class |
CountAction<T> |
class |
ElapsedAction<T> |
class |
TimestampAction<T> |
Modifier and Type | Class and Description |
---|---|
class |
ReduceByKeyAction<K,V> |
class |
ScanByKeyAction<K,V> |
Modifier and Type | Class and Description |
---|---|
class |
AfterAction<T> |
class |
CallbackAction<T> |
class |
FinallyAction<T> |
class |
LoggerAction<T> |
class |
StreamStateCallbackAction<T> |
Modifier and Type | Class and Description |
---|---|
class |
DefaultSubscriber<O> |
Modifier and Type | Class and Description |
---|---|
class |
AdaptiveConsumerAction<T> |
class |
ConsumerAction<T> |
Modifier and Type | Class and Description |
---|---|
class |
DefaultIfEmptyAction<T> |
class |
DematerializeAction<T> |
class |
GroupByAction<T,K>
Manage a dynamic registry of substreams for a given key extracted from the incoming data.
|
class |
MapAction<T,V> |
class |
MaterializeAction<T> |
class |
ScanAction<T,A> |
class |
SplitAction<T> |
Modifier and Type | Class and Description |
---|---|
class |
BehaviorBroadcaster<O>
A
Broadcaster is a subclass of Stream which exposes methods for publishing values into the pipeline. |
class |
Broadcaster<O>
A
Broadcaster is a subclass of Stream which exposes methods for publishing values into the pipeline. |
class |
SerializedBroadcaster<O>
A
Broadcaster is a subclass of Stream which exposes methods for publishing values into the pipeline. |
Modifier and Type | Class and Description |
---|---|
class |
BarrierStream
|
class |
DeferredStream<T>
A
Publisher supplier that will call the passed supplier on each subscribe call. |
class |
ErrorStream<O,T extends Throwable>
A Stream that emits a sigle error signal.
|
class |
FutureStream<T>
A Stream that emits a result of a
Future and then complete. |
class |
GroupedStream<K,T>
The Stream will complete or fail whever the parent groupBy action terminates itself.
|
class |
LiftStream<O,V>
A Stream wrapper that defers a parent stream subscription to the child action subscribe() call.
|
class |
MapStream<K,V>
A SubscribableMap is an event-driven Map that signals logged operations to its subscribers.
|
class |
PeriodicTimerStream
A Stream that emits
0 after an initial delay and ever incrementing long counter if the period argument is
specified. |
class |
PublisherStream<T>
A
Publisher wrapper that takes care of lazy subscribing. |
class |
SingleTimerStream
A Stream that emits
0 after an initial delay and then complete
The SingleTimerStream will manage dedicated timers for new subscriber assigned via
this#subscribe(org.reactivestreams.Subscriber) . |
class |
SingleValueStream<T>
A Stream that emits only one value and then complete.
|
class |
SupplierStream<T>
A Stream that returns the result from
Supplier.get() everytime it is requested via
Subscription.request(long) . |
Modifier and Type | Class and Description |
---|---|
class |
ChronicleReaderStream<K,V>
Implementation of a
Dispatcher that uses a IndexedChronicle to
queue tasks to execute. |
class |
ChronicleStream<K,V> |
Copyright © 2016. All rights reserved.