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.
AbstractMultivaluedMap<K,V>	Abstract skeleton implementation of a MultivaluedMap that is backed by a [key, multi-value] store represented as a Map<K, List<V>>.
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.
AccessLogAppender	An interface defining an appender for Grizzly access logs entries.
AccessLogBuilder	A simple builder to configure access logging for Grizzly.
AccessLogFormat	An interface defining a component capable of formatting Responses into printable access log entries.
AccessLogProbe	A Grizzly probe used to provide access logs generation.
ActivityCheckFilter	The Filter is responsible for tracking Connection activity and closing Connection ones it becomes idle for certain amount of time.
ActivityCheckFilter.TimeoutHandler
AddOn	The HttpServer addon interface, responsible for adding features like WebSockets, Comet to HttpServer.
AfterServiceListener	The listener, which could be registered on a Request using Request.addAfterServiceListener(org.glassfish.grizzly.http.server.AfterServiceListener) and be notified once the Request processing will be completed.
AggregatorAddOn	AggregatorAddOn installs AggregatorAddOn.AggregatorFilter into HttpServer FilterChain.
AlternateDocBase
AnnotatedEndpoint	Endpoint descendant which represents deployed annotated endpoint.
ApacheLogFormat	An AccessLogFormat using a standard vaguely similar and heavily influenced by Apache's own custom access log formats.
Appendable<T>
Appender<E>
Application	Java class for anonymous complex type
ApplicationEventListener	Listens to application-level events that are interesting for monitoring.
ArraySet<T>	The thread safe set implementation, which uses array to hold its elements.
ArrayUtils	Set of utility methods to work with Arrays.
Ascii	This class implements some basic ASCII character handling functions.
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.
AuthConfig	AuthConfig serves as a configuration of HTTP authentication.
AuthConfig.Builder	The AuthConfig.Builder is a class used for creating an instance of AuthConfig for purpose of HTTP Authentication.
AuthenticationException	This exception is set as a cause of DeploymentException thrown when WebSocketContainer.connectToServer(...)
Authenticator	Authenticator provides a way how to plug-in custom authentication provider.
B2CConverter	Efficient conversion of bytes to character .
B2CConverterBlocking	Efficient conversion of bytes to character .
BackendConfiguration	This configuration might be useful, when Grizzly HttpServer is running behind an HTTP gateway like reverse proxy, load balancer etc...
Base	Base
BaseContainer	Base WebSocket container.
BaseContainer.ShutDownCondition
BaseFilter	Provides empty implementation for Filter processing methods.
Beta	Marker of a public Tyrus API that is still in "beta" non-final version.
BinaryFrame	Binary frame representation.
BinaryNIOInputSource	Adds the ability for binary based InputSources to obtain the incoming Buffer directly without having to use intermediate objects to copy the data to.
BinaryNIOOutputSink	Adds the ability for binary based OutputSinks to write a Buffer instead of having to convert to those types supported by OutputStream.
BinTree	BinTree
BitTreeDecoder	BitTreeDecoder
BitTreeEncoder	BitTreeEncoder
BroadcastListener	Broadcast listener.
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
BufferChunk	Buffer chunk representation.
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.
ByteChunk	This class is used to represent a chunk of bytes, and utilities to manipulate byte[].
ByteChunk.ByteInputChannel
ByteChunk.ByteOutputChannel
C2BConverter	Efficient conversion of character to bytes.
Cacheable
CacheableDataChunk	DataChunk implementation, which could be cached in the thread cache.
ChainProcessorSelector	ProcessorSelector implementation, which acts like wrapper for chain of ProcessorSelectors.
ChangeListener<E>
ChannelConfigurator	Configurator responsible for initial SelectableChannel configuration.
CharChunk	Utilities to manipulate char chunks.
CharChunk.CharInputChannel
CharChunk.CharOutputChannel	When we need more space we'll either grow the buffer ( up to the limit ) or send it to a channel.
Charsets	Charset utility class.
Chunk	General interface for CharChunk and BufferChunk.
ChunkedTransferEncoding	Chunked transfer encoding implementation.
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
ClassLoaderUtil	Simple ClassLoader utility.
ClientContainer	Entry point for client implementation.
ClientEndpoint	The ClientEndpoint annotation a class level annotation is used to denote that a POJO is a web socket client and can be deployed as such.
ClientEndpointConfig	The ClientEndpointConfig is a special kind of endpoint configuration object that contains web socket configuration information specific only to client endpoints.
ClientEndpointConfig.Builder	The ClientEndpointConfig.Builder is a class used for creating ClientEndpointConfig objects for the purposes of deploying a client endpoint.
ClientEndpointConfig.Configurator	The Configurator class may be extended by developers who want to provide custom configuration algorithms, such as intercepting the opening handshake, or providing arbitrary methods and algorithms that can be accessed from each endpoint instance configured with this configurator.
ClientEngine	Facade for handling client operations from containers.
ClientEngine.ClientUpgradeInfo	Upgrade process result.
ClientEngine.ClientUpgradeStatus	Status of upgrade process.
ClientEngine.TimeoutHandler	Indicates to container that handshake timeout was reached.
ClientManager	ClientManager implementation.
ClientManager.ReconnectHandler	Reconnect handler.
ClientProperties	Tyrus client configuration properties.
Closeable	General asynchronous closable interface.
CloseFrame	Close frame representation.
CloseListener<T extends Closeable,C extends ICloseType>	The listener, which is used to be notified, when Connection gets closed.
CloseReason	A class encapsulating the reason why a web socket has been closed, or why it is being asked to close.
CloseReason	An object, describing the reason why Connection was closed.
CloseReason.CloseCode	A marker interface for the close codes.
CloseReason.CloseCodes	An Enumeration of status codes for a web socket close that are defined in the specification.
CloseReasons	Enum containing standard CloseReasons defined in RFC 6455, see chapter 7.4.1 Defined Status Codes.
CloseType
CLStaticHttpHandler	HttpHandler, which processes requests to a static resources resolved by a given ClassLoader.
ClusterContext	Cluster related context.
Codec<K,L>	Codec is able to transform the original message to a custom represantation and vise versa.
CodecFilter<K,L>
CoderAdapter	Adapter for Encoder and Decoder which implements lifecycle methods.
CoderWrapper<T>	Wrapper of coders storing the coder coder class (and optionally coder instance), return type of the encode / decode method and coder class.
CompletionHandler<E>	Interface, which will be used by Grizzly to notify about asynchronous I/O operations status updates.
CompletionHandler<E>	A callback to notify about asynchronous I/O operations status updates.
CompletionHandlerAdapter<A,B>
ComponentProvider	Provides an instance.
ComponentProviderService	Provides an instance of component.
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.
CompressionConfig	Compression configuration class.
CompressionConfig.CompressionMode
CompressionConfig.CompressionModeI	Common CompressionMode interface.
CompressionEncodingFilter
CompressionLevel	Deprecated. pls. use org.glassfish.grizzly.http.Compression#CompressionLevel.
Condition
Connection<L>	Common interface, which represents any kind of connection.
Connection	A logical websocket connection.
Connection.CloseListener	Deprecated. use CloseListener
Connection.CloseListener	Transport close listener that receives connection close notifications from Tyrus.
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.
Constants	Constants.
Constants	Constants.
ContainerProvider	Provider class that allows the developer to get a reference to the implementation of the WebSocketContainer.
ContentEncoding	Abstraction, which represents HTTP content-encoding.
ContentEncodingException
ContentType	This class serves as a Content-Type holder, plus it implements useful utility methods to work with content-type.
ContentType.SettableContentType	Mutable ContentType object.
Context	Object, which is responsible for holding context during I/O event processing.
Context.MinimalisticArrayList<E>
Cookie	Creates a cookie, a small amount of information sent by a servlet to a Web browser, saved by the browser, and later sent back to the server.
CookieHeaderGenerator	Cookie header generator based on RFC6265
CookieHeaderParser	Cookie header parser based on RFC6265
CookieParserUtils	The set of Cookie utility methods for cookie parsing.
Cookies	A collection of cookies - reusable and tuned for server side performance.
CookiesBuilder	Cookies builder, which could be used to construct a set of cookies, either client or server.
CookiesBuilder.AbstractCookiesBuilder<E extends CookiesBuilder.AbstractCookiesBuilder>
CookiesBuilder.ClientCookiesBuilder
CookiesBuilder.ServerCookiesBuilder
CookieSerializerUtils	The set of Cookie utility methods for cookie serialization.
CookieUtils	The general set of Cookie utility methods.
Copyable	General interface for the objects, that could be copied/cloned.
CRC	CRC
Credentials	Credentials can be used when configuring authentication properties used during client handshake.
DataChunk	Buffer chunk representation.
DataChunk.Type
DebugContext	A Logger wrapper that gives logging records a common formatting and temporarily stores log records and postpones their logging until they can be provided with a session ID.
DebugContext.TracingThreshold	Tracing threshold - used for configuration granularity of information that will be sent in tracing headers.
DebugContext.TracingType	Type of tracing - used for tracing configuration.
DebugContext.Type	Type of the record - used to graphically distinguish these message types in the log.
DebugPoint	Utility class, which may stores the current execution position to help tracking threading issues.
DecodeException	A general exception that occurs when trying to decode a custom object from a text or binary message.
Decoder	The Decoder interface holds member interfaces that define how a developer can provide the web socket container a way web socket messages into developer defined custom objects.
Decoder	RangeDecoder
Decoder.Binary<T>	This interface defines how a custom object (of type T) is decoded from a web socket message in the form of a byte buffer.
Decoder.BinaryStream<T>	This interface defines how a custom object is decoded from a web socket message in the form of a binary stream.
Decoder.LiteralDecoder
Decoder.LiteralDecoder.Decoder2
Decoder.State
Decoder.Text<T>	This interface defines how a custom object is decoded from a web socket message in the form of a string.
Decoder.TextStream<T>	This interface defines how a custom object of type T is decoded from a web socket message in the form of a character stream.
DefaultAttributeBuilder	Default AttributeBuilder implementation.
DefaultComponentProvider	Provides instances using reflection.
DefaultErrorPageGenerator	Default Grizzly ErrorPageGenerator.
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
DefaultSessionManager	Default SessionManager implementation.
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.
DeploymentException	Checked exception indicating some kind of failure either to publish an endpoint on its server, or a failure to connect a client to its server.
DeploymentHandshakeException	The DeploymentException wrapping the HandshakeException and makes the HTTP status code accessible directly.
DirContext	The directory service interface, containing methods for examining and updating attributes associated with objects, and for searching the directory.
DirectByteBufferRecord	Thread-local Direct ByteBuffer storage.
DispatcherHelper	Interface simplifies by path or name mapping.
DistributedSession	Extended Session which adds distributed properties.
EchoFilter	Echo Filter implementation
EmptyCompletionHandler<E>	Empty implementation for CompletionHandler interface.
EncodeException	A general exception that occurs when trying to encode a custom object to a string or binary message.
Encoder	The Encoder interface defines how developers can provide a way to convert their custom objects into web socket messages.
Encoder	RangeEncoder
Encoder.Binary<T>	This interface defines how to provide a way to convert a custom object into a binary message.
Encoder.BinaryStream<T>	This interface may be implemented by encoding algorithms that want to write the encoded object to a binary stream.
Encoder.Text<T>	This interface defines how to provide a way to convert a custom object into a text message.
Encoder.TextStream<T>	This interface may be implemented by encoding algorithms that want to write the encoded object to a character stream.
EncodingFilter
Endpoint	The Web Socket Endpoint represents an object that can handle websocket conversations.
Endpoint	Java class for anonymous complex type
EndpointConfig	The endpoint configuration contains all the information needed during the handshake process for this end point.
EndpointEventListener	Listens to endpoint-level events that are interesting for monitoring.
Enumerator<E>	HttpHandler class that wraps an Enumeration around a Java2 collection classes object Iterator so that existing APIs returning Enumerations can easily run on top of the new collections.
ErrorCollector	Used to collect deployment errors to present these to the user together.
ErrorPageGenerator	Error page generator interface, which is responsible for generating of an error page corresponding to the given response status.
ExceptionHandler
ExceptionHandler.Severity
Exceptions	Exceptions utilities.
Exceptions	Converts the exceptions into more specific ones.
ExecutorServiceProvider
ExpandJar	Expand out a jar.
ExtendedExtension	WebSocket Extension.
ExtendedExtension.ExtensionContext	Context present as a parameter in all ExtendedExtension methods.
Extension	A simple representation of a websocket extension as a name and map of extension parameters.
Extension.Parameter	This member interface defines a single websocket extension parameter.
FastDateFormat	Fast date formatter that caches recently formatted date information and uses it to avoid too-frequent calls to the underlying formatter.
FastHttpDateFormat	Utility class to generate HTTP dates.
FileAppender	An appender writing log entries to Files.
FileCache	This class implements a file caching mechanism used to cache static resources.
FileCache.CacheResult
FileCache.CacheType
FileCacheEntry	The entry value in the file cache map.
FileCacheFilter
FileCacheKey	The entry key in the file cache map.
FileCacheProbe	Monitoring probe providing callbacks that may be invoked by Grizzly FileCache.
FileCacheProbe.Adapter	FileCacheProbe adapter that provides no-op implementations for all interface methods allowing easy extension by the developer.
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.
FixedLengthTransferEncoding	Fixed length transfer encoding implementation.
FixedThreadPool	Minimalistic fixed thread pool to allow for nice scalability if a good Queue impl is used.
Frame	WebSocket frame representation.
Frame.Builder	Frame builder.
FutureImpl<R>	Future interface, which has full control over the state.
Futures	Set of Future utilities.
GenericAdapter<K,V>	Generic Adapter interface.
GenericCloseListener	Deprecated.
Globals	Global constants that are applicable to multiple packages within Catalina.
GracefulShutdownListener	Interface to notify interested parties that a Transport is being shutdown.
Grizzly	Class contains information about Grizzly framework.
GrizzlyClientContainer
GrizzlyClientProperties	Grizzly client properties.
GrizzlyClientSocket	Implementation of the WebSocket interface.
GrizzlyContainerProvider
GrizzlyExecutorService
GrizzlyFuture<R>	Grizzly Future implementation.
GrizzlyJmxManager	Grizzly JMX manager
GrizzlyPrincipal	Generic implementation of java.security.Principal that is used to represent principals authenticated at the protocol handler level.
GrizzlyWriter
GZipContentEncoding	GZip ContentEncoding implementation, which compresses/decompresses HTTP content using gzip algorithm.
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.
Handshake	Class responsible for performing and validating handshake.
HandshakeException	Exception, which describes the error, occurred during the handshake phase.
HandshakeResponse	The handshake response represents the WebSocket-defined HTTP response that is the response to the opening handshake request.
Header	Enumeration of all headers as defined in RFC 2616.
HeaderValue	This class serves as an HTTP header value holder, plus it implements useful utility methods to optimize headers serialization.
HeapBuffer	Buffer implementation, which uses the ByteBuffer underneath.
HeapMemoryManager	A WrapperAware MemoryManager implementation for managing HeapBuffer instances.
HexUtils	Library of utility methods useful in dealing with converting byte arrays to and from strings of hexadecimal digits.
Holder<E>	The object holder, which might be used for lazy object initialization.
Holder.IntHolder
Holder.LazyHolder<E>
Holder.LazyIntHolder
HtmlHelper	Utility class used to generate HTML pages.
HttpBaseFilter	Base HTTP Filter.
HttpBrokenContent	HttpContent message, which represents broken HTTP content.
HttpBrokenContent.Builder	HttpTrailer message builder.
HttpBrokenContentException	RuntimeException, means something wrong happened during HTTP message content parsing.
HttpClientFilter	Client side HttpCodecFilter implementation, which is responsible for decoding HttpResponsePacket and encoding HttpRequestPacket messages.
HttpCodecFilter	The Filter, responsible for transforming Buffer into HttpPacket and vice versa in asynchronous mode.
HttpCodecFilter.ContentParsingState
HttpCodecFilter.HeaderParsingState
HttpCodecUtils	General HttpCodec utility methods.
HttpContent	Object represents HTTP message content: complete or part.
HttpContent.Builder<T extends HttpContent.Builder>	HttpContent message builder.
HttpContext	Represents a single logical HTTP transaction.
HttpEvents	The class contains a set of standard HTTP events sent on FilterChain during HTTP packets processing.
HttpEvents.ChangePacketInProgressEvent
HttpEvents.IncomingHttpUpgradeEvent
HttpEvents.OutgoingHttpUpgradeEvent
HttpEvents.ResponseCompleteEvent
HttpHandler	Base class to use when Request/Response/InputStream/OutputStream are needed to implement a customized HTTP container/extension to the HTTP module.
HttpHandlerChain	The HttpHandlerChain class allows the invocation of multiple HttpHandlers every time a new HTTP request is ready to be handled.
HttpHandlerRegistration	Class representing HttpHandler registration information on a HttpServer.
HttpHandlerRegistration.Builder
HttpHeader	HttpPacket, which represents HTTP message header.
HttpHeader.Builder<T extends HttpHeader.Builder>	HttpHeader message builder.
HttpPacket	Abstraction, which represents any type of HTTP message: HttpRequestPacket, HttpResponsePacket, HttpContent.
HttpPacketParsing
HttpPipelineOptAddOn	The plugin, that optimizes processing of pipelined HTTP requests by buffering HTTP responses and then writing them as one operation.
HttpProbe	Monitoring probe providing callbacks that may be invoked by Grizzly Http filters.
HttpProbe.Adapter	HttpProbe adapter that provides no-op implementations for all interface methods allowing easy extension by the developer.
HttpRequestPacket	The HttpHeader object, which represents HTTP request message.
HttpRequestPacket.Builder	HttpRequestPacket message builder.
HttpRequestURIDecoder	Utility class that make sure an HTTP url defined inside a MessageBytes is normalized, converted and valid.
HttpResponsePacket	The HttpHeader object, which represents HTTP response message.
HttpResponsePacket.Builder	HttpResponsePacket message builder.
HttpServer
HttpServerFilter	Server side HttpCodecFilter implementation, which is responsible for decoding HttpRequestPacket and encoding HttpResponsePacket messages.
HttpServerFilter	Filter implementation to provide high-level HTTP request/response processing.
HttpServerMonitoringConfig	Grizzly web server monitoring config.
HttpServerProbe	Monitoring probe providing callbacks that may be invoked by Grizzly HttpServerFilter.
HttpServerProbe.Adapter	HttpServerProbe adapter that provides no-op implementations for all interface methods allowing easy extension by the developer.
HttpStatus	This enum encapsulates the HTTP response status and reason phrases as defined by RFC 2616.
HttpTrailer	HttpContent message, which represents HTTP trailer message.
HttpTrailer.Builder	HttpTrailer message builder.
HttpUtils	Utility class.
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
InputBuffer	Abstraction exposing both byte and character methods to read content from the HTTP messaging system in Grizzly.
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.
InputStreamDecoder	Built in Decoder for InputStream.
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.
JmxEventListener	Notify implementations when JMX is enabled on a HttpServer instance.
KeepAlive	Web container configuration for keep-alive HTTP connections.
KeepAliveProbe	Monitoring probe providing callbacks that may be invoked by Grizzly KeepAlive.
KeepAliveProbe.Adapter	KeepAliveProbe adapter that provides no-op implementations for all interface methods allowing easy extension by the developer.
LazyCookieState	Lazy cookie implementation, which is based on preparsed Grizzly Buffers.
LazyFileCacheKey	Lazy FileCacheKey object.
LazyValue<T>	Lazily initialized value.
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.
Localizable	Localizable message.
LocalizableMessage
LocalizableMessage
LocalizableMessageFactory
LocalizableMessageFactory
LocalizationMessages	Defines string formatting method for each constant in the resource file
Localizer	Localizes the Localizable into a message by using a configured Locale.
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
LZMAContentEncoding
LZMADecoder
LZMADecoder.LZMAInputState
LZMAEncoder
LZMAEncoder.LZMAOutputState
LZMAEncoder.LZMAProperties
LZMAFilter
Mapper	Mapper, which implements the servlet API mapping rules (which are derived from the HTTP rules).
Mapper.Context
Mapper.ContextList
Mapper.Host
Mapper.MapElement
Mapper.Wrapper
MappingData	Mapping data.
MaskingKeyGenerator	Can be implemented to generate masking keys.
Match	Defines a match on an endpoint.
MaxSessions	This annotation may be used to annotate server endpoints as a optional annotation to ServerEndpoint.
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.
MessageBytes	This class is used to represent a subarray of bytes in an HTTP message.
MessageBytes.MessageBytesFactory
MessageCloner<E>	Cloner, which will be called by AsyncQueueWriter, when message could not be written directly, and will be added to the queue.
MessageEventListener	Listens for message-level events that are interesting for monitoring.
MessageHandler	Developers implement MessageHandlers in order to receive incoming messages during a web socket conversation.
MessageHandler.Partial<T>	This kind of handler is notified by the implementation as it becomes ready to deliver parts of a whole message.
MessageHandler.Whole<T>	This kind of handler is notified by the container on arrival of a complete message.
MessageHandlerManager	Manages registered MessageHandlers and checks whether the new ones may be registered.
Method	Predefined HTTP methods
Method.PayloadExpectation
MimeHeaders	Memory-efficient repository for Mime Headers.
MimeHeadersPacket	Common interface for HttpPackets, which contain mimeheaders.
MimeType	Hardcoded mime-type supported by default.
Monitorable	Interface that allows arbitrary entities to provide a JmxObject that can be registered with the org.glassfish.grizzly.monitoring.jmx.GrizzlyJmxManager.
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.
MultivaluedHashMap<K,V>	A hash table based implementation of MultivaluedMap interface.
MultivaluedMap<K,V>	A map of key-values pairs.
MultivaluedStringMap	An implementation of MultivaluedMap where keys and values are instances of String.
NamingContext	This interface represents a naming context, which consists of a set of name-to-object bindings.
NamingException	This is the superclass of all exceptions thrown by operations in the Context and DirContext interfaces.
NetworkListener
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.
NIOInputStream	Stream implementation to read binary request content.
NIOOutputStream	Stream implementation for writing binary content to an HTTP user-agent.
NIOReader	Character stream implementation used to read character-based request content.
NIOTransport
NIOTransportBuilder<T extends NIOTransportBuilder>	This builder is responsible for creating NIOTransport implementations as well as providing basic configuration for IOStrategies and thread pools.
NIOWriter	Stream implementation for writing character content to an HTTP user-agent.
NoOpByteArrayCoder	Encoder and Decoder implementation for byte array.
NoOpByteBufferCoder	Encoder and Decoder implementation for ByteBuffer.
NoOpTextCoder
Note<E>	The Note value associated with HttpRequestPacket.
ObjectFactory	This object contains factory methods for each Java content interface and Java element interface generated in the org.glassfish.tyrus.core.wsadl.model package.
ObjectPool<E extends PoolableObject>	Basic interface for object pool implementations
OnClose	This method level annotation can be used to decorate a Java method that wishes to be called when a web socket session is closing.
OnError	This method level annotation can be used to decorate a Java method that wishes to be called in order to handle errors.
OnMessage	This method level annotation can be used to make a Java method receive incoming web socket messages.
OnOpen	This method level annotation can be used to decorate a Java method that wishes to be called when a new web socket session is open.
OsgiRegistry	Taken from Jersey 2.
Output
OutputBuffer	Abstraction exposing both byte and character methods to write content to the HTTP messaging system in Grizzly.
OutputBuffer.LifeCycleListener
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.
ParameterMap	Extended implementation of LinkedHashMap that includes a locked property.
Parameters
ParsingResult	Class, which represents result of TransferEncoding or ContentEncoding parsing.
PathPattern	A path pattern that is a regular expression generated from a URI path template.
PathPattern.RightHandPath	The set of right hand path patterns that may be appended to a path pattern.
PathSegment	Represents a URI path segment and any associated matrix parameters.
PathTemplate	A URI template for a URI path.
PatternWithGroups	A pattern for matching a string against a regular expression and returning capturing group values for any capturing groups present in the expression.
PendingWriteQueueLimitExceededException	Thrown when an attempt is made to add a record that exceeds the configured maximum queue size.
PingFrame	Ping frame representation.
PongFrame	Pong frame representation.
PongMessage	The PongMessage interface represents a web socket pong.
PoolableObject
PooledMemoryManager	A MemoryManager implementation based on a series of shared memory pools.
PortRange	Immutable class representing a port range.
PrimitiveDecoders<T>	Collection of decoders for all primitive types.
PrimitiveDecoders.BooleanDecoder
PrimitiveDecoders.ByteDecoder
PrimitiveDecoders.CharacterDecoder
PrimitiveDecoders.DoubleDecoder
PrimitiveDecoders.FloatDecoder
PrimitiveDecoders.IntegerDecoder
PrimitiveDecoders.LongDecoder
PrimitiveDecoders.ShortDecoder
ProcessingState	Maintains semantic state necessary to proper HTTP processing.
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
Protocol	Predefined HTTP protocol versions
ProtocolException	Represents issue with parsing or producing websocket frame.
ProtocolHandler	Tyrus protocol handler.
PushBackContext	Deprecated. push back logic is deprecated.
PushBackHandler	Deprecated. push back logic is deprecated.
PushBuilder	Build a request to be pushed.
PushEvent	A FilterChainEvent to trigger an HTTP/2 push promise and trigger a new request to be sent upstream to generate a response for said push promise.
PushEvent.PushEventBuilder	Construct a new PushEvent.
QueueingAppender	An appender enqueueing log entries into a LinkedBlockingQueue and using a secondary, separate Thread to forward them to a configured nested appender.
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.
ReaderDecoder	Built in Decoder for Reader.
ReadHandler	Deprecated. please use ReadHandler
ReadHandler	This class represents a call-back mechanism that will notify implementations as more input data becomes available to read without blocking.
ReadHandler	Read handler provides a way for a transport to pass websocket connection data to tyrus runtime.
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.
RedirectException	This exception is set as a cause of DeploymentException thrown from WebSocketContainer.connectToServer(...)
ReflectionHelper	Utility methods for Java reflection.
ReflectionHelper.ClassTypePair	A tuple consisting of a class and type of the class.
ReflectionHelper.DeclaringClassInterfacePair	A tuple consisting of a concrete class, declaring class that declares a generic interface type.
ReflectionHelper.TypeClassPair
RegisterChannelResult
RemoteEndpoint	The RemoteEndpoint object is supplied by the container and represents the 'other end' or peer of the Web Socket conversation.
RemoteEndpoint.Async	This representation of the peer of a web socket conversation has the ability to send messages asynchronously.
RemoteEndpoint.Basic	This representation of the peer of a web socket conversation has the ability to send messages synchronously.
RemoteSession	Remote session represents session originating from another node.
RemoteSession.DistributedMapKey
Request	Wrapper object for the Coyote request.
Request.PathResolver
RequestContext	Implementation of all possible request interfaces.
RequestContext.Builder	RequestContext builder.
RequestContext.Builder.IsUserInRoleDelegate	Is user in role delegate.
RequestExecutorProvider	An implementation of this interface will be responsible for executing user's code in HttpHandler.service(org.glassfish.grizzly.http.server.Request, org.glassfish.grizzly.http.server.Response) and notifying ReadHandler, WriteHandler registered by the user.
RequestExecutorProvider.SameThreadProvider	The RequestExecutorProvider implementation, which always returns null to force the user code to be executed on the current Thread.
RequestExecutorProvider.WorkerThreadProvider	The RequestExecutorProvider implementation, which checks if the current Thread is a service Thread (see Threads.isService()).
RequestURIRef	Request URI holder.
RequestUtils
RerunFilterAction	This NextAction instructs the FilterChain to rerun the same Filter again.
Response	Wrapper object for the Coyote response.
Result	Common I/O result interface.
ResultAware<E>
RetryAfterException	This exception is set as a cause of DeploymentException thrown from WebSocketContainer.connectToServer(...) when HTTP response status code 503 - Service Unavailable is received.
RotatingFileAppender	An appender writing log entries to Files, and rotating/archiving them when necessary.
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.
SendHandler	A simple callback object for asynchronous sending of web socket messages.
SendResult	The result of asynchronously sending a web socket message.
ServerConfiguration	Configuration options for a particular HttpServer instance.
ServerContainer	HTTP server abstraction.
ServerContainerFactory	Factory used to get instances of ServerContainer.
ServerEndpointConfigWrapper	A public class that holds a wrapped ServerEndpointConfig.
ServerFilterConfiguration	HttpServerFilter configuration.
ServerInputBuffer	Server-side implementation of the InputBuffer.
ServerOutputBuffer
ServiceConfigurationError	Error thrown when something goes wrong while looking up service providers.
ServiceConfigurationError	Taken from Jersey 2.
ServiceFinder<T>	A simple service-provider lookup mechanism.
ServiceFinder<T>	A simple service-provider lookup mechanism.
ServiceFinder.DefaultServiceIteratorProvider	The default service iterator provider that looks up provider classes in META-INF/services files.
ServiceFinder.ServiceIteratorProvider	Supports iteration of provider instances or classes.
Session	A Web Socket session represents a conversation between two web socket endpoints.
Session	Simple session object.
SessionEventListener	Session event listener.
SessionException	A SessionException represents a general exception type reporting problems occurring on a websocket session.
SessionListener	Session listener.
SessionManager	HTTP session manager abstraction responsible for keeping track of HTTP session associated with a user Request.
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.
SimpleDateFormats
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 ssl context.
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	SSLEngineConfigurator class from Grizzly project.
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>
StaticHttpHandler	HttpHandler, which processes requests to a static resources.
StaticHttpHandlerBase	The basic class for HttpHandler implementations, which processes requests to a static resources.
Stream	Common interface for Stream readers and writers.
StreamAppender	An appender writing log entries to an OutputStream.
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.
StrictUtf8
StrictUtf8.Parser	Surrogate parsing support.
StringCache	This class implements a String cache for ByteChunk and CharChunk.
StringCache.ByteEntry
StringCache.CharEntry
StringDecoder	String decoder, which decodes Buffer to String
StringEncoder	String decoder, which decodes Buffer to String
StringFilter	StringFilter implementation, which performs Buffer <-> String transformation.
StringManager	An internationalization / localization helper class which reduces the bother of handling ResourceBundles and takes care of the common cases of message formatting which otherwise require the creation of Object arrays and such.
StringParser	Utility class for string parsing that is higher performance than StringParser for simple delimited text cases.
SupplierWithEx<T,EX extends java.lang.Exception>
SuspendContext	Interface represents a context of the suspended Response.
SuspendStatus	The request/response suspend status bound to a specific thread.
SyncThreadPool	ExecutorService implementation, which function the similar way as former Grizzly 1.x Pipeline based thread pools.
TaskProcessor	A class responsible for processing TaskProcessor.Task.
TaskProcessor.Condition	Condition used in TaskProcessor.processTask(org.glassfish.tyrus.container.grizzly.client.TaskProcessor.Task).
TaskProcessor.Task	Generic task representation.
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
TextFrame	Text frame representation.
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).
ThreadPoolConfig	Client thread pool configuration, which might be used to customize client thread pool.
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.
TimeoutHandler	Handler, which processes suspended Response timeout and is able to either confirm it or reset.
TimeStamp	Main tool for object expiry.
ToStringEncoder	Fall-back encoder - encoders any object to string using Object.toString() method.
TransferEncoding	Abstraction, which represents HTTP transfer-encoding.
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.
TyrusClientEndpointConfigurator	Extended Configurator that can be used for subclassing the user provided configurator.
TyrusClientEngine	Tyrus ClientEngine implementation.
TyrusClientEngine.ClientHandshakeListener	Called when response is received from the server.
TyrusConfiguration	Inner Tyrus configuration properties holder object.
TyrusConfiguration.Builder
TyrusEndpointWrapper	Wraps the registered application class.
TyrusEndpointWrapper.SessionListener	Session listener.
TyrusEndpointWrapper.SessionListener.OnOpenResult	Result of TyrusEndpointWrapper.SessionListener.onOpen(TyrusSession).
TyrusExtension	WebSocket Extension implementation.
TyrusExtension.TyrusParameter	WebSocket Extension.Parameter implementation.
TyrusFrame	Frame representation used in Tyrus runtime.
TyrusFrame.FrameType	An Enumeration of frame types.
TyrusFuture<T>	Tyrus Future implementation.
TyrusRemoteEndpoint	Wraps the RemoteEndpoint and represents the other side of the websocket connection.
TyrusServerEndpointConfig	Configuration ServerEndpointConfig enhanced to offer tyrus specific attributes like maxSessions.
TyrusServerEndpointConfig.Builder	The TyrusServerEndpointConfig.Builder is a class used for creating TyrusServerEndpointConfig.Builder objects for the purposes of deploying a server endpoint.
TyrusServerEndpointConfigurator	Tyrus' implementation of ServerEndpointConfig.Configurator.
TyrusSession	Implementation of the Session.
TyrusUpgradeResponse	HTTP response representation.
TyrusWebSocket	Tyrus representation of web socket connection.
TyrusWebSocketEngine	WebSocketEngine implementation, which handles server-side handshake, validation and data processing.
TyrusWebSocketEngine.TyrusWebSocketEngineBuilder	TyrusWebSocketEngine builder.
UDecoder	All URL decoding happens here.
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
UEncoder	Efficient implementation for encoders.
UnsafeFutureImpl<R>	Simple thread-unsafe Future implementation.
UpgradeRequest	Abstraction for a HTTP upgrade request.
UpgradeResponse	Abstraction for a HTTP upgrade response.
UriComponent	Utility class for validating, encoding and decoding components of a URI.
UriComponent.Type	The URI component type.
UriTemplate	A URI template.
UriTemplateParser	A URI template parser that parses JAX-RS specific URI templates.
URLDecoder
Utf8DecodingException	TODO
Utils	Utility methods shared among Tyrus modules.
Utils.Stringifier<T>	Define to String conversion for various types.
Value<T>	A generic value provider.
Values	A collection of Value provider factory & utility methods.
Version	TODO
WebSocketContainer	A WebSocketContainer is an implementation provided object that provides applications a view on the container running it.
WebSocketEngine	WebSocket engine is used for upgrading HTTP requests into websocket connections.
WebSocketEngine.UpgradeInfo	Upgrade info that includes status for HTTP request upgrading and connection creation details.
WebSocketEngine.UpgradeStatus	Upgrade Status for HTTP request upgrading.
WebSocketException	WebSocketException can be thrown during runtime (after handshake).
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	Deprecated. please use WriteHandler
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	Writer class that is used by tyrus runtime to pass outbound websocket data for a connection to a transport.
Writer.Reentrant	Write reentrants counter
WriteResult<K,L>	Result of write operation, returned by Writeable.
WriterInfo	Additional data for the transport.
WriterInfo.MessageType	Possible WebSocket Message Types.
WriterInfo.RemoteEndpointType