| abstract_spec | Helper for defining an abstract managed class |
| AbstractAggregator | Abstract base class implementation of coherence::util::InvocableMap::EntryAggregator that supports parallel aggregation |
| AbstractCacheLoader | An abstract base class for CacheLoader implementations |
| AbstractCacheStore | An abstract base class for CacheStore implementations |
| 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 |
| 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 implementation |
| 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 |
| 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 the default implementation of the processAll method |
| 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 |
| 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 |
| 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 |
| 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 |
| 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 |
| CacheEvent | An extension of the MapEvent which allows to differentiate between client driven (natural) events and cache internal (synthetic) events |
| 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 |
| 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 |
| 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 |
| 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 |
| 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 |
| ConfigurableCacheFactory | An interface for XML driven cache factory |
| 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 Object array value returned from a method invocation for containment of any value in a Set |
| ContainsFilter | Filter which tests a Collection or Object array 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 |
| 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 toStream() 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 |
| 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 |
| Evolvable | The Evolvable interface is implemented by classes that require forwards- and backwards-compatibility of their serialized form |
| 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 |
| 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::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 |
| 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 |
| 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 |
| 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 |
| 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 |
| 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::SynchronousListener | A tag interface indicating that tagged MapListener implementation has to receive the MapEvent notifications in a synchronous manner |
| 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 |
| 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 |
| NeverFilter | Filter which always evaluates to false |
| NoSuchElementException | Thrown to indicate that a object is not found in the cache/map/collection |
| 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 |
| 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 |
| OctetArrayReadBuffer::OctetArrayBufferInput | This is an implementation of the BufferInput interface on top of a 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 |
| 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 |
| 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 |
| 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 |
| 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 |
| 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 | Base Filter implementation for doing extractor-based processing |
| 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 |
| 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 |
| Reference | Reference provides an additional level of indirection to object instances |
| ReflectionExtractor | Reflection-based ValueExtractor implementation |
| ReflectionUpdater | Reflection-based ValueUpdater implementation |
| 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 |
| 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 |
| Serializer | The Serializer interface provides the capability of reading and writing an object from and to an in-memory buffer |
| Service | A Service is a Controllable that emits service lifecycle events |
| Service | This Service interface represents a controllable service that operates in a clustered network environment |
| 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 |
| SimplePofContext | Basic PofContext implementation |
| SimplePofPath | A static PofNavigator implementation which uses an array of integer indices to navigate the PofValue hierarchy |
| SmartMember | Base class for smart data-members of managed Objects |
| SocketAddress | SocketAddress interface |
| SortedMap | An interface for a map which guarantees its key's iteration order |
| 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 |
| 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 |
| 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 programatically |
| 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 |
| TreeMap | A tree map implementation |
| TreeMap::Node | An AVL tree node |
| TypedBarrenClass | TypedBarrenClass provides a templated extension of Class but does not provide a means to instantiate new instances of the class |
| TypedClass | TypedClass provides a templated implementation of Class |
| 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 |
| 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 |
| 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 |
| 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 |
| 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 |