| 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::AbstractCollection< E > | This class provides a skeletal implementation of the Collection interface, to minimize the effort required to implement this interface |
| decaf::util::concurrent::AbstractExecutorService | Provides a default implementation for the methods of the ExecutorService 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::AbstractMap< K, V, COMPARATOR > | This class provides a skeletal implementation of the Map interface, to minimize the effort required to implement this interface |
| 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::AbstractQueue< E > | This class provides skeletal implementations of some Queue operations |
| 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::AbstractSet< E > | This class provides a skeletal implementation of the Set interface to minimize the effort required to implement this interface |
| activemq::transport::AbstractTransportFactory | Abstract implementation of the TransportFactory interface, providing the base functionality that's common to most of the TransportFactory instances |
| activemq::core::ActiveMQAckHandler | Interface class that is used to give CMS Messages an interface to Ack themselves with |
| activemq::commands::ActiveMQBlobMessage | |
| activemq::wireformat::openwire::marshal::generated::ActiveMQBlobMessageMarshaller | Marshaling code for Open Wire Format for ActiveMQBlobMessageMarshaller |
| activemq::commands::ActiveMQBytesMessage | |
| activemq::wireformat::openwire::marshal::generated::ActiveMQBytesMessageMarshaller | Marshaling code for Open Wire Format for ActiveMQBytesMessageMarshaller |
| activemq::core::ActiveMQConnection | Concrete connection used for all connectors to the ActiveMQ broker |
| activemq::core::ActiveMQConnectionFactory | |
| activemq::core::ActiveMQConnectionMetaData | This class houses all the various settings and information that is used by an instance of an ActiveMQConnection class |
| 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::core::ActiveMQConsumer | |
| activemq::library::ActiveMQCPP | |
| activemq::commands::ActiveMQDestination | |
| activemq::wireformat::openwire::marshal::generated::ActiveMQDestinationMarshaller | Marshaling code for Open Wire Format for ActiveMQDestinationMarshaller |
| activemq::exceptions::ActiveMQException | |
| activemq::commands::ActiveMQMapMessage | |
| activemq::wireformat::openwire::marshal::generated::ActiveMQMapMessageMarshaller | Marshaling code for Open Wire Format for ActiveMQMapMessageMarshaller |
| activemq::commands::ActiveMQMessage | |
| activemq::wireformat::openwire::marshal::generated::ActiveMQMessageMarshaller | Marshaling code for Open Wire Format for ActiveMQMessageMarshaller |
| activemq::commands::ActiveMQMessageTemplate< T > | |
| activemq::commands::ActiveMQObjectMessage | |
| activemq::wireformat::openwire::marshal::generated::ActiveMQObjectMessageMarshaller | Marshaling code for Open Wire Format for ActiveMQObjectMessageMarshaller |
| activemq::core::ActiveMQProducer | |
| activemq::util::ActiveMQProperties | Implementation of the CMSProperties interface that delegates to a decaf::util::Properties object |
| activemq::commands::ActiveMQQueue | |
| activemq::core::ActiveMQQueueBrowser | |
| activemq::wireformat::openwire::marshal::generated::ActiveMQQueueMarshaller | Marshaling code for Open Wire Format for ActiveMQQueueMarshaller |
| activemq::core::ActiveMQSession | |
| activemq::core::ActiveMQSessionExecutor | Delegate dispatcher for a single session |
| activemq::commands::ActiveMQStreamMessage | |
| activemq::wireformat::openwire::marshal::generated::ActiveMQStreamMessageMarshaller | Marshaling code for Open Wire Format for ActiveMQStreamMessageMarshaller |
| activemq::commands::ActiveMQTempDestination | |
| activemq::wireformat::openwire::marshal::generated::ActiveMQTempDestinationMarshaller | Marshaling code for Open Wire Format for ActiveMQTempDestinationMarshaller |
| activemq::commands::ActiveMQTempQueue | |
| activemq::wireformat::openwire::marshal::generated::ActiveMQTempQueueMarshaller | Marshaling code for Open Wire Format for ActiveMQTempQueueMarshaller |
| activemq::commands::ActiveMQTempTopic | |
| activemq::wireformat::openwire::marshal::generated::ActiveMQTempTopicMarshaller | Marshaling code for Open Wire Format for ActiveMQTempTopicMarshaller |
| activemq::commands::ActiveMQTextMessage | |
| activemq::wireformat::openwire::marshal::generated::ActiveMQTextMessageMarshaller | Marshaling code for Open Wire Format for ActiveMQTextMessageMarshaller |
| activemq::commands::ActiveMQTopic | |
| activemq::wireformat::openwire::marshal::generated::ActiveMQTopicMarshaller | Marshaling code for Open Wire Format for ActiveMQTopicMarshaller |
| activemq::core::ActiveMQTransactionContext | Transaction Management class, hold messages that are to be redelivered upon a request to roll-back |
| activemq::core::ActiveMQXAConnection | |
| activemq::core::ActiveMQXAConnectionFactory | |
| activemq::core::ActiveMQXASession | |
| decaf::util::zip::Adler32 | Clas that can be used to compute an Adler-32 Checksum for a data stream |
| decaf::lang::Appendable | An object to which char sequences and values can be appended |
| 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::util::ArrayList< E > | |
| decaf::util::concurrent::CopyOnWriteArrayList< E >::ArrayListIterator | |
| decaf::lang::ArrayPointer< 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 |
| decaf::lang::ArrayPointerComparator< 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 value of the actual pointer to the array being contained in this ArrayPointer |
| decaf::util::Arrays | |
| decaf::util::concurrent::atomic::AtomicBoolean | A boolean value that may be updated atomically |
| decaf::util::concurrent::atomic::AtomicInteger | An int value that may be updated atomically |
| decaf::util::concurrent::atomic::AtomicRefCounter | |
| decaf::util::concurrent::atomic::AtomicReference< T > | An Pointer reference that may be updated atomically |
| activemq::transport::failover::BackupTransport | |
| activemq::transport::failover::BackupTransportPool | |
| activemq::commands::BaseCommand | |
| activemq::wireformat::openwire::marshal::generated::BaseCommandMarshaller | Marshaling code for Open Wire Format for BaseCommandMarshaller |
| activemq::wireformat::openwire::marshal::BaseDataStreamMarshaller | Base class for all Marshallers that marshal DataStructures to and from the wire using the OpenWire protocol |
| activemq::commands::BaseDataStructure | |
| decaf::net::BindException | |
| decaf::io::BlockingByteArrayInputStream | This is a blocking version of a byte buffer stream |
| 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::lang::Boolean | |
| activemq::commands::BooleanExpression | |
| 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::util::concurrent::BrokenBarrierException | |
| activemq::commands::BrokerError | This class represents an Exception sent from the Broker |
| activemq::exceptions::BrokerException | |
| activemq::commands::BrokerId | |
| activemq::wireformat::openwire::marshal::generated::BrokerIdMarshaller | Marshaling code for Open Wire Format for BrokerIdMarshaller |
| activemq::commands::BrokerInfo | |
| activemq::wireformat::openwire::marshal::generated::BrokerInfoMarshaller | Marshaling code for Open Wire Format for BrokerInfoMarshaller |
| decaf::nio::Buffer | A container for data of a specific primitive type |
| 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::BufferedOutputStream | Wrapper around another output stream that buffers output before writing to the target output stream |
| 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::nio::BufferOverflowException | |
| decaf::nio::BufferUnderflowException | |
| decaf::lang::Byte | |
| 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::internal::nio::ByteArrayBuffer | This class defines six categories of operations upon byte buffers: |
| decaf::io::ByteArrayInputStream | A ByteArrayInputStream contains an internal buffer that contains bytes that may be read from the stream |
| decaf::io::ByteArrayOutputStream | |
| decaf::nio::ByteBuffer | This class defines six categories of operations upon byte buffers: |
| cms::BytesMessage | A BytesMessage object is used to send a message containing a stream of unsigned bytes |
| activemq::cmsutil::CachedConsumer | A cached message consumer contained within a pooled session |
| activemq::cmsutil::CachedProducer | A cached message producer contained within a pooled session |
| decaf::util::concurrent::Callable< V > | A task that returns a result and may throw an exception |
| 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::CancellationException | |
| decaf::security::cert::Certificate | Base interface for all identity certificates |
| decaf::security::cert::CertificateEncodingException | |
| decaf::security::cert::CertificateException | |
| decaf::security::cert::CertificateExpiredException | |
| decaf::security::cert::CertificateNotYetValidException | |
| decaf::security::cert::CertificateParsingException | |
| decaf::lang::Character | |
| decaf::internal::nio::CharArrayBuffer | |
| decaf::nio::CharBuffer | This class defines four categories of operations upon character buffers: |
| decaf::lang::CharSequence | A CharSequence is a readable sequence of char values |
| 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::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::Checksum | An interface used to represent Checksum values in the Zip package |
| decaf::lang::exceptions::ClassCastException | |
| cms::Closeable | Interface for a class that implements the close method |
| decaf::io::Closeable | Interface for a class that implements the close method |
| activemq::transport::failover::CloseTransportsTask | |
| 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 |
| cms::CMSException | CMS API Exception that is the base for all exceptions thrown from CMS classes |
| activemq::util::CMSExceptionSupport | |
| cms::CMSProperties | Interface for a Java-like properties object |
| cms::CMSSecurityException | This exception must be thrown when a provider rejects a user name/password submitted by a client |
| activemq::cmsutil::CmsTemplate | CmsTemplate simplifies performing synchronous CMS operations |
| code | |
| decaf::util::Collection< E > | The root interface in the collection hierarchy |
| activemq::commands::Command | |
| 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 |
| decaf::lang::Comparable< T > | This interface imposes a total ordering on the objects of each class that implements it |
| decaf::util::Comparator< T > | A comparison function, which imposes a total ordering on some collection of objects |
| activemq::util::CompositeData | Represents a Composite URI |
| activemq::threads::CompositeTask | Represents a single task that can be part of a set of Tasks that are contained in a CompositeTaskRunner |
| 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::transport::CompositeTransport | A Composite Transport is a Transport implementation that is composed of several Transports |
| decaf::util::concurrent::ConcurrentMap< K, V, COMPARATOR > | Interface for a Map type that provides additional atomic putIfAbsent, remove, and replace methods alongside the already available Map interface |
| decaf::util::ConcurrentModificationException | |
| 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::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::ConditionHandle | |
| decaf::internal::util::concurrent::ConditionImpl | |
| decaf::net::ConnectException | |
| cms::Connection | The client's connection to its provider |
| activemq::commands::ConnectionControl | |
| activemq::wireformat::openwire::marshal::generated::ConnectionControlMarshaller | Marshaling code for Open Wire Format for ConnectionControlMarshaller |
| activemq::commands::ConnectionError | |
| activemq::wireformat::openwire::marshal::generated::ConnectionErrorMarshaller | Marshaling code for Open Wire Format for ConnectionErrorMarshaller |
| 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::exceptions::ConnectionFailedException | |
| activemq::commands::ConnectionId | |
| activemq::wireformat::openwire::marshal::generated::ConnectionIdMarshaller | Marshaling code for Open Wire Format for ConnectionIdMarshaller |
| activemq::commands::ConnectionInfo | |
| activemq::wireformat::openwire::marshal::generated::ConnectionInfoMarshaller | Marshaling code for Open Wire Format for ConnectionInfoMarshaller |
| cms::ConnectionMetaData | A ConnectionMetaData object provides information describing the Connection object |
| activemq::state::ConnectionState | |
| activemq::state::ConnectionStateTracker | |
| decaf::util::logging::ConsoleHandler | This Handler publishes log records to System.err |
| activemq::commands::ConsumerControl | |
| activemq::wireformat::openwire::marshal::generated::ConsumerControlMarshaller | Marshaling code for Open Wire Format for ConsumerControlMarshaller |
| activemq::commands::ConsumerId | |
| activemq::wireformat::openwire::marshal::generated::ConsumerIdMarshaller | Marshaling code for Open Wire Format for ConsumerIdMarshaller |
| activemq::commands::ConsumerInfo | |
| activemq::wireformat::openwire::marshal::generated::ConsumerInfoMarshaller | Marshaling code for Open Wire Format for ConsumerInfoMarshaller |
| activemq::state::ConsumerState | |
| activemq::commands::ControlCommand | |
| activemq::wireformat::openwire::marshal::generated::ControlCommandMarshaller | Marshaling code for Open Wire Format for ControlCommandMarshaller |
| decaf::util::concurrent::CopyOnWriteArrayList< E > | |
| 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::concurrent::CountDownLatch | |
| decaf::util::zip::CRC32 | Class that can be used to compute a CRC-32 checksum for a data stream |
| ct_data_s | |
| activemq::commands::DataArrayResponse | |
| activemq::wireformat::openwire::marshal::generated::DataArrayResponseMarshaller | Marshaling code for Open Wire Format for DataArrayResponseMarshaller |
| decaf::util::zip::DataFormatException | |
| 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::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::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 |
| decaf::io::DataOutputStream | A data output stream lets an application write primitive Java data types to an output stream in a portable way |
| activemq::commands::DataResponse | |
| activemq::wireformat::openwire::marshal::generated::DataResponseMarshaller | Marshaling code for Open Wire Format for DataResponseMarshaller |
| activemq::wireformat::openwire::marshal::DataStreamMarshaller | Base class for all classes that marshal commands for Openwire |
| activemq::commands::DataStructure | |
| decaf::util::Date | Wrapper class around a time value in milliseconds |
| decaf::internal::DecafRuntime | Handles APR initialization and termination |
| activemq::threads::DedicatedTaskRunner | |
| activemq::core::policies::DefaultPrefetchPolicy | |
| activemq::core::policies::DefaultRedeliveryPolicy | |
| decaf::internal::net::DefaultServerSocketFactory | Default implementation of the Decaf ServerSocketFactory, creates ServerSocket objects with supplied options |
| decaf::internal::net::DefaultSocketFactory | SocketFactory implementation that is used to create Sockets |
| decaf::internal::net::ssl::DefaultSSLContext | Default SSLContext manager for the Decaf library |
| 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::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 |
| 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 |
| decaf::util::zip::Deflater | This class compresses data using the DEFLATE algorithm (see specification) |
| decaf::util::zip::DeflaterOutputStream | Provides a FilterOutputStream instance that compresses the data before writing it to the wrapped OutputStream |
| decaf::util::concurrent::Delayed | A mix-in style interface for marking objects that should be acted upon after a given delay |
| cms::DeliveryMode | This is an Abstract class whose purpose is to provide a container for the delivery mode enumeration for CMS messages |
| decaf::util::Deque< E > | Defines a 'Double ended Queue' interface that allows for insertion and removal of elements from both ends |
| cms::Destination | A Destination object encapsulates a provider-specific address |
| activemq::commands::ActiveMQDestination::DestinationFilter | |
| activemq::commands::DestinationInfo | |
| activemq::wireformat::openwire::marshal::generated::DestinationInfoMarshaller | Marshaling code for Open Wire Format for DestinationInfoMarshaller |
| activemq::cmsutil::DestinationResolver | Resolves a CMS destination name to a Destination |
| decaf::util::concurrent::ThreadPoolExecutor::CallerRunsPolicy::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::CallerRunsPolicy::DiscardPolicy | Handler policy for tasks that are rejected upon a call to ThreadPoolExecutor::execute this class always destroys the rejected task and returns quietly |
| activemq::commands::DiscoveryEvent | |
| activemq::wireformat::openwire::marshal::generated::DiscoveryEventMarshaller | Marshaling code for Open Wire Format for DiscoveryEventMarshaller |
| 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 |
| decaf::lang::Double | |
| decaf::internal::nio::DoubleArrayBuffer | |
| decaf::nio::DoubleBuffer | This class defines four categories of operations upon double buffers: |
| decaf::lang::DYNAMIC_CAST_TOKEN | |
| activemq::cmsutil::DynamicDestinationResolver | Resolves a CMS destination name to a Destination |
| decaf::util::Map< K, V, COMPARATOR >::Entry | |
| decaf::io::EOFException | |
| decaf::util::logging::ErrorManager | ErrorManager objects can be attached to Handlers to process any error that occur on a Handler during Logging |
| decaf::lang::Exception | |
| cms::ExceptionListener | If a CMS provider detects a serious problem, it notifies the client application through an ExceptionListener that is registered with the Connection |
| activemq::commands::ExceptionResponse | |
| activemq::wireformat::openwire::marshal::generated::ExceptionResponseMarshaller | Marshaling code for Open Wire Format for ExceptionResponseMarshaller |
| decaf::util::concurrent::ExecutionException | |
| decaf::util::concurrent::Executor | An object that executes submitted decaf.lang.Runnable 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::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 |
| activemq::transport::failover::FailoverTransport | |
| activemq::transport::failover::FailoverTransportFactory | Creates an instance of a FailoverTransport |
| activemq::transport::failover::FailoverTransportListener | Utility class used by the Transport to perform the work of responding to events from the active Transport |
| activemq::core::FifoMessageDispatchChannel | |
| 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::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::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 |
| decaf::io::FilterOutputStream | This class is the superclass of all classes that filter output streams |
| decaf::lang::Float | |
| decaf::internal::nio::FloatArrayBuffer | |
| decaf::nio::FloatBuffer | This class defines four categories of operations upon float buffers: |
| decaf::io::Flushable | A Flushable is a destination of data that can be flushed |
| activemq::commands::FlushCommand | |
| activemq::wireformat::openwire::marshal::generated::FlushCommandMarshaller | Marshaling code for Open Wire Format for FlushCommandMarshaller |
| decaf::util::logging::Formatter | A Formatter provides support for formatting LogRecords |
| decaf::util::concurrent::Future< V > | A Future represents the result of an asynchronous computation |
| activemq::transport::correlator::FutureResponse | A container that holds a response object |
| decaf::security::GeneralSecurityException | |
| decaf::internal::util::GenericResource< T > | A Generic Resource wraps some type and will delete it when the Resource itself is deleted |
| gz_header_s | |
| gz_state | |
| decaf::util::logging::Handler | A Handler object takes log messages from a Logger and exports them |
| decaf::internal::util::HexStringParser | |
| activemq::wireformat::openwire::utils::HexTable | Maps hexidecimal strings to the value of an index into the table, i.e |
| decaf::net::HttpRetryException | |
| activemq::util::IdGenerator | |
| decaf::lang::exceptions::IllegalArgumentException | |
| decaf::lang::exceptions::IllegalMonitorStateException | |
| 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 |
| decaf::lang::exceptions::IllegalStateException | |
| decaf::lang::exceptions::IllegalThreadStateException | |
| activemq::transport::inactivity::InactivityMonitor | |
| decaf::lang::exceptions::IndexOutOfBoundsException | |
| decaf::net::Inet4Address | |
| decaf::net::Inet6Address | |
| decaf::net::InetAddress | Represents an IP address |
| decaf::net::InetSocketAddress | |
| inflate_state | |
| decaf::util::zip::Inflater | This class uncompresses data that was compressed using the DEFLATE algorithm (see specification) |
| decaf::util::zip::InflaterInputStream | A FilterInputStream that decompresses data read from the wrapped InputStream instance |
| 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::InputStreamReader | An InputStreamReader is a bridge from byte streams to character streams |
| decaf::internal::nio::IntArrayBuffer | |
| decaf::nio::IntBuffer | This class defines four categories of operations upon int buffers: |
| decaf::lang::Integer | |
| activemq::commands::IntegerResponse | |
| activemq::wireformat::openwire::marshal::generated::IntegerResponseMarshaller | Marshaling code for Open Wire Format for IntegerResponseMarshaller |
| internal_state | |
| activemq::transport::mock::InternalCommandListener | Listens for Commands sent from the MockTransport |
| decaf::lang::exceptions::InterruptedException | |
| decaf::io::InterruptedIOException | |
| 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 |
| decaf::security::InvalidKeyException | |
| decaf::nio::InvalidMarkException | |
| cms::InvalidSelectorException | This exception must be thrown when a CMS client attempts to give a provider a message selector with invalid syntax |
| decaf::lang::exceptions::InvalidStateException | |
| decaf::io::IOException | |
| activemq::transport::IOTransport | Implementation of the Transport interface that performs marshaling of commands to IO streams |
| decaf::lang::Iterable< E > | Implementing this interface allows an object to be cast to an Iterable type for generic collections API calls |
| decaf::util::Iterator< E > | Defines an object that can be used to iterate over the elements of a collection |
| activemq::commands::JournalQueueAck | |
| activemq::wireformat::openwire::marshal::generated::JournalQueueAckMarshaller | Marshaling code for Open Wire Format for JournalQueueAckMarshaller |
| activemq::commands::JournalTopicAck | |
| activemq::wireformat::openwire::marshal::generated::JournalTopicAckMarshaller | Marshaling code for Open Wire Format for JournalTopicAckMarshaller |
| activemq::commands::JournalTrace | |
| activemq::wireformat::openwire::marshal::generated::JournalTraceMarshaller | Marshaling code for Open Wire Format for JournalTraceMarshaller |
| activemq::commands::JournalTransaction | |
| activemq::wireformat::openwire::marshal::generated::JournalTransactionMarshaller | Marshaling code for Open Wire Format for JournalTransactionMarshaller |
| activemq::commands::KeepAliveInfo | |
| activemq::wireformat::openwire::marshal::generated::KeepAliveInfoMarshaller | Marshaling code for Open Wire Format for KeepAliveInfoMarshaller |
| decaf::security::Key | The Key interface is the top-level interface for all keys |
| decaf::security::KeyException | |
| decaf::security::KeyManagementException | |
| activemq::commands::LastPartialCommand | |
| activemq::wireformat::openwire::marshal::generated::LastPartialCommandMarshaller | Marshaling code for Open Wire Format for LastPartialCommandMarshaller |
| decaf::util::comparators::Less< E > | Simple Less Comparator that compares to elements to determine if the first is less than the second |
| 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::logging::Level | Defines a set of standard logging levels that can be used to control logging output |
| 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::LinkedList< E > | A complete implementation of the List interface using a doubly linked list data structure |
| decaf::util::List< E > | An ordered collection (also known as a sequence) |
| 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 |
| activemq::commands::LocalTransactionId | |
| activemq::wireformat::openwire::marshal::generated::LocalTransactionIdMarshaller | Marshaling code for Open Wire Format for LocalTransactionIdMarshaller |
| 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::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 | |
| activemq::io::LoggingInputStream | |
| activemq::io::LoggingOutputStream | OutputStream filter that just logs the data being written |
| activemq::transport::logging::LoggingTransport | A transport filter that logs commands as they are sent/received |
| 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 | |
| decaf::lang::Long | |
| decaf::internal::nio::LongArrayBuffer | |
| decaf::nio::LongBuffer | This class defines four categories of operations upon long long buffers: |
| 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::net::MalformedURLException | |
| decaf::util::Map< 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 |
| cms::MapMessage | A MapMessage object is used to send a set of name-value pairs |
| decaf::util::logging::MarkBlockLogger | Defines a class that can be used to mark the entry and exit from scoped blocks |
| activemq::wireformat::MarshalAware | |
| 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 |
| activemq::util::MemoryUsage | |
| activemq::commands::Message | |
| cms::Message | Root of all messages |
| activemq::commands::MessageAck | |
| activemq::wireformat::openwire::marshal::generated::MessageAckMarshaller | Marshaling code for Open Wire Format for MessageAckMarshaller |
| cms::MessageConsumer | A client uses a MessageConsumer to received messages from a destination |
| activemq::cmsutil::MessageCreator | Creates the user-defined message to be sent by the CmsTemplate |
| activemq::commands::MessageDispatch | |
| activemq::core::MessageDispatchChannel | |
| activemq::wireformat::openwire::marshal::generated::MessageDispatchMarshaller | Marshaling code for Open Wire Format for MessageDispatchMarshaller |
| activemq::commands::MessageDispatchNotification | |
| activemq::wireformat::openwire::marshal::generated::MessageDispatchNotificationMarshaller | Marshaling code for Open Wire Format for MessageDispatchNotificationMarshaller |
| cms::MessageEnumeration | Defines an object that enumerates a collection of Messages |
| 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 |
| activemq::commands::MessageId | |
| activemq::wireformat::openwire::marshal::generated::MessageIdMarshaller | Marshaling code for Open Wire Format for MessageIdMarshaller |
| cms::MessageListener | A MessageListener object is used to receive asynchronously delivered messages |
| activemq::wireformat::openwire::marshal::generated::MessageMarshaller | Marshaling code for Open Wire Format for MessageMarshaller |
| 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::MessageProducer | A client uses a MessageProducer object to send messages to a Destination |
| 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 |
| activemq::commands::MessagePull | |
| activemq::wireformat::openwire::marshal::generated::MessagePullMarshaller | Marshaling code for Open Wire Format for MessagePullMarshaller |
| 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::mock::MockTransportFactory | Manufactures MockTransports, which are objects that read from input streams and write to output streams |
| 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::concurrent::MutexHandle | |
| decaf::internal::util::concurrent::MutexImpl | |
| decaf::internal::net::Network | Internal class used to manage Networking related resources and hide platform dependent calls from the higher level API |
| activemq::commands::NetworkBridgeFilter | |
| activemq::wireformat::openwire::marshal::generated::NetworkBridgeFilterMarshaller | Marshaling code for Open Wire Format for NetworkBridgeFilterMarshaller |
| decaf::net::NoRouteToHostException | |
| decaf::security::NoSuchAlgorithmException | |
| decaf::util::NoSuchElementException | |
| decaf::security::NoSuchProviderException | |
| decaf::lang::exceptions::NullPointerException | |
| decaf::lang::Number | The abstract class Number is the superclass of classes Byte, Double, Float, Integer, Long, and Short |
| decaf::lang::exceptions::NumberFormatException | |
| cms::ObjectMessage | Place holder for interaction with JMS systems that support Java, the C++ client is not responsible for deserializing the contained Object |
| decaf::internal::net::ssl::openssl::OpenSSLContextSpi | Provides an SSLContext that wraps the OpenSSL API |
| decaf::internal::net::ssl::openssl::OpenSSLParameters | Container class for parameters that are Common to OpenSSL socket classes |
| decaf::internal::net::ssl::openssl::OpenSSLServerSocket | SSLServerSocket based on OpenSSL library code |
| decaf::internal::net::ssl::openssl::OpenSSLServerSocketFactory | SSLServerSocketFactory that creates Server Sockets that use OpenSSL |
| 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::internal::net::ssl::openssl::OpenSSLSocketException | Subclass of the standard SocketException that knows how to produce an error message from the OpenSSL error stack |
| decaf::internal::net::ssl::openssl::OpenSSLSocketFactory | Client Socket Factory that creates SSL based client sockets using the OpenSSL library |
| decaf::internal::net::ssl::openssl::OpenSSLSocketInputStream | An output stream for reading data from an OpenSSL Socket instance |
| decaf::internal::net::ssl::openssl::OpenSSLSocketOutputStream | OutputStream implementation used to write data to an OpenSSLSocket instance |
| activemq::wireformat::openwire::OpenWireFormat | |
| activemq::wireformat::openwire::OpenWireFormatFactory | |
| activemq::wireformat::openwire::OpenWireFormatNegotiator | |
| activemq::wireformat::openwire::OpenWireResponseBuilder | Used to allow a MockTransport to generate response commands to OpenWire Commands |
| decaf::io::OutputStream | Base interface for any class that wants to represent an output stream of bytes |
| decaf::io::OutputStreamWriter | A class for turning a character stream into a byte stream |
| activemq::commands::PartialCommand | |
| activemq::wireformat::openwire::marshal::generated::PartialCommandMarshaller | Marshaling code for Open Wire Format for PartialCommandMarshaller |
| 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 |
| 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 |
| activemq::cmsutil::PooledSession | A pooled session object that wraps around a delegate session |
| decaf::net::PortUnreachableException | |
| activemq::core::PrefetchPolicy | Interface for a Policy object that controls message Prefetching on various destination types in ActiveMQ-CPP |
| activemq::util::PrimitiveList | List of primitives |
| activemq::util::PrimitiveMap | Map of named primitives |
| 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::util::PriorityQueue< E > | An unbounded priority queue based on a binary heap algorithm |
| activemq::commands::ProducerAck | |
| activemq::wireformat::openwire::marshal::generated::ProducerAckMarshaller | Marshaling code for Open Wire Format for ProducerAckMarshaller |
| activemq::cmsutil::ProducerCallback | Callback for sending a message to a CMS destination |
| activemq::cmsutil::CmsTemplate::ProducerExecutor | |
| activemq::commands::ProducerId | |
| activemq::wireformat::openwire::marshal::generated::ProducerIdMarshaller | Marshaling code for Open Wire Format for ProducerIdMarshaller |
| activemq::commands::ProducerInfo | |
| activemq::wireformat::openwire::marshal::generated::ProducerInfoMarshaller | Marshaling code for Open Wire Format for ProducerInfoMarshaller |
| 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::net::ProtocolException | |
| decaf::security::PublicKey | A public key |
| decaf::io::PushbackInputStream | A PushbackInputStream adds functionality to another input stream, namely the ability to "push back" or "unread" one byte |
| cms::Queue | An interface encapsulating a provider-specific queue name |
| decaf::util::Queue< E > | A kind of collection provides advanced operations than other basic collections, such as insertion, extraction, and inspection |
| cms::QueueBrowser | This class implements in interface for browsing the messages in a Queue without removing them |
| decaf::util::Random | Random Value Generator which is used to generate a stream of pseudorandom numbers |
| decaf::lang::Readable | A Readable is a source of characters |
| activemq::transport::inactivity::ReadChecker | Runnable class that is used by the { |
| decaf::io::Reader | |
| decaf::nio::ReadOnlyBufferException | |
| decaf::util::concurrent::locks::ReadWriteLock | A ReadWriteLock maintains a pair of associated locks, one for read-only operations and one for writing |
| activemq::cmsutil::CmsTemplate::ReceiveExecutor | |
| activemq::core::RedeliveryPolicy | Interface for a RedeliveryPolicy object that controls how message Redelivery is handled in ActiveMQ-CPP when a transaction is rolled back |
| decaf::util::concurrent::locks::ReentrantLock | A reentrant mutual exclusion Lock with extended capabilities |
| decaf::util::concurrent::RejectedExecutionException | |
| decaf::util::concurrent::RejectedExecutionHandler | A handler for tasks that cannot be executed by a ThreadPoolExecutor |
| activemq::commands::RemoveInfo | |
| activemq::wireformat::openwire::marshal::generated::RemoveInfoMarshaller | Marshaling code for Open Wire Format for RemoveInfoMarshaller |
| activemq::commands::RemoveSubscriptionInfo | |
| activemq::wireformat::openwire::marshal::generated::RemoveSubscriptionInfoMarshaller | Marshaling code for Open Wire Format for RemoveSubscriptionInfoMarshaller |
| activemq::commands::ReplayCommand | |
| activemq::wireformat::openwire::marshal::generated::ReplayCommandMarshaller | Marshaling code for Open Wire Format for ReplayCommandMarshaller |
| activemq::cmsutil::CmsTemplate::ResolveProducerExecutor | |
| activemq::cmsutil::CmsTemplate::ResolveReceiveExecutor | |
| decaf::internal::util::Resource | Interface for all Managed Resources in Decaf, these objects are added to the Runtime System and are destroyed at shutdown |
| activemq::cmsutil::ResourceLifecycleManager | Manages the lifecycle of a set of CMS resources |
| decaf::internal::util::ResourceLifecycleManager | |
| activemq::commands::Response | |
| 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::transport::correlator::ResponseCorrelator | This type of transport filter is responsible for correlating asynchronous responses with requests |
| activemq::wireformat::openwire::marshal::generated::ResponseMarshaller | Marshaling code for Open Wire Format for ResponseMarshaller |
| decaf::lang::Runnable | Interface for a runnable object - defines a task that can be run by a thread |
| decaf::lang::Runtime | |
| decaf::lang::exceptions::RuntimeException | |
| activemq::threads::Scheduler | Scheduler class for use in executing Runnable Tasks either periodically or one time only with optional delay |
| activemq::threads::SchedulerTimerTask | Extension of the Decaf TimerTask that adds a Runnable instance which is the target of this task |
| decaf::security::SecureRandom | |
| 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::security::SecureRandomSpi | Interface class used by Security Service Providers to implement a source of secure random bytes |
| decaf::util::concurrent::Semaphore | A counting semaphore |
| activemq::cmsutil::CmsTemplate::SendExecutor | |
| decaf::net::ServerSocket | This class implements server sockets |
| decaf::net::ServerSocketFactory | Class used to create Server Sockets, subclasses can be created that create certain types of server sockets according to specific policies |
| activemq::util::Service | Base interface for all classes that run as a Service inside the application |
| activemq::util::ServiceListener | Listener interface for observers of Service related events |
| activemq::util::ServiceStopper | |
| activemq::util::ServiceSupport | Provides a base class for Service implementations |
| cms::Session | A Session object is a single-threaded context for producing and consuming messages |
| activemq::cmsutil::SessionCallback | Callback for executing any number of operations on a provided CMS Session |
| activemq::commands::SessionId | |
| activemq::wireformat::openwire::marshal::generated::SessionIdMarshaller | Marshaling code for Open Wire Format for SessionIdMarshaller |
| activemq::commands::SessionInfo | |
| activemq::wireformat::openwire::marshal::generated::SessionInfoMarshaller | Marshaling code for Open Wire Format for SessionInfoMarshaller |
| activemq::cmsutil::SessionPool | A pool of CMS sessions from the same connection and with the same acknowledge mode |
| activemq::state::SessionState | |
| decaf::util::Set< E > | A collection that contains no duplicate elements |
| decaf::lang::Short | |
| decaf::internal::nio::ShortArrayBuffer | |
| decaf::nio::ShortBuffer | This class defines four categories of operations upon short buffers: |
| activemq::commands::ShutdownInfo | |
| activemq::wireformat::openwire::marshal::generated::ShutdownInfoMarshaller | Marshaling code for Open Wire Format for ShutdownInfoMarshaller |
| decaf::security::SignatureException | |
| decaf::util::logging::SimpleFormatter | Print a brief summary of the LogRecord in a human readable format |
| decaf::util::logging::SimpleLogger | |
| activemq::core::SimplePriorityMessageDispatchChannel | |
| decaf::net::Socket | |
| decaf::net::SocketAddress | Base class for protocol specific Socket addresses |
| decaf::net::SocketError | Static utility class to simplify handling of error codes for socket operations |
| decaf::net::SocketException | Exception for errors when manipulating sockets |
| 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::SocketFileDescriptor | File Descriptor type used internally by Decaf Socket objects |
| decaf::net::SocketImpl | Acts as a base class for all physical Socket implementations |
| decaf::net::SocketImplFactory | Factory class interface for a Factory that creates ScoketImpl objects |
| decaf::net::SocketOptions | |
| decaf::net::SocketTimeoutException | |
| 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::net::ssl::SSLParameters | |
| 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::net::ssl::SSLServerSocketFactory | Factory class interface that provides methods to create SSL Server Sockets |
| decaf::net::ssl::SSLSocket | |
| decaf::net::ssl::SSLSocketFactory | Factory class interface for a SocketFactory that can create SSLSocket objects |
| activemq::transport::tcp::SslTransport | Transport for connecting to a Broker using an SSL Socket |
| activemq::transport::tcp::SslTransportFactory | |
| activemq::commands::BrokerError::StackTraceElement | |
| decaf::internal::io::StandardErrorOutputStream | Wrapper Around the Standard error Output facility on the current platform |
| decaf::internal::io::StandardInputStream | |
| decaf::internal::io::StandardOutputStream | |
| cms::Startable | Interface for a class that implements the start method |
| decaf::lang::STATIC_CAST_TOKEN | |
| activemq::core::ActiveMQConstants::StaticInitializer | |
| 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::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::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 |
| 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 |
| activemq::wireformat::stomp::StompWireFormat | |
| activemq::wireformat::stomp::StompWireFormatFactory | Factory used to create the Stomp Wire Format instance |
| cms::Stoppable | Interface for a class that implements the stop method |
| decaf::util::logging::StreamHandler | Stream based logging Handler |
| cms::StreamMessage | Interface for a StreamMessage |
| decaf::lang::String | Immutable sequence of chars |
| decaf::util::StringTokenizer | Class that allows for parsing of string based on Tokens |
| activemq::commands::SubscriptionInfo | |
| activemq::wireformat::openwire::marshal::generated::SubscriptionInfoMarshaller | Marshaling code for Open Wire Format for SubscriptionInfoMarshaller |
| decaf::util::concurrent::Synchronizable | The interface for all synchronizable objects (that is, objects that can be locked and unlocked) |
| 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 |
| activemq::core::Synchronization | Transacted Object Synchronization, used to sync the events of a Transaction with the items in the Transaction |
| 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::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::threads::TaskRunner | |
| decaf::internal::net::tcp::TcpSocket | Platform-independent implementation of the socket interface |
| decaf::internal::net::tcp::TcpSocketInputStream | Input stream for performing reads on a socket |
| decaf::internal::net::tcp::TcpSocketOutputStream | Output stream for performing write operations on a socket |
| 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::TcpTransportFactory | Factory Responsible for creating the TcpTransport |
| cms::TemporaryQueue | Defines a Temporary Queue based Destination |
| cms::TemporaryTopic | Defines a Temporary Topic based Destination |
| cms::TextMessage | Interface for a text message |
| decaf::lang::Thread | A Thread is a concurrent unit of execution |
| decaf::util::concurrent::ThreadFactory | Public interface ThreadFactory |
| decaf::lang::ThreadGroup | |
| decaf::util::concurrent::ThreadPoolExecutor | Defines a Thread Pool object that implements the functionality of pooling threads to perform user tasks |
| decaf::lang::Throwable | This class represents an error that has occurred |
| decaf::util::concurrent::TimeoutException | |
| decaf::util::Timer | A facility for threads to schedule tasks for future execution in a background thread |
| decaf::util::TimerTask | A Base class for a task object that can be scheduled for one-time or repeated execution by a Timer |
| decaf::internal::util::TimerTaskHeap | A Binary Heap implemented specifically for the Timer class in Decaf Util |
| 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 |
| cms::Topic | An interface encapsulating a provider-specific topic name |
| activemq::state::Tracked | |
| activemq::commands::TransactionId | |
| activemq::wireformat::openwire::marshal::generated::TransactionIdMarshaller | Marshaling code for Open Wire Format for TransactionIdMarshaller |
| activemq::commands::TransactionInfo | |
| activemq::wireformat::openwire::marshal::generated::TransactionInfoMarshaller | Marshaling code for Open Wire Format for TransactionInfoMarshaller |
| 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 |
| 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::Transport | Interface for a transport layer for command objects |
| activemq::transport::TransportFactory | Defines the interface for Factories that create Transports or TransportFilters |
| activemq::transport::TransportFilter | A filter on the transport layer |
| activemq::transport::TransportListener | A listener of asynchronous exceptions from a command transport object |
| activemq::transport::TransportRegistry | Registry of all Transport Factories that are available to the client at runtime |
| tree_desc_s | |
| decaf::lang::Thread::UncaughtExceptionHandler | Interface for handlers invoked when a Thread abruptly terminates due to an uncaught exception |
| decaf::net::UnknownHostException | |
| decaf::net::UnknownServiceException | |
| decaf::io::UnsupportedEncodingException | Thrown when the the Character Encoding is not supported |
| decaf::lang::exceptions::UnsupportedOperationException | |
| 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 |
| decaf::net::URI | This class represents an instance of a URI as defined by RFC 2396 |
| 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::net::URISyntaxException | |
| 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 | |
| decaf::io::UTFDataFormatException | Thrown from classes that attempt to read or write a UTF-8 encoded string and an encoding error is encountered |
| decaf::util::UUID | A class that represents an immutable universally unique identifier (UUID) |
| 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::WireFormatFactory | The WireFormatFactory is the interface that all WireFormatFactory classes must extend |
| activemq::commands::WireFormatInfo | |
| activemq::wireformat::openwire::marshal::generated::WireFormatInfoMarshaller | Marshaling code for Open Wire Format for WireFormatInfoMarshaller |
| activemq::wireformat::WireFormatNegotiator | Defines a WireFormatNegotiator which allows a WireFormat to |
| activemq::wireformat::WireFormatRegistry | Registry of all WireFormat Factories that are available to the client at runtime |
| activemq::transport::inactivity::WriteChecker | Runnable class used by the { |
| decaf::io::Writer | |
| decaf::security::auth::x500::X500Principal | |
| decaf::security::cert::X509Certificate | Base interface for all identity certificates |
| cms::XAConnection | The XAConnection interface defines an extended Connection type that is used to create XASession objects |
| cms::XAConnectionFactory | The XAConnectionFactory interface is specialized interface that defines an ConnectionFactory that creates Connection instance that will participate in XA Transactions |
| cms::XAException | The XAException is thrown by the Resource Manager (RM) to inform the Transaction Manager of an error encountered by the involved transaction |
| 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) |
| 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::commands::XATransactionId | |
| activemq::wireformat::openwire::marshal::generated::XATransactionIdMarshaller | Marshaling code for Open Wire Format for XATransactionIdMarshaller |
| cms::Xid | An interface which provides a mapping for the X/Open XID transaction identifier structure |
| decaf::util::logging::XMLFormatter | Format a LogRecord into a standard XML format |
| z_stream_s | |
| decaf::util::zip::ZipException | |
1.7.3