| Interface | Description | 
|---|---|
| Action | 
 An Action represents a controllable action or behavior that a Service might
 perform. 
 | 
| ActionPolicy | 
 ActionPolicy defines which aspects of a Service's behavior are currently
 allowed. 
 | 
| AddressProvider | 
 The AddressProvider is a subclass interface of  
SocketAddressProvider
 which returns InetSocketAddress from AddressProvider.getNextAddress(). | 
| AddressProviderFactory | 
 A factory for  
AddressProvider objects. | 
| AsyncNamedCache<K,V> | 
 Asynchronous  
NamedCache. | 
| AsyncNamedCache.Option | 
 An immutable option for creating and configuring  
AsyncNamedCaches. | 
| BackingMapContext | 
 The BackingMapContext provides an execution context to server side agents such
 as  
EntryProcessors and
 EntryAggregators. | 
| BackingMapManager | 
 A callback interface used by CacheService implementations. 
 | 
| BackingMapManagerContext | 
 The BackingMapManager context is used by the CacheService to pass information
 to the BackingMapManager during the service initialization. 
 | 
| CacheFactoryBuilder | 
 CacheFactoryBuilder provides the means for building and managing configurable
 cache factories across class loaders in a pluggable fashion. 
 | 
| CacheProvider | Deprecated | 
| CacheService | 
 A CacheService is a clustered service providing a collection of named Maps
 that hold resources shared among members of a cluster. 
 | 
| CacheService.CacheAction | 
 CacheAction represents a type of action taken by a CacheService. 
 | 
| Cluster | 
 The Cluster interface represents a collection of
 services that operate in a clustered network environment. 
 | 
| Cluster.MemberTimeoutAction | 
 MemberTimeoutAction is taken by the cluster service to remove members from
 the cluster who have exceeded a network timeout (e.g. packet-timeout). 
 | 
| ClusterDependencies | 
 The ClusterDependencies interface defines externally provided dependencies
 for a  
Cluster. | 
| ConfigurableCacheFactory | 
 An interface for cache factory. 
 | 
| DatagramSocketProvider | 
 DatagramSocketProivder defines an interface for creating datagram and multicast
 sockets. 
 | 
| DescribableAddressProvider | 
 An AddressProvider that additionally allows to retrieve a human readable
 description of underlying addresses without doing a DNS lookup. 
 | 
| DistributedCacheService | 
 A DistributedCacheService is a clustered cache service that partitions its
 data across cluster members that provide backing storage. 
 | 
| ExtensibleConfigurableCacheFactory.Dependencies | |
| FederatedCacheService | 
 A FederatedCacheService is a distributed cache service that also replicates
 data to other clusters/participants in the Federation. 
 | 
| FlowControl | 
 Communication facilities that provide an asynchronous (non-blocking) way
 of submitting data exchange requests commonly implement mechanisms of
 modulating the control flow for underlying data transfer units
 (e.g. messages or packets). 
 | 
| Guardable | 
 A Guardable is a logical execution unit whose lifetime may be guarded by a
 Guardian. 
 | 
| Guardian | 
 A Guardian is responsible for monitoring the registered  
Guardable
 objects. | 
| Guardian.GuardContext | 
 A GuardContext represents the lifecycle status of a Guardable. 
 | 
| 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. 
 | 
| InvocableInOrder | 
 The InvocableInOrder interface allows to control the ordering in which
 the results of Invocable tasks are returned back to the caller by the
 Invocation service with a thread pool. 
 | 
| InvocationObserver | 
 The InvocationObserver is an object that asynchronously receives 
 notification of results from the execution of Invocable objects. 
 | 
| InvocationService | 
 The InvocationService is a Service for delivering executable objects to
 cluster members for distributed invocation. 
 | 
| Member | 
 The Member interface represents a cluster member. 
 | 
| MemberIdentity | 
 The MemberIdentity interface represents the identity of a cluster member. 
 | 
