Thrown when all connections in a pool are in use..

Thrown when an attempt is made to connect to DistributedSystem second time.

A gemfire assertion exception.

Factory class to create instances of RegionAttributesTKey, TValue.

Supports modification of certain region attributes after the region has been created.

Provides a distributed cache.

Thrown when authentication to the server fails.

Thrown when credentials are not provided to a server which expects them.

Thrown when the internal buffer size is exceeded.

Provides a distributed cache.

An immutable filename wrapper that can serve as a distributable key object for caching as well as being a string value.

A mutable ICacheableKey hash set wrapper that can serve as a distributable object for caching.

This class wraps the native C++ gemfire::Serializable objects as managed [!:../../IGFSerializable] objects.

A mutable ICacheableKey hash set wrapper that can serve as a distributable object for caching. This is provided for compability with java side though is functionally identical to CacheableHashSet i.e. does not provide the linked semantics of java LinkedHashSet.

An mutable generic [!:System.Object] wrapper that can serve as a distributable value for caching.

A mutable IGFSerializable object array wrapper that can serve as a distributable object for caching. Though this class provides compatibility with java Object[] serialization, it provides the semantics of .NET generic List class.

A mutable generic [!:System.Object] wrapper that can serve as a distributable value for caching.

Encapsulate an undefined result.

Defines attributes for configuring a cache.

Creates instances of CacheAttributes.

Thrown when an operation is attempted on a closed cache.

Thrown when an attempt is made to create an existing cache.

A factory class that must be used to obtain instance of Cache.

Utility class that implements all methods in ICacheListener with empty implementations. Applications can subclass this class and only override the methods for the events of interest.

Thrown when the cache listener throws an exception.

CacheLoader

Thrown when the cache loader aborts the operation.

Thrown when there is an error in the cache proxy.

Thrown when an exception occurs on the cache server.

Defines common statistical information for both the region and its entries.

CacheTransactionManager encapsulates the transactions for a cache

Utility class that implements all methods in ICacheWriter with empty implementations. Applications can subclass this class and only override the methods for the events of interest.

Thrown when the cache writer aborts the operation.

Thrown when the cache xml is incorrect.

Thrown when a cast operation fails.

Thrown if commit fails.

Thrown when a concurrent operation fails.

Defines attributes for configuring a cq.

Creates instances of CqAttributes.

Supports modification of certain cq attributes after the cq has been created.

Thrown if the Cq on which the operaion performed is closed

This class encapsulates events that occur for cq.

Thrown during continuous query execution time.

Thrown if a Cq by this name already exists on this client

Thrown when cq is invalid

Class to encapsulate a continuous query (CQ).

Thrown if the Cq Query failed

Defines common statistical information for cqservice

Static class containing convenience methods for CqState.

Defines common statistical information for a cq.

Provides operations for reading primitive data values, byte arrays, strings, IGFSerializable objects from a byte stream.

Thrown by the persistence manager when the data to be read from disk is corrupt.

Thrown by the persistence manager when a write fails due to disk failure.

Static class containing convenience methods for DiskPolicyType.

DistributedSystem encapsulates this applications "connection" into the GemFire Java servers.

Thrown when a duplicate durable client id is provided to the server.

Thrown when an operation is attempted on a destroyed entry.

This class encapsulates events that occur for an entry in a region.

Thrown when attempt is made to create an existing entry.

Thrown when an operation is attempted on a non-existent entry.

This class encapsulates events that occur for cq.

Static class containing convenience methods for ExpirationAction.

Thrown when there is a fatal internal exception in GemFire.

Thrown when a non-existing file is accessed.

Thrown when function execution failed

Static class containing the classIds of the built-in cacheable types.

Thrown when gemfire configuration file is incorrect.

The base exception class of all managed GemFire exceptions.

Thrown when there is an input/output error.

Thrown when an argument to a method is illegal.

Thrown when the state of cache is manipulated to be illegal.

Thrown when persistence manager fails to initialize.

Thrown when an operation is interrupted.

Thrown if a Key is not present in the region.

Thrown when lease of cache proxy has expired.

Defines methods available to clients that want to write a log message to their GemFire system's shared log file.

Thrown when an unknown message is received from the server.

Thrown when a client is unable to contact any locators.

Thrown when the connecting target is not running.

Thrown when a client operation is not authorized on the server.

Thrown when an operation is attempted before connecting to the distributed system.

Thrown when an attempt is made to release a lock not owned by the thread.

Thrown when a null argument is provided to a method where it is expected to be non-null.

Thrown when the system cannot allocate any more memory.

Thrown when bound of array/vector etc. is exceeded.

A pool of connections.

This interface provides for the configuration and creation of instances of Pool.

This interface provides for the configuration and creation of instances of PoolFactory.

Provides a collection of properties, each of which is a key/value pair. Each key is a string, and the value may be a string or an integer.

Class to encapsulate a query.

Thrown when query exception occurs at the server.

Provides a query service.

Defines attributes for configuring a region.

Thrown when a region creation operation fails.

Thrown when an operation is attempted on a destroyed region.

An object in a region that represents an entry, that is, a key-value pair.

This class encapsulates events that occur for a region.

Thrown when an attempt is made to create an existing region.

This interface provides for the configuration and creation of instances of Region.

collect function execution results, default collector

Encapsulates a query result set. It specifies the interface for the resultset obtained from the Gemfire cache server

Static class containing convenience methods for ScopeType.

Iterator for a query result.

This class wraps the native C++ gemfire::Serializable objects as managed IGFSerializable objects.

Thrown when persistence manager fails to close properly.

A class that describes an individual statistic whose value is updated by an application and may be archived by GemFire. These descriptions are gathered together in a StatisticsType class.

An instantiation of an existing StatisticsType object with methods for setting, incrementing and getting individual StatisticDescriptor values.

Thrown when statistics are invoked for a region where they are disabled.

Instances of this interface provide methods that create instances of StatisticDescriptor and StatisticsType. Every StatisticsFactory is also a type factory.

This class is used to describe a logical collection of StatisticDescriptors.These descriptions are used to create an instance of Statistics class.

Encapsulates a row of query struct set.

Encapsulates a query struct set.

A class for internal use, that encapsulates the properties that can be set through [!:DistributedSystem.Connect] or a gfcpp.properties file.

Thrown when a timout occurs.

Thrown if transaction delegate went down.

Thrown if commit rebalance happens during a transaction.

This class encapsulates Id of a transaction.

An unknown exception occurred.

Thrown when an operation unsupported by the current configuration is attempted.

UserFunctionExecutionException class is used to encapsulate gemfire sendException in case of Function execution.

Thrown when a region is created in an incorrect scope.

Specifies the mechanism to obtain credentials for a client. It is mandantory for clients when the server is running in secure mode having a security-client-authenticator module specified. Implementations should register the library path as security-client-auth-library system property and factory function (a zero argument function returning pointer to an AuthInitialize object) as the security-client-auth-factory system property. For a managed class implementing IAuthInitialize the fully qualified name of the factory function should be provided in the form {Namespace}.{Class Name}.{Method Name} as the security-client-auth-factory property.

This interface class is the superclass of all user objects in the cache that can be used as a key.

An application plug-in that can be installed on a region.

A data-loading application plug-in that can be installed on a region.

An application plug-in that can be installed on a region. Defines methods that are called before entry modification, such as writing the value to a database.

An application plug-in that can be installed on a region. Listener change notifications are invoked after the change has occured.

An application plug-in that can be installed on a region. Listener change notifications are invoked after the change has occured.

Interface to encapsulate a select query result set.

Extension of CqListener. Adds two new methods to CqListener, one that is called when the cq is connected and one that is called when the cq is disconnected.

GemFireCache represents the singleton cache that must be created in order to connect to Gemfire server.

This interface is used for delta propagation. To use delta propagation, an application class must implement interfaces IGFDelta as well as IGFSerializable. The IGFDelta interface methods HasDelta( ), ToDelta( ) and FromDelta( ) must be implemented by the class, as these methods are used by GemFire to detect the presence of delta in an object, to serialize the delta, and to apply a serialized delta to an existing object of the class. If a customized cloning method is required, the class must also implement the interface System.ICloneable. To use cloning in delta propagation for a region, the region attribute for cloning must be enabled.

This interface class is the superclass of all user objects in the cache that can be serialized.

PdxInstance provides run time access to the fields of a PDX without deserializing the PDX. Preventing deserialization saves time and memory and does not require the domain class. This interface is implemented by NativeClient. The PdxInstance implementation is a light weight wrapper that simply refers to the raw bytes of the PDX that are kept in the cache. Applications can choose to access PdxInstances instead of .NET objects by configuring the Cache to prefer PDX instances during deserialization. This can be done in cache.xml by setting the attribute read-serialized to true on the pdx element. Or it can be done programmatically using the [!:CacheFactory.SetPdxReadSerialized] method. Once this preference is configured, then any time deserialization of a PDX is done it will deserialize into a PdxInstance. PdxInstance are immutable. If you want to change one call [!:IPdxInstance.CreateWriter].

PdxInstanceFactory gives you a way to create PdxInstances. Call the write methods to populate the field data and then call Create to produce an actual instance that contains the data. To create a factory call [!:IRegionService.CreatePdxInstanceFactory]. A factory can only create a single instance. To create multiple instances create multiple factories or use [!:IPdxInstance.CreateWriter] to create subsequent instances.

A IPdxReader will be passed to IPdxSerializable.fromData or during deserialization of a PDX. The domain class needs to deserialize field members using this interface. This interface is implemented by Native Client. Each readXXX call will return the field's value. If the serialized PDX does not contain the named field then a default value will be returned. Standard Java defaults are used. For Objects this is null and for primitives it is 0 or 0.0.

When a domain class implements PdxSerializable it marks itself as a PDX. The implementation of toData provides the serialization code and fromData provides the deserialization code. These methods also define each field name and field type of the PDX. Domain classes should serialize and de-serialize all its member fields in same order in toData and fromData method. A domain class which implements this interface should register delgate [!:Serializable.RegisterPdxType] to create new instance of type for de-serilization.

The IPdxSerializer interface allows domain classes to be serialized and deserialized as PDXs without modification of the domain class. A domain class should register delgate [!:Serializable.RegisterPdxType] to create new instance of type for de-serilization.

Application can implement this interface to map pdx type name to local type name. Need to set this using [!:Serializable.SetPdxTypeMapper]

Serialize the data in gemfire Portable Data eXchange(Pdx) Format. This format provides class versioning(forward and backward compability of types) in cache. This provides ability to query .NET domian objects.

A IPdxWriter will be passed to IPdxSerializable.toData when it is serializing the domain class. The domain class needs to serialize member fields using this interface. This interface is implemented by Native Client.

IPersistenceManager interface for persistence and overflow. This class abstracts the disk-related operations in case of persistence or overflow to disk. A specific disk storage implementation will implement all the methods described here.

collect function execution results, can be overriden

Interface to encapsulate a select query result set.

WritablePdxInstance is a [!:IPdxInstance] that also supports field modification using the SetField(String, Object)method. To get a WritablePdxInstance call [!:IPdxInstance.CreateWriter].

Signature of function delegates passed to [!:Serializable.RegisterPdxType]. Such functions should return an empty instance of the type they represent. New instance will be created during de-serialization of Pdx Types IPdxSerializable.

Delegate that represents visitor for the Properties class.

Signature of function delegates passed to [!:Serializable.RegisterType]. Such functions should return an empty instance of the type they represent. The delegate shall be stored in the internal DelegateWrapper class and an instance will be initialized in the DelegateWrapper.NativeDelegate method by a call to [!:IGFSerializable.FromData].

Enumerated type for CqOperationType

Enumerated type for cq state @nativeclient For Native Clients: @endnativeclient

Enumerated type for disk policy. Contains values for setting the disk policy type.

Enumerated type for expiration (LRU) actions. Contains values for setting an action type.

Enumerated type for pdx FieldType

Logging levels.

Enumerated type for region distribution scope. Contains values for setting Scope. Local scope is invalid (it is a non-native client local region), and DistributedAck and DistributedNoAck have the same behavior.