| 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 | |
| Cgz_header_s | |
| Cgz_state | |
| Cinflate_state | |
| Cinternal_state | |
| Ctree_desc_s | |
| Cz_stream_s | |
1.17.0