Package | Description |
---|---|
reactor | |
reactor.bus |
Hold the required abstraction to enable Event Driven Programming with Reactor.
|
reactor.bus.registry |
Registries provide a common way to retrieve items registered using a
Selector . |
reactor.bus.routing | |
reactor.bus.spec |
Specs help create
Reactors by providing a fluent API to specify
common options. |
reactor.bus.support | |
reactor.bus.timer | |
reactor.core |
Core components of the Reactor framework.
|
reactor.core.dispatch |
Dispatchers provide a way for work to be done in another thread,
but unlike a standard thread pool, do so with extreme efficiency. |
reactor.core.processor |
This package offers a suite of asynchronous
Processor with backpressure support. |
reactor.core.reactivestreams | |
reactor.fn |
This package contains the foundational abstractions on which Reactor's functional and reactive components are
built.
|
reactor.fn.support | |
reactor.fn.timer | |
reactor.groovy.config | |
reactor.groovy.ext | |
reactor.groovy.support | |
reactor.io.codec |
Components to handle encoding and decoding of objects into
Buffers . |
reactor.io.codec.compress | |
reactor.io.codec.json |
Encoding and decoding using the JSON format.
|
reactor.io.codec.kryo | |
reactor.io.codec.protobuf | |
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.codec.syslog |
Decoding using the syslog format.
|
reactor.io.net.impl.netty |
Implementations of the various TCP abstractions based on Netty.
|
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.terminal | |
reactor.rx.action.transformation | |
reactor.rx.broadcast |
Broadcasters are akin to Reactive Extensions Subject.
|
reactor.rx.stream | |
reactor.rx.subscription | |
reactor.rx.subscription.support |
Modifier and Type | Method and Description |
---|---|
Environment |
Environment.assignErrorJournal(Consumer<? super Throwable> errorJournal)
Assign the error
Consumer to listen for any call to this#routeError(Throwable) . |
static DispatcherSupplier |
Environment.createDispatcherFactory(String name,
int poolsize,
int bufferSize,
Consumer<Throwable> errorHandler,
com.lmax.disruptor.dsl.ProducerType producerType,
com.lmax.disruptor.WaitStrategy waitStrategy)
Create a RingBuffer pool that will clone up to generated dispatcher and return a different one
on a round robin fashion each time
Supplier.get() is called. |
static Environment |
Environment.initialize(Consumer<Throwable> errorConsumer)
Create and assign a context environment bound to the current classloader.
|
Modifier and Type | Class and Description |
---|---|
class |
EventBus
|
class |
EventBus.ReplyToConsumer<E extends Event<?>,V> |
Modifier and Type | Method and Description |
---|---|
Consumer<Throwable> |
EventBus.getDispatchErrorHandler() |
Consumer<Throwable> |
Event.getErrorConsumer()
Get the internal error consumer callback being wrapped.
|
Consumer<Throwable> |
EventBus.getUncaughtErrorHandler() |
<T> Consumer<Event<T>> |
EventBus.prepare(Object key)
Create an optimized path for publishing notifications to the given key.
|
Modifier and Type | Method and Description |
---|---|
Registry<Object,Consumer<? extends Event<?>>> |
EventBus.getConsumerRegistry()
|
<T extends Event<?>> |
EventBus.on(Selector selector,
Consumer<T> consumer) |
<V extends T> |
Bus.on(Selector selector,
Consumer<V> consumer)
|
<T extends Event<?>,V> |
EventBus.receive(Selector sel,
Function<T,V> fn)
|
Modifier and Type | Method and Description |
---|---|
<T extends Event<?>> |
EventBus.on(Selector selector,
Consumer<T> consumer) |
<V extends T> |
Bus.on(Selector selector,
Consumer<V> consumer)
|
<T> void |
EventBus.schedule(Consumer<T> consumer,
T data)
Schedule an arbitrary
Consumer to be executed on the current Reactor Dispatcher , passing the given . |
<T extends Event<?>> |
EventBus.sendAndReceive(Object key,
Event<?> event,
Consumer<T> reply)
|
<T extends Event<?>> |
EventBus.sendAndReceive(Object key,
Supplier<? extends Event<?>> supplier,
Consumer<T> reply)
|
Constructor and Description |
---|
Event(Event.Headers headers,
T data,
Consumer<Throwable> errorConsumer)
|
EventBus(Dispatcher dispatcher,
Router router,
Consumer<Throwable> dispatchErrorHandler,
Consumer<Throwable> uncaughtErrorHandler) |
EventBus(Dispatcher dispatcher,
Router router,
Consumer<Throwable> dispatchErrorHandler,
Consumer<Throwable> uncaughtErrorHandler) |
EventBus(Registry<Object,Consumer<? extends Event<?>>> consumerRegistry,
Dispatcher dispatcher,
Router router,
Consumer<Throwable> dispatchErrorHandler,
Consumer<Throwable> uncaughtErrorHandler)
Create a new Reactor that uses the given
dispatacher and eventRouter . |
EventBus(Registry<Object,Consumer<? extends Event<?>>> consumerRegistry,
Dispatcher dispatcher,
Router router,
Consumer<Throwable> dispatchErrorHandler,
Consumer<Throwable> uncaughtErrorHandler)
Create a new Reactor that uses the given
dispatacher and eventRouter . |
Constructor and Description |
---|
EventBus(Registry<Object,Consumer<? extends Event<?>>> consumerRegistry,
Dispatcher dispatcher,
Router router,
Consumer<Throwable> dispatchErrorHandler,
Consumer<Throwable> uncaughtErrorHandler)
Create a new Reactor that uses the given
dispatacher and eventRouter . |
Modifier and Type | Method and Description |
---|---|
static <K,V> Registry<K,V> |
Registries.create(boolean useCache,
boolean cacheNotFound,
Consumer<K> onNotFound) |
Modifier and Type | Method and Description |
---|---|
<E extends Event<?>> |
ConsumerFilteringRouter.route(Object key,
E event,
List<Registration<Object,? extends Consumer<? extends Event<?>>>> consumers,
Consumer<E> completionConsumer,
Consumer<Throwable> errorConsumer) |
<E extends Event<?>> |
ConsumerFilteringRouter.route(Object key,
E event,
List<Registration<Object,? extends Consumer<? extends Event<?>>>> consumers,
Consumer<E> completionConsumer,
Consumer<Throwable> errorConsumer) |
<E extends Event<?>> |
Router.route(Object key,
E data,
List<Registration<Object,? extends Consumer<? extends Event<?>>>> consumers,
Consumer<E> completionConsumer,
Consumer<Throwable> errorConsumer)
Routes the
event , triggered by a notification with the given key to the
consumers . |
<E extends Event<?>> |
Router.route(Object key,
E data,
List<Registration<Object,? extends Consumer<? extends Event<?>>>> consumers,
Consumer<E> completionConsumer,
Consumer<Throwable> errorConsumer)
Routes the
event , triggered by a notification with the given key to the
consumers . |
<E extends Event<?>> |
TraceableDelegatingRouter.route(Object key,
E event,
List<Registration<Object,? extends Consumer<? extends Event<?>>>> consumers,
Consumer<E> completionConsumer,
Consumer<Throwable> errorConsumer) |
<E extends Event<?>> |
TraceableDelegatingRouter.route(Object key,
E event,
List<Registration<Object,? extends Consumer<? extends Event<?>>>> consumers,
Consumer<E> completionConsumer,
Consumer<Throwable> errorConsumer) |
Modifier and Type | Method and Description |
---|---|
<E extends Event<?>> |
ConsumerFilteringRouter.route(Object key,
E event,
List<Registration<Object,? extends Consumer<? extends Event<?>>>> consumers,
Consumer<E> completionConsumer,
Consumer<Throwable> errorConsumer) |
<E extends Event<?>> |
Router.route(Object key,
E data,
List<Registration<Object,? extends Consumer<? extends Event<?>>>> consumers,
Consumer<E> completionConsumer,
Consumer<Throwable> errorConsumer)
Routes the
event , triggered by a notification with the given key to the
consumers . |
<E extends Event<?>> |
TraceableDelegatingRouter.route(Object key,
E event,
List<Registration<Object,? extends Consumer<? extends Event<?>>>> consumers,
Consumer<E> completionConsumer,
Consumer<Throwable> errorConsumer) |
Modifier and Type | Method and Description |
---|---|
SPEC |
EventRoutingComponentSpec.consumerNotFoundHandler(Consumer<Object> consumerNotFoundHandler)
Configures the callback to invoke if a notification key is sent into this component and there are no consumers
registered to respond to it.
|
SPEC |
EventRoutingComponentSpec.dispatchErrorHandler(Consumer<Throwable> dispatchErrorHandler)
Configures the component's error handler for any errors occurring during dispatch (e.g.
|
SPEC |
EventRoutingComponentSpec.uncaughtErrorHandler(Consumer<Throwable> uncaughtErrorHandler)
Configures the component's uncaught error handler for any errors that get reported into this component but aren't a
direct result of dispatching (e.g. errors that originate from another component).
|
Modifier and Type | Method and Description |
---|---|
SPEC |
EventRoutingComponentSpec.consumerRegistry(Registry<Object,Consumer<? extends Event<?>>> consumerRegistry)
Configures the
Registry to use when creating this component. |
Modifier and Type | Class and Description |
---|---|
class |
EventConsumer<T>
|
class |
NotifyConsumer<T>
A
Consumer that notifies an observable of each value that it has accepted. |
Constructor and Description |
---|
CallbackEvent(Event.Headers headers,
T data,
Consumer callback) |
CallbackEvent(Event.Headers headers,
T data,
Consumer callback,
Consumer<Throwable> throwableConsumer) |
CallbackEvent(Event.Headers headers,
T data,
Consumer callback,
Consumer<Throwable> throwableConsumer) |
CallbackEvent(T data,
Consumer callback) |
EventConsumer(Consumer<T> delegate)
Creates a new
EventConsumer that will pass event data to the given delegate . |
Modifier and Type | Method and Description |
---|---|
Registration<Long,? extends Consumer<Long>> |
EventTimer.schedule(Consumer<Long> consumer,
long period,
TimeUnit timeUnit) |
Registration<Long,? extends Consumer<Long>> |
EventTimer.schedule(Consumer<Long> consumer,
long period,
TimeUnit timeUnit,
long delayInMilliseconds) |
Registration<Long,? extends Consumer<Long>> |
EventTimer.submit(Consumer<Long> consumer) |
Registration<Long,? extends Consumer<Long>> |
EventTimer.submit(Consumer<Long> consumer,
long delay,
TimeUnit timeUnit) |
Modifier and Type | Method and Description |
---|---|
Registration<Long,? extends Consumer<Long>> |
EventTimer.schedule(Consumer<Long> consumer,
long period,
TimeUnit timeUnit) |
Registration<Long,? extends Consumer<Long>> |
EventTimer.schedule(Consumer<Long> consumer,
long period,
TimeUnit timeUnit,
long delayInMilliseconds) |
Registration<Long,? extends Consumer<Long>> |
EventTimer.submit(Consumer<Long> consumer) |
Registration<Long,? extends Consumer<Long>> |
EventTimer.submit(Consumer<Long> consumer,
long delay,
TimeUnit timeUnit) |
Modifier and Type | Method and Description |
---|---|
<E> void |
Dispatcher.dispatch(E data,
Consumer<E> eventConsumer,
Consumer<Throwable> errorConsumer)
Instruct the
Dispatcher to dispatch the data . |
<E> void |
Dispatcher.dispatch(E data,
Consumer<E> eventConsumer,
Consumer<Throwable> errorConsumer)
Instruct the
Dispatcher to dispatch the data . |
<E> void |
Dispatcher.tryDispatch(E data,
Consumer<E> eventConsumer,
Consumer<Throwable> errorConsumer)
Instruct the
Dispatcher to dispatch the data . |
<E> void |
Dispatcher.tryDispatch(E data,
Consumer<E> eventConsumer,
Consumer<Throwable> errorConsumer)
Instruct the
Dispatcher to dispatch the data . |
Modifier and Type | Field and Description |
---|---|
protected Consumer<Throwable> |
AbstractLifecycleDispatcher.Task.errorConsumer |
protected Consumer |
AbstractLifecycleDispatcher.Task.eventConsumer |
Modifier and Type | Method and Description |
---|---|
<E> void |
TailRecurseDispatcher.dispatch(E event,
Consumer<E> eventConsumer,
Consumer<Throwable> errorConsumer) |
<E> void |
TailRecurseDispatcher.dispatch(E event,
Consumer<E> eventConsumer,
Consumer<Throwable> errorConsumer) |
<E> void |
AbstractLifecycleDispatcher.dispatch(E event,
Consumer<E> eventConsumer,
Consumer<Throwable> errorConsumer) |
<E> void |
AbstractLifecycleDispatcher.dispatch(E event,
Consumer<E> eventConsumer,
Consumer<Throwable> errorConsumer) |
<E> void |
TraceableDelegatingDispatcher.dispatch(E event,
Consumer<E> consumer,
Consumer<Throwable> errorConsumer) |
<E> void |
TraceableDelegatingDispatcher.dispatch(E event,
Consumer<E> consumer,
Consumer<Throwable> errorConsumer) |
<E> void |
SynchronousDispatcher.dispatch(E event,
Consumer<E> eventConsumer,
Consumer<Throwable> errorConsumer) |
<E> void |
SynchronousDispatcher.dispatch(E event,
Consumer<E> eventConsumer,
Consumer<Throwable> errorConsumer) |
AbstractLifecycleDispatcher.Task |
AbstractLifecycleDispatcher.Task.setErrorConsumer(Consumer<Throwable> errorConsumer) |
AbstractLifecycleDispatcher.Task |
AbstractLifecycleDispatcher.Task.setEventConsumer(Consumer<?> eventConsumer) |
<E> void |
TailRecurseDispatcher.tryDispatch(E event,
Consumer<E> consumer,
Consumer<Throwable> errorConsumer) |
<E> void |
TailRecurseDispatcher.tryDispatch(E event,
Consumer<E> consumer,
Consumer<Throwable> errorConsumer) |
<E> void |
AbstractLifecycleDispatcher.tryDispatch(E event,
Consumer<E> eventConsumer,
Consumer<Throwable> errorConsumer) |
<E> void |
AbstractLifecycleDispatcher.tryDispatch(E event,
Consumer<E> eventConsumer,
Consumer<Throwable> errorConsumer) |
<E> void |
TraceableDelegatingDispatcher.tryDispatch(E event,
Consumer<E> eventConsumer,
Consumer<Throwable> errorConsumer) |
<E> void |
TraceableDelegatingDispatcher.tryDispatch(E event,
Consumer<E> eventConsumer,
Consumer<Throwable> errorConsumer) |
<E> void |
SynchronousDispatcher.tryDispatch(E event,
Consumer<E> consumer,
Consumer<Throwable> errorConsumer) |
<E> void |
SynchronousDispatcher.tryDispatch(E event,
Consumer<E> consumer,
Consumer<Throwable> errorConsumer) |
Constructor and Description |
---|
RingBufferDispatcher(String name,
int bufferSize,
Consumer<Throwable> uncaughtExceptionHandler)
Creates a new RingBufferDispatcher with the given
name . |
RingBufferDispatcher(String name,
int bufferSize,
Consumer<Throwable> uncaughtExceptionHandler,
com.lmax.disruptor.dsl.ProducerType producerType,
com.lmax.disruptor.WaitStrategy waitStrategy)
Creates a new RingBufferDispatcher with the given
name . |
WorkQueueDispatcher(String name,
int poolSize,
int backlog,
Consumer<Throwable> uncaughtExceptionHandler) |
WorkQueueDispatcher(String name,
int poolSize,
int backlog,
Consumer<Throwable> uncaughtExceptionHandler,
com.lmax.disruptor.dsl.ProducerType producerType,
com.lmax.disruptor.WaitStrategy waitStrategy) |
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 | Method and Description |
---|---|
static <I,O> org.reactivestreams.Publisher<O> |
PublisherFactory.barrier(org.reactivestreams.Publisher<I> source,
BiConsumer<I,org.reactivestreams.Subscriber<? super O>> dataConsumer,
BiConsumer<Throwable,org.reactivestreams.Subscriber<? super O>> errorConsumer,
Consumer<org.reactivestreams.Subscriber<? super O>> completeConsumer)
Intercept a source
Publisher onNext signal to eventually transform, forward or filter the data by calling
or not
the right operand Subscriber . |
static <T,C> org.reactivestreams.Publisher<T> |
PublisherFactory.create(BiConsumer<Long,SubscriberWithContext<T,C>> requestConsumer,
Function<org.reactivestreams.Subscriber<? super T>,C> contextFactory,
Consumer<C> shutdownConsumer)
Create a
Publisher reacting on requests with the passed BiConsumer . |
static <T> org.reactivestreams.Subscriber<T> |
SubscriberFactory.create(Consumer<org.reactivestreams.Subscription> subscriptionHandler)
Create a
Subscriber reacting onSubscribe with the passed Consumer |
static <T,C> org.reactivestreams.Subscriber<T> |
SubscriberFactory.create(Function<org.reactivestreams.Subscription,C> subscriptionHandler,
BiConsumer<T,SubscriptionWithContext<C>> dataConsumer,
BiConsumer<Throwable,C> errorConsumer,
Consumer<C> completeConsumer)
Create a
Subscriber reacting onNext, onSubscribe, onError, onComplete with the passed BiConsumer . |
static <T,C> org.reactivestreams.Publisher<T> |
PublisherFactory.forEach(Consumer<SubscriberWithContext<T,C>> requestConsumer,
Function<org.reactivestreams.Subscriber<? super T>,C> contextFactory)
|
static <T,C> org.reactivestreams.Publisher<T> |
PublisherFactory.forEach(Consumer<SubscriberWithContext<T,C>> requestConsumer,
Function<org.reactivestreams.Subscriber<? super T>,C> contextFactory,
Consumer<C> shutdownConsumer)
|
static <T,C> org.reactivestreams.Publisher<T> |
PublisherFactory.forEach(Consumer<SubscriberWithContext<T,C>> requestConsumer,
Function<org.reactivestreams.Subscriber<? super T>,C> contextFactory,
Consumer<C> shutdownConsumer)
|
static <T> org.reactivestreams.Publisher<T> |
PublisherFactory.forEach(Consumer<SubscriberWithContext<T,Void>> requestConsumer)
|
static <T> org.reactivestreams.Subscriber<T> |
SubscriberFactory.unbounded(BiConsumer<T,SubscriptionWithContext<Void>> dataConsumer,
Consumer<Throwable> errorConsumer)
Create a
Subscriber reacting onNext and onError. |
static <T> org.reactivestreams.Subscriber<T> |
SubscriberFactory.unbounded(BiConsumer<T,SubscriptionWithContext<Void>> dataConsumer,
Consumer<Throwable> errorConsumer,
Consumer<Void> completeConsumer)
Create a
Subscriber reacting onNext, onError and onComplete. |
static <T> org.reactivestreams.Subscriber<T> |
SubscriberFactory.unbounded(BiConsumer<T,SubscriptionWithContext<Void>> dataConsumer,
Consumer<Throwable> errorConsumer,
Consumer<Void> completeConsumer)
Create a
Subscriber reacting onNext, onError and onComplete. |
Modifier and Type | Method and Description |
---|---|
static <T> Consumer<T> |
Functions.chain(Consumer<T>... consumers)
Deprecated.
|
static <T> Consumer<T> |
Functions.consumer(Runnable r)
Deprecated.
|
Modifier and Type | Method and Description |
---|---|
static <T> Consumer<T> |
Functions.chain(Consumer<T>... consumers)
Deprecated.
|
Modifier and Type | Class and Description |
---|---|
class |
Tap<T>
A
Tap provides a limited window into an event stream. |
Modifier and Type | Class and Description |
---|---|
static class |
HashWheelTimer.TimerPausable<T extends Consumer<Long>>
Timer Registration
|
Modifier and Type | Method and Description |
---|---|
Pausable |
HashWheelTimer.schedule(Consumer<Long> consumer,
long period,
TimeUnit timeUnit) |
Pausable |
Timer.schedule(Consumer<Long> consumer,
long period,
TimeUnit timeUnit)
Schedule a recurring task.
|
Pausable |
HashWheelTimer.schedule(Consumer<Long> consumer,
long period,
TimeUnit timeUnit,
long delayInMilliseconds) |
Pausable |
Timer.schedule(Consumer<Long> consumer,
long period,
TimeUnit timeUnit,
long delayInMilliseconds)
Schedule a recurring task.
|
Pausable |
HashWheelTimer.submit(Consumer<Long> consumer) |
Pausable |
Timer.submit(Consumer<Long> consumer)
Submit a task for arbitrary execution after the delay of this timer's resolution.
|
Pausable |
HashWheelTimer.submit(Consumer<Long> consumer,
long period,
TimeUnit timeUnit) |
Pausable |
Timer.submit(Consumer<Long> consumer,
long delay,
TimeUnit timeUnit)
Submit a task for arbitrary execution after the given time delay.
|
Modifier and Type | Method and Description |
---|---|
ReactorBuilder |
ReactorBuilder.on(Consumer consumer) |
ReactorBuilder |
ReactorBuilder.on(Selector selector,
Consumer closure) |
ReactorBuilder |
ReactorBuilder.on(String selector,
Consumer closure) |
<E extends Event<?>> |
StreamRouter.route(Object key,
E event,
List<Registration<Object,? extends Consumer<? extends Event<?>>>> consumers,
Consumer<E> completionConsumer,
Consumer<Throwable> errorConsumer) |
<E extends Event<?>> |
StreamRouter.route(Object key,
E event,
List<Registration<Object,? extends Consumer<? extends Event<?>>>> consumers,
Consumer<E> completionConsumer,
Consumer<Throwable> errorConsumer) |
Modifier and Type | Method and Description |
---|---|
<E extends Event<?>> |
StreamRouter.route(Object key,
E event,
List<Registration<Object,? extends Consumer<? extends Event<?>>>> consumers,
Consumer<E> completionConsumer,
Consumer<Throwable> errorConsumer) |
Modifier and Type | Method and Description |
---|---|
static <K,T> Registration<K,Consumer<T>> |
BusExtensions.react(EventBus selfType,
Selector<K> selector,
groovy.lang.Closure handler) |
static <T> Registration<String,Consumer<T>> |
BusExtensions.react(EventBus selfType,
String selector,
groovy.lang.Closure handler) |
Modifier and Type | Method and Description |
---|---|
static <T> void |
BusExtensions.call(Consumer<T> selfType,
T value) |
static <T> Promise<T> |
StreamExtensions.leftShift(Promise<T> selfType,
Consumer<T> other) |
static <T> Control |
StreamExtensions.leftShift(Stream<T> selfType,
Consumer<T> other) |
Modifier and Type | Class and Description |
---|---|
class |
ClosureConsumer<T> |
class |
ClosureEventConsumer<T> |
class |
ClosureTupleConsumer
Invokes a
Closure using the contents of the incoming Tuple as the
arguments. |
Modifier and Type | Method and Description |
---|---|
Function<Buffer,byte[]> |
ByteArrayCodec.decoder(Consumer<byte[]> next) |
Function<Buffer,Frame> |
FrameCodec.decoder(Consumer<Frame> next) |
abstract Function<SRC,IN> |
Codec.decoder(Consumer<IN> next)
Provide the caller with a decoder to turn a source object into an instance of the input
type.
|
Function<Buffer,IN> |
SerializationCodec.decoder(Consumer<IN> next) |
Function<Buffer,IN> |
LengthFieldCodec.decoder(Consumer<IN> next) |
Function<Buffer,IN> |
DelimitedCodec.decoder(Consumer<IN> next) |
Function<SRC,SRC> |
PassThroughCodec.decoder(Consumer<SRC> next) |
Function<Buffer,String> |
StringCodec.decoder(Consumer<String> next) |
Function<Buffer,T> |
JavaSerializationCodec.decoder(Consumer<T> next) |
protected abstract Function<byte[],IN> |
SerializationCodec.deserializer(E engine,
Class<IN> type,
Consumer<IN> next) |
protected IN |
Codec.doDelimitedBufferDecode(Consumer<IN> decoderCallback,
Buffer buffer)
Helper method to scan for delimiting byte the codec might benefit from, e.g.
|
protected static <IN> IN |
Codec.invokeCallbackOrReturn(Consumer<IN> consumer,
IN v) |
Modifier and Type | Method and Description |
---|---|
Function<Buffer,IN> |
CompressionCodec.decoder(Consumer<IN> next) |
Modifier and Type | Method and Description |
---|---|
Function<Buffer,IN> |
JsonCodec.decoder(Consumer<IN> next) |
protected Function<byte[],IN> |
JacksonJsonCodec.deserializer(com.fasterxml.jackson.databind.ObjectMapper engine,
Class<IN> type,
Consumer<IN> next) |
Modifier and Type | Method and Description |
---|---|
protected Function<byte[],IN> |
KryoCodec.deserializer(com.esotericsoftware.kryo.Kryo engine,
Class<IN> type,
Consumer<IN> next) |
protected Function<byte[],IN> |
KryoPoolCodec.deserializer(com.esotericsoftware.kryo.pool.KryoPool engine,
Class<IN> type,
Consumer<IN> next) |
Modifier and Type | Method and Description |
---|---|
protected Function<byte[],IN> |
ProtobufCodec.deserializer(Map<Class<?>,com.google.protobuf.Message> messages,
Class<IN> type,
Consumer<IN> next) |
Modifier and Type | Method and Description |
---|---|
ReactorChannel.ConsumerSpec |
ReactorChannel.ConsumerSpec.close(Consumer<Void> onClose)
Assign a
Runnable to be invoked when the channel is closed. |
ReactorChannel.ConsumerSpec |
ReactorChannel.ConsumerSpec.readIdle(long idleTimeout,
Consumer<Void> onReadIdle)
Assign a
Runnable to be invoked when reads have become idle for the given timeout. |
ReactorChannel.ConsumerSpec |
ReactorChannel.ConsumerSpec.writeIdle(long idleTimeout,
Consumer<Void> onWriteIdle)
Assign a
Runnable to be invoked when writes have become idle for the given timeout. |
Modifier and Type | Method and Description |
---|---|
Function<Buffer,SyslogMessage> |
SyslogCodec.decoder(Consumer<SyslogMessage> next) |
Modifier and Type | Method and Description |
---|---|
Consumer<io.netty.channel.ChannelPipeline> |
NettyClientSocketOptions.pipelineConfigurer() |
Consumer<io.netty.channel.ChannelPipeline> |
NettyServerSocketOptions.pipelineConfigurer() |
Modifier and Type | Method and Description |
---|---|
NettyClientSocketOptions |
NettyClientSocketOptions.pipelineConfigurer(Consumer<io.netty.channel.ChannelPipeline> pipelineConfigurer) |
NettyServerSocketOptions |
NettyServerSocketOptions.pipelineConfigurer(Consumer<io.netty.channel.ChannelPipeline> pipelineConfigurer) |
Modifier and Type | Method and Description |
---|---|
Consumer<org.zeromq.ZMQ.Socket> |
ZeroMQServerSocketOptions.socketConfigurer()
The
Consumer responsible for configuring the underlying ZeroMQ socket. |
Consumer<org.zeromq.ZMQ.Socket> |
ZeroMQClientSocketOptions.socketConfigurer()
The
Consumer responsible for configuring the underlying ZeroMQ socket. |
Modifier and Type | Method and Description |
---|---|
ZeroMQServerSocketOptions |
ZeroMQServerSocketOptions.socketConfigurer(Consumer<org.zeromq.ZMQ.Socket> socketConfigurer)
Set the
Consumer responsible for configure the underlying ZeroMQ socket. |
ZeroMQClientSocketOptions |
ZeroMQClientSocketOptions.socketConfigurer(Consumer<org.zeromq.ZMQ.Socket> socketConfigurer)
Set the
Consumer responsible for configure the underlying ZeroMQ socket. |
Modifier and Type | Class and Description |
---|---|
class |
Promise<O>
A
Promise is a stateful event container that accepts a single value or error. |
static class |
StreamUtils.StreamVisitor |
Modifier and Type | Method and Description |
---|---|
Control |
Stream.adaptiveConsume(Consumer<? super O> consumer,
Function<Stream<Long>,? extends org.reactivestreams.Publisher<? extends Long>> requestMapper)
|
Control |
Stream.adaptiveConsumeOn(Dispatcher dispatcher,
Consumer<? super O> consumer,
Function<Stream<Long>,? extends org.reactivestreams.Publisher<? extends Long>> requestMapper)
|
Control |
Stream.batchConsume(Consumer<? super O> consumer,
Function<Long,? extends Long> requestMapper)
|
Control |
Stream.batchConsumeOn(Dispatcher dispatcher,
Consumer<? super O> consumer,
Function<Long,? extends Long> requestMapper)
|
Control |
Stream.consume(Consumer<? super O> consumer)
|
Control |
Stream.consume(Consumer<? super O> consumer,
Consumer<? super Throwable> errorConsumer)
|
Control |
Stream.consume(Consumer<? super O> consumer,
Consumer<? super Throwable> errorConsumer)
|
Control |
Stream.consume(Consumer<? super O> consumer,
Consumer<? super Throwable> errorConsumer,
Consumer<Void> completeConsumer)
|
Control |
Stream.consume(Consumer<? super O> consumer,
Consumer<? super Throwable> errorConsumer,
Consumer<Void> completeConsumer)
|
Control |
Stream.consume(Consumer<? super O> consumer,
Consumer<? super Throwable> errorConsumer,
Consumer<Void> completeConsumer)
|
Control |
Stream.consumeOn(Dispatcher dispatcher,
Consumer<? super O> consumer)
|
Control |
Stream.consumeOn(Dispatcher dispatcher,
Consumer<? super O> consumer,
Consumer<? super Throwable> errorConsumer)
|
Control |
Stream.consumeOn(Dispatcher dispatcher,
Consumer<? super O> consumer,
Consumer<? super Throwable> errorConsumer)
|
Control |
Stream.consumeOn(Dispatcher dispatcher,
Consumer<? super O> consumer,
Consumer<? super Throwable> errorConsumer,
Consumer<Void> completeConsumer)
|
Control |
Stream.consumeOn(Dispatcher dispatcher,
Consumer<? super O> consumer,
Consumer<? super Throwable> errorConsumer,
Consumer<Void> completeConsumer)
|
Control |
Stream.consumeOn(Dispatcher dispatcher,
Consumer<? super O> consumer,
Consumer<? super Throwable> errorConsumer,
Consumer<Void> completeConsumer)
|
static <T,C> Stream<T> |
Streams.createWith(BiConsumer<Long,SubscriberWithContext<T,C>> requestConsumer,
Function<org.reactivestreams.Subscriber<? super T>,C> contextFactory,
Consumer<C> shutdownConsumer)
Create a
Stream reacting on requests with the passed BiConsumer . |
Stream<O> |
Stream.finallyDo(Consumer<Signal<O>> consumer)
Attach a
Consumer to this Stream that will observe terminal signal complete|error. |
Stream<O> |
Stream.observe(Consumer<? super O> consumer)
|
Stream<O> |
Stream.observeCancel(Consumer<Void> consumer)
Attach a
Consumer to this Stream that will observe any cancel signal |
Stream<O> |
Stream.observeComplete(Consumer<Void> consumer)
Attach a
Consumer to this Stream that will observe any complete signal |
Stream<O> |
Stream.observeStart(Consumer<? super org.reactivestreams.Subscription> consumer)
Attach a
Consumer to this Stream that will observe any onSubscribe signal |
Stream<O> |
Stream.observeSubscribe(Consumer<? super org.reactivestreams.Subscriber<? super O>> consumer)
Attach a
Consumer to this Stream that will observe any subscribe signal |
Promise<O> |
Promise.onComplete(Consumer<Promise<O>> onComplete)
Assign a
Consumer that will either be invoked later, when the Promise is completed by either
setting a value or propagating an error, or, if this Promise has already been fulfilled, is immediately
scheduled to be executed on the current Dispatcher . |
Promise<O> |
Promise.onError(Consumer<Throwable> onError)
Assign a
Consumer that will either be invoked later, when the Promise is completed with an error,
or, if this Promise has already been fulfilled, is immediately scheduled to be executed on the current
Dispatcher . |
Promise<O> |
Promise.onSuccess(Consumer<O> onSuccess)
Assign a
Consumer that will either be invoked later, when the Promise is successfully completed
with
a value, or, if this Promise has already been fulfilled, is immediately scheduled to be executed on the
current Dispatcher . |
<E extends Throwable> |
Stream.when(Class<E> exceptionType,
Consumer<E> onError)
Assign an error handler to exceptions of the given type.
|
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).
|
class |
Signal<T>
A domain representation of a Reactive
Stream signal. |
Modifier and Type | Method and Description |
---|---|
Consumer<?> |
Action.toBroadcastCompleteConsumer()
Create a consumer that broadcast complete signal from any accepted value.
|
Consumer<Throwable> |
Action.toBroadcastErrorConsumer()
Create a consumer that broadcast error signal from any accepted value.
|
Consumer<O> |
Action.toBroadcastNextConsumer()
Create a consumer that broadcast next signal from accepted values.
|
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. |
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 | Field and Description |
---|---|
protected Consumer<T> |
BatchAction.flushConsumer |
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 |
FanInSubscription<O,E,X,SUBSCRIBER extends FanInAction.InnerSubscriber<O,E,X>> |
class |
MergeAction<O> |
static class |
MergeAction.InnerSubscriber<I> |
class |
SwitchAction<T> |
class |
ZipAction<O,V,TUPLE extends Tuple> |
static class |
ZipAction.InnerSubscriber<O,V> |
Modifier and Type | Method and Description |
---|---|
void |
FanInSubscription.forEach(Consumer<FanInSubscription.InnerSubscription<O,E,SUBSCRIBER>> consumer) |
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> |
Constructor and Description |
---|
ErrorAction(Class<E> selector,
Consumer<? super E> consumer,
org.reactivestreams.Publisher<? extends T> fallback) |
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> |
Constructor and Description |
---|
CallbackAction(Consumer<? super T> consumer,
Consumer<Void> completeConsumer) |
CallbackAction(Consumer<? super T> consumer,
Consumer<Void> completeConsumer) |
FinallyAction(Consumer<Signal<T>> consumer) |
StreamStateCallbackAction(Consumer<? super org.reactivestreams.Subscriber<? super T>> subscribeConsumer,
Consumer<Void> cancelConsumer,
Consumer<? super org.reactivestreams.Subscription> onSubscribeConsumer) |
StreamStateCallbackAction(Consumer<? super org.reactivestreams.Subscriber<? super T>> subscribeConsumer,
Consumer<Void> cancelConsumer,
Consumer<? super org.reactivestreams.Subscription> onSubscribeConsumer) |
StreamStateCallbackAction(Consumer<? super org.reactivestreams.Subscriber<? super T>> subscribeConsumer,
Consumer<Void> cancelConsumer,
Consumer<? super org.reactivestreams.Subscription> onSubscribeConsumer) |
Modifier and Type | Class and Description |
---|---|
class |
AdaptiveConsumerAction<T> |
class |
ConsumerAction<T> |
Constructor and Description |
---|
AdaptiveConsumerAction(Dispatcher dispatcher,
long initCapacity,
Consumer<? super T> consumer,
Function<Stream<Long>,? extends org.reactivestreams.Publisher<? extends Long>> requestMapper) |
ConsumerAction(long capacity,
Dispatcher dispatcher,
Consumer<? super T> consumer,
Consumer<? super Throwable> errorConsumer,
Consumer<Void> completeConsumer) |
ConsumerAction(long capacity,
Dispatcher dispatcher,
Consumer<? super T> consumer,
Consumer<? super Throwable> errorConsumer,
Consumer<Void> completeConsumer) |
ConsumerAction(long capacity,
Dispatcher dispatcher,
Consumer<? super T> consumer,
Consumer<? super Throwable> errorConsumer,
Consumer<Void> completeConsumer) |
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 |
---|---|
<I> Consumer<I> |
BarrierStream.wrap(Consumer<I> consumer) |
Modifier and Type | Method and Description |
---|---|
<I> Consumer<I> |
BarrierStream.wrap(Consumer<I> consumer) |
Modifier and Type | Class and Description |
---|---|
class |
BatchSubscription<T>
A Subscription wrapper which request
|
class |
DropSubscription<O>
Relationship between a Stream (Publisher) and a Subscriber.
|
class |
FanOutSubscription<O>
A composite subscription used to achieve pub/sub pattern.
|
class |
PushSubscription<O>
Relationship between a Stream (Publisher) and a Subscriber.
|
class |
ReactiveSubscription<O>
Relationship between a Stream (Publisher) and a Subscriber.
|
Modifier and Type | Method and Description |
---|---|
void |
FanOutSubscription.forEach(Consumer<PushSubscription<O>> consumer) |
Modifier and Type | Class and Description |
---|---|
class |
WrappedSubscription<O> |
Copyright © 2016. All rights reserved.