All Classes

Class	Description
AbstractBindingHandler
AbstractBindingHandler.Builder<E extends AbstractBindingHandler.Builder>	Builder
AbstractBufferArray<E>
AbstractCodecFilter<K,L>
AbstractFilterChain	Abstract FilterChain implementation, which redirects Processor.process(org.glassfish.grizzly.Context) call to the FilterChain.execute(org.glassfish.grizzly.filterchain.FilterChainContext)
AbstractIOStrategy
AbstractMemoryManager<E extends Buffer>	A MemoryManager abstraction to provide utilities that may be useful across different MemoryManager implementations.
AbstractMemoryManager.TrimAware	This is a marker interface indicating a particular Buffer implementation can be trimmed.
AbstractNIOAsyncQueueReader	The AsyncQueueReader implementation, based on the Java NIO
AbstractNIOAsyncQueueWriter	The AsyncQueueWriter implementation, based on the Java NIO
AbstractNIOConnectionDistributor
AbstractReader<L>	Abstract class, which provides transitive dependencies for overloaded Reader methods.
AbstractSocketConnectorHandler	Abstract class simplifies the implementation of SocketConnectorHandler interface by pre-implementing some of its methods.
AbstractSocketConnectorHandler.Builder<E extends AbstractSocketConnectorHandler.Builder>	Builder
AbstractStreamReader	Each method reads data from the current ByteBuffer.
AbstractStreamWriter	Write the primitive Java type to the current ByteBuffer.
AbstractStreamWriter.DisposeBufferCompletionHandler
AbstractThreadPool	Abstract ExecutorService implementation.
AbstractTransformer<K,L>
AbstractTransformer.LastResultAwareState<K,L>
AbstractTransport	Abstract Transport.
AbstractWriter<L>	Abstract class, which provides transitive dependencies for overloaded Writer methods.
ActivityCheckFilter	The Filter is responsible for tracking Connection activity and closing Connection ones it becomes idle for certain amount of time.
ActivityCheckFilter.TimeoutHandler
Appendable<T>
Appender<E>
ArraySet<T>	The thread safe set implementation, which uses array to hold its elements.
ArrayUtils	Set of utility methods to work with Arrays.
AsyncQueue	Common interface for AsyncQueue processors.
AsyncQueue.AsyncResult
AsyncQueueEnabledTransport	Interface, which Transports should implement if they support AsyncQueues.
AsyncQueueIO<L>	Class encapsulates asynchronous queue implementation: AsyncQueueReader, AsyncQueueWriter.
AsyncQueueIO.Factory
AsyncQueueIO.ImmutableAsyncQueueIO<L>
AsyncQueueIO.MutableAsyncQueueIO<L>
AsyncQueueReader<L>	The AsyncQueue, which implements asynchronous read queue.
AsyncQueueRecord<R>	AsyncQueue element unit
AsyncQueueWriter<L>	The AsyncQueue, which implements asynchronous write queue.
AsyncReadQueueRecord	AsyncQueue read element unit
AsyncWriteQueueRecord	AsyncQueue write element unit
Attribute<T>	Class used to define dynamic typed attributes on AttributeHolder instances.
AttributeBuilder	AttributeBuilder is responsible for creating and indexing Attributes.
AttributeHolder	Interface declares common functionality for objects, which have associated Attributes.
AttributeStorage	AttributeStorage provides access to a AttributeHolder, where application can store Attributes.
Base	Base
BaseFilter	Provides empty implementation for Filter processing methods.
BinTree	BinTree
BitTreeDecoder	BitTreeDecoder
BitTreeEncoder	BitTreeEncoder
Buffer	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.
BufferArray
BufferedInput
BufferedOutput
BufferInputStream	InputStream implementation over Grizzly Buffer.
BufferOutputStream	OutputStream implementation to write to a Buffer.
Buffers	Class has useful methods to simplify the work with Buffers.
BuffersBuffer
ByteBufferArray
ByteBufferAware
ByteBufferManager	The simple Buffer manager implementation, which works as wrapper above ByteBuffers.
ByteBufferWrapper	Buffer implementation, which uses the ByteBuffer underneath.
Cacheable
ChainProcessorSelector	ProcessorSelector implementation, which acts like wrapper for chain of ProcessorSelectors.
ChangeListener<E>
ChannelConfigurator	Configurator responsible for initial SelectableChannel configuration.
Charsets	Charset utility class.
ChunkingFilter	The Filter is responsible to break the incoming/outgoing data into chunks and pass them down/up by the FilterChain.
ChunkingFilter.ChunkingDecoder
ChunkingFilter.ChunkingEncoder
ChunkingFilter.ChunkingTransformer
Closeable	General asynchronous closable interface.
CloseListener<T extends Closeable,C extends ICloseType>	The listener, which is used to be notified, when Connection gets closed.
CloseReason	An object, describing the reason why Connection was closed.
CloseType
Codec<K,L>	Codec is able to transform the original message to a custom represantation and vise versa.
CodecFilter<K,L>
CompletionHandler<E>	Interface, which will be used by Grizzly to notify about asynchronous I/O operations status updates.
CompletionHandlerAdapter<A,B>
CompositeBuffer
CompositeBuffer.BulkOperation	Bulk Buffer operation, responsible for byte-by-byte Buffer processing.
CompositeBuffer.DisposeOrder	The order in which internal Buffers will be disposed.
CompositeBuffer.Setter	Setter.
Condition
Connection<L>	Common interface, which represents any kind of connection.
Connection.CloseListener	Deprecated. use CloseListener
Connection.CloseType	Deprecated. use CloseType
ConnectionProbe	Monitoring probe providing callbacks that may be invoked by Grizzly Connection implementations.
ConnectionProbe.Adapter	ConnectionProbe adapter that provides no-op implementations for all interface methods allowing easy extension by the developer.
ConnectorHandler<E>	Client side connector handler API.
Context	Object, which is responsible for holding context during I/O event processing.
Context.MinimalisticArrayList<E>
Copyable	General interface for the objects, that could be copied/cloned.
CRC	CRC
DebugPoint	Utility class, which may stores the current execution position to help tracking threading issues.
Decoder	RangeDecoder
Decoder.LiteralDecoder
Decoder.LiteralDecoder.Decoder2
Decoder.State
DefaultAttributeBuilder	Default AttributeBuilder implementation.
DefaultFilterChain	Default FilterChain implementation
DefaultMemoryManagerFactory	Allows creation/customization of MemoryManager implementation to be used as the MemoryManager.DEFAULT_MEMORY_MANAGER.
DefaultMonitoringConfig<E>	Default monitoring configuration, with no JMX support.
DefaultProcessorSelector	Default ProcessorSelector implementation, which uses Connection's Processor preferences.
DefaultSelectionKeyHandler
DefaultSelectorHandler	Default implementation of NIO SelectorHandler
DefaultSelectorHandler.DeregisterChannelOperation
DefaultSelectorHandler.RegisterChannelOperation
DefaultSelectorHandler.RegisterKeyTask
DefaultSelectorHandler.RunnableTask
DefaultStreamReader
DefaultStreamReader.Input
DefaultStreamWriter
DefaultStreamWriter.Output
DefaultWorkerThread	Default Grizzly worker thread implementation
DelayedExecutor
DelayedExecutor.Resolver<E>
DelayedExecutor.Worker<E>
DelayFilter	Filter which pauses protocol chain processing for a certain time.
DirectByteBufferRecord	Thread-local Direct ByteBuffer storage.
EchoFilter	Echo Filter implementation
EmptyCompletionHandler<E>	Empty implementation for CompletionHandler interface.
Encoder	RangeEncoder
ExceptionHandler
ExceptionHandler.Severity
Exceptions	Exceptions utilities.
FileChunk
FileTransfer	A simple class that abstracts FileChannel.transferTo(long, long, java.nio.channels.WritableByteChannel) for use with Grizzly 2.0 AsyncQueueWriter.
Filter	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.
FilterChain	This class implement the "Chain of Responsibility" pattern (for more info, take a look at the classic "Gang of Four" design patterns book).
FilterChainBuilder	FilterChainBuilder implementation, which is responsible for constructing FilterChains.
FilterChainBuilder.StatelessFilterChainBuilder
FilterChainContext	FilterChain Context implementation.
FilterChainContext.CompletionListener	The interface, which represents a listener, which will be notified, once FilterChainContext processing is complete.
FilterChainContext.CopyListener	The interface, which represents a listener, which will be notified, after FilterChainContext.copy() is called.
FilterChainContext.Operation
FilterChainContext.State
FilterChainContext.TransportContext
FilterChainEnabledTransport	Common interface for Transports, which support FilterChains.
FilterChainEvent
FilterChainProcessorSelector	ProcessorSelector implementation, which delegates processing of IOEvent to the FilterChain.
FilterExecutor	Executes appropriate Filter processing method to process occurred IOEvent.
FixedThreadPool	Minimalistic fixed thread pool to allow for nice scalability if a good Queue impl is used.
FutureImpl<R>	Future interface, which has full control over the state.
Futures	Set of Future utilities.
GenericAdapter<K,V>	Generic Adapter interface.
GenericCloseListener	Deprecated.
GracefulShutdownListener	Interface to notify interested parties that a Transport is being shutdown.
Grizzly	Class contains information about Grizzly framework.
GrizzlyExecutorService
GrizzlyFuture<R>	Grizzly Future implementation.
GrizzlyJmxManager	Grizzly JMX manager
GZipDecoder	This class implements a Transformer which decodes data represented in the GZIP format.
GZipDecoder.DecodeStatus
GZipDecoder.GZipInputState
GZipEncoder	This class implements a Transformer which encodes plain data to the GZIP format.
GZipEncoder.GZipOutputState
GZipFilter	This class implements a Filter which encodes/decodes data in the GZIP format.
HeapBuffer	Buffer implementation, which uses the ByteBuffer underneath.
HeapMemoryManager	A WrapperAware MemoryManager implementation for managing HeapBuffer instances.
Holder<E>	The object holder, which might be used for lazy object initialization.
Holder.IntHolder
Holder.LazyHolder<E>
Holder.LazyIntHolder
ICloseType	Deprecated.
IdleTimeoutFilter	The Filter is responsible for tracking Connection activity and closing Connection once it becomes idle for certain amount of time.
IdleTimeoutFilter.TimeoutHandler
IdleTimeoutFilter.TimeoutResolver
IndexedAttributeAccessor	The interface declares, that AttributeHolder supports indexed Attribute access.
IndexedAttributeHolder	AttributeHolder, which supports indexed access to stored Attributes.
Input
InputSource	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.
Interceptor<R>	Handler, which is used to finer control Readable.
InWindow	InWindow
IOEvent	Enumeration represents the I/O events, occurred on a Connection.
IOEventLifeCycleListener	The IOEvent life-cycle listener, which will be notified about changes in IOEvent processing statuses.
IOEventLifeCycleListener.Adapter	Empty IOEventLifeCycleListener implementation.
IOStrategy	strategy is responsible for making decision how Runnable task will be run: in current thread, worker thread.
JdkVersion
LeaderFollowerNIOStrategy	IOStrategy, which executes Processors in a current threads, and resumes selector thread logic in separate thread.
ListFacadeFilterChain	FilterChain facade, which implements all the List related methods.
Localizable	Localizable message.
LocalizableMessage
LocalizableMessageFactory
Localizer	Localizes the Localizable into a message by using a configured Locale.
LogFilter	Simple log Filter
LoggingFormatter	Format the record to include the Thread that logged the record.
LogMessages	Defines string formatting method for each constant in the resource file
LZMADecoder
LZMADecoder.LZMAInputState
LZMAEncoder
LZMAEncoder.LZMAOutputState
LZMAEncoder.LZMAProperties
LZMAFilter
MemoryManager<E extends Buffer>	MemoryManager, responsible for allocating and releasing memory, required during application runtime.
MemoryProbe	MemoryManager monitoring probe.
MemoryProbe.Adapter	MemoryProbe adapter that provides no-op implementations for all interface methods allowing easy extension by the developer.
MemoryUtils	Class has useful methods to simplify the work with Buffers.
MessageCloner<E>	Cloner, which will be called by AsyncQueueWriter, when message could not be written directly, and will be added to the queue.
MonitoringAware<E>	General interface for the objects, which could be monitored during the lifecycle.
MonitoringConfig<E>	General monitoring configuration interface.
MonitoringUtils	The class, which contains utility methods for monitoring support.
NextAction	The interface defines the instruction for a FilterChain, how it should continue filter chain execution.
NIOChannelDistributor
NIOConnection	Common Connection implementation for Java NIO Connections.
NIOTransport
NIOTransportBuilder<T extends NIOTransportBuilder>	This builder is responsible for creating NIOTransport implementations as well as providing basic configuration for IOStrategies and thread pools.
NullaryFunction<T>	Deprecated. pls.
NullaryFunction<T>	General initializer interface.
ObjectPool<E extends PoolableObject>	Basic interface for object pool implementations
Output
OutputSink	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	OutWindow
Pair<K,L>	Key : Value pair implementation.
PendingWriteQueueLimitExceededException	Thrown when an attempt is made to add a record that exceeds the configured maximum queue size.
PoolableObject
PooledMemoryManager	A MemoryManager implementation based on a series of shared memory pools.
PortRange	Immutable class representing a port range.
Processor<E extends Context>	Processor implementations are responsible for processing I/O events, which occur on connection.
ProcessorExecutor
ProcessorResult	The interface represents the result of Processor execution.
ProcessorResult.Status	Enumeration represents the status/code of ProcessorResult.
ProcessorSelector	Implementations of the interface will be responsible to find correct Processor, which will process IOEvent, occurred on the Connection
PushBackContext	Deprecated. push back logic is deprecated.
PushBackHandler	Deprecated. push back logic is deprecated.
RangeDecoder	RangeDecoder
RangeEncoder	RangeEncoder
Readable<L>	Implementations of this interface are able to read data from internal source to a Buffer.
Reader<L>	Implementations of this interface are able to read data from Connection to a Buffer.
ReadHandler	This class represents a call-back mechanism that will notify implementations as more input data becomes available to read without blocking.
ReadResult<K,L>	Result of read operation, returned by Readable.
ReadyFutureImpl<R>	Future implementation with the specific unmodifiable result.
RecordReadResult<K,L>	Read result associated with a AsyncWriteQueueRecord.
RecordWriteResult<K,L>	Write result associated with a AsyncWriteQueueRecord.
RegisterChannelResult
RerunFilterAction	This NextAction instructs the FilterChain to rerun the same Filter again.
Result	Common I/O result interface.
ResultAware<E>
RoundRobinConnectionDistributor	RoundRobin NIOConnectionDistributor implementation, which allocates one SelectorRunner for OP_ACCEPT events and other event will be assign to a next SelectorRunner from the array.
SafeFutureImpl<R>	Safe FutureImpl implementation.
SameThreadIOStrategy	IOStrategy, which executes Processors in a current thread.
SelectionKeyHandler	SelectionKeyHandler implementations are responsible for handling SelectionKey life cycle events.
SelectorHandler
SelectorHandler.Task
SelectorHandlerTask	Task, which may be registered on SelectorHandler and executed in a Selector thread.
SelectorRunner	Class is responsible for processing certain (single) SelectorHandler
Selectors	Utility class for Selector related operations.
ServiceConfigurationError	Error thrown when something goes wrong while looking up service providers.
ServiceFinder<T>	A simple service-provider lookup mechanism.
ShutdownContext	This class will be passed to GracefulShutdownListener instances registered against a Transport.
ShutdownEvent	An event that Filter implementations may listen for if special processing is required during a graceful shutdown.
SilentConnectionFilter	Filter, which determines silent connections and closes them.
SimpleDynamicNIOStrategy	Simple dynamic strategy, which switches I/O processing strategies, basing on statistics.
SocketAcceptor	Common interface for SocketAcceptor implementations.
SocketBinder	Common API for Socket based Transports, which are able to bind server Socket to specific address and listen for incoming data.
SocketConnectorHandler	Socket based client side connector.
SSLBaseFilter	SSL Filter to operate with SSL encrypted data.
SSLBaseFilter.CertificateEvent
SSLBaseFilter.HandshakeListener
SSLBaseFilter.SSLTransportFilterWrapper
SSLCodec	SSL Codec, which contains SSL encoder and decoder Transformers.
SSLConnectionContext	SSL context associated with a Connection.
SSLContextConfigurator	Utility class, which helps to configure SSLContext.
SSLContextConfigurator.GenericStoreException
SSLDecoderTransformer	Transformer, which decodes SSL encrypted data, contained in the input Buffer, to the output Buffer.
SSLEncoderTransformer	Transformer, which encrypts plain data, contained in the input Buffer, into SSL/TLS data and puts the result to the output Buffer.
SSLEngineConfigurator	Utility class, which helps to configure SSLEngine.
SSLEngineFactory	The factory responsible for creating SSLEngine.
SSLFilter	SSL Filter to operate with SSL encrypted data.
SSLStreamReader	SSL aware StreamReader implementation, which work like a wrapper over existing StreamReader.
SSLStreamWriter	SSL aware StreamWriter implementation, which work like a wrapper over existing StreamWriter.
SSLStreamWriter.HandshakeCompletionHandler
SSLStreamWriter.SSLHandshakeCondition
SSLSupport	SSLSupport Interface for SSL-specific functions
SSLSupport.CipherData	Simple data class that represents the cipher being used, along with the corresponding effective key size.
SSLSupportImpl
SSLUtils	Utility class, which implements the set of useful SSL related operations.
StandaloneProcessor	Processor, which is not interested in processing I/O events.
StandaloneProcessorSelector	ProcessorSelector, which doesn't add any Processor to process occurred IOEvent.
StateHolder<E>	Class, which holds the state.
StateHolder.ConditionElement<E>
Stream	Common interface for Stream readers and writers.
StreamDecodeCondition<E>
StreamInput
StreamOutput
StreamReader	Interface that defines methods for reading primitive types and arrays of primitive types from a stream.
StreamWriter	Write the primitive Java types and arrays of primitives to some data sink.
StringDecoder	String decoder, which decodes Buffer to String
StringEncoder	String decoder, which decodes Buffer to String
StringFilter	StringFilter implementation, which performs Buffer <-> String transformation.
SyncThreadPool	ExecutorService implementation, which function the similar way as former Grizzly 1.x Pipeline based thread pools.
TaskQueue<E extends AsyncQueueRecord>	Class represents common implementation of asynchronous processing queue.
TaskQueue.MutableMaxQueueSize
TCPNIOAsyncQueueReader	The TCP transport AsyncQueueReader implementation, based on the Java NIO
TCPNIOAsyncQueueWriter	The TCP transport AsyncQueueWriter implementation, based on the Java NIO
TCPNIOBindingHandler	This 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.
TCPNIOBindingHandler.Builder
TCPNIOConnection	Connection implementation for the TCPNIOTransport
TCPNIOConnection.ConnectResultHandler	This interface implementations can be used to be notified about the TCPNIOConnection connect state.
TCPNIOConnectorHandler	TCP NIO transport client side ConnectorHandler implementation
TCPNIOConnectorHandler.Builder
TCPNIOServerConnection
TCPNIOTemporarySelectorReader
TCPNIOTemporarySelectorWriter
TCPNIOTransport	TCP Transport NIO implementation
TCPNIOTransportBuilder	NIOTransportBuilder implementation for TCP.
TCPNIOTransportFilter	The TCPNIOTransport's transport Filter implementation
TCPNIOUtils	TCP NIO Transport utils
TemporarySelectorIO
TemporarySelectorPool
TemporarySelectorReader
TemporarySelectorsEnabledTransport	Common interface for Transports, which will use temporary selectors technics
TemporarySelectorWriter
ThreadCache
ThreadCache.CachedTypeIndex<E>
ThreadCache.ObjectCache
ThreadCache.ObjectCacheElement
ThreadLocalPool<E>	A thread local pool used by a MemoryManager to create and modify Buffers
ThreadLocalPoolProvider	This interface may be implemented by custom MemoryManager implementations in order to provide per-thread memory management.
ThreadPoolConfig	Grizzly thread-pool configuration, which might be used to create and initialize a thread-pool via GrizzlyExecutorService.createInstance(org.glassfish.grizzly.threadpool.ThreadPoolConfig).
ThreadPoolProbe	Monitoring probe providing callbacks that may be invoked by Grizzly AbstractThreadPool implementations.
ThreadPoolProbe.Adapter	ThreadPoolProbe adapter that provides no-op implementations for all interface methods allowing easy extension by the developer.
Threads	Set of Thread utilities.
TransferQueue<E>	A BlockingQueue in which producers may wait for consumers to receive elements.
TransformationException	Describes the problem, occured during original message transformation.
TransformationResult<I,O>	Represents the result of message encoding/decoding.
TransformationResult.Status
Transformer<K,L>	Transformer interface, which knows how to transform the original data to some custom representation.
TransformerInput
TransformerOutput
TransformerStreamReader
TransformerStreamWriter
Transport	Transport interface describes the transport unit used in Grizzly.
Transport.State
TransportFilter	Transport Filter implementation, which should work with any Transport.
TransportFilter.FlushEvent
TransportProbe	Monitoring probe providing callbacks that may be invoked by Grizzly Transport implementations.
TransportProbe.Adapter	TransportProbe adapter that provides no-op implementations for all interface methods allowing easy extension by the developer.
UDPNIOAsyncQueueReader	The UDP transport AsyncQueueReader implementation, based on the Java NIO
UDPNIOAsyncQueueWriter	The UDP transport AsyncQueueWriter implementation, based on the Java NIO
UDPNIOBindingHandler	This 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.
UDPNIOBindingHandler.Builder
UDPNIOConnection	Connection implementation for the UDPNIOTransport
UDPNIOConnectorHandler	UDP NIO transport client side ConnectorHandler implementation
UDPNIOConnectorHandler.Builder
UDPNIOServerConnection	Server Connection implementation for the UDPNIOTransport
UDPNIOTemporarySelectorReader
UDPNIOTemporarySelectorWriter
UDPNIOTransport	UDP NIO transport implementation
UDPNIOTransportBuilder	NIOTransportBuilder implementation for UDP.
UDPNIOTransportFilter	The UDPNIOTransport's transport Filter implementation
UnsafeFutureImpl<R>	Simple thread-unsafe Future implementation.
WorkerThread	Interface, which Grizzly thread pool threads should implement.
WorkerThreadIOStrategy	IOStrategy, which executes Processors in worker thread.
WorkerThreadPoolConfigProducer	Strategy implementations may implement this interface to signify they have certain thread pool configuration requirements that could be used when building the runtime.
WrapperAware	MemoryManagers, which implement this interface, are able to convert frequently used Java buffer types to Grizzly Buffer.
WritableMessage	Common interface for entities that may be written to a Channel.
Writeable<L>	Implementations of this interface are able to write data from a Buffer.
WriteHandler	Callback notification mechanism that signals the developer it's possible to write content.
Writer<L>	Implementations of this interface are able to write data from a Buffer to Connection.
Writer.Reentrant	Write reentrants counter
WriteResult<K,L>	Result of write operation, returned by Writeable.