| abstract_spec | Helper for defining an abstract managed class |
| AbstractAggregator | Abstract base class implementation of coherence::util::InvocableMap::EntryAggregator that supports parallel aggregation |
| AbstractAnnotation | AbstractAnnotation provides a common base class for Annotations |
| AbstractBundler | An abstract base for processors that implement bundling strategy |
| AbstractBundler::Bundle | Bundle represents a unit of optimized execution |
| AbstractBundler::Statistics | Statistics class contains the latest bundler statistics |
| AbstractCacheLoader | An abstract base class for CacheLoader implementations |
| AbstractCacheStore | An abstract base class for CacheStore implementations |
| AbstractClusterProcessor | Base class for entry processors that may only be executed within the cluster |
| AbstractCollection | This class provides a skeletal implementation of the Collection interface, to minimize the effort required to implement this interface |
| AbstractComparableAggregator | Abstract aggregator that processes values extracted from a set of entries in a Map, with knowledge of how to compare those values |
| AbstractCompositeExtractor | Abstract super class for ValueExtractor implementations that are based on an underlying array of ValueExtractor objects |
| AbstractConcurrentQueue | The ConcurrentQueue provides a means to efficiently (and in a thread-safe manner) queue elements with minimal contention |
| AbstractEntryBundler | An abstract entry-based bundler serves as a base for NamedCache::put() operation bundling |
| AbstractEvolvable | Abstract base implementation of the Evolvable interface |
| AbstractExtractor | Abstract base for ValueExtractor implementations |
| AbstractFloat64Aggregator | Abstract aggregator that processes numeric values extracted from a set of entries in a Map |
| AbstractHeapAnalyzer | AbstractHeapAnalyzer provides a starting point for writing custom heap analyzers |
| AbstractInteger64Aggregator | Abstract aggregator that processes numeric values extracted from a set of entries in a Map |
| AbstractInvocable | An abstract base for Invocable and PriorityTask implementations |
| AbstractKeyBundler | An abstract key-based bundler serves as a base for NamedCache get() and remove() operation bundling |
| AbstractKeyBundler::Bundle | Bundle represents a unit of optimized execution |
| AbstractList | This class provides a skeletal implementation of the List interface to minimize the effort required to implement this interface |
| AbstractLongArray | Abstract base class for LongArray implementations |
| AbstractMap | This class provides a skeletal implementation of the Map interface, to minimize the effort required to implement this interface |
| AbstractMapListener | A base class that simplifies the implementation of a MapListener, particularly inner classes that only implement one or two of the three event methods |
| AbstractOctetArrayReadBuffer | The AbstractOctetArrayReadBuffer abstract class is intended to serve as a base class for the following: |
| AbstractOctetArrayReadBuffer::OctetArrayBufferInput | This is an implementation of the BufferInput interface on top of an octet array |
| AbstractPofPath | Abstract base class for static, path-based implementations of the PofNavigator interface |
| AbstractPriorityTask | An abstract base for AbstractPriorityTask implementations |
| AbstractProcessor | An AbstractProcessor is a partial EntryProcessor implementation that provides default implementations of the process and processAll methods |
| AbstractReadBuffer | Abstract base implementation of the ReadBuffer interface |
| AbstractReadBuffer::AbstractBufferInput | This is an implementation of the BufferInput interface that delegates its work back to its ReadBuffer |
| AbstractSet | This class provides a skeletal implementation of the Set interface to minimize the effort required to implement this interface |
| AbstractSparseArray | A data structure resembling an array indexed by long values, stored as an AVL tree |
| AbstractSparseArray::Node | An AVL tree node |
| AbstractStableIterator | An abstract Iterator implementation that is stable between the hasNext() and next() methods |
| AbstractTypedClass | AbstractTypedClass provides an abstract templated implementation of Class |
| AbstractUpdater | Abstract base for ValueUpdater implementations |
| AbstractWriteBuffer | The AbstractWriteBuffer is a partial implementation of the WriteBuffer interface intended to be used as a base class for easily creating concrete WriteBuffer implementations |
| AbstractWriteBuffer::AbstractBufferOutput | AbstractBufferOutput is a concrete implementation of BufferOutput for the non-concrete AbstractWriteBuffer implementation |
| adapter_map | Adapter_map provides an STL-like "pair associative container" wrapper around coherence::util::Map implementations |
| adapter_map::hasher | Hasher function |
| adapter_map::key_equal | Key equality relation |
| AddressProvider | The AddressProvider is an interface that serves as a means to provide addresses to a consumer |
| AddressProviderFactory | A factory for AddressProvider objects |
| AllFilter | Filter which returns the logical "and" of a filter array |
| AlwaysFilter | Filter which always evaluates to true |
| AndFilter | Filter which returns the logical "and" of two other filters |
| AnnotatedElement | AnnotatedElement represents an annotated element |
| Annotation | Annotation is the common interface extended by all annotation types |
| AnyFilter | Filter which returns the logical "or" of a filter array |
| ArithmeticException | An exception that indicates exceptional condition related to arithmetic operations |
| Array | A fixed size collection of values, indexed by integer position |
| Array::MemberArray | The underlying Array of values |
| ArrayFilter | Filter which is a logical operator of a filter array |
| ArrayFilter::WeightedFilter | A thin wrapper around a Filter allowing for sorting the filters according to their effectiveness |
| Arrays | This class contains various methods for manipulating arrays (such as sorting and searching) |
| AtomicCounter | AtomicCounter allows for atomic updates to a "int64_t" value where possible without requiring synchronization |
| BetweenFilter | Filter which compares the result of a method invocation with a value for "Between" condition |
| Binary | A thread-safe immutable binary object |
| BinaryWriteBuffer | A WriteBuffer implementation whose primary purpose is to be used to create Binary objects |
| Boolean | An immutable boolean value |
| BoxExtractor | Template based auto-boxing ValueExtractor implementation |
| BoxHandle | A TypedHandle implementation which supports auto-boxing |
| boxing_map | Boxing_map provides an STL-like map adapter around a coherence::util::map, and additionally auto-boxes the keys and values to their corresponding non-managed types |
| BoxUpdater | Template based auto-boxing ValueUpdater implementation |
| BundlingNamedCache | Bundling NamedCache implementation |
| CacheEvent | An extension of the MapEvent which allows to differentiate between client driven (natural) events and cache internal (synthetic) events |
| CacheEventFilter | An extension of the MapEventFilter which allows selection of client driven (natural) events, cache internal (synthetic) events, or both |
| CacheFactory | Factory for the Oracle Coherence for C++ cache product |
| CacheLoader | A cache loader |
| CacheMap | A CacheMap is a coherence::util::Map that supports caching |
| CacheService | A CacheService is a clustered service providing a collection of named Maps that hold resources shared among members of a cluster |
| CacheStatistics | An interface for exposing Cache statistics |
| CacheStore | A cache store |
| CachingMap | Map implementation that wraps two maps - a front map (assumed to be "inexpensive" and probably "incomplete") and a back map (assumed to be "complete" and "correct", but more "expensive") - using a read-through/write-through approach |
| CachingMap::DeactivationListener | DeactivationListener for the back NamedCache |
| CachingMap::FrontMapListener | MapListener for back map responsible for keeping the front map coherent with the back map |
| CachingMap::PrimingListener | MapListener for back map responsible for keeping the front map coherent with the back map |
| CachingMap::SimpleListener | MapListener for back map responsible for keeping the front map coherent with the back map |
| ChainedComparator | Composite comparator implementation based on a collection of comparators |
| ChainedExtractor | Composite ValueExtractor implementation based on an array of extractors |
| Character16 | An immutable 16-bit Unicode character value |
| CircularArrayList | Resizable-array implementation of the List interface |
| CircularArrayList::SubCircularArrayList | Utility class to implement a SubList of a CircularArrayList |
| Class | A Class represents a managed object implementation |
| class_spec | Helper for defining a non-cloneable concrete managed class |
| ClassBasedHeapAnalyzer | ClassBasedHeapAnalyzer provides heap analysis at the class level, that is it tracks the number of live instances of each class |
| ClassBasedHeapAnalyzer::ClassStats | Statistics relating to a class |
| ClassBasedHeapAnalyzer::Snapshot | Snapshot containing the object count |
| ClassCastException | Thrown when an attempt is made to cast to an incompatible type |
| ClassLoader | ClassLoader provides a mechanism for obtaining a Class object |
| ClassNotFoundException | Thrown when a definition for a named Class could be found |
| cloneable_spec | Helper for defining a cloneable managed class |
| CloneNotSupportedException | Thrown when an attempt is made to clone an object which does not support cloning |
| Codec | A Codec provides an interception point for any specific code that needs to be executed pre or post (de)serialization |
| Codecs | Codecs is a container for accessing default Codec implementations |
| Codecs::AbstractCodec | Abstract Codec implementations that encodes objects by simply delegating to PofWriter::writeObject |
| Codecs::DefaultCodec | Implementation of Codec that simply delegates to PofReader::readObject and PofWriter::writeObject to deserialize and serialize an object |
| Collection | The base interface of all collections managed by Coherence |
| Collections | This class consists exclusively of static methods that operate on or return collections |
| Comparable | This interface imposes a total ordering on the objects of each class that implements it |
| ComparableMax | Calculates a maximum among values extracted from a set of entries in a Map |
| ComparableMin | Calculates a minimum among values extracted from a set of entries in a Map |
| Comparator | The Comparator defines a partial order on the collection of Objects |
| ComparisonFilter | Filter which compares the result of a method invocation with a value |
| ComparisonValueExtractor | A synthetic ValueExtractor that returns a result of comparison between two values extracted from the same target |
| CompositeAggregator | CompositeAggregator provides an ability to execute a collection of aggregators against the same subset of the entries in an InvocableMap, resulting in a list of corresponding aggregation results |
| CompositeKey | Key class that consists of a primary and secondary component |
| CompositeProcessor | The CompositeProcessor represents a collection of entry processors that are invoked sequentially against the same Entry |
| CompositeUpdater | A ValueManipulator implementation based on an extractor-updater pair |
| ConcurrentMap | Map with additional concurrency features |
| ConcurrentMap::LockBlock | The LockBlock allows for easy creation of ConcurrentMap::lock code |
| ConcurrentModificationException | Thrown to indicate that a non-permissible concurrent modification of an object has been detected |
| ConditionalExtractor | An IndexAwareExtractor implementation that is only used to create a coherence::util::ConditionalIndex |
| ConditionalIndex | ConditionalIndex is a conherence::util::MapIndex implementation that uses an associated filter to evaluate whether or not an entry should be indexed |
| ConditionalProcessor | Conditional entry processor represents a processor that is invoked conditionally based on the result of an entry evaluation |
| ConditionalPut | ConditionalPut is an EntryProcessor that performs an InvocableMap::Entry::setValue operation if the specified condition is satisfied |
| ConditionalPutAll | ConditionalPutAll is an EntryProcessor that performs a InvocableMap::Entry::setValue Entry.setValue} operation for multiple entries that satisfy the specified condition |
| ConditionalRemove | ConditionalRemove is an EntryProcessor that performs an InvocableMap::Entry::remove Entry.remove operation if the specified condition is satisfied |
| ConfigurableAddressProvider | ConfigurableAddressProvider is an implementation of the AddressProvider interface based on a static list of addresses configured in an XML element that contains one or more items in the following format: |
| ConfigurableAddressProvider::AddressHolder | A stateful holder for an InetSocketAddress object |
| ConfigurableAddressProviderFactory | An AddressProviderFactory implementation that creates instances of a AddressProvider class configured using an XmlElement of the following structure: |
| ConfigurableCacheFactory | An interface for XML driven cache factory |
| ConfigurableSerializerFactory | A factory for Serializer objects |
| ConnectionException | Signals that an underlying communication channel used by a Connection may have been closed, severed, or become unusable |
| ConstCastException | Thrown when an attempt is made to cast away constness from a Holder assigned from a View |
| ContainsAllFilter | Filter which tests a Collection or ObjectArray value returned from a method invocation for containment of all values in a Set |
| ContainsAnyFilter | Filter which tests a Collection or ObjectArray value returned from a method invocation for containment of any value in a Set |
| ContainsFilter | Filter which tests a Collection or ObjectArray value returned from a method invocation for containment of a given value |
| ContinuousQueryCache | Create a materialized view of a NamedCache using the Coherence Continuous Query capability |
| ContinuousQueryCache::AsynchronousEvent | Encapsulates an event and a listener that are to be dispatched asynchronously |
| ContinuousQueryCache::TaskDaemon | Daemon thread used to dispatch messages asynchronously |
| Controllable | The Controllable interface represents a configurable dameon-like object, quite oftenly referred to as a service, that usually operates on its own thread and has a controllable life cycle |
| Converter | Interface for conversion from one Object type to another one |
| ConverterCollections | A collection of Collection implementation classes that use the Converter interface to convert the items stored in underlying Collection objects |
| ConverterCollections::ConverterCacheEvent | A Converter CacheEvent views an underlying CacheEvent through a set of key and value Converters |
| ConverterCollections::ConverterCacheMap | A ConverterCacheMap views an underlying CacheMap through a set of key and value Converters |
| ConverterCollections::ConverterCollection | A ConverterCollection views an underlying Collection through a Converter |
| ConverterCollections::ConverterConcurrentMap | A Converter ConverterConcurrentMap views an underlying ConcurrentMap through a set of key and value Converters |
| ConverterCollections::ConverterEntry | A ConverterEntry views an underlying Map::Entry through a Converter |
| ConverterCollections::ConverterInvocableMap | A ConverterInvocable views an underlying InvocableMap through a set of key and value Converters |
| ConverterCollections::ConverterIterator | A ConverterIterator views an underlying Iterator through a Converter |
| ConverterCollections::ConverterMap | A ConverterMap views an underlying Map through a Converter |
| ConverterCollections::ConverterMapEvent | A Converter MapEvent views an underlying MapEvent through a set of key and value Converters |
| ConverterCollections::ConverterMapListener | A converter MapListener that converts events of the underlying MapListener for the underlying map |
| ConverterCollections::ConverterNamedCache | A ConverterNamedCache views an underlying NamedCache through a set of key and value Converters |
| ConverterCollections::ConverterObservableMap | A Converter ObservableMap views an underlying ObservableMap through a set of key and value Converters |
| ConverterCollections::ConverterQueryMap | A Converter QueryMap views an underlying QueryMap through a set of key and value Converters |
| ConverterCollections::ConverterSet | A ConverterSet views an underlying Set through a Converter |
| ConverterCollections::EntryConverter | Map::Entry Converter, supporting key and value conversion |
| ConverterCollections::UnsupportedConverter | Converter which always throws an UnsupportedOperationException |
| Count | Calculates a number of values in an entry set |
| DefaultConfigurableCacheFactory | DefaultConfigurableCacheFactory provides a facility to access caches declared in a "cache-config.dtd" compliant configuration file |
| DefaultConfigurableCacheFactory::CacheInfo | CacheInfo is a placeholder for cache attributes retrieved during parsing the corresponding cache mapping element |
| DefaultIdentityAsserter | The default implementation of the IdentityAsserter interface |
| DefaultIdentityTransformer | The default implementation of the IdentityTransformer interface, which simply returns the Subject that is passed to it |
| DefaultOperationalContext | The DefaultOperationalContext provides an OperationalContext with information obtained from XML in coherence.dtd format, system properties (as set through environment variables) and default values |
| DelegatingWriteBuffer | A DelegatingWriteBuffer is a WriteBuffer that writes through to an underlying (or "containing") WriteBuffer |
| DelegatingWriteBuffer::DelegatingBufferOutput | A BufferOutput implementation that delegates to a BufferOutput implementation, except that its offset range is shifted and limited |
| DeltaSet | Implements a set which is based on another set, which is assumed to be immutable |
| Describable | Abstract Object extension that simplifies the implementation of toString() for class hierarchies |
| DetachFinalizer | Finalizer which detaches from an Object upon deletion |
| DistinctValues | Return the set of unique values extracted from a set of entries in a Map |
| DualQueue | The DualQueue is optimized for the producer consumer use case |
| EntryAwareComparator | EntryAwareComparator is an extension to the Comparator interface that allows the EntryComparator to know whether the underlying comparator expects to compare the corresponding Entries' keys or values |
| EntryComparator | Comparator implementation used to compare map entries |
| EntryExtractor | The EntryExtractor is a base abstract class for special purpose custom ValueExtractor implementations |
| EntryFilter | EntryFilter provides an extension to Filter for those cases in which both a key and a value may be necessary to evaluate the conditional inclusion of a particular object |
| Enumeration | An object that implements the Enumeration interface generates a series of elements, one at a time |
| EOFException | Signals that an end of file or stream has been reached unexpectedly during input |
| EqualsFilter | Filter which compares the result of a method invocation with a value for equality |
| Event | The root class from which all event state classes shall be derived |
| EventListener | A tag interface that all event listener interfaces must extend |
| EventObject | The root class from which all event state objects shall be derived |
| EvictionPolicy | An eviction policy is an object that the cache provides with access information, and when requested, the eviction policy selects and evicts entries from the cache |
| Evolvable | The Evolvable interface is implemented by classes that require forwards- and backwards-compatibility of their serialized form |
| EvolvableHolder | Storage for Evolvable classes |
| EvolvableObject | Defines an interface that should be implemented by the classes that want to support evolution |
| EvolvablePortableObject | Extension of the PortableObject interface that supports forwards- and backwards-compatibility of its POF serialized state |
| Exception | Base class for all exceptions used in Coherence |
| ExecutableClass | Interface specialization for Classes which are executable |
| extends | The extends template indicates the parent class in a class specification |
| ExtractorEventTransformer | ExtractorEventTransformer is a special purpose MapEventTransformer implementation that transforms emitted events, extracting one or more properties from either the OldValue or the NewValue |
| ExtractorFilter | Base Filter implementation for doing extractor-based processing |
| ExtractorProcessor | ExtractorProcessor is an EntryProcessor implementations that extracts a value from an object cached in an InvocableMap |
| factory | Auto-generates static create methods for a class, corresponding to the class's constructors |
| Filter | Provide for "pluggable" conditional behavior |
| FilterMuterator | Provides a generic implementation of an iterator which can iterate items based on an inclusion test |
| FilterTrigger | A generic Filter-based MapTrigger implementation |
| FinalHandle | FinalHandle is an immutable thread-safe handle used by an Object to reference its non-const child Objects |
| FinalHolder | FinalHolder is an immutable thread-safe holder intended for use as a data-member within Objects |
| FinalizableBlock | A finalizable block which runs a series of chained Finalizers as part of its destruction |
| FinalizableBlock::Finalizer | Interface for custom automatic cleanup operations |
| FinalView | FinalView is an immutable thread-safe view intended for use as a data-member within Objects |
| Float32 | An immutable 32-bit floating-point value |
| Float64 | An immutable 64-bit floating-point value |
| Float64Average | Calculates an average for values of any numberic type extracted from a set of entries in a Map |
| Float64Max | Calculates a maximum of numeric values extracted from a set of entries in a Map |
| Float64Min | Calculates a minimum of numeric values extracted from a set of entries in a Map |
| Float64Sum | Sums up numeric values extracted from a set of entries in a Map |
| GenericPrincipal | A generic implementation of the Principal interface |
| GenericSubject | A generic implementation of the subject interface |
| GreaterEqualsFilter | Filter which compares the result of a method invocation with a value for "Greater or Equals" condition |
| GreaterFilter | Filter which compares the result of a method invocation with a value for "Greater" condition |
| GroupAggregator | The GroupAggregator provides an ability to split a subset of entries in an InvocableMap into a collection of non-intersecting subsets and then aggregate them separately and independently |
| HashHelper | This abstract class contains helper functions for calculating hash code values for any group of C++ intrinsics |
| HashSet | Set implementation which is backed by a HashMap |
| Hashtable | An implementation of coherence::util::Map that is thread-safe, but unlike SafeHashMap does not attempt to provide stable iteration in the presence of concurrent modifications |
| HeapAnalyzer | HeapAnalyzer provides a base diagnostics interface for tracking heap usage |
| HeapAnalyzer::Block | The HeapAnalyzer::Block allows for easily verifying that a block of code does not leak memory |
| HeapAnalyzer::Snapshot | Snapshot provides a abstract mechanism for comparing successive heap analysis points |
| IdentityAsserter | IdentityAsserter validates a token in order to establish a user's identity |
| IdentityExtractor | Trivial ValueExtractor implementation that does not actually extract anything from the passed value, but returns the value itself |
| IdentityHashMap | IdentityHashMap is a HashMap implementation where key equality is based on reference rather then value equality |
| IdentityHashMap::Entry | A Map::Entry where key equality is based on reference equality |
| IdentityHolder | A thread local storage to hold the identity of an object and its corresponding POF stream reader |
| IdentityTransformer | IdentityTransformer transforms a Subject to a token that asserts identity |
| IllegalArgumentException | Thrown to indicate that a function has been passed an illegal or inappropriate argument |
| IllegalStateException | Signals that a function has been called at an illegal or inappropriate time |
| Immutable | A Handle implementation which upon assignment ensures that it will reference an immutable Object |
| implements | The implements template specifies a list of interfaces which a class or interface specification derives from |
| IndexAwareExtractor | IndexAwareExtractor is an extension to the ValueExtractor interface that supports the creation and destruction of an MapIndex index |
| IndexAwareFilter | IndexAwareFilter is an extension to the EntryFilter interface that allows a filter to use a Map index to fully or partially evaluate itself |
| IndexOutOfBoundsException | Thrown to indicate that an index of some sort (such as to an array, to a string, or to a vector) is out of range |
| InetAddress | InetAddress represents an IP address |
| InetSocketAddress | InetSocketAddress represents an endpoint of a IP socket connection |
| InFilter | Filter which checks whether the result of a method invocation belongs to a predefined set of values |
| Inherited | The Inherited annotation is used to annotate annotations in order to indicate that the annotation is to be automatically inherited by derived AnnotationElements |
| InKeySetFilter | Filter that limits the underlying filter evaluation only to the specified set of keys |
| Integer16 | An immutable 16-bit integer value |
| Integer32 | An immutable 32-bit integer value |
| Integer64 | An immutable 64-bit integer value |
| Integer64Max | Calculates a maximum of numeric values extracted from a set of entries in a Map |
| Integer64Min | Calculates a minimum of numeric values extracted from a set of entries in a Map |
| Integer64Sum | Sums up numeric values extracted from a set of entries in a Map |
| interface_spec | Helper for defining a managed interface |
| InterruptedException | Signals that the current thread has been interrupted |
| InterruptedIOException | Signals that the current thread has been interrupted while blocked on IO |
| InverseComparator | Comparator that reverses the result of another comparator |
| Invocable | The Invocable object is a cluster-portable object that can be invoked on any set of remote members and each can optionally register a return value for the invocation |
| InvocableMap | Map with additional query features |
| InvocableMap::Entry | An InvocableMap::Entry contains additional information and exposes additional operations that the basic Map::Entry does not |
| InvocableMap::EntryAggregator | An EntryAggregator represents processing that can be directed to occur against some subset of the entries in an InvocableMap, resulting in a aggregated result |
| InvocableMap::EntryProcessor | An invocable agent that operates against the Entry objects within a Map |
| InvocableMap::ParallelAwareAggregator | A ParallelAwareAggregator is an advanced extension to EntryAggregator that is explicitly capable of being run in parallel, for example in a distributed environment |
| InvocableMap::ParallelAwareAggregator::PartialResultAggregator | PartialResultAggregator allows for the intermediate aggregation of the partial results of a parallel aggregation |
| InvocationService | The InvocationService is a Service for delivering executable objects to the cluster member to which the client is connected |
| IOException | Signals that an I/O exception of some sort has occurred |
| IsNotNullFilter | Filter which tests the result of a method invocation for inequality to null |
| IsNullFilter | Filter which compares the result of a method invocation with null |
| IterableCacheLoader | A CacheLoader that can iterate its underlying contents |
| Iterator | An object that implements the Iterator interface generates series of Object::Holders, one at a time |
| KeyAssociatedFilter | Filter which limits the scope of another filter according to the key association information |
| KeyAssociation | A KeyAssociation represents a key object that has a natural association with another key object |
| KeyExtractor | The KeyExtractor is a special purpose ValueExtractor implementation that serves as an indicator that a query should be run against the key objects rather than the values |
| KeyFilter | EntryFilter which checks whether an entry key belongs to a set |
| LessEqualsFilter | Filter which compares the result of a method invocation with a value for "Less or Equals" condition |
| LessFilter | Filter which compares the result of a method invocation with a value for "Less" condition |
| LikeFilter | Filter which compares the result of a method invocation with a value for pattern match |
| LimitFilter | Filter which truncates the results of another filter |
| LinkedList | A linked list implementation of List |
| LinkedList::ListElement | ListElement is the foundation element for the linked list |
| LinkedList::SubLinkedList | Utility class to implement a SubList of a LinkedList |
| List | An ordered collection (also known as a sequence) |
| Listeners | Provides a simple, efficient, and thread-safe implementation of a list of event listeners |
| ListIterator | 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 |
| ListMuterator | Muterator is mutating iterator, that is it is capable of changing the list it iterates |
| LiteSet | An implementation of coherence::util::Set that is optimal (in terms of both size and speed) for very small sets of data but still works excellently with large sets of data |
| LocalCache | A LocalCache implementation that supports CacheLoader and CacheStore objects |
| LocalCache::Entry | A holder for a cached value |
| LocalCache::InternalListener | An internal MapListener that listens to this cache and reports changes to the CacheStore |
| LocalCache::KeyMask | A class that masks certain changes so that they are not reported back to the CacheStore |
| LongArray | An interface, similar in its methods to List, and similar in its purpose to an array, designed for sparse storage and indexed by long values |
| LongArrayIterator | A LongArray specific iterator that adds a "current element" concept |
| Managed | Managed is an adaptor class which transforms a pre-existing class into a Coherence managed Object |
| Map | An interface for associating key value pairs |
| Map::Entry | A map entry (key-value pair) |
| MapEvent | An event which indicates that the content of a map has changed: |
| MapEventFilter | Filter which evaluates the content of a MapEvent object according to the specified criteria |
| MapEventTransformer | MapEventTransformer interface is used to allow an event consumer to change the content of a MapEvent destined for the corresponding MapListener |
| MapEventTransformerFilter | MapEventTransformerFilter is a generic multiplexing wrapper that combines two implementations: a Filter (most commonly a MapEventFilter) and a MapEventTransformer and is used to register event listeners that allow to change the content of a MapEvent |
| MapIndex | MapIndex is used to correlate values stored in an indexed Map (or attributes of those values) to the corresponding keys in the indexed Map |
| MapKeySet | A wrapper class that provides the Set interface for the key set of a map |
| MapKeySet::KeyConverter | Convert a Map::Entry into a Map::Entry::Key |
| MapListener | The listener interface for receiving MapEvents |
| MapListenerSupport | This class provides support for advanced MapListener functionality |
| MapListenerSupport::FilterEvent | An extension of the CacheEvent which may carry no values (old or new), but instead holds an array of Filter objects being the "cause" of the event |
| MapListenerSupport::PrimingListener | A tag interface indicating that tagged MapListener implementation has to receive the MapEvent notifications in a synchronous manner for lite events (carrying only a key) |
| MapListenerSupport::SynchronousListener | A tag interface indicating that tagged MapListener implementation has to receive the MapEvent notifications in a synchronous manner |
| MapListenerSupport::WrapperPrimingListener | A wrapper class that turns the specified MapListener into a Priminglistener |
| MapListenerSupport::WrapperSynchronousListener | A wrapper class that turns the specified MapListener into a synchronous listener |
| MappedSet | Set implementation which is backed by a Map |
| MapTrigger | MapTrigger represents a functional agent that allows to validate, reject or modify mutating operations against an underlying map |
| MapTrigger::Entry | A MapTrigger Entry represents a pending change to an Entry that is about to committed to the underlying Map |
| MapTriggerListener | MapTriggerListener is a special purpose MapListener implementation that is used to register a MapTrigger on a corresponding ObservableMap |
| MapValuesCollection | A wrapper class that provides the Collection interface for the value collection of a map |
| MapValuesCollection::ValueConverter | Convert a Map::Entry into a Map::Entry::Key |
| Member | The Member interface represents a cluster member |
| MemberEvent | An event which indicates that membership has changed: |
| MemberHandle | MemberHandle is a thread-safe handle used by an Object to reference its non-const child Objects |
| MemberHolder | MemberHolder is a thread-safe handle implementation which supports referencing Objects as either Handles or Views |
| MemberListener | The listener interface for receiving MemberEvents |
| MemberView | MemberView is a thread-safe view intended for use as a data-member within Objects |
| Method | Method represents a method within a managed class |
| MultiExtractor | Composite ValueExtractor implementation based on an array of extractors |
| MultiplexingMapListener | A base class that simplifies the implementation of a MapListener by multiplexing all events into a single listener method |
| Muterator | Muterator is mutating iterator, that is it is capable of changing the collection it iterates |
| NamedCache | A NamedCache is a Map that holds resources shared among members of a cluster |
| NamedCacheDeactivationListener | Pseudo MapListener that can be used to listen for a deactivation event from a NamedCache |
| NameService | A NameService is a clustered service that accepts connections from external clients (e.g |
| NavigableMap | A SortedMap extended with navigation methods returning the closest matches for given search targets |
| NearCache | A "near cache" is a CachingMap whose front map is a size-limited and/or auto-expiring local cache, and whose back map is a distributed cache |
| NeverFilter | Filter which always evaluates to false |
| NoSuchElementException | Thrown to indicate that a object is not found in the cache/map/collection |
| NoSuchMethodException | Thrown when a definition for a named Method could not be found |
| NotEqualsFilter | Filter which compares the result of a method invocation with a value for inequality |
| NotFilter | Provide for "pluggable" conditional behavior that negates |
| NullFilter | Filter which discards null references |
| NullImplementation | A collection of classes that do nothing |
| NullPointerException | Thrown when an application attempts to use NULL in a case where a non-NULL handle to Object is required |
| Number | Interface implemented by all managed numeric types |
| NumberIncrementor | The NumberIncrementor entry processor is used to increment a property value of a Number type |
| NumberMultiplier | The NumberMultiplier entry processor is used to multiply a property value of a Number type |
| Object | Object is the base class for all Coherence managed objects |
| ObjectCountHeapAnalyzer | ObjectCountHeapAnalyzer provides simple heap analysis based solely on the count of the number of live objects in the system |
| ObjectCountHeapAnalyzer::Snapshot | Snapshot containing the object count |
| Objects | This class consists of static NULL-safe or NULL-tolerant utility methods for operating on Objects |
| ObservableMap | ObservableMap interface represents an object with a model being a Map that allows for pluggable notifications for occuring changes |
| Octet | An immutable 8-bit unsigned value |
| OctetArrayReadBuffer | A ReadBuffer on top of an octet Array |
| OctetArrayWriteBuffer | OctetArrayWriteBuffer is an implementation of WriteBuffer on an octet array |
| OctetArrayWriteBuffer::OctetArrayBufferOutput | OctetArrayBufferOutput is an implementation of BufferOutput optimized for writing to the buffer's underlying octet array |
| OldCache | A generic cache manager |
| OldCache::Entry | Entry for the local cache extends SafeHashMap::Entry adding entry statistics used for the various eviction policies |
| OldCache::EntrySet | A set of entries backed by this map |
| OldCache::IteratorFilter | This iterator will filter out expired entries from the result set and expire them |
| OldCache::KeySet | A set of entries backed by this map |
| OldCache::ValuesCollection | A set of entries backed by this map |
| OperationalContext | OperationalContext is an interface for providing Oracle Coherence operational configuration |
| Optional | C++ port of java.util.Optional, a container object which may or may not contain a non-NULL value |
| OrFilter | Filter which returns the logical "and" of two other filters |
| OutOfMemoryError | Thrown to indicate that an attempt to allocate an object failed due to resource constraints |
| ParallelCompositeAggregator | ParallelCompositeAggregator provides an ability to execute a collection of parallel aware aggregators against the same subset of the entries in an InvocableMap, resulting in a list of corresponding aggregation results |
| ParallelGroupAggregator | The ParallelGroupAggregator provides an ability to split a subset of entries in an InvocableMap into a collection of non-intersecting subsets and then aggregate them separately and independently |
| PartitionSet | PartitionSet is a light-weight data structure that represents a set of partitions that are used in parallel processing |
| PofAnnotationSerializer | A PofAnnotationSerializer provides annotation based (de)serialization |
| PofBufferReader | PofReader implementation that reads POF-encoded data from a ReadBuffer::BufferInput |
| PofBufferWriter | PofWriter implementation that writes POF-encoded data to a WriteBuffer::BufferOutput |
| PofConstants | Constants related to POF streams |
| PofContext | A PofContext is a registry of PofSerializer instances, and thus, represents a set of user types that can be serialized to and deserialized from a POF stream |
| PofExtractor | POF-based ValueExtractor implementation |
| PofHandler | This interface defines the handler for an event-driven approach to parsing (or assembling) a POF stream |
| PofHelper | Collection of helper methods for POF streams |
| PofHelper::ReadableEntrySetMap | Map implementation backed by a List of Map.Entry objects |
| PofHelper::WriteableEntrySetMap | Immutable Map implementation backed by a Set of Map::Entry objects |
| PofIntrinsic | PofIntrinsic is a marker interface for built-in POF types |
| PofNavigator | The PofNavigator interface represents an algorithm for navigating a PofValue hierarchy in order to locate a contained PofValue for extraction, modification and/or removal purposes |
| PofReader | The PofReader interface provides the capability of reading a set of non-primitive types ("user types") from a POF stream as an ordered sequence of indexed properties |
| PofSerializer | The PofSerializer interface provides the capability of reading and writing an object from and to a Portable Object Format (POF) stream |
| PofUpdater | POF-based ValueUpdater implementation |
| PofValue | PofValue represents the POF data structure in a POF stream, or any sub-structure or value thereof |
| PofWriter | The PofWriter interface provides the capability of writing a set of non-primitive types ("user types") to a POF stream as an ordered sequence of indexed properties |
| Portable | Portable marks a class as being eligible for use by a PofAnnotationSerializer |
| PortableException | A PortableException is an exception that allows information about a remote exception or error to be serialized and deserialized to/from a POF stream |
| PortableObject | The PortableObject interface is implemented by classes that can self-serialize and deserialize their state to and from a POF data stream |
| PortableObjectSerializer | A PofSerializer implementation that supports the serialization and deserialization of any class that implements PortableObject to and from a POF stream |
| PortableProperty | A PortableProperty marks a method accessor as a POF serialized attribute |
| PortableTypeSerializer | A PofSerializer implementation that serializes classes that implement PortableObject interface (and optionally EvolvableObject interface) |
| PreloadRequest | PreloadRequest is a simple EntryProcessor that performs a InvocableMap::Entry::getValue() call |
| PresentFilter | Filter which returns true for InvocableMap::Entry objects that currently exist in a Map |
| Primitive | Template class which converts primitive data types into immutable managed objects |
| Principal | A Principal represents a portion of an overall identity, such as a person, or group |
| PrincipalPofSerializer | PofSerializer implementation that can serialize and deserialize a Principal to/from a POF stream |
| PriorityAggregator | PriorityAggregator is used to explicitly control the scheduling priority and timeouts for execution of EntryAggregator-based methods |
| PriorityFilter | PriorityFilter is used to explicitly control the scheduling priority and timeouts for execution of filter-based methods |
| PriorityProcessor | PriorityProcessor is used to explicitly control the scheduling priority and timeouts for execution of EntryProcessor-based methods |
| PriorityTask | The PriorityTask interface allows to control the ordering in which a service schedules tasks for execution using a thread pool and limit their execution times to a specified duration |
| PropertyManipulator | PropertyManipulator is a reflection based ValueManipulator implementation based on the JavaBean property name conventions |
| PropertyProcessor | PropertyProcessor is a base class for EntryProcessor implementations that depend on a ValueManipulator |
| QueryMap | Map with additional query features |
| QueryMap::Entry | A QueryMap::Entry exposes additional index-related operation that the basic Map::Entry does not |
| QueryMapComparator | This interface is used by Comparator implementations that can use value extraction optimization exposed by the QueryMap::Entry interface |
| QueryRecord | The QueryRecord object carries a record of the estimated or actual execution cost for a query operation |
| QueryRecord::PartialResult | A QueryPlan.PartialResult is a partial query record that contains recorded costs for a query operation |
| QueryRecord::PartialResult::IndexLookupRecord | An IndexLookupRecord holds the recorded information about an index lookup performed during filter evaluation as part of a query record |
| QueryRecord::PartialResult::Step | A QueryPlan.Step carries the recorded cost of evaluating a filter as part of a query operation |
| QueryRecorder | This parallel aggregator used to produce a QueryRecord object that contains an estimated or actual cost of the query execution for a given filter |
| Queue | The Queue provides a means to efficiently (and in a thread-safe manner) queue received messages and messages to be sent |
| Random | An instance of this class is used to generate a stream of pseudorandom numbers |
| RawDate | Raw immutable POF date value |
| RawDateTime | Raw immutable POF date-time value |
| RawDayTimeInterval | Raw immutable POF day-time interval value |
| RawTime | Raw immutable POF time value |
| RawTimeInterval | Raw immutable POF time interval value |
| RawYearMonthInterval | Raw POF year-month interval value |
| ReadBuffer | The ReadBuffer interface represents an in-memory block of binary data |
| ReadBuffer::BufferInput | The BufferInput interface represents a data input stream on top of a ReadBuffer |
| ReadOnlyArrayList | Implementation of the Collection Framework interface "List" in a read- only fashion on top of an array data structure |
| ReadOnlyMultiList | Implementation of the List interface in a read-only fashion based on a collection of arrays |
| ReadOnlyMultiList::ListView | ListView exposes the underlying ReadOnlyMultiList through the List interface, maintaining correct equals() and hashCode() semantics |
| ReadOnlyMultiList::SetView | SetView exposes the underlying ReadOnlyMultiList through the Set interface, maintaining correct equals() and hashCode() semantics |
| ReducerAggregator | The ReducerAggregator is used to implement functionality similar to CacheMap::getAll(Collection) API |
| Reference | Reference provides an additional level of indirection to object instances |
| ReferenceLibrary | A "library" of object references and their corresponding identities in the POF stream |
| ReflectionExtractor | Reflection-based ValueExtractor implementation |
| ReflectionUpdater | Reflection-based ValueUpdater implementation |
| RequestIncompleteException | Signals that a request execution in a clustered environment failed to complete successfully |
| RequestTimeoutException | Signals that a request execution in a clustered environment did not complete in a pre-determined amount of time |
| RunAsBlock | Allows for easy creation of scoped authorization code blocks based on a Subject |
| Runnable | Interface implemented by any class whose instances are intended to be executed by a thread |
| RuntimeException | RuntimeException is the superclass for exceptions which are not normally handled by user code |
| SafeComparator | NULL-safe delegating comparator |
| SafeHashMap | An implementation of coherence::util::Map that is synchronized, but minimally so |
| SafeHashMap::Entry | A map entry (key-value pair) |
| SafeHashMap::EntrySet | A set of entries backed by this map |
| SafeHashMap::EntrySetIterator | An Iterator over the EntrySet that is backed by the SafeHashMap |
| SafeHashSet | A thread-safe Set implementation which is backed by a SafeHashMap |
| SecurityException | Thrown to indicate a security violation |
| SemiLiteEventTransformer | SemiLiteEventTransformer is a special purpose MapEventTransformer implementation that removes an OldValue from the MapEvent object for the purpose of reducing the amount of data that has to be sent over the network to event consumers |
| SerializationHelper | Miscellaneous serialization utilities |
| SerializationHelper::Stats | Serialization statistics for a given user type |
| Serializer | The Serializer interface provides the capability of reading and writing an object from and to an in-memory buffer |
| SerializerFactory | A factory for Serializer objects |
| Service | This Service interface represents a controllable service that operates in a clustered network environment |
| Service | A Service is a Controllable that emits service lifecycle events |
| ServiceEvent | An event which indicates that a Service state has changed: |
| ServiceInfo | The ServiceInfo represents information about a Service that operates in a clustered network environment |
| ServiceListener | The listener interface for receiving ServiceEvents |
| Set | A collection that contains no duplicate elements |
| SimpleCacheStatistics | Implementation of the CacheStatistics class intended for use by a cache to maintain its statistics |
| SimpleEvolvable | Simple implementation of Evolvable interface |
| SimpleMapIndex | SimpleMapIndex is a MapIndex implementation used to correlate property values extracted from resource map entries with corresponding keys using what is commonly known as an Inverted Index algorithm |
| SimplePofContext | Basic PofContext implementation |
| SimplePofPath | A static PofNavigator implementation which uses an array of integer indices to navigate the PofValue hierarchy |
| SimpleQueryRecord | Simple QueryRecord implementation |
| SimpleQueryRecord::PartialResult | Simple QueryRecord::PartialResult implementation |
| SimpleQueryRecord::PartialResult::IndexLookupRecord | Simple QueryRecord::PartialResult::IndexLookupRecord implementation |
| SimpleQueryRecord::PartialResult::Step | Simple QueryRecord::PartialResult::Step implementation |
| SimpleQueryRecordReporter | Simple query record reporter used to obtain a string representation of QueryRecord object |
| SingleAddressProvider | SocketAddressProvider wrapper for a single address dynamically added to this provider |
| Size32 | An immutable 32-bit unsigned value |
| Size64 | An immutable 64-bit unsigned value |
| SmartMember | Base class for smart data-members of managed Objects |
| SocketAddress | SocketAddress interface |
| SortedBag | SortedBag is a multiset or bag implementation that supports sorted traversal of the contained elements and is optimized for insertions and removals |
| SortedBag::UniqueElement | UniqueElement represents a unique instance of a logical element in the bag |
| SortedBag::ViewBag | A range-limited view of the SortedBag |
| SortedBag::WrapperComparator | WrapperComparator is a Comparator implementation that is aware of UniqueElement wrappers and will delegate the comparison of the elements in both forms to the wrapped comparator |
| SortedMap | An interface for a map which guarantees its key's iteration order |
| SortedSet | A Set that further provides a total ordering on its elements |
| SparseArray | A data structure resembling an array keyed by long values |
| StackTraceElement | StackTraceElement interface represents a frame within a stack trace |
| String | A managed C-style (NUL terminated) string |
| String::StringHandle | StringHandle provides standard TypedHandle features as well as auto-boxing support for standard string types including: |
| Subject | A Subject represents a grouping of related information for a single entity, such as a person |
| SubjectPofSerializer | PofSerializer implementation that can serialize and deserialize a Subject to/from a POF stream |
| SubList | SubList delegates all operations to it's full list while providing a partial view of the list |
| SubscriptHandle | A TypedHandle implementation which supports automatic delegation of the subscript operator |
| SubscriptHolder | A TypedHolder implementation which supports automatic delegation of the subscript operator |
| SubSet | Implements a set which is based on another set, which is assumed to be immutable |
| Supplier | A Supplier provides the ability to provide a value in a deferred fashion |
| SynchronizedBlock | Allows for easy creation of synchronized code blocks based on an Object's monitor |
| SynchronizedMemberReadBlock | Allows for easy creation of synchronized code blocks based on an Object's member level read/write lock |
| SynchronizedMemberReadBlock::Guard | Simple read lock structure for use in inlining |
| SynchronizedMemberWriteBlock | The SynchronizedMemberBlock class allows for easy creation of synchronized code blocks based on an Object's member level read/write lock |
| SynchronizedMemberWriteBlock::Guard | Simple write lock structure for use in inlining |
| SynchronousListener | A tag interface indicating that a listener implementation has to receive the event notifications synchronously on the corresponding service's thread |
| System | A collection of general purpose utility methods |
| System::CommonMonitor | A class which acts as CommonMonitor |
| SystemClassLoader | SystemClassLoader is a ClassLoader implementation based on registration only |
| SystemPofContext | System-wide PofContext implementation that allows POF user types to be registered programmatically |
| Thread | An Object representing a thread of execution |
| ThreadGate | Use this class in cases that large numbers of threads can operate concurrently with an additional requirement that all threads be blocked for certain operations |
| ThreadGate::Counter | Counter is a mutable integer class |
| ThreadGate::GateBlock | The EnterBlock class allows for easy creation of ThreadGate::enter code |
| ThreadGroup | ThreadGroup represents a set of threads |
| ThreadLocalReference | ThreadLocalReferences provide a means to store a Handle to an Object in thread local storage |
| throwable_spec | Helper for defining a throwable managed class |
| throwable_spec::bridge | Bridge joins two hierarchy types into a single type |
| throwable_spec::hierarchy | The hierarchy class wraps the Coherence C++ Exception classes in a object that preserves their hierarchical structure |
| ThrowablePofSerializer | PofSerializer implementation that can serialize and deserialize an Exception to/from a POF stream |
| TimeoutBlock | TimeoutBlock provides a mechanism for allowing a thread to interrupt itself if it doesn't return to a specific call site within a given timeout |
| TopNAggregator | TopNAggregator is a ParallelAwareAggregator that aggregates the top N extracted values into an array |
| TopNAggregator::PartialResult | The sorted partial result |
| TreeMap | A tree map implementation |
| TreeMap::Node | An AVL tree node |
| TreeSet | A TreeSet implementation based on a TreeMap |
| TypedBarrenClass | TypedBarrenClass provides a templated extension of Class but does not provide a means to instantiate new instances of the class |
| TypedClass | TypedClass extends AbstractTypedClass supporting classes which include a no-argument create method |
| TypedCollections | A collection of wrapper classes which expose an underlying collection's contents as explicit types rather then just as Objects |
| TypedCollections::TypedCollection | Typed wrapper over Collection interface |
| TypedCollections::TypedEntry | Typed wrapper over Map::Entry interface |
| TypedCollections::TypedIterator | Typed wrapper over Iterator interface |
| TypedCollections::TypedList | Typed wrapper over List interface |
| TypedCollections::TypedListIterator | Typed wrapper over ListIterator interface |
| TypedCollections::TypedMap | Typed wrapper over Map interface |
| TypedCollections::TypedMap::EntryConverter | A converter from untyped to typed entries: Map::Entry -> TypedEntry |
| TypedCollections::TypedSet | Typed wrapper over Set interface |
| TypedExecutableClass | TypedExecutableClass provides a templated extension of ExecutableClass |
| TypedExtractor | Template based ValueExtractor implementation |
| TypedHandle | Reference counting "smart pointer" class for use with Coherence managed objects |
| TypedHandle::identity_hash_functor | Identity based hash functor which is compatible with both the SGI and MS style hash containers |
| TypedHandle::value_equal_functor | The binary functor that compares values pointed by the handles for equality |
| TypedHandle::value_hash_functor | Value based hash functor which is compatible with both the SGI and MS style hash containers |
| TypedHandle::value_less_functor | The binary functor that compares objects pointed by the handles with the "less-than" operator |
| TypedHolder | A handle implementation which supports referencing Objects as either Handles or Views |
| TypedMethod | TypedMethod provides a template based implementation for building Methods which delegate to member function pointers |
| TypedSerializer | A PofSerializer implementation that supports the serialization and deserialization of any class to and from a POF stream, by delegating the serialization logic to templated free functions |
| TypedUpdater | Template based ValueUpdater implementation |
| UnitCalculator | A unit calculator is an object that can calculate the cost of caching an object |
| UniversalExtractor | Universal ValueExtractor implementation |
| UniversalUpdater | Universal ValueUpdater implementation |
| UnknownHostException | UnknownHostException is thrown as a result of a failed hostname resolution |
| UnsupportedOperationException | Thrown to indicate that the requested operation is not supported |
| UpdaterProcessor | UpdaterProcessor is an EntryProcessor implementations that updates an attribute of an object cached in an InvocableMap |
| UserTypeReader | The UserTypeReader implementation is a contextually-aware PofReader whose purpose is to advance through the properties of a value of a specified user type |
| UserTypeWriter | The UserTypeWriter implementation is a contextually-aware PofWriter whose purpose is to write the properties of a value of a specified user type |
| UTFDataFormatException | Signals that a malformed UTF-8 string has been read in a data input stream |
| UUID | A UUID is a 256-bit identifier that, if it is generated, is statistically guaranteed to be unique |
| ValueChangeEventFilter | Filter which evaluates the content of a MapEvent values based on the specified value extractor |
| ValueExtractor | ValueExtractor is used to both extract values (for example, for sorting or filtering) from an object, and to provide an identity for that extraction |
| ValueManipulator | ValueManipulator represents a composition of ValueExtractor and ValueManipulator implementations |
| ValueUpdater | ValueUpdater is used to update an object's state |
| Versionable | An interface for versionable data |
| VersionedPut | VersionedPut is an EntryProcessor that assumes that entry values implement Versionable interface and performs an InvocableMap::Entry::setValue operation if and only if the version of the specified value matches to the version of the current value |
| VersionedPutAll | VersionedPutAll is an EntryProcessor that assumes that entry values implement Versionable interface and performs an InvocableMap::Entry::setValue operation only for entries whose versions match to versions of the corresponding current values |
| ViewBuilder | The ViewBuilder provides a means to build() a view (ContinuousQueryCache) using a fluent pattern / style |
| Volatile | Template class wraps primitive data types with memory barriers, providing JSR-133 style volatiles |
| WeakHandle | WeakHandles are a TypedHandle like wrapper around WeakReferences |
| WeakHashMap | WeakHashMap is a HashMap implementation based on weak keys |
| WeakHashMap::Entry | A map entry (key-value pair) |
| WeakHolder | WeakHolders are a TypedHolder like wrapper around WeakReferences |
| WeakReference | WeakReferences allow one Object to safely reference another without blocking it from being destroyed |
| WeakView | WeakViews are a TypedHandle like wrapper around WeakReferences |
| WrapperCollections | A collection of abstract Collection implementation classes for wrapping Collection types |
| WrapperCollections::AbstractWrapperCollection | Collection implementation which delegates all calls to another Collection |
| WrapperCollections::AbstractWrapperEntry | Map::Entry implementation which delegates all calls to another Map::Entry |
| WrapperCollections::AbstractWrapperIterator | Iterator implementation which delegates all calls to another Iterator |
| WrapperCollections::AbstractWrapperList | List implementation which delegates all calls to another List |
| WrapperCollections::AbstractWrapperListIterator | ListIterator implementation which delegates all calls to another ListIterator |
| WrapperCollections::AbstractWrapperMap | Map implementation which delegates all calls to another Map |
| WrapperCollections::AbstractWrapperSet | Set implementation which delegates all calls to another Set |
| WrapperNamedCache | A wrapper for the given NamedCache |
| WrapperStreamFactory | Provides the means to wrap an BufferInput and BufferOutput, such that functionality such as compression and encryption can be implemented in a layered, pluggable fashion |
| WriteBuffer | The WriteBuffer interface represents an in-memory block of binary data that is being accumulated (written to) |
| WriteBuffer::BufferOutput | The BufferOutput interface represents a data output stream on top of a WriteBuffer |
| WritingPofHandler | An implementation of PofHandler that writes a POF stream to a WriteBuffer using a BufferOutput object |
| WritingPofHandler::Complex | A Complex object represents the current complex data structure in the POF stream |
| WritingPofHandler::ComplexMap | A ComplexMap object represents a map data structure (with uniform keys or with uniform keys and values) in the POF stream |
| XmlConfigurable | XmlConfigurable interface represents an Object that can be configured by providing configuration information from XML structure |
| XmlDocument | An interface for XML document access |
| XmlElement | An interface for XML element access |
| XmlValue | An interface for XML element content and element attribute values |
| XorFilter | Filter which returns the logical exclusive or ("xor") of two other filters |