Oracle Coherence for C++ API
Release 3.6.1.0

E18813-01

Oracle Coherence for C++ API Class List

Here are the classes, structs, unions and interfaces with brief descriptions:
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
AbstractEvolvable Abstract base implementation of the Evolvable interface
AbstractExtractor Abstract base for ValueExtractor implementations
AbstractFloat64Aggregator Abstract aggregator that processes numeric values extracted from a set of entries in a Map
AbstractHeapAnalyzer AbstractHeapAnalyzer provides a starting point for writing custom heap analyzers
AbstractInteger64Aggregator Abstract aggregator that processes numeric values extracted from a set of entries in a Map
AbstractInvocable An abstract base for Invocable 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
AbstractUpdater Abstract base for ValueUpdater implementations
AbstractWriteBuffer The AbstractWriteBuffer is a partial implementation of the WriteBuffer interface intended to be used as a base class for easily creating concrete WriteBuffer implementations
AbstractWriteBuffer::AbstractBufferOutput AbstractBufferOutput is a concrete implementation of BufferOutput for the non-concrete AbstractWriteBuffer implementation
adapter_map Adapter_map provides an STL-like "pair associative container" wrapper around coherence::util::Map implementations
adapter_map::hasher Hasher function
adapter_map::key_equal Key equality relation
AddressProvider The AddressProvider is an interface that serves as a means to provide addresses to a consumer
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
CompositeKey Key class that consists of a primary and secondary component
CompositeProcessor The CompositeProcessor represents a collection of entry processors that are invoked sequentially against the same Entry
CompositeUpdater A ValueManipulator implementation based on an extractor-updater pair
ConcurrentMap Map with additional concurrency features
ConcurrentMap::LockBlock The LockBlock allows for easy creation of ConcurrentMap::lock code
ConcurrentModificationException Thrown to indicate that a non-permissible concurrent modification of an object has been detected
ConditionalExtractor An IndexAwareExtractor implementation that is only used to create a coherence::util::ConditionalIndex
ConditionalIndex ConditionalIndex is a conherence::util::MapIndex implementation that uses an associated filter to evaluate whether or not an entry should be indexed
ConditionalProcessor Conditional entry processor represents a processor that is invoked conditionally based on the result of an entry evaluation
ConditionalPut ConditionalPut is an EntryProcessor that performs an InvocableMap::Entry::setValue operation if the specified condition is satisfied
ConditionalPutAll ConditionalPutAll is an EntryProcessor that performs a InvocableMap::Entry::setValue Entry.setValue} operation for multiple entries that satisfy the specified condition
ConditionalRemove ConditionalRemove is an EntryProcessor that performs an InvocableMap::Entry::remove Entry.remove operation if the specified condition is satisfied
ConfigurableAddressProvider ConfigurableAddressProvider is an implementation of the AddressProvider interface based on a static list of addresses configured in an XML element that contains one or more items in the following format:
ConfigurableAddressProvider::AddressHolder A stateful holder for an InetSocketAddress object
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 ObjectArray value returned from a method invocation for containment of any value in a Set
ContainsFilter Filter which tests a Collection or ObjectArray value returned from a method invocation for containment of a given value
ContinuousQueryCache Create a materialized view of a NamedCache using the Coherence Continuous Query capability
ContinuousQueryCache::AsynchronousEvent Encapsulates an event and a listener that are to be dispatched asynchronously
ContinuousQueryCache::TaskDaemon Daemon thread used to dispatch messages asynchronously
Controllable The Controllable interface represents a configurable dameon-like object, quite oftenly referred to as a service, that usually operates on its own thread and has a controllable life cycle
Converter Interface for conversion from one Object type to another one
ConverterCollections A collection of Collection implementation classes that use the Converter interface to convert the items stored in underlying Collection objects
ConverterCollections::ConverterCacheEvent A Converter CacheEvent views an underlying CacheEvent through a set of key and value Converters
ConverterCollections::ConverterCacheMap A ConverterCacheMap views an underlying CacheMap through a set of key and value Converters
ConverterCollections::ConverterCollection A ConverterCollection views an underlying Collection through a Converter
ConverterCollections::ConverterConcurrentMap A Converter ConverterConcurrentMap views an underlying ConcurrentMap through a set of key and value Converters
ConverterCollections::ConverterEntry A ConverterEntry views an underlying Map::Entry through a Converter
ConverterCollections::ConverterInvocableMap A ConverterInvocable views an underlying InvocableMap through a set of key and value Converters
ConverterCollections::ConverterIterator A ConverterIterator views an underlying Iterator through a Converter
ConverterCollections::ConverterMap A ConverterMap views an underlying Map through a Converter
ConverterCollections::ConverterMapEvent A Converter MapEvent views an underlying MapEvent through a set of key and value Converters
ConverterCollections::ConverterMapListener A converter MapListener that converts events of the underlying MapListener for the underlying map
ConverterCollections::ConverterNamedCache A ConverterNamedCache views an underlying NamedCache through a set of key and value Converters
ConverterCollections::ConverterObservableMap A Converter ObservableMap views an underlying ObservableMap through a set of key and value Converters
ConverterCollections::ConverterQueryMap A Converter QueryMap views an underlying QueryMap through a set of key and value Converters
ConverterCollections::ConverterSet A ConverterSet views an underlying Set through a Converter
ConverterCollections::EntryConverter Map::Entry Converter, supporting key and value conversion
ConverterCollections::UnsupportedConverter Converter which always throws an UnsupportedOperationException
Count Calculates a number of values in an entry set
DefaultConfigurableCacheFactory DefaultConfigurableCacheFactory provides a facility to access caches declared in a "cache-config.dtd" compliant configuration file
DefaultConfigurableCacheFactory::CacheInfo CacheInfo is a placeholder for cache attributes retrieved during parsing the corresponding cache mapping element
DefaultIdentityAsserter The default implementation of the IdentityAsserter interface
DefaultIdentityTransformer The default implementation of the IdentityTransformer interface, which simply returns the Subject that is passed to it
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
Enumeration An object that implements the Enumeration interface generates a series of elements, one at a time
EOFException Signals that an end of file or stream has been reached unexpectedly during input
EqualsFilter Filter which compares the result of a method invocation with a value for equality
Event The root class from which all event state classes shall be derived
EventListener A tag interface that all event listener interfaces must extend
EventObject The root class from which all event state objects shall be derived
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
IndexAwareExtractor IndexAwareExtractor is an extension to the ValueExtractor interface that supports the creation and destruction of an MapIndex index
IndexAwareFilter IndexAwareFilter is an extension to the EntryFilter interface that allows a filter to use a Map index to fully or partially evaluate itself
IndexOutOfBoundsException Thrown to indicate that an index of some sort (such as to an array, to a string, or to a vector) is out of range
InetAddress InetAddress represents an IP address
InetSocketAddress InetSocketAddress represents an endpoint of a IP socket connection
InFilter Filter which checks whether the result of a method invocation belongs to a predefined set of values
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
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
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 PriorityFilter is used to explicitly control the scheduling priority and timeouts for execution of filter-based methods
PriorityProcessor PriorityProcessor is used to explicitly control the scheduling priority and timeouts for execution of EntryProcessor-based methods
PriorityTask The PriorityTask interface allows to control the ordering in which a service schedules tasks for execution using a thread pool and limit their execution times to a specified duration
PropertyManipulator PropertyManipulator is a reflection based ValueManipulator implementation based on the JavaBean property name conventions
PropertyProcessor PropertyProcessor is a base class for EntryProcessor implementations that depend on a ValueManipulator
QueryMap Map with additional query features
QueryMap::Entry A QueryMap::Entry exposes additional index-related operation that the basic Map::Entry does not
QueryMapComparator This interface is used by Comparator implementations that can use value extraction optimization exposed by the QueryMap::Entry interface
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
ReferenceLibrary A "library" of object references and their corresponding identities in the POF stream
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
SimpleMapIndex SimpleMapIndex is a MapIndex implementation used to correlate property values extracted from resource map entries with corresponding keys using what is commonly known as an Inverted Index algorithm
SimplePofContext Basic PofContext implementation
SimplePofPath A static PofNavigator implementation which uses an array of integer indices to navigate the PofValue hierarchy
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
Copyright © 2000, 2010, Oracle and/or its affiliates. All rights reserved.