Package | Description |
---|---|
reactor.groovy.config | |
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.terminal | |
reactor.rx.action.transformation | |
reactor.rx.broadcast |
Broadcasters are akin to Reactive Extensions Subject.
|
reactor.rx.stream |
Modifier and Type | Method and Description |
---|---|
void |
ReactorBuilder.stream(groovy.lang.Closure<Action<Event<?>,Event<?>>> closure) |
void |
ReactorBuilder.stream(Selector selector,
groovy.lang.Closure<Action<Event<?>,Event<?>>> closure) |
void |
ReactorBuilder.stream(String selector,
groovy.lang.Closure<Action<Event<?>,Event<?>>> closure) |
Modifier and Type | Method and Description |
---|---|
Action<?,?> |
Promise.findOldestStream() |
static <T> Action<org.reactivestreams.Publisher<? extends T>,T> |
Streams.switchOnNext()
Build a Synchronous Action whose data are emitted by the most recent
onNext(Object)
signaled publisher. |
static <T> Action<org.reactivestreams.Publisher<? extends T>,T> |
Streams.switchOnNext(Dispatcher dispatcher)
Build an Action whose data are emitted by the most recent
onNext(Object) signaled
publisher. |
Modifier and Type | Method and Description |
---|---|
<V> Stream<V> |
Stream.lift(Supplier<? extends Action<O,V>> action)
Defer the subscription of an
Action to the actual pipeline. |
Modifier and Type | Class and Description |
---|---|
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 | Method and Description |
---|---|
Action<I,O> |
Action.capacity(long elements)
--------------------------------------------------------------------------------------------------------
ACTION MODIFIERS
--------------------------------------------------------------------------------------------------------
|
Action<E,O> |
CompositeAction.capacity(long elements) |
<E> Action<I,O> |
Action.control(Stream<E> controlStream,
Consumer<Tuple2<Action<I,O>,? super E>> controller)
Consume a Stream to allow for dynamic
Action update. |
Action<E,?> |
CompositeAction.input() |
Modifier and Type | Method and Description |
---|---|
<E> Action<I,O> |
Action.control(Stream<E> controlStream,
Consumer<Tuple2<Action<I,O>,? super E>> controller)
Consume a Stream to allow for dynamic
Action update. |
Constructor and Description |
---|
CompositeAction(Action<E,?> head,
Action<?,O> tail) |
CompositeAction(Action<E,?> head,
Action<?,O> tail) |
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> |
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.
|
class |
MergeAction<O> |
class |
SwitchAction<T> |
class |
ZipAction<O,V,TUPLE extends Tuple> |
Modifier and Type | Method and Description |
---|---|
Action<org.reactivestreams.Publisher<? extends I>,O> |
DynamicMergeAction.capacity(long elements) |
Action<?,?> |
FanInAction.dynamicMergeAction() |
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 |
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 | Method and Description |
---|---|
Action<O,V> |
LiftStream.onLift() |
Constructor and Description |
---|
LiftStream(Stream<O> thiz,
Supplier<? extends Action<O,V>> action) |
Copyright © 2016. All rights reserved.