  decaf::util::concurrent::locks::AbstractOwnableSynchronizer | 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 |
  decaf::util::concurrent::locks::AbstractQueuedSynchronizer | |
 activemq::core::ActiveMQAckHandler | Interface class that is used to give CMS Messages an interface to Ack themselves with |
| activemq::core::ActiveMQConstants | 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 |
| activemq::library::ActiveMQCPP | |
| activemq::util::ActiveMQMessageTransformation | |
| activemq::util::AdvisorySupport | Support class that provides various static constants for use in constructing Destination names for the ActiveMQ advisory destinations |
| decaf::lang::Appendable | An object to which char sequences and values can be appended |
| decaf::io::Writer | |
| decaf::io::OutputStreamWriter | A class for turning a character stream into a byte stream |
 decaf::nio::CharBuffer | This class defines four categories of operations upon character buffers: |
 decaf::internal::nio::CharArrayBuffer | |
| decaf::internal::AprPool | 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 |
| decaf::lang::ArrayPointer< T > | 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 |
| decaf::util::Arrays | |
| decaf::util::concurrent::atomic::AtomicBoolean | A boolean value that may be updated atomically |
| decaf::util::concurrent::atomic::AtomicRefCounter | |
| decaf::lang::Pointer< ConstStlMapEntrySet > | |
| decaf::lang::Pointer< ConstStlMapKeySet > | |
| decaf::lang::Pointer< ConstStlMapValueCollection > | |
| decaf::lang::Pointer< StlMapEntrySet > | |
| decaf::lang::Pointer< StlMapKeySet > | |
| decaf::lang::Pointer< StlMapValueCollection > | |
| decaf::util::concurrent::atomic::AtomicReference< T > | An Pointer reference that may be updated atomically |
| decaf::internal::util::concurrent::Atomics | |
| decaf::util::BitSet | This class implements a vector of bits that grows as needed |
| activemq::wireformat::openwire::utils::BooleanStream | Manages the writing and reading of boolean data streams to and from a data source such as a DataInputStream or DataOutputStream |
| decaf::nio::Buffer | A container for data of a specific primitive type |
| decaf::nio::ByteBuffer | This class defines six categories of operations upon byte buffers: |
| decaf::internal::nio::ByteArrayBuffer | This class defines six categories of operations upon byte buffers: |
| decaf::nio::CharBuffer | This class defines four categories of operations upon character buffers: |
| decaf::nio::DoubleBuffer | This class defines four categories of operations upon double buffers: |
| decaf::internal::nio::DoubleArrayBuffer | |
| decaf::nio::FloatBuffer | This class defines four categories of operations upon float buffers: |
| decaf::internal::nio::FloatArrayBuffer | |
| decaf::nio::IntBuffer | This class defines four categories of operations upon int buffers: |
| decaf::internal::nio::IntArrayBuffer | |
| decaf::nio::LongBuffer | This class defines four categories of operations upon long long buffers: |
| decaf::internal::nio::LongArrayBuffer | |
| decaf::nio::ShortBuffer | This class defines four categories of operations upon short buffers: |
| decaf::internal::nio::ShortArrayBuffer | |
| decaf::internal::nio::BufferFactory | Factory class used by static methods in the decaf::nio package to create the various default version of the NIO interfaces |
| decaf::internal::util::ByteArrayAdapter | 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 |
| decaf::util::concurrent::CallableType | Base class of all Callable<T> objects, used to allow identification via type casting |
| decaf::util::concurrent::Callable< E > | |
| decaf::util::concurrent::Callable< T > | |
| decaf::util::concurrent::Callable< V > | A task that returns a result and may throw an exception |
| decaf::security::cert::Certificate | Base interface for all identity certificates |
| decaf::security::cert::X509Certificate | Base interface for all identity certificates |
| decaf::lang::CharSequence | A CharSequence is a readable sequence of char values |
| decaf::lang::String | Immutable sequence of chars |
| decaf::nio::CharBuffer | This class defines four categories of operations upon character buffers: |
| decaf::util::zip::Checksum | An interface used to represent Checksum values in the Zip package |
| decaf::util::zip::Adler32 | Clas that can be used to compute an Adler-32 Checksum for a data stream |
| decaf::util::zip::CRC32 | Class that can be used to compute a CRC-32 checksum for a data stream |
| cms::Closeable | Interface for a class that implements the close method |
| activemq::commands::ActiveMQTempDestination | |
| activemq::commands::ActiveMQTempQueue | |
| activemq::commands::ActiveMQTempTopic | |
| cms::Connection | The client's connection to its provider |
| activemq::core::ActiveMQConnection | Concrete connection used for all connectors to the ActiveMQ broker |
| activemq::core::ActiveMQXAConnection | |
| cms::XAConnection | The XAConnection interface defines an extended Connection type that is used to create XASession objects |
| activemq::core::ActiveMQXAConnection | |
| cms::MessageConsumer | A client uses a MessageConsumer to received messages from a destination |
| activemq::cmsutil::CachedConsumer | A cached message consumer contained within a pooled session |
| activemq::core::ActiveMQConsumer | |
| activemq::core::kernels::ActiveMQConsumerKernel | |
| cms::MessageProducer | A client uses a MessageProducer object to send messages to a Destination |
| activemq::cmsutil::CachedProducer | A cached message producer contained within a pooled session |
| activemq::core::ActiveMQProducer | |
| activemq::core::kernels::ActiveMQProducerKernel | |
| cms::QueueBrowser | This class implements in interface for browsing the messages in a Queue without removing them |
| activemq::core::ActiveMQQueueBrowser | |
| cms::Session | A Session object is a single-threaded context for producing and consuming messages |
| activemq::cmsutil::PooledSession | A pooled session object that wraps around a delegate session |
| activemq::core::ActiveMQSession | |
| activemq::core::ActiveMQXASession | |
| activemq::core::kernels::ActiveMQSessionKernel | |
| activemq::core::kernels::ActiveMQXASessionKernel | |
| cms::XASession | 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) |
| activemq::core::ActiveMQXASession | |
| activemq::core::kernels::ActiveMQXASessionKernel | |
| decaf::io::Closeable | Interface for a class that implements the close method |
| activemq::transport::Transport | Interface for a transport layer for command objects |
| activemq::transport::CompositeTransport | A Composite Transport is a Transport implementation that is composed of several Transports |
| activemq::transport::failover::FailoverTransport | |
| activemq::transport::IOTransport | Implementation of the Transport interface that performs marshaling of commands to IO streams |
| activemq::transport::mock::MockTransport | 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 |
| activemq::transport::TransportFilter | A filter on the transport layer |
| activemq::transport::correlator::ResponseCorrelator | This type of transport filter is responsible for correlating asynchronous responses with requests |
| activemq::transport::inactivity::InactivityMonitor | |
| activemq::transport::logging::LoggingTransport | A transport filter that logs commands as they are sent/received |
| activemq::transport::tcp::TcpTransport | Implements a TCP/IP based transport filter, this transport is meant to wrap an instance of an IOTransport |
| activemq::transport::tcp::SslTransport | Transport for connecting to a Broker using an SSL Socket |
| activemq::wireformat::WireFormatNegotiator | Defines a WireFormatNegotiator which allows a WireFormat to |
| activemq::wireformat::openwire::OpenWireFormatNegotiator | |
| decaf::io::InputStream | A base class that must be implemented by all classes wishing to provide a class that reads in a stream of bytes |
| decaf::internal::io::StandardInputStream | |
| decaf::internal::net::ssl::openssl::OpenSSLSocketInputStream | An output stream for reading data from an OpenSSL Socket instance |
| decaf::internal::net::tcp::TcpSocketInputStream | Input stream for performing reads on a socket |
| decaf::io::BlockingByteArrayInputStream | This is a blocking version of a byte buffer stream |
| decaf::io::ByteArrayInputStream | A ByteArrayInputStream contains an internal buffer that contains bytes that may be read from the stream |
| decaf::io::FilterInputStream | 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 |
| activemq::io::LoggingInputStream | |
| decaf::io::BufferedInputStream | 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 |
| decaf::io::DataInputStream | A data input stream lets an application read primitive Java data types from an underlying input stream in a machine-independent way |
| decaf::io::PushbackInputStream | A PushbackInputStream adds functionality to another input stream, namely the ability to "push back" or "unread" one byte |
| decaf::util::zip::CheckedInputStream | 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 |
| decaf::util::zip::InflaterInputStream | A FilterInputStream that decompresses data read from the wrapped InputStream instance |
| decaf::io::OutputStream | Base interface for any class that wants to represent an output stream of bytes |
| decaf::internal::io::StandardErrorOutputStream | Wrapper Around the Standard error Output facility on the current platform |
| decaf::internal::io::StandardOutputStream | |
| decaf::internal::net::ssl::openssl::OpenSSLSocketOutputStream | OutputStream implementation used to write data to an OpenSSLSocket instance |
| decaf::internal::net::tcp::TcpSocketOutputStream | Output stream for performing write operations on a socket |
| decaf::io::ByteArrayOutputStream | |
| decaf::io::FilterOutputStream | This class is the superclass of all classes that filter output streams |
| activemq::io::LoggingOutputStream | OutputStream filter that just logs the data being written |
| decaf::io::BufferedOutputStream | Wrapper around another output stream that buffers output before writing to the target output stream |
| decaf::io::DataOutputStream | A data output stream lets an application write primitive Java data types to an output stream in a portable way |
| decaf::util::zip::CheckedOutputStream | 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 |
| decaf::util::zip::DeflaterOutputStream | Provides a FilterOutputStream instance that compresses the data before writing it to the wrapped OutputStream |
| decaf::io::Reader | |
| decaf::io::InputStreamReader | An InputStreamReader is a bridge from byte streams to character streams |
| decaf::io::Writer | |
| decaf::net::Socket | |
| decaf::net::ssl::SSLSocket | |
| decaf::internal::net::ssl::openssl::OpenSSLSocket | Wraps a a Normal Socket object and extends or overrides functions in that class to make use of the OpenSSL Socket API |
| decaf::util::logging::Handler | A Handler object takes log messages from a Logger and exports them |
| decaf::util::logging::StreamHandler | Stream based logging Handler |
| decaf::util::logging::ConsoleHandler | This Handler publishes log records to System.err |
| activemq::cmsutil::CmsAccessor | Base class for activemq.cmsutil.CmsTemplate and other CMS-accessing gateway helpers, defining common properties such as the CMS cms.ConnectionFactory to operate on |
| activemq::cmsutil::CmsDestinationAccessor | Extends the CmsAccessor to add support for resolving destination names |
| activemq::cmsutil::CmsTemplate | CmsTemplate simplifies performing synchronous CMS operations |
| cms::CMSException | CMS API Exception that is the base for all exceptions thrown from CMS classes |
| cms::CMSSecurityException | This exception must be thrown when a provider rejects a user name/password submitted by a client |
| cms::IllegalStateException | 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 |
| cms::InvalidClientIdException | 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 |
| cms::InvalidDestinationException | This exception must be thrown when a destination either is not understood by a provider or is no longer valid |
| cms::InvalidSelectorException | This exception must be thrown when a CMS client attempts to give a provider a message selector with invalid syntax |
| cms::MessageEOFException | This exception must be thrown when an unexpected end of stream has been reached when a StreamMessage or BytesMessage is being read |
| cms::MessageFormatException | 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 |
| cms::MessageNotReadableException | This exception must be thrown when a CMS client attempts to read a write-only message |
| cms::MessageNotWriteableException | This exception must be thrown when a CMS client attempts to write to a read-only message |
| cms::ResourceAllocationException | This exception is thrown when an operation is invalid because a transaction is in progress |
| cms::TransactionInProgressException | This exception is thrown when an operation is invalid because a transaction is in progress |
| cms::TransactionRolledBackException | This exception must be thrown when a call to Session.commit results in a rollback of the current transaction |
| cms::UnsupportedOperationException | 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 |
| cms::XAException | The XAException is thrown by the Resource Manager (RM) to inform the Transaction Manager of an error encountered by the involved transaction |
| activemq::util::CMSExceptionSupport | |
| cms::CMSProperties | Interface for a Java-like properties object |
| activemq::util::ActiveMQProperties | Implementation of the CMSProperties interface that delegates to a decaf::util::Properties object |
| code | |
| decaf::util::Collections | |
| activemq::state::CommandVisitor | Interface for an Object that can visit the various Command Objects that are sent from and to this client |
| activemq::state::CommandVisitorAdapter | Default Implementation of a CommandVisitor that returns NULL for all calls |
| activemq::state::ConnectionStateTracker | |
| decaf::lang::Comparable< T > | This interface imposes a total ordering on the objects of each class that implements it |
| decaf::lang::Comparable< ActiveMQDestination > | |
| activemq::commands::ActiveMQDestination | |
| activemq::commands::ActiveMQQueue | |
| activemq::commands::ActiveMQTempDestination | |
| activemq::commands::ActiveMQTopic | |
| decaf::lang::Comparable< bool > | |
| decaf::lang::Boolean | |
| decaf::lang::Comparable< Boolean > | |
| decaf::lang::Boolean | |
| decaf::lang::Comparable< BrokerId > | |
| activemq::commands::BrokerId | |
| decaf::lang::Comparable< Byte > | |
| decaf::lang::Byte | |
| decaf::lang::Comparable< ByteBuffer > | |
| decaf::nio::ByteBuffer | This class defines six categories of operations upon byte buffers: |
| decaf::lang::Comparable< char > | |
| decaf::lang::Character | |
| decaf::lang::Comparable< Character > | |
| decaf::lang::Character | |
| decaf::lang::Comparable< CharBuffer > | |
| decaf::nio::CharBuffer | This class defines four categories of operations upon character buffers: |
| decaf::lang::Comparable< ConnectionId > | |
| activemq::commands::ConnectionId | |
| decaf::lang::Comparable< ConsumerId > | |
| activemq::commands::ConsumerId | |
| decaf::lang::Comparable< Date > | |
| decaf::util::Date | Wrapper class around a time value in milliseconds |
| decaf::lang::Comparable< Delayed > | |
| decaf::util::concurrent::Delayed | A mix-in style interface for marking objects that should be acted upon after a given delay |
| decaf::lang::Comparable< Double > | |
| decaf::lang::Double | |
| decaf::lang::Comparable< double > | |
| decaf::lang::Double | |
| decaf::lang::Comparable< DoubleBuffer > | |
| decaf::nio::DoubleBuffer | This class defines four categories of operations upon double buffers: |
| decaf::lang::Comparable< Float > | |
| decaf::lang::Float | |
| decaf::lang::Comparable< float > | |
| decaf::lang::Float | |
| decaf::lang::Comparable< FloatBuffer > | |
| decaf::nio::FloatBuffer | This class defines four categories of operations upon float buffers: |
| decaf::lang::Comparable< int > | |
| decaf::lang::Integer | |
| decaf::lang::Comparable< IntBuffer > | |
| decaf::nio::IntBuffer | This class defines four categories of operations upon int buffers: |
| decaf::lang::Comparable< Integer > | |
| decaf::lang::Integer | |
| decaf::lang::Comparable< Level > | |
| decaf::util::logging::Level | Defines a set of standard logging levels that can be used to control logging output |
| decaf::lang::Comparable< LocalTransactionId > | |
| activemq::commands::LocalTransactionId | |
| decaf::lang::Comparable< Long > | |
| decaf::lang::Long | |
| decaf::lang::Comparable< long long > | |
| decaf::lang::Long | |
| decaf::lang::Comparable< LongBuffer > | |
| decaf::nio::LongBuffer | This class defines four categories of operations upon long long buffers: |
| decaf::lang::Comparable< MessageId > | |
| activemq::commands::MessageId | |
| decaf::lang::Comparable< ProducerId > | |
| activemq::commands::ProducerId | |
| decaf::lang::Comparable< SessionId > | |
| activemq::commands::SessionId | |
| decaf::lang::Comparable< Short > | |
| decaf::lang::Short | |
| decaf::lang::Comparable< short > | |
| decaf::lang::Short | |
| decaf::lang::Comparable< ShortBuffer > | |
| decaf::nio::ShortBuffer | This class defines four categories of operations upon short buffers: |
| decaf::lang::Comparable< TimeUnit > | |
| decaf::util::concurrent::TimeUnit | 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 |
| decaf::lang::Comparable< TransactionId > | |
| activemq::commands::TransactionId | |
| activemq::commands::LocalTransactionId | |
| activemq::commands::XATransactionId | |
| decaf::lang::Comparable< unsigned char > | |
| decaf::lang::Byte | |
| decaf::lang::Comparable< URI > | |
| decaf::net::URI | This class represents an instance of a URI as defined by RFC 2396 |
| decaf::lang::Comparable< UUID > | |
| decaf::util::UUID | A class that represents an immutable universally unique identifier (UUID) |
| decaf::lang::Comparable< XATransactionId > | |
| activemq::commands::XATransactionId | |
| decaf::util::Comparator< T > | A comparison function, which imposes a total ordering on some collection of objects |
| decaf::util::Comparator< ArrayPointer< T > > | |
| decaf::lang::ArrayPointerComparator< T > | 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 |
| decaf::util::Comparator< E > | |
| decaf::util::comparators::Less< E > | Simple Less Comparator that compares to elements to determine if the first is less than the second |
| decaf::util::Comparator< Pointer< T, R > > | |
| decaf::lang::PointerComparator< T, R > | 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 |
| decaf::internal::util::concurrent::CompletionCondition | |
| activemq::util::CompositeData | Represents a Composite URI |
| decaf::util::concurrent::ConcurrentHashMap | |
| decaf::util::concurrent::locks::Condition | 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 |
| decaf::util::concurrent::locks::AbstractQueuedSynchronizer::ConditionObject | Condition object for this Synchronizer, which serves as the basis for other Lock objects |
| cms::ConnectionFactory | 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 |
| activemq::core::ActiveMQConnectionFactory | |
| activemq::core::ActiveMQXAConnectionFactory | |
| cms::ConnectionMetaData | A ConnectionMetaData object provides information describing the Connection object |
| activemq::core::ActiveMQConnectionMetaData | This class houses all the various settings and information that is used by an instance of an ActiveMQConnection class |
| activemq::state::ConnectionState | |
| activemq::state::ConsumerState | |
| decaf::util::concurrent::CountDownLatch | |
| ct_data_s | |
| decaf::net::DatagramPacket | Class that represents a single datagram packet |
| decaf::io::DataInput | The DataInput interface provides for reading bytes from a binary stream and reconstructing from them data in any of the C++ primitive types |
| decaf::io::DataOutput | 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 |
| activemq::wireformat::openwire::marshal::DataStreamMarshaller | Base class for all classes that marshal commands for Openwire |
| activemq::wireformat::openwire::marshal::BaseDataStreamMarshaller | Base class for all Marshallers that marshal DataStructures to and from the wire using the OpenWire protocol |
| activemq::wireformat::openwire::marshal::generated::ActiveMQDestinationMarshaller | Marshaling code for Open Wire Format for ActiveMQDestinationMarshaller |
| activemq::wireformat::openwire::marshal::generated::ActiveMQQueueMarshaller | Marshaling code for Open Wire Format for ActiveMQQueueMarshaller |
| activemq::wireformat::openwire::marshal::generated::ActiveMQTempDestinationMarshaller | Marshaling code for Open Wire Format for ActiveMQTempDestinationMarshaller |
| activemq::wireformat::openwire::marshal::generated::ActiveMQTempQueueMarshaller | Marshaling code for Open Wire Format for ActiveMQTempQueueMarshaller |
| activemq::wireformat::openwire::marshal::generated::ActiveMQTempTopicMarshaller | Marshaling code for Open Wire Format for ActiveMQTempTopicMarshaller |
| activemq::wireformat::openwire::marshal::generated::ActiveMQTopicMarshaller | Marshaling code for Open Wire Format for ActiveMQTopicMarshaller |
| activemq::wireformat::openwire::marshal::generated::BaseCommandMarshaller | Marshaling code for Open Wire Format for BaseCommandMarshaller |
| activemq::wireformat::openwire::marshal::generated::BrokerInfoMarshaller | Marshaling code for Open Wire Format for BrokerInfoMarshaller |
| activemq::wireformat::openwire::marshal::generated::ConnectionControlMarshaller | Marshaling code for Open Wire Format for ConnectionControlMarshaller |
| activemq::wireformat::openwire::marshal::generated::ConnectionErrorMarshaller | Marshaling code for Open Wire Format for ConnectionErrorMarshaller |
| activemq::wireformat::openwire::marshal::generated::ConnectionInfoMarshaller | Marshaling code for Open Wire Format for ConnectionInfoMarshaller |
| activemq::wireformat::openwire::marshal::generated::ConsumerControlMarshaller | Marshaling code for Open Wire Format for ConsumerControlMarshaller |
| activemq::wireformat::openwire::marshal::generated::ConsumerInfoMarshaller | Marshaling code for Open Wire Format for ConsumerInfoMarshaller |
| activemq::wireformat::openwire::marshal::generated::ControlCommandMarshaller | Marshaling code for Open Wire Format for ControlCommandMarshaller |
| activemq::wireformat::openwire::marshal::generated::DestinationInfoMarshaller | Marshaling code for Open Wire Format for DestinationInfoMarshaller |
| activemq::wireformat::openwire::marshal::generated::FlushCommandMarshaller | Marshaling code for Open Wire Format for FlushCommandMarshaller |
| activemq::wireformat::openwire::marshal::generated::KeepAliveInfoMarshaller | Marshaling code for Open Wire Format for KeepAliveInfoMarshaller |
| activemq::wireformat::openwire::marshal::generated::MessageAckMarshaller | Marshaling code for Open Wire Format for MessageAckMarshaller |
| activemq::wireformat::openwire::marshal::generated::MessageDispatchMarshaller | Marshaling code for Open Wire Format for MessageDispatchMarshaller |
| activemq::wireformat::openwire::marshal::generated::MessageDispatchNotificationMarshaller | Marshaling code for Open Wire Format for MessageDispatchNotificationMarshaller |
| activemq::wireformat::openwire::marshal::generated::MessageMarshaller | Marshaling code for Open Wire Format for MessageMarshaller |
| activemq::wireformat::openwire::marshal::generated::ActiveMQBlobMessageMarshaller | Marshaling code for Open Wire Format for ActiveMQBlobMessageMarshaller |
| activemq::wireformat::openwire::marshal::generated::ActiveMQBytesMessageMarshaller | Marshaling code for Open Wire Format for ActiveMQBytesMessageMarshaller |
| activemq::wireformat::openwire::marshal::generated::ActiveMQMapMessageMarshaller | Marshaling code for Open Wire Format for ActiveMQMapMessageMarshaller |
| activemq::wireformat::openwire::marshal::generated::ActiveMQMessageMarshaller | Marshaling code for Open Wire Format for ActiveMQMessageMarshaller |
| activemq::wireformat::openwire::marshal::generated::ActiveMQObjectMessageMarshaller | Marshaling code for Open Wire Format for ActiveMQObjectMessageMarshaller |
| activemq::wireformat::openwire::marshal::generated::ActiveMQStreamMessageMarshaller | Marshaling code for Open Wire Format for ActiveMQStreamMessageMarshaller |
| activemq::wireformat::openwire::marshal::generated::ActiveMQTextMessageMarshaller | Marshaling code for Open Wire Format for ActiveMQTextMessageMarshaller |
| activemq::wireformat::openwire::marshal::generated::MessagePullMarshaller | Marshaling code for Open Wire Format for MessagePullMarshaller |
| activemq::wireformat::openwire::marshal::generated::ProducerAckMarshaller | Marshaling code for Open Wire Format for ProducerAckMarshaller |
| activemq::wireformat::openwire::marshal::generated::ProducerInfoMarshaller | Marshaling code for Open Wire Format for ProducerInfoMarshaller |
| activemq::wireformat::openwire::marshal::generated::RemoveInfoMarshaller | Marshaling code for Open Wire Format for RemoveInfoMarshaller |
| activemq::wireformat::openwire::marshal::generated::RemoveSubscriptionInfoMarshaller | Marshaling code for Open Wire Format for RemoveSubscriptionInfoMarshaller |
| activemq::wireformat::openwire::marshal::generated::ReplayCommandMarshaller | Marshaling code for Open Wire Format for ReplayCommandMarshaller |
| activemq::wireformat::openwire::marshal::generated::ResponseMarshaller | Marshaling code for Open Wire Format for ResponseMarshaller |
| activemq::wireformat::openwire::marshal::generated::DataArrayResponseMarshaller | Marshaling code for Open Wire Format for DataArrayResponseMarshaller |
| activemq::wireformat::openwire::marshal::generated::DataResponseMarshaller | Marshaling code for Open Wire Format for DataResponseMarshaller |
| activemq::wireformat::openwire::marshal::generated::ExceptionResponseMarshaller | Marshaling code for Open Wire Format for ExceptionResponseMarshaller |
| activemq::wireformat::openwire::marshal::generated::IntegerResponseMarshaller | Marshaling code for Open Wire Format for IntegerResponseMarshaller |
| activemq::wireformat::openwire::marshal::generated::SessionInfoMarshaller | Marshaling code for Open Wire Format for SessionInfoMarshaller |
| activemq::wireformat::openwire::marshal::generated::ShutdownInfoMarshaller | Marshaling code for Open Wire Format for ShutdownInfoMarshaller |
| activemq::wireformat::openwire::marshal::generated::TransactionInfoMarshaller | Marshaling code for Open Wire Format for TransactionInfoMarshaller |
| activemq::wireformat::openwire::marshal::generated::BrokerIdMarshaller | Marshaling code for Open Wire Format for BrokerIdMarshaller |
| activemq::wireformat::openwire::marshal::generated::ConnectionIdMarshaller | Marshaling code for Open Wire Format for ConnectionIdMarshaller |
| activemq::wireformat::openwire::marshal::generated::ConsumerIdMarshaller | Marshaling code for Open Wire Format for ConsumerIdMarshaller |
| activemq::wireformat::openwire::marshal::generated::DiscoveryEventMarshaller | Marshaling code for Open Wire Format for DiscoveryEventMarshaller |
| activemq::wireformat::openwire::marshal::generated::JournalQueueAckMarshaller | Marshaling code for Open Wire Format for JournalQueueAckMarshaller |
| activemq::wireformat::openwire::marshal::generated::JournalTopicAckMarshaller | Marshaling code for Open Wire Format for JournalTopicAckMarshaller |
| activemq::wireformat::openwire::marshal::generated::JournalTraceMarshaller | Marshaling code for Open Wire Format for JournalTraceMarshaller |
| activemq::wireformat::openwire::marshal::generated::JournalTransactionMarshaller | Marshaling code for Open Wire Format for JournalTransactionMarshaller |
| activemq::wireformat::openwire::marshal::generated::MessageIdMarshaller | Marshaling code for Open Wire Format for MessageIdMarshaller |
| activemq::wireformat::openwire::marshal::generated::NetworkBridgeFilterMarshaller | Marshaling code for Open Wire Format for NetworkBridgeFilterMarshaller |
| activemq::wireformat::openwire::marshal::generated::PartialCommandMarshaller | Marshaling code for Open Wire Format for PartialCommandMarshaller |
| activemq::wireformat::openwire::marshal::generated::LastPartialCommandMarshaller | Marshaling code for Open Wire Format for LastPartialCommandMarshaller |
| activemq::wireformat::openwire::marshal::generated::ProducerIdMarshaller | Marshaling code for Open Wire Format for ProducerIdMarshaller |
| activemq::wireformat::openwire::marshal::generated::SessionIdMarshaller | Marshaling code for Open Wire Format for SessionIdMarshaller |
| activemq::wireformat::openwire::marshal::generated::SubscriptionInfoMarshaller | Marshaling code for Open Wire Format for SubscriptionInfoMarshaller |
| activemq::wireformat::openwire::marshal::generated::TransactionIdMarshaller | Marshaling code for Open Wire Format for TransactionIdMarshaller |
| activemq::wireformat::openwire::marshal::generated::LocalTransactionIdMarshaller | Marshaling code for Open Wire Format for LocalTransactionIdMarshaller |
| activemq::wireformat::openwire::marshal::generated::XATransactionIdMarshaller | Marshaling code for Open Wire Format for XATransactionIdMarshaller |
| activemq::wireformat::openwire::marshal::generated::WireFormatInfoMarshaller | Marshaling code for Open Wire Format for WireFormatInfoMarshaller |
| decaf::internal::net::ssl::DefaultSSLContext | Default SSLContext manager for the Decaf library |
| decaf::util::zip::Deflater | This class compresses data using the DEFLATE algorithm (see specification) |
| cms::DeliveryMode | This is an Abstract class whose purpose is to provide a container for the delivery mode enumeration for CMS messages |
| cms::Destination | A Destination object encapsulates a provider-specific address |
| cms::Queue | An interface encapsulating a provider-specific queue name |
| activemq::commands::ActiveMQQueue | |
| cms::TemporaryQueue | Defines a Temporary Queue based Destination |
| activemq::commands::ActiveMQTempQueue | |
| cms::Topic | An interface encapsulating a provider-specific topic name |
| activemq::commands::ActiveMQTopic | |
| cms::TemporaryTopic | Defines a Temporary Topic based Destination |
| activemq::commands::ActiveMQTempTopic | |
| activemq::commands::ActiveMQDestination::DestinationFilter | |
| activemq::cmsutil::DestinationResolver | Resolves a CMS destination name to a Destination |
| activemq::cmsutil::DynamicDestinationResolver | Resolves a CMS destination name to a Destination |
| activemq::core::DispatchData | Simple POCO that contains the information necessary to route a message to a specified consumer |
| activemq::core::Dispatcher | Interface for an object responsible for dispatching messages to consumers |
| activemq::core::AdvisoryConsumer | |
| activemq::core::kernels::ActiveMQConsumerKernel | |
| activemq::core::kernels::ActiveMQSessionKernel | |
| decaf::lang::DYNAMIC_CAST_TOKEN | |
| decaf::util::logging::ErrorManager | ErrorManager objects can be attached to Handlers to process any error that occur on a Handler during Logging |
| cms::ExceptionListener | If a CMS provider detects a serious problem, it notifies the client application through an ExceptionListener that is registered with the Connection |
| cms::AsyncCallback | Asynchronous event interface for CMS asynchronous operations |
| decaf::util::concurrent::Executor | An object that executes submitted decaf.lang.Runnable tasks |
| decaf::util::concurrent::ExecutorService | An Executor that provides methods to manage termination and methods that can produce a Future for tracking progress of one or more asynchronous tasks |
| decaf::util::concurrent::AbstractExecutorService | Provides a default implementation for the methods of the ExecutorService interface |
| decaf::util::concurrent::ThreadPoolExecutor | Defines a Thread Pool object that implements the functionality of pooling threads to perform user tasks |
| decaf::util::concurrent::Executors | 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 |
| decaf::internal::util::concurrent::ExecutorsSupport | Various support methods for use in Executors and surrounding classes |
| decaf::io::FileDescriptor | 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 |
| decaf::internal::net::SocketFileDescriptor | File Descriptor type used internally by Decaf Socket objects |
| decaf::util::logging::Filter | A Filter can be used to provide fine grain control over what is logged, beyond the control provided by log levels |
| decaf::io::Flushable | A Flushable is a destination of data that can be flushed |
| decaf::io::OutputStream | Base interface for any class that wants to represent an output stream of bytes |
| decaf::io::Writer | |
| decaf::util::logging::Formatter | A Formatter provides support for formatting LogRecords |
| decaf::util::logging::SimpleFormatter | Print a brief summary of the LogRecord in a human readable format |
| decaf::util::logging::XMLFormatter | Format a LogRecord into a standard XML format |
| activemq::transport::FutureResponse | A container that holds a response object |
| decaf::util::concurrent::FutureType | |
| decaf::util::concurrent::Future< V > | A Future represents the result of an asynchronous computation |
| decaf::util::concurrent::Future< T > | |
| decaf::util::concurrent::RunnableFuture< T > | A Runnable version of the Future type |
| decaf::util::concurrent::FutureTask< T > | A cancellable asynchronous computation |
| gz_header_s | |
| gz_state | |
| decaf::util::HashCodeUnaryBase< T > | |
| decaf::util::HashCode< T > | Base HashCode template, specializations are created from this to account for the various native types |
| decaf::util::HashCodeUnaryBase< bool > | |
| decaf::util::HashCode< bool > | |
| decaf::util::HashCodeUnaryBase< char > | |
| decaf::util::HashCode< char > | |
| decaf::util::HashCodeUnaryBase< const std::string & > | |
| decaf::util::HashCode< std::string > | |
| decaf::util::HashCodeUnaryBase< const T & > | |
| decaf::util::HashCode< const T & > | |
| decaf::util::HashCodeUnaryBase< decaf::lang::Pointer< T > > | |
| decaf::util::HashCode< decaf::lang::Pointer< T > > | |
| decaf::util::HashCodeUnaryBase< double > | |
| decaf::util::HashCode< double > | |
| decaf::util::HashCodeUnaryBase< float > | |
| decaf::util::HashCode< float > | |
| decaf::util::HashCodeUnaryBase< int > | |
| decaf::util::HashCode< int > | |
| decaf::util::HashCodeUnaryBase< long long > | |
| decaf::util::HashCode< long long > | |
| decaf::util::HashCodeUnaryBase< short > | |
| decaf::util::HashCode< short > | |
| decaf::util::HashCodeUnaryBase< T * > | |
| decaf::util::HashCode< T * > | |
| decaf::util::HashCodeUnaryBase< unsigned int > | |
| decaf::util::HashCode< unsigned int > | |
| decaf::util::HashCodeUnaryBase< unsigned long long > | |
| decaf::util::HashCode< unsigned long long > | |
| decaf::util::HashCodeUnaryBase< unsigned short > | |
| decaf::util::HashCode< unsigned short > | |
| decaf::util::HashCodeUnaryBase< wchar_t > | |
| decaf::util::HashCode< wchar_t > | |
| decaf::internal::util::HexStringParser | |
| activemq::wireformat::openwire::utils::HexTable | Maps hexidecimal strings to the value of an index into the table, i.e |
| activemq::util::IdGenerator | |
| decaf::net::InetAddress | Represents an IP address |
| decaf::net::Inet4Address | |
| decaf::net::Inet6Address | |
| inflate_state | |
| decaf::util::zip::Inflater | This class uncompresses data that was compressed using the DEFLATE algorithm (see specification) |
| internal_state | |
| decaf::lang::Iterable< E > | Implementing this interface allows an object to be cast to an Iterable type for generic collections API calls |
| decaf::util::Collection< E > | The root interface in the collection hierarchy |
| decaf::util::AbstractCollection< E > | This class provides a skeletal implementation of the Collection interface, to minimize the effort required to implement this interface |
| decaf::util::AbstractList< E > | 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) |
| decaf::util::AbstractSequentialList< E > | 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) |
| decaf::util::LinkedList< E > | A complete implementation of the List interface using a doubly linked list data structure |
| decaf::util::ArrayList< E > | |
| decaf::util::StlList< E > | List class that wraps the STL list object to provide a simpler interface and additional methods not provided by the STL type |
| decaf::util::AbstractQueue< E > | This class provides skeletal implementations of some Queue operations |
| decaf::util::concurrent::BlockingQueue< E > | 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 |
| decaf::util::concurrent::LinkedBlockingQueue< E > | A BlockingQueue derivative that allows for a bound to be placed on the number of elements that can be enqueued at any one time |
| decaf::util::concurrent::SynchronousQueue< E > | A blocking queue in which each insert operation must wait for a corresponding remove operation by another thread, and vice versa |
| decaf::util::PriorityQueue< E > | An unbounded priority queue based on a binary heap algorithm |
| decaf::util::AbstractSet< E > | This class provides a skeletal implementation of the Set interface to minimize the effort required to implement this interface |
| decaf::util::concurrent::CopyOnWriteArraySet< E > | Since the CopyOnWriteArraySet and the CopyOnWriteArrayList share much of the same operational semantics this class uses the CopyOnWriteArrayList for all its underlying operations |
| decaf::util::StlSet< E > | 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 |
| decaf::util::List< E > | An ordered collection (also known as a sequence) |
| decaf::util::AbstractList< E > | 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) |
| decaf::util::concurrent::CopyOnWriteArrayList< E > | |
| decaf::util::Queue< E > | A kind of collection provides advanced operations than other basic collections, such as insertion, extraction, and inspection |
| decaf::util::AbstractQueue< E > | This class provides skeletal implementations of some Queue operations |
| decaf::util::Deque< E > | Defines a 'Double ended Queue' interface that allows for insertion and removal of elements from both ends |
| decaf::util::LinkedList< E > | A complete implementation of the List interface using a doubly linked list data structure |
| decaf::util::Set< E > | A collection that contains no duplicate elements |
| decaf::util::AbstractSet< E > | This class provides a skeletal implementation of the Set interface to minimize the effort required to implement this interface |
| decaf::lang::Iterable< K > | |
| decaf::util::Collection< K > | |
| decaf::util::AbstractCollection< K > | |
| decaf::util::AbstractSet< K > | |
| decaf::util::Set< K > | |
| decaf::util::AbstractSet< K > | |
| decaf::lang::Iterable< MapEntry< K, V > > | |
| decaf::util::Collection< MapEntry< K, V > > | |
| decaf::util::AbstractCollection< MapEntry< K, V > > | |
| decaf::util::AbstractSet< MapEntry< K, V > > | |
| decaf::util::Set< MapEntry< K, V > > | |
| decaf::util::AbstractSet< MapEntry< K, V > > | |
| decaf::lang::Iterable< PrimitiveValueNode > | |
| decaf::util::Collection< PrimitiveValueNode > | |
| decaf::util::AbstractCollection< PrimitiveValueNode > | |
| decaf::util::AbstractList< PrimitiveValueNode > | |
| decaf::util::AbstractSequentialList< PrimitiveValueNode > | |
| decaf::util::LinkedList< PrimitiveValueNode > | |
| activemq::util::PrimitiveList | List of primitives |
| decaf::util::List< PrimitiveValueNode > | |
| decaf::util::AbstractList< PrimitiveValueNode > | |
| decaf::util::Queue< PrimitiveValueNode > | |
| decaf::util::Deque< PrimitiveValueNode > | |
| decaf::util::LinkedList< PrimitiveValueNode > | |
| decaf::lang::Iterable< V > | |
| decaf::util::Collection< V > | |
| decaf::util::AbstractCollection< V > | |
| decaf::util::Iterator< E > | Defines an object that can be used to iterate over the elements of a collection |
| decaf::util::ListIterator< E > | 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 |
| decaf::util::concurrent::CopyOnWriteArrayList< E >::ArrayListIterator | |
| decaf::util::Iterator< K > | |
| decaf::util::Iterator< MapEntry< K, V > > | |
| decaf::util::Iterator< T > | |
| decaf::util::Iterator< V > | |
| decaf::security::Key | The Key interface is the top-level interface for all keys |
| decaf::security::PublicKey | A public key |
| std::less< decaf::lang::ArrayPointer< T > > | An override of the less function object so that the Pointer objects can be stored in STL Maps, etc |
| std::less< decaf::lang::Pointer< T > > | An override of the less function object so that the Pointer objects can be stored in STL Maps, etc |
| decaf::util::concurrent::Lock | A wrapper class around a given synchronization mechanism that provides automatic release upon destruction |
| decaf::util::concurrent::locks::Lock | Lock implementations provide more extensive locking operations than can be obtained using synchronized statements |
| decaf::util::concurrent::locks::ReentrantLock | A reentrant mutual exclusion Lock with extended capabilities |
| decaf::util::concurrent::locks::LockSupport | Basic thread blocking primitives for creating locks and other synchronization classes |
| decaf::util::logging::Logger | A Logger object is used to log messages for a specific system or application component |
| decaf::util::logging::LoggerHierarchy | |
| decaf::util::logging::LogManager | There is a single global LogManager object that is used to maintain a set of shared state about Loggers and log services |
| decaf::util::logging::LogRecord | LogRecord objects are used to pass logging requests between the logging framework and individual log Handlers |
| decaf::util::logging::LogWriter | |
| activemq::util::LongSequenceGenerator | This class is used to generate a sequence of long long values that are incremented each time a new value is requested |
| decaf::util::MapEntry< K, V > | |
| decaf::util::logging::MarkBlockLogger | Defines a class that can be used to mark the entry and exit from scoped blocks |
| activemq::wireformat::MarshalAware | |
| activemq::commands::DataStructure | |
| activemq::commands::BaseDataStructure | |
| activemq::commands::ActiveMQDestination | |
| activemq::commands::BooleanExpression | |
| activemq::commands::BrokerId | |
| activemq::commands::Command | |
| activemq::commands::BaseCommand | |
| activemq::commands::BrokerError | This class represents an Exception sent from the Broker |
| activemq::commands::BrokerInfo | |
| activemq::commands::ConnectionControl | |
| activemq::commands::ConnectionError | |
| activemq::commands::ConnectionInfo | |
| activemq::commands::ConsumerControl | |
| activemq::commands::ConsumerInfo | |
| activemq::commands::ControlCommand | |
| activemq::commands::DestinationInfo | |
| activemq::commands::FlushCommand | |
| activemq::commands::KeepAliveInfo | |
| activemq::commands::Message | |
| activemq::commands::ActiveMQMessageTemplate< T > | |
| activemq::commands::ActiveMQMessageTemplate< cms::BytesMessage > | |
| activemq::commands::ActiveMQBytesMessage | |
| activemq::commands::ActiveMQMessageTemplate< cms::MapMessage > | |
| activemq::commands::ActiveMQMapMessage | |
| activemq::commands::ActiveMQMessageTemplate< cms::Message > | |
| activemq::commands::ActiveMQBlobMessage | |
| activemq::commands::ActiveMQMessage | |
| activemq::commands::ActiveMQMessageTemplate< cms::ObjectMessage > | |
| activemq::commands::ActiveMQObjectMessage | |
| activemq::commands::ActiveMQMessageTemplate< cms::StreamMessage > | |
| activemq::commands::ActiveMQStreamMessage | |
| activemq::commands::ActiveMQMessageTemplate< cms::TextMessage > | |
| activemq::commands::ActiveMQTextMessage | |
| activemq::commands::MessageAck | |
| activemq::commands::MessageDispatch | |
| activemq::commands::MessageDispatchNotification | |
| activemq::commands::MessagePull | |
| activemq::commands::ProducerAck | |
| activemq::commands::ProducerInfo | |
| activemq::commands::RemoveInfo | |
| activemq::commands::RemoveSubscriptionInfo | |
| activemq::commands::ReplayCommand | |
| activemq::commands::Response | |
| activemq::commands::DataArrayResponse | |
| activemq::commands::DataResponse | |
| activemq::commands::ExceptionResponse | |
| activemq::commands::IntegerResponse | |
| activemq::state::Tracked | |
| activemq::commands::SessionInfo | |
| activemq::commands::ShutdownInfo | |
| activemq::commands::TransactionInfo | |
| activemq::commands::WireFormatInfo | |
| activemq::commands::ConnectionId | |
| activemq::commands::ConsumerId | |
| activemq::commands::DiscoveryEvent | |
| activemq::commands::JournalQueueAck | |
| activemq::commands::JournalTopicAck | |
| activemq::commands::JournalTrace | |
| activemq::commands::JournalTransaction | |
| activemq::commands::MessageId | |
| activemq::commands::NetworkBridgeFilter | |
| activemq::commands::PartialCommand | |
| activemq::commands::LastPartialCommand | |
| activemq::commands::ProducerId | |
| activemq::commands::SessionId | |
| activemq::commands::SubscriptionInfo | |
| activemq::commands::TransactionId | |
| activemq::wireformat::openwire::marshal::generated::MarshallerFactory | Used to create marshallers for a specific version of the wire protocol |
| activemq::util::MarshallingSupport | |
| decaf::lang::Math | The class Math contains methods for performing basic numeric operations such as the elementary exponential, logarithm, square root, and trigonometric functions |
| cms::Message | Root of all messages |
| activemq::commands::ActiveMQMessageTemplate< cms::Message > | |
| cms::BytesMessage | A BytesMessage object is used to send a message containing a stream of unsigned bytes |
| activemq::commands::ActiveMQMessageTemplate< cms::BytesMessage > | |
| cms::MapMessage | A MapMessage object is used to send a set of name-value pairs |
| activemq::commands::ActiveMQMessageTemplate< cms::MapMessage > | |
| cms::ObjectMessage | Place holder for interaction with JMS systems that support Java, the C++ client is not responsible for deserializing the contained Object |
| activemq::commands::ActiveMQMessageTemplate< cms::ObjectMessage > | |
| cms::StreamMessage | Interface for a StreamMessage |
| activemq::commands::ActiveMQMessageTemplate< cms::StreamMessage > | |
| cms::TextMessage | Interface for a text message |
| activemq::commands::ActiveMQMessageTemplate< cms::TextMessage > | |
| cms::MessageAvailableListener | A listener interface similar to the MessageListener interface |
| activemq::cmsutil::MessageCreator | Creates the user-defined message to be sent by the CmsTemplate |
| cms::MessageEnumeration | Defines an object that enumerates a collection of Messages |
| activemq::core::ActiveMQQueueBrowser | |
| cms::MessageListener | A MessageListener object is used to receive asynchronously delivered messages |
| activemq::wireformat::openwire::utils::MessagePropertyInterceptor | 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 |
| cms::MessageTransformer | 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 |
| decaf::internal::util::concurrent::MonitorHandle | |
| decaf::internal::net::Network | Internal class used to manage Networking related resources and hide platform dependent calls from the higher level API |
| decaf::lang::Number | The abstract class Number is the superclass of classes Byte, Double, Float, Integer, Long, and Short |
| decaf::lang::Byte | |
| decaf::lang::Character | |
| decaf::lang::Double | |
| decaf::lang::Float | |
| decaf::lang::Integer | |
| decaf::lang::Long | |
| decaf::lang::Short | |
| decaf::util::concurrent::atomic::AtomicInteger | An int value that may be updated atomically |
| decaf::internal::net::ssl::openssl::OpenSSLParameters | Container class for parameters that are Common to OpenSSL socket classes |
| decaf::internal::util::concurrent::PlatformThread | |
| decaf::lang::Pointer< T, REFCOUNTER > | 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 |
| activemq::core::PrefetchPolicy | Interface for a Policy object that controls message Prefetching on various destination types in ActiveMQ-CPP |
| activemq::core::policies::DefaultPrefetchPolicy | |
| activemq::wireformat::openwire::marshal::PrimitiveTypesMarshaller | 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 |
| activemq::util::PrimitiveValueNode::PrimitiveValue | Define a union type comprised of the various types |
| activemq::util::PrimitiveValueConverter | Class controls the conversion of data contained in a PrimitiveValueNode from one type to another |
| activemq::util::PrimitiveValueNode | Class that wraps around a single value of one of the many types |
| decaf::security::Principal | Base interface for a principal, which can represent an individual or organization |
| decaf::security::auth::x500::X500Principal | |
| decaf::util::PriorityQueueBase | |
| decaf::util::PriorityQueue< E > | An unbounded priority queue based on a binary heap algorithm |
| activemq::cmsutil::ProducerCallback | Callback for sending a message to a CMS destination |
| activemq::cmsutil::CmsTemplate::SendExecutor | |
| activemq::state::ProducerState | |
| decaf::util::Properties | Java-like properties class for mapping string names to string values |
| decaf::util::logging::PropertiesChangeListener | Defines the interface that classes can use to listen for change events on Properties |
| decaf::util::Random | Random Value Generator which is used to generate a stream of pseudorandom numbers |
| decaf::security::SecureRandom | |
| decaf::lang::Readable | A Readable is a source of characters |
| decaf::io::Reader | |
| decaf::util::concurrent::locks::ReadWriteLock | A ReadWriteLock maintains a pair of associated locks, one for read-only operations and one for writing |
| decaf::util::concurrent::locks::ReentrantReadWriteLock | |
| activemq::core::RedeliveryPolicy | Interface for a RedeliveryPolicy object that controls how message Redelivery is handled in ActiveMQ-CPP when a transaction is rolled back |
| activemq::core::policies::DefaultRedeliveryPolicy | |
| decaf::util::concurrent::RejectedExecutionHandler | A handler for tasks that cannot be executed by a ThreadPoolExecutor |
| decaf::util::concurrent::ThreadPoolExecutor::AbortPolicy | Handler policy for tasks that are rejected upon a call to ThreadPoolExecutor::execute this class always throws a RejectedExecutionException |
| decaf::util::concurrent::ThreadPoolExecutor::CallerRunsPolicy | 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 |
| decaf::util::concurrent::ThreadPoolExecutor::DiscardOldestPolicy | 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 |
| decaf::util::concurrent::ThreadPoolExecutor::DiscardPolicy | Handler policy for tasks that are rejected upon a call to ThreadPoolExecutor::execute this class always destroys the rejected task and returns quietly |
| decaf::internal::util::Resource | Interface for all Managed Resources in Decaf, these objects are added to the Runtime System and are destroyed at shutdown |
| decaf::internal::util::GenericResource< T > | A Generic Resource wraps some type and will delete it when the Resource itself is deleted |
| activemq::cmsutil::ResourceLifecycleManager | Manages the lifecycle of a set of CMS resources |
| decaf::internal::util::ResourceLifecycleManager | |
| activemq::transport::mock::ResponseBuilder | Interface for all Protocols to implement that defines the behavior of the Broker in response to messages of that protocol |
| activemq::wireformat::openwire::OpenWireResponseBuilder | Used to allow a MockTransport to generate response commands to OpenWire Commands |
| activemq::transport::ResponseCallback | Allows an async send to complete at a later time via a Response event |
| decaf::lang::Runnable | Interface for a runnable object - defines a task that can be run by a thread |
| activemq::threads::CompositeTaskRunner | 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 |
| activemq::threads::DedicatedTaskRunner | |
| activemq::transport::IOTransport | Implementation of the Transport interface that performs marshaling of commands to IO streams |
| decaf::lang::Thread | A Thread is a concurrent unit of execution |
| activemq::transport::mock::InternalCommandListener | Listens for Commands sent from the MockTransport |
| decaf::util::concurrent::RunnableFuture< T > | A Runnable version of the Future type |
| decaf::util::TimerTask | A Base class for a task object that can be scheduled for one-time or repeated execution by a Timer |
| activemq::threads::SchedulerTimerTask | Extension of the Decaf TimerTask that adds a Runnable instance which is the target of this task |
| activemq::transport::inactivity::ReadChecker | Runnable class that is used by the { |
| activemq::transport::inactivity::WriteChecker | Runnable class used by the { |
| decaf::lang::Runtime | |
| decaf::internal::DecafRuntime | Handles APR initialization and termination |
| decaf::internal::util::concurrent::RWLOCK | |
| decaf::security::SecureRandomSpi | Interface class used by Security Service Providers to implement a source of secure random bytes |
| decaf::internal::security::SecureRandomImpl | Secure Random Number Generator for Unix based platforms that attempts to obtain secure bytes with high entropy from known sources |
| decaf::internal::security::SecureRandomImpl | Secure Random Number Generator for Unix based platforms that attempts to obtain secure bytes with high entropy from known sources |
| decaf::util::concurrent::Semaphore | A counting semaphore |
| decaf::net::ServerSocket | This class implements server sockets |
| decaf::net::ssl::SSLServerSocket | Represents a server socket that is used to accept connections from clients using the Secure Sockets protocol or the Top Level Security protocol |
| decaf::internal::net::ssl::openssl::OpenSSLServerSocket | SSLServerSocket based on OpenSSL library code |
| decaf::net::ServerSocketFactory | Class used to create Server Sockets, subclasses can be created that create certain types of server sockets according to specific policies |
| decaf::internal::net::DefaultServerSocketFactory | Default implementation of the Decaf ServerSocketFactory, creates ServerSocket objects with supplied options |
| decaf::net::ssl::SSLServerSocketFactory | Factory class interface that provides methods to create SSL Server Sockets |
| decaf::internal::net::ssl::DefaultSSLServerSocketFactory | 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 |
| decaf::internal::net::ssl::openssl::OpenSSLServerSocketFactory | SSLServerSocketFactory that creates Server Sockets that use OpenSSL |
| activemq::util::Service | Base interface for all classes that run as a Service inside the application |
| activemq::util::ServiceSupport | Provides a base class for Service implementations |
| activemq::threads::Scheduler | Scheduler class for use in executing Runnable Tasks either periodically or one time only with optional delay |
| activemq::util::ServiceListener | Listener interface for observers of Service related events |
| activemq::util::ServiceStopper | |
| activemq::cmsutil::SessionCallback | Callback for executing any number of operations on a provided CMS Session |
| activemq::cmsutil::CmsTemplate::ProducerExecutor | |
| activemq::cmsutil::CmsTemplate::ResolveProducerExecutor | |
| activemq::cmsutil::CmsTemplate::ReceiveExecutor | |
| activemq::cmsutil::CmsTemplate::ResolveReceiveExecutor | |
| activemq::cmsutil::SessionPool | A pool of CMS sessions from the same connection and with the same acknowledge mode |
| activemq::state::SessionState | |
| decaf::util::logging::SimpleLogger | |
| decaf::net::SocketAddress | Base class for protocol specific Socket addresses |
| decaf::net::InetSocketAddress | |
| decaf::net::SocketError | Static utility class to simplify handling of error codes for socket operations |
| decaf::net::SocketFactory | The SocketFactory is used to create Socket objects and can be sub-classed to provide other types of Sockets or Sockets with varying configurations |
| decaf::internal::net::DefaultSocketFactory | SocketFactory implementation that is used to create Sockets |
| decaf::net::ssl::SSLSocketFactory | Factory class interface for a SocketFactory that can create SSLSocket objects |
| decaf::internal::net::ssl::DefaultSSLSocketFactory | 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 |
| decaf::internal::net::ssl::openssl::OpenSSLSocketFactory | Client Socket Factory that creates SSL based client sockets using the OpenSSL library |
| decaf::net::SocketImplFactory | Factory class interface for a Factory that creates ScoketImpl objects |
| decaf::net::SocketOptions | |
| decaf::net::SocketImpl | Acts as a base class for all physical Socket implementations |
| decaf::internal::net::tcp::TcpSocket | Platform-independent implementation of the socket interface |
| decaf::net::ssl::SSLContext | Represents on implementation of the Secure Socket Layer for streaming based sockets |
| decaf::net::ssl::SSLContextSpi | Defines the interface that should be provided by an SSLContext provider |
| decaf::internal::net::ssl::openssl::OpenSSLContextSpi | Provides an SSLContext that wraps the OpenSSL API |
| decaf::net::ssl::SSLParameters | |
| activemq::commands::BrokerError::StackTraceElement | |
| cms::Startable | Interface for a class that implements the start method |
| cms::Connection | The client's connection to its provider |
| cms::MessageConsumer | A client uses a MessageConsumer to received messages from a destination |
| cms::Session | A Session object is a single-threaded context for producing and consuming messages |
| decaf::lang::STATIC_CAST_TOKEN | |
| activemq::core::ActiveMQConstants::StaticInitializer | |
| activemq::wireformat::stomp::StompCommandConstants | |
| activemq::wireformat::stomp::StompFrame | A Stomp-level message frame that encloses all messages to and from the broker |
| activemq::wireformat::stomp::StompHelper | Utility Methods used when marshaling to and from StompFrame's |
| cms::Stoppable | Interface for a class that implements the stop method |
| cms::Connection | The client's connection to its provider |
| cms::MessageConsumer | A client uses a MessageConsumer to received messages from a destination |
| cms::Session | A Session object is a single-threaded context for producing and consuming messages |
| decaf::util::StringTokenizer | Class that allows for parsing of string based on Tokens |
| decaf::internal::util::StringUtils | |
| decaf::util::concurrent::Synchronizable | The interface for all synchronizable objects (that is, objects that can be locked and unlocked) |
| activemq::core::MessageDispatchChannel | |
| activemq::core::FifoMessageDispatchChannel | |
| activemq::core::SimplePriorityMessageDispatchChannel | |
| decaf::util::Collection< K > | |
| decaf::util::Collection< MapEntry< K, V > > | |
| decaf::util::Collection< PrimitiveValueNode > | |
| decaf::util::Collection< V > | |
| decaf::internal::util::concurrent::SynchronizableImpl | A convenience class used by some Decaf classes to implement the Synchronizable interface when there is no issues related to multiple inheritance |
| decaf::io::InputStream | A base class that must be implemented by all classes wishing to provide a class that reads in a stream of bytes |
| decaf::io::OutputStream | Base interface for any class that wants to represent an output stream of bytes |
| decaf::util::Collection< E > | The root interface in the collection hierarchy |
| decaf::util::concurrent::Mutex | 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 |
| decaf::util::Map< K, V > | An object that maps keys to values |
| decaf::util::AbstractMap< K, V > | This class provides a skeletal implementation of the Map interface, to minimize the effort required to implement this interface |
| decaf::util::HashMap< K, V, HASHCODE > | Hash table based implementation of the Map interface |
| decaf::util::LRUCache< K, V, COMPARATOR > | A Basic Least Recently Used (LRU) Cache Map |
| decaf::util::concurrent::ConcurrentMap< K, V > | Interface for a Map type that provides additional atomic putIfAbsent, remove, and replace methods alongside the already available Map interface |
| decaf::util::concurrent::ConcurrentStlMap< K, V, COMPARATOR > | 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 |
| decaf::util::StlMap< K, V, COMPARATOR > | 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 |
| decaf::util::StlQueue< T > | The Queue class accepts messages with an psuh(m) command where m is the message to be queued |
| decaf::util::Map< std::string, PrimitiveValueNode > | |
| decaf::util::StlMap< std::string, PrimitiveValueNode > | |
| activemq::util::PrimitiveMap | Map of named primitives |
| activemq::core::Synchronization | Transacted Object Synchronization, used to sync the events of a Transaction with the items in the Transaction |
| decaf::lang::System | Static methods for accessing system level resources and performing some system dependent tasks such as looking up environment values and copying memory and arrays |
| activemq::threads::Task | Represents a unit of work that requires one or more iterations to complete |
| activemq::core::ActiveMQSessionExecutor | Delegate dispatcher for a single session |
| activemq::threads::CompositeTask | Represents a single task that can be part of a set of Tasks that are contained in a CompositeTaskRunner |
| activemq::transport::failover::BackupTransportPool | |
| activemq::transport::failover::CloseTransportsTask | |
| activemq::transport::failover::FailoverTransport | |
| activemq::threads::CompositeTaskRunner | 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 |
| activemq::threads::TaskRunner | |
| activemq::threads::CompositeTaskRunner | 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 |
| activemq::threads::DedicatedTaskRunner | |
| decaf::util::concurrent::ThreadFactory | Public interface ThreadFactory |
| decaf::lang::ThreadGroup | |
| decaf::internal::util::concurrent::ThreadHandle | |
| decaf::internal::util::concurrent::Threading | |
| decaf::internal::util::concurrent::ThreadLocalImpl | |
| decaf::lang::ThreadLocal< E > | This class provides thread-local variables |
| decaf::lang::Throwable | This class represents an error that has occurred |
| decaf::lang::Exception | |
| activemq::exceptions::ActiveMQException | |
| activemq::exceptions::BrokerException | |
| activemq::exceptions::ConnectionFailedException | |
| decaf::io::IOException | |
| decaf::io::EOFException | |
| decaf::io::InterruptedIOException | |
| decaf::net::SocketTimeoutException | |
| decaf::io::UnsupportedEncodingException | Thrown when the the Character Encoding is not supported |
| decaf::io::UTFDataFormatException | Thrown from classes that attempt to read or write a UTF-8 encoded string and an encoding error is encountered |
| decaf::net::HttpRetryException | |
| decaf::net::MalformedURLException | |
| decaf::net::ProtocolException | |
| decaf::net::SocketException | Exception for errors when manipulating sockets |
| decaf::internal::net::ssl::openssl::OpenSSLSocketException | Subclass of the standard SocketException that knows how to produce an error message from the OpenSSL error stack |
| decaf::net::BindException | |
| decaf::net::ConnectException | |
| decaf::net::NoRouteToHostException | |
| decaf::net::PortUnreachableException | |
| decaf::net::UnknownHostException | |
| decaf::net::UnknownServiceException | |
| decaf::util::zip::ZipException | |
| decaf::lang::exceptions::ClassCastException | |
| decaf::lang::exceptions::IllegalArgumentException | |
| decaf::lang::exceptions::IllegalMonitorStateException | |
| decaf::lang::exceptions::IllegalStateException | |
| decaf::nio::InvalidMarkException | |
| decaf::lang::exceptions::IllegalThreadStateException | |
| decaf::lang::exceptions::IndexOutOfBoundsException | |
| decaf::lang::exceptions::InterruptedException | |
| decaf::lang::exceptions::InvalidStateException | |
| decaf::lang::exceptions::NullPointerException | |
| decaf::lang::exceptions::NumberFormatException | |
| decaf::lang::exceptions::OutOfMemoryError | |
| decaf::lang::exceptions::RuntimeException | |
| decaf::lang::exceptions::NegativeArraySizeException | |
| decaf::util::ConcurrentModificationException | |
| decaf::util::NoSuchElementException | |
| decaf::lang::exceptions::UnsupportedOperationException | |
| decaf::nio::ReadOnlyBufferException | |
| decaf::net::URISyntaxException | |
| decaf::nio::BufferOverflowException | |
| decaf::nio::BufferUnderflowException | |
| decaf::security::GeneralSecurityException | |
| decaf::security::cert::CertificateException | |
| decaf::security::cert::CertificateEncodingException | |
| decaf::security::cert::CertificateExpiredException | |
| decaf::security::cert::CertificateNotYetValidException | |
| decaf::security::cert::CertificateParsingException | |
| decaf::security::KeyException | |
| decaf::security::InvalidKeyException | |
| decaf::security::KeyManagementException | |
| decaf::security::NoSuchAlgorithmException | |
| decaf::security::NoSuchProviderException | |
| decaf::security::SignatureException | |
| decaf::util::concurrent::BrokenBarrierException | |
| decaf::util::concurrent::CancellationException | |
| decaf::util::concurrent::ExecutionException | |
| decaf::util::concurrent::RejectedExecutionException | |
| decaf::util::concurrent::TimeoutException | |
| decaf::util::zip::DataFormatException | |
| decaf::util::Timer | A facility for threads to schedule tasks for future execution in a background thread |
| decaf::internal::util::TimerTaskHeap | A Binary Heap implemented specifically for the Timer class in Decaf Util |
| activemq::state::TransactionState | |
| decaf::internal::util::concurrent::Transferer< E > | Shared internal API for dual stacks and queues |
| decaf::internal::util::concurrent::TransferQueue< E > | This extends Scherer-Scott dual queue algorithm, differing, among other ways, by using modes within nodes rather than marked pointers |
| decaf::internal::util::concurrent::TransferStack< E > | |
| activemq::transport::TransportFactory | Defines the interface for Factories that create Transports or TransportFilters |
| activemq::transport::AbstractTransportFactory | Abstract implementation of the TransportFactory interface, providing the base functionality that's common to most of the TransportFactory instances |
| activemq::transport::failover::FailoverTransportFactory | Creates an instance of a FailoverTransport |
| activemq::transport::mock::MockTransportFactory | Manufactures MockTransports, which are objects that read from input streams and write to output streams |
| activemq::transport::tcp::TcpTransportFactory | Factory Responsible for creating the TcpTransport |
| activemq::transport::tcp::SslTransportFactory | |
| activemq::transport::TransportListener | A listener of asynchronous exceptions from a command transport object |
| activemq::core::ActiveMQConnection | Concrete connection used for all connectors to the ActiveMQ broker |
| activemq::transport::DefaultTransportListener | A Utility class that create empty implementations for the TransportListener interface so that a subclass only needs to override the one's its interested |
| activemq::transport::failover::BackupTransport | |
| activemq::transport::mock::InternalCommandListener | Listens for Commands sent from the MockTransport |
| activemq::transport::failover::FailoverTransportListener | Utility class used by the Transport to perform the work of responding to events from the active Transport |
| activemq::transport::TransportFilter | A filter on the transport layer |
| activemq::transport::TransportRegistry | Registry of all Transport Factories that are available to the client at runtime |
| tree_desc_s | |
| decaf::lang::Types | |
| decaf::lang::Thread::UncaughtExceptionHandler | Interface for handlers invoked when a Thread abruptly terminates due to an uncaught exception |
| decaf::internal::net::URIEncoderDecoder | |
| decaf::internal::net::URIHelper | Helper class used by the URI classes in encoding and decoding of URI's |
| activemq::transport::failover::URIPool | |
| activemq::util::URISupport | |
| decaf::internal::net::URIType | Basic type object that holds data that composes a given URI |
| decaf::net::URL | Class URL represents a Uniform Resource Locator, a pointer to a "resource" on the World Wide Web |
| decaf::net::URLDecoder | |
| decaf::net::URLEncoder | |
| activemq::util::Usage | |
| activemq::util::MemoryUsage | |
| activemq::wireformat::WireFormat | Provides a mechanism to marshal commands into and out of packets or into and out of streams, Channels and Datagrams |
| activemq::wireformat::openwire::OpenWireFormat | |
| activemq::wireformat::stomp::StompWireFormat | |
| activemq::wireformat::WireFormatFactory | The WireFormatFactory is the interface that all WireFormatFactory classes must extend |
| activemq::wireformat::openwire::OpenWireFormatFactory | |
| activemq::wireformat::stomp::StompWireFormatFactory | Factory used to create the Stomp Wire Format instance |
| activemq::wireformat::WireFormatRegistry | Registry of all WireFormat Factories that are available to the client at runtime |
| cms::XAConnectionFactory | The XAConnectionFactory interface is specialized interface that defines an ConnectionFactory that creates Connection instance that will participate in XA Transactions |
| activemq::core::ActiveMQXAConnectionFactory | |
| cms::XAResource | 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) |
| activemq::core::ActiveMQTransactionContext | Transaction Management class, hold messages that are to be redelivered upon a request to roll-back |
| cms::Xid | An interface which provides a mapping for the X/Open XID transaction identifier structure |
| activemq::commands::XATransactionId | |
| z_stream_s | |
