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 |
AbstractHeapAnalyzer | AbstractHeapAnalyzer provides a starting point for writing custom heap analyzers |
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 |
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 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 |
AbstractTypedClass | AbstractTypedClass provides an abstract templated implementation of Class |
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 |
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 |
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 |
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 |
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 |
Comparable | This interface imposes a total ordering on the objects of each class that implements it |
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 |
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 |
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 |
ConstCastException | Thrown when an attempt is made to cast away constness from a Holder assigned from a View |
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 |
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 |
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 |
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 |
GenericPrincipal | A generic implementation of the Principal interface |
GenericSubject | A generic implementation of the subject interface |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
OutOfMemoryError | Thrown to indicate that an attempt to allocate an object failed due to resource constraints |
PartitionSet | PartitionSet is a light-weight data structure that represents a set of partitions that are used in parallel processing |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
SimplePofContext | Basic PofContext implementation |
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 |
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 | A range-limited view of the SortedBag |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
XmlElement | An interface for XML element access |
XmlValue | An interface for XML element content and element attribute values |