All Classes and Interfaces
Class
Description
Builder
Abstract
FilterChain implementation, which redirects
Processor.process(org.glassfish.grizzly.Context) call to the
FilterChain.execute(org.glassfish.grizzly.filterchain.FilterChainContext)A
MemoryManager abstraction to provide utilities that may be useful across different MemoryManager
implementations.This is a marker interface indicating a particular
Buffer implementation can be trimmed.The
AsyncQueueReader implementation, based on the Java NIOThe
AsyncQueueWriter implementation, based on the Java NIOAbstract class, which provides transitive dependencies for overloaded
Reader methods.Abstract class simplifies the implementation of
SocketConnectorHandler interface by pre-implementing some of
its methods.Builder
Each method reads data from the current ByteBuffer.
Write the primitive Java type to the current ByteBuffer.
Abstract
ExecutorService implementation.Abstract
Transport.Abstract class, which provides transitive dependencies for overloaded
Writer methods.The Filter is responsible for tracking
Connection activity and closing Connection ones it becomes
idle for certain amount of time.The thread safe set implementation, which uses array to hold its elements.
Set of utility methods to work with Arrays.
Common interface for
AsyncQueue processors.Interface, which Transports should implement if they support AsyncQueues.
Class encapsulates asynchronous queue implementation:
AsyncQueueReader, AsyncQueueWriter.The
AsyncQueue, which implements asynchronous read queue.AsyncQueue element unitThe
AsyncQueue, which implements asynchronous write queue.AsyncQueue read element unitAsyncQueue write element unitClass used to define dynamic typed attributes on
AttributeHolder instances.AttributeBuilder is responsible for creating and indexing
Attributes.Interface declares common functionality for objects, which have associated
Attributes.AttributeStorage provides access to a
AttributeHolder, where application can store
Attributes.Base
Provides empty implementation for
Filter processing methods.BinTree
BitTreeDecoder
BitTreeEncoder
JDK
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.OutputStream implementation to write to a Buffer.Class has useful methods to simplify the work with
Buffers.The simple Buffer manager implementation, which works as wrapper above
ByteBuffers.Buffer implementation, which uses the ByteBuffer underneath.ProcessorSelector implementation, which acts like wrapper for chain of ProcessorSelectors.Configurator responsible for initial
SelectableChannel configuration.Charset utility class.
The Filter is responsible to break the incoming/outgoing data into chunks and pass them down/up by the
FilterChain.General asynchronous closable interface.
The listener, which is used to be notified, when Connection gets closed.
An object, describing the reason why
Connection was closed.Codec is able to transform the original message to a custom represantation and vise versa.
Interface, which will be used by Grizzly to notify about asynchronous I/O operations status updates.
Bulk Buffer operation, responsible for byte-by-byte Buffer processing.
The order in which internal
Buffers will be disposed.Setter.
Common interface, which represents any kind of connection.
Deprecated.
Deprecated.
use
CloseTypeMonitoring probe providing callbacks that may be invoked by Grizzly
Connection implementations.ConnectionProbe adapter that provides no-op implementations for all interface methods allowing easy extension
by the developer.Client side connector handler API.
Object, which is responsible for holding context during I/O event processing.
General interface for the objects, that could be copied/cloned.
CRC
Utility class, which may stores the current execution position to help tracking threading issues.
RangeDecoder
Default
AttributeBuilder implementation.Default
FilterChain implementationAllows creation/customization of
MemoryManager implementation to be used as the
MemoryManager.DEFAULT_MEMORY_MANAGER.Default monitoring configuration, with no JMX support.
Default implementation of NIO
SelectorHandlerDefault Grizzly worker thread implementation
Filter which pauses protocol chain processing for a certain time.
Thread-local Direct
ByteBuffer storage.Echo
Filter implementationEmpty implementation for
CompletionHandler interface.RangeEncoder
Exceptions utilities.
A simple class that abstracts
FileChannel.transferTo(long, long, java.nio.channels.WritableByteChannel) for
use with Grizzly 2.0 AsyncQueueWriter.A Filter encapsulates a unit of processing work to be performed, whose purpose is to examine and/or modify the state
of a transaction that is represented by a
FilterChainContext.
This class implement the "Chain of Responsibility" pattern (for more info, take a look at the classic "Gang of Four"
design patterns book).
FilterChainBuilder implementation, which is responsible for constructing FilterChains.FilterChain Context implementation.The interface, which represents a listener, which will be notified, once
FilterChainContext processing is
complete.The interface, which represents a listener, which will be notified, after
FilterChainContext.copy() is
called.Common interface for Transports, which support
FilterChains.Minimalistic fixed thread pool to allow for nice scalability if a good Queue impl is used.
Future interface, which has full control over the state.Set of
Future utilities.Generic Adapter interface.
Deprecated.
Interface to notify interested parties that a
Transport is being shutdown.Class contains information about Grizzly framework.
Grizzly
Future implementation.Grizzly JMX manager
This class implements a
Transformer which decodes data represented in the GZIP format.This class implements a
Transformer which encodes plain data to the GZIP format.This class implements a
Filter which encodes/decodes data in the GZIP
format.Buffer implementation, which uses the ByteBuffer underneath.The object holder, which might be used for lazy object initialization.
Deprecated.
The Filter is responsible for tracking
Connection activity and closing Connection once it becomes
idle for certain amount of time.The interface declares, that
AttributeHolder supports indexed Attribute access.AttributeHolder, which supports indexed access to stored Attributes.
This interface defines methods to allow an
InputStream or Reader to notify the developer
when and how much data is ready to be read without blocking.Handler, which is used to finer control
Readable.InWindow
Enumeration represents the I/O events, occurred on a
Connection.Empty
IOEventLifeCycleListener implementation.strategy is responsible for making decision how
Runnable task will be run: in current thread, worker
thread.IOStrategy, which executes Processors in a current
threads, and resumes selector thread logic in separate thread.FilterChain facade, which implements all the List related methods.Localizable message.
Localizes the
Localizable into a message by using a configured Locale.Simple log
FilterFormat the record to include the Thread that logged the record.
Defines string formatting method for each constant in the resource file
MemoryManager, responsible for allocating and releasing memory, required during application runtime.
MemoryManager monitoring probe.MemoryProbe adapter that provides no-op implementations for all interface methods allowing easy extension by
the developer.Class has useful methods to simplify the work with
Buffers.Cloner, which will be called by
AsyncQueueWriter, when message could not be written directly, and will be
added to the queue.General interface for the objects, which could be monitored during the lifecycle.
General monitoring configuration interface.
The class, which contains utility methods for monitoring support.
The interface defines the instruction for a
FilterChain, how it should continue filter chain execution.Common
Connection implementation for Java NIO Connections.This builder is responsible for creating
NIOTransport implementations as well as providing basic
configuration for IOStrategies and thread pools.Basic interface for object pool implementations
This interface defines methods to allow an
OutputStream or Writer to allow the
developer to check with the runtime whether or not it's possible to write a certain amount of data, or if it's not
possible, to be notified when it is.OutWindow
Key : Value pair implementation.
Thrown when an attempt is made to add a record that exceeds the configured maximum queue size.
A
MemoryManager implementation based on a series of shared memory pools.Immutable class representing a port range.
Processor implementations are responsible for processing I/O events, which occur on connection.
The interface represents the result of
Processor execution.Enumeration represents the status/code of
ProcessorResult.Implementations of the interface will be responsible to find correct
Processor, which will process
IOEvent, occurred on the ConnectionDeprecated.
push back logic is deprecated.
Deprecated.
push back logic is deprecated.
RangeDecoder
RangeEncoder
Implementations of this interface are able to read data from internal source to a
Buffer.Implementations of this interface are able to read data from
Connection to a Buffer.
This class represents a call-back mechanism that will notify implementations as more input data becomes available to
read without blocking.
Result of read operation, returned by
Readable.Future implementation with the specific unmodifiable result.Read result associated with a
AsyncWriteQueueRecord.Write result associated with a
AsyncWriteQueueRecord.Common I/O result interface.
RoundRobin NIOConnectionDistributor implementation, which allocates one SelectorRunner for OP_ACCEPT events and other
event will be assign to a next SelectorRunner from the array.
Safe
FutureImpl implementation.IOStrategy, which executes Processors in a current
thread.SelectionKeyHandler implementations are responsible for handling SelectionKey life cycle events.Task, which may be registered on
SelectorHandler and executed in a Selector thread.Class is responsible for processing certain (single)
SelectorHandlerUtility class for
Selector related operations.Error thrown when something goes wrong while looking up service providers.
A simple service-provider lookup mechanism.
This class will be passed to
GracefulShutdownListener instances registered against a Transport.An event that
Filter implementations may listen for if special processing is required during a graceful
shutdown.Filter, which determines silent connections and closes them.
Simple dynamic strategy, which switches I/O processing strategies, basing on statistics.
Common interface for SocketAcceptor implementations.
Socket based client side connector.
SSL
Filter to operate with SSL encrypted data.SSL Codec, which contains SSL encoder and decoder
Transformers.SSL context associated with a
Connection.Utility class, which helps to configure
SSLContext.Transformer, which decodes SSL encrypted data, contained in the input Buffer, to the output Buffer.
Transformer, which encrypts plain data, contained in the input Buffer, into SSL/TLS data and puts the result
to the output Buffer.
Utility class, which helps to configure
SSLEngine.The factory responsible for creating
SSLEngine.SSL
Filter to operate with SSL encrypted data.SSL aware
StreamReader implementation, which work like a wrapper over existing StreamReader.SSL aware
StreamWriter implementation, which work like a wrapper over existing StreamWriter.SSLSupport
Interface for SSL-specific functions
Simple data class that represents the cipher being used, along with the corresponding effective key size.
Utility class, which implements the set of useful SSL related operations.
Processor, which is not interested in processing I/O events.Class, which holds the state.
Common interface for Stream readers and writers.
Interface that defines methods for reading primitive types and arrays of primitive types from a stream.
Write the primitive Java types and arrays of primitives to some data sink.
StringFilter implementation, which performs Buffer <-> String transformation.
ExecutorService implementation, which function the similar way as former Grizzly 1.x Pipeline based thread
pools.Class represents common implementation of asynchronous processing queue.
The TCP transport
AsyncQueueReader implementation, based on the Java NIOThe TCP transport
AsyncQueueWriter implementation, based on the Java NIOThis class may be used to apply a custom
Processor and/or
ProcessorSelector atomically within a bind operation - not something that can normally
be done using the TCPNIOTransport alone.Connection implementation for the TCPNIOTransportThis interface implementations can be used to be notified about the TCPNIOConnection connect state.
TCP NIO transport client side ConnectorHandler implementation
TCP Transport NIO implementation
NIOTransportBuilder implementation for TCP.The
TCPNIOTransport's transport Filter implementationTCP NIO Transport utils
Common interface for Transports, which will use temporary selectors technics
A thread local pool used by a
MemoryManager to create and modify BuffersThis interface may be implemented by custom
MemoryManager implementations in order to provide per-thread
memory management.Grizzly thread-pool configuration, which might be used to create and initialize a thread-pool via
GrizzlyExecutorService.createInstance(org.glassfish.grizzly.threadpool.ThreadPoolConfig).Monitoring probe providing callbacks that may be invoked by Grizzly
AbstractThreadPool implementations.ThreadPoolProbe adapter that provides no-op implementations for all interface methods allowing easy extension
by the developer.Set of
Thread utilities.A
BlockingQueue in which producers may wait for consumers to receive elements.Describes the problem, occured during original message transformation.
Represents the result of message encoding/decoding.
Transformer interface, which knows how to transform the original data to some custom representation.
Transport interface describes the transport unit used in Grizzly.
Monitoring probe providing callbacks that may be invoked by Grizzly
Transport implementations.TransportProbe adapter that provides no-op implementations for all interface methods allowing easy extension
by the developer.The UDP transport
AsyncQueueReader implementation, based on the Java NIOThe UDP transport
AsyncQueueWriter implementation, based on the Java NIOThis class may be used to apply a custom
Processor and/or
ProcessorSelector atomically within a bind operation - not something that can normally
be done using the UDPNIOTransport alone.Connection implementation for the UDPNIOTransportUDP NIO transport client side ConnectorHandler implementation
Server
Connection implementation for the UDPNIOTransportUDP NIO transport implementation
NIOTransportBuilder implementation for UDP.The
UDPNIOTransport's transport Filter implementationSimple thread-unsafe
Future implementation.Interface, which Grizzly thread pool threads should implement.
IOStrategy, which executes Processors in worker thread.Strategy implementations may implement this interface to signify they have certain thread pool configuration
requirements that could be used when building the runtime.
MemoryManagers, which implement this interface, are able to convert frequently used Java buffer types to
Grizzly Buffer.Common interface for entities that may be written to a
Channel.Implementations of this interface are able to write data from a
Buffer.Callback notification mechanism that signals the developer it's possible to write content.
Implementations of this interface are able to write data from a
Buffer to Connection.Write reentrants counter
Result of write operation, returned by
Writeable.
CloseListener