Search Java Classes and Packages

Search Java Frameworks and Libraries

255581 classes and counting ...
Search Tips Index Status



# Classes and Interfaces in #Reactor - 312 results found.
NameDescriptionTypePackageFramework
AbstractLifecycleDispatcherA Dispatcher that has a lifecycle.Classreactor.core.dispatchReactor
AbstractReferenceAn abstract Reference implementation that does reference counting.Classreactor.allocReactor
ActionAn Action is a reactive component to subscribe to a Publisher and in particular to a Stream.Classreactor.rx.actionReactor
AdaptiveConsumerActionClassreactor.rx.action.terminalReactor
AfterActionClassreactor.rx.action.passiveReactor
AgileWaitingStrategyA pair of slow and fast wait strategies to dynamically adapt to a given application loadSince:2.Classreactor.core.dispatch.waitReactor
AllocatorAn Allocator is responsible for returning to the caller a Reference to a reusable object or to provide a newly-created object, depending on the underlying allocation strategy.Interfacereactor.allocReactor
AssertAssertion utility class that assists in validating arguments.Classreactor.core.supportReactor
AsyncAppenderA Logback Appender implementation that uses a Reactor RingBufferProcessor to queue events to a single-writer thread.Classreactor.logbackReactor
BarrierStreamA BarrierStream provides a type of Stream into which you can bind Consumers and Functions from arbitrary components.Classreactor.rx.streamReactor
BatchActionClassreactor.rx.action.aggregationReactor
BatchSubscriptionA Subscription wrapper which requestAuthor:Stephane MaldiniClassreactor.rx.subscriptionReactor
BehaviorBroadcasterA Broadcaster is a subclass of Stream which exposes methods for publishing values into the pipeline.Classreactor.rx.broadcastReactor
BiConsumerInterfacereactor.fnReactor
BiFunctionInterfacereactor.fnReactor
BiStreamsA Streams add-on to work with key/value pairs hydrated in Tuple2.Classreactor.rxReactor
BroadcasterA Broadcaster is a subclass of Stream which exposes methods for publishing values into the pipeline.Classreactor.rx.broadcastReactor
BufferA Buffer is a general-purpose IO utility class that wraps a ByteBuffer.Classreactor.io.bufferReactor
BufferActionClassreactor.rx.action.aggregationReactor
BufferAllocatorAn Allocator implementation that allocates Buffers.Classreactor.io.bufferReactor
BufferCodecClassreactor.io.codecReactor
BufferShiftActionClassreactor.rx.action.aggregationReactor
BufferShiftWhenActionClassreactor.rx.action.aggregationReactor
BufferWhenActionClassreactor.rx.action.aggregationReactor
BusBasic unit of event handling in Reactor.Interfacereactor.busReactor
BusPublisherEmit signals whenever an Event arrives from the Selector topic from the Bus.Classreactor.bus.publisherReactor
ByteArrayCodecA simple Codec implementation that turns a Buffer into a byte[] andAuthor:Jon Brisbin, Stephane MaldiniClassreactor.io.codecReactor
CachableRegistrationClassreactor.bus.registryReactor
CacheActionClassreactor.rx.action.aggregationReactor
CachingRegistryClassreactor.bus.registryReactor
CallbackActionClassreactor.rx.action.passiveReactor
CallbackEventSimple Event implementation that attaches a callback to an Event and passes it to a delegate Consumer.Classreactor.bus.supportReactor
CancelExceptionAn exception signal from downstream subscribers consuming data when their state is denying any additional event.Classreactor.core.processorReactor
ChronicleQueuePersistorA QueuePersistor implementation that uses a Java Chronicle IndexedChronicle to persist items in the queue.Classreactor.io.queueReactor
ChronicleReaderStream queue tasks to execute.Classreactor.rx.stream.ioReactor
ChronicleStreamClassreactor.rx.stream.ioReactor
ClassSelectorClassreactor.bus.selectorReactor
ClientSocketOptionsClassreactor.io.net.configReactor
ClosureTupleConsumerClassreactor.groovy.supportReactor
Codec instance of IN and passing that to the given Consumer.Classreactor.io.codecReactor
CombineLatestActionClassreactor.rx.action.combinationReactor
CommonSocketOptionsEncapsulates common socket options.Classreactor.io.net.configReactor
CompletableBlockingQueueA LinkedQueue that supports a terminal state.Classreactor.core.queueReactor
CompletableLinkedQueueA LinkedQueue that supports a terminal state.Classreactor.core.queueReactor
CompletableQueueQueues that support a terminal stateSince:2.Interfacereactor.core.queueReactor
CompositeActionCreate a Processor where a given head/tail couple is provided as a Stream (Input upstream) and Action (OutputSince:2.Classreactor.rx.actionReactor
CompressionCodecClassreactor.io.codec.compressReactor
ConcatActionClassreactor.rx.action.combinationReactor
ConfigurationReaderA ConfigurationReader is used to read Reactor configuration.Interfacereactor.core.configReactor
ConsumerInterfacereactor.fnReactor
ConsumerActionClassreactor.rx.action.terminalReactor
ConsumerFilteringRouterAn Router that filters consumers before routing events toAuthor:Andy Wilkinson, Stephane MaldiniClassreactor.bus.routingReactor
ControlAn interface generally associated with a Stream terminal action such as Stream.Interfacereactor.rx.actionReactor
CountActionClassreactor.rx.action.metricsReactor
DatagramServerClassreactor.io.net.udpReactor
DefaultIfEmptyActionClassreactor.rx.action.transformationReactor
DefaultSubscriberClassreactor.rx.action.supportReactor
DeferredStreamA Publisher supplier that will call the passed supplier on each subscribe call.Classreactor.rx.streamReactor
DelimitedCodecAn implementation of Codec that decodes by splitting a Buffer into segments based on a delimiter and encodes by appending its delimiter to each piece of output.Classreactor.io.codecReactor
DematerializeActionClassreactor.rx.action.transformationReactor
DispatcherA Dispatcher is used to dispatch(Object, Consumer, Consumer) dispatch} data to Consumers.Interfacereactor.coreReactor
DispatcherActionClassreactor.rx.action.controlReactor
DispatcherComponentSpecA generic environment-aware class for specifying components that need to be configured with an Environment and Dispatcher.Classreactor.bus.specReactor
DispatcherConfigurationAn encapsulation of the configuration for a Dispatcher.Classreactor.core.configReactor
DispatcherSupplierA Dispatcher Supplier with shutdown capacities to clean produced dispatchers.Interfacereactor.coreReactor
DispatcherTypeAn enumeration of supported types of Dispatcher.Classreactor.core.configReactor
DistinctActionClassreactor.rx.action.filterReactor
DistinctUntilChangedActionClassreactor.rx.action.filterReactor
DropSubscriptionRelationship between a Stream (Publisher) and a Subscriber.Classreactor.rx.subscriptionReactor
DurableAsyncAppenderAn AsyncAppender subclass that first writes a log event to a durable Chronicle using Java Chronicle before allowing the event to be queued.Classreactor.logbackReactor
DurableLogUtilityClassreactor.logbackReactor
DynamicMergeActionClassreactor.rx.action.combinationReactor
ElapsedActionClassreactor.rx.action.metricsReactor
ElementAtActionClassreactor.rx.action.filterReactor
EnvironmentClassreactorReactor
ErrorActionClassreactor.rx.action.errorReactor
ErrorReturnActionClassreactor.rx.action.errorReactor
ErrorStreamA Stream that emits a sigle error signal.Classreactor.rx.streamReactor
ErrorWithValueActionClassreactor.rx.action.errorReactor
EventWrapper for an object that needs to be processed by Consumers.Classreactor.busReactor
EventAllocatorGeneric Event Allocator.Classreactor.allocReactor
EventBusA reactor is an event gateway that allows other components to register Event Consumers that can subsequently be notified of events.Classreactor.busReactor
EventBusSpecA helper class for configuring a new EventBus.Classreactor.bus.specReactor
EventConsumerSimple Consumer implementation that pulls the data from an Event and passes it to a delegate Consumer.Classreactor.bus.supportReactor
EventFactorySupplierA Supplier implementation that instantiates Events based on Event data type.Classreactor.allocReactor
EventRoutingComponentSpecA generic environment-aware class for specifying components that need to be configured with an Environment, Dispatcher, and Router.Classreactor.bus.specReactor
EventTimerA hashed wheel timer implementation that uses a Registry and custom Selectors to determine when tasks should be executed.Classreactor.bus.timerReactor
ExceptionsStatic Helpers to decorate an exception with an associated data Original design from https://github.Classreactor.core.supportReactor
ExecutorPoweredProcessorA base processor used by executor backed processors to take care of their ExecutorServiceAuthor:Stephane MaldiniClassreactor.core.processorReactor
ExistsActionClassreactor.rx.action.conditionalReactor
FallbackActionClassreactor.rx.action.errorReactor
FanInActionThe best moment of my life so far, not.Classreactor.rx.action.combinationReactor
FanInSubscriptionClassreactor.rx.action.combinationReactor
FanOutSubscriptionA composite subscription used to achieve pub/sub pattern.Classreactor.rx.subscriptionReactor
FilterA Filter is used to filter a list of items.Interfacereactor.bus.filterReactor
FilterActionClassreactor.rx.action.filterReactor
FinallyActionClassreactor.rx.action.passiveReactor
FirstFilterA Filter implementation that returns the first item.Classreactor.bus.filterReactor
FlowControlActionClassreactor.rx.action.controlReactor
FrameClassreactor.io.codecReactor
FrameCodecCodec for decoding data into length-field-based Frames.Classreactor.io.codecReactor
FunctionInterfacereactor.fnReactor
FunctionsHelper methods to provide syntax sugar for working with functional components in Reactor.Classreactor.fnReactor
FutureStreamA Stream that emits a result of a Future and then complete.Classreactor.rx.streamReactor
GroupByActionManage a dynamic registry of substreams for a given key extracted from the incoming data.Classreactor.rx.action.transformationReactor
GroupedStreamThe Stream will complete or fail whever the parent groupBy action terminates itself.Classreactor.rx.streamReactor
GzipCodecClassreactor.io.codec.compressReactor
HashWheelTimerHash Wheel Timer, as per the paper: Hashed and hierarchical timing wheels:Classreactor.fn.timerReactor
HeaderResolverResponsible for extracting any applicable headers from a key.Interfacereactor.bus.selectorReactor
HeadersHeader names common to HTTP requests and responsesAuthor:Sebastien DeleuzeInterfacereactor.io.net.http.modelReactor
HttpChannelA Request/Response ChannelStream extension that provides for several helpers to control HTTP behavior and observe its metadata.Classreactor.io.net.httpReactor
HttpClientThe base class for a Reactor-based Http client.Classreactor.io.net.httpReactor
HttpExceptionAn exception for signalling that an error occurred during a communication over HTTP protocolAuthor:Anatoly KadyshevSee Also:Serialized FormClassreactor.io.net.httpReactor
HttpHeadersInterfacereactor.io.net.http.modelReactor
HttpSelectorA Selector to match against ServerRequestAuthor:Stephane MaldiniClassreactor.io.net.httpReactor
HttpServerBase functionality needed by all servers that communicate with clients over HTTP.Classreactor.io.net.httpReactor
IgnoreErrorActionClassreactor.rx.action.errorReactor
InMemoryQueuePersistorA QueuePersistor implementations that stores items in-memory.Classreactor.io.queueReactor
InsufficientCapacityExceptionException thrown when the it is not possible to dispatch a signal a Dispatcher.Classreactor.core.processorReactor
IOA factory for Reactive basic IO operations such as File read/write, Byte read and Codec decoding.Classreactor.ioReactor
IOStreamsA Streams add-on to work with IO components such as ChronicleStreams.Classreactor.rxReactor
IterableStreamA Stream that emits Iterable values one by one and then complete.Classreactor.rx.streamReactor
JacksonJsonCodecClassreactor.io.codec.jsonReactor
JavaSerializationCodecCodec to transform Java objects into Buffers and visa-versa.Classreactor.io.codecReactor
JsonCodecA codec for decoding JSON into Java objects and encoding Java objects into JSON.Classreactor.io.codec.jsonReactor
JsonPathSelectorClassreactor.bus.selectorReactor
KryoCodecClassreactor.io.codec.kryoReactor
KryoPoolCodecClassreactor.io.codec.kryoReactor
LastActionClassreactor.rx.action.aggregationReactor
LengthFieldCodecA codec that uses a length-field at the start of each chunk to denote the chunk's size.Classreactor.io.codecReactor
LiftStreamA Stream wrapper that defers a parent stream subscription to the child action subscribe() call.Classreactor.rx.streamReactor
LoggerActionClassreactor.rx.action.passiveReactor
MapActionClassreactor.rx.action.transformationReactor
MapStreamA SubscribableMap is an event-driven Map that signals logged operations to its subscribers.Classreactor.rx.streamReactor
MatchAllSelectorClassreactor.bus.selectorReactor
MaterializeActionClassreactor.rx.action.transformationReactor
MergeActionClassreactor.rx.action.combinationReactor
MethodA Model representation of supported HTTP MethodsAuthor:Sebastien Deleuze, Stephane MaldiniClassreactor.io.net.http.modelReactor
MpscDispatcher queue tasks to execute.Classreactor.core.dispatchReactor
MpscLinkedQueueA MultiProduceSingleConsumer impl.Classreactor.core.queue.internalReactor
MpscLinkedQueueNodeClassreactor.core.queue.internalReactor
MultiThreadDispatcherBase implementation for multi-threaded dispatchersSince:1.Classreactor.core.dispatchReactor
MutableSignalClassreactor.core.processorReactor
NamedDaemonThreadFactoryA thread factory that creates named daemon threads.Classreactor.core.supportReactor
NetSelectorsHelper methods for creating Selectors.Classreactor.io.netReactor
NetStreamsA Streams add-on to work with network facilities from reactor-net, e.Classreactor.io.netReactor
NettyChannelHandlerBridgeNetty ChannelInboundHandler implementation that passes data to a Reactor ChannelStream.Classreactor.io.net.impl.nettyReactor
NettyChannelStreamReactorChannel implementation that delegates to Netty.Classreactor.io.net.impl.nettyReactor
NettyClientSocketOptionsClassreactor.io.net.impl.nettyReactor
NettyDatagramServerDatagramServer implementation built on Netty.Classreactor.io.net.impl.netty.udpReactor
NettyHttpChannelClassreactor.io.net.impl.netty.httpReactor
NettyHttpClientA Netty-based TcpClient.Classreactor.io.net.impl.netty.httpReactor
NettyHttpClientHandlerClassreactor.io.net.impl.netty.httpReactor
NettyHttpHeadersClassreactor.io.net.impl.netty.httpReactor
NettyHttpResponseHeadersClassreactor.io.net.impl.netty.httpReactor
NettyHttpServerA Netty-based TcpServer implementationAuthor:Jon Brisbin, Stephane MaldiniClassreactor.io.net.impl.netty.httpReactor
NettyHttpServerHandlerConversion between Netty types and Reactor types (NettyHttpChannel and Buffer).Classreactor.io.net.impl.netty.httpReactor
NettyHttpWSClientHandlerClassreactor.io.net.impl.netty.httpReactor
NettyHttpWSServerHandlerConversion between Netty types and Reactor types (NettyHttpChannel and Buffer).Classreactor.io.net.impl.netty.httpReactor
NettyNativeDetectorClassreactor.io.net.impl.nettyReactor
NettyServerSocketOptionsClassreactor.io.net.impl.nettyReactor
NettyTcpClientA Netty-based TcpClient.Classreactor.io.net.impl.netty.tcpReactor
NettyTcpServerA Netty-based TcpServer implementationAuthor:Jon Brisbin, Stephane MaldiniClassreactor.io.net.impl.netty.tcpReactor
NonBlockingA dispatcher aware componentAuthor:Stephane MaldiniInterfacereactor.core.supportReactor
NotifyConsumerA Consumer that notifies an observable of each value that it has accepted.Classreactor.bus.supportReactor
ObjectSelectorSelector implementation that uses the Object.Classreactor.bus.selectorReactor
ParkWaitStrategyClassreactor.core.dispatch.waitReactor
PassThroughCodecA simple Codec that uses the source object as both input and output.Classreactor.io.codecReactor
PassThroughFilterA Filter implementation that performs no filtering, returning the items as-is.Classreactor.bus.filterReactor
PausableInterfacereactor.fnReactor
PeriodicTimerStreamA Stream that emits 0 after an initial delay and ever incrementing long counter if the period argument is The TimerStream will manage dedicated timers for new subscriber assigned viaClassreactor.rx.streamReactor
PersistentQueueA PersistentQueue is a Queue implementation that delegates the actual storage of the elements in the queue to a QueuePersistor.Classreactor.io.queueReactor
PersistentQueueSpecHelper spec to create a PersistentQueue instance.Classreactor.io.queue.specReactor
PlatformDependentBorrowed from Netty project which itself borrows from JCTools and various other projects.Classreactor.core.internalReactor
PredicateDetermines if the input object matches some criteria.Interfacereactor.fnReactor
PredicatesClassreactor.fnReactor
PredicateSelectorClassreactor.bus.selectorReactor
PromiseA Promise is a stateful event container that accepts a single value or error.Classreactor.rxReactor
PromisesHelper methods for creating Promise instances.Classreactor.rxReactor
PropertiesConfigurationReaderA ConfigurationReader that reads the configuration from properties files and System properties.Classreactor.core.configReactor
ProtobufCodecClassreactor.io.codec.protobufReactor
ProtocolA Model representation of supported HTTP ProtocolsAuthor:Sebastien Deleuze, Stephane MaldiniClassreactor.io.net.http.modelReactor
PublisherFactoryA Reactive Streams Publisher factory which callbacks on start, request and shutdown The Publisher will directly forward all the signals passed to the subscribers and complete when onComplete is called.Classreactor.core.reactivestreamsReactor
PublisherStreamA Publisher wrapper that takes care of lazy subscribing.Classreactor.rx.streamReactor
PushSubscriptionRelationship between a Stream (Publisher) and a Subscriber.Classreactor.rx.subscriptionReactor
QueuePersistor Persistence could be achieved through in-memory solutions like a Map or could be more complex and use a backing datastore.Interfacereactor.io.queueReactor
RandomFilterA Filter implementation that returns a single, randomly selected item.Classreactor.bus.filterReactor
RangeStreamA Stream that emits N Long from the inclusive start value defined to the inclusive end and then Since the stream retains the boundaries in a final field, any SubscriberClassreactor.rx.streamReactor
ReactiveSubscriptionRelationship between a Stream (Publisher) and a Subscriber.Classreactor.rx.subscriptionReactor
ReactorChannelHandlerA ReactorChannel callback that is attached on ReactorPeer or ReactorClient initialization and receives all connected ReactorChannel.Interfacereactor.io.netReactor
ReactorClientA network-aware client that will publish its connection once available to the ReactorChannelHandler passed.Classreactor.io.netReactor
ReactorConfigurationAn encapsulation of configuration for ReactorAuthor:Andy Wilkinson, Jon BrisbinClassreactor.core.configReactor
ReactorFatalExceptionan exception that should stop producing more dataSince:2.Classreactor.core.supportReactor
ReactorPeerAbstract base class that implements common functionality shared by clients and servers.Classreactor.io.netReactor
ReactorProcessorClassreactor.core.processorReactor
ReadableHeadersInterfacereactor.io.net.http.modelReactor
Reconnect to the TcpClient whether or not to attempt to reconnect a broken connection.Interfacereactor.io.netReactor
RecyclableA simple interface that marks an object as being recyclable.Interfacereactor.core.supportReactor
RecyclableNumberClassreactor.allocReactor
RecyclableStringClassreactor.allocReactor
ReduceByKeyActionClassreactor.rx.action.pairReactor
ReferenceA Reference provides access to and metadata about a poolable object.Interfacereactor.allocReactor
ReferenceCountingAllocatorAn implementation of Allocator that uses reference counting to determine when an object be recycled and placed back into the pool to be reused.Classreactor.allocReactor
RegexSelectorA Selector implementation based on the given regular expression.Classreactor.bus.selectorReactor
RegistrationA Registration represents an object that has been registered with a Registry.Interfacereactor.bus.registryReactor
RegistriesClassreactor.bus.registryReactor
Registry use simple keys, they use Selectors to map their objects.Interfacereactor.bus.registryReactor
RepeatActionClassreactor.rx.action.controlReactor
RepeatWhenActionClassreactor.rx.action.controlReactor
ResourceA Resource is a component with an active state, generally consuming hardware capacities (memory, cpu, io).Interfacereactor.fnReactor
ResponseHeadersInterfacereactor.io.net.http.modelReactor
RetryActionClassreactor.rx.action.errorReactor
RetryWhenActionClassreactor.rx.action.errorReactor
RingBufferDispatcherClassreactor.core.dispatchReactor
RingBufferProcessorAn implementation of a RingBuffer backed message-passing Processor.Classreactor.core.processorReactor
RingBufferSubscriberUtilsUtility methods to perform common tasks associated with Subscriber handling when the signals are stored in a com.Classreactor.core.processor.utilReactor
RingBufferWorkProcessorAn implementation of a RingBuffer backed message-passing WorkProcessor.Classreactor.core.processorReactor
RoundRobinFilterA Filter implementation that returns a single item.Classreactor.bus.filterReactor
RouterAn Router is used to route an Object to Consumers.Interfacereactor.bus.routingReactor
SampleActionClassreactor.rx.action.aggregationReactor
ScanActionClassreactor.rx.action.transformationReactor
ScanByKeyActionClassreactor.rx.action.pairReactor
SelectorA Selector is a wrapper around an arbitrary object.Interfacereactor.bus.selectorReactor
SelectorsHelper methods for creating Selectors.Classreactor.bus.selectorReactor
SerializationCodecAbstract base class for Codec Codecs that perform serialization of objects.Classreactor.io.codecReactor
SerializedBroadcasterA Broadcaster is a subclass of Stream which exposes methods for publishing values into the pipeline.Classreactor.rx.broadcastReactor
SerializedSubscriberEnforces single-threaded, serialized, ordered execution of onNext(T), onComplete(), onError(java.Classreactor.core.reactivestreamsReactor
ServerSocketOptionsEncapsulates configuration options for server sockets.Classreactor.io.net.configReactor
SetMembershipSelector objects on set membership.Classreactor.bus.selectorReactor
SignalA domain representation of a Reactive Stream signal.Classreactor.rx.actionReactor
SimpleCachingRegistryA naive caching Registry implementation for use in situations that the default CachingRegistry can't be used due to its reliance on the gs-collections library.Classreactor.bus.registryReactor
SingleThreadDispatcherBase Implementation for single-threaded Dispatchers.Classreactor.core.dispatchReactor
SingleTimerStreamA Stream that emits 0 after an initial delay and then complete The SingleTimerStream will manage dedicated timers for new subscriber assigned viaClassreactor.rx.streamReactor
SingleUseExecutorClassreactor.core.processor.utilReactor
SingleValueStreamA Stream that emits only one value and then complete.Classreactor.rx.streamReactor
SkipActionClassreactor.rx.action.filterReactor
SkipUntilTimeoutClassreactor.rx.action.filterReactor
SnappyCodecClassreactor.io.codec.compressReactor
SocketUtilsNOTE: This code is a copy of that available in the Spring Framework.Classreactor.io.net.tcp.supportReactor
SortActionClassreactor.rx.action.aggregationReactor
SpecSpecifications used to build client and servers.Interfacereactor.io.netReactor
SpecificationExceptionsClassreactor.core.supportReactor
SplitActionClassreactor.rx.action.transformationReactor
SSLEngineSupplierClassreactor.io.net.tcp.sslReactor
SslOptionsHelper class encapsulating common SSL configuration options.Classreactor.io.net.configReactor
StandardCodecsA selection of standard codecs.Classreactor.io.codecReactor
StatusClassreactor.io.net.http.modelReactor
StreamRouterClassreactor.groovy.configReactor
StreamsA public factory to build Stream, Streams provide for common transformations from a few structures such as Iterable or Future to a Stream, in addition to provide for combinatory operations (merge, switchOnNext.Classreactor.rxReactor
StreamStateCallbackActionClassreactor.rx.action.passiveReactor
StreamUtilsA simple collection of utils to assist in various tasks such as DebuggingSince:1.Classreactor.rxReactor
StringCodecClassreactor.io.codecReactor
SubscriberBarrierA Subscriber with an asymetric typed wrapped subscriber.Classreactor.core.reactivestreamsReactor
SubscriberFactoryA Reactive Streams Subscriber factory which callbacks on start, onNext, onError and shutdown The Publisher will directly forward all the signals passed to the subscribers and complete when onComplete is called.Classreactor.core.reactivestreamsReactor
SubscriberWithContextA Subscriber with a typed stateful context.Classreactor.core.reactivestreamsReactor
SubscriptionWithContextA Subscription with a typed stateful context.Classreactor.core.reactivestreamsReactor
Supplier get() or can be created in some other way.Interfacereactor.fnReactor
SuppliersHelper class for working tying Suppliers to Iterables and other types ofCreate a Supplier that aggregates the given list of suppliers by calling each one, inClassreactor.fnReactor
SupplierStreamA Stream that returns the result from Supplier.Classreactor.rx.streamReactor
SwitchActionClassreactor.rx.action.combinationReactor
SynchronousDispatcherA Dispatcher implementation that dispatches events using the calling thread.Classreactor.core.dispatchReactor
SyslogCodecA coded for consuming syslog messages.Classreactor.io.net.codec.syslogReactor
SyslogMessageClassreactor.io.net.codec.syslogReactor
TailRecurseDispatcherA Dispatcher implementation that trampolines events using the calling thread and.Classreactor.core.dispatchReactor
TakeActionClassreactor.rx.action.filterReactor
TakeUntilTimeoutClassreactor.rx.action.filterReactor
TakeWhileActionClassreactor.rx.action.filterReactor
TapA Tap provides a limited window into an event stream.Classreactor.fn.supportReactor
TapAndControlsClassreactor.rx.action.supportReactor
TcpClientThe base class for a Reactor-based TCP client.Classreactor.io.net.tcpReactor
TcpServerBase functionality needed by all servers that communicate with clients over TCP.Classreactor.io.net.tcpReactor
ThreadPoolExecutorDispatcherA Dispatcher that uses a ThreadPoolExecutor with an unbounded queue to dispatch events.Classreactor.core.dispatchReactor
ThrottleRequestActionClassreactor.rx.action.controlReactor
ThrottleRequestWhenActionClassreactor.rx.action.controlReactor
TimeoutActionClassreactor.rx.action.errorReactor
TimerInterfacereactor.fn.timerReactor
TimestampActionClassreactor.rx.action.metricsReactor
TimeUtilsClassreactor.fn.timerReactor
TraceableDelegatingDispatcherAn implementation of Dispatcher that traces activity through it.Classreactor.core.dispatchReactor
TraceableDelegatingFilterClassreactor.bus.filterReactor
TraceableDelegatingRouterClassreactor.bus.routingReactor
TransferClassreactor.io.net.http.modelReactor
TupleA Tuple is an immutable Collection of objects, each of which can be of an arbitrary type.Classreactor.fn.tupleReactor
Tuple1A tuple that holds a single valueAuthor:Jon Brisbin, Stephane MaldiniSee Also:Serialized FormClassreactor.fn.tupleReactor
Tuple2A tuple that holds two valuesAuthor:Jon Brisbin, Stephane MaldiniSee Also:Serialized FormClassreactor.fn.tupleReactor
Tuple3A tuple that holds three valuesAuthor:Jon Brisbin, Stephane MaldiniSee Also:Serialized FormClassreactor.fn.tupleReactor
Tuple4A tuple that holds four valuesAuthor:Jon Brisbin, Stephane MaldiniSee Also:Serialized FormClassreactor.fn.tupleReactor
Tuple5A tuple that holds five valuesAuthor:Jon Brisbin, Stephane MaldiniSee Also:Serialized FormClassreactor.fn.tupleReactor
Tuple6A tuple that holds six valuesAuthor:Jon Brisbin, Stephane MaldiniSee Also:Serialized FormClassreactor.fn.tupleReactor
Tuple7A tuple that holds seven valuesAuthor:Jon Brisbin, Stephane MaldiniSee Also:Serialized FormClassreactor.fn.tupleReactor
Tuple8A tuple that holds eight valuesAuthor:Jon Brisbin, Stephane MaldiniSee Also:Serialized FormClassreactor.fn.tupleReactor
TupleNA tuple that holds 9 or more valuesAuthor:Jon Brisbin, Stephane MaldiniSee Also:Serialized FormClassreactor.fn.tupleReactor
UriPathSelectorA Selector implementation based on a UriPathTemplate.Classreactor.bus.selectorReactor
UriPathTemplateRepresents a URI template.Classreactor.bus.selectorReactor
UriSelectorA Selector implementation that matches on various components of a full URI.Classreactor.bus.selectorReactor
UUIDUtilsHelper for creating random and Type 1 (time-based) UUIDs.Classreactor.core.supportReactor
WaitingMoodA Component with some waiting capacities such as Dispatcher that uses a CPU-friendly strategy (e.Interfacereactor.core.dispatch.waitReactor
WindowActionWindowAction is forwarding events on a steam until is reached, after that streams collected events further, complete it and create a fresh new stream.Classreactor.rx.action.aggregationReactor
WindowShiftActionWindowAction is forwarding events on a steam until is reached, after that streams collected events further, complete it and create a fresh new stream.Classreactor.rx.action.aggregationReactor
WindowShiftWhenActionWindowAction is forwarding events on a steam until is reached, after that streams collected events further, complete it and create a fresh new stream.Classreactor.rx.action.aggregationReactor
WindowWhenActionWindowAction 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.Classreactor.rx.action.aggregationReactor
WorkQueueDispatcherClassreactor.core.dispatchReactor
WrappedSubscriptionClassreactor.rx.subscription.supportReactor
WritableHeadersInterfacereactor.io.net.http.modelReactor
ZeroMQClassreactor.io.net.impl.zmq.tcpReactor
ZeroMQChannelStreamClassreactor.io.net.impl.zmqReactor
ZeroMQClientSocketOptionsClientSocketOptions that include ZeroMQ-specific configuration options.Classreactor.io.net.impl.zmqReactor
ZeroMQServerSocketOptionsServerSocketOptions that include ZeroMQ-specific configuration options.Classreactor.io.net.impl.zmqReactor
ZeroMQTcpClientClassreactor.io.net.impl.zmq.tcpReactor
ZeroMQTcpServerClassreactor.io.net.impl.zmq.tcpReactor
ZeroMQWorkerClassreactor.io.net.impl.zmqReactor
ZipActionClassreactor.rx.action.combinationReactor