| Interface | Description | 
|---|---|
| BackupAwareOperation | 
 A BackupAwareOperation is an Operation to indicate then when a change is made, a
  
BackupOperation is created to replicate the backup. | 
| BackupOperation | 
 When an  
BackupAwareOperation makes a change, the backups need to be replicated to other
 members (depending on the configuration and if change really happened). | 
| Callback<T> | 
 A callback interface; make it possible to receive a callback. 
 | 
| ClientAwareService | 
 A interface that can be implemented by a SPI Service so that it can be notified about client disconnects. 
 | 
| ConfigurableService<T> | 
 A capability for SPI services. 
 | 
| CoreService | 
 Marker interface for core Hazelcast services. 
 | 
| EventFilter | 
 A predicate that can filter out events. 
 | 
| EventPublishingService<E,T> | 
 A service for publishing events. 
 | 
| EventRegistration | 
 The result of a Event Registration. 
 | 
| EventService | 
 Component responsible for handling events like topic events or map.listener events. 
 | 
| ExecutionService | 
 A Service responsible for providing access to 'system' executors and customer executors. 
 | 
| ExecutionTracingService | 
 Service that keeps registry of operations' execution/lifecycle. 
 | 
| InitializingObject | 
 Can be implemented by DistributedObject (proxies) to indicate that they want to be initialized. 
 | 
| InternalCompletableFuture<E> | 
 A  
ICompletableFuture with more functionality like getting
 the result without needing to deal with checked exceptions. | 
| ManagedService | 
 A interface that can be implemented by a SPI Service to receive lifecycle calls:
 
     initialization
     shutdown
     reset
  
 | 
| MembershipAwareService | 
 An interface that can be implemented by a SPI service that needs to be notified members joining and leaving
 the cluster. 
 | 
| MigrationAwareService | 
 An interface that can be implemented by SPI services to get notified of partition changes. 
 | 
| NodeAware | 
 A 'capability' that can be implemented by object to get the Node injected. 
 | 
| NodeEngine | 
 The NodeEngine is the internal heart of a member. 
 | 
| NonThreadSafe | 
 Marker interface for non-thread-safe classes. 
 | 
| Notifier | 
 A component used in wait/notify systems like Condition. 
 | 
| ObjectNamespace | 
 An ObjectNamespace that makes identification of in object within a service possible. 
 | 
| OperationFactory | 
 A Factory for creating  
Operation instances. | 
| OperationService | 
 The OperationService is responsible for executing operations. 
 | 
| PartitionAwareOperation | 
 An interface that can be implemented by an operation to indicate that is should
 be invoked on a particular partition. 
 | 
| PostJoinAwareService | |
| ProxyService | 
 A  
CoreService responsible for managing the DistributedObject proxies. | 
| ReadonlyOperation | 
 Read-only operations are not retried during migration. 
 | 
| RemoteService | 
 An interface that can be implemented by SPI-Services to give them the ability to create proxies to
 distributed objects. 
 | 
| ReplicationSupportingService | 
 An interface that can be implemented by SPI services to give them the ability to listen to
 Replication Events. 
 | 
| ResponseHandler | 
 A handler for the  
OperationService when it has calculated a response. | 
| ServiceConfigurationParser<T> | 
 A hook into the parsing system. 
 | 
| SharedService | 
 A shared service (not clear what the difference is between shared and unshared though). 
 | 
| SplitBrainHandlerService | 
 An interface that can be implemented by SPI services that want to be able to resolve a split brain. 
 | 
| TraceableOperation | 
 Operation which has a traceable identifier 
 | 
| TransactionalService | 
 An interface that can be implemented by SPI services that want to deal with transactions. 
 | 
| UrgentSystemOperation | 
 An Marker interface that signals that an operation is an urgent System Operation. 
 | 
| WaitNotifyKey | 
 A key for a wait notify object e.g. 
 | 
| WaitNotifyService | 
 A service for object where one can wait on, like ICondition or a ILock when a thread needs
 to wait for a lock to be released. 
 | 
| WaitSupport | 
 A interface that can be implemented to participate in the Wait/Notify System. 
 | 
| Class | Description | 
|---|---|
| AbstractDistributedObject<S extends RemoteService> | 
 Abstract DistributedObject implementation. 
 | 
| AbstractOperation | 
 Abstract  
Operation implementation with some basic methods
 implemented. | 
| AbstractWaitNotifyKey | 
 Abstract implementation of the WaitNotifyKey. 
 | 
| DefaultObjectNamespace | 
 Default  
ObjectNamespace implementation. | 
| InvocationBuilder | 
 The InvocationBuilder is responsible for building an invocation of an operation and invoking it. 
 | 
| MemberAttributeServiceEvent | 
 This service event is fired to inform services about a change in a member's attributes collection 
 | 
| MembershipServiceEvent | 
 Membership event fired when a new member is added
 to the cluster and/or when a member leaves the cluster. 
 | 
| Operation | 
 An operation could be compared the a  
Runnable. | 
| OperationAccessor | 
 Allows access to certain attributes on an Operation. 
 | 
| PartitionMigrationEvent | 
 An  
EventObject for a partition migration. | 
| PartitionReplicationEvent | 
 An event send to  
MigrationAwareService when partitions changes happen. | 
| ServiceInfo | 
 Contains the name of the service and the actual service. 
 | 
| Enum | Description | 
|---|---|
| ExceptionAction | 
 The possible actions that can be taken when a certain exception is thrown. 
 | 
Copyright © 2014 Hazelcast, Inc.. All Rights Reserved.