Data Structures

Here are the data structures with brief descriptions:

Nactivemq	Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements
Ncmsutil
CCachedConsumer	A cached message consumer contained within a pooled session
CCachedProducer	A cached message producer contained within a pooled session
CCmsAccessor	Base class for activemq.cmsutil.CmsTemplate and other CMS-accessing gateway helpers, defining common properties such as the CMS cms.ConnectionFactory to operate on
CCmsDestinationAccessor	Extends the CmsAccessor to add support for resolving destination names
CCmsTemplate	CmsTemplate simplifies performing synchronous CMS operations
CProducerExecutor
CResolveProducerExecutor
CSendExecutor
CReceiveExecutor
CResolveReceiveExecutor
CDestinationResolver	Resolves a CMS destination name to a Destination
CDynamicDestinationResolver	Resolves a CMS destination name to a Destination
CMessageCreator	Creates the user-defined message to be sent by the CmsTemplate
CPooledSession	A pooled session object that wraps around a delegate session
CProducerCallback	Callback for sending a message to a CMS destination
CResourceLifecycleManager	Manages the lifecycle of a set of CMS resources
CSessionCallback	Callback for executing any number of operations on a provided CMS Session
CSessionPool	A pool of CMS sessions from the same connection and with the same acknowledge mode
Ncommands
CActiveMQBlobMessage
CActiveMQBytesMessage
CActiveMQDestination
CDestinationFilter
CActiveMQMapMessage
CActiveMQMessage
CActiveMQMessageTemplate
CActiveMQObjectMessage
CActiveMQQueue
CActiveMQStreamMessage
CActiveMQTempDestination
CActiveMQTempQueue
CActiveMQTempTopic
CActiveMQTextMessage
CActiveMQTopic
CBaseCommand
CBaseDataStructure
CBooleanExpression
CBrokerError	This class represents an Exception sent from the Broker
CStackTraceElement
CBrokerId
CBrokerInfo
CCommand
CConnectionControl
CConnectionError
CConnectionId
CConnectionInfo
CConsumerControl
CConsumerId
CConsumerInfo
CControlCommand
CDataArrayResponse
CDataResponse
CDataStructure
CDestinationInfo
CDiscoveryEvent
CExceptionResponse
CFlushCommand
CIntegerResponse
CJournalQueueAck
CJournalTopicAck
CJournalTrace
CJournalTransaction
CKeepAliveInfo
CLastPartialCommand
CLocalTransactionId
CMessage
CMessageAck
CMessageDispatch
CMessageDispatchNotification
CMessageId
CMessagePull
CNetworkBridgeFilter
CPartialCommand
CPointer	Decaf's implementation of a Smart Pointer that is a template on a Type and is Thread Safe if the default Reference Counter is used
CProducerAck
CProducerId
CProducerInfo
CRemoveInfo
CRemoveSubscriptionInfo
CReplayCommand
CResponse
CSessionId
CSessionInfo
CShutdownInfo
CSubscriptionInfo
CTransactionId
CTransactionInfo
CWireFormatInfo
CXATransactionId
Ncore
Nkernels
CActiveMQConsumerKernel
CActiveMQProducerKernel
CActiveMQSessionKernel
CActiveMQXASessionKernel
CAtomicBoolean	A boolean value that may be updated atomically
CPointer	Decaf's implementation of a Smart Pointer that is a template on a Type and is Thread Safe if the default Reference Counter is used
Npolicies
CDefaultPrefetchPolicy
CDefaultRedeliveryPolicy
CActiveMQAckHandler	Interface class that is used to give CMS Messages an interface to Ack themselves with
CActiveMQConnection	Concrete connection used for all connectors to the ActiveMQ broker
CActiveMQConnectionFactory
CActiveMQConnectionMetaData	This class houses all the various settings and information that is used by an instance of an ActiveMQConnection class
CActiveMQConstants	Class holding constant values for various ActiveMQ specific things Each constant is defined as an enumeration and has functions that convert back an forth between string and enum values
CStaticInitializer
CActiveMQConsumer
CActiveMQDestinationEvent
CActiveMQDestinationSource
CActiveMQMessageAudit
CActiveMQProducer
CActiveMQQueueBrowser
CActiveMQSession
CActiveMQSessionExecutor	Delegate dispatcher for a single session
CActiveMQTransactionContext	Transaction Management class, hold messages that are to be redelivered upon a request to roll-back
CActiveMQXAConnection
CActiveMQXAConnectionFactory
CActiveMQXASession
CAdvisoryConsumer
CArrayPointer	Decaf's implementation of a Smart Pointer that is a template on a Type and is Thread Safe if the default Reference Counter is used
CAtomicBoolean	A boolean value that may be updated atomically
CConnectionAudit	Provides the Auditing functionality used by Connections to attempt to filter out duplicate Messages
CDispatchData	Simple POCO that contains the information necessary to route a message to a specified consumer
CDispatcher	Interface for an object responsible for dispatching messages to consumers
CFifoMessageDispatchChannel
CMessageDispatch
CMessageDispatchChannel
CPointer	Decaf's implementation of a Smart Pointer that is a template on a Type and is Thread Safe if the default Reference Counter is used
CPrefetchPolicy	Interface for a Policy object that controls message Prefetching on various destination types in ActiveMQ-CPP
CRedeliveryPolicy	Interface for a RedeliveryPolicy object that controls how message Redelivery is handled in ActiveMQ-CPP when a transaction is rolled back
CSimplePriorityMessageDispatchChannel
CSynchronization	Transacted Object Synchronization, used to sync the events of a Transaction with the items in the Transaction
Nexceptions
CActiveMQException
CBrokerException
CConnectionFailedException
Nio
CLoggingInputStream
CLoggingOutputStream	OutputStream filter that just logs the data being written
Nlibrary
CActiveMQCPP
Nstate
CAtomicBoolean	A boolean value that may be updated atomically
CCommandVisitor	Interface for an Object that can visit the various Command Objects that are sent from and to this client
CCommandVisitorAdapter	Default Implementation of a CommandVisitor that returns NULL for all calls
CConcurrentStlMap	Map template that wraps around a std::map to provide a more user-friendly interface and to provide common functions that do not exist in std::map
CConnectionState
CConnectionStateTracker
CConsumerState
CLinkedList	A complete implementation of the List interface using a doubly linked list data structure
CPointer	Decaf's implementation of a Smart Pointer that is a template on a Type and is Thread Safe if the default Reference Counter is used
CProducerState
CSessionState
CTracked
CTransactionState
Nthreads
CCompositeTask	Represents a single task that can be part of a set of Tasks that are contained in a CompositeTaskRunner
CCompositeTaskRunner	A Task Runner that can contain one or more CompositeTasks that are each checked for pending work and run if any is present in the order that the tasks were added
CDedicatedTaskRunner
CScheduler	Scheduler class for use in executing Runnable Tasks either periodically or one time only with optional delay
CSchedulerTimerTask	Extension of the Decaf TimerTask that adds a Runnable instance which is the target of this task
CTask	Represents a unit of work that requires one or more iterations to complete
CTaskRunner
Ntransport
Ncorrelator
CCommand
CPointer	Decaf's implementation of a Smart Pointer that is a template on a Type and is Thread Safe if the default Reference Counter is used
CResponse
CResponseCorrelator	This type of transport filter is responsible for correlating asynchronous responses with requests
Nfailover
CBackupTransport
CBackupTransportPool
CCloseTransportsTask
CCommand
CCompositeTaskRunner	A Task Runner that can contain one or more CompositeTasks that are each checked for pending work and run if any is present in the order that the tasks were added
CFailoverTransport
CFailoverTransportFactory	Creates an instance of a FailoverTransport
CFailoverTransportListener	Utility class used by the Transport to perform the work of responding to events from the active Transport
CLinkedList	A complete implementation of the List interface using a doubly linked list data structure
CPointer	Decaf's implementation of a Smart Pointer that is a template on a Type and is Thread Safe if the default Reference Counter is used
CResponse
CURIPool
Ninactivity
CInactivityMonitor
CPointer	Decaf's implementation of a Smart Pointer that is a template on a Type and is Thread Safe if the default Reference Counter is used
CReadChecker	Runnable class that is used by the {
CWriteChecker	Runnable class used by the {
Nlogging
CLoggingTransport	A transport filter that logs commands as they are sent/received
CPointer	Decaf's implementation of a Smart Pointer that is a template on a Type and is Thread Safe if the default Reference Counter is used
Nmock
CCommand
CInternalCommandListener	Listens for Commands sent from the MockTransport
CMockTransport	The MockTransport defines a base level Transport class that is intended to be used in place of an a regular protocol Transport suck as TCP
CMockTransportFactory	Manufactures MockTransports, which are objects that read from input streams and write to output streams
CPointer	Decaf's implementation of a Smart Pointer that is a template on a Type and is Thread Safe if the default Reference Counter is used
CResponse
CResponseBuilder	Interface for all Protocols to implement that defines the behavior of the Broker in response to messages of that protocol
Ntcp
CPointer	Decaf's implementation of a Smart Pointer that is a template on a Type and is Thread Safe if the default Reference Counter is used
CSslTransport	Transport for connecting to a Broker using an SSL Socket
CSslTransportFactory
CTcpTransport	Implements a TCP/IP based transport filter, this transport is meant to wrap an instance of an IOTransport
CTcpTransportFactory	Factory Responsible for creating the TcpTransport
CAbstractTransportFactory	Abstract implementation of the TransportFactory interface, providing the base functionality that's common to most of the TransportFactory instances
CCommand
CCompositeTransport	A Composite Transport is a Transport implementation that is composed of several Transports
CDefaultTransportListener	A Utility class that create empty implementations for the TransportListener interface so that a subclass only needs to override the one's its interested
CFutureResponse	A container that holds a response object
CIOTransport	Implementation of the Transport interface that performs marshaling of commands to IO streams
CList	An ordered collection (also known as a sequence)
CPointer	Decaf's implementation of a Smart Pointer that is a template on a Type and is Thread Safe if the default Reference Counter is used
CResponse
CResponseCallback	Allows an async send to complete at a later time via a Response event
CTransport	Interface for a transport layer for command objects
CTransportFactory	Defines the interface for Factories that create Transports or TransportFilters
CTransportFilter	A filter on the transport layer
CTransportListener	A listener of asynchronous exceptions from a command transport object
CTransportRegistry	Registry of all Transport Factories that are available to the client at runtime
CURI	This class represents an instance of a URI as defined by RFC 2396
Nutil
CActiveMQMessageTransformation
CActiveMQProperties	Implementation of the CMSProperties interface that delegates to a decaf::util::Properties object
CAdvisorySupport	Support class that provides various static constants for use in constructing Destination names for the ActiveMQ advisory destinations
CCMSExceptionSupport
CCompositeData	Represents a Composite URI
CIdGenerator
CLinkedList	A complete implementation of the List interface using a doubly linked list data structure
CLongSequenceGenerator	This class is used to generate a sequence of long long values that are incremented each time a new value is requested
CMarshallingSupport
CMemoryUsage
CPrimitiveList	List of primitives
CPrimitiveMap	Map of named primitives
CPrimitiveValueConverter	Class controls the conversion of data contained in a PrimitiveValueNode from one type to another
CPrimitiveValueNode	Class that wraps around a single value of one of the many types
CPrimitiveValue	Define a union type comprised of the various types
CProperties	Java-like properties class for mapping string names to string values
CService	Base interface for all classes that run as a Service inside the application
CServiceListener	Listener interface for observers of Service related events
CServiceStopper
CServiceSupport	Provides a base class for Service implementations
CSuspendable	Interface for any resouce that support a suspend / resume style of operation
CURI	This class represents an instance of a URI as defined by RFC 2396
CURISupport
CUsage
Nwireformat
Nopenwire
Nmarshal
Ngenerated
CActiveMQBlobMessageMarshaller	Marshaling code for Open Wire Format for ActiveMQBlobMessageMarshaller
CActiveMQBytesMessageMarshaller	Marshaling code for Open Wire Format for ActiveMQBytesMessageMarshaller
CActiveMQDestinationMarshaller	Marshaling code for Open Wire Format for ActiveMQDestinationMarshaller
CActiveMQMapMessageMarshaller	Marshaling code for Open Wire Format for ActiveMQMapMessageMarshaller
CActiveMQMessageMarshaller	Marshaling code for Open Wire Format for ActiveMQMessageMarshaller
CActiveMQObjectMessageMarshaller	Marshaling code for Open Wire Format for ActiveMQObjectMessageMarshaller
CActiveMQQueueMarshaller	Marshaling code for Open Wire Format for ActiveMQQueueMarshaller
CActiveMQStreamMessageMarshaller	Marshaling code for Open Wire Format for ActiveMQStreamMessageMarshaller
CActiveMQTempDestinationMarshaller	Marshaling code for Open Wire Format for ActiveMQTempDestinationMarshaller
CActiveMQTempQueueMarshaller	Marshaling code for Open Wire Format for ActiveMQTempQueueMarshaller
CActiveMQTempTopicMarshaller	Marshaling code for Open Wire Format for ActiveMQTempTopicMarshaller
CActiveMQTextMessageMarshaller	Marshaling code for Open Wire Format for ActiveMQTextMessageMarshaller
CActiveMQTopicMarshaller	Marshaling code for Open Wire Format for ActiveMQTopicMarshaller
CBaseCommandMarshaller	Marshaling code for Open Wire Format for BaseCommandMarshaller
CBrokerIdMarshaller	Marshaling code for Open Wire Format for BrokerIdMarshaller
CBrokerInfoMarshaller	Marshaling code for Open Wire Format for BrokerInfoMarshaller
CConnectionControlMarshaller	Marshaling code for Open Wire Format for ConnectionControlMarshaller
CConnectionErrorMarshaller	Marshaling code for Open Wire Format for ConnectionErrorMarshaller
CConnectionIdMarshaller	Marshaling code for Open Wire Format for ConnectionIdMarshaller
CConnectionInfoMarshaller	Marshaling code for Open Wire Format for ConnectionInfoMarshaller
CConsumerControlMarshaller	Marshaling code for Open Wire Format for ConsumerControlMarshaller
CConsumerIdMarshaller	Marshaling code for Open Wire Format for ConsumerIdMarshaller
CConsumerInfoMarshaller	Marshaling code for Open Wire Format for ConsumerInfoMarshaller
CControlCommandMarshaller	Marshaling code for Open Wire Format for ControlCommandMarshaller
CDataArrayResponseMarshaller	Marshaling code for Open Wire Format for DataArrayResponseMarshaller
CDataResponseMarshaller	Marshaling code for Open Wire Format for DataResponseMarshaller
CDestinationInfoMarshaller	Marshaling code for Open Wire Format for DestinationInfoMarshaller
CDiscoveryEventMarshaller	Marshaling code for Open Wire Format for DiscoveryEventMarshaller
CExceptionResponseMarshaller	Marshaling code for Open Wire Format for ExceptionResponseMarshaller
CFlushCommandMarshaller	Marshaling code for Open Wire Format for FlushCommandMarshaller
CIntegerResponseMarshaller	Marshaling code for Open Wire Format for IntegerResponseMarshaller
CJournalQueueAckMarshaller	Marshaling code for Open Wire Format for JournalQueueAckMarshaller
CJournalTopicAckMarshaller	Marshaling code for Open Wire Format for JournalTopicAckMarshaller
CJournalTraceMarshaller	Marshaling code for Open Wire Format for JournalTraceMarshaller
CJournalTransactionMarshaller	Marshaling code for Open Wire Format for JournalTransactionMarshaller
CKeepAliveInfoMarshaller	Marshaling code for Open Wire Format for KeepAliveInfoMarshaller
CLastPartialCommandMarshaller	Marshaling code for Open Wire Format for LastPartialCommandMarshaller
CLocalTransactionIdMarshaller	Marshaling code for Open Wire Format for LocalTransactionIdMarshaller
CMarshallerFactory	Used to create marshallers for a specific version of the wire protocol
CMessageAckMarshaller	Marshaling code for Open Wire Format for MessageAckMarshaller
CMessageDispatchMarshaller	Marshaling code for Open Wire Format for MessageDispatchMarshaller
CMessageDispatchNotificationMarshaller	Marshaling code for Open Wire Format for MessageDispatchNotificationMarshaller
CMessageIdMarshaller	Marshaling code for Open Wire Format for MessageIdMarshaller
CMessageMarshaller	Marshaling code for Open Wire Format for MessageMarshaller
CMessagePullMarshaller	Marshaling code for Open Wire Format for MessagePullMarshaller
CNetworkBridgeFilterMarshaller	Marshaling code for Open Wire Format for NetworkBridgeFilterMarshaller
CPartialCommandMarshaller	Marshaling code for Open Wire Format for PartialCommandMarshaller
CProducerAckMarshaller	Marshaling code for Open Wire Format for ProducerAckMarshaller
CProducerIdMarshaller	Marshaling code for Open Wire Format for ProducerIdMarshaller
CProducerInfoMarshaller	Marshaling code for Open Wire Format for ProducerInfoMarshaller
CRemoveInfoMarshaller	Marshaling code for Open Wire Format for RemoveInfoMarshaller
CRemoveSubscriptionInfoMarshaller	Marshaling code for Open Wire Format for RemoveSubscriptionInfoMarshaller
CReplayCommandMarshaller	Marshaling code for Open Wire Format for ReplayCommandMarshaller
CResponseMarshaller	Marshaling code for Open Wire Format for ResponseMarshaller
CSessionIdMarshaller	Marshaling code for Open Wire Format for SessionIdMarshaller
CSessionInfoMarshaller	Marshaling code for Open Wire Format for SessionInfoMarshaller
CShutdownInfoMarshaller	Marshaling code for Open Wire Format for ShutdownInfoMarshaller
CSubscriptionInfoMarshaller	Marshaling code for Open Wire Format for SubscriptionInfoMarshaller
CTransactionIdMarshaller	Marshaling code for Open Wire Format for TransactionIdMarshaller
CTransactionInfoMarshaller	Marshaling code for Open Wire Format for TransactionInfoMarshaller
CWireFormatInfoMarshaller	Marshaling code for Open Wire Format for WireFormatInfoMarshaller
CXATransactionIdMarshaller	Marshaling code for Open Wire Format for XATransactionIdMarshaller
CBaseDataStreamMarshaller	Base class for all Marshallers that marshal DataStructures to and from the wire using the OpenWire protocol
CDataStreamMarshaller	Base class for all classes that marshal commands for Openwire
CPrimitiveTypesMarshaller	This class wraps the functionality needed to marshal a primitive map to the Openwire Format's expectation of what the map looks like on the wire
Nutils
CBooleanStream	Manages the writing and reading of boolean data streams to and from a data source such as a DataInputStream or DataOutputStream
CHexTable	Maps hexidecimal strings to the value of an index into the table, i.e
CMessagePropertyInterceptor	Used the base ActiveMQMessage class to intercept calls to get and set properties in order to capture the calls that use the reserved JMS properties and get and set them in the OpenWire Message properties
COpenWireFormat
COpenWireFormatFactory
COpenWireFormatNegotiator
COpenWireResponseBuilder	Used to allow a MockTransport to generate response commands to OpenWire Commands
CPointer	Decaf's implementation of a Smart Pointer that is a template on a Type and is Thread Safe if the default Reference Counter is used
Nstomp
CActiveMQDestination
CDestinationFilter
CCommand
CConsumerId
CMessage
CMessageId
CPointer	Decaf's implementation of a Smart Pointer that is a template on a Type and is Thread Safe if the default Reference Counter is used
CProducerId
CStompCommandConstants
CStompFrame	A Stomp-level message frame that encloses all messages to and from the broker
CStompHelper	Utility Methods used when marshaling to and from StompFrame's
CStompWireFormat
CStompWireFormatFactory	Factory used to create the Stomp Wire Format instance
CTransactionId
CMarshalAware
CPointer	Decaf's implementation of a Smart Pointer that is a template on a Type and is Thread Safe if the default Reference Counter is used
CWireFormat	Provides a mechanism to marshal commands into and out of packets or into and out of streams, Channels and Datagrams
CWireFormatFactory	The WireFormatFactory is the interface that all WireFormatFactory classes must extend
CWireFormatNegotiator	Defines a WireFormatNegotiator which allows a WireFormat to
CWireFormatRegistry	Registry of all WireFormat Factories that are available to the client at runtime
Ncms	Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements
CAsyncCallback	Asynchronous event interface for CMS asynchronous operations
CBytesMessage	A BytesMessage object is used to send a message containing a stream of unsigned bytes
CCloseable	Interface for a class that implements the close method
CCMSException	CMS API Exception that is the base for all exceptions thrown from CMS classes
CCMSProperties	Interface for a Java-like properties object
CCMSSecurityException	This exception must be thrown when a provider rejects a user name/password submitted by a client
CConnection	The client's connection to its provider
CConnectionFactory	Defines the interface for a factory that creates connection objects, the Connection objects returned implement the CMS Connection interface and hide the CMS Provider specific implementation details behind that interface
CConnectionMetaData	A ConnectionMetaData object provides information describing the Connection object
CDeliveryMode	This is an Abstract class whose purpose is to provide a container for the delivery mode enumeration for CMS messages
CDestination	A Destination object encapsulates a provider-specific address
CDestinationEvent	An event class that is used to wrap information related to Destination add and remove events from the CMS Provider
CDestinationListener	A listener class that the client can implement to receive events related to Destination addition or removal on the CMS Provider
CDestinationSource	Provides an object that will provide a snapshot view of Destinations that exist on the Message provider
CEnhancedConnection	An enhanced CMS Connection instance that provides additional features above the default required features of a CMS Connection instance
CExceptionListener	If a CMS provider detects a serious problem, it notifies the client application through an ExceptionListener that is registered with the Connection
CIllegalStateException	This exception is thrown when a method is invoked at an illegal or inappropriate time or if the provider is not in an appropriate state for the requested operation
CInvalidClientIdException	This exception must be thrown when a client attempts to set a connection's client ID to a value that is rejected by a provider
CInvalidDestinationException	This exception must be thrown when a destination either is not understood by a provider or is no longer valid
CInvalidSelectorException	This exception must be thrown when a CMS client attempts to give a provider a message selector with invalid syntax
CMapMessage	A MapMessage object is used to send a set of name-value pairs
CMessage	Root of all messages
CMessageAvailableListener	A listener interface similar to the MessageListener interface
CMessageConsumer	A client uses a MessageConsumer to received messages from a destination
CMessageEnumeration	Defines an object that enumerates a collection of Messages
CMessageEOFException	This exception must be thrown when an unexpected end of stream has been reached when a StreamMessage or BytesMessage is being read
CMessageFormatException	This exception must be thrown when a CMS client attempts to use a data type not supported by a message or attempts to read data in a message as the wrong type
CMessageListener	A MessageListener object is used to receive asynchronously delivered messages
CMessageNotReadableException	This exception must be thrown when a CMS client attempts to read a write-only message
CMessageNotWriteableException	This exception must be thrown when a CMS client attempts to write to a read-only message
CMessageProducer	A client uses a MessageProducer object to send messages to a Destination
CMessageTransformer	Provides an interface for clients to transform cms::Message objects inside the CMS MessageProducer and MessageConsumer objects before the message's are sent or received
CObjectMessage	Place holder for interaction with JMS systems that support Java, the C++ client is not responsible for deserializing the contained Object
CQueue	An interface encapsulating a provider-specific queue name
CQueueBrowser	This class implements in interface for browsing the messages in a Queue without removing them
CResourceAllocationException	This exception is thrown when an operation is invalid because a transaction is in progress
CSession	A Session object is a single-threaded context for producing and consuming messages
CStartable	Interface for a class that implements the start method
CStoppable	Interface for a class that implements the stop method
CStreamMessage	Interface for a StreamMessage
CTemporaryQueue	Defines a Temporary Queue based Destination
CTemporaryTopic	Defines a Temporary Topic based Destination
CTextMessage	Interface for a text message
CTopic	An interface encapsulating a provider-specific topic name
CTransactionInProgressException	This exception is thrown when an operation is invalid because a transaction is in progress
CTransactionRolledBackException	This exception must be thrown when a call to Session.commit results in a rollback of the current transaction
CUnsupportedOperationException	This exception must be thrown when a CMS client attempts use a CMS method that is not implemented or not supported by the CMS Provider in use
CXAConnection	The XAConnection interface defines an extended Connection type that is used to create XASession objects
CXAConnectionFactory	The XAConnectionFactory interface is specialized interface that defines an ConnectionFactory that creates Connection instance that will participate in XA Transactions
CXAException	The XAException is thrown by the Resource Manager (RM) to inform the Transaction Manager of an error encountered by the involved transaction
CXAResource	The XAResource interface is a CMS mapping of the industry standard XA interface based on the X/Open CAE Specification (Distributed Transaction Processing: The XA Specification)
CXASession	The XASession interface extends the capability of Session by adding access to a CMS provider's support for the operating inside an XA Transaction (optional)
CXid	An interface which provides a mapping for the X/Open XID transaction identifier structure
Ndecaf	Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements
Ninternal
Nio
CStandardErrorOutputStream	Wrapper Around the Standard error Output facility on the current platform
CStandardInputStream
CStandardOutputStream
Nnet
Nfile
CFileHandler
Nhttp
CHttpHandler
Nhttps
CHttpsHandler
Nssl
Nopenssl
COpenSSLContextSpi	Provides an SSLContext that wraps the OpenSSL API
COpenSSLParameters	Container class for parameters that are Common to OpenSSL socket classes
COpenSSLServerSocket	SSLServerSocket based on OpenSSL library code
COpenSSLServerSocketFactory	SSLServerSocketFactory that creates Server Sockets that use OpenSSL
COpenSSLSocket	Wraps a a Normal Socket object and extends or overrides functions in that class to make use of the OpenSSL Socket API
COpenSSLSocketException	Subclass of the standard SocketException that knows how to produce an error message from the OpenSSL error stack
COpenSSLSocketFactory	Client Socket Factory that creates SSL based client sockets using the OpenSSL library
COpenSSLSocketInputStream	An output stream for reading data from an OpenSSL Socket instance
COpenSSLSocketOutputStream	OutputStream implementation used to write data to an OpenSSLSocket instance
CDefaultSSLContext	Default SSLContext manager for the Decaf library
CDefaultSSLServerSocketFactory	Default implementation of the SSLServerSocketFactory, this factory throws an Exception from all its create methods to indicate that SSL is not supported, this factory is used when OpenSSL is not enabled in the builds
CDefaultSSLSocketFactory	Default implementation of the SSLSocketFactory, this factory throws an Exception from all its create methods to indicate that SSL is not supported, this factory is used when OpenSSL is not enabled in the builds
Ntcp
CTcpSocket	Platform-independent implementation of the socket interface
CTcpSocketInputStream	Input stream for performing reads on a socket
CTcpSocketOutputStream	Output stream for performing write operations on a socket
CDefaultServerSocketFactory	Default implementation of the Decaf ServerSocketFactory, creates ServerSocket objects with supplied options
CDefaultSocketFactory	SocketFactory implementation that is used to create Sockets
CNetwork	Internal class used to manage Networking related resources and hide platform dependent calls from the higher level API
CSocketFileDescriptor	File Descriptor type used internally by Decaf Socket objects
CURIEncoderDecoder
CURIHelper	Helper class used by the URI classes in encoding and decoding of URI's
CURIType	Basic type object that holds data that composes a given URI
CURLStreamHandlerManager
CURLType	Basic type object that holds data that composes a given URL
CURLUtils
Nnio
CBufferFactory	Factory class used by static methods in the decaf::nio package to create the various default version of the NIO interfaces
CByteArrayAdapter	This class adapts primitive type arrays to a base byte array so that the classes can inter-operate on the same base byte array without copying data
CByteArrayBuffer	This class defines six categories of operations upon byte buffers:
CCharArrayBuffer
CDoubleArrayBuffer
CFloatArrayBuffer
CIntArrayBuffer
CLongArrayBuffer
CShortArrayBuffer
Nsecurity
Nprovider
Ncrypto
CMD4MessageDigestSpi	MD4 MessageDigestSpi
CMD5MessageDigestSpi	MD5 MessageDigestSpi
CSHA1MessageDigestSpi	SHA1 MessageDigestSpi
CDefaultMessageDigestProviderService	Decaf's Default Message Digest Security provider used to create instances of the built-in Message Digest algorithm SPI classes
CDefaultProvider	Implements the Security Provider interface for the Decaf library
CDefaultSecureRandomProviderService	Decaf's Default Secure Random Security provider used to create instances of the built-in Secure Random algorithm SPI classes
CEngine	Serves as a convenience class for classes in the Decaf Security package
CSecureRandomImpl	Secure Random Number Generator for Unix based platforms that attempts to obtain secure bytes with high entropy from known sources
CSecurityRuntime	Internal class used to manage Security related resources and hide platform dependent calls from the higher level API
CServiceRegistry	Serves as a registry for all the Providers for services using the naming format of "ServiceName.Algorithm"
Nutil
Nconcurrent
CAtomicReference	An Pointer reference that may be updated atomically
CAtomics
CCompletionCondition
CExecutorsSupport	Various support methods for use in Executors and surrounding classes
CMonitorHandle
CPlatformThread
CRWLOCK
CSynchronizableImpl	A convenience class used by some Decaf classes to implement the Synchronizable interface when there is no issues related to multiple inheritance
CThread	A Thread is a concurrent unit of execution
CUncaughtExceptionHandler	Interface for handlers invoked when a Thread abruptly terminates due to an uncaught exception
CThreadHandle
CThreading
CThreadLocalImpl
CTransferer	Shared internal API for dual stacks and queues
CTransferQueue	This extends Scherer-Scott dual queue algorithm, differing, among other ways, by using modes within nodes rather than marked pointers
CTransferStack
CByteArrayAdapter	This class adapts primitive type arrays to a base byte array so that the classes can inter-operate on the same base byte array without copying data
CGenericResource	A Generic Resource wraps some type and will delete it when the Resource itself is deleted
CHexStringParser
CPointer	Decaf's implementation of a Smart Pointer that is a template on a Type and is Thread Safe if the default Reference Counter is used
CResource	Interface for all Managed Resources in Decaf, these objects are added to the Runtime System and are destroyed at shutdown
CResourceLifecycleManager
CStringUtils
CTimerTask	A Base class for a task object that can be scheduled for one-time or repeated execution by a Timer
CTimerTaskHeap	A Binary Heap implemented specifically for the Timer class in Decaf Util
CAprPool	Wraps an APR pool object so that classes in decaf can create a static member for use in static methods where apr function calls that need a pool are made
CDecafRuntime	Handles APR initialization and termination
Nio
CBlockingByteArrayInputStream	This is a blocking version of a byte buffer stream
CBufferedInputStream	A wrapper around another input stream that performs a buffered read, where it reads more data than it needs in order to reduce the number of io operations on the input stream
CBufferedOutputStream	Wrapper around another output stream that buffers output before writing to the target output stream
CByteArrayInputStream	A ByteArrayInputStream contains an internal buffer that contains bytes that may be read from the stream
CByteArrayOutputStream
CCloseable	Interface for a class that implements the close method
CDataInput	The DataInput interface provides for reading bytes from a binary stream and reconstructing from them data in any of the C++ primitive types
CDataInputStream	A data input stream lets an application read primitive Java data types from an underlying input stream in a machine-independent way
CDataOutput	The DataOutput interface provides for converting data from any of the C++ primitive types to a series of bytes and writing these bytes to a binary stream
CDataOutputStream	A data output stream lets an application write primitive Java data types to an output stream in a portable way
CEOFException
CFileDescriptor	This class servers as an opaque wrapper around an underlying OS level resource that can be used as a source / sink for byte level data such as sockets and files
CFilterInputStream	A FilterInputStream contains some other input stream, which it uses as its basic source of data, possibly transforming the data along the way or providing additional functionality
CFilterOutputStream	This class is the superclass of all classes that filter output streams
CFlushable	A Flushable is a destination of data that can be flushed
CInputStream	A base class that must be implemented by all classes wishing to provide a class that reads in a stream of bytes
CInputStreamReader	An InputStreamReader is a bridge from byte streams to character streams
CInterruptedIOException
CIOException
COutputStream	Base interface for any class that wants to represent an output stream of bytes
COutputStreamWriter	A class for turning a character stream into a byte stream
CPushbackInputStream	A PushbackInputStream adds functionality to another input stream, namely the ability to "push back" or "unread" one byte
CReader
CUnsupportedEncodingException	Thrown when the the Character Encoding is not supported
CUTFDataFormatException	Thrown from classes that attempt to read or write a UTF-8 encoded string and an encoding error is encountered
CWriter
Nlang
Nexceptions
CArrayIndexOutOfBoundsException
CClassCastException
CCloneNotSupportedException
CIllegalArgumentException
CIllegalMonitorStateException
CIllegalStateException
CIllegalThreadStateException
CIndexOutOfBoundsException
CInterruptedException
CInvalidStateException
CNegativeArraySizeException
CNullPointerException
CNumberFormatException
COutOfMemoryError
CRuntimeException
CSecurityException
CStringIndexOutOfBoundsException
CUnsupportedOperationException
CAbstractStringBuilder	A modifiable sequence of characters for use in creating and modifying Strings
CAppendable	An object to which char sequences and values can be appended
CArrayPointer	Decaf's implementation of a Smart Pointer that is a template on a Type and is Thread Safe if the default Reference Counter is used
CArrayPointerComparator	This implementation of Comparator is designed to allows objects in a Collection to be sorted or tested for equality based on the value of the value of the actual pointer to the array being contained in this ArrayPointer
CBoolean
CByte
CCharacter
CCharSequence	A CharSequence is a readable sequence of char values
CComparable	This interface imposes a total ordering on the objects of each class that implements it
CDouble
CDYNAMIC_CAST_TOKEN
CException
CFloat
CInteger
CIterable	Implementing this interface allows an object to be cast to an Iterable type for generic collections API calls
CLong
CMath	The class Math contains methods for performing basic numeric operations such as the elementary exponential, logarithm, square root, and trigonometric functions
CNumber	The abstract class Number is the superclass of classes Byte, Double, Float, Integer, Long, and Short
CPointer	Decaf's implementation of a Smart Pointer that is a template on a Type and is Thread Safe if the default Reference Counter is used
CPointerComparator	This implementation of Comparator is designed to allows objects in a Collection to be sorted or tested for equality based on the value of the Object being Pointed to and not the value of the contained pointer in the Pointer instance
CReadable	A Readable is a source of characters
CRunnable	Interface for a runnable object - defines a task that can be run by a thread
CRuntime
CShort
CSTATIC_CAST_TOKEN
CString	An immutable sequence of characters
CStringBuffer	StringBuffer is a variable size contiguous indexable array of characters
CStringBuilder	A modifiable sequence of characters for use in creating and modifying Strings
CSystem	Static methods for accessing system level resources and performing some system dependent tasks such as looking up environment values and copying memory and arrays
CThread	A Thread is a concurrent unit of execution
CUncaughtExceptionHandler	Interface for handlers invoked when a Thread abruptly terminates due to an uncaught exception
CThreadGroup
CThreadLocal	This class provides thread-local variables
CThrowable	This class represents an error that has occurred
CTypes
Nnet
Nssl
CSSLContext	Represents on implementation of the Secure Socket Layer for streaming based sockets
CSSLContextSpi	Defines the interface that should be provided by an SSLContext provider
CSSLParameters
CSSLServerSocket	Represents a server socket that is used to accept connections from clients using the Secure Sockets protocol or the Top Level Security protocol
CSSLServerSocketFactory	Factory class interface that provides methods to create SSL Server Sockets
CSSLSocket
CSSLSocketFactory	Factory class interface for a SocketFactory that can create SSLSocket objects
CBindException
CConnectException
CContentHandlerFactory	Defines a factory interface for content handlers
CDatagramPacket	Class that represents a single datagram packet
CFileNameMap	Defines a scheme for mapping a filename type to a MIME content type
CHttpRetryException
CHttpURLConnection	This abstract subclass of URLConnection defines methods for managing HTTP connection according to the description given by RFC 2068
CInet4Address
CInet6Address
CInetAddress	Represents an IP address
CInetSocketAddress
CMalformedURLException
CNoRouteToHostException
CPortUnreachableException
CProtocolException
CProxy
CServerSocket	This class implements server sockets
CServerSocketFactory	Class used to create Server Sockets, subclasses can be created that create certain types of server sockets according to specific policies
CSocket
CSocketAddress	Base class for protocol specific Socket addresses
CSocketError	Static utility class to simplify handling of error codes for socket operations
CSocketException	Exception for errors when manipulating sockets
CSocketFactory	The SocketFactory is used to create Socket objects and can be sub-classed to provide other types of Sockets or Sockets with varying configurations
CSocketImpl	Acts as a base class for all physical Socket implementations
CSocketImplFactory	Factory class interface for a Factory that creates ScoketImpl objects
CSocketOptions
CSocketTimeoutException
CUnknownHostException
CUnknownServiceException
CURI	This class represents an instance of a URI as defined by RFC 2396
CURISyntaxException
CURL	Class URL represents a Uniform Resource Locator, a pointer to a "resource" on the World Wide Web
CURLConnection	Concrete implementations of the abstract URLConnection class provide a communication link to a URL for exchanging data with a specific protocol type
CURLDecoder
CURLEncoder
CURLStreamHandler	The abstract class URLStreamHandler is the common superclass for all stream protocol handlers
CURLStreamHandlerFactory	Defines a factory which creates an URLStreamHandler for a specified protocol
Nnio
CBuffer	A container for data of a specific primitive type
CBufferOverflowException
CBufferUnderflowException
CByteBuffer	This class defines six categories of operations upon byte buffers:
CCharBuffer	This class defines four categories of operations upon character buffers:
CDoubleBuffer	This class defines four categories of operations upon double buffers:
CFloatBuffer	This class defines four categories of operations upon float buffers:
CIntBuffer	This class defines four categories of operations upon int buffers:
CInvalidMarkException
CLongBuffer	This class defines four categories of operations upon long long buffers:
CReadOnlyBufferException
CShortBuffer	This class defines four categories of operations upon short buffers:
Nsecurity
Nauth
Nx500
CX500Principal
Ncert
CCertificate	Base interface for all identity certificates
CCertificateEncodingException
CCertificateException
CCertificateExpiredException
CCertificateNotYetValidException
CCertificateParsingException
CX509Certificate	Base interface for all identity certificates
CDigestException
CGeneralSecurityException
CInvalidKeyException
CKey	The Key interface is the top-level interface for all keys
CKeyException
CKeyManagementException
CMessageDigest	This MessageDigest class provides applications the functionality of a message digest algorithm, such as MD5 or SHA
CMessageDigestSpi	This class defines the Service Provider Interface (SPI) for the MessageDigest class, which provides the functionality of a message digest algorithm, such as MD5 or SHA
CNoSuchAlgorithmException
CNoSuchProviderException
CPrincipal	Base interface for a principal, which can represent an individual or organization
CProvider	This class represents a "provider" for the Decaf Security API, where a provider implements some or all parts of Decaf Security
CProviderException
CProviderService
CPublicKey	A public key
CSecureRandom
CSecureRandomSpi	Interface class used by Security Service Providers to implement a source of secure random bytes
CSecurity
CSecuritySpi	Base class used as a Marker for all Security Provider Interface classes in the Decaf Security API
CSignatureException
Nutil
Ncomparators
CEquals	Equality comparator that utilizes the default equality comparison expression == to determine if two values are considered equal
CEquals< decaf::lang::Pointer< E > >
CLess	Simple Less Comparator that compares to elements to determine if the first is less than the second
Nconcurrent
Natomic
CAtomicBoolean	A boolean value that may be updated atomically
CAtomicInteger	An int value that may be updated atomically
CAtomicRefCounter
CAtomicReference	An Pointer reference that may be updated atomically
Nlocks
CAbstractOwnableSynchronizer	Base class for locks that provide the notion of Ownership, the types of locks that are implemented using this base class would be owned by one specific Thread at any given time
CAbstractQueuedSynchronizer
CConditionObject	Condition object for this Synchronizer, which serves as the basis for other Lock objects
CCondition	Condition factors out the Mutex monitor methods (wait, notify and notifyAll) into distinct objects to give the effect of having multiple wait-sets per object, by combining them with the use of arbitrary Lock implementations
CLock	Lock implementations provide more extensive locking operations than can be obtained using synchronized statements
CLockSupport	Basic thread blocking primitives for creating locks and other synchronization classes
CReadWriteLock	A ReadWriteLock maintains a pair of associated locks, one for read-only operations and one for writing
CReentrantLock	A reentrant mutual exclusion Lock with extended capabilities
CReentrantReadWriteLock
CAbstractExecutorService	Provides a default implementation for the methods of the ExecutorService interface
CBlockingQueue	A decaf::util::Queue that additionally supports operations that wait for the queue to become non-empty when retrieving an element, and wait for space to become available in the queue when storing an element
CBrokenBarrierException
CCallable	A task that returns a result and may throw an exception
CCallableType	Base class of all Callable<T> objects, used to allow identification via type casting
CCancellationException
CConcurrentHashMap
CConcurrentMap	Interface for a Map type that provides additional atomic putIfAbsent, remove, and replace methods alongside the already available Map interface
CConcurrentStlMap	Map template that wraps around a std::map to provide a more user-friendly interface and to provide common functions that do not exist in std::map
CCopyOnWriteArrayList
CArrayListIterator
CCopyOnWriteArraySet	Since the CopyOnWriteArraySet and the CopyOnWriteArrayList share much of the same operational semantics this class uses the CopyOnWriteArrayList for all its underlying operations
CCountDownLatch
CDelayed	A mix-in style interface for marking objects that should be acted upon after a given delay
CExecutionException
CExecutor	An object that executes submitted decaf.lang.Runnable tasks
CExecutors	Implements a set of utilities for use with Executors, ExecutorService, ThreadFactory, and Callable types, as well as providing factory methods for instance of these types configured for the most common use cases
CExecutorService	An Executor that provides methods to manage termination and methods that can produce a Future for tracking progress of one or more asynchronous tasks
CFuture	A Future represents the result of an asynchronous computation
CFutureTask	A cancellable asynchronous computation
CFutureType
CLinkedBlockingQueue	A BlockingQueue derivative that allows for a bound to be placed on the number of elements that can be enqueued at any one time
CLock	A wrapper class around a given synchronization mechanism that provides automatic release upon destruction
CMutex	Mutex object that offers recursive support on all platforms as well as providing the ability to use the standard wait / notify pattern used in languages like Java
CPointer	Decaf's implementation of a Smart Pointer that is a template on a Type and is Thread Safe if the default Reference Counter is used
CRejectedExecutionException
CRejectedExecutionHandler	A handler for tasks that cannot be executed by a ThreadPoolExecutor
CRunnableFuture	A Runnable version of the Future type
CSemaphore	A counting semaphore
CSynchronizable	The interface for all synchronizable objects (that is, objects that can be locked and unlocked)
CSynchronousQueue	A blocking queue in which each insert operation must wait for a corresponding remove operation by another thread, and vice versa
CThreadFactory	Public interface ThreadFactory
CThreadPoolExecutor	Defines a Thread Pool object that implements the functionality of pooling threads to perform user tasks
CAbortPolicy	Handler policy for tasks that are rejected upon a call to ThreadPoolExecutor::execute this class always throws a RejectedExecutionException
CCallerRunsPolicy	Handler policy for tasks that are rejected upon a call to ThreadPoolExecutor::execute this class will attempt to run the task in the Thread that called the execute method unless the executor is shutdown in which case the task is not run and is destroyed
CDiscardPolicy	Handler policy for tasks that are rejected upon a call to ThreadPoolExecutor::execute this class always destroys the rejected task and returns quietly
CDiscardOldestPolicy	Handler policy for tasks that are rejected upon a call to ThreadPoolExecutor::execute this class always destroys the oldest unexecuted task in the Queue and then attempts to execute the rejected task using the passed in executor
CTimeoutException
CTimeUnit	A TimeUnit represents time durations at a given unit of granularity and provides utility methods to convert across units, and to perform timing and delay operations in these units
Nlogging
CConsoleHandler	This Handler publishes log records to System.err
CErrorManager	ErrorManager objects can be attached to Handlers to process any error that occur on a Handler during Logging
CFilter	A Filter can be used to provide fine grain control over what is logged, beyond the control provided by log levels
CFormatter	A Formatter provides support for formatting LogRecords
CHandler	A Handler object takes log messages from a Logger and exports them
CLevel	Defines a set of standard logging levels that can be used to control logging output
CLogger	A Logger object is used to log messages for a specific system or application component
CLoggerHierarchy
CLogManager	There is a single global LogManager object that is used to maintain a set of shared state about Loggers and log services
CLogRecord	LogRecord objects are used to pass logging requests between the logging framework and individual log Handlers
CLogWriter
CMarkBlockLogger	Defines a class that can be used to mark the entry and exit from scoped blocks
CPointer	Decaf's implementation of a Smart Pointer that is a template on a Type and is Thread Safe if the default Reference Counter is used
CPropertiesChangeListener	Defines the interface that classes can use to listen for change events on Properties
CSimpleFormatter	Print a brief summary of the LogRecord in a human readable format
CSimpleLogger
CStreamHandler	Stream based logging Handler
CXMLFormatter	Format a LogRecord into a standard XML format
Nzip
CAdler32	Clas that can be used to compute an Adler-32 Checksum for a data stream
CCheckedInputStream	An implementation of a FilterInputStream that will maintain a Checksum of the bytes read, the Checksum can then be used to verify the integrity of the input stream
CCheckedOutputStream	An implementation of a FilterOutputStream that will maintain a Checksum of the bytes written, the Checksum can then be used to verify the integrity of the output stream
CChecksum	An interface used to represent Checksum values in the Zip package
CCRC32	Class that can be used to compute a CRC-32 checksum for a data stream
CDataFormatException
CDeflater	This class compresses data using the DEFLATE algorithm (see specification)
CDeflaterOutputStream	Provides a FilterOutputStream instance that compresses the data before writing it to the wrapped OutputStream
CInflater	This class uncompresses data that was compressed using the DEFLATE algorithm (see specification)
CInflaterInputStream	A FilterInputStream that decompresses data read from the wrapped InputStream instance
CZipException
CAbstractCollection	This class provides a skeletal implementation of the Collection interface, to minimize the effort required to implement this interface
CAbstractList	This class provides a skeletal implementation of the List interface to minimize the effort required to implement this interface backed by a "random access" data store (such as an array)
CAbstractMap	This class provides a skeletal implementation of the Map interface, to minimize the effort required to implement this interface
CAbstractQueue	This class provides skeletal implementations of some Queue operations
CAbstractSequentialList	This class provides a skeletal implementation of the List interface to minimize the effort required to implement this interface backed by a "sequential access" data store (such as a linked list)
CAbstractSet	This class provides a skeletal implementation of the Set interface to minimize the effort required to implement this interface
CArrayList
CArrays
CBitSet	This class implements a vector of bits that grows as needed
CCollection	The root interface in the collection hierarchy
CCollections
CComparator	A comparison function, which imposes a total ordering on some collection of objects
CConcurrentModificationException
CDate	Wrapper class around a time value in milliseconds
CDeque	Defines a 'Double ended Queue' interface that allows for insertion and removal of elements from both ends
CHashCode	Base HashCode template, specializations are created from this to account for the various native types
CHashCode< bool >
CHashCode< char >
CHashCode< const std::string >
CHashCode< const T * >
CHashCode< const T >
CHashCode< decaf::lang::Pointer< T > >
CHashCode< double >
CHashCode< float >
CHashCode< int >
CHashCode< long long >
CHashCode< short >
CHashCode< std::string >
CHashCode< T * >
CHashCode< unsigned int >
CHashCode< unsigned long long >
CHashCode< unsigned short >
CHashCode< wchar_t >
CHashCodeUnaryBase
CHashMap	Hash table based implementation of the Map interface
CHashMapEntry
CHashMapEntrySet
CConstHashMapEntrySet
CHashMapKeySet
CConstHashMapKeySet
CHashMapValueCollection
CConstHashMapValueCollection
CHashSet	This class implements the Set interface, backed by a hash table (actually a HashMap instance)
CIterator	Defines an object that can be used to iterate over the elements of a collection
CLinkedHashMap	Hashed and linked list implementation of the Map interface, with predictable iteration order
CLinkedHashSet	Hash table and linked list implementation of the Set interface, with predictable iteration order
CLinkedList	A complete implementation of the List interface using a doubly linked list data structure
CList	An ordered collection (also known as a sequence)
CListIterator	An iterator for lists that allows the programmer to traverse the list in either direction, modify the list during iteration, and obtain the iterator's current position in the list
CLRUCache	A Basic Least Recently Used (LRU) Cache Map
CMap	An object that maps keys to values
CMapEntry
CNoSuchElementException
CPriorityQueue	An unbounded priority queue based on a binary heap algorithm
CPriorityQueueBase
CProperties	Java-like properties class for mapping string names to string values
CQueue	A kind of collection provides advanced operations than other basic collections, such as insertion, extraction, and inspection
CRandom	Random Value Generator which is used to generate a stream of pseudorandom numbers
CSet	A collection that contains no duplicate elements
CStlList	List class that wraps the STL list object to provide a simpler interface and additional methods not provided by the STL type
CStlMap	Map template that wraps around a std::map to provide a more user-friendly interface and to provide common functions that do not exist in std::map
CStlQueue	The Queue class accepts messages with an psuh(m) command where m is the message to be queued
CStlSet	Set template that wraps around a std::set to provide a more user-friendly interface and to provide common functions that do not exist in std::set
CStringTokenizer	Class that allows for parsing of string based on Tokens
CSystem	Static methods for accessing system level resources and performing some system dependent tasks such as looking up environment values and copying memory and arrays
CTimer	A facility for threads to schedule tasks for future execution in a background thread
CTimerTask	A Base class for a task object that can be scheduled for one-time or repeated execution by a Timer
CUUID	A class that represents an immutable universally unique identifier (UUID)
Nstd
Cless< decaf::lang::ArrayPointer< T > >	An override of the less function object so that the Pointer objects can be stored in STL Maps, etc
Cless< decaf::lang::Pointer< T > >	An override of the less function object so that the Pointer objects can be stored in STL Maps, etc
Ccode
Cct_data_s
C[union].fc
C[union].dl
Cgz_header_s
Cgz_state
Cinflate_state
Cinternal_state
Ctree_desc_s
Cz_stream_s