|
||||||||||
| PREV NEXT | FRAMES NO FRAMES | |||||||||
CallbackHandler implementation, which delegates
Processor.process(Context) call to appropriate CallbackHandler
method.FilterChain implementation,
which redirects Processor.process(com.sun.grizzly.Context)
call to the AbstractFilterChain.execute(com.sun.grizzly.filterchain.FilterChainContext)AsyncQueueReader implementation, based on the Java NIOAsyncQueueWriter implementation, based on the Java NIOConnection implementation for Java NIO Connections.Processor interface implementation.Reader#read(...) methods.SocketConnectorHandler
interface by preimplementing some of its methods.Transport.Writer#read(...) methods.Connection
Connection
Connection
ConditionListener to listen this StateHolder's
state changes.
ExceptionHandler to handle errors, occurred during the
Transport execution.
ExceptionHandler to handle errors, occurred during the
Transport execution.
StreamReader, which could be requested for data source
address.StreamWriter, which can send data to different destinations.Processor execution,
so it can release associated resources.
Processor execution,
so it can release associated resources.
Buffer of the required size.
Buffer of required size, which is actually sliced from
large preallocated ByteBuffer pool.
Buffer of required size.
Buffer of the required size.
ByteBuffer of required size.
IOEventMask implementationIOEventMask, with specific enabled interests
AsyncQueueReader, AsyncQueueWriter.AsyncQueue processors.ProcessorSelector implementation, which is aware of
Connection asynchronous read/write queues, and is responsible
for adding corresponding Processor.AsyncQueueProcessor, which implements asynchronous read queue.AsyncQueue element unitAsyncQueueProcessor, which implements asynchronous write queue.AsyncQueue read element unitAsyncQueue write element unitConnection to this SSLStreamReader.
AttributeHolder
instances.Attributes.Attributes.AttributeHolder, where
application can store Attributes.Processor.
Processor.
SSLHandshaker implementation.ByteBuffer was taken as base for Grizzly
Buffer interface, but Buffer has several extensions:
it's possible to prepend some data to a Buffer and release Buffer, when
it's not required any more.ByteBuffers.ByteBufferManager implementation, which doesn't allocate
ByteBuffers each time allocate is called.Buffer implementation, which uses the ByteBuffer underneath.Processor, where
each IOEvent could be processed in separate method.CallbackHandler interface.Connection was cancelled.
Connection was cancelled.
ByteBuffer pool.
ProcessorSelector implementation, which acts like wrapper for chain
of ProcessorSelectors.AsyncQueueWriter, when message
could not be written directly, and will be added to the queue.
Connection
StreamWriter and make sure all data was flushed.
StreamWriter and make sure all data was flushed.
TransportFactory and release all resources.
Connection was completed.
Connection was completed.
CompletionHandler interface, which has empty
implementation for all callback methods.ObjectPool implementation based on LinkedTransferQueueSSLEngine, using current configurator settings
Transport mode.
Connection mode.
Transport mode.
SocketChannel according the transport settings
Connection.
Connection.
Connection, representing socket.
SocketAddress and returns Connection, representing socket.
SocketAddress and returns Connection, representing socket.
Buffer content as String
Context itself.
Context
Context
FilterChain instance.
Context instance.
SSLEngine, basing on current settings.
Transport.
Transport.
Executor, which executes a tasks in a current ThreadByteBuffer from which views
will be created.
AttributeBuilder implementation.AttributeBuilder used by all Transports.
FilterChain implementationFilter processing method to process occured
IOEvent.DefaultFilterChain codec implementation.MemoryManager, used in Grizzly.MemoryManager used by all Transports.
ByteBufferWrapper implementation, which supports triming.ProcessorSelector implementation, which uses
Connection's Processor preferences.Transports.
ScheduledThreadPoolExecutorSelectorHandlerThreadPoolExecutorTransports.
SSLStreamReader into Connection.
Filter implementationAttribute value.
FilterChain
FilterChain
IOEvent on this FilterChain.
Filter in chain to process IOEvent.
ProcessorRunnable task.
ProcessorRunnable task.
ProcessorRunnable task.
ProcessorRunnable task.
ProcessorRunnable task.
FilterChainFactory, responsible for creating FilterChain
instances
Connection was failed.
Connection was failed.
FilterChainContext.Filter processing methods.FilterChain Context implementation.FilterChainContext object pool.
FilterChains.FilterChains.ProcessorSelector implementation, which delegates processing
of IOEvent to the FilterChain.Buffer.
Buffer.
IOEvent on the Connection
IOEvent on the Connection
IOEvent on the Connection
Future implementation, which uses synchronization
Object to synchronize during the lifecycle.Future implementation, which uses ReentrantLock
to synchronize during the lifecycle.AttributeHolder.
AttributeStorage.
IOEvent processing.
Transport associated AttributeBuilder, which will
be used by Transport and its Connections to store custom
Attributes.
Transport associated AttributeBuilder, which will
be used by Transport and its Connections to store custom
Attributes.
Set of attribute names.
Set of attribute names.
Set of attribute names.
AttributeHolder.
AttributeHolder), associated with the processing
Context.
Buffer.
Buffer, where the StreamWriter buffers
output.
Buffer.
Buffer, where the StreamWriter buffers
output.
Buffer size to be used for StreamReader
read operations.
Buffer size to be used for StreamWriter
write operations.
Buffer size to be used for StreamReader
read operations.
Buffer size to be used for StreamWriter
write operations.
FilterChain Codec.
Connection.
Connection.
Connection data were read from.
Connection, associated with the result.
Connection this StreamReader belongs to.
Connection this StreamWriter belongs to.
Connection this StreamReader belongs to.
Connection this StreamWriter belongs to.
Connection this StreamWriter belongs to.
Connection data were read from.
Context.
Filter, which is currently running.
Filter in
the FilterChainContext.filters list.
AttributeBuilder, used by all Transports.
MemoryManager, used by all Transports.
Transports.
Transports.
ProcessorResult description.
List of executed Filters.
FilterChainFactory, which
created this FilterChain.
FilterChainFactory, which
created this FilterChain.
FilterChain, which is executing this Filter
on the current thread.
FilterChain, which runs the Filter.
FilterChain instance.
FilterChainFactory, responsible to construct
FilterChain instance.
FilterChain instance pattern.
FilterChain pattern, which is chain instance.
List of Filters.
Filters.
IndexedAttributeAccessor, which will make Attribute
access as fast as access to array element.
IndexedAttributeAccessor for accessing Attributes
by index.
TransportFactory instance.
Selector polling etc.
Selector polling etc.
NextAction implementation, which instructs FilterChain to
process next Filter in chain.
NextAction implementation, which instructs FilterChain to
process next Filter in chain.
NextAction implementation, which instructs FilterChain to
process next Filter in chain.
IOEvent.
IOEvent.
org.apache.catalina.valves.CertificateValve
SelectionKeys, which were selected last time.
SelectionKeys, which should be selected
from a Selector, to make it apply LeaderFollowerStrategy.
Transport associated MemoryManager, which will
be used by the Transport, its Connections and by during
processing I/O events, occurred on Connections.
Transport associated MemoryManager, which will
be used by the Transport, its Connections and by during
processing I/O events, occurred on Connections.
Filter, which is aware of Transport
specifics; knows how to read/write from/to Transport.
Transport name.
Transport name.
Filter in
NextAction.getFilters() list, which should be executed next.
StreamReader data source.
PostProcessor, which will be called after
Processor will finish its execution to finish IOEvent processing.
PostProcessor, which will be called after
Processor will finish its execution to finish IOEvent processing.
Processor, which will process Connection
I/O events in case, if Connection doesn't have own
Processor preferences.
Processor, which will process Connection
I/O events.
Processor, which is responsible to process
the IOEvent.
Processor, which is responsible to process
the IOEvent.
Processor to process IOEvent, occuring
on connection phase.
Processor, which will process Connection
I/O events in case, if Connection doesn't have own
Processor preferences.
ProcessorRunnable task instance.
ProcessorSelector, which will be used to get
Processor to process Connection I/O events, in case if
this Transport's Processor is null and
Connection doesn't have neither preferred Processor
nor ProcessorSelector.
ProcessorSelector, which will be used to get
Processor to process Connection I/O events, in case if
this Connection's Processor is null.
ProcessorSelector, which will be used to get
Processor to process I/O events, occuring on connection phase.
ProcessorSelector, which will be used to get
Processor to process Connection I/O events, in case if
this Transport's Processor is null and
Connection doesn't have neither preferred Processor
nor ProcessorSelector.
Buffers, which will be allocated for
reading data from Transport's Connections.
Buffers, which will be allocated for
reading data from Connection.
Buffers, which will be allocated for
reading data from Transport's Connections.
AsyncQueueReader implementation.
NextAction implementation, which is expected only on post processing
phase.
Transport state controller.
Transport state controller.
StateHolder
NextAction implementation, which instructs FilterChain
to stop executing phase and start post executing filters.
Strategy implementation, which will be used by
Transport to process IOEvent.
Strategy implementation, which will be used by
Transport to process IOEvent.
Connection StreamReader, to read data from the
Connection.
StreamReader, associated with processing.
Filter, which is aware of Transport
specifics; knows how to read/write from/to Transport
specific Connection streams.
Connection StreamWriter, to write data to the
Connection.
StreamWriter, associated with processing.
NextAction, which instructs FilterChain to suspend filter
chain execution, both execute and post-execute phases.
MemoryManager.
Transport, to which this Connection belongs to.
Transport specific transport filter.
take or poll.
SelectionKeys, which should be selected
from a Selector, to make it apply WorkerThreadStrategy.
Buffers, which will be allocated for
writing data to Transport's Connections.
Buffers, which will be allocated for
writing data to Connection.
Buffers, which will be allocated for
writing data to Transport's Connections.
AsyncQueueWriter implementation.
Transport's specific transport
filter.
Transport's specific transport
filter.
Transport's specific transport
filter.
Transport's specific transport
filter.
FilterChainContext default StreamReader and
StreamWriter with SSL aware ones.
Transport's specific transport
filter.
Connection's
SSLStreamReader and SSLStreamWriter.
Connection's
SSLStreamReader and SSLStreamWriter.
true if there is at least one consumer waiting
to dequeue an element via take or poll.
AttributeHolders.
AttributeHolder supports
indexed Attribute access.AttributeHolder, which supports indexed access to stored
Attributes.IndexedAttributeAccessor implementation.Context with task's settings.
Readable, so it is possible to
customize reading process.
Readable.read(...).Connection.Transport mode.
Connection mode.
StreamReader mode.
StreamReader mode.
StreamReader mode.
StreamReader mode.
StreamReader mode.
StreamReader mode.
Transport mode.
SSLEngine be configured to work in client mode.
TransportFactory has been closed, or
false otherwise.
ProcessorExecutor uses current
Thread to run I/O event processing, or false otherwise.
ByteBuffers, or false otherwise.
Processor interested in processing the i/o event
Processor interested in processing the i/o event
Processor interested in processing the i/o event
Processor interested in processing the i/o event
Processor interested in processing the i/o event
StandaloneProcessor is not interested in any IOEvent.
Connection open and ready.
AsyncQueue,
associated with the Connection.
AsyncQueue,
associated with the Connection.
AsyncQueue,
associated with the Connection.
AttributeHolder.
AttributeStorage.
Thread after task will be
executed.
Thread after task will be
executed.
Thread after task will be
executed.
Thread after task will be
executed.
Thread after task will be
executed.
ByteBuffer pool.
ByteBuffer.
Strategy, which executes Processors in a current threads, and
resumes selector thread logic in separate thread.ArrayList, which internaly uses array offset, to
avoid redundant array shifting when executing add, remove methods.LinkedTransferQueue.
LinkedTransferQueue
initially containing the elements of the given collection,
added in traversal order of the collection's iterator.
FilterChain facade, which implements all the List related
methods.FilterBuffers.AsyncQueueWriter, when message
could not be written directly, and will be added to the queue.AttributeHolders.
AttributeHolder implementation, which doesn't support indexed access
to Attributes.FilterChain,
how it should continue filter chain execution.Future, using which it's possible check if
StreamReader has required amound of bytes available
for reading reading.
Future, using which it's possible check if
StreamReader has required amound of bytes available
for reading reading.
Future, using which it's possible check if
StreamReader has required amound of bytes available
for reading reading.
Future, using which it's possible check if
StreamReader has required amound of bytes available
for reading reading.
Future, using which it's possible check if
StreamReader meets specific Condition.
Future, using which it's possible check if
StreamReader meets specific Condition.
Future, using which it's possible check if
StreamReader meets specific Condition.
Future, using which it's possible check if
StreamReader meets specific Condition.
Transport execution.
Transport execution.
Attribute initializer.AttributeHolder.
AttributeHolder), associated with the processing
Context.
Context to the ObjectPool it was
taken from.
IOEvent.ACCEPTED event occured on
Connection.
IOEvent.ACCEPTED event occured on
Connection.
Connection has been closed,
to let processor release a connection associated resources.
IOEvent.CLOSED event occured on
Connection.
IOEvent.CLOSED event occured on
Connection.
Connection has been closed,
to let processor release a connection associated resources.
Connection has been closed,
to let processor release a connection associated resources.
IOEvent.CONNECTED event occured on
Connection.
IOEvent.CONNECTED event occured on
Connection.
IOEvent.READ event occured on
Connection.
IOEvent.READ event occured on
Connection.
IOEvent.WRITE event occured on
Connection.
IOEvent.WRITE event occured on
Connection.
FilterChainFactory implementation, which is able to create new
FilterChain instances by the given pattern.Filter#handleAccept(com.sun.grizzly.FilterChainContext) method of
this Filter instance.
Filter#handleAccept(com.sun.grizzly.FilterChainContext) method of
this Filter instance.
Transport's specific
transport filter.
Filter#handleClose(com.sun.grizzly.FilterChainContext) method of
this Filter instance.
Filter#handleClose(com.sun.grizzly.FilterChainContext) method of
this Filter instance.
Transport's specific
transport filter.
Filter#handleClose(com.sun.grizzly.FilterChainContext) method of
this Filter instance.
Filter#handleConnect(com.sun.grizzly.FilterChainContext) method of
this Filter instance.
Filter#handleConnect(com.sun.grizzly.FilterChainContext) method of
this Filter instance.
Transport's specific
transport filter.
Filter to post process
IOEvent.
Processor will
complete its execution.Filter#handleRead(com.sun.grizzly.FilterChainContext) method of
this Filter instance.
Filter#handleRead(com.sun.grizzly.FilterChainContext) method of
this Filter instance.
Transport's specific
transport filter.
Filter#handleRead(com.sun.grizzly.FilterChainContext) method of
this Filter instance.
Filter#handleWrite(com.sun.grizzly.FilterChainContext) method of
this Filter instance.
Filter#handleWrite(com.sun.grizzly.FilterChainContext) method of
this Filter instance.
Transport's specific
transport filter.
Filter#handleWrite(com.sun.grizzly.FilterChainContext) method of
this Filter instance.
ObjectPool to store and reuse
Context instances - this method will be called before
Context will be polled from pool.
Strategy for processing IOEvent, occured on the
Connection.
Strategy for processing IOEvent, occured on the
Connection.
Strategy for processing IOEvent, occured on the
Connection.
Strategy for processing IOEvent, occured on the
Connection.
Strategy for processing IOEvent, occured on the
Connection.
IOEvent processing to appropriate
CallbackHandler method.
AbstractFilterChain.execute(com.sun.grizzly.filterchain.FilterChainContext)
StandaloneProcessor.isInterested(IOEvent) returns false for any
IOEvent.
ProcessorRunnable.Processor execution.ProcessorResult.Runnable task, which encapsulates Processor execution
information and actually runs Processor
to process occured IOEvent.Processor, which will process IOEvent, occurred on the
ConnectionProcessor, which redirects all calls to internal Processor
instance;StreamReader chain into this
StreamReader
Buffer.Readable and InputStreamBuffer and
makes next available Buffer current.
Buffer and
makes next available Buffer current.
Connection to a Buffer.Readable.Future implementation with the specific unmodifiable result.Future.
Future with the result.
Future.
Buffer to a required size.
Buffer to a required size.
Buffer to a required size.
Buffer to a required size.
ObjectPool to store and reuse
Context instances - this method will be called before
Context will be offered to pool.
FilterChain instance.
Buffer.
Buffer.
AttributeHolder.
AttributeStorage.
ExceptionHandler from the list of Transport
ExceptionHandlers.
ExceptionHandler from the list of Transport
ExceptionHandlers.
Strategy, which executes Processors in a current thread.Processor if required
Processor, which will process connection event.
Processor, which will process connection event.
FilterChain instance, if it's interested in processing
passed IOEvent, or null otherwise.
Processor, which will process connection event.
Processor was found to process
IOEvent.
SelectionKeyHandler implementations are responsible for handling
SelectionKey life cycle events.SelectorHandlerAttributeHolder.
AttributeStorage.
IOEvent processing.
Transport associated AttributeBuilder, which will
be used by Transport and its Connections to store custom
Attributes.
Transport associated AttributeBuilder, which will
be used by Transport and its Connections to store custom
Attributes.
StreamReader mode.
StreamReader mode.
StreamReader mode.
StreamReader mode.
StreamReader mode.
StreamReader mode.
Buffer size to be used for StreamReader
read operations.
Buffer size to be used for StreamWriter
write operations.
Buffer size to be used for StreamReader
read operations.
Buffer size to be used for StreamWriter
write operations.
SSLEngine to be configured to work in client mode.
Connection.
Connection.
Context.
Filter, which is currently running.
Filter in
the FilterChainContext.filters list.
AttributeBuilder, used by all Transports.
MemoryManager, used by all Transports.
Transports.
Transports.
ByteBuffers, or false otherwise.
List of executed Filters.
FilterChainFactory, responsible to construct
FilterChain instance.
FilterChain instance pattern.
FilterChain pattern, which is chain instance.
List of Filters.
Attribute, to make access to its value
as fast as array[index].
TransportFactory instance.
Processor is interested in
Processor is interested in
Processor is interested in
Processor is interested in
Processor is interested in
Selector polling etc.
Selector polling etc.
IOEvent.
IOEvent.
SelectionKeys, which should be selected
from a Selector, to make it apply LeaderFollowerStrategy.
Transport associated MemoryManager, which will
be used by the Transport, its Connections and by during
processing I/O events, occurred on Connections.
Transport associated MemoryManager, which will
be used by the Transport, its Connections and by during
processing I/O events, occurred on Connections.
Transport name.
Transport name.
PostProcessor, which will be called after
Processor will finish its execution to finish IOEvent processing.
PostProcessor, which will be called after
Processor will finish its execution to finish IOEvent processing.
Processor, which will process Connection
I/O events in case, if Connection doesn't have own
Processor preferences.
Processor, which will process Connection
I/O events.
Processor, which is responsible to process
the IOEvent.
Processor, which is responsible to process
the IOEvent.
Processor to process IOEvent, occuring
on connection phase.
Processor, which will process Connection
I/O events in case, if Connection doesn't have own
Processor preferences.
ProcessorRunnable task instance.
ProcessorSelector, which will be used to get
Processor to process Connection I/O events, in case if
this Transport's Processor is null and
Connection doesn't have neither preferred Processor
nor ProcessorSelector.
ProcessorSelector, which will be used to get
Processor to process Connection I/O events, in case if
this Connection's Processor is null.
ProcessorSelector, which will be used to get
Processor to process I/O events, occuring on connection phase.
ProcessorSelector, which will be used to get
Processor to process Connection I/O events, in case if
this Transport's Processor is null and
Connection doesn't have neither preferred Processor
nor ProcessorSelector.
Buffers, which will be allocated for
reading data from Transport's Connections.
Buffers, which will be allocated for
reading data from Connection.
Buffers, which will be allocated for
reading data from Transport's Connections.
Strategy implementation, which will be used by
Transport to process IOEvent.
Strategy implementation, which will be used by
Transport to process IOEvent.
StreamReader, associated with processing.
StreamWriter, associated with processing.
Transport with factory default settings.
SelectionKeys, which should be selected
from a Selector, to make it apply WorkerThreadStrategy.
Buffers, which will be allocated for
writing data to Transport's Connections.
Buffers, which will be allocated for
writing data to Connection.
Buffers, which will be allocated for
writing data to Transport's Connections.
FilterChainFactory implementation, which operates just with a single
FilterChain instance.ByteBuffer of required size from big chunk.
Codec, which is able to encode/decode custom protocol message
by their class structure.Buffer to a custom protocol
message.Buffer.Buffer to StringBuffer to StringSocket based Transports, which are able
to bind server Socket to specific address and listen for incoming
data.Transformers.SSLContext.SSLEngine.Filter to operate with SSL encrypted data.SSLEngineConfigurator.
SSLEngineConfigurator and
custom SSLHandshaker
Transformer, which works as the decoder on the SSL handshaking phase.Transformer, which works as the encoder on the SSL handshaking phase.AttributeHolder.StreamReader implementation, which work like a wrapper over
existing StreamReader.StreamWriter implementation, which work like a wrapper over
existing StreamWriter.Processor, which is not interested in processing I/O events.ProcessorSelector, which doesn't add any Processor to process
occurred IOEvent.StateHolder.
StateHolder.
StateHolder.
ProcessorRunnable task will be run: in current thread, worker thread.Buffer to StringBuffer to StringAsyncQueueReader implementation, based on
the Java NIOAsyncQueueWriter implementation, based on
the Java NIOConnection implementation
for the TCPNIOTransportTCPNIOTransport's transport Filter implementationtake or poll.
BlockingQueue in which producers may wait for consumers
to receive elements.Transports.Filter implementation, which should work with any
Transport.TransportFilter.Mode.Stream mode.
false
without enqueuing the element.
take or poll.
AsyncQueueReader implementation, based on
the Java NIOAsyncQueueWriter implementation, based on
the Java NIOConnection implementation
for the UDPNIOTransportUDPNIOTransport's transport Filter implementationConnection implementation
for the UDPNIOTransportUDPNIOTransport's transport Filter implementationTransport connection.
Transport connection.
Transport connection.
Transport connections.
SSLContextConfigurator configuration.
SSLContextConfigurator configuration.
ReferenceThreadPool threads should implementRunnable in
one of the ThreadPool's worker threadStrategy, which executes Processors in worker thread.Buffer, which wraps the byte array.
Buffer, which wraps the part of byte array with
specific offset and length.
Buffer, which wraps the String.
Buffer, which wraps the String with the specific
Charset.
Buffer, which wraps the ByteBuffer.
Buffer, which wraps the String.
Buffer, which wraps the String with the specific
Charset.
Buffer, which wraps the byte array.
Buffer, which wraps the part of byte array with
specific offset and length.
Buffer, which wraps the ByteBuffer.
Buffer, which wraps the byte array.
Buffer, which wraps the part of byte array with
specific offset and length.
Buffer, which wraps the String.
Buffer, which wraps the String with the specific
Charset.
Buffer, which wraps the ByteBuffer.
MemoryManagers, which implement this interface, are able to convert
frequently used Java buffer types to Grizzly Buffer.Buffer.Writable and OutputStreamBuffer to the specific address.
Buffer to the specific address.
Buffer is empty
Buffer to the StreamWriter.
Buffer to the StreamWriter.
Buffer
to Connection.Writable.StreamReader available data to this StreamWriter
This method will make possible direct writing from StreamReader,
avoiding Buffer copying.
StreamReader available data to this StreamWriter
This method will make possible direct writing from StreamReader,
avoiding Buffer copying.
|
||||||||||
| PREV NEXT | FRAMES NO FRAMES | |||||||||