Oracle Coherence for C++ API Class List

Here are the classes, structs, unions and interfaces with brief descriptions:
abstract_specHelper for defining an abstract managed class
AbstractAggregatorAbstract base class implementation of coherence::util::InvocableMap::EntryAggregator that supports parallel aggregation
AbstractCacheLoaderAn abstract base class for CacheLoader implementations
AbstractCacheStoreAn abstract base class for CacheStore implementations
AbstractCollectionThis class provides a skeletal implementation of the Collection interface, to minimize the effort required to implement this interface
AbstractComparableAggregatorAbstract aggregator that processes Comparable values extracted from a set of entries in a Map
AbstractCompositeExtractorAbstract super class for ValueExtractor implementations that are based on an underlying array of ValueExtractor objects
AbstractConcurrentQueueThe ConcurrentQueue provides a means to efficiently (and in a thread-safe manner) queue elements with minimal contention
AbstractExtractorAbstract base for ValueExtractor implementations
AbstractFloat64AggregatorAbstract aggregator that processes numeric values extracted from a set of entries in a Map
AbstractHeapAnalyzerAbstractHeapAnalyzer provides a starting point for writting custom heap analyzers
AbstractInteger64AggregatorAbstract aggregator that processes numeric values extracted from a set of entries in a Map
AbstractInvocableAn abstract base for Invocable implementation
AbstractListThis class provides a skeletal implementation of the List interface to minimize the effort required to implement this interface
AbstractLongArrayAbstract base class for LongArray implementations
AbstractMapThis class provides a skeletal implementation of the Map interface, to minimize the effort required to implement this interface
AbstractMapListenerA base class that simplifies the implementation of a MapListener, particularly inner classes that only implement one or two of the three event methods
AbstractPriorityTaskAn abstract base for AbstractPriorityTask implementations
AbstractProcessorAn AbstractProcessor is a partial EntryProcessor implementation that provides the default implementation of the processAll method
AbstractReadBufferAbstract base implementation of the ReadBuffer interface
AbstractReadBuffer::AbstractBufferInputThis is an implementation of the BufferInput interface that delegates its work back to its ReadBuffer
AbstractSetThis class provides a skeletal implementation of the Set interface to minimize the effort required to implement this interface
AbstractSparseArrayA data structure resembling an array indexed by long values, stored as an AVL tree
AbstractSparseArray::NodeAn AVL tree node
AbstractStableIteratorAn abstract Iterator implementation that is stable between the hasNext() and next() methods
AbstractWriteBufferThe AbstractWriteBuffer is a partial implementation of the WriteBuffer interface intended to be used as a base class for easily creating concrete WriteBuffer implementations
AbstractWriteBuffer::AbstractBufferOutputAbstractBufferOutput is a concrete implementation of BufferOutput for the non-concrete AbstractWriteBuffer implementation
adapter_mapAdapter_map provides an STL-like "pair associative container" wrapper around coherence::util::Map implementations
adapter_map::hasherHasher function
adapter_map::key_equalKey equality relation
AddressProviderThe AddressProvider is an interface that serves as a means to provide addresses to a consumer
AllFilterFilter which returns the logical "and" of a filter array
AlwaysFilterFilter which always evaluates to true
AndFilterFilter which returns the logical "and" of two other filters
AnyFilterFilter which returns the logical "or" of a filter array
ArithmeticExceptionAn exception that indicates exceptional condition related to arithmetic operations
ArrayA fixed size collection of values, indexed by integer position
Array::MemberArrayThe underlying array of values
ArrayFilterFilter which is a logical operator of a filter array
ArraysThis class contains various methods for manipulating arrays (such as sorting and searching)
AtomicCounterAtomicCounter allows for atomic updates to a "int64_t" value where possible without requiring synchronization
BetweenFilterFilter which compares the result of a method invocation with a value for "Between" condition
BinaryA thread-safe immutable binary object
BooleanAn immutable boolean value
BoxHandleA TypedHandle implementation which supports auto-boxing
boxing_mapBoxing_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
CacheEventAn extension of the MapEvent which allows to differentiate between client driven (natural) events and cache internal (synthetic) events
CacheFactoryFactory for the Oracle Coherence for C++ cache product
CacheLoaderA cache loader
CacheMapA CacheMap is a coherence::util::Map that supports caching
CacheServiceA CacheService is a clustered service providing a collection of named Maps that hold resources shared among members of a cluster
CacheStatisticsAn interface for exposing Cache statistics
CacheStoreA cache store
ChainedComparatorComposite comparator implementation based on a collection of comparators
ChainedExtractorComposite ValueExtractor implementation based on an array of extractors
Character16An immutable 16-bit Unicode character value
ClassA Class represents a managed object implementation
class_specHelper for defining a non-cloneable concrete managed class
ClassBasedHeapAnalyzerClassBasedHeapAnalyzer provides heap analysis at the class level, that is it tracks the number of live instances of each class
ClassBasedHeapAnalyzer::ClassStatsStatistics relating to a class
ClassBasedHeapAnalyzer::SnapshotSnapshot containging the object count
ClassCastExceptionThrown when an attempt is made to cast to an incompatible type
ClassLoaderClassLoader provides a mechansim for obtainging a Class object
ClassNotFoundExceptionThrown when a definition for a named Class could be found
cloneable_specHelper for defining a cloneable managed class
CollectionThe base interface of all collections managed by Coherence
CollectionsThis class consists exclusively of static methods that operate on or return collections
ComparableThis interface imposes a total ordering on the objects of each class that implements it
ComparableMaxCalculates a maximum among Comparable values extracted from a set of entries in a Map
ComparableMinCalculates a minimum among Comparable values extracted from a set of entries in a Map
ComparatorThe Comparator defines a partial order on the collection of Objects
ComparisonFilterFilter which compares the result of a method invocation with a value
ComparisonValueExtractorA synthetic ValueExtractor that returns a result of comparison between two values extracted from the same target
CompositeAggregatorCompositeAggregator 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
CompositeProcessorThe CompositeProcessor represents a collection of entry processors that are invoked sequentially against the same Entry
CompositeUpdaterA ValueManipulator implementation based on an extractor-updater pair
ConcurrentMapMap with additional concurrency features
ConcurrentMap::LockBlockThe LockBlock allows for easy creation of ConcurrentMap::lock code
ConcurrentModificationExceptionThrown to indicate that a non-permissible concurrent modification of an object has been detected
ConditionalProcessorConditional entry processor represents a processor that is invoked conditionally based on the result of an entry evaluation
ConditionalPutConditionalPut is an EntryProcessor that performs an InvocableMap::Entry::setValue operation if the specified condition is satisfied
ConditionalPutAllConditionalPutAll is an EntryProcessor that performs a InvocableMap::Entry::setValue Entry.setValue} operation for multiple entries that satisfy the specified condition
ConditionalRemoveConditionalRemove is an EntryProcessor that performs an InvocableMap::Entry::remove Entry.remove operation if the specified condition is satisfied
ConfigurableAddressProviderConfigurableAddressProvider 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::AddressHolderA stateful holder for an InetSocketAddress object
ConfigurableCacheFactoryAn interface for XML driven cache factory
ConstCastExceptionThrown when an attempt is made to cast away constness from a Holder assigned from a View
ContainsAllFilterFilter which tests a Collection or ObjectArray value returned from a method invocation for containment of all values in a Set
ContainsAnyFilterFilter which tests a Collection or Object array value returned from a method invocation for containment of any value in a Set
ContainsFilterFilter which tests a Collection or Object array value returned from a method invocation for containment of a given value
ContinuousQueryCacheCreate a materialized view of a NamedCache using the Coherence Continuous Query capability
ContinuousQueryCache::AsynchronousEventEncapsulates an event and a listener that are to be dispatched asynchronously
ContinuousQueryCache::TaskDaemonDaemon thread used to dispatch messages asynchronously
ControllableThe 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
ConverterInterface for conversion from one Object type to another one
ConverterCollectionsA collection of Collection implementation classes that use the Converter interface to convert the items stored in underlying Collection objects
ConverterCollections::ConverterCacheEventA Converter CacheEvent views an underlying CacheEvent through a set of key and value Converters
ConverterCollections::ConverterCacheMapA ConverterCacheMap views an underlying CacheMap through a set of key and value Converters
ConverterCollections::ConverterCollectionA ConverterCollection views an underlying Collection through a Converter
ConverterCollections::ConverterConcurrentMapA Converter ConverterConcurrentMap views an underlying ConcurrentMap through a set of key and value Converters
ConverterCollections::ConverterEntryA ConverterEntry views an underlying Map::Entry through a Converter
ConverterCollections::ConverterInvocableMapA ConverterInvocable views an underlying InvocableMap through a set of key and value Converters
ConverterCollections::ConverterIteratorA ConverterIterator views an underlying Iterator through a Converter
ConverterCollections::ConverterMapA ConverterMap views an underlying Map through a Converter
ConverterCollections::ConverterMapEventA Converter MapEvent views an underlying MapEvent through a set of key and value Converters
ConverterCollections::ConverterMapListenerA converter MapListener that converts events of the underlying MapListener for the underlying map
ConverterCollections::ConverterNamedCacheA ConverterNamedCache views an underlying NamedCache through a set of key and value Converters
ConverterCollections::ConverterObservableMapA Converter ObservableMap views an underlying ObservableMap through a set of key and value Converters
ConverterCollections::ConverterQueryMapA Converter QueryMap views an underlying QueryMap through a set of key and value Converters
ConverterCollections::ConverterSetA ConverterSet views an underlying Set through a Converter
ConverterCollections::EntryConverterMap::Entry Converter, supporting key and value conversion
ConverterCollections::UnsupportedConverterConverter which always throws UnsupportedOperationException
CountCalculates a number of values in an entry set
DefaultConfigurableCacheFactoryDefaultConfigurableCacheFactory provides a facility to access caches declared in a "cache-config.dtd" compliant configuration file
DefaultConfigurableCacheFactory::CacheInfoCacheInfo is a placeholder for cache attributes retrieved during parsing the corresponding cache mapping element
DelegatingWriteBufferA DelegatingWriteBuffer is a WriteBuffer that writes through to an underlying (or "containing") WriteBuffer
DelegatingWriteBuffer::DelegatingBufferOutputA BufferOutput implementation that delegates to a BufferOutput implementation, except that its offset range is shifted and limited
DescribableAbstract Object extension that simplifies the implementation of toStream() for class hierarchies
DetachFinalizerFinalizer which detaches from an Object upon deletion
DistinctValuesReturn the set of unique values extracted from a set of entries in a Map
DualQueueThe DualQueue is optimized for the producer consumer use case
EntryAwareComparatorEntryAwareComparator 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
EntryComparatorComparator implementation used to compare map entries
EntryExtractorThe EntryExtractor is a base abstract class for special purpose custom ValueExtractor implementations
EntryFilterEntryFilter 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
EOFExceptionSignals that an end of file or stream has been reached unexpectedly during input
EqualsFilterFilter which compares the result of a method invocation with a value for equality
EventThe root class from which all event state classes shall be derived
EventListenerA tag interface that all event listener interfaces must extend
EventObjectThe root class from which all event state objects shall be derived
EvolvableThe Evolvable interface is implemented by classes that require forwards- and backwards-compatibility of their serialized form
EvolvablePortableObjectExtension of the PortableObject interface that supports forwards- and backwards-compatibility of its POF serialized state
ExceptionBase class for all exceptions used in Coherence
extendsThe extends template indicates the parent class in a class specification
ExtractorEventTransformerExtractorEventTransformer is a special purpose MapEventTransformer implementation that transforms emitted events, extracting one or more properties from either the OldValue or the NewValue
ExtractorFilterBase Filter implementation for doing extractor-based processing
ExtractorProcessorExtractorProcessor is an EntryProcessor implementations that extracts a value from an object cached in an InvocableMap
factoryAuto-generates static create methods for a class, corresponding to the class's constructors
FilterProvide for "pluggable" conditional behavior
FilterMuteratorProvides a generic implementation of an iterator which can iterate items based on an inclusion test
FilterTriggerA generic Filter-based MapTrigger implementation
FinalizableBlockA finalizable block which runs a series of chained Finalizers as part of its destruction
FinalizableBlock::FinalizerInterface for custom automatic cleanup operations
Float32An immutable 32-bit floating-point value
Float64An immutable 64-bit floating-point value
Float64AverageCalculates an average for values of any numberic type extracted from a set of entries in a Map
Float64MaxCalculates a maximum of numeric values extracted from a set of entries in a Map
Float64MinCalculates a minimum of numeric values extracted from a set of entries in a Map
Float64SumSums up numeric values extracted from a set of entries in a Map
GenericPrincipalA generic implementation of the Principal interface
GenericSubjectA generic implementation of the subject interface
GreaterEqualsFilterFilter which compares the result of a method invocation with a value for "Greater or Equals" condition
GreaterFilterFilter which compares the result of a method invocation with a value for "Greater" condition
GroupAggregatorThe 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
HashSetSet implementation which is backed by a HashMap
HeapAnalyzerHeapAnalyzer provides a base diagnostics interface for tracking heap useage
HeapAnalyzer::SnapshotSnapshot provides a abstract mechanism for comparing successive heap analysis points
IdentityExtractorTrivial ValueExtractor implementation that does not actually extract anything from the passed value, but returns the value itself
IdentityHashMapIdentityHashMap is a HashMap implementation where key equality is based on reference rather then value equality
IdentityHashMap::EntryA Map::Entry where key equality is based on reference equality
IllegalArgumentExceptionThrown to indicate that a function has been passed an illegal or inappropriate argument
IllegalStateExceptionSignals that a function has been called at an illegal or inappropriate time
ImmutableA Handle implementation which upon assignment ensures that it will reference an immutable Object
implementsThe implements template specifies a list of interfaces which a class or interface specification derives from
IndexOutOfBoundsExceptionThrown to indicate that an index of some sort (such as to an array, to a string, or to a vector) is out of range
InetAddressInetAddress represents an IP address
InetSocketAddressInetSocketAddress represents an endpoint of a IP socket connection
InFilterFilter which checks whether the result of a method invocation belongs to a predefined set of values
InKeySetFilterFilter that limits the underlying filter evaluation only to the specified set of keys
Integer16An immutable 16-bit integer value
Integer32An immutable 32-bit integer value
Integer64An immutable 64-bit integer value
Integer64MaxCalculates a maximum of numeric values extracted from a set of entries in a Map
Integer64MinCalculates a minimum of numeric values extracted from a set of entries in a Map
Integer64SumSums up numeric values extracted from a set of entries in a Map
interface_specHelper for defining a managed interface
InterruptedExceptionSignals that the current thread has been interrupted
InterruptedIOExceptionSignals that the current thread has been interrupted while blocked on IO
InverseComparatorComparator that reverses the result of another comparator
InvocableThe 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
InvocableMapMap with additional query features
InvocableMap::EntryAn InvocableMap::Entry contains additional information and exposes additional operations that the basic Map::Entry does not
InvocableMap::EntryAggregatorAn EntryAggregator represents processing that can be directed to occur against some subset of the entries in an InvocableMap, resulting in a aggregated result
InvocableMap::EntryProcessorAn invocable agent that operates against the Entry objects within a Map
InvocableMap::ParallelAwareAggregatorA ParallelAwareAggregator is an advanced extension to EntryAggregator that is explicitly capable of being run in parallel, for example in a distributed environment
InvocationServiceThe InvocationService is a Service for delivering executable objects to the cluster member to which the client is connected
IOExceptionSignals that an I/O exception of some sort has occurred
IsNotNullFilterFilter which tests the result of a method invocation for inequality to null
IsNullFilterFilter which compares the result of a method invocation with null
IterableCacheLoaderA CacheLoader that can iterate its underlying contents
IteratorAn object that implements the Iterator interface generates series of Object::Holders, one at a time
KeyAssociatedFilterFilter which limits the scope of another filter according to the key association information
KeyExtractorThe 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
KeyFilterEntryFilter which checks whether an entry key belongs to a set
LessEqualsFilterFilter which compares the result of a method invocation with a value for "Less or Equals" condition
LessFilterFilter which compares the result of a method invocation with a value for "Less" condition
LikeFilterFilter which compares the result of a method invocation with a value for pattern match
LimitFilterFilter which truncates the results of another filter
LinkedListA linked list implementation of List
LinkedList::ListElementListElement is the foundation element for the linked list
LinkedList::SubLinkedListUtility class to implement a SubList of a LinkedList
ListAn ordered collection (also known as a sequence)
ListenersProvides a simple, efficient, and thread-safe implementation of a list of event listeners
ListIteratorAn 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
ListMuteratorMuterator is mutating iterator, that is it is capable of changing the list it iterates
LongArrayAn interface, similar in its methods to List, and similar in its purpose to an array, designed for sparse storage and indexed by long values
LongArrayIteratorA LongArray specific iterator that adds a "current element" concept
ManagedManaged is an adaptor class which transforms a pre-existing class into a Coherence managed Object
MapAn interface for associating key value pairs
Map::EntryA map entry (key-value pair)
MapEventAn event which indicates that the content of a map has changed:
MapEventFilterFilter which evaluates the content of a MapEvent object according to the specified criteria
MapEventTransformerMapEventTransformer interface is used to allow an event consumer to change the content of a MapEvent destined for the corresponding MapListener
MapEventTransformerFilterMapEventTransformerFilter 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
MapKeySetA wrapper class that provides the Set interface for the key set of a map
MapKeySet::KeyConverterConvert a Map::Entry into a Map::Entry::Key
MapListenerThe listener interface for receiving MapEvents
MappedSetSet implementation which is backed by a Map
MapTriggerMapTrigger represents a functional agent that allows to validate, reject or modify mutating operations against an underlying map
MapTrigger::EntryA MapTrigger Entry represents a pending change to an Entry that is about to committed to the underlying Map
MapTriggerListenerMapTriggerListener is a special purpose MapListener implementation that is used to register a MapTrigger on a corresponding ObservableMap
MapValuesCollectionA wrapper class that provides the Collection interface for the value collection of a map
MapValuesCollection::ValueConverterConvert a Map::Entry into a Map::Entry::Key
MemberThe Member interface represents a cluster member
MemberEventAn event which indicates that membership has changed:
MemberHandleMemberHandle is a thread-safe handle used by an Object to reference its non-const child Objects
MemberHolderMemberHolder is a thread-safe handle implementation which supports referencing Objects as either Handles or Views
MemberListenerThe listener interface for receiving MemberEvents
MemberViewMemberView is a thread-safe view intended for use as a data-member within Objects
MultiExtractorComposite ValueExtractor implementation based on an array of extractors
MultiplexingMapListenerA base class that simplifies the implementation of a MapListener by multiplexing all events into a single listener method
MuteratorMuterator is mutating iterator, that is it is capable of changing the collection it iterates
NamedCacheA NamedCache is a Map that holds resources shared among members of a cluster
NeverFilterFilter which always evaluates to false
NoSuchElementExceptionThrown to indicate that a object is not found in the cache/map/collection
NotEqualsFilterFilter which compares the result of a method invocation with a value for inequality
NotFilterProvide for "pluggable" conditional behavior that negates
NullFilterFilter which discards null references
NullImplementationA collection of classes that do nothing
NullPointerExceptionThrown when an application attempts to use NULL in a case where a non-NULL handle to Object is required
NumberInterface implemented by all managed numeric types
NumberIncrementorThe NumberIncrementor entry processor is used to increment a property value of a Number type
NumberMultiplierThe NumberMultiplier entry processor is used to multiply a property value of a Number type
ObjectObject is the base class for all Coherence managed objects
ObjectCountHeapAnalyzerObjectCountHeapAnalyzer provides simple heap analysis based soley on the count of the number of live objects in the system
ObjectCountHeapAnalyzer::SnapshotSnapshot containging the object count
ObservableMapObservableMap interface represents an object with a model being a Map that allows for pluggable notifications for occuring changes
OctetAn immutable 8-bit unsigned value
OctetArrayReadBufferA ReadBuffer on top of an octet array
OctetArrayReadBuffer::OctetArrayBufferInputThis is an implementation of the BufferInput interface on top of a octet array
OctetArrayWriteBufferOctetArrayWriteBuffer is an implementation of WriteBuffer on an octet array
OctetArrayWriteBuffer::OctetArrayBufferOutputOctetArrayBufferOutput is an implementation of BufferOutput optimized for writing to the buffer's underlying octet array
OrFilterFilter which returns the logical "and" of two other filters
OutOfMemoryErrorThrown to indicate that an attempt to allocate an object failed due to resource constraints
ParallelCompositeAggregatorParallelCompositeAggregator 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
ParallelGroupAggregatorThe 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
PofBufferReaderPofReader implementation that reads POF-encoded data from a ReadBuffer::BufferInput
PofBufferWriterPofWriter implementation that writes POF-encoded data to a WriteBuffer::BufferOutput
PofConstantsConstants related to POF streams
PofContextA 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
PofHandlerThis interface defines the handler for an event-driven approach to parsing (or assembling) a POF stream
PofHelperCollection of helper methods for POF streams
PofHelper::ReadableEntrySetMapMap implementation backed by a List of Map.Entry objects
PofHelper::WriteableEntrySetMapImmutable Map implementation backed by a Set of Map::Entry objects
PofReaderThe 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
PofSerializerThe PofSerializer interface provides the capability of reading and writing an object from and to a Portable Object Format (POF) stream
PofWriterThe 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
PortableExceptionA PortableException is an exception that allows information about a remote exception or error to be serialized and deserialized to/from a POF stream
PortableObjectThe PortableObject interface is implemented by classes that can self-serialize and deserialize their state to and from a POF data stream
PortableObjectSerializerA PofSerializer implementation that supports the serialization and deserialization of any class that implements PortableObject to and from a POF stream
PreloadRequestPreloadRequest is a simple EntryProcessor that performs a InvocableMap::Entry::getValue() call
PresentFilterFilter which returns true for InvocableMap::Entry objects that currently exist in a Map
PrimitiveTemplate class which converts primitive data types into immutable managed objects
PrincipalA Principal represents a portion of an overall identity, such as a person, or group
PrincipalPofSerializerPofSerializer implementation that can serialize and deserialize a Principal to/from a POF stream
PriorityAggregatorPriorityAggregator is used to explicitly control the scheduling priority and timeouts for execution of EntryAggregator-based methods
PriorityFilterBase Filter implementation for doing extractor-based processing
PriorityProcessorPriorityProcessor is used to explicitly control the scheduling priority and timeouts for execution of EntryProcessor-based methods
PriorityTaskThe 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
PropertyManipulatorPropertyManipulator is a reflection based ValueManipulator implementation based on the JavaBean property name conventions
PropertyProcessorPropertyProcessor is a base class for EntryProcessor implementations that depend on a ValueManipulator
QueryMapMap with additional query features
QueryMap::EntryA QueryMap::Entry exposes additional index-related operation that the basic Map::Entry does not
QueryMapComparatorThis interface is used by Comparator implementations that can use value extraction optimization exposed by the QueryMap::Entry interface
QueueThe Queue provides a means to efficiently (and in a thread-safe manner) queue received messages and messages to be sent
RandomAn instance of this class is used to generate a stream of pseudorandom numbers
RawDateRaw immutable POF date value
RawDateTimeRaw immutable POF date-time value
RawDayTimeIntervalRaw immutable POF day-time interval value
RawTimeRaw immutable POF time value
RawTimeIntervalRaw immutable POF time interval value
RawYearMonthIntervalRaw POF year-month interval value
ReadBufferThe ReadBuffer interface represents an in-memory block of binary data
ReadBuffer::BufferInputThe BufferInput interface represents a data input stream on top of a ReadBuffer
ReferenceReference provides an additional level of indirection to object instances
ReflectionExtractorReflection-based ValueExtractor implementation
ReflectionUpdaterReflection-based ValueUpdater implementation
RequestTimeoutExceptionSignals that a request execution in a clustered environment did not complete in a pre-determined amount of time
RunAsBlockAllows for easy creation of scoped authorization code blocks based on a Subject
RunnableInterface implemented by any class whose instances are intended to be executed by a thread
RuntimeExceptionRuntimeException is the superclass for exceptions which are not normally handled by user code
SafeComparatorNULL-safe delegating comparator
SafeHashMapAn implementation of coherence::util::Map that is synchronized, but minimally so
SafeHashMap::EntryA map entry (key-value pair)
SafeHashMap::EntrySetA set of entries backed by this map
SafeHashMap::EntrySetIteratorAn Iterator over the EntrySet that is backed by the SafeHashMap
SemiLiteEventTransformerSemiLiteEventTransformer 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
SerializerThe Serializer interface provides the capability of reading and writing an object from and to an in-memory buffer
ServiceA Service is a Controllable that emits service lifecycle events
ServiceThis Service interface represents a controllable service that operates in a clustered network environment
ServiceEventAn event which indicates that a Service state has changed:
ServiceInfoThe ServiceInfo represents information about a Service that operates in a clustered network environment
ServiceListenerThe listener interface for receiving ServiceEvents
SetA collection that contains no duplicate elements
SimpleCacheStatisticsImplementation of the CacheStatistics class intended for use by a cache to maintain its statistics
SmartMemberBase class for smart data-members of managed Objects
SocketAddressSocketAddress interface
SparseArrayA data structure resembling an array keyed by long values
StackTraceElementStackTraceElement interface represents a frame within a stack trace
StringA managed C-style (NUL terminated) string
String::StringHandleStringHandle provides standard TypedHandle feaures as well as auto-boxing support for standard string types including:
SubjectA Subject represents a grouping of related information for a single entity, such as a person
SubjectPofSerializerPofSerializer implementation that can serialize and deserialize a Subject to/from a POF stream
SubListSubList delegates all operations to it's full list while providing a partial view of the list
SubscriptHandleA TypedHandle implementation which supports automatic delegation of the subscript operator
SynchronizedBlockAllows for easy creation of synchronized code blocks based on an Object's monitor
SynchronizedMemberReadBlockAllows for easy creation of synchronized code blocks based on an Object's member level read/write lock
SynchronizedMemberWriteBlockThe SynchronizedMemberBlock class allows for easy creation of synchronized code blocks based on an Object's member level read/write lock
SystemA collection of general purpose utility methods
SystemClassLoaderSystemClassLoader is a ClassLoader implementation based on registration only
SystemPofContextSystem-wide PofContext implementation that allows POF user types to be registered programatically
ThreadAn Object representing a thread of execution
ThreadGateUse 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::CounterCounter is a mutable integer class
ThreadGate::GateBlockThe EnterBlock class allows for easy creation of ThreadGate::enter code
ThreadLocalReferenceThreadLocalReferences provide a means to store a Handle to an Object in thread local storage
throwable_specHelper for defining a throwable managed class
throwable_spec::bridgeBridge joins two hierarchy types into a single type
throwable_spec::hierarchyThe hierarchy class wraps the Coherence C++ Exception classes in a object that preserves their hierarchical structure
ThrowablePofSerializerPofSerializer implementation that can serialize and deserialize an Exception to/from a POF stream
TypedBarrenClassTypedBarrenClass provides a templated extension of Class but does not provide a means to instantiate new instances of the class
TypedClassTypedClass provides a templated implementation of Class
TypedCollectionsA collection of wrapper classes which expose an underlying collection's contents as explicit types rather then just as Objects
TypedCollections::TypedCollectionTyped wrapper over Collection interface
TypedCollections::TypedEntryTyped wrapper over Map::Entry interface
TypedCollections::TypedIteratorTyped wrapper over Iterator interface
TypedCollections::TypedListTyped wrapper over List interface
TypedCollections::TypedListIteratorTyped wrapper over ListIterator interface
TypedCollections::TypedMapTyped wrapper over Map interface
TypedCollections::TypedMap::EntryConverterA converter from untyped to typed entries: Map::Entry -> TypedEntry
TypedCollections::TypedSetTyped wrapper over Set interface
TypedHandleReference counting "smart pointer" class for use with Coherence managed objects
TypedHandle::identity_hash_functorIdentity based hash functor which is compatible with both the SGI and MS style hash containers
TypedHandle::value_equal_functorThe binary functor that compares values pointed by the handles for equality
TypedHandle::value_hash_functorValue based hash functor which is compatible with both the SGI and MS style hash containers
TypedHandle::value_less_functorThe binary functor that compares objects pointed by the handles with the "less-than" operator
TypedHolderA handle implementation which supports referencing Objects as either Handles or Views
TypedSerializerA 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
UnitCalculatorA unit calculator is an object that can calculate the cost of caching an object
UnknownHostExceptionUnknownHostException is thrown as a result of a failed hostname resolution
UnsupportedOperationExceptionThrown to indicate that the requested operation is not supported
UpdaterProcessorUpdaterProcessor is an EntryProcessor implementations that updates an attribute of an object cached in an InvocableMap
UserTypeReaderThe UserTypeReader implementation is a contextually-aware PofReader whose purpose is to advance through the properties of a value of a specified user type
UserTypeWriterThe UserTypeWriter implementation is a contextually-aware PofWriter whose purpose is to write the properties of a value of a specified user type
UTFDataFormatExceptionSignals that a malformed UTF-8 string has been read in a data input stream
ValueChangeEventFilterFilter which evaluates the content of a MapEvent values based on the specified value extractor
ValueExtractorValueExtractor is used to both extract values (for example, for sorting or filtering) from an object, and to provide an identity for that extraction
ValueManipulatorValueManipulator represents a composition of ValueExtractor and ValueManipulator implementations
ValueUpdaterValueUpdater is used to update an object's state
VersionableAn interface for versionable data
VersionedPutVersionedPut 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
VersionedPutAllVersionedPutAll 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
VolatileTemplate class wraps primitive data types with memory barriers, providing JSR-133 style volatiles
WeakHandleWeakHandles are a TypedHandle like wrapper around WeakReferences
WeakHashMapWeakHashMap is a HashMap implementation based on weak keys
WeakHashMap::EntryA map entry (key-value pair)
WeakReferenceWeakReferences allow one Object to safely reference another without blocking it from being destroyed
WeakViewWeakViews are a TypedHandle like wrapper around WeakReferences
WrapperCollectionsA collection of abstract Collection implementation classes for wrapping Collection types
WrapperCollections::AbstractWrapperCollectionCollection implementation which delegates all calls to another Collection
WrapperCollections::AbstractWrapperEntryMap::Entry implementation which delegates all calls to another Map::Entry
WrapperCollections::AbstractWrapperIteratorIterator implementation which delegates all calls to another Iterator
WrapperCollections::AbstractWrapperListList implementation which delegates all calls to another List
WrapperCollections::AbstractWrapperListIteratorListIterator implementation which delegates all calls to another ListIterator
WrapperCollections::AbstractWrapperMapMap implementation which delegates all calls to another Map
WrapperCollections::AbstractWrapperSetSet implementation which delegates all calls to another Set
WrapperStreamFactoryProvides the means to wrap an InputStream and OutputStream, such that functionality such as compression and encryption can be implemented in a layered, pluggable fashion
WriteBufferThe WriteBuffer interface represents an in-memory block of binary data that is being accumulated (written to)
WriteBuffer::BufferOutputThe BufferOutput interface represents a data output stream on top of a WriteBuffer
WritingPofHandlerAn implementation of PofHandler that writes a POF stream to a WriteBuffer using a BufferOutput object
WritingPofHandler::ComplexA Complex object represents the current complex data structure in the POF stream
WritingPofHandler::ComplexMapA ComplexMap object represents a map data structure (with uniform keys or with uniform keys and values) in the POF stream
XmlConfigurableXmlConfigurable interface represents an Object that can be configured by providing configuration information from XML structure
XmlDocumentAn interface for XML document access
XmlElementAn interface for XML element access
XmlValueAn interface for XML element content and element attribute values
XorFilterFilter which returns the logical exclusive or ("xor") of two other filters
Copyright (c) 2000-2008 Oracle. All rights reserved.