All Classes and Interfaces (Apache Geode 2.0.2)
Description: class index

# All Classes and Interfaces

Class
Description
AbstractCache
AbstractCacheLifecycleListener
AbstractCommitSessionValve<SelfT extends AbstractCommitSessionValve<?>>
AbstractConfiguration<R extends RuntimeInfo>
This class represents either a configuration or a filter.
AbstractGatewayDeltaEvent
AbstractLauncher<T extends Comparable<T>>
The AbstractLauncher class is a base class for implementing various launchers to construct and run different GemFire processes, like Cache Servers, Locators, Managers, HTTP servers and so on.
AbstractLauncher.ServiceState<T extends Comparable<T>>
The ServiceState is an immutable type representing the state of the specified Locator at any given moment in time.
AbstractLauncher.Status
The Status enumerated type represents the various lifecycle states of a GemFire service (such as a Cache Server, a Locator or a Manager).
AbstractSessionCache
AccessControl
Deprecated.
since Geode 1.0, use `SecurityManager` instead
AdminConfig
Deprecated.
as of 7.0 use the `management` package instead
AdminConfig.Entry
AdminDistributedSystem
Deprecated.
as of 7.0 use the `management` package instead
AdminDistributedSystemFactory
Deprecated.
as of 7.0 use the `management` package instead
AdminException
Deprecated.
as of 7.0 use the `management` package instead
AdminXmlException
Deprecated.
as of 7.0 use the `management` package instead
Agent
Deprecated.
as of 7.0 use the `management` package instead
AgentConfig
Deprecated.
as of 7.0 use the `management` package instead
AgentFactory
Deprecated.
as of 7.0 use the `management` package instead
Aggregator
Behavior of a user-defined aggregator.
Alert
Deprecated.
as of 7.0 use the `management` package instead
AlertLevel
Deprecated.
as of 7.0 use the `management` package instead
AlertListener
Deprecated.
as of 7.0 use the `management` package instead
AllConnectionsInUseException
Indicates that the connection pool is at its maximum size and all connections are in use.
AlreadyRunningException
Indicates that a request to start a management service failed because it was already running.
AmbiguousNameException
Thrown if an attribute or method name in a query can be resolved to more than one object in scope or if there is more than one maximally specific overridden method in a class.
Argument
Class representing a single command line argument.
ArgumentHandler
Interface specifying the requirements for objects wiching to be able to examine arguments (potentially tweaking parameters) at the time of parsing, thereby allowing for usage display to occur automatically.
ArgumentProcessor
This class is used to process command line arguments for Java programs in a flexible and powerful manner.
ArgumentValues
Result object capturing the result of processing command line arguments.
AsyncEvent<K,V>
Represents `Cache` events delivered to `AsyncEventListener`.
AsyncEventListener
A callback for events passing through the `AsyncEventQueue` to which this listener is attached.
AsyncEventQueue
Interface of AsyncEventQueue.
AsyncEventQueueFactory
Factory to create the `AsyncEventQueue`.
AsyncEventQueueMXBean
MBean that provides access to an `AsyncEventQueue`.
AttachAPINotFoundException
The AttachAPINotFoundException class is a RuntimeException indicating that the JDK tools.jar has not been properly set on the user's classpath
AttributesFactory<K,V>
Deprecated.
as of 6.5 use `Cache.createRegionFactory(RegionShortcut)` or `ClientCache.createClientRegionFactory(ClientRegionShortcut)` instead.
AttributesMutator<K,V>
Supports modification of certain region attributes after the region has been created.
AuthenticationExpiredException
This exception is thrown by the SecurityManager's authorize method to indicate that the authentication has expired.
AuthenticationFailedException
Thrown if authentication of this client/peer fails.
AuthenticationRequiredException
Thrown if the distributed system is in secure mode and this client/peer has not set the security credentials.
Authenticator
Deprecated.
since Geode 1.0, use `SecurityManager` instead
AuthInitialize
Specifies the mechanism to obtain credentials for a client or peer.
AuthTokenEnabledComponents
AutoBalancer
Re-balancing operation relocates data from heavily loaded members to lightly loaded members.
AutoSerializer
The configuration of a org.apache.geode.pdx.ReflectionBasedAutoSerializer found in the geode-core module that is used for easy PDX serialization.
BackupStatus
Deprecated.
as of 7.0 use the `management` package instead
BackupStatus
The status of a backup operation.
Banner
BootstrappingFunction
Cache
Caches are obtained from the `CacheFactory.create()` method.
CacheCallback
User-defined objects that can be plugged into caching to receive callback notifications.
CacheClosedException
Indicates that the caching system has been closed.
CacheConfig
Java class for anonymous complex type.
CacheConfig.AsyncEventQueue
Java class for anonymous complex type.
CacheConfig.CacheServer
Java class for anonymous complex type.
CacheConfig.GatewayHub
Java class for anonymous complex type.
CacheConfig.GatewayHub.Gateway
Java class for anonymous complex type.
CacheConfig.GatewayHub.Gateway.GatewayEndpoint
Java class for anonymous complex type.
CacheConfig.GatewayHub.Gateway.GatewayQueue
Java class for anonymous complex type.
CacheConfig.GatewaySender
Java class for anonymous complex type.
CacheDoesNotExistException
Deprecated.
as of 7.0 use the `management` package instead
CacheElement
CacheEvent<K,V>
A region- or entry-related event affecting the cache.
CacheException
A generic exception, which indicates a cache error has occurred.
CacheExistsException
Thrown when attempting to create a `Cache` if one already exists.
CacheFactory
Factory class used to create the singleton `cache` and connect to the GemFire singleton `distributed system`.
CacheHealthConfig
Deprecated.
as of 7.0 use the `management` package instead
CacheListener<K,V>
A listener to handle region or entry related events.
CacheListenerAdapter<K,V>
Utility class that implements all methods in `CacheListener` with empty implementations.
CacheLoader<K,V>
Allows data from outside of the VM to be placed into a region.
CacheLoaderException
Thrown from the `CacheLoader.load(org.apache.geode.cache.LoaderHelper<K, V>)` method indicating that an error occurred when a CacheLoader was attempting to load a value.
CacheRuntimeException
A generic runtime exception that indicates a cache error has occurred.
CacheServer
Deprecated.
as of 5.7 use `CacheVm` instead.
CacheServer
A cache server that serves the contents of a `Cache` to client VMs in another distributed system via a socket.
CacheServerConfig
Deprecated.
as of 5.7 use `CacheVmConfig` instead.
CacheServerInfo
CacheServerMXBean
MBean that provides access to information and management functionality for a `CacheServer`.
CacheSnapshotService
Allows a snapshot of cache data to be imported and exported.
CacheStatistics
Defines common statistics information for both region and entries.
CacheTransactionManager
The CacheTransactionManager interface allows applications to manage transactions on a per `Cache` basis.
CacheTransactionManagerType
A "cache-transaction-manager" element allows insertion of cache-level transaction listeners.
CacheVm
Deprecated.
as of 7.0 use the `management` package instead
CacheVmConfig
Deprecated.
as of 7.0 use the `management` package instead
CacheWriter<K,V>
A user-defined object defined in the `RegionAttributes` that is called synchronously before a region or entry in the cache is modified.
CacheWriterAdapter<K,V>
Utility class that implements all methods in `CacheWriter` with empty implementations.
CacheWriterException
An exception thrown by a `CacheWriter` method.
CacheXmlException
Thrown when a problem is encountered while parsing a declarative caching XML file.
CancelCriterion
Abstract cancellation proxy for cancelling an operation, esp.
CancelException
Abstract root class of all GemFire exceptions representing system cancellation
CanonicalInstantiator
`CanonicalInstantiator` is much like its parent `Instantiator` except that instead of needing to implement `newInstance()` you now must implement `newInstance(DataInput)`.
ClassLoaderObjectInputStream
This class is used when session attributes need to be reconstructed with a new classloader.
ClassName
Used to configure an attribute that represents an instance of a java class.
ClassNameType
Java class for anonymous complex type.
ClientCache
A ClientCache instance controls the life cycle of the local singleton cache in a client.
ClientCacheFactory
Factory class used to create the singleton `client cache` and connect to one or more GemFire Cache Servers.
ClientHealthStatus
Composite data type used to distribute statistics which can be used to determine the health of a cache client.
ClientMembership
Provides utility methods for registering and unregistering ClientMembershipListeners in this process.
ClientMembershipEvent
An event delivered to a `ClientMembershipListener` when this process detects connection changes to ClientServers or clients.
ClientMembershipListener
A listener whose callback methods are invoked when this process detects connection changes to CacheServers or clients.
ClientMembershipListenerAdapter
Utility class that implements all methods in `ClientMembershipListener` with empty implementations.
ClientNotReadyException
Deprecated.
as of 6.5 this exception is no longer thrown by GemFire so any code that catches it should be removed.
ClientQueueDetail
ClientRegionFactory<K,V>
A factory for constructing `client cache` `regions`.
ClientRegionShortcut
Each enum represents a predefined `RegionAttributes` in a `ClientCache`.
ClientServerCache
This is a singleton class which maintains configuration properties as well as starting a Client-Server cache.
ClientServerCacheLifecycleListener
ClientServerSessionCache
ClientSession
Class `ClientSession` represents a client connection on the server.
ClientSocketFactory
Interface `ClientSocketFactory` is used to create non-default client sockets.
ClientSubscriptionConfig
Used to configure queuing on a cache server for client subscriptions.
CliFunction<T>
An abstract function implementation to be extended by cli functions.
CliMetaData
An annotation to define additional meta-data for commands.
CliMetaData.AvailabilityMetadata
Deprecated.
since Geode1.2, not used at all
CloseCQOperationContext
Deprecated.
since Geode1.0, use `ResourcePermission` instead
ClusterManagementException
Base class of all exceptions thrown by `ClusterManagementService` implementations.
ClusterManagementGetResult<T extends AbstractConfiguration<R>,R extends RuntimeInfo>
ClusterManagementListOperationsResult<A extends ClusterManagementOperation<V>,V extends OperationResult>
returned from `ClusterManagementService.list(ClusterManagementOperation)`
ClusterManagementListResult<T extends AbstractConfiguration<R>,R extends RuntimeInfo>
ClusterManagementOperation<V extends OperationResult>
Interface for cluster management operations that can be used with `ClusterManagementService.start(ClusterManagementOperation)` Classes implementing this interface should hold only the parameters for the operation.
ClusterManagementOperationResult<A extends ClusterManagementOperation<V>,V extends OperationResult>
Returned by `ClusterManagementService.start(ClusterManagementOperation)` to convey status of launching the async operation, and by `ClusterManagementService.get(ClusterManagementOperation, String)` to describe the status of a started async operation.
ClusterManagementRealizationException
Thrown by `ClusterManagementService.create(AbstractConfiguration)`, update, and delete operations which have a possibility of "partial" failure.
ClusterManagementRealizationResult
ClusterManagementResult
This base class provides the common attributes returned from all `ClusterManagementService` methods
ClusterManagementResult.StatusCode
these status codes generally have a one-to-one mapping to the http status code returned by the REST controller
ClusterManagementService
Implementations of this interface are responsible for applying and persisting cache configuration changes.
ClusterManagementServiceBuilder
This builder facilitates creating a ClusterManagementService using either (or both) a `ConnectionConfig` or a `ClusterManagementServiceTransport`.
ClusterManagementServiceTransport
Interface which abstracts the transport between the CMS client and the endpoint.
CollectionType
Represents the type of a collection, an object that can contain element objects.
CommandProcessingException
Indicates that an exception occurred while processing a GemFire Command Line Interface (CLI) command.
CommandService
Deprecated.
since 1.3 use OnlineCommandProcessor directly
CommandServiceException
Indicates that an exception occurred while accessing/creating a Command Service for processing GemFire Command Line Interface (CLI) commands.
CommandStatement
Deprecated.
since Geode 1.3.
CommandType
Commands used by `ClusterManagementServiceTransport` which mimic HTTP verbs.
CommitConflictException
Thrown when a commit fails due to a write conflict.
CommitDistributionException
Indicates that an attempt to notify required participants of a transaction involving one or more regions that are configured with `MembershipAttributes` may have failed.
CommitIncompleteException
Thrown when a commit fails to complete due to errors
CompressionException
Wraps specific compression errors for `compressors`.
Compressor
Interface for a compression codec.
ConfigurationParameter
Deprecated.
as of 7.0 use the `management` package instead
ConfigurationPersistenceService
ConfigurationProperties
This interface defines all the configuration properties that can be used.
ConflictingPersistentDataException
Thrown when a member with persistence is recovering, and it discovers that the data it has on disk was never part of the same distributed system as the members that are currently online.
ConnectionConfig
Concrete implementation of `ConnectionConfig` which can be used where the various connection properties should be set directly as opposed to being derived from another context such as a `Cache`.
ContextMapper
This basic singleton class maps context paths to manager instances.
ConverterHint
Used in ShellOption annotations to indicate which converter(s) should or should not be used.
CopyException
Indicates a failure to copy an object.
CopyHelper
A static helper for optimally creating copies.
CqAttributes
This interface holds all attribute values for a CQ and provides methods for retrieving all attribute settings.
CqAttributesFactory
The factory class for the CqAttributes instance.
CqAttributesMutator
This interface is used to modify the listeners that are associated with a CQ.
CqClosedException
Thrown if the CqQuery on which the operation performed is closed.
CqEvent
This interface provides methods to get all the information sent from the server about the CQ event.
CqException
Thrown during continuous query creation, execution time.
CqExistsException
Thrown if a CQ by this name already exists on this client
CqListener
Application plug-in interface for handling continuous query events after they occur.
CqListenerAdapter
CqQuery
Interface for continuous query.
CqResults<E>
Represents the results of a CQ query that is executed using CqQuery.executeWithInitialResults() The result will contain the instances of `Struct` having key and value of the region entry that satisfy the CQ query condition.
CqServiceStatistics
This class provides methods to get aggregate statistical information about the CQs of a client.
CqState
This interface gives information on the state of a CqQuery.
CqStatistics
This class provides methods to get statistical information about a registered Continuous Query (CQ) represented by the CqQuery object.
CqStatusListener
Extension of CqListener.
CreateRegionFunction
CustomExpiry<K,V>
This is the contract that a `custom-expiry` element must honor.
DataPolicy
Enumerated type for region data policy.
DataSerializable
An interface for objects whose state can be written/read as primitive types and strings ("data").
DataSerializable.Replaceable
`Replaceable` allows an object to write an alternative version of itself to a `DataOutput`.
DataSerializer
Provides static helper methods for reading and writing non-primitive data when working with a `DataSerializable`.
DebugCacheListener
Declarable
An object that can be described in a declarative caching XML file.
DeclarableType
A "declarable" element specifies a Declarable object to be placed in a Region entry.
Delta
This interface defines a contract between the application and GemFire that allows GemFire to determine whether an application object contains a delta, allows GemFire to extract the delta from an application object, and generate a new application object by applying a delta to an existing application object.
DeltaSerializationException
This exception wraps any checked exception encountered during invocation of `Delta.fromDelta(java.io.DataInput)` or `Delta.toDelta(java.io.DataOutput)` in GemFire.
DeltaSession
DeltaSession10
DeltaSessionFacade
DeltaSessionInterface
DeltaSessionManager<CommitSessionValveT extends AbstractCommitSessionValve<?>>
DependenciesNotFoundException
Indicates that required dependencies were not found in the ClassPath.
Deployment
DeploymentInfo
DestroyOperationContext
Deprecated.
since Geode1.0, use `ResourcePermission` instead
Disabled
This annotation disables a `GfshCommand` class from being loaded by the `CommandManager` unless the provided flag value exists in the VM's environment.
DiskAccessException
Indicates that an `IOException` during a disk region operation.
DiskBackupResult
Composite data type used to distribute the results of a disk backup operation.
DiskBackupStatus
Composite data type used to distribute the status of disk backup operations.
DiskDir
DiskDirsType
A "disk-dirs" element specifies the region's disk directories.
DiskDirType
A "disk-dir" element specifies one of a region or diskstore's disk directories.
DiskMetrics
Composite data type used to distribute metrics for a `DiskStore`.
DiskStore
Provides disk storage for one or more regions.
DiskStore
DiskStoreFactory
Factory for creating instances of `DiskStore`.
DiskStoreInfo
DiskStoreMXBean
MBean that provides access to information and management functionality for a `DiskStore`.
DiskStoreType
A "disk-store" element specifies a DiskStore for persistence.
DiskWriteAttributes
Deprecated.
as of 6.5 use `DiskStore` instead
DiskWriteAttributesFactory
Deprecated.
as of 6.5 use `DiskStoreFactory` instead
DistributedLockService
A named instance of DistributedLockService defines a space for locking arbitrary names across the distributed system defined by a specified distribution manager.
DistributedLockServiceMXBean
MBean that provides access to information for a named instance of `DistributedLockService`.
DistributedMember
This is the fundamental representation of a member in a GemFire distributed system.
DistributedRegionMXBean
MBean that provides access to information and management functionality for a `Region`.
DistributedSystem
A "connection" to a GemFire distributed system.
DistributedSystemConfig
Deprecated.
as of 7.0 use the `management` package instead
DistributedSystemConfig.ConfigListener
A listener whose callback methods are invoked when this config changes.
DistributedSystemDisconnectedException
Thrown when a GemFire distributed system has been terminated.
DistributedSystemHealthConfig
Deprecated.
as of 7.0 use the `management` package instead
DistributedSystemMXBean
MBean that provides access to information and management operations for a `DistributedSystem`.
DistributionLocator
Deprecated.
as of 7.0 use the `management` package instead
DistributionLocatorConfig
Deprecated.
as of 7.0 use the `management` package instead
DuplicatePrimaryPartitionException
This exception is thrown when two nodes are defined with same primary partitions
DurableClientAttributes
Class `DurableClientAttributes` represents durable member attributes.
DynamicRegionFactory
Deprecated.
This class is deprecated.
DynamicRegionFactory.Config
Configuration for dynamic region factory.
DynamicRegionFactoryType
dynamic-region-factory is deprecated.
DynamicRegionListener
`DynamicRegionListener` is an interface that can be implemented to handle dynamic region-related events.
EmptyRegionFunctionException
Exception to indicate that Region is empty for data aware functions.
EntityGroupInfo<T extends AbstractConfiguration<R>,R extends RuntimeInfo>
A simple object that holds a configuration object and its corresponding runtime info on each member.
EntityInfo<T extends AbstractConfiguration<R>,R extends RuntimeInfo>
This holds the configuration of a particular entity in the cluster.
EntryDestroyedException
Indicates that a method was invoked on an entry that has been destroyed.
EntryEvent<K,V>
Contains information about an event affecting an entry, including its identity and the the circumstances of the event.
EntryExistsException
Thrown when attempting to create a `Region.Entry` that already exists in the `Region`.
EntryNotFoundException
Thrown when an operation is invoked on `Region` for an entry that doesn't exist in the `Region`.
EntryOperation<K,V>
Gemfire Context passed to `PartitionResolver` to compute the data location
EnumActionDestroyOverflow
Java class for enum-action-destroy-overflow.
EnumReadableWritable
Java class for enum-readable-writable.
EventSequenceID
This class wraps 1) DistributedMembershipID 2) ThreadID 3) SequenceID attributes which are used to uniquely identify any Region Operation like create, update, destroy etc.
EvictionAction
The action that an `EvictionAlgorithm` takes.
EvictionAlgorithm
The algorithm used to determine when to perform an `EvictionAction`
EvictionAttributes
Attributes that describe how a `Region`'s size is managed through an eviction controller.
EvictionAttributesData
Composite data type used to distribute the eviction attributes for a `Region`.
EvictionAttributesMutator
The EvictionAttributesMutator allows changes to be made to a `EvictionAttributes`.
ExampleAnnotationBasedMethodInvocationAuthorizer
ExamplePostProcessor
This is example that implements PostProcessor
ExampleSecurityManager
This class provides a sample implementation of `SecurityManager` for authentication and authorization initialized from data provided as JSON.
ExampleSecurityManager.Role
ExampleSecurityManager.User
ExecuteCQOperationContext
Deprecated.
since Geode1.0, use `ResourcePermission` instead
ExecuteFunctionOperationContext
Deprecated.
since Geode1.0, use `ResourcePermission` instead
Execution<IN,OUT,AGG>
Provides methods to build the context for the execution of a `Function` .
Experimental
Signifies that a public API (public class, method or field) is subject to incompatible changes, or even removal, in a future release.
ExpirationAction
Enumerated type for expiration actions.
ExpirationAttributes
Immutable parameter object for accessing and setting the attributes associated with `timeToLive` and `idleTimeout`.
FailedSynchronizationException
Thrown when a cache transaction fails to register with the `UserTransaction` (aka JTA transaction), most likely the cause of the `UserTransaction`'s `javax.transaction.Status#STATUS_MARKED_ROLLBACK` status.
Failure<SuccessType>
This type of `ServiceResult` represents a failed operation.
FieldType
Every field of a pdx must have one of these types.
FixedPartitionAttributes
Composite date type used to distribute the attributes for a fixed partition.
FixedPartitionAttributesData
Composite date type used to distribute the fixed partition attributes for a `Region`.
FixedPartitionResolver<K,V>
Implementers of interface `FixedPartitionResolver` helps to achieve explicit mapping of a "user defined" partition to a data member node.
FlatFormatSerializer
A built-in `LuceneSerializer` to parse user's nested object into a flat format, i.e.
ForcedDisconnectException
An `ForcedDisconnectException` is thrown when a GemFire application is removed from the distributed system due to membership constraints such as network partition detection.
Function<T>
Defines the interface a user defined function implements.
FunctionAdapter
Deprecated.
Use `Function` instead.
FunctionContext<T1>
Defines the execution context of a `Function`.
FunctionDomainException
Thrown if the domain of a function is not legal.
FunctionException
Thrown to indicate an error or exceptional condition during the execution of Functions in GemFire.
FunctionInvocationTargetException
Thrown if one of the function execution nodes goes away or cache is closed.
FunctionService
Provides the entry point into execution of user defined Functions.
FunctionServiceType
The "function service" element configures the behavior of the function service.
FutureCancelledException
Thrown when a `Future` has been cancelled.
Gateway
From 9.0 old wan support is removed.
Gateway.OrderPolicy
The order policy.
GatewayCancelledException
Thrown when a GemFire WAN gateway has been terminated.
GatewayConfigurationException
An exception indicating that a gateway configuration will not work with the remote side of the gateway's configuration.
GatewayConflictHelper
GatewayConflictHelper is used by an GatewayConflictResolver to decide what to do with an event received from another distributed system that is going to overwrite the current cache state.
GatewayConflictResolver
GatewayConflictResolver is a Cache-level plugin that is called upon to decide what to do with events that originate in other systems and arrive through the WAN Gateway.
GatewayDelta
GatewayDeltaCreateEvent
GatewayDeltaDestroyEvent
GatewayDeltaEvent
GatewayDeltaEventApplicationCacheListener
GatewayDeltaForwarderCacheListener
GatewayEvent
Deprecated.
as of GemFire 8.0.
GatewayEventFilter
Callback for users to filter out events before dispatching to remote distributed system
GatewayEventSubstitutionFilter<K,V>
Interface `GatewayEventSubstitutionFilter` provides a way to specify a substitute value to be stored in the `GatewayQueueEvent` and enqueued in the `RegionQueue`.
GatewayException
An exception thrown by a `Gateway`.
GatewayQueueEvent<K,V>
Represents `Cache` events going through `GatewaySender`s.
GatewayReceiver
A GatewayReceiver that receives the events from a `GatewaySender`.
GatewayReceiver
Use this to configure the gateway receiver in the cluster setting the bindAddress and hostname for clients are not supported by this api.
GatewayReceiverConfig
Java class for anonymous complex type.
GatewayReceiverFactory
GatewayReceiverInfo
GatewayReceiverMXBean
MBean that provides access to information and management functionality for a `GatewayReceiver`.
GatewaySender
GatewaySender.OrderPolicy
The order policy.
GatewaySenderFactory
Factory to create SerialGatewaySender
GatewaySenderMXBean
MBean that provides access to information and management functionality for a `GatewaySender`.
GatewayTransportFilter
GemFireCache
GemFireCache represents the singleton cache that must be created in order to use GemFire in a Java virtual machine.
GemFireCacheException
An `GemFireCacheException` is used to wrap a `CacheException`.
GemFireCheckedException
This is the abstract superclass of exceptions that are thrown and declared.
GemFireConfigException
A `GemFireConfigException` is used for failures while processing a GemFire configuration XML file.
GemFireException
This is the abstract superclass of exceptions that are thrown to indicate incorrect usage of GemFire.
GemFireHealth
Deprecated.
as of 7.0 use the `management` package instead
GemFireHealth.Health
An enumerated type for the health of GemFire.
GemFireHealthConfig
Deprecated.
as of 7.0 use the `management` package instead
GemFireIOException
A `GemFireIOException` is thrown when a GemFire operation failure is caused by an `IOException`.
GemFireMemberStatus
Deprecated.
as of 7.0 use the `management` package instead
GemFireMemcachedServer
This is the Server that listens for incoming memcached client connections.
GemFireMemcachedServer.Protocol
The protocol used by GemFireMemcachedServer
GemFireProperties
Composite Data type to be used by member to depict gemfire properties in key value manner
GemFireRethrowable
This error is used by GemFire for internal purposes.
GemFireSecurityException
The base class for all org.apache.geode.security package related exceptions.
GeodeClusterManagementServiceBuilder
GetDurableCQsOperationContext
Deprecated.
since Geode1.0, use `ResourcePermission` instead
GetOperationContext
Deprecated.
since Geode1.0, use `ResourcePermission` instead
GFConnection
GFConnectionFactory
GfshCommand
GroupableConfiguration<R extends RuntimeInfo>
HasFile
Identifiable<T extends Comparable<T>>
The Identifiable interface defines a contract for classes whose Object instances can be uniquely identified relative to other Object instances within the same class type hierarchy.
Immutable
Annotates a class that cannot be changed after construction or a field that cannot be modified after initialization.
IncompatibleSystemException
An `IncompatibleSystemException` is thrown when a new GemFire process tries to connect to an existing distributed system and its version is not the same as that of the distributed system.
IncompatibleVersionException
An `IncompatibleVersionException` that the client version was not compatible with the server version.
Index
Java class for anonymous complex type.
Index
An index that is built over the data stored in a GemFire `Region`.
Index
Index.Field
Java class for anonymous complex type.
IndexCreationException
This class is used to represent any partitioned index creation exceptions.
IndexExistsException
Thrown while creating the new index if there exists an Index with the same definition as new index.
IndexInfo
IndexInvalidException
Thrown if the index definition is not valid.
IndexMaintenanceException
Thrown if an error occurs while updating query indexes during region modification.
IndexNameConflictException
Thrown while creating the new index if there exists an Index with the same name as new index.
IndexStatistics
Provides statistics about a GemFire cache `Index`.
IndexType
Deprecated.
As of 6.6.1.
IndexType
Public ENUM to indicate type of Index on a Geode `Region` used by the Management API.
Installer
Instantiator
`Instantiator` allows classes that implement `DataSerializable` to be registered with the data serialization framework.
InterestOperationContext
Deprecated.
since Geode1.0, use `ResourcePermission` instead
InterestPolicy
Enumerated type for region subscription interest policy.
InterestRegistrationEvent
Interface `InterestRegistrationEvent` encapsulated interest event information like region and keys of interest.
InterestRegistrationListener
Interface `InterestRegisterationListener` provides the ability for applications to be notified of interest registration and unregistration events.
InterestResultPolicy
Class `InterestResultPolicy` is an enumerated type for a register interest result.
InterestType
Enumeration for various interest types.
InternalGemFireError
Indicates that serious error has occurred within the GemFire system.
InternalGemFireException
An `InternalGemFireException` is thrown when a low level, internal, operation fails due to no fault of the user.
InvalidateOperationContext
Deprecated.
since Geode1.0, use `ResourcePermission` instead
InvalidDeltaException
An `InvalidDeltaException` is thrown when a delta cannot be successfully applied by the receiving peer/client.
InvalidValueException
An `InvalidValueException` is thrown when an attempt is made to set a configuration attribute to an invalid value is made.
InvalidVersionException
JarClassLoader
Classloader, which allows finding classes in jars within jars.
JavaBeanAccessorMethodAuthorizer
An immutable and thread-safe `MethodInvocationAuthorizer` that allows any method execution that follows the design patterns for accessor methods described in the JavaBean specification 1.01; that is, any method whose name begins with 'get' or 'is'.
JdbcAsyncWriter
This class provides write behind cache semantics for a JDBC data source using AsyncEventListener.
JdbcConnectorException
An exception thrown when communication with an external JDBC data source fails and can be used to diagnose the cause of database communication failures.
JdbcLoader<K,V>
This class provides loading from a data source using JDBC.
JdbcPooledDataSourceFactory
This class implements PooledDataSourceFactory for the JDBC Connector extension.
JdbcWriter<K,V>
This class provides synchronous write through to a data source using JDBC.
JMXNotificationType
Enumerated type for JMX notification types emitted by GemFire management system.
JMXNotificationUserData
This interface acts as UserData section of JMX notifications of type "system.alert".
JndiBindingsType
A jndi-bindings element will contain the jndi-binding for each of the datasources which are to be bound with the JNDI Context.
JndiBindingsType.JndiBinding
Java class for anonymous complex type.
JndiBindingsType.JndiBinding.ConfigProperty
Java class for anonymous complex type.
JSONFormatter
JSONFormatter has a static method `JSONFormatter.fromJSON(String, String...)` to convert a JSON document into a `PdxInstance` and a static method `JSONFormatter.toJSON(PdxInstance)` to convert a `PdxInstance` into a JSON Document.
JSONFormatterException
This exception will be thrown, when {link @JSONFormatter} is unable to parse the JSON document or {link @PdxInstance}.
JsonSerializable
marker interface that allows subclasses to be deserialized correctly note that any class can still be serialized using JSON (without implementing this interface) as long as it has no subclasses
JVMMetrics
Composite data type used to distribute metrics for the JVM running a GemFire member.
JvmRouteBinderValve
KeyOperationContext
Deprecated.
since Geode1.0, use `ResourcePermission` instead
KeySetOperationContext
Deprecated.
since Geode1.0, use `ResourcePermission` instead
KeyValueOperationContext
Deprecated.
since Geode1.0, use `ResourcePermission` instead
LeaseExpiredException
A `LeaseExpiredException` is thrown when GemFire detects that a distributed lock obtained by the current thread with a limited lease (see @link DistributedLockService} has expired before it was explicitly released.
LifecycleTypeAdapter
Adapter for the Catalina Lifecycle event types
Links
this keeps all HATEOAS links related to a particular configuration object.
LoaderHelper<K,V>
Provides a set of APIs to help the implementation of the `CacheLoader` load method.
LocalSessionCacheLoader
LocalSessionCacheWriter
Locator
Represents a distribution locator server that provides discovery information to members and clients of a GemFire distributed system.
LocatorLauncher
The LocatorLauncher class is a launcher for a Geode Locator.
LocatorLauncher.Builder
Following the Builder design pattern, the LocatorLauncher Builder is used to configure and create a properly initialized instance of the LocatorLauncher class for running the Locator and performing other Locator operations.
LocatorLauncher.Command
An enumerated type representing valid commands to the Locator launcher.
LocatorLauncher.LocatorState
The LocatorState is an immutable type representing the state of the specified Locator at any given moment in time.
LocatorMXBean
MBean that provides access to information and management functionality for a `Locator`.
LockNotHeldException
A `LockNotHeldException` is thrown when attempting unlock a lock that is not held by the thread performing the unlock.
LockServiceDestroyedException
A `LockServiceDestroyedException` is thrown when attempting use a distributed lock service that has been destroyed.
LockServiceMXBean
MBean that provides access to information and management functionality for a `DLockService`.
LogWriter
Deprecated.
Please use Log4J2 instead.
LogWriterI18n
Deprecated.
Please use Log4J2 instead.
LossAction
Deprecated.
this feature is scheduled to be removed
LowMemoryException
Indicates a low memory condition either on the local or a remote `Cache`.
LuceneIndex
LuceneIndex represents the Lucene index created over the data stored in Apache Geode regions.
LuceneIndexDestroyedException
A LuceneIndexDestroyedException is thrown if a Lucene index is attempted to be used while it is being destroyed or after it has been destroyed.
LuceneIndexExistsException
A LuceneIndexExistsException is thrown if a Lucene index that already exists is attempted to be created.
LuceneIndexFactory
A factory for creating a lucene index on the current member.
LuceneIndexMetrics
LuceneIndexNotFoundException
A LuceneIndexNotFoundException is thrown if a Lucene index is requested but not found.
LuceneQuery<K,V>
A query on a Lucene index.
LuceneQueryException
Thrown when a Lucene query fails.
LuceneQueryFactory
Factory for configuring a Lucene query.
LuceneQueryProvider
A factory for `Query` objects.
LuceneResultStruct<K,V>
An interface which stores a single result obtained by executing a Lucene query.
LuceneSerializer<T>
An interface for writing the fields of an object into a lucene document
LuceneService
The LuceneService provides the capability to create Lucene indexes and execute lucene queries on data stored in Geode regions.
LuceneServiceMXBean
MBean that provides access to the `LuceneService`.
LuceneServiceProvider
Class for retrieving or creating the currently running instance of the LuceneService.
ManagedEntity
Deprecated.
as of 7.0 use the `management` package instead
ManagedEntityConfig
Deprecated.
as of 7.0 use the `management` package instead
ManagementException
A `ManagementException` is a general exception that may be thrown when any administration or monitoring operation on a GemFire component fails.
ManagementService
Interface to the GemFire management service for a single Cache.
ManagerMXBean
MBean that provides access to information and management functionality for a `Manager`.
MapType
Represents the type of a Map, a collection that contains keys as well as values and maintains an association between key-value pairs.
Member
MemberHealthConfig
Deprecated.
as of 7.0 use the `management` package instead
MemberInformation
Data class to hold the information of the member Used in describe member command
MemberMXBean
MBean that provides access to information and management functionality for a `DistributedMember` of the GemFire distributed system.
MembershipAttributes
Deprecated.
this feature is scheduled to be removed
MembershipAttributesData
Deprecated.
this API is scheduled to be removed
MembershipEvent
An event that describes the member that originated this event.
MembershipListener
A listener whose callback methods are invoked when members join or leave the GemFire distributed system.
MethodInvocationAuthorizer
The root interface that should be implemented by method invocation authorizer instances.
MetricsPublishingService
Publishes metrics managed by a `MetricsSession`.
MetricsSession
A session that manages Geode metrics.
MirrorType
Deprecated.
as of GemFire 5.0, use `DataPolicy` instead.
MultiIndexCreationException
Consists a map of index names and Exceptions thrown during index creation using `QueryService.createDefinedIndexes()`.
MultiJarDeployment
NameNotFoundException
Thrown when an attribute or method name could not be resolved during query execution because no matching method or field could be found.
NameResolutionException
Thrown if an attribute or method name in a query cannot be resolved.
NetworkMetrics
Composite data type used to distribute network related metrics for a member.
NoAvailableLocatorsException
An exception indicating that there are no active locators available to connect to.
NoAvailableServersException
An exception indicating that there are no active servers available to connect to.
NonPortableClassException
Thrown if "check-portability" is enabled and an attempt is made to pdx serialize a class that is not portable to non-java platforms.
NoQueueServersAvailableException
Indicates that this client cannot contact any queue servers and therefore cannot perform operations that require a queue, such as registering interest.
NoSubscriptionServersAvailableException
Indicates that this client cannot contact any servers and therefore cannot perform operations that require subscriptions, such as registering interest.
NoSystemException
A `NoSystemException` is thrown when a locator can not be found or connected to.
NotAuthorizedException
Thrown when a client/peer is unauthorized to perform a requested operation.
ObjectSizer
The sizer interface defines a method that when called returns the size of the object passed in.
ObjectType
Java class for anonymous complex type.
ObjectType
An ObjectType represents the type of an object in a query.
Operation
Enumerated type for an event operation.
OperationAbortedException
Indicates that the operation that would have otherwise affected the cache has been aborted.
OperationCancelledException
Deprecated.
as of 7.0 use the `management` package instead
OperationContext
Deprecated.
since Geode1.0, use `ResourcePermission` instead
OperationContext.OperationCode
OperationResult
Describes the result of a starting or checking the status of a `ClusterManagementOperation`.
OplogCancelledException
Thrown when a GemFire operation log has been terminated.
OSMetrics
Composite data type used to distribute metrics for the operating system hosting a member of the distributed system.
OutOfOffHeapMemoryException
Indicates that attempts to allocate more objects in off-heap memory has failed and the Cache will be closed to prevent it from losing distributed consistency.
PageableLuceneQueryResults<K,V>
This interface allows you to retrieve a page of query results at a time, using the `PageableLuceneQueryResults.hasNext()` and `PageableLuceneQueryResults.next()` methods.
ParameterCountInvalidException
Thrown when the number of bound paramters for a query does not match the number of placeholders.
ParameterType
A "parameter" element describes a parameter used to initialize a Declarable object.
PartitionAttributes<K,V>
Attributes that define the partitioned character of a Partitioned Region.
PartitionAttributesData
Composite date type used to distribute attributes for a `PartitionedRegion`.
PartitionAttributesFactory<K,V>
A factory that creates instances of `PartitionAttributes` which are used to create a partitioned `Region`.
PartitionedRegionDistributionException
Indicates a failure to perform a distributed operation on a Partitioned Region after multiple attempts.
PartitionedRegionStorageException
Description of the conditions under which this exception is thrown
PartitionListener
A callback for partitioned regions, invoked when a partition region is created or any bucket is created/deleted or any bucket in a partitioned region becomes primary.
It is highly recommended that implementations of this listener should be quick and not try to manipulate regions and data because the the callbacks are invoked while holding locks that may block region operations.
PartitionListenerAdapter
Utility class that implements all methods in `PartitionListener` with empty implementations.
PartitionMemberInfo
Describes a member that has been configured to provide storage space for a partitioned region.
PartitionNotAvailableException
This exception is thrown when for the given fixed partition, datastore (local-max-memory > 0) is not available.
PartitionOfflineException
Thrown when a paritioned region is configured for disk persistence, and part of the data is stored on members that are known to be offline.
PartitionRebalanceInfo
The detailed results of rebalancing a partitioned region.
PartitionRegionHelper
Utility methods for handling partitioned Regions, for example during execution of `Functions` on a Partitioned Region.
PartitionRegionInfo
Information describing the data storage and distribution of a partitioned region.
PartitionResolver<K,V>
Implementers of interface `PartitionResolver` enable custom standard partitioning on the `PartitionedRegion`.
See `FixedPartitionResolver` to enable custom fixed partitioning.
Pdx
Used to configure PDX serialization for a cache.
PdxConfigurationException
Thrown when a configuration that is now allowed by PDX is detected.
PdxFieldAlreadyExistsException
Thrown when writing a field if the named field already exists.
PdxFieldDoesNotExistException
Thrown when a PDX field does not exist and the current operation requires its existence.
PdxFieldTypeMismatchException
Thrown if the type of a PDX field was changed or the wrong type was used.
PdxInfo
PdxInitializationException
Thrown if the PDX system could not be successfully initialized.
PdxInstance
PdxInstance provides run time access to the fields of a PDX without deserializing the PDX.
PdxInstanceFactory
PdxInstanceFactory gives you a way to create PdxInstances.
PdxReader
A PdxReader will be passed to `fromData` or `PdxSerializer fromData` by GemFire during deserialization of a PDX.
PdxRegistryMismatchException
Thrown when an attempt is made to reuse a PDX Type.
PdxSerializable
When a domain class implements PdxSerializable it marks itself as a PDX.
PdxSerializationException
Thrown if a problem occurred during serialization or deserialization of a PDX.
PdxSerializer
The PdxSerializer interface allows domain classes to be serialized and deserialized as PDXs without modification of the domain class.
PdxType
A "pdx" element specifies the configuration for the portable data exchange (PDX) method of serialization.
PdxUnreadFields
Marker interface for an object that GemFire creates and returns from `readUnreadFields`.
PdxWriter
A PdxWriter will be passed to `toData` or `PdxSerializer toData` by GemFire when it is serializing the domain class.
PeerToPeerCache
This is a singleton class which maintains configuration properties as well as starting a Peer-To-Peer cache.
PeerToPeerCacheLifecycleListener
This is a thin wrapper around a peer-to-peer cache.
PeerToPeerSessionCache
PersistentID
A pattern describing a single member's a set of persistent files for a region.
PersistentMemberDetails
Composite data type used to distribute attributes for the missing disk store of a persistent member.
PersistentReplicatesOfflineException
Thrown when a replicated region is configured for persistence on some members but none of those members are currently online.
Pool
A pool for connections from a client to a set of GemFire Cache Servers.
PoolCancelledException
Thrown when a GemFire connection pool has been terminated.
PooledDataSourceFactory
Classes that implement this interface can be used as the class name specified in the "gfsh create data-source --pooled-data-source-factory-class" parameter.
PoolFactory
This interface provides for the configuration and creation of instances of `Pool`.
PoolManager
Manages creation and access to `connection pools` for clients.
PoolType
A "pool" element specifies a client to server connection pool.
PoolType.Locator
Java class for anonymous complex type.
PoolType.Server
Java class for anonymous complex type.
PostProcessor
PostProcessor allows the customer to massage the values seen by a particular user.
ProxySocketFactories
PutAllOperationContext
Deprecated.
since Geode1.0, use `ResourcePermission` instead
PutOperationContext
Deprecated.
since Geode1.0, use `ResourcePermission` instead
Query
Interface for query objects.
QueryConfigService
Java class for anonymous complex type.
QueryConfigService.MethodAuthorizer
Java class for anonymous complex type.
QueryConfigService.MethodAuthorizer.Parameter
Java class for anonymous complex type.
QueryException
Thrown during by the query engine during parsing or execution.
QueryExecutionLowMemoryException
Thrown when the query is executing and the critical heap percentage is met.
QueryExecutionTimeoutException
Thrown when the query execution takes more than the specified max time.
QueryInvalidException
Thrown if the query language syntax is not valid.
QueryInvocationTargetException
Thrown if an exception is thrown when a method is invoked during query execution.
QueryOperationContext
Deprecated.
since Geode1.0, use `ResourcePermission` instead
QueryService
Interface for the query service, which is used for instantiating queries, creating and destroying indexes, creating CQs and operating on CQs.
QueryStatistics
Provides statistical information about a query performed on a GemFire `Region`.
RealizationResult
this holds the information returned by the ConfigurationRealizers to indicate the success/failure of the realization step.
RebalanceFactory
Factory for defining and starting a `RebalanceOperation`.
RebalanceOperation
Operation for rebalancing resources used by the `Cache`.
RebalanceOperation
Defines a distributed system request to optimize bucket allocation across members.
RebalanceRegionResult
Details of the rebalancing work performed for a partitioned region.
RebalanceResult
the final results of a `RebalanceOperation`
RebalanceResults
The results of rebalancing `Cache` resources.
ReflectionBasedAutoSerializer
This class uses Java reflection in conjunction with `PdxSerialzer` to perform automatic serialization of domain objects.
RegExMethodAuthorizer
An immutable and thread-safe `MethodInvocationAuthorizer` that only allows the execution of those methods matching the configured regular expression.
Region<K,V>
Manages subregions and cached data.
Region
this holds the region attributes you can configure using management rest api for regions created using gfsh but listed using management rest api, the attributes not supported by management rest api won't be shown.
Region.Entry<K,V>
A key-value pair containing the cached data in a region.
Region.Eviction
Region.EvictionAction
Region.EvictionType
Region.Expiration
Region.ExpirationAction
Region.ExpirationType
RegionAccessException
Deprecated.
the MembershipAttributes API is scheduled to be removed
RegionAttributes<K,V>
Defines attributes for configuring a region.
RegionAttributesData
Composite data type used to distribute attributes for a `Region`.
RegionAttributesDataPolicy
Java class for region-attributesData-policy.
RegionAttributesIndexUpdateType
Java class for region-attributesIndex-update-type.
RegionAttributesMirrorType
Java class for region-attributesMirror-type.
RegionAttributesScope
Java class for region-attributesScope.
RegionAttributesType
Java class for region-attributes-type complex type.
RegionAttributesType.DiskWriteAttributes
Java class for anonymous complex type.
RegionAttributesType.DiskWriteAttributes.AsynchronousWrites
Java class for anonymous complex type.
RegionAttributesType.EvictionAttributes
Java class for anonymous complex type.
RegionAttributesType.EvictionAttributes.LruEntryCount
Java class for anonymous complex type.
RegionAttributesType.EvictionAttributes.LruHeapPercentage
Java class for anonymous complex type.
RegionAttributesType.EvictionAttributes.LruMemorySize
Java class for anonymous complex type.
RegionAttributesType.ExpirationAttributesDetail
RegionAttributesType.ExpirationAttributesType
Java class for anonymous complex type.
RegionAttributesType.MembershipAttributes
Java class for anonymous complex type.
RegionAttributesType.MembershipAttributes.RequiredRole
Java class for anonymous complex type.
RegionAttributesType.PartitionAttributes
Java class for anonymous complex type.
RegionAttributesType.PartitionAttributes.FixedPartitionAttributes
Java class for anonymous complex type.
RegionAttributesType.SubscriptionAttributes
Java class for anonymous complex type.
RegionClearOperationContext
Deprecated.
since Geode1.0, use `ResourcePermission` instead
RegionConfig
A "region" element describes a region (and its entries) in Geode distributed cache.
RegionConfig.Entry
Java class for anonymous complex type.
RegionConfig.Index
Java class for anonymous complex type.
RegionConfiguration
Class `RegionConfiguration` encapsulates the configuration attributes for a `Region` to be created on the server.
RegionConfigurationCacheListener
RegionCreateOperationContext
Deprecated.
since Geode1.0, use `ResourcePermission` instead
RegionDestroyedException
Indicates that the region has been destroyed.
RegionDestroyOperationContext
Deprecated.
since Geode1.0, use `ResourcePermission` instead
RegionDistributionException
Deprecated.
the MembershipAttributes API is scheduled to be removed
RegionEvent<K,V>
Contains information about an event affecting a region, including its identity and the circumstances of the event.
RegionExistsException
Indicates that the requested region already exists when a region is being created.
RegionFactory<K,V>
`RegionFactory` is used to create `regions` in a `cache`.
RegionFunctionContext
Defines the execution context of a data dependent `Function`.
RegionHelper
RegionMembershipListener<K,V>
A listener that can be implemented to handle region membership events.
RegionMembershipListenerAdapter<K,V>
Utility class that implements all methods in `RegionMembershipListener` with empty implementations.
RegionMXBean
MBean that provides access to information and management functionality for a local `Region`.
RegionNotFoundException
Deprecated.
as of 7.0 use the `management` package instead
RegionNotFoundException
Thrown if a region referenced by name in a query cannot be found.
RegionOperationContext
Deprecated.
since Geode1.0, use `ResourcePermission` instead
RegionRedundancyStatus
Used to calculate and store a snapshot of the redundancy status for a partitioned region.
RegionRedundancyStatus.RedundancyStatus
The redundancy status of the region used to create this object at time of creation.
RegionReinitializedException
Indicates that the region has been reinitialized.
RegionRoleException
Deprecated.
this feature is scheduled to be removed
RegionRoleListener<K,V>
Deprecated.
this feature is scheduled to be removed
RegionRoleListenerAdapter<K,V>
Deprecated.
this feature is scheduled to be removed
RegionScoped
RegionService
A RegionService provides access to existing `regions` that exist in a `GemFire cache`.
RegionShortcut
Each enum represents a predefined `RegionAttributes` in a `Cache`.
RegionSizeFunction
RegionSnapshotService<K,V>
Allows a snapshot of region data to be imported and exported.
RegionStatus
RegionSubRegionSnapshot
Deprecated.
as of 7.0 use the `management` package instead
RegionType
these are the region types supported by Cluster Management V2 API.
RegisterInterestOperationContext
Deprecated.
since Geode1.0, use `ResourcePermission` instead
RemoveAllOperationContext
Deprecated.
since Geode1.0, use `ResourcePermission` instead
RequiredRoles
Deprecated.
this feature is scheduled to be removed
ResourceException
A Generic exception to indicate that a resource exception has occurred.
ResourceManager
Provides support for managing resources used by the local `Cache`.
ResourceManagerType
The "resource manager" element configures the behavior of the resource manager.
ResourceManagerValidator
ResourcePermission
ResourcePermission defines the resource, the operation, the region and the key involved in the action to be authorized.
ResourcePermission.Operation
ResourcePermission.Resource
ResourcePermission.Target
RestoreRedundancyOperation
Class for defining and starting a `CompletableFuture` that returns `RestoreRedundancyResults`.
RestoreRedundancyRequest
Defines a distributed system request to optimize bucket allocation across members.
RestoreRedundancyResults
A class to collect the results of restore redundancy operations for one or more regions and determine the success of failure of the operation.
RestoreRedundancyResults.Status
`RestoreRedundancyResults.Status.SUCCESS` is defined as every included region having fully satisfied redundancy.
RestrictedMethodAuthorizer
The default, immutable and thread-safe `MethodInvocationAuthorizer` used by Geode to determine whether a `Method` is allowed to be executed on a specific `Object` instance.
RestTemplateClusterManagementServiceTransport
Concrete implementation of `ClusterManagementServiceTransport` which uses Spring's `RestTemplate` for communication between client and CMS endpoint.
Result
The result of processing a GemFire Command Line Interface (CLI) command string.
Result<SuccessType,FailureType>
The `Result` type is an attempt at the function construct of * Either.
Result.Status
Indicates a Results status.
ResultCollector<T,S>
Defines the interface for a container that gathers results from function execution.
GemFire provides a default implementation for ResultCollector.
ResultSender<T>
Provides methods to send results back to the ResultCollector.
ResumptionAction
Deprecated.
this API is scheduled to be removed
RevokedPersistentDataException
Thrown when a member with persistence is recovering, and it discovers that other members in the system have revoked the persistent data stored on this member.
RevokeFailedException
Thrown when a member tries to revoke a persistent ID, but the member with that persistent ID is currently running.
Role
Deprecated.
this feature is scheduled to be removed
RoleEvent<K,V>
Deprecated.
this feature is scheduled to be removed
RoleException
Deprecated.
this feature is scheduled to be removed
RuntimeAdminException
Deprecated.
as of 7.0 use the `management` package instead
RuntimeInfo
RuntimeRegionInfo
Scope
Enumerated type for region distribution scope.
SecurableCommunicationChannels
This class defines all the static definitions for the `ConfigurationProperties.SSL_ENABLED_COMPONENTS` Since: Geode 1.0
SecurityManager
User implementation of a authentication/authorization logic for Integrated Security.
SelectResults<E>
Contains the results of a executing a `SELECT` expression within a query.
SerializationException
An exception indicating that a serialization or deserialization failed.
SerializationRegistrationType
A serialization-registration contains a set of serializer or instantiator tags to register customer DataSerializer extensions or DataSerializable implementations respectively.
SerializationRegistrationType.Instantiator
Java class for anonymous complex type.
SerializationRegistrationType.Serializer
Java class for anonymous complex type.
SerializedCacheValue<V>
Class `SerializedCacheValue` represents a serialized cache value.
ServerConnectivityException
A generic exception indicating that a failure has happened while communicating with a gemfire server.
ServerLauncher
The ServerLauncher class is a launcher class with main method to start a Geode Server (implying a Geode Cache Server process).
ServerLauncher.Builder
The Builder class, modeled after the Builder creational design pattern, is used to construct a properly configured and initialized instance of the ServerLauncher to control and run Geode servers (in particular, cache servers).
ServerLauncher.Command
An enumerated type representing valid commands to the Server launcher.
ServerLauncher.ServerState
The ServerState is an immutable type representing the state of the specified Server at any given moment in time.
ServerLauncherCacheProvider
ServerLauncherCacheProvider is an extension point for overriding the behavior of a server started with `ServerLauncher` or the gfsh start server command.
ServerLauncherParameters
GEODE-5256: Parameters containing startup options specified by the user.
ServerLoad
A data object containing the load information for a cache server.
ServerLoadData
Composite data type used to distribute server load information.
ServerLoadProbe
A load probe is installed in a cache server to measure the load on the cache server for balancing load between multiple cache servers.
ServerLoadProbeAdapter
Utility class that implements all methods in `ServerLoadProbe` with empty implementations for open and close.
ServerMetrics
Metrics about the resource usage for a cache server.
ServerOperationException
An exception indicating that a failure has happened on the server while processing an operation that was sent to it by a client.
ServerRefusedConnectionException
A `ServerRefusedConnectionException` indicates a client attempted to connect to a server, but the handshake was rejected.
ServerType
Java class for server-type complex type.
ServerType.ClientSubscription
Java class for anonymous complex type.
ServiceResult<SuccessType>
The `ServiceResult` type is an attempt at the function construct of Either.
SessionCache
SessionCachingFilter
Primary class which orchestrates everything.
SessionCachingFilter.RequestWrapper
This request wrapper class extends the support class HttpServletRequestWrapper, which implements all the methods in the HttpServletRequest interface, as delegations to the wrapped request.
SessionCustomExpiry
SessionExpirationCacheListener
SessionManager
SimpleSecurityManager
Intended for example and demo purpose, this class authenticates a user when the username matches the password, which also represents the permissions the user is granted.
SingleGfshCommand
Command class that extends this class can only have one single command method, * i.e only one method that is annotated with @CliCommand.
SnappyCompressor
An implementation of `Compressor` for Google's Snappy compression codec.
SnapshotFilter<K,V>
Filters region entries for inclusion into a snapshot.
SnapshotIterator<K,V>
Iterates over the entries in a region snapshot.
SnapshotOptions<K,V>
Provides a way to configure the behavior of snapshot operations.
SnapshotOptions.SnapshotFormat
Defines the available snapshot file formats.
SnapshotReader
Provides utilities for reading cache data.
SniProxySocketFactory
A `SocketFactory` that connects a client to locators and servers through a SNI proxy.
SocketFactory
A socket factory used to create sockets from a client to locators or servers.
SSLParameterExtension
User implementation of a SSLParameter extension logic.
SSLParameterExtensionContext
Statistic
Deprecated.
as of 7.0 use the `management` package instead
StatisticDescriptor
Describes an individual statistic whose value is updated by an application and may be archived by GemFire.
StatisticResource
Deprecated.
as of 7.0 use the `management` package instead
Statistics
Instances of this interface maintain the values of various application-defined statistics.
StatisticsDisabledException
Thrown if statistics are requested when statistics are disabled on the region.
StatisticsFactory
Instances of this interface provide methods that create instances of `Statistics`.
StatisticsType
Used to describe a logical collection of statistics.
StatisticsTypeFactory
Instances of this interface provide methods that create instances of `StatisticDescriptor` and `StatisticsType`.
StopCQOperationContext
Deprecated.
since Geode1.0, use `ResourcePermission` instead
StringId
Deprecated.
localization in Geode is deprecated
StringPrefixPartitionResolver
This partition resolver requires every key of the partitioned region to be an instance of String and to contain at least one "|" delimiter.
Struct
An immutable and thread-safe data type used by the result of some `SELECT` queries.
StructType
Describes the field names and types for each field in a `Struct`.
SubscriptionAttributes
Configuration attributes for defining subscriber requirements and behavior for a `Region`.
SubscriptionNotEnabledException
An exception indicating that client subscriptions are not enabled on this client, but the client is trying to perform an operation that requires a client subscription, such as `Region.registerInterest(Object)`.
Success<SuccessType>
This type of `ServiceResult` represents a successful operation.
SynchronizationCommitConflictException
Thrown when a commit operation of a JTA enlisted cache transaction fails
SystemConnectException
An `SystemConnectException` is thrown when a GemFire application tries to connect to an existing distributed system and is unable to contact all members of the distributed system to announce its presence.
SystemFailure
Deprecated.
since Geode 1.11 because it is potentially counterproductive to try to mitigate a VirtualMachineError since the JVM (spec) makes no guarantees about the soundness of the JVM after such an error.
SystemIsRunningException
A `SystemIsRunningException` is thrown when an operation is attempted that requires that the locator is stopped.
SystemMember
Deprecated.
as of 7.0 use the `management` package instead
SystemMemberBridgeServer
Deprecated.
as of 5.7 use `SystemMemberCacheServer` instead.
SystemMemberCache
Deprecated.
as of 7.0 use the `management` package instead
SystemMemberCacheEvent
Deprecated.
as of 7.0 use the `management` package instead
SystemMemberCacheListener
Deprecated.
as of 7.0 use the `management` package instead
SystemMemberCacheServer
Deprecated.
as of 7.0 use the `management` package instead
SystemMemberRegion
Deprecated.
as of 7.0 use the `management` package instead
SystemMemberRegionEvent
Deprecated.
as of 7.0 use the `management` package instead
SystemMembershipEvent
Deprecated.
as of 7.0 use the `management` package instead
SystemMembershipListener
Deprecated.
as of 7.0 use the `management` package instead
SystemMemberType
Deprecated.
as of 7.0 use the `management` package instead
TimeoutException
Thrown if a `netSearch` times out without getting a response back from a cache, or when attempting to acquire a distributed lock.
TimestampedEntryEvent
TimestampedEntryEvent is an EntryEvent that has additional information provided to GatewayConflictResolver plugins.
ToDataException
A `ToDataException` is thrown during serialization if `DataSerializable.toData(java.io.DataOutput)` throws an exception or if `DataSerializer.toData(java.lang.Object, java.io.DataOutput)` is called and returns false.
Tomcat10CommitSessionValve
Tomcat10DeltaSessionManager
TouchPartitionedRegionEntriesFunction
Touches the keys contained in the set of keys by performing a get on the partitioned region.
TouchReplicatedRegionEntriesFunction
Touches the keys contained in the set of keys by performing a get on the replicated region.
TransactionDataNodeHasDepartedException
Thrown when the transactional data host has shutdown or no longer has the data being modified by the transaction.
TransactionDataNotColocatedException
Indicates that an attempt was made to transactionally modify multiple keys that are not colocated on the same data host.
TransactionDataRebalancedException
Thrown when a `RebalanceOperation` occurs concurrently with a transaction.
TransactionEvent
An event that describes the culmination of an entire transaction.
TransactionException
This is the superclass for all Exceptions that may be thrown by a GemFire transaction.
TransactionId
The TransactionId interface is a "marker" interface that represents a unique GemFire transaction.
TransactionInDoubtException
This Exception is thrown in presence of node failures, when GemFire cannot know with certainty about the outcome of the transaction.
TransactionListener
A listener that can be implemented to handle transaction related events.
TransactionListenerAdapter
Utility class that implements all methods in `TransactionListener` with empty implementations.
TransactionWriter
A callback that is allowed to veto a transaction.
TransactionWriterException
Exception thrown by implementors of `TransactionWriter.beforeCommit(org.apache.geode.cache.TransactionEvent)` to signal that the current transaction should be aborted.
TXManagerCancelledException
Thrown when a GemFire transaction manager has been terminated.
TypeMismatchException
Thrown if type consistency is violated while a query is being executed.
UncreatedSystemException
An `UncreatedSystemException` is thrown when the specified locator's directory or configuration file can not be found.
UniversalMembershipListenerAdapter
The `UniversalMembershipListenerAdapter` is a wrapper for `MembershipListener` and `ClientMembershipListener`, providing a facade that makes both appear as a single `MembershipListener` .
UniversalMembershipListenerAdapter.AdaptedMembershipEvent
Adapts ClientMembershipEvent to look like a MembershipEvent
UnknownArgumentHandler
Interface defining unknown argument handlers, given the opportunity to either ignore the issue or force the parameter to be dealt with.
UnmodifiableConfigurationException
Deprecated.
as of 7.0 use the `management` package instead
UnmodifiableException
A `UnmodifiableException` is thrown when a an attempt is made to modify a GemFire member configuration attribute that can not currently be modified.
UnregisterInterestOperationContext
Deprecated.
since Geode1.0, use `ResourcePermission` instead
UnrestrictedMethodAuthorizer
An immutable and thread-safe `MethodInvocationAuthorizer` that allows any method execution as long as the target object does not belong to a Geode package, or does belong but it's marked as safe (see `RestrictedMethodAuthorizer.isAllowedGeodeMethod(Method, Object)`).
UnstartedSystemException
An `UnstartedSystemException` is thrown when the specified locator exists but is not running or could not be connected to.
UnsupportedOperationInTransactionException
Indicates that an attempt was mode to invoke an operation that is not allowed in a transaction.
UnsupportedVersionException
An `UnsupportedVersionException` indicates an unsupported version.
UpdateAllConfigurationGroupsMarker
This interface is implemented by gfsh commands that can potentially update the configuration for all groups (including the cluster-wide group, "cluster").
URLArgumentHandler
Argument handler implementation which accepts file paths or URLs and normalizes the parameters to URLs.
UsageException
Invalid usage exception.
VersionException
An `VersionException` is an exception that indicates a client / server version mismatch exception has occurred.
VisibleForTesting
Annotates a program element that exists, or is more widely visible than otherwise necessary, only for use in test code.
WritablePdxInstance
WritablePdxInstance is a `PdxInstance` that also supports field modification using the `setField` method.
XSDRootElement