|
||||||||||
| PREV NEXT | FRAMES NO FRAMES | |||||||||
FilterChain implementation,
which redirects Processor.process(org.glassfish.grizzly.Context)
call to the FilterChain.execute(org.glassfish.grizzly.filterchain.FilterChainContext)MemoryManager abstraction to provide utilities that may be useful
across different MemoryManager implementations.AbstractMemoryManager using a max buffer size
of 65536.
AbstractMemoryManager using the specified
buffer size.
Buffer
implementation can be trimmed.AsyncQueueReader implementation, based on the Java NIOAsyncQueueWriter implementation, based on the Java NIOReader methods.SocketConnectorHandler
interface by pre-implementing some of its methods.ExecutorService implementation.Transport.Writer methods.Connection.
Connection
Connection
Connection activity and closing
Connection ones it becomes idle for certain amount of time.Connection.CloseListener, which will be notified once Connection
will be closed.
Connection.CloseListener, which will be notified once Connection
will be closed.
FilterChainContext.CompletionListener, which will be notified, when
this FilterChainContext processing will be completed.
FilterChainContext.CopyListener, which will be notified, right after
this FilterChainContext.copy() is called.
ConnectionProbe, which will be notified about
Connection life-cycle events.
Buffer of the required size.
Buffer of the required size.
Buffer of the required size.
Buffer at least of the provided size.
Buffer at least of the provided size.
Buffer at least of the provided size.
ByteBuffer of required size.
ByteBuffer of required size.
Buffer using the provided ThreadLocalPool.
Buffers.
Buffers.
Buffer that shares this buffer's
content.
AsyncQueue processors.AsyncQueueReader, AsyncQueueWriter.AsyncQueue, which implements asynchronous read queue.AsyncQueue element unitAsyncQueue, which implements asynchronous write queue.AsyncQueue read element unitAsyncQueue write element unitAttributeHolder
instances.Attributes.Attributes.AttributeHolder, where
application can store Attributes.AsyncQueueWriter.setMaxPendingBytesPerConnection(int) means
the async write queue size will be configured automatically per
NIOConnection depending on connections write buffer size.
Filter processing methods.PortRange.
PortRange.
PortRange.
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.InputStream implementation over Grizzly Buffer.InputStream over Grizzly Buffer.
InputStream over Grizzly Buffer.
OutputStream implementation to write to a Buffer.Buffer as initial.
Buffer as initial.
Buffers.FilterChainBuilder, responsible for creating FilterChain
instances
TCPNIOConnectorHandler builder.
UDPNIOConnectorHandler builder.
Buffer bytes from Buffer.position() to Buffer.limit()
and lets CompositeBuffer.BulkOperation examine/change the buffer content;
Buffer bytes from position to limit
and lets CompositeBuffer.BulkOperation examine/change the buffer content;
Buffer bytes from Buffer.position() to Buffer.limit()
and lets CompositeBuffer.BulkOperation examine/change the buffer content;
Buffer bytes from position to limit
and lets CompositeBuffer.BulkOperation examine/change the buffer content;
ByteBuffers.ByteBufferManager JMX object.ByteBufferWrapper implementation, which supports trimming.Buffer implementation, which uses the ByteBuffer underneath.ProcessorSelector implementation, which acts like wrapper for chain
of ProcessorSelectors.Connection was reported as connected.
FilterChain.AsyncQueueWriter, when message
could not be written directly, and will be added to the queue.
Buffer.
Buffer.
Connection
Connection
StreamWriter and make sure all data was flushed.
StreamWriter and make sure all data was flushed.
StreamWriter and make sure all data was flushed.
Connection silently, no notification required on
completion or failure.
SelectorRunner pool's
default core and max pool size.
SSLEngine, using current configurator settings
Transport mode.
Connection mode.
Transport mode.
SocketAddress and returns Connection, representing socket.
SocketAddress and returns Connection, representing socket.
SocketAddress and returns Connection, representing socket.
SocketAddress and returns Connection, representing socket.
Connection, representing socket.
SocketAddress and returns Connection, representing socket.
SocketAddress and returns Connection, representing socket.
SocketAddress and returns Connection, representing socket.
SocketAddress and returns Connection, representing socket.
Connection.
Connection.
Connection, representing socket.
SocketAddress and returns Connection, representing socket.
SocketAddress and returns Connection, representing socket.
SocketAddress and returns Connection, representing socket.
SocketAddress and returns Connection, representing socket.
Connection, representing socket.
Connection implementations.ConnectionProbe adapter that provides no-op implementations for
all interface methods allowing easy extension by the developer.Future.
Future with the result.
Future.
SafeFutureImpl.
Future.
JmxObject, which represents this object.
Future, which has a preset result.
Future, which has a preset failure.
FutureImpl implementation.
SSLEngine, basing on current settings.
FutureImpl implementation.
AttributeBuilder implementation used by all created builder
instances.
ThreadLocalPools.
MemoryManager implementation used by all created builder
instances.
SelectionKeyHandler used by all created builder instances.
SelectorHandler used by all created builder instances.
AttributeBuilder implementation.FilterChain implementationProcessorSelector implementation, which uses
Connection's Processor preferences.SelectorHandlerJmxObject.
SelectorRunner's Selector.
SelectorRunner's Selector.
Buffer that shares this buffer's content.
Filter implementationCompletionHandler interface.IOEventProcessingHandler implementation.Attribute value.
FilterChain
FilterChain
IOEvent on this FilterChain.
Filter in chain to process IOEvent.
Filter, using specific FilterExecutor and
FilterChainContext.
SelectorRunner will invoke this
method to allow the strategy implementation to decide how the
IOEvent will be handled.
SelectorRunner will invoke this
method to allow the strategy implementation to decide how the
IOEvent will be handled.
FileChannel.transferTo(long, long, java.nio.channels.WritableByteChannel)
for use with Grizzly 2.0 AsyncQueueWriter.FileTransfer instance backed by the specified
File.
FileTransfer instance backed by the specified
File.
Buffer with the specific byte value.
Buffer's part [position, limit) with the specific byte value starting from the
Buffer's position won't be changed.
ByteBuffer with the specific byte value.
ByteBuffer's part [position, limit) with the specific byte value starting from the
ByteBuffer's position won't be changed.
FilterChainContext.FilterChainBuilder.StatelessFilterChainBuilder implementation, which is responsible for
constructing FilterChains.FilterChain Context implementation.FilterChainContext processing is complete.FilterChainContext.copy() is called.FilterChains.ProcessorSelector implementation, which delegates processing
of IOEvent to the FilterChain.Filter processing method to process occurred
IOEvent.IOEvent on the Connection
Future interface, which has full control over the state.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.
AttributeHolder.
Buffer.
Buffer.
Buffer (not flipped).
Appender which knows how to append Buffers.
Charset's CharsetDecoder.
Charset's CharsetEncoder.
Connection.
Connection, associated with the current processing.
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 data were read from.
Connections.
Connections.
ProcessorResult extra data.
FilterChain, which is executing this Filter
on the current thread.
FilterChain, which runs the Filter.
IndexedAttributeAccessor, which will make Attribute
access as fast as access to array element.
IndexedAttributeAccessor for accessing Attributes
by index.
Context this filter context wraps.
NextAction implementation, which instructs FilterChain to
process next Filter in chain.
NextAction implementation, which instructs FilterChain to
process next Filter in chain.
IOEvent.
IOStrategy implementation, which will be used by
Transport to process IOEvent.
IOStrategy implementation, which will be used by
Transport to process IOEvent.
org.apache.catalina.valves.CertificateValve
SelectionKeys, which were selected last time.
Transport associated MemoryManager, which will
be used by the Transport, its Connections and by during
processing I/O events, occurred on Connections.
FilterChainContext.getConnection().getTransport().getMemoryManager().
Transport associated MemoryManager, which will
be used by the Transport, its Connections and by during
processing I/O events, occurred on Connections.
MonitoringConfig.
JmxMonitoringConfig.
JmxMonitoringConfig.
MonitoringConfig.
MonitoringConfig.
JmxMonitoringConfig.
JmxMonitoringConfig.
MonitoringConfig.
ConnectionProbe, which are registered on the Connection.
Transport name.
Transport name.
Processor to process IOEvent, occurring
on connection phase.
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 will process Connection
I/O events in case, if Connection doesn't have own
Processor preferences.
ProcessorSelector, which will be used to get
Processor to process I/O events, occurring 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.
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 Connection I/O events, in case if
this Transport's Processor is null and
Connection doesn't have neither preferred Processor
nor ProcessorSelector.
PushBackHandler passed along with one of the
Writer's write(...) method call.
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.
AsyncQueueReader implementation.
AsyncQueueReader implementation.
Reader to read data from the Connection.
Reader implementation, depending on the requested mode.
Reader to read data from the Connection.
Reader implementation, depending on the requested mode.
Reader to read data from the Connection.
Reader implementation, depending on the requested mode.
NextAction, which instructs FilterChain to rerun the
filter.
SelectorProvider to be used by this transport.
Transport state controller.
Transport state controller.
StateHolder
NextAction implementation, which instructs FilterChain
to stop executing phase.
NextAction implementation, which instructs FilterChain
stop executing phase.
NextAction implementation, which instructs FilterChain
stop executing phase.
NextAction implementation, which instructs FilterChain
stop executing phase.
Connection StreamReader, to read data from the
Connection.
Connection StreamWriter, to write data to the
Connection.
NextAction, which instructs FilterChain to suspend filter
chain execution.
FilterChainContext.getForkAction()
Transport, to which this Connection belongs to.
TransportFilter related context.
Filter, which is aware of Transport
specifics; knows how to read/write from/to Transport
specific Connection streams.
Transport specific transport filter.
take or poll.
IOStrategy) to let kernel threads continue
their job.
IOStrategy) to let kernel threads continue
their job.
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.
AsyncQueueWriter implementation.
AsyncQueueWriter implementation.
Writer to write data to the Connection.
Writer implementation, depending on the requested mode.
Writer to write data to the Connection.
Writer implementation, depending on the requested mode.
Writer to write data to the Connection.
Writer implementation, depending on the requested mode.
Future implementation, which might be recycled and reused.Transformer which decodes data
represented in the GZIP format.Transformer which encodes plain data to
the GZIP format.Filter which
encodes/decodes data in the GZIP format.Transport's specific transport
filter.
Connection.
Transport's specific transport
filter.
Transport's specific transport
filter.
Connection.
Connection.
Transport's specific transport
filter.
FilterChainContext.getMessage() and,
as the result, produces a Buffer with a plain data.
Transport's specific transport
filter.
FilterChainContext.getMessage() and,
as the result, produces a Buffer with a GZIP compressed data.
Transport's specific transport
filter.
true if this message has data remaining to be
written.
true if this message has data remaining to be
written.
true if there is at least one consumer waiting
to dequeue an element via take or poll.
Buffer implementation, which uses the ByteBuffer underneath.WrapperAware MemoryManager implementation for
managing HeapBuffer instances.HeapMemoryManager JMX object.Connection activity and closing
Connection ones it becomes idle for certain amount of time.AttributeHolders.
AttributeHolder supports
indexed Attribute access.AttributeHolder, which supports indexed access to stored
Attributes.IndexedAttributeAccessor implementation.FilterChain, associated with the
Connection.
Filter in chain, which type is filterType, or
-1 if the Filter of required type was not found.
Filter in chain, which type is filterType, or
-1 if the Filter of required type was not found.
Readable, so it is possible to
customize reading process.
Readable.Connection.IOEvent processing handler, which will be notified about changes
in IOEvent processing statuses.Runnable task will be run: in current thread, worker thread.Transport mode.
Transport mode.
SSLEngine be configured to work in client mode.
ByteBuffers, or false otherwise.
FileTransfer),
which is not loaded in memory.
FileTransfer),
which is not loaded in memory.
FileTransfer),
which is not loaded in memory.
FileTransfer),
which is not loaded in memory.
FileTransfer),
which is not loaded in memory.
Processor interested in processing the i/o event
Processor interested in processing the i/o event
StandaloneProcessor is not interested in any IOEvent.
AsyncQueueWriter.Reentrant object, and next write
will happen in the separate thread.
Connection open and ready.
AsyncQueueWriter, optimized to be used in connection multiplexing
mode, or false otherwise.
AsyncQueue,
associated with the Connection.
AsyncQueue,
associated with the Connection.
AsyncQueue,
associated with the Connection.
AttributeHolder.
AttributeStorage.
IOStrategy, which executes Processors in a current threads, and
resumes selector thread logic in separate thread.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.Localizable into a message
by using a configured Locale.FilterCharset by name.
Throwable by IOException.
MemoryManager JMX object.MemoryManager monitoring probe.MemoryProbe adapter that provides no-op implementations for
all interface methods allowing easy extension by the developer.Buffers.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.Selector using passed SelectorProvider.
FilterChain,
how it should continue filter chain execution.Connection implementation for Java NIO Connections.NIOTransport implementations
as well as providing basic configuration for IOStrategies and
thread pools.NIOTransport using the given
transportClass and IOStrategy.
Future, using which it's possible check if
StreamReader has required amount of bytes available
for reading reading.
Future, using which it's possible check if
StreamReader has required amount of bytes available
for reading reading.
Future, using which it's possible check if
StreamReader has required amount of bytes available
for reading reading.
Future, using which it's possible check if
StreamReader has required amount of bytes available
for reading reading.
FutureImpl and CompletionHandler via
the cancellation notification.
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.
FutureImpl and CompletionHandler using
the passed error
ConnectionProbes about the IO Event disabled event.
ConnectionProbes about the IO Event enabled event.
ConnectionProbes about the IO Event ready event.
ConnectionProbes about the accept event.
ConnectionProbes about the bind event.
ConnectionProbes about the close event.
TransportProbes about the config changed event.
ConnectionProbes about the connect event.
ConnectionProbes about the error.
TransportProbes about the error.
TransportProbes about the pause event.
ConnectionProbes about the read event.
TransportProbes about the resume event.
TransportProbes about the start event.
TransportProbes about the stop event.
ConnectionProbes about the write event.
FutureImpl and CompletionHandler using
the passed result object.
WriteHandler, which will be notified ones Buffer
of "size"-bytes can be written.
WriteHandler, which will be notified ones Buffer
of "size"-bytes can be written.
Attribute initializer.Context
Context
Processor, which will process Transport
Connections I/O events in case, if Connection
doesn't have own Processor preferences.
Processor, which will process Connection
I/O event.
Processor, which will process Transport
Connections I/O events in case, if Connection
doesn't have own Processor preferences.
Processor state associated with this Connection.
Writer.
FilterChain.
MemoryManager, when new buffer gets allocated
MemoryManager, when new buffer gets allocated
MemoryManager, when buffer gets allocated from some pool
MemoryManager, when buffer gets allocated from some pool
MemoryManager, when buffer gets releaed into a buffer pool
MemoryManager, when buffer gets releaed into a buffer pool
Connection has been closed,
to let processor release a connection associated resources.
Connection has been closed,
to let processor release a connection associated resources.
Connection has been closed,
to let processor release a connection associated resources.
Connection gets closed.
Connection gets closed.
IOEvent processing completed.
FilterChainContext processing
is complete.
IOEvent processing completed.
Transport configuration gets changed.
Transport configuration gets changed.
IOEvent processing resumed.
IOEvent processing resumed.
IOEvent processing suspended.
IOEvent processing suspended.
FilterChainContext
is copied.
IOEvent processing.
IOEvent processing.
Connection.
Connection.
Transport.
Transport.
FilterChain this Filter is part of,
has been changed.
IOEvent for the specific
Connection gets disabled.
IOEvent for the specific
Connection gets disabled.
IOEvent for the specific
Connection gets enabled.
IOEvent for the specific
Connection gets enabled.
IOEvent for the specific
Connection gets ready.
IOEvent for the specific
Connection gets ready.
IOEvent processing out of this Context.
IOEvent processing out of this Context.
AbstractThreadPool implementation
has allocated and is managing a number of threads equal to the maximum limit
of the pool.
AbstractThreadPool implementation
has allocated and is managing a number of threads equal to the maximum limit
of the pool.
IOEvent wasn't processed.
IOEvent wasn't processed.
Transport gets paused.
Transport gets paused.
Writer
due to I/O or memory limitations.
Connection has read data.
Connection has read data.
FilterChain.
IOEvent interest.
IOEvent interest.
IOEvent processing.
IOEvent processing.
Transport gets resumed.
Transport gets resumed.
Transport gets started.
Transport gets started.
Transport gets stopped.
Transport gets stopped.
Runnable has
completed execution.
AbstractThreadPool
implementation has exceeded its configured size.
AbstractThreadPool
implementation has exceeded its configured size.
IOEvent processing in this thread, but it's going to
be continued later.
IOEvent processing in this thread, but it's going to
be continued later.
AbstractThreadPool implementation
allocates a new managed Thread.
AbstractThreadPool implementation
allocates a new managed Thread.
AbstractThreadPool implementation
starts running.
AbstractThreadPool implementation
starts running.
AbstractThreadPool implementation
stops.
AbstractThreadPool implementation
stops.
AbstractThreadPool implementation.
AbstractThreadPool implementation.
AbstractThreadPool.Worker, when it's completing
AbstractThreadPool.Worker.run() method execution, which in most cases means,
that ThreadPool's thread will be released.
AbstractThreadPool.Worker, when it's starting
AbstractThreadPool.Worker.run() method execution, which means, that ThreadPool's
thread is getting active and ready to process tasks.
Connection has written data.
Connection has written data.
CompletionHandler, which will be notified, when operation will be
complete.
AttributeHolder,
the difference from Attribute.get(org.glassfish.grizzly.attributes.AttributeHolder) is
that default value or NullaryFunction won't be invoked.
AttributeStorage,
the difference from Attribute.get(AttributeStorage) is
that default value or NullaryFunction won't be invoked.
AsyncWriteQueueRecord that exceeds
the configured maximum queue size.Connection object before actual connecting phase
will be started.
Charsets available to the JMV, which makes charset
searching faster (at the cost of memory).
FilterChain, associated with the
Connection and prepares the Context for remainder processing.
StandaloneProcessor.isInterested(IOEvent) returns false for any
IOEvent.
Processor execution.ProcessorResult.Processor, which will process IOEvent, occurred on the
ConnectionWriter refuses to
accept passed WritableMessage due to I/O or memory limitations.Writer
implementation, if message can not be neither written nor added to write queue
at the moment due to I/O or memory limitations.Buffer.Connection to a Buffer.Readable.Future implementation with the specific unmodifiable result.Buffer to a required size.
Buffer to a required size.
Buffer to a required size.
ThreadPoolConfig
Context
Context
JmxObject as child of the passed parent object
with the specific name.
JmxObject at the root with the passed name.
WritableMessage.
WritableMessage.
Buffer.
Buffer.
QueueMonitors about the update.
AttributeHolder.
AttributeStorage.
Buffers, without disposing
Connection.CloseListener.
Connection.CloseListener.
FilterChainContext.CompletionListener.
FilterChainContext.CopyListener.
ConnectionProbe.
Buffer with another one.
NextAction instructs the FilterChain to rerun the same
Filter again.ObjectPool
to store and reuse Context instances - this method will be
called before Context will be offered to pool.
ObjectPool to store
and reuse TransformationResult instances - this method will be
called before TransformationResult will be offered to pool.
FutureImpl implementation.IOStrategy, which executes Processors in a current thread.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.SelectorHandler and executed in a
Selector thread.SelectorHandlerSelector related operations.AttributeHolder.
AttributeStorage.
IOEvent processing.
Transport associated AttributeBuilder, which will
be used by Transport and its Connections to store custom
Attributes.
AttributeBuilder to be used by the created NIOTransport.
Transport associated AttributeBuilder, which will
be used by Transport and its Connections to store custom
Attributes.
SSLEngine to be configured to work in client mode.
Connection.
ByteBuffers, or false otherwise.
Processor is interested in
Processor is interested in
IOEvent.
IOStrategy implementation, which will be used by
Transport to process IOEvent.
IOStrategy that will be used.
IOStrategy implementation, which will be used by
Transport to process IOEvent.
ThreadPoolConfig to be used by the Transport internal
thread pool.
ThreadPoolConfig to be used by the Transport internal
thread pool.
Connection.
Connection.
Connection.
Transport associated MemoryManager, which will
be used by the Transport, its Connections and by during
processing I/O events, occurred on Connections.
MemoryManager to be used by the created NIOTransport.
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.
NIOChannelDistributor to be used by the created NIOTransport.
Processor to process IOEvent, occurring
on connection phase.
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 will process Connection
I/O events in case, if Connection doesn't have own
Processor preferences.
ProcessorSelector, which will be used to get
Processor to process I/O events, occurring 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.
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 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.
SelectionKeyHandler to be used by the created NIOTransport.
SelectorHandler to be used by the created NIOTransport.
SelectorProvider to be used by this transport.
SelectorProvider to be used by the created NIOTransport.
IOStrategy) to let kernel threads continue
their job.
IOStrategy) to let kernel threads continue
their job.
ThreadPoolConfig to be used by the worker thread pool.
ThreadPoolConfig to be used by the worker thread pool.
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.
Buffer whose content is a shared subsequence
of this buffer's content.
Buffer whose content is a shared subsequence of
this buffer's content.
ByteBuffer of required size from big chunk.
ByteBuffer's slice basing on its passed position and limit.
Socket based Transports, which are able
to bind server Socket to specific address and listen for incoming
data.Transformers.SSLContext.SSLEngine.SSLContext.
SSLContext,
using passed client mode, need/want client auth parameters.
SSLContextConfigurator.
SSLContextConfigurator.
Filter to operate with SSL encrypted data.SSLEngineConfigurator.
SSLEngineConfigurator.
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.
Buffer to StringBuffer to StringExecutorService implementation, which function the similar way as
former Grizzly 1.x Pipeline based thread pools.Buffer.
AsyncQueueReader implementation, based on
the Java NIOAsyncQueueWriter implementation, based on
the Java NIOConnection implementation
for the TCPNIOTransportNIOTransportBuilder implementation for TCP.TCPNIOTransport's transport Filter implementationMemoryManager implementations
in order to provide per-thread memory management.AbstractThreadPool implementations.ThreadPoolProbe adapter that provides no-op implementations for
all interface methods allowing easy extension by the developer.CompletionHandler, which may serve as a bridge
for passed FutureImpl.
CompletionHandler, which may serve as a bridge
for passed FutureImpl and CompletionHandler.
BufferArray instance with this Buffer
added as an element to the BufferArray.
BufferArray after adding this Buffer.
Buffer's position and limit
and adds it to a new BufferArray instance.
Buffer's position and limit
and adds it to the specified BufferArray.
Buffer to a ByteBuffer whose content
is a shared subsequence of this buffer's content.
Buffer to a ByteBuffer whose content
is a shared subsequence of this buffer's content.
Buffer to a ByteBuffer per Buffer.toByteBuffer()
and returns a ByteBufferArray containing the converted ByteBuffer.
Buffer to a ByteBuffer per Buffer.toByteBuffer()
and adds the result to the provided ByteBufferArray.
Buffer to a ByteBuffer per Buffer.toByteBuffer(int, int)
and returns a ByteBufferArray containing the converted ByteBuffer.
Buffer to a ByteBuffer per Buffer.toByteBuffer(int, int)
and adds the result to the provided ByteBufferArray.
CompletionHandler, which may serve as a bridge for passed
FutureImpl.
CompletionHandler, which may serve as a bridge for passed
FutureImpl and CompletionHandler objects.
Buffer content as String, using default Charset
Buffer content as String
Buffer's chunk content as String
take or poll.
BlockingQueue in which producers may wait for consumers
to receive elements.NIOTransport implementation.
Filter implementation, which should work with any
Transport.Transport implementations.TransportProbe adapter that provides no-op implementations for
all interface methods allowing easy extension by the developer.false
without enqueuing the element.
take or poll.
AsyncQueueReader implementation, based on
the Java NIOAsyncQueueWriter implementation, based on
the Java NIOConnection implementation
for the UDPNIOTransportConnection implementation
for the UDPNIOTransportUDPNIOConnectorHandler.NIOTransportBuilder implementation for UDP.UDPNIOTransport's transport Filter implementationTransport connection.
Transport connection.
Transport connection.
Transport connections.
AsyncQueueWriter.setMaxPendingBytesPerConnection(int) means
the async write queue size is unlimited.
Future implementation.SSLContextConfigurator configuration.
SSLContextConfigurator configuration.
MemoryManager.allocate(int) or MemoryManager.allocateAtLeast(int) call,
made in the current thread for the given memory size, going to return a Buffer based
on direct ByteBuffer, or false otherwise.
MemoryManager.allocate(int) or MemoryManager.allocateAtLeast(int) call,
made in the current thread for the given memory size, going to return a Buffer based
on direct ByteBuffer, or false otherwise.
MemoryManager.allocate(int) or MemoryManager.allocateAtLeast(int) call,
made in the current thread for the given memory size, going to return a Buffer based
on direct ByteBuffer, or false otherwise.
IOStrategy, which executes Processors in worker thread.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.
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 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.Channel.WritableMessage.
WritableMessage.
WritableMessage to the specific address.
WritableMessage to the specific address.
Buffer to the specific address.
Buffer to the specific address.
WritableMessage to the specific address.
WritableMessage to the specific address.
WritableMessage.
WritableMessage.
WritableMessage to the specific address.
WritableMessage to the specific address.
WritableMessage to the specific address.
Buffer is empty
Buffer to the StreamWriter.
Buffer to the StreamWriter.
Buffer
to Connection.Writable.FileTransfer to the specified
WritableByteChannel.
|
||||||||||
| PREV NEXT | FRAMES NO FRAMES | |||||||||