| MemberListener | 
 The listener interface for receiving MemberEvents. 
 | 
| NamedCache<K,V> | 
 A Map-based data-structure that manages entries across one or more processes. 
 | 
| NamedCache.Option | 
 An immutable option for requesting and configuring  
NamedCaches. | 
| NamedCollection | 
 NamedCollection defines a common base interface for various named collection types. 
 | 
| NamedCollection.Option | 
 The Option interface defines the root interface of all NamedCollection Options. 
 | 
| NameService | 
 A NameService is a service that accepts connections from external clients
 (e.g. 
 | 
| NameService.LookupCallback | 
 An object which implements  
NameService.LookupCallback can be registered
 with a NameService via NameService.addLookupCallback(com.tangosol.net.NameService.LookupCallback) to
 perform a lookup on names that were not found in the NameService's directory. | 
| NameService.RequestContext | 
 An object which implements  
NameService.RequestContext stores information about the NameService request. | 
| NameService.Resolvable | 
 During the  
lookup call, if the retrieved
 object is NameService.Resolvable, then the result of the resolve
 call is returned. | 
| NonBlockingInvocable | 
 NonBlockingInvocable is an  
Invocable that can be executed asynchronously. | 
| OperationalContext | 
 OperationalContext is an interface for providing Oracle Coherence
 operational configuration. 
 | 
| PartitionedService | 
 A PartitionedService is aware of a mapping of keys to partitions and of
 partitions to cluster members. 
 | 
| PartitionedService.PartitionedAction | 
 PartitionedAction represents a type of action taken by a
 PartitionedService. 
 | 
| PasswordProvider | 
 PasswordProvider allows Coherence users to plugin their own mechanism to determine the appropriate password. 
 | 
| 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. 
 | 
| ProxyService | 
 A ProxyService is a clustered service that accepts connections from
 external clients (e.g. 
 | 
| ProxyService.ProxyAction | 
 ProxyAction represents a type of action taken by a ProxyService. 
 | 
| Releasable | 
 A resource that is activated and then at a later time be released. 
 | 
| ScopeResolver | 
 This interface is used to derive a scope name used to create an instance
 of  
ConfigurableCacheFactory. | 
| Service | 
 This Service interface represents a controllable service that operates in a
 clustered network environment. 
 | 
| Service.MemberJoinAction | 
 MemberJoinAction is taken to allow a new member to join a clustered
 Service. 
 | 
| ServiceDependencies | 
 The ServiceDependencies interface defines externally provided dependencies
 for  
clustered services. | 
| ServiceFailurePolicy | 
 ServiceFailurePolicy is used to control how a Guardable associated with a
 service is managed by its Guardian after the configured timeout. 
 | 
| ServiceInfo | 
 The ServiceInfo represents information about a Service that
 operates in a clustered network environment. 
 | 
| ServiceLoad | 
 A ServiceLoad encapsulates information about the current utilization
 of a Service. 
 | 
| ServiceLoadBalancer<S extends Service,T extends ServiceLoad> | 
 A ServiceLoadBalancer is a pluggable strategy for controlling the
 client load across individual members of a clustered Service. 
 | 
| ServiceMonitor | 
 The  
ServiceMonitor is a facility that keeps registered services
 alive. | 
| Session | 
 A thread-safe mechanism to request Coherence-based resources, like
  
NamedCaches, from a deployed module. | 
| Session.Option | 
 An immutable option for creating and configuring  
Sessions. | 
| SessionProvider | 
 Creates  
Sessions for use by applications requiring Coherence-based
 resources, including NamedCaches, often for specific
 ClassLoaders, for deployed modules. | 
| SessionProvider.Option | 
 An immutable option for creating and configuring  
SessionProviders. | 
| SocketAddressProvider | 
 The SocketAddressProvider is an interface that serves as a means to provide
 addresses to a consumer. 
 | 
| SocketProvider | 
 SocketProvider defines an abstraction for creating various types of sockets. 
 | 
| SocketProviderFactory.Dependencies | 
 Dependencies specifies all dependency requirements of the SocketProviderFactory. 
 | 
| TcpDatagramSocketProvider.Dependencies | 
 Dependencies specifies all dependency requirements of the TcpDatagramSocketProvider. 
 | 
| ThreadPoolManager | 
 A ThreadPoolManager manages the thread pool information for a Coherence
 service thread pool. 
 | 
| ThreadPoolSizingStrategy | 
 A ThreadPoolSizingStrategy is a pluggable strategy used by a
 Coherence service thread pool to manage its size. 
 | 
| ValueTypeAssertion<V> | 
 Defines a  
NamedTopic.Option for asserting the type
 of values used with a NamedTopic. | 
| Class | Description | 
|---|---|
| AbstractBackingMapManager | 
 Abstract base of the BackingMapManager implementations. 
 | 
| AbstractInvocable | 
 An abstract base for Invocable and PriorityTask implementations. 
 | 
| AbstractPriorityTask | 
 An abstract base for PriorityTask implementations. 
 | 
| AbstractServiceLoadBalancer<S extends Service,T extends ServiceLoad> | 
 An abstract base for ServiceLoadBalancer implementations. 
 | 
| AsyncNamedCache.OrderBy | 
 A configuration option which determines the ordering of async operations. 
 | 
| CacheFactory | 
 Factory for the Coherence™ cache product. 
 | 
| ClusterPermission | 
 This class represents access to a clustered resource such as a Service
 or NamedCache. 
 | 
| CoherenceSession | 
 An implementation of a  
Session allowing applications to use
 the new operator to create a Session via the default
 SessionProvider. | 
| CompositeActionPolicy | 
 CompositeActionPolicy represents the "intersection" of two policies. 
 | 
| CompositeAddressProvider | 
 CompositeAddressProvider is a composite of one or more AddressProviders or
 addresses that also implements the Set interface. 
 | 
| CompositeAddressProvider.AddressIterator | 
 An Iterator over the addresses in this AddressProvider. 
 | 
| CompositeSocketAddressProvider | 
 CompositeSocketAddressProvider is a composite of one or more
 SocketAddressProviders. 
 | 
| CompressionFilter | Deprecated
 As of Coherence 3.7 
 | 
| CompressionFilter.DeflaterOutputShell | 
 DeflaterOutputShell enforces the "end" call for the
 corresponding Deflater object. 
 | 
| CompressionFilter.InflaterInputShell | 
 InflaterInputShell enforces the "end" call for the
 corresponding Inflater object. 
 | 
| 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:
 
 <socket-address>
   <address>... 
 | 
| ConfigurableAddressProvider.AddressHolder | 
 A stateful holder for an obtaining an InetSocketAddress object. 
 | 
| ConfigurableAddressProviderFactory | Deprecated | 
| ConfigurableLocalAddressProvider | 
 ConfigurableLocalAddressProvider is an AddressProvider which is only
 capable of returning local addresses. 
 | 
| ConfigurableQuorumPolicy | 
 ConfigurableQuorumPolicy provides a Quorum-based  
ActionPolicy for
 services based on the cluster-configuration. | 
| ConfigurableQuorumPolicy.ClusterQuorumPolicy | 
 ClusterQuorumPolicy defines an action policy that is applicable to the
 cluster. 
 | 
| ConfigurableQuorumPolicy.MembershipQuorumPolicy | 
 MembershipQuorumPolicy is a quorum policy that is stateless and based
 solely on service membership sizes. 
 | 
| ConfigurableQuorumPolicy.MembershipQuorumPolicy.QuorumRule | 
 A quorum rule defines a set of allowable actions beyond the rule's
 threshold size. 
 | 
| ConfigurableQuorumPolicy.PartitionedCacheQuorumPolicy | 
 PartitionedCacheQuorumPolicy defines a configurable quorum policy that is
 applicable to a DistributedCacheService. 
 | 
| ConfigurableQuorumPolicy.PartitionedCacheQuorumPolicy.Notification | 
 Notification is a simple struct carrying the notification info. 
 | 
| ConfigurableQuorumPolicy.ProxyQuorumPolicy | 
 ProxyQuorumPolicy defines a configurable quorum policy that is applicable
 to a proxy service. 
 | 
| DatagramPacketOutputStream | 
 Provides an OutputStream on top of a DatagramPacket. 
 | 
| DefaultCacheFactoryBuilder | 
DefaultCacheFactoryBuilder is the default implementation of CacheFactoryBuilder. | 
| DefaultCacheServer | 
 DefaultCacheServer is a simple command line facility and convenience API
 that starts all services that are declared as requiring an "autostart" in
 the configurable factory XML descriptor. 
 | 
| DefaultCacheServer.GarServer | 
 GarServer provides the functionality of DefaultCacheServer under the
 context of a GAR file. 
 | 
| DefaultCacheServer.SimpleContext | 
 Simple ContainerContext implementation. 
 | 
| DefaultConfigurableCacheFactory | Deprecated | 
| DefaultConfigurableCacheFactory.CacheInfo | 
 CacheInfo is a placeholder for cache attributes retrieved during parsing
 the corresponding cache mapping element. 
 | 
| ExtensibleConfigurableCacheFactory | 
 ExtensibleConfigurableCacheFactory provides a facility to access caches
 declared in a "coherence-cache-config.xsd" compliant configuration file. 
 | 
| ExtensibleConfigurableCacheFactory.DefaultDependencies | 
 The  
ExtensibleConfigurableCacheFactory.DefaultDependencies is a simple implementation of
 the ExtensibleConfigurableCacheFactory ExtensibleConfigurableCacheFactory.Dependencies
 interface. | 
| ExtensibleConfigurableCacheFactory.DependenciesHelper | 
 The  
ExtensibleConfigurableCacheFactory.DependenciesHelper provides helper method for constructing
 ExtensibleConfigurableCacheFactory.Dependencies implementations for ExtensibleConfigurableCacheFactorys. | 
| ExtensibleConfigurableCacheFactory.Manager | 
 The Manager class uses builders to create the required backing maps
 and provides client access to those maps. 
 | 
| ExtensibleConfigurableCacheFactory.PartitionedBackingMapManager | 
 The PartitionedBackingMapManager is used by PartitionAwareBackingMap(s) to
 lazily configure the enclosing PABM based on the configuration settings of
 the enclosed maps. 
 | 
| GuardSupport | 
 A concrete implementation of Guardian/Guardable interactions. 
 | 
| InetAddressHelper | 
 Helper class that encapsulates common InetAddress functionality. 
 | 
| InetAddressHelper.RoutableFilter | 
 The RoutableFilter evaluates to true for any InetAddress which is
 externally routable. 
 | 
| InetAddressHelper.SubnetMaskFilter | 
 SubnetMaskFilter evaluates to true for any address with matches the
 pattern for the masked bits 
 | 
| LoadBalancer | 
 A non-sticky HTTP load-balancer. 
 | 
| LoadBalancer.AddressPort | 
 An AddressPort is an immutable combination of an IP address and a port
 number. 
 | 
| LoadBalancer.Queue | 
 A Queue is used to effeciently queue up items for daemon threads to
 work on. 
 | 
| LoadBalancer.SocketHandler | 
 A SocketHandler is an abstract daemon thread. 
 | 
| MemberEvent | 
 An event which indicates that membership has changed:
 
 a Member has joined
 a Member is leaving
 a Member has left
 
 A MemberEvent object is sent as an argument to the MemberListener
 interface methods. 
 | 
| NonBlockingTcpDatagramSocket | 
 TCP based non-blocking datagram socket implementation. 
 | 
| NonBlockingTcpDatagramSocket.Impl | 
 A specialization of  
TcpDatagramSocket.Impl which provides
 non-blocking functionality, see NonBlockingTcpDatagramSocket.Impl.send(DatagramPacket). | 
| PartitionedService.PartitionRecoveryAction | 
 A PartitionedAction representing the recovery of orphaned partitions from
 the persistent storage, or the assignment of empty partitions if the
 persistent storage is unavailable or lost. 
 | 
| Ping | 
 Ping is a simple utility for testing if a machine is reachable. 
 | 
| RefreshableAddressProvider | 
 A RefreshableAddressProvider is an AddressProvider implementation 
 that wraps another AddressProvider and refresh the address list of 
 the provider asynchronously. 
 | 
| ScopedCacheFactoryBuilder | 
 Implementation of  
CacheFactoryBuilder that manages multiple
 instances of ConfigurableCacheFactory. | 
| SimpleServiceLoadBalancer<S extends Service,T extends ServiceLoad> | 
 A simple ServiceLoadBalancer implementation. 
 | 
| SimpleServiceMonitor | 
 The  
SimpleServiceMonitor starts and monitors services that are
 registered for monitoring. | 
| SingletonCacheFactoryBuilder | 
 Implementation of  
CacheFactoryBuilder that maintains a single
 ConfigurableCacheFactory instance regardless of the requesting
 ClassLoader if a URI is not provided. | 
| SocketOptions | 
 SocketOptions provides a means to configure the various aspects of Sockets. 
 | 
| SocketProviderFactory | 
 The SocketProviderFactory produces SocketProviders. 
 | 
| SocketProviderFactory.DefaultDependencies | 
 DefaultDependencies is a basic implementation of the Dependencies
 interface. 
 | 
| SystemDatagramSocketProvider | 
 SystemDatagramSocketProvider produces JVM default datagram sockets 
 | 
| TcpDatagramSocket | 
 TCP based datagram socket implementation. 
 | 
| TcpDatagramSocket.Impl | 
 A specialized version of  
DatagramSocketImpl. | 
| TcpDatagramSocketProvider | 
 TcpDatagramSocketProvider produces datagram sockets that uses
 TCP sockets underneath for unicast communication. 
 | 
| TcpDatagramSocketProvider.DefaultDependencies | 
 DefaultDependenceis is a basic implementation of the Dependencies
 interface providing "setter" methods for each property. 
 | 
| ValueTypeAssertion.WithValueTypeAssertion<V> | 
 Defines a  
NamedTopic.Option for asserting the type
 of values used with a NamedTopic. | 
| ViewBuilder<K,V> | 
 The  
ViewBuilder provides a means to ViewBuilder.build() a view (ContinuousQueryCache)
 using a fluent pattern / style. | 
| WrapperCacheService | 
 CacheService implementation that delegates to a wrapped CacheService
 instance. 
 | 
| WrapperInvocationService | 
 InvocationService implementation that delegates to a wrapped
 InvocationService instance. 
 | 
| WrapperService | 
 Service implementation that delegates to a wrapped Service instance. 
 | 
| Enum | Description | 
|---|---|
| ConfigurableQuorumPolicy.PartitionedCacheQuorumPolicy.ActionRule | 
 Action Rules for  
ConfigurableQuorumPolicy.PartitionedCacheQuorumPolicy | 
| SocketProviderFactory.Dependencies.ProviderType | 
 Enumeration of Provider types. 
 | 
| Exception | Description | 
|---|---|
| ClusterException | Deprecated
 As of release 3.4, replaced by
              
PortableException | 
| RequestIncompleteException | 
 Signals that a request execution in a distributed environment failed to
 complete successfully. 
 | 
| RequestPolicyException | 
 Signals that a request was not allowed to complete due to the related service
 action being disallowed by the corresponding ActionPolicy. 
 | 
| RequestTimeoutException | 
 Signals that a request execution in a distributed environment did not
 complete in a pre-determined amount of time. 
 | 
| ServiceStoppedException | 
 Signals that a request was not able to execute because the underlying service
 has been stopped. 
 |