Reactor (reactor-core 1.1.6.RELEASE API)

java.lang.Object
- reactor.core.Reactor

All Implemented Interfaces:

Observable
```
public class Reactor
extends java.lang.Object
implements Observable
```
A reactor is an event gateway that allows other components to register Event Consumers that can subsequently be notified of events. A consumer is typically registered with a Selector which, by matching on the notification key, governs which events the consumer will receive.
When a Reactor is notified of an Event, a task is dispatched using the reactor's Dispatcher which causes it to be executed on a thread based on the implementation of the Dispatcher being used.

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

class Reactor.ReplyToConsumer<E extends Event<?>,V>

static class Reactor.ReplyToEvent<T>

Nested Classes
Modifier and Type	Class and Description
`class`	`Reactor.ReplyToConsumer<E extends Event<?>,V>`
`static class`	`Reactor.ReplyToEvent<T>`

Constructor Summary

Constructors
Constructor and Description
`Reactor(Dispatcher dispatcher)` Create a new Reactor that uses the given `Dispatcher`.
`Reactor(Dispatcher dispatcher, EventRouter eventRouter)` Create a new Reactor that uses the given `Dispatcher`.
`Reactor(Dispatcher dispatcher, EventRouter eventRouter, Consumer<java.lang.Throwable> dispatchErrorHandler, Consumer<java.lang.Throwable> uncaughtErrorHandler)`
`Reactor(Registry<Consumer<? extends Event<?>>> consumerRegistry, Dispatcher dispatcher, EventRouter eventRouter, Consumer<java.lang.Throwable> dispatchErrorHandler, Consumer<java.lang.Throwable> uncaughtErrorHandler)` Create a new Reactor that uses the given `dispatacher` and `eventRouter`.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`<T> Consumer<java.lang.Iterable<Event<T>>>`	`batchNotify(java.lang.Object key)` Notify the key with all any accepted iterable group of events by the returned `Consumer`.
`<T> Consumer<java.lang.Iterable<Event<T>>>`	`batchNotify(java.lang.Object key, Consumer<java.lang.Void> completeConsumer)` Notify the key with all any accepted iterable group of events by the returned `Consumer`.
`boolean`	`equals(java.lang.Object o)`
`Registry<Consumer<? extends Event<?>>>`	`getConsumerRegistry()` Get the `Registry` is use to maintain the `Consumer`s currently listening for events on this Reactor.
`Dispatcher`	`getDispatcher()` Get the `Dispatcher` currently in use.
`Consumer<java.lang.Throwable>`	`getDispatchErrorHandler()`
`EventRouter`	`getEventRouter()` Get the `EventRouter` used to route events to `Consumers`.
`java.util.UUID`	`getId()` Get the unique, time-used `UUID` of this Reactor.
`Consumer<java.lang.Throwable>`	`getUncaughtErrorHandler()`
`Reactor`	`notify(java.lang.Object key)` Notify this component that the consumers registered with a `Selector` that matches the `key` should be triggered with a null input argument.
`<E extends Event<?>> Reactor`	`notify(java.lang.Object key, E ev)` Notify this component that an `Event` is ready to be processed.
`<E extends Event<?>> Reactor`	`notify(java.lang.Object key, E ev, Consumer<E> onComplete)` Notify this component that an `Event` is ready to be processed and `accept` `onComplete` after dispatching.
`<S extends Supplier<? extends Event<?>>> Reactor`	`notify(java.lang.Object key, S supplier)` Notify this component that the given `Supplier` can provide an event that's ready to be processed.
`<E extends Event<?>> Registration<Consumer<E>>`	`on(Selector selector, Consumer<E> consumer)` Register a `Consumer` to be triggered when a notification matches the given `Selector`.
`<T> Consumer<Event<T>>`	`prepare(java.lang.Object key)` Create an optimized path for publishing notifications to the given key.
`<E extends Event<?>,V> Registration<Consumer<E>>`	`receive(Selector sel, Function<E,V> fn)` Assign a `Function` to receive an `Event` and produce a reply of the given type.
`boolean`	`respondsToKey(java.lang.Object key)` Are there any `Registration`s with `Selectors` that match the given `key`.
`<T> void`	`schedule(Consumer<T> consumer, T data)` Schedule an arbitrary `Consumer` to be executed on the current Reactor `Dispatcher`, passing the given .
`<E extends Event<?>> Reactor`	`send(java.lang.Object key, E ev)` Notify this component of the given `Event` and register an internal `Consumer` that will take the output of a previously-registered `Function` and respond using the key set on the `Event`'s replyTo property.
`<E extends Event<?>> Reactor`	`send(java.lang.Object key, E ev, Observable replyTo)` Notify this component of the given `Event` and register an internal `Consumer` that will take the output of a previously-registered `Function` and respond to the key set on the `Event`'s replyTo property and will call the `notify` method on the given `Observable`.
`<S extends Supplier<? extends Event<?>>> Reactor`	`send(java.lang.Object key, S supplier)` Notify this component that the given `Supplier` will provide an `Event` and register an internal `Consumer` that will take the output of a previously-registered `Function` and respond using the key set on the `Event`'s replyTo property.
`<S extends Supplier<? extends Event<?>>> Reactor`	`send(java.lang.Object key, S supplier, Observable replyTo)` Notify this component that the given `Supplier` will provide an `Event` and register an internal `Consumer` that will take the output of a previously-registered `Function` and respond to the key set on the `Event`'s replyTo property and will call the `notify` method on the given `Observable`.
`<REQ extends Event<?>,RESP extends Event<?>> Reactor`	`sendAndReceive(java.lang.Object key, REQ ev, Consumer<RESP> reply)` Register the given `Consumer` on an anonymous `Selector` and set the given event's `replyTo` property to the corresponding anonymous key, then register the consumer to receive replies from the `Function` assigned to handle the given key.
`<REQ extends Event<?>,RESP extends Event<?>,S extends Supplier<REQ>> Reactor`	`sendAndReceive(java.lang.Object key, S supplier, Consumer<RESP> reply)` Register the given `Consumer` on an anonymous `Selector` and set the event's `replyTo` property to the corresponding anonymous key, then register the consumer to receive replies from the `Function` assigned to handle the given key.

Methods inherited from class java.lang.Object
clone, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - Reactor
```
public Reactor(@Nullable
               Dispatcher dispatcher)
```
    Create a new Reactor that uses the given Dispatcher. The reactor will use a default EventRouter that broadcast events to all of the registered consumers that match the notification key and does not perform any type conversion.
    
    Parameters:
    
    dispatcher - The Dispatcher to use. May be null in which case a new SynchronousDispatcher is used
  - Reactor
```
public Reactor(@Nullable
               Dispatcher dispatcher,
               @Nullable
               EventRouter eventRouter)
```
    Create a new Reactor that uses the given Dispatcher. The reactor will use a default CachingRegistry.
    
    Parameters:
    
    dispatcher - The Dispatcher to use. May be null in which case a new synchronous dispatcher is used.
    
    eventRouter - The EventRouter used to route events to Consumers. May be null in which case the default event router that broadcasts events to all of the registered consumers that match the notification key and does not perform any type conversion will be used.
  - Reactor
```
public Reactor(@Nullable
               Dispatcher dispatcher,
               @Nullable
               EventRouter eventRouter,
               @Nullable
               Consumer<java.lang.Throwable> dispatchErrorHandler,
               @Nullable
               Consumer<java.lang.Throwable> uncaughtErrorHandler)
```
  - Reactor
```
public Reactor(@Nonnull
               Registry<Consumer<? extends Event<?>>> consumerRegistry,
               @Nullable
               Dispatcher dispatcher,
               @Nullable
               EventRouter eventRouter,
               @Nullable
               Consumer<java.lang.Throwable> dispatchErrorHandler,
               @Nullable
               Consumer<java.lang.Throwable> uncaughtErrorHandler)
```
    Create a new Reactor that uses the given dispatacher and eventRouter.
    
    Parameters:
    
    dispatcher - The Dispatcher to use. May be null in which case a new synchronous dispatcher is used.
    
    eventRouter - The EventRouter used to route events to Consumers. May be null in which case the default event router that broadcasts events to all of the registered consumers that match the notification key and does not perform any type conversion will be used.
    
    consumerRegistry - The Registry to be used to match Selector and dispatch to Consumer.
- Method Detail
  - getId
```
public java.util.UUID getId()
```
    Get the unique, time-used UUID of this Reactor.
    
    Returns:
    
    The UUID of this Reactor.
  - getConsumerRegistry
```
public Registry<Consumer<? extends Event<?>>> getConsumerRegistry()
```
    Get the Registry is use to maintain the Consumers currently listening for events on this Reactor.
    
    Returns:
    
    The Registry in use.
  - getDispatcher
```
public Dispatcher getDispatcher()
```
    Get the Dispatcher currently in use.
    
    Returns:
    
    The Dispatcher.
  - getEventRouter
```
public EventRouter getEventRouter()
```
    Get the EventRouter used to route events to Consumers.
    
    Returns:
    
    The EventRouter.
  - getDispatchErrorHandler
```
public Consumer<java.lang.Throwable> getDispatchErrorHandler()
```
  - getUncaughtErrorHandler
```
public Consumer<java.lang.Throwable> getUncaughtErrorHandler()
```
  - respondsToKey
```
public boolean respondsToKey(java.lang.Object key)
```
    Description copied from interface: Observable
    
    Are there any Registrations with Selectors that match the given key.
    
    Specified by:
    
    respondsToKey in interface Observable
    
    Parameters:
    
    key - The key to be matched by Selectors
    
    Returns:
    
    true if there are any matching Registrations, false otherwise
  - on
```
public <E extends Event<?>> Registration<Consumer<E>> on(Selector selector,
                                                         Consumer<E> consumer)
```
    Description copied from interface: Observable
    
    Register a Consumer to be triggered when a notification matches the given Selector.
    
    Specified by:
    
    on in interface Observable
    
    Type Parameters:
    
    E - The type of the Event
    
    Parameters:
    
    selector - The Selector to be used for matching
    
    consumer - The Consumer to be triggered
    
    Returns:
    
    A Registration object that allows the caller to interact with the given mapping
  - receive
```
public <E extends Event<?>,V> Registration<Consumer<E>> receive(Selector sel,
                                                                Function<E,V> fn)
```
    Description copied from interface: Observable
    
    Assign a Function to receive an Event and produce a reply of the given type.
    
    Specified by:
    
    receive in interface Observable
    
    Type Parameters:
    
    E - The type of the Event
    
    V - The type of the response data
    
    Parameters:
    
    sel - The Selector to be used for matching
    
    fn - The transformative Function to call to receive an Event
    
    Returns:
    
    A Registration object that allows the caller to interact with the given mapping
  - notify
```
public <E extends Event<?>> Reactor notify(java.lang.Object key,
                                           E ev,
                                           Consumer<E> onComplete)
```
    Description copied from interface: Observable
    
    Notify this component that an Event is ready to be processed and accept onComplete after dispatching.
    
    Specified by:
    
    notify in interface Observable
    
    Type Parameters:
    
    E - The type of the Event
    
    Parameters:
    
    key - The key to be matched by Selectors
    
    ev - The Event
    
    onComplete - The callback Consumer
    
    Returns:
    
    this
  - notify
```
public <E extends Event<?>> Reactor notify(java.lang.Object key,
                                           E ev)
```
    Description copied from interface: Observable
    
    Notify this component that an Event is ready to be processed.
    
    Specified by:
    
    notify in interface Observable
    
    Type Parameters:
    
    E - The type of the Event
    
    Parameters:
    
    key - The key to be matched by Selectors
    
    ev - The Event
    
    Returns:
    
    this
  - notify
```
public <S extends Supplier<? extends Event<?>>> Reactor notify(java.lang.Object key,
                                                               S supplier)
```
    Description copied from interface: Observable
    
    Notify this component that the given Supplier can provide an event that's ready to be processed.
    
    Specified by:
    
    notify in interface Observable
    
    Type Parameters:
    
    S - The type of the Supplier
    
    Parameters:
    
    key - The key to be matched by Selectors
    
    supplier - The Supplier that will provide the actual Event
    
    Returns:
    
    this
  - notify
```
public Reactor notify(java.lang.Object key)
```
    Description copied from interface: Observable
    
    Notify this component that the consumers registered with a Selector that matches the key should be triggered with a null input argument.
    
    Specified by:
    
    notify in interface Observable
    
    Parameters:
    
    key - The key to be matched by Selectors
    
    Returns:
    
    this
  - send
```
public <E extends Event<?>> Reactor send(java.lang.Object key,
                                         E ev)
```
    Description copied from interface: Observable
    
    Notify this component of the given Event and register an internal Consumer that will take the output of a previously-registered Function and respond using the key set on the Event's replyTo property.
    
    Specified by:
    
    send in interface Observable
    
    Type Parameters:
    
    E - The type of the Event
    
    Parameters:
    
    key - The key to be matched by Selectors
    
    ev - The Event
    
    Returns:
    
    this
  - send
```
public <S extends Supplier<? extends Event<?>>> Reactor send(java.lang.Object key,
                                                             S supplier)
```
    Description copied from interface: Observable
    
    Notify this component that the given Supplier will provide an Event and register an internal Consumer that will take the output of a previously-registered Function and respond using the key set on the Event's replyTo property.
    
    Specified by:
    
    send in interface Observable
    
    Parameters:
    
    key - The key to be matched by Selectors
    
    supplier - The Supplier that will provide the actual Event instance
    
    Returns:
    
    this
  - send
```
public <E extends Event<?>> Reactor send(java.lang.Object key,
                                         E ev,
                                         Observable replyTo)
```
    Description copied from interface: Observable
    
    Notify this component of the given Event and register an internal Consumer that will take the output of a previously-registered Function and respond to the key set on the Event's replyTo property and will call the notify method on the given Observable.
    
    Specified by:
    
    send in interface Observable
    
    Type Parameters:
    
    E - The type of the Event
    
    Parameters:
    
    key - The key to be matched by Selectors
    
    ev - The Event
    
    replyTo - The Observable on which to invoke the notify method
    
    Returns:
    
    this
  - send
```
public <S extends Supplier<? extends Event<?>>> Reactor send(java.lang.Object key,
                                                             S supplier,
                                                             Observable replyTo)
```
    Description copied from interface: Observable
    
    Notify this component that the given Supplier will provide an Event and register an internal Consumer that will take the output of a previously-registered Function and respond to the key set on the Event's replyTo property and will call the notify method on the given Observable.
    
    Specified by:
    
    send in interface Observable
    
    Type Parameters:
    
    S - The type of the Supplier
    
    Parameters:
    
    key - The key to be matched by Selectors
    
    supplier - The Supplier that will provide the actual Event instance
    
    replyTo - The Observable on which to invoke the notify method
    
    Returns:
    
    this
  - sendAndReceive
```
public <REQ extends Event<?>,RESP extends Event<?>> Reactor sendAndReceive(java.lang.Object key,
                                                                           REQ ev,
                                                                           Consumer<RESP> reply)
```
    Description copied from interface: Observable
    
    Register the given Consumer on an anonymous Selector and set the given event's replyTo property to the corresponding anonymous key, then register the consumer to receive replies from the Function assigned to handle the given key.
    
    Specified by:
    
    sendAndReceive in interface Observable
    
    Type Parameters:
    
    REQ - The type of the request event.
    
    RESP - The type of the response event.
    
    Parameters:
    
    key - The key to be matched by Selectors
    
    ev - The event to notify.
    
    reply - The consumer to register as a reply handler.
    
    Returns:
    
    this
  - sendAndReceive
```
public <REQ extends Event<?>,RESP extends Event<?>,S extends Supplier<REQ>> Reactor sendAndReceive(java.lang.Object key,
                                                                                                   S supplier,
                                                                                                   Consumer<RESP> reply)
```
    Description copied from interface: Observable
    
    Register the given Consumer on an anonymous Selector and set the event's replyTo property to the corresponding anonymous key, then register the consumer to receive replies from the Function assigned to handle the given key.
    
    Specified by:
    
    sendAndReceive in interface Observable
    
    Type Parameters:
    
    REQ - The type of the request event.
    
    RESP - The type of the response event.
    
    S - The type of the supplier.
    
    Parameters:
    
    key - The key to be matched by Selectors
    
    supplier - The supplier to supply the event.
    
    reply - The consumer to register as a reply handler.
    
    Returns:
    
    this
  - prepare
```
public <T> Consumer<Event<T>> prepare(java.lang.Object key)
```
    Description copied from interface: Observable
    
    Create an optimized path for publishing notifications to the given key.
    
    Specified by:
    
    prepare in interface Observable
    
    Parameters:
    
    key - The key to be matched by Selectors
    
    Returns:
    
    a Consumer to invoke with the Events to publish
  - batchNotify
```
public <T> Consumer<java.lang.Iterable<Event<T>>> batchNotify(java.lang.Object key)
```
    Description copied from interface: Observable
    
    Notify the key with all any accepted iterable group of events by the returned Consumer. The implementation will take care of reducing the consumer selection to one per batch. The candidate consumers are selected with the key , possibly on each batch to refresh the result list.
    
    Specified by:
    
    batchNotify in interface Observable
    
    Parameters:
    
    key - The key to be matched by Selectors
    
    Returns:
    
    a Consumer to invoke with the Events to publish
  - batchNotify
```
public <T> Consumer<java.lang.Iterable<Event<T>>> batchNotify(java.lang.Object key,
                                                              Consumer<java.lang.Void> completeConsumer)
```
    Description copied from interface: Observable
    
    Notify the key with all any accepted iterable group of events by the returned Consumer. The implementation will take care of reducing the consumer selection to one per batch. The candidate consumers are selected with the key , possibly on each batch to refresh the result list.
    
    Specified by:
    
    batchNotify in interface Observable
    
    Parameters:
    
    key - The key to be matched by Selectors
    
    completeConsumer - The consumer to trigger after batch completion
    
    Returns:
    
    a Consumer to invoke with the Events to publish
  - equals
```
public boolean equals(java.lang.Object o)
```
    Overrides:
    
    equals in class java.lang.Object
  - schedule
```
public <T> void schedule(Consumer<T> consumer,
                         T data)
```
    Schedule an arbitrary Consumer to be executed on the current Reactor Dispatcher, passing the given .
    
    Type Parameters:
    
    T - The type of the data.
    
    Parameters:
    
    consumer - The Consumer to invoke.
    
    data - The data to pass to the consumer.

Class Reactor

Nested Class Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

Reactor

Reactor

Reactor

Reactor

Method Detail

getId

getConsumerRegistry

getDispatcher

getEventRouter

getDispatchErrorHandler

getUncaughtErrorHandler

respondsToKey

on

receive

notify

notify

notify

notify

send

send

send

send

sendAndReceive

sendAndReceive

prepare

batchNotify

batchNotify

equals

schedule