geode-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From echobr...@apache.org
Subject [21/27] geode-native git commit: GEODE-2729: Remove global variables
Date Thu, 10 Aug 2017 15:20:29 GMT
http://git-wip-us.apache.org/repos/asf/geode-native/blob/da389793/src/cppcache/include/geode/Region.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/geode/Region.hpp b/src/cppcache/include/geode/Region.hpp
index b7fc10a..15e2da1 100644
--- a/src/cppcache/include/geode/Region.hpp
+++ b/src/cppcache/include/geode/Region.hpp
@@ -33,8 +33,8 @@
 #include "CacheableBuiltins.hpp"
 
 /**
-* @file
-*/
+ * @file
+ */
 
 #include "RegionEntry.hpp"
 #include "CacheListener.hpp"
@@ -86,30 +86,30 @@ namespace client {
 */
 class CPPCACHE_EXPORT Region : public std::enable_shared_from_this<Region> {
   /** @brief Public Methods
-  */
+   */
  public:
   /** return single name of region. The storage is backed by the region. */
   virtual const char* getName() const = 0;
   // virtual uint64_t getUpdateReceived() const { return 0; };
 
   /** return the full path of the region as can be used to lookup the
-  * region from Cache::getRegion. The storage is backed by the region.
-  */
+   * region from Cache::getRegion. The storage is backed by the region.
+   */
   virtual const char* getFullPath() const = 0;
 
   /** Returns the parent region, or nullptr if a root region.
-  * @throws RegionDestroyedException
-  */
+   * @throws RegionDestroyedException
+   */
   virtual RegionPtr getParentRegion() const = 0;
 
   /** Return the RegionAttributes for this region.
-  */
+   */
   virtual RegionAttributesPtr getAttributes() const = 0;
 
   /** Return the a mutator object for changing a subset of the region
-  * attributes.
-  * @throws RegionDestroyedException.
-  */
+   * attributes.
+   * @throws RegionDestroyedException.
+   */
   virtual AttributesMutatorPtr getAttributesMutator() const = 0;
 
   // virtual void updateAccessOrModifiedTime() = 0;
@@ -117,22 +117,21 @@ class CPPCACHE_EXPORT Region : public std::enable_shared_from_this<Region> {
   virtual CacheStatisticsPtr getStatistics() const = 0;
 
   /** Invalidates this region. The invalidation will cascade to
-  * all the subregions and cached entries. After
-  * the <code>invalidateRegion</code> , the region and the entries in it still
-  * exist. In order to remove all the entries and the region,
-  * <code>destroyRegion</code> should be used.
-  *
-  * @param aCallbackArgument a user-defined parameter to pass to callback events
-  *        triggered by this method.
-  *        Can be nullptr. If it is sent on the wire, it has to be Serializable.
-  * @throws CacheListenerException if CacheListener throws an exception; if this
-  *         occurs some subregions may have already been successfully
-  * invalidated
-  * @throws RegionDestroyedException if the region is no longer valid
-  * @see   destroyRegion
-  * @see   CacheListener::afterRegionInvalidate
-  * This operation is not distributed.
-  */
+   * all the subregions and cached entries. After
+   * the <code>invalidateRegion</code> , the region and the entries in it still
+   * exist. In order to remove all the entries and the region,
+   * <code>destroyRegion</code> should be used.
+   *
+   * @param aCallbackArgument a user-defined parameter to pass to callback
+   * events triggered by this method. Can be nullptr. If it is sent on the wire,
+   * it has to be Serializable.
+   * @throws CacheListenerException if CacheListener throws an exception; if
+   * this occurs some subregions may have already been successfully invalidated
+   * @throws RegionDestroyedException if the region is no longer valid
+   * @see   destroyRegion
+   * @see   CacheListener::afterRegionInvalidate
+   * This operation is not distributed.
+   */
   virtual void invalidateRegion(
       const UserDataPtr& aCallbackArgument = nullptr) = 0;
 
@@ -159,42 +158,41 @@ class CPPCACHE_EXPORT Region : public std::enable_shared_from_this<Region> {
       const UserDataPtr& aCallbackArgument = nullptr) = 0;
 
   /** Destroys the whole region and provides a user-defined parameter
-  * object to any <code>CacheWriter</code> invoked in the process.
-  * Destroy cascades to all entries
-  * and subregions. After the destroy, this region object cannot be used
-  * any more. Any attempt to use this region object will get a
-  * <code>RegionDestroyedException</code> exception.
-  *
-  * The region destroy not only destroys the local region but also destroys the
-  * server region. However, if server region destroy fails throwing back
-  * <code>CacheServerException</code> or security exception,
-  * the local region is still destroyed.
-  *
-  * @param aCallbackArgument a user-defined parameter to pass to callback events
-  *        triggered by this call.
-  *        Can be nullptr. If it is sent on the wire, it has to be Serializable.
-  * @throws CacheWriterException if CacheWriter aborts the operation; if this
-  *         occurs some subregions may have already been successfully destroyed.
-  * @throws CacheListenerException if CacheListener throws an exception; if this
-  *         occurs some subregions may have already been successfully
-  * invalidated
-  * @throws CacheServerException If an exception is received from the Java cache
-  * server.
-  *         Only for Native Client regions.
-  * @throws NotConnectedException if not connected to the geode system because
-  * the client
-  *         cannot establish usable connections to any of the servers given to
-  * it.
-  *         For pools configured with locators, if no locators are available,
-  * the cause
-  *         of NotConnectedException is set to NoAvailableLocatorsException.
-  * @throws MessageExcepton If the message received from server could not be
-  *         handled. This will be the case when an unregistered typeId is
-  *         received in the reply or reply is not well formed.
-  *         More information can be found in the log.
-  * @throws TimeoutException if operation timed out
-  * @see  invalidateRegion
-  */
+   * object to any <code>CacheWriter</code> invoked in the process.
+   * Destroy cascades to all entries
+   * and subregions. After the destroy, this region object cannot be used
+   * any more. Any attempt to use this region object will get a
+   * <code>RegionDestroyedException</code> exception.
+   *
+   * The region destroy not only destroys the local region but also destroys the
+   * server region. However, if server region destroy fails throwing back
+   * <code>CacheServerException</code> or security exception,
+   * the local region is still destroyed.
+   *
+   * @param aCallbackArgument a user-defined parameter to pass to callback
+   * events triggered by this call. Can be nullptr. If it is sent on the wire,
+   * it has to be Serializable.
+   * @throws CacheWriterException if CacheWriter aborts the operation; if this
+   *         occurs some subregions may have already been successfully
+   * destroyed.
+   * @throws CacheListenerException if CacheListener throws an exception; if
+   * this occurs some subregions may have already been successfully invalidated
+   * @throws CacheServerException If an exception is received from the Java
+   * cache server. Only for Native Client regions.
+   * @throws NotConnectedException if not connected to the geode system because
+   * the client
+   *         cannot establish usable connections to any of the servers given to
+   * it.
+   *         For pools configured with locators, if no locators are available,
+   * the cause
+   *         of NotConnectedException is set to NoAvailableLocatorsException.
+   * @throws MessageExcepton If the message received from server could not be
+   *         handled. This will be the case when an unregistered typeId is
+   *         received in the reply or reply is not well formed.
+   *         More information can be found in the log.
+   * @throws TimeoutException if operation timed out
+   * @see  invalidateRegion
+   */
   virtual void destroyRegion(
       const UserDataPtr& aCallbackArgument = nullptr) = 0;
   /**
@@ -215,24 +213,24 @@ class CPPCACHE_EXPORT Region : public std::enable_shared_from_this<Region> {
   virtual void localClear(const UserDataPtr& aCallbackArgument = nullptr) = 0;
 
   /** Destroys the whole region and provides a user-defined parameter
-  * object to any <code>CacheWriter</code> invoked in the process.
-  * Destroy cascades to all entries
-  * and subregions. After the destroy, this region object cannot be used
-  * any more. Any attempt to use this region object will get a
-  * <code>RegionDestroyedException</code> exception. The region destroy is not
-  * distributed to other caches.
-  *
-  * @param aCallbackArgument a user-defined parameter to pass to callback events
-  *        triggered by this call.
-  *        Can be nullptr. If it is sent on the wire, it has to be Serializable.
-  * @throws CacheWriterException if CacheWriter aborts the operation; if this
-  *         occurs some subregions may have already been successfully destroyed.
-  * @throws CacheListenerException if CacheListener throws an exception; if this
-  *         occurs some subregions may have already been successfully
-  * invalidated
-  *
-  * @see  localInvalidateRegion
-  */
+   * object to any <code>CacheWriter</code> invoked in the process.
+   * Destroy cascades to all entries
+   * and subregions. After the destroy, this region object cannot be used
+   * any more. Any attempt to use this region object will get a
+   * <code>RegionDestroyedException</code> exception. The region destroy is not
+   * distributed to other caches.
+   *
+   * @param aCallbackArgument a user-defined parameter to pass to callback
+   * events triggered by this call. Can be nullptr. If it is sent on the wire,
+   * it has to be Serializable.
+   * @throws CacheWriterException if CacheWriter aborts the operation; if this
+   *         occurs some subregions may have already been successfully
+   * destroyed.
+   * @throws CacheListenerException if CacheListener throws an exception; if
+   * this occurs some subregions may have already been successfully invalidated
+   *
+   * @see  localInvalidateRegion
+   */
   virtual void localDestroyRegion(
       const UserDataPtr& aCallbackArgument = nullptr) = 0;
 
@@ -246,17 +244,17 @@ class CPPCACHE_EXPORT Region : public std::enable_shared_from_this<Region> {
       const RegionAttributesPtr& aRegionAttributes) = 0;
 
   /** Populates the passed in VectorOfRegion with subregions of the current
-  * region
-  * @param recursive determines whether the method recursively fills in
-  * subregions
-  * @param[out] sr subregions
-  * @throws RegionDestroyedException
-  */
+   * region
+   * @param recursive determines whether the method recursively fills in
+   * subregions
+   * @param[out] sr subregions
+   * @throws RegionDestroyedException
+   */
   virtual void subregions(const bool recursive, VectorOfRegion& sr) = 0;
 
   /** Return the meta-object RegionEntry for key.
-  * @throws IllegalArgumentException, RegionDestroyedException.
-  */
+   * @throws IllegalArgumentException, RegionDestroyedException.
+   */
   virtual RegionEntryPtr getEntry(const CacheableKeyPtr& key) = 0;
 
   /** Convenience method allowing key to be a const char* */
@@ -266,46 +264,46 @@ class CPPCACHE_EXPORT Region : public std::enable_shared_from_this<Region> {
   }
 
   /** Returns the value associated with the specified key, passing the callback
-  * argument to any cache loaders that are invoked in the
-  * operation.
-  * If the value is not present locally then it is requested from the java
-  *server.
-  * If even that is unsuccessful then a local CacheLoader will be invoked if
-  *there is one.
-  * The value returned by get is not copied, so multi-threaded applications
-  * should not modify the value directly, but should use the update methods.
-  *<p>
-  * Updates the {@link CacheStatistics::getLastAccessedTime},
-  * {@link CacheStatistics::getHitCount}, {@link CacheStatistics::getMissCount},
-  * and {@link CacheStatistics::getLastModifiedTime} (if a new value is loaded)
-  * for this region and the entry.
-  *
-  * @param key whose associated value is to be returned. The key Object must
-  * implement the equals and hashCode methods.
-  * @param aCallbackArgument an argument passed into the CacheLoader if
-  * loader is used. If it is sent on the wire, it has to be Serializable.
-  *
-  * @throws IllegalArgumentException if key is nullptr or aCallbackArgument is
-  *         not serializable and a remote CacheLoader needs to be invoked
-  * @throws CacheLoaderException if CacheLoader throws an exception
-  * @throws CacheServerException If an exception is received from the Java cache
-  *server.
-  *         Only for Native Client regions.
-  * @throws NotConnectedException if it is not connected to the cache because
-  *the client
-  *         cannot establish usable connections to any of the servers given to
-  *it.
-  *         For pools configured with locators, if no locators are available,
-  *the cause
-  *         of NotConnectedException is set to NoAvailableLocatorsException.
-  * @throws MessageExcepton If the message received from server could not be
-  *         handled. This will be the case when an unregistered typeId is
-  *         received in the reply or reply is not well formed.
-  *         More information can be found in the log.
-  * @throws TimeoutException if operation timed out
-  * @throws RegionDestroyedException if the method is called on a destroyed
-  *region
-  **/
+   * argument to any cache loaders that are invoked in the
+   * operation.
+   * If the value is not present locally then it is requested from the java
+   *server.
+   * If even that is unsuccessful then a local CacheLoader will be invoked if
+   *there is one.
+   * The value returned by get is not copied, so multi-threaded applications
+   * should not modify the value directly, but should use the update methods.
+   *<p>
+   * Updates the {@link CacheStatistics::getLastAccessedTime},
+   * {@link CacheStatistics::getHitCount}, {@link
+   *CacheStatistics::getMissCount}, and {@link
+   *CacheStatistics::getLastModifiedTime} (if a new value is loaded) for this
+   *region and the entry.
+   *
+   * @param key whose associated value is to be returned. The key Object must
+   * implement the equals and hashCode methods.
+   * @param aCallbackArgument an argument passed into the CacheLoader if
+   * loader is used. If it is sent on the wire, it has to be Serializable.
+   *
+   * @throws IllegalArgumentException if key is nullptr or aCallbackArgument is
+   *         not serializable and a remote CacheLoader needs to be invoked
+   * @throws CacheLoaderException if CacheLoader throws an exception
+   * @throws CacheServerException If an exception is received from the Java
+   *cache server. Only for Native Client regions.
+   * @throws NotConnectedException if it is not connected to the cache because
+   *the client
+   *         cannot establish usable connections to any of the servers given to
+   *it.
+   *         For pools configured with locators, if no locators are available,
+   *the cause
+   *         of NotConnectedException is set to NoAvailableLocatorsException.
+   * @throws MessageExcepton If the message received from server could not be
+   *         handled. This will be the case when an unregistered typeId is
+   *         received in the reply or reply is not well formed.
+   *         More information can be found in the log.
+   * @throws TimeoutException if operation timed out
+   * @throws RegionDestroyedException if the method is called on a destroyed
+   *region
+   **/
   virtual CacheablePtr get(const CacheableKeyPtr& key,
                            const UserDataPtr& aCallbackArgument = nullptr) = 0;
 
@@ -317,48 +315,50 @@ class CPPCACHE_EXPORT Region : public std::enable_shared_from_this<Region> {
   }
 
   /** Places a new value into an entry in this region with the specified key,
-  * providing a user-defined parameter
-  * object to any <code>CacheWriter</code> invoked in the process.
-  * The same parameter is also passed to the <code>CacheListener</code>,
-  * if one is defined for this <code>Region</code>, invoked in the process.
-  * If there is already an entry associated with the specified key in this
-  * region,
-  * the entry's previous value is overwritten.
-  * The new put value is propogated to the java server to which it is connected
-  * with.
-  * <p>Updates the {@link CacheStatistics::getLastAccessedTime} and
-  * {@link CacheStatistics::getLastModifiedTime} for this region and the entry.
-  *
-  * If remote server put fails throwing back a <code>CacheServerException</code>
-  * or security exception, then local put is tried to rollback. However, if the
-  * entry has overflowed/evicted/expired then the rollback is aborted since it
-  * may be due to a more recent notification or update by another thread.
-  *
-  * @param key a key smart pointer associated with the value to be put into this
-  * region.
-  * @param value the value to be put into the cache
-  * @param aCallbackArgument an argument that is passed to the callback function
-  *
-  * @throws IllegalArgumentException if key or value is nullptr
-  * @throws CacheWriterException if CacheWriter aborts the operation
-  * @throws CacheListenerException if CacheListener throws an exception
-  * @throws RegionDestroyedException if region no longer valid
-  * @throws CacheServerException If an exception is received from the Java cache
-  * server.
-  * @throws NotConnectedException if it is not connected to the cache because
-  * the client
-  *         cannot establish usable connections to any of the servers given to
-  * it
-  *         For pools configured with locators, if no locators are available,
-  * the cause
-  *         of NotConnectedException is set to NoAvailableLocatorsException.
-  * @throws MessageExcepton If the message received from server could not be
-  *         handled. This will be the case when an unregistered typeId is
-  *         received in the reply or reply is not well formed.
-  *         More information can be found in the log.
-  * @throws TimeoutException if operation timed out
-  * @throws OutOfMemoryException if  not enoough memory for the value
-  */
+   * providing a user-defined parameter
+   * object to any <code>CacheWriter</code> invoked in the process.
+   * The same parameter is also passed to the <code>CacheListener</code>,
+   * if one is defined for this <code>Region</code>, invoked in the process.
+   * If there is already an entry associated with the specified key in this
+   * region,
+   * the entry's previous value is overwritten.
+   * The new put value is propogated to the java server to which it is connected
+   * with.
+   * <p>Updates the {@link CacheStatistics::getLastAccessedTime} and
+   * {@link CacheStatistics::getLastModifiedTime} for this region and the entry.
+   *
+   * If remote server put fails throwing back a
+   * <code>CacheServerException</code> or security exception, then local put is
+   * tried to rollback. However, if the entry has overflowed/evicted/expired
+   * then the rollback is aborted since it may be due to a more recent
+   * notification or update by another thread.
+   *
+   * @param key a key smart pointer associated with the value to be put into
+   * this region.
+   * @param value the value to be put into the cache
+   * @param aCallbackArgument an argument that is passed to the callback
+   * function
+   *
+   * @throws IllegalArgumentException if key or value is nullptr
+   * @throws CacheWriterException if CacheWriter aborts the operation
+   * @throws CacheListenerException if CacheListener throws an exception
+   * @throws RegionDestroyedException if region no longer valid
+   * @throws CacheServerException If an exception is received from the Java
+   * cache server.
+   * @throws NotConnectedException if it is not connected to the cache because
+   * the client
+   *         cannot establish usable connections to any of the servers given to
+   * it
+   *         For pools configured with locators, if no locators are available,
+   * the cause
+   *         of NotConnectedException is set to NoAvailableLocatorsException.
+   * @throws MessageExcepton If the message received from server could not be
+   *         handled. This will be the case when an unregistered typeId is
+   *         received in the reply or reply is not well formed.
+   *         More information can be found in the log.
+   * @throws TimeoutException if operation timed out
+   * @throws OutOfMemoryException if  not enoough memory for the value
+   */
   virtual void put(const CacheableKeyPtr& key, const CacheablePtr& value,
                    const UserDataPtr& aCallbackArgument = nullptr) = 0;
 
@@ -457,51 +457,51 @@ class CPPCACHE_EXPORT Region : public std::enable_shared_from_this<Region> {
   }
 
   /** Creates a new entry in this region with the specified key and value,
-  * providing a user-defined parameter
-  * object to any <code>CacheWriter</code> invoked in the process.
-  * The same parameter is also passed to the <code>CacheListener</code>,
-  * if one is defined for this <code>Region</code>, invoked in the process.
-  * The new entry is propogated to the java server also to which it is connected
-  * with.
-  * <p>Updates the {@link CacheStatistics::getLastAccessedTime} and
-  * {@link CacheStatistics::getLastModifiedTime} for this region and the entry.
-  * <p>
-  *
-  * If remote server put fails throwing back a <code>CacheServerException</code>
-  * or security exception, then local put is tried to rollback. However, if the
-  * entry has overflowed/evicted/expired then the rollback is aborted since it
-  * may be due to a more recent notification or update by another thread.
-  *
-  * @param key the key smart pointer for which to create the entry in this
-  * region.
-  * @param value the value for the new entry, which may be nullptr meaning
-  *              the new entry starts as if it had been locally invalidated.
-  * @param aCallbackArgument a user-defined parameter to pass to callback events
-  *        triggered by this method. Can be nullptr. Should be serializable if
-  *        passed to remote callback events
-  * @throws IllegalArgumentException if key is nullptr or if the key, value, or
-  *         aCallbackArgument do not meet serializability requirements
-  * @throws CacheWriterException if CacheWriter aborts the operation
-  * @throws CacheListenerException if CacheListener throws an exception
-  * @throws RegionDestroyedException if region is no longer valid
-  * @throws CacheServerException If an exception is received from the Java cache
-  * server.
-  *         Only for Native Client regions.
-  * @throws NotConnectedException if it is not connected to the cache because
-  * the client
-  *         cannot establish usable connections to any of the servers given to
-  * it
-  *         For pools configured with locators, if no locators are available,
-  * the cause
-  *         of NotConnectedException is set to NoAvailableLocatorsException.
-  * @throws MessageExcepton If the message received from server could not be
-  *         handled. This will be the case when an unregistered typeId is
-  *         received in the reply or reply is not well formed.
-  *         More information can be found in the log.
-  * @throws TimeoutException if the operation timed out
-  * @throws OutOfMemoryException if no memory for new entry
-  * @throws EntryExistsException if an entry with this key already exists
-  */
+   * providing a user-defined parameter
+   * object to any <code>CacheWriter</code> invoked in the process.
+   * The same parameter is also passed to the <code>CacheListener</code>,
+   * if one is defined for this <code>Region</code>, invoked in the process.
+   * The new entry is propogated to the java server also to which it is
+   * connected with. <p>Updates the {@link CacheStatistics::getLastAccessedTime}
+   * and
+   * {@link CacheStatistics::getLastModifiedTime} for this region and the entry.
+   * <p>
+   *
+   * If remote server put fails throwing back a
+   * <code>CacheServerException</code> or security exception, then local put is
+   * tried to rollback. However, if the entry has overflowed/evicted/expired
+   * then the rollback is aborted since it may be due to a more recent
+   * notification or update by another thread.
+   *
+   * @param key the key smart pointer for which to create the entry in this
+   * region.
+   * @param value the value for the new entry, which may be nullptr meaning
+   *              the new entry starts as if it had been locally invalidated.
+   * @param aCallbackArgument a user-defined parameter to pass to callback
+   * events triggered by this method. Can be nullptr. Should be serializable if
+   *        passed to remote callback events
+   * @throws IllegalArgumentException if key is nullptr or if the key, value, or
+   *         aCallbackArgument do not meet serializability requirements
+   * @throws CacheWriterException if CacheWriter aborts the operation
+   * @throws CacheListenerException if CacheListener throws an exception
+   * @throws RegionDestroyedException if region is no longer valid
+   * @throws CacheServerException If an exception is received from the Java
+   * cache server. Only for Native Client regions.
+   * @throws NotConnectedException if it is not connected to the cache because
+   * the client
+   *         cannot establish usable connections to any of the servers given to
+   * it
+   *         For pools configured with locators, if no locators are available,
+   * the cause
+   *         of NotConnectedException is set to NoAvailableLocatorsException.
+   * @throws MessageExcepton If the message received from server could not be
+   *         handled. This will be the case when an unregistered typeId is
+   *         received in the reply or reply is not well formed.
+   *         More information can be found in the log.
+   * @throws TimeoutException if the operation timed out
+   * @throws OutOfMemoryException if no memory for new entry
+   * @throws EntryExistsException if an entry with this key already exists
+   */
   virtual void create(const CacheableKeyPtr& key, const CacheablePtr& value,
                       const UserDataPtr& aCallbackArgument = nullptr) = 0;
 
@@ -577,27 +577,27 @@ class CPPCACHE_EXPORT Region : public std::enable_shared_from_this<Region> {
   }
 
   /** Invalidates the entry with the specified key,
-  * and provides a user-defined argument to the <code>CacheListener</code>.
-  * Invalidate only removes the value from the entry, the key is kept intact.
-  * To completely remove the entry, destroy should be used.
-  * The invalidate is not propogated to the Geode cache server to which it is
-  * connected with.
-  * <p>Updates the {@link CacheStatistics::getLastAccessedTime} and
-  * {@link CacheStatistics::getLastModifiedTime} for this region and the entry.
-  * <p>
-  *
-  * @param key the key of the value to be invalidated
-  * @param aCallbackArgument a user-defined parameter to pass to callback events
-  *        triggered by this method. Can be nullptr. Should be serializable if
-  *        passed to remote callback events
-  * @throws IllegalArgumentException if key is nullptr
-  * @throws CacheListenerException if CacheListener throws an exception
-  * @throws EntryNotFoundException if this entry does not exist in this region
-  * locally
-  * @throws RegionDestroyedException if the region is destroyed
-  * @see destroy
-  * @see CacheListener::afterInvalidate
-  */
+   * and provides a user-defined argument to the <code>CacheListener</code>.
+   * Invalidate only removes the value from the entry, the key is kept intact.
+   * To completely remove the entry, destroy should be used.
+   * The invalidate is not propogated to the Geode cache server to which it is
+   * connected with.
+   * <p>Updates the {@link CacheStatistics::getLastAccessedTime} and
+   * {@link CacheStatistics::getLastModifiedTime} for this region and the entry.
+   * <p>
+   *
+   * @param key the key of the value to be invalidated
+   * @param aCallbackArgument a user-defined parameter to pass to callback
+   * events triggered by this method. Can be nullptr. Should be serializable if
+   *        passed to remote callback events
+   * @throws IllegalArgumentException if key is nullptr
+   * @throws CacheListenerException if CacheListener throws an exception
+   * @throws EntryNotFoundException if this entry does not exist in this region
+   * locally
+   * @throws RegionDestroyedException if the region is destroyed
+   * @see destroy
+   * @see CacheListener::afterInvalidate
+   */
   virtual void invalidate(const CacheableKeyPtr& key,
                           const UserDataPtr& aCallbackArgument = nullptr) = 0;
 
@@ -608,25 +608,25 @@ class CPPCACHE_EXPORT Region : public std::enable_shared_from_this<Region> {
   }
 
   /** Invalidates the entry with the specified key in the local cache only,
-  * and provides a user-defined argument to the <code>CacheListener</code>.
-  * Invalidate only removes the value from the entry, the key is kept intact.
-  * To completely remove the entry, destroy should be used.
-  * <p>Updates the {@link CacheStatistics::getLastAccessedTime} and
-  * {@link CacheStatistics::getLastModifiedTime} for this region and the entry.
-  * <p>
-  *
-  * @param key the key of the value to be invalidated
-  * @param aCallbackArgument a user-defined parameter to pass to callback events
-  *        triggered by this method. Can be nullptr. Should be serializable if
-  *        passed to remote callback events
-  * @throws IllegalArgumentException if key is nullptr
-  * @throws CacheListenerException if CacheListener throws an exception
-  * @throws EntryNotFoundException if this entry does not exist in this region
-  * locally
-  * @throws RegionDestroyedException if the region is destroyed
-  * @see destroy
-  * @see CacheListener::afterInvalidate
-  */
+   * and provides a user-defined argument to the <code>CacheListener</code>.
+   * Invalidate only removes the value from the entry, the key is kept intact.
+   * To completely remove the entry, destroy should be used.
+   * <p>Updates the {@link CacheStatistics::getLastAccessedTime} and
+   * {@link CacheStatistics::getLastModifiedTime} for this region and the entry.
+   * <p>
+   *
+   * @param key the key of the value to be invalidated
+   * @param aCallbackArgument a user-defined parameter to pass to callback
+   * events triggered by this method. Can be nullptr. Should be serializable if
+   *        passed to remote callback events
+   * @throws IllegalArgumentException if key is nullptr
+   * @throws CacheListenerException if CacheListener throws an exception
+   * @throws EntryNotFoundException if this entry does not exist in this region
+   * locally
+   * @throws RegionDestroyedException if the region is destroyed
+   * @see destroy
+   * @see CacheListener::afterInvalidate
+   */
   virtual void localInvalidate(
       const CacheableKeyPtr& key,
       const UserDataPtr& aCallbackArgument = nullptr) = 0;
@@ -639,49 +639,49 @@ class CPPCACHE_EXPORT Region : public std::enable_shared_from_this<Region> {
   }
 
   /** Destroys the entry with the specified key, and provides a user-defined
-  * parameter object to any <code>CacheWriter</code> invoked in the process.
-  * The same parameter is also passed to the <code>CacheListener</code>,
-  * if one is defined for this <code>Region</code>, invoked in the process.
-  * Destroy removes
-  * not only the value, but also the key and entry from this region.
-  *
-  * The destroy is propogated to the Geode cache server to which it is
-  * connected with. If the destroy fails due to an exception on server
-  * throwing back <code>CacheServerException</code> or security exception,
-  * then the local entry is still destroyed.
-  *
-  * <p>Updates the {@link CacheStatistics::getLastAccessedTime} and
-  * {@link CacheStatistics::getLastModifiedTime} for this region and the entry.
-  * <p>
-  *
-  * @param key the key of the entry to destroy
-  * @param aCallbackArgument a user-defined parameter to pass to callback events
-  *        triggered by this method.
-  *        Can be nullptr. If it is sent on the wire, it has to be Serializable.
-  * @throws IllegalArgumentException if key is nullptr
-  * @throws CacheWriterException if CacheWriter aborts the operation
-  * @throws CacheListenerException if CacheListener throws an exception
-  * @throws CacheServerException If an exception is received from the Geode
-  * cache server.
-  *         Only for Native Client regions.
-  * @throws NotConnectedException if it is not connected to the cache because
-  * the client
-  *         cannot establish usable connections to any of the servers given to
-  * it
-  *         For pools configured with locators, if no locators are available,
-  * the cause
-  *         of NotConnectedException is set to NoAvailableLocatorsException.
-  * @throws MessageExcepton If the message received from server could not be
-  *         handled. This will be the case when an unregistered typeId is
-  *         received in the reply or reply is not well formed.
-  *         More information can be found in the log.
-  * @throws TimeoutException if the operation timed out
-  * @throws RegionDestroyedException if the region is destroyed.
-  * @throws EntryNotFoundException if the entry does not exist in this region.
-  * @see invalidate
-  * @see CacheListener::afterDestroy
-  * @see CacheWriter::beforeDestroy
-  */
+   * parameter object to any <code>CacheWriter</code> invoked in the process.
+   * The same parameter is also passed to the <code>CacheListener</code>,
+   * if one is defined for this <code>Region</code>, invoked in the process.
+   * Destroy removes
+   * not only the value, but also the key and entry from this region.
+   *
+   * The destroy is propogated to the Geode cache server to which it is
+   * connected with. If the destroy fails due to an exception on server
+   * throwing back <code>CacheServerException</code> or security exception,
+   * then the local entry is still destroyed.
+   *
+   * <p>Updates the {@link CacheStatistics::getLastAccessedTime} and
+   * {@link CacheStatistics::getLastModifiedTime} for this region and the entry.
+   * <p>
+   *
+   * @param key the key of the entry to destroy
+   * @param aCallbackArgument a user-defined parameter to pass to callback
+   * events triggered by this method. Can be nullptr. If it is sent on the wire,
+   * it has to be Serializable.
+   * @throws IllegalArgumentException if key is nullptr
+   * @throws CacheWriterException if CacheWriter aborts the operation
+   * @throws CacheListenerException if CacheListener throws an exception
+   * @throws CacheServerException If an exception is received from the Geode
+   * cache server.
+   *         Only for Native Client regions.
+   * @throws NotConnectedException if it is not connected to the cache because
+   * the client
+   *         cannot establish usable connections to any of the servers given to
+   * it
+   *         For pools configured with locators, if no locators are available,
+   * the cause
+   *         of NotConnectedException is set to NoAvailableLocatorsException.
+   * @throws MessageExcepton If the message received from server could not be
+   *         handled. This will be the case when an unregistered typeId is
+   *         received in the reply or reply is not well formed.
+   *         More information can be found in the log.
+   * @throws TimeoutException if the operation timed out
+   * @throws RegionDestroyedException if the region is destroyed.
+   * @throws EntryNotFoundException if the entry does not exist in this region.
+   * @see invalidate
+   * @see CacheListener::afterDestroy
+   * @see CacheWriter::beforeDestroy
+   */
   virtual void destroy(const CacheableKeyPtr& key,
                        const UserDataPtr& aCallbackArgument = nullptr) = 0;
 
@@ -726,53 +726,53 @@ class CPPCACHE_EXPORT Region : public std::enable_shared_from_this<Region> {
   }
 
   /** Removes the entry with the specified key, value and provides a
-  * user-defined
-  * parameter object to any <code>CacheWriter</code> invoked in the process.
-  * The same parameter is also passed to the <code>CacheListener</code> and
-  * <code>CacheWriter</code>,
-  * if one is defined for this <code>Region</code>, invoked in the process.
-  * remove removes
-  * not only the value, but also the key and entry from this region.
-  *
-  * The remove is propogated to the Geode cache server to which it is
-  * connected with. If the destroy fails due to an exception on server
-  * throwing back <code>CacheServerException</code> or security exception,
-  * then the local entry is still removed.
-  *
-  * <p>Updates the {@link CacheStatistics::getLastAccessedTime} and
-  * {@link CacheStatistics::getLastModifiedTime} for this region and the entry.
-  * <p>
-  *
-  * @param key the key of the entry to remove
-  * @param value the value of the key to remove, it can be nullptr.
-  * @param aCallbackArgument a user-defined parameter to pass to callback events
-  *        triggered by this method.
-  *        Can be nullptr. If it is sent on the wire, it has to be Serializable.
-  * @throws IllegalArgumentException if key is nullptr
-  * @throws CacheWriterException if CacheWriter aborts the operation
-  * @throws CacheListenerException if CacheListener throws an exception
-  * @throws CacheServerException If an exception is received from the Geode
-  * cache server.
-  *         Only for Native Client regions.
-  * @throws NotConnectedException if it is not connected to the cache because
-  * the client
-  *         cannot establish usable connections to any of the servers given to
-  * it
-  *         For pools configured with locators, if no locators are available,
-  * the cause
-  *         of NotConnectedException is set to NoAvailableLocatorsException.
-  * @throws MessageExcepton If the message received from server could not be
-  *         handled. This will be the case when an unregistered typeId is
-  *         received in the reply or reply is not well formed.
-  *         More information can be found in the log.
-  * @throws TimeoutException if the operation timed out
-  * @throws RegionDestroyedException if the region is destroyed.
-  * @return the boolean true if an entry(key, value)has been removed or
-  * false if an entry(key, value) has not been removed.
-  * @see destroy
-  * @see CacheListener::afterDestroy
-  * @see CacheWriter::beforeDestroy
-  */
+   * user-defined
+   * parameter object to any <code>CacheWriter</code> invoked in the process.
+   * The same parameter is also passed to the <code>CacheListener</code> and
+   * <code>CacheWriter</code>,
+   * if one is defined for this <code>Region</code>, invoked in the process.
+   * remove removes
+   * not only the value, but also the key and entry from this region.
+   *
+   * The remove is propogated to the Geode cache server to which it is
+   * connected with. If the destroy fails due to an exception on server
+   * throwing back <code>CacheServerException</code> or security exception,
+   * then the local entry is still removed.
+   *
+   * <p>Updates the {@link CacheStatistics::getLastAccessedTime} and
+   * {@link CacheStatistics::getLastModifiedTime} for this region and the entry.
+   * <p>
+   *
+   * @param key the key of the entry to remove
+   * @param value the value of the key to remove, it can be nullptr.
+   * @param aCallbackArgument a user-defined parameter to pass to callback
+   * events triggered by this method. Can be nullptr. If it is sent on the wire,
+   * it has to be Serializable.
+   * @throws IllegalArgumentException if key is nullptr
+   * @throws CacheWriterException if CacheWriter aborts the operation
+   * @throws CacheListenerException if CacheListener throws an exception
+   * @throws CacheServerException If an exception is received from the Geode
+   * cache server.
+   *         Only for Native Client regions.
+   * @throws NotConnectedException if it is not connected to the cache because
+   * the client
+   *         cannot establish usable connections to any of the servers given to
+   * it
+   *         For pools configured with locators, if no locators are available,
+   * the cause
+   *         of NotConnectedException is set to NoAvailableLocatorsException.
+   * @throws MessageExcepton If the message received from server could not be
+   *         handled. This will be the case when an unregistered typeId is
+   *         received in the reply or reply is not well formed.
+   *         More information can be found in the log.
+   * @throws TimeoutException if the operation timed out
+   * @throws RegionDestroyedException if the region is destroyed.
+   * @return the boolean true if an entry(key, value)has been removed or
+   * false if an entry(key, value) has not been removed.
+   * @see destroy
+   * @see CacheListener::afterDestroy
+   * @see CacheWriter::beforeDestroy
+   */
   virtual bool remove(const CacheableKeyPtr& key, const CacheablePtr& value,
                       const UserDataPtr& aCallbackArgument = nullptr) = 0;
 
@@ -806,51 +806,51 @@ class CPPCACHE_EXPORT Region : public std::enable_shared_from_this<Region> {
   }
 
   /** Removes the entry with the specified key and provides a user-defined
-  * parameter object to any <code>CacheWriter</code> invoked in the process.
-  * The same parameter is also passed to the <code>CacheListener</code> and
-  * <code>CacheWriter</code>,
-  * if one is defined for this <code>Region</code>, invoked in the process.
-  * remove removes
-  * not only the value, but also the key and entry from this region.
-  *
-  * The remove is propogated to the Geode cache server to which it is
-  * connected with. If the destroy fails due to an exception on server
-  * throwing back <code>CacheServerException</code> or security exception,
-  * then the local entry is still removed.
-  *
-  * <p>Updates the {@link CacheStatistics::getLastAccessedTime} and
-  * {@link CacheStatistics::getLastModifiedTime} for this region and the entry.
-  * <p>
-  *
-  * @param key the key of the entry to remove
-  * @param aCallbackArgument a user-defined parameter to pass to callback events
-  *        triggered by this method.
-  *        Can be nullptr. If it is sent on the wire, it has to be Serializable.
-  * @throws IllegalArgumentException if key is nullptr
-  * @throws CacheWriterException if CacheWriter aborts the operation
-  * @throws CacheListenerException if CacheListener throws an exception
-  * @throws CacheServerException If an exception is received from the Geode
-  * cache server.
-  *         Only for Native Client regions.
-  * @throws NotConnectedException if it is not connected to the cache because
-  * the client
-  *         cannot establish usable connections to any of the servers given to
-  * it
-  *         For pools configured with locators, if no locators are available,
-  * the cause
-  *         of NotConnectedException is set to NoAvailableLocatorsException.
-  * @throws MessageExcepton If the message received from server could not be
-  *         handled. This will be the case when an unregistered typeId is
-  *         received in the reply or reply is not well formed.
-  *         More information can be found in the log.
-  * @throws TimeoutException if the operation timed out
-  * @throws RegionDestroyedException if the region is destroyed.
-  * @return the boolean true if an entry(key, value)has been removed or
-  * false if an entry(key, value) has not been removed.
-  * @see destroy
-  * @see CacheListener::afterDestroy
-  * @see CacheWriter::beforeDestroy
-  */
+   * parameter object to any <code>CacheWriter</code> invoked in the process.
+   * The same parameter is also passed to the <code>CacheListener</code> and
+   * <code>CacheWriter</code>,
+   * if one is defined for this <code>Region</code>, invoked in the process.
+   * remove removes
+   * not only the value, but also the key and entry from this region.
+   *
+   * The remove is propogated to the Geode cache server to which it is
+   * connected with. If the destroy fails due to an exception on server
+   * throwing back <code>CacheServerException</code> or security exception,
+   * then the local entry is still removed.
+   *
+   * <p>Updates the {@link CacheStatistics::getLastAccessedTime} and
+   * {@link CacheStatistics::getLastModifiedTime} for this region and the entry.
+   * <p>
+   *
+   * @param key the key of the entry to remove
+   * @param aCallbackArgument a user-defined parameter to pass to callback
+   * events triggered by this method. Can be nullptr. If it is sent on the wire,
+   * it has to be Serializable.
+   * @throws IllegalArgumentException if key is nullptr
+   * @throws CacheWriterException if CacheWriter aborts the operation
+   * @throws CacheListenerException if CacheListener throws an exception
+   * @throws CacheServerException If an exception is received from the Geode
+   * cache server.
+   *         Only for Native Client regions.
+   * @throws NotConnectedException if it is not connected to the cache because
+   * the client
+   *         cannot establish usable connections to any of the servers given to
+   * it
+   *         For pools configured with locators, if no locators are available,
+   * the cause
+   *         of NotConnectedException is set to NoAvailableLocatorsException.
+   * @throws MessageExcepton If the message received from server could not be
+   *         handled. This will be the case when an unregistered typeId is
+   *         received in the reply or reply is not well formed.
+   *         More information can be found in the log.
+   * @throws TimeoutException if the operation timed out
+   * @throws RegionDestroyedException if the region is destroyed.
+   * @return the boolean true if an entry(key, value)has been removed or
+   * false if an entry(key, value) has not been removed.
+   * @see destroy
+   * @see CacheListener::afterDestroy
+   * @see CacheWriter::beforeDestroy
+   */
   virtual bool removeEx(const CacheableKeyPtr& key,
                         const UserDataPtr& aCallbackArgument = nullptr) = 0;
 
@@ -861,32 +861,32 @@ class CPPCACHE_EXPORT Region : public std::enable_shared_from_this<Region> {
   }
 
   /** Removes the entry with the specified key and value in the local cache
-  * only,
-  * and provides a user-defined parameter object to any
-  * <code>CacheWriter</code> invoked in the process.
-  * The same parameter is also passed to the <code>CacheListener</code> and
-  * <code>CacheWriter</code>,
-  * if one is defined for this <code>Region</code>, invoked in the process.
-  * Remove removes
-  * not only the value but also the key and entry from this region.
-  * <p>
-  * <p>Updates the {@link CacheStatistics::getLastAccessedTime} and
-  * {@link CacheStatistics::getLastModifiedTime} for this region and the entry.
-  * <p>
-  *
-  * @param key the key of the entry to remove.
-  * @param value the value of the entry to remove.
-  * @param aCallbackArgument the callback for user to pass in, default is
-  * nullptr.
-  * @throws IllegalArgumentException if key is nullptr
-  * @throws CacheWriterException if CacheWriter aborts the operation
-  * @throws CacheListenerException if CacheListener throws an exception
-  * @return the boolean true if an entry(key, value)has been removed or
-  * false if an entry(key, value) has not been removed.
-  * @see destroy
-  * @see CacheListener::afterDestroy
-  * @see CacheWriter::beforeDestroy
-  */
+   * only,
+   * and provides a user-defined parameter object to any
+   * <code>CacheWriter</code> invoked in the process.
+   * The same parameter is also passed to the <code>CacheListener</code> and
+   * <code>CacheWriter</code>,
+   * if one is defined for this <code>Region</code>, invoked in the process.
+   * Remove removes
+   * not only the value but also the key and entry from this region.
+   * <p>
+   * <p>Updates the {@link CacheStatistics::getLastAccessedTime} and
+   * {@link CacheStatistics::getLastModifiedTime} for this region and the entry.
+   * <p>
+   *
+   * @param key the key of the entry to remove.
+   * @param value the value of the entry to remove.
+   * @param aCallbackArgument the callback for user to pass in, default is
+   * nullptr.
+   * @throws IllegalArgumentException if key is nullptr
+   * @throws CacheWriterException if CacheWriter aborts the operation
+   * @throws CacheListenerException if CacheListener throws an exception
+   * @return the boolean true if an entry(key, value)has been removed or
+   * false if an entry(key, value) has not been removed.
+   * @see destroy
+   * @see CacheListener::afterDestroy
+   * @see CacheWriter::beforeDestroy
+   */
   virtual bool localRemove(const CacheableKeyPtr& key,
                            const CacheablePtr& value,
                            const UserDataPtr& aCallbackArgument = nullptr) = 0;
@@ -913,30 +913,30 @@ class CPPCACHE_EXPORT Region : public std::enable_shared_from_this<Region> {
   }
 
   /** Removes the entry with the specified key in the local cache only,
-  * and provides a user-defined parameter object to any
-  * <code>CacheWriter</code> invoked in the process.
-  * The same parameter is also passed to the <code>CacheListener</code> and
-  * <code>CacheWriter</code>,
-  * if one is defined for this <code>Region</code>, invoked in the process.
-  * Remove removes
-  * not only the value but also the key and entry from this region.
-  * <p>
-  * <p>Updates the {@link CacheStatistics::getLastAccessedTime} and
-  * {@link CacheStatistics::getLastModifiedTime} for this region and the entry.
-  * <p>
-  *
-  * @param key the key of the entry to remove.
-  * @param aCallbackArgument the callback for user to pass in, default is
-  * nullptr.
-  * @throws IllegalArgumentException if key is nullptr
-  * @throws CacheWriterException if CacheWriter aborts the operation
-  * @throws CacheListenerException if CacheListener throws an exception
-  * @return the boolean true if an entry(key, value)has been removed or
-  * false if an entry(key, value) has not been removed.
-  * @see destroy
-  * @see CacheListener::afterDestroy
-  * @see CacheWriter::beforeDestroy
-  */
+   * and provides a user-defined parameter object to any
+   * <code>CacheWriter</code> invoked in the process.
+   * The same parameter is also passed to the <code>CacheListener</code> and
+   * <code>CacheWriter</code>,
+   * if one is defined for this <code>Region</code>, invoked in the process.
+   * Remove removes
+   * not only the value but also the key and entry from this region.
+   * <p>
+   * <p>Updates the {@link CacheStatistics::getLastAccessedTime} and
+   * {@link CacheStatistics::getLastModifiedTime} for this region and the entry.
+   * <p>
+   *
+   * @param key the key of the entry to remove.
+   * @param aCallbackArgument the callback for user to pass in, default is
+   * nullptr.
+   * @throws IllegalArgumentException if key is nullptr
+   * @throws CacheWriterException if CacheWriter aborts the operation
+   * @throws CacheListenerException if CacheListener throws an exception
+   * @return the boolean true if an entry(key, value)has been removed or
+   * false if an entry(key, value) has not been removed.
+   * @see destroy
+   * @see CacheListener::afterDestroy
+   * @see CacheWriter::beforeDestroy
+   */
 
   virtual bool localRemoveEx(
       const CacheableKeyPtr& key,
@@ -950,42 +950,42 @@ class CPPCACHE_EXPORT Region : public std::enable_shared_from_this<Region> {
   }
 
   /**
-  * Return all the keys in the local process for this region. This includes
-  * keys for which the entry is invalid.
-  */
+   * Return all the keys in the local process for this region. This includes
+   * keys for which the entry is invalid.
+   */
   virtual void keys(VectorOfCacheableKey& v) = 0;
 
   /**
-  * Return the set of keys defined in the server process associated to this
-  * client and region. If a server has the region defined as a mirror, then
-  * this will be the entire keyset for the region across all PEER in the
-  * distributed system.
-  * The vector v will contain only the server keys. Any prior contents in the
-  * vector will be removed.
-  * @throws CacheServerException If an exception is received from the Geode
-  * cache server.
-  *         Only for Native Client regions.
-  * @throws NotConnectedException if it is not connected to the cache because
-  * the client
-  *         cannot establish usable connections to any of the servers given to
-  * it
-  *         For pools configured with locators, if no locators are available,
-  * the cause
-  *         of NotConnectedException is set to NoAvailableLocatorsException.
-  * @throws MessageExcepton If the message received from server could not be
-  *         handled. This will be the case when an unregistered typeId is
-  *         received in the reply or reply is not well formed.
-  *         More information can be found in the log.
-  * @throws TimeoutException if there is a timeout getting the keys
-  * @throws UnsupportedOperationException if the member type is not CLIENT
-  *                                       or region is not a native client one.
-  */
+   * Return the set of keys defined in the server process associated to this
+   * client and region. If a server has the region defined as a mirror, then
+   * this will be the entire keyset for the region across all PEER in the
+   * distributed system.
+   * The vector v will contain only the server keys. Any prior contents in the
+   * vector will be removed.
+   * @throws CacheServerException If an exception is received from the Geode
+   * cache server.
+   *         Only for Native Client regions.
+   * @throws NotConnectedException if it is not connected to the cache because
+   * the client
+   *         cannot establish usable connections to any of the servers given to
+   * it
+   *         For pools configured with locators, if no locators are available,
+   * the cause
+   *         of NotConnectedException is set to NoAvailableLocatorsException.
+   * @throws MessageExcepton If the message received from server could not be
+   *         handled. This will be the case when an unregistered typeId is
+   *         received in the reply or reply is not well formed.
+   *         More information can be found in the log.
+   * @throws TimeoutException if there is a timeout getting the keys
+   * @throws UnsupportedOperationException if the member type is not CLIENT
+   *                                       or region is not a native client one.
+   */
   virtual void serverKeys(VectorOfCacheableKey& v) = 0;
 
   /**
-  * Return all values in the local process for this region. No value is included
-  * for entries that are invalidated.
-  */
+   * Return all values in the local process for this region. No value is
+   * included for entries that are invalidated.
+   */
   virtual void values(VectorOfCacheable& vc) = 0;
 
   virtual void entries(VectorOfRegionEntry& me, bool recursive) = 0;
@@ -999,313 +999,313 @@ class CPPCACHE_EXPORT Region : public std::enable_shared_from_this<Region> {
   virtual bool isDestroyed() const = 0;
 
   /**
-  * This operations checks for the value in the local cache .
-  * It is not propagated to the Geode cache server
-  * to which it is connected.
-  */
+   * This operations checks for the value in the local cache .
+   * It is not propagated to the Geode cache server
+   * to which it is connected.
+   */
   virtual bool containsValueForKey(const CacheableKeyPtr& keyPtr) const = 0;
 
   /**
-  * Convenience method allowing key to be a const char*
-  * This operations checks for the value in the local cache .
-  * It is not propagated to the Geode cache server
-  * to which it is connected.
-  */
+   * Convenience method allowing key to be a const char*
+   * This operations checks for the value in the local cache .
+   * It is not propagated to the Geode cache server
+   * to which it is connected.
+   */
   template <class KEYTYPE>
   inline bool containsValueForKey(const KEYTYPE& key) const {
     return containsValueForKey(createKey(key));
   }
 
   /**
-  * Only the client's cache is searched for the key. It does not go to the java
-  * server
-  * to which it is connected with.
-  */
+   * Only the client's cache is searched for the key. It does not go to the java
+   * server
+   * to which it is connected with.
+   */
   virtual bool containsKey(const CacheableKeyPtr& keyPtr) const = 0;
   /**
-  * The cache of the server, to which it is connected with, is searched
-  * for the key to see if the key is present.
-  * @throws UnsupportedOperationException if the region's scope is
-  * ScopeType::LOCAL.
-  */
+   * The cache of the server, to which it is connected with, is searched
+   * for the key to see if the key is present.
+   * @throws UnsupportedOperationException if the region's scope is
+   * ScopeType::LOCAL.
+   */
   virtual bool containsKeyOnServer(const CacheableKeyPtr& keyPtr) const = 0;
   /**
-  * Returns the list of keys on which this client is interested and will be
-  * notified of changes.
-  * @throws UnsupportedOperationException if the region's scope is
-  * ScopeType::LOCAL.
-  */
+   * Returns the list of keys on which this client is interested and will be
+   * notified of changes.
+   * @throws UnsupportedOperationException if the region's scope is
+   * ScopeType::LOCAL.
+   */
   virtual void getInterestList(VectorOfCacheableKey& vlist) const = 0;
   /**
-  * Returns the list of regular expresssions on which this client is
-  * interested and will be notified of changes.
-  * @throws UnsupportedOperationException if the region's scope is
-  * ScopeType::LOCAL.
-  */
+   * Returns the list of regular expresssions on which this client is
+   * interested and will be notified of changes.
+   * @throws UnsupportedOperationException if the region's scope is
+   * ScopeType::LOCAL.
+   */
   virtual void getInterestListRegex(VectorOfCacheableString& vregex) const = 0;
   /**
-  * Convenience method allowing key to be a const char*
-  * This operations checks for the key in the local cache .
-  * It is not propagated to the Geode cache server
-  * to which it is connected.
-  */
+   * Convenience method allowing key to be a const char*
+   * This operations checks for the key in the local cache .
+   * It is not propagated to the Geode cache server
+   * to which it is connected.
+   */
   template <class KEYTYPE>
   inline bool containsKey(const KEYTYPE& key) const {
     return containsKey(createKey(key));
   }
 
   /**
-  * Registers an array of keys for getting updates from the server.
-  * Valid only for a Native Client region when client notification
-  * ( {@link AttributesFactory::setClientNotification} ) is true.
-  *
-  * @param keys the array of keys
-  * @param isDurable flag to indicate whether this is a durable registration
-  * @param getInitialValues true to populate the cache with values of the keys
-  *   that were registered on the server
-  * @param receiveValues whether to act like notify-by-subscription is set
-  *
-  * @throws IllegalArgumentException If the array of keys is empty.
-  * @throws IllegalStateException If already registered interest for all keys.
-  * @throws EntryNotFoundException If an exception occurs while obtaining
-  *   values from server after register interest is complete. The actual cause
-  *   of the exception can be obtained using <code>Exception::getCause</code>.
-  *   If an application wants to undo the registration on server, or take
-  *   some other steps for the incomplete cache population then this is
-  *   the exception that should be caught.
-  * @throws UnsupportedOperationException If the region is not a Native Client
-  * region or
-  * {@link AttributesFactory::setClientNotification} is false.
-  * @throws CacheServerException If an exception is received from the Java cache
-  * server.
-  * @throws NotConnectedException if it is not connected to the cache because
-  * the client
-  *         cannot establish usable connections to any of the servers given to
-  * it
-  *         For pools configured with locators, if no locators are available,
-  * the cause
-  *         of NotConnectedException is set to NoAvailableLocatorsException.
-  * @throws RegionDestroyedException If region destroy is pending.
-  * @throws UnknownException For other exceptions.
-  * @throws TimeoutException if operation timed out
-  */
+   * Registers an array of keys for getting updates from the server.
+   * Valid only for a Native Client region when client notification
+   * ( {@link AttributesFactory::setClientNotification} ) is true.
+   *
+   * @param keys the array of keys
+   * @param isDurable flag to indicate whether this is a durable registration
+   * @param getInitialValues true to populate the cache with values of the keys
+   *   that were registered on the server
+   * @param receiveValues whether to act like notify-by-subscription is set
+   *
+   * @throws IllegalArgumentException If the array of keys is empty.
+   * @throws IllegalStateException If already registered interest for all keys.
+   * @throws EntryNotFoundException If an exception occurs while obtaining
+   *   values from server after register interest is complete. The actual cause
+   *   of the exception can be obtained using <code>Exception::getCause</code>.
+   *   If an application wants to undo the registration on server, or take
+   *   some other steps for the incomplete cache population then this is
+   *   the exception that should be caught.
+   * @throws UnsupportedOperationException If the region is not a Native Client
+   * region or
+   * {@link AttributesFactory::setClientNotification} is false.
+   * @throws CacheServerException If an exception is received from the Java
+   * cache server.
+   * @throws NotConnectedException if it is not connected to the cache because
+   * the client
+   *         cannot establish usable connections to any of the servers given to
+   * it
+   *         For pools configured with locators, if no locators are available,
+   * the cause
+   *         of NotConnectedException is set to NoAvailableLocatorsException.
+   * @throws RegionDestroyedException If region destroy is pending.
+   * @throws UnknownException For other exceptions.
+   * @throws TimeoutException if operation timed out
+   */
   virtual void registerKeys(const VectorOfCacheableKey& keys,
                             bool isDurable = false,
                             bool getInitialValues = false,
                             bool receiveValues = true) = 0;
 
   /**
-  * Unregisters an array of keys to stop getting updates for them.
-  * Valid only for a Native Client region when client notification
-  * ( {@link AttributesFactory::setClientNotification} ) is true.
-  *
-  * @param keys the array of keys
-  *
-  * @throws IllegalArgumentException If the array of keys is empty.
-  * @throws IllegalStateException If no keys were previously registered.
-  * @throws UnsupportedOperationException If the region is not a Native Client
-  * region or
-  * {@link AttributesFactory::setClientNotification} is false.
-  * @throws CacheServerException If an exception is received from the Java cache
-  * server.
-  * @throws NotConnectedException if it is not connected to the cache because
-  * the client
-  *         cannot establish usable connections to any of the servers given to
-  * it
-  *         For pools configured with locators, if no locators are available,
-  * the cause
-  *         of NotConnectedException is set to NoAvailableLocatorsException.
-  * @throws RegionDestroyedException If region destroy is pending.
-  * @throws UnknownException For other exceptions.
-  * @throws TimeoutException if operation timed out
-  */
+   * Unregisters an array of keys to stop getting updates for them.
+   * Valid only for a Native Client region when client notification
+   * ( {@link AttributesFactory::setClientNotification} ) is true.
+   *
+   * @param keys the array of keys
+   *
+   * @throws IllegalArgumentException If the array of keys is empty.
+   * @throws IllegalStateException If no keys were previously registered.
+   * @throws UnsupportedOperationException If the region is not a Native Client
+   * region or
+   * {@link AttributesFactory::setClientNotification} is false.
+   * @throws CacheServerException If an exception is received from the Java
+   * cache server.
+   * @throws NotConnectedException if it is not connected to the cache because
+   * the client
+   *         cannot establish usable connections to any of the servers given to
+   * it
+   *         For pools configured with locators, if no locators are available,
+   * the cause
+   *         of NotConnectedException is set to NoAvailableLocatorsException.
+   * @throws RegionDestroyedException If region destroy is pending.
+   * @throws UnknownException For other exceptions.
+   * @throws TimeoutException if operation timed out
+   */
   virtual void unregisterKeys(const VectorOfCacheableKey& keys) = 0;
 
   /**
-  * Registers to get updates for all keys from the server.
-  * Valid only for a Native Client region when client notification
-  * ( {@link AttributesFactory::setClientNotification} ) is true.
-  *
-  * @param isDurable flag to indicate whether this is a durable registration
-  * @param resultKeys If non-nullptr then all the keys on the server that got
-  *   registered are returned. The vector is cleared at the start to discard
-  *   any existing keys in the vector.
-  * @param getInitialValues true to populate the cache with values of all keys
-  *   from the server
-  * @param receiveValues whether to act like notify-by-subscription is set
-  *
-  * @throws EntryNotFoundException If an exception occurs while obtaining
-  *   values from server after register interest is complete. The actual cause
-  *   of the exception can be obtained using <code>Exception::getCause</code>.
-  *   If an application wants to undo the registration on server, or take
-  *   some other steps for the incomplete cache population then this is
-  *   the exception that should be caught.
-  * @throws UnsupportedOperationException If the region is not a Native Client
-  * region or
-  * {@link AttributesFactory::setClientNotification} is false.
-  * @throws CacheServerException If an exception is received from the Java cache
-  * server.
-  * @throws NotConnectedException if it is not connected to the cache because
-  * the client
-  *         cannot establish usable connections to any of the servers given to
-  * it
-  *         For pools configured with locators, if no locators are available,
-  * the cause
-  *         of NotConnectedException is set to NoAvailableLocatorsException.
-  * @throws RegionDestroyedException If region destroy is pending.
-  * @throws UnknownException For other exceptions.
-  * @throws TimeoutException if operation timed out
-  */
+   * Registers to get updates for all keys from the server.
+   * Valid only for a Native Client region when client notification
+   * ( {@link AttributesFactory::setClientNotification} ) is true.
+   *
+   * @param isDurable flag to indicate whether this is a durable registration
+   * @param resultKeys If non-nullptr then all the keys on the server that got
+   *   registered are returned. The vector is cleared at the start to discard
+   *   any existing keys in the vector.
+   * @param getInitialValues true to populate the cache with values of all keys
+   *   from the server
+   * @param receiveValues whether to act like notify-by-subscription is set
+   *
+   * @throws EntryNotFoundException If an exception occurs while obtaining
+   *   values from server after register interest is complete. The actual cause
+   *   of the exception can be obtained using <code>Exception::getCause</code>.
+   *   If an application wants to undo the registration on server, or take
+   *   some other steps for the incomplete cache population then this is
+   *   the exception that should be caught.
+   * @throws UnsupportedOperationException If the region is not a Native Client
+   * region or
+   * {@link AttributesFactory::setClientNotification} is false.
+   * @throws CacheServerException If an exception is received from the Java
+   * cache server.
+   * @throws NotConnectedException if it is not connected to the cache because
+   * the client
+   *         cannot establish usable connections to any of the servers given to
+   * it
+   *         For pools configured with locators, if no locators are available,
+   * the cause
+   *         of NotConnectedException is set to NoAvailableLocatorsException.
+   * @throws RegionDestroyedException If region destroy is pending.
+   * @throws UnknownException For other exceptions.
+   * @throws TimeoutException if operation timed out
+   */
   virtual void registerAllKeys(bool isDurable = false,
                                VectorOfCacheableKeyPtr resultKeys = nullptr,
                                bool getInitialValues = false,
                                bool receiveValues = true) = 0;
 
   /**
-  * Registers to get updates for all keys from the server.
-  * Valid only for a Native Client region when client notification
-  * ( {@link AttributesFactory::setClientNotification} ) is true.
-  *
-  * @throws IllegalStateException If not previously registered all keys.
-  * @throws UnsupportedOperationException If the region is not a Native Client
-  * region or
-  * {@link AttributesFactory::setClientNotification} is false.
-  * @throws CacheServerException If an exception is received from the Java cache
-  * server.
-  * @throws NotConnectedException if it is not connected to the cache because
-  * the client
-  *         cannot establish usable connections to any of the servers given to
-  * it
-  *         For pools configured with locators, if no locators are available,
-  * the cause
-  *         of NotConnectedException is set to NoAvailableLocatorsException.
-  * @throws RegionDestroyedException If region destroy is pending.
-  * @throws UnknownException For other exceptions.
-  * @throws TimeoutException if operation timed out
-  */
+   * Registers to get updates for all keys from the server.
+   * Valid only for a Native Client region when client notification
+   * ( {@link AttributesFactory::setClientNotification} ) is true.
+   *
+   * @throws IllegalStateException If not previously registered all keys.
+   * @throws UnsupportedOperationException If the region is not a Native Client
+   * region or
+   * {@link AttributesFactory::setClientNotification} is false.
+   * @throws CacheServerException If an exception is received from the Java
+   * cache server.
+   * @throws NotConnectedException if it is not connected to the cache because
+   * the client
+   *         cannot establish usable connections to any of the servers given to
+   * it
+   *         For pools configured with locators, if no locators are available,
+   * the cause
+   *         of NotConnectedException is set to NoAvailableLocatorsException.
+   * @throws RegionDestroyedException If region destroy is pending.
+   * @throws UnknownException For other exceptions.
+   * @throws TimeoutException if operation timed out
+   */
   virtual void unregisterAllKeys() = 0;
 
   /**
-  * Registers a regular expression to match with keys to get updates from the
-  * server.
-  * Valid only for a Native Client region when client notification
-  * ( {@link AttributesFactory::setClientNotification} ) is true.
-  *
-  * @param regex The regular expression string.
-  * @param isDurable flag to indicate whether this is a durable registration
-  * @param resultKeys If non-nullptr then the keys that match the regular
-  *   expression on the server are returned. The vector is cleared at the
-  *   start to discard any existing keys in the vector.
-  * @param getInitialValues true to populate the cache with values of the keys
-  *   that were registered on the server
-  * @param receiveValues whether to act like notify-by-subscription is set
-  *
-  * @throws IllegalArgumentException If regex is empty.
-  * @throws IllegalStateException If already registered interest for all keys.
-  * @throws EntryNotFoundException If an exception occurs while obtaining
-  *   values from server after register interest is complete. The actual cause
-  *   of the exception can be obtained using <code>Exception::getCause</code>.
-  *   If an application wants to undo the registration on server, or take
-  *   some other steps for the incomplete cache population then this is
-  *   the exception that should be caught.
-  * @throws UnsupportedOperationException If the region is not a Native Client
-  * region or
-  * {@link AttributesFactory::setClientNotification} is false.
-  * @throws CacheServerException If an exception is received from the Java cache
-  * server.
-  * @throws NotConnectedException if it is not connected to the cache because
-  * the client
-  *         cannot establish usable connections to any of the servers given to
-  * it
-  *         For pools configured with locators, if no locators are available,
-  * the cause
-  *         of NotConnectedException is set to NoAvailableLocatorsException.
-  * @throws MessageExcepton If the message received from server could not be
-  *         handled. This will be the case when an unregistered typeId is
-  *         received in the reply or reply is not well formed.
-  *         More information can be found in the log.
-  * @throws RegionDestroyedException If region destroy is pending.
-  * @throws UnknownException For other exceptions.
-  * @throws TimeoutException if operation timed out
-  */
+   * Registers a regular expression to match with keys to get updates from the
+   * server.
+   * Valid only for a Native Client region when client notification
+   * ( {@link AttributesFactory::setClientNotification} ) is true.
+   *
+   * @param regex The regular expression string.
+   * @param isDurable flag to indicate whether this is a durable registration
+   * @param resultKeys If non-nullptr then the keys that match the regular
+   *   expression on the server are returned. The vector is cleared at the
+   *   start to discard any existing keys in the vector.
+   * @param getInitialValues true to populate the cache with values of the keys
+   *   that were registered on the server
+   * @param receiveValues whether to act like notify-by-subscription is set
+   *
+   * @throws IllegalArgumentException If regex is empty.
+   * @throws IllegalStateException If already registered interest for all keys.
+   * @throws EntryNotFoundException If an exception occurs while obtaining
+   *   values from server after register interest is complete. The actual cause
+   *   of the exception can be obtained using <code>Exception::getCause</code>.
+   *   If an application wants to undo the registration on server, or take
+   *   some other steps for the incomplete cache population then this is
+   *   the exception that should be caught.
+   * @throws UnsupportedOperationException If the region is not a Native Client
+   * region or
+   * {@link AttributesFactory::setClientNotification} is false.
+   * @throws CacheServerException If an exception is received from the Java
+   * cache server.
+   * @throws NotConnectedException if it is not connected to the cache because
+   * the client
+   *         cannot establish usable connections to any of the servers given to
+   * it
+   *         For pools configured with locators, if no locators are available,
+   * the cause
+   *         of NotConnectedException is set to NoAvailableLocatorsException.
+   * @throws MessageExcepton If the message received from server could not be
+   *         handled. This will be the case when an unregistered typeId is
+   *         received in the reply or reply is not well formed.
+   *         More information can be found in the log.
+   * @throws RegionDestroyedException If region destroy is pending.
+   * @throws UnknownException For other exceptions.
+   * @throws TimeoutException if operation timed out
+   */
   virtual void registerRegex(const char* regex, bool isDurable = false,
                              VectorOfCacheableKeyPtr resultKeys = nullptr,
                              bool getInitialValues = false,
                              bool receiveValues = true) = 0;
 
   /**
-  * Unregisters a regular expression to stop getting updates for keys from the
-  * server.
-  * Valid only for a Native Client region when client notification
-  * ( {@link AttributesFactory::setClientNotification} ) is true.
-  *
-  * @param regex The regular expression string.
-  *
-  * @throws IllegalArgumentException If regex is empty.
-  * @throws IllegalStateException If not previously registered this regular
-  * expression string.
-  * @throws UnsupportedOperationException If the region is not a Native Client
-  * region or
-  * {@link AttributesFactory::setClientNotification} is false.
-  * @throws CacheServerException If an exception is received from the Java cache
-  * server.
-  * @throws NotConnectedException if it is not connected to the cache because
-  * the client
-  *         cannot establish usable connections to any of the servers given to
-  * it
-  *         For pools configured with locators, if no locators are available,
-  * the cause
-  *         of NotConnectedException is set to NoAvailableLocatorsException.
-  * @throws RegionDestroyedException If region destroy is pending.
-  * @throws UnknownException For other exceptions.
-  * @throws TimeoutException if operation timed out
-  */
+   * Unregisters a regular expression to stop getting updates for keys from the
+   * server.
+   * Valid only for a Native Client region when client notification
+   * ( {@link AttributesFactory::setClientNotification} ) is true.
+   *
+   * @param regex The regular expression string.
+   *
+   * @throws IllegalArgumentException If regex is empty.
+   * @throws IllegalStateException If not previously registered this regular
+   * expression string.
+   * @throws UnsupportedOperationException If the region is not a Native Client
+   * region or
+   * {@link AttributesFactory::setClientNotification} is false.
+   * @throws CacheServerException If an exception is received from the Java
+   * cache server.
+   * @throws NotConnectedException if it is not connected to the cache because
+   * the client
+   *         cannot establish usable connections to any of the servers given to
+   * it
+   *         For pools configured with locators, if no locators are available,
+   * the cause
+   *         of NotConnectedException is set to NoAvailableLocatorsException.
+   * @throws RegionDestroyedException If region destroy is pending.
+   * @throws UnknownException For other exceptions.
+   * @throws TimeoutException if operation timed out
+   */
   virtual void unregisterRegex(const char* regex) = 0;
 
   /**
-  * Gets values for an array of keys from the local cache or server.
-  * If value for a key is not present locally then it is requested from the
-  * java server. The value returned is not copied, so multi-threaded
-  * applications should not modify the value directly,
-  * but should use the update methods.
-  *<p>
-  * Updates the {@link CacheStatistics::getLastAccessedTime},
-  * {@link CacheStatistics::getHitCount} and {@link
-  *CacheStatistics::getMissCount}
-  * for this region and the entry.
-  *
-  * @param keys the array of keys
-  * @param values Output parameter that provides the map of keys to
-  *   respective values. It is ignored if nullptr, and when nullptr then at
-  *least
-  *   the <code>addToLocalCache</code> parameter should be true and caching
-  *   should be enabled for the region to get values into the region
-  *   otherwise an <code>IllegalArgumentException</code> is thrown.
-  * @param exceptions Output parameter that provides the map of keys
-  *   to any exceptions while obtaining the key. It is ignored if nullptr.
-  * @param addToLocalCache true if the obtained values have also to be added
-  *   to the local cache
-  * @since 8.1
-  * @param aCallbackArgument an argument that is passed to the callback
-  *functions.
-  * It may be nullptr. Must be serializable if this operation is distributed.
-  * @throws IllegalArgumentException If the array of keys is empty. Other
-  *   invalid case is when the <code>values</code> parameter is nullptr, and
-  *   either <code>addToLocalCache</code> is false or caching is disabled
-  *   for this region.
-  * @throws CacheServerException If an exception is received from the Java
-  *   cache server while processing the request.
-  * @throws NotConnectedException if it is not connected to the cache because
-  *   the client cannot establish usable connections to any of the given servers
-  *   For pools configured with locators, if no locators are available, the
-  *cause
-  *   of NotConnectedException is set to NoAvailableLocatorsException.
-  * @throws RegionDestroyedException If region destroy is pending.
-  * @throws TimeoutException if operation timed out.
-  * @throws UnknownException For other exceptions.
-  *
-  * @see get
-  */
+   * Gets values for an array of keys from the local cache or server.
+   * If value for a key is not present locally then it is requested from the
+   * java server. The value returned is not copied, so multi-threaded
+   * applications should not modify the value directly,
+   * but should use the update methods.
+   *<p>
+   * Updates the {@link CacheStatistics::getLastAccessedTime},
+   * {@link CacheStatistics::getHitCount} and {@link
+   *CacheStatistics::getMissCount}
+   * for this region and the entry.
+   *
+   * @param keys the array of keys
+   * @param values Output parameter that provides the map of keys to
+   *   respective values. It is ignored if nullptr, and when nullptr then at
+   *least
+   *   the <code>addToLocalCache</code> parameter should be true and caching
+   *   should be enabled for the region to get values into the region
+   *   otherwise an <code>IllegalArgumentException</code> is thrown.
+   * @param exceptions Output parameter that provides the map of keys
+   *   to any exceptions while obtaining the key. It is ignored if nullptr.
+   * @param addToLocalCache true if the obtained values have also to be added
+   *   to the local cache
+   * @since 8.1
+   * @param aCallbackArgument an argument that is passed to the callback
+   *functions.
+   * It may be nullptr. Must be serializable if this operation is distributed.
+   * @throws IllegalArgumentException If the array of keys is empty. Other
+   *   invalid case is when the <code>values</code> parameter is nullptr, and
+   *   either <code>addToLocalCache</code> is false or caching is disabled
+   *   for this region.
+   * @throws CacheServerException If an exception is received from the Java
+   *   cache server while processing the request.
+   * @throws NotConnectedException if it is not connected to the cache because
+   *   the client cannot establish usable connections to any of the given
+   *servers For pools configured with locators, if no locators are available,
+   *the cause of NotConnectedException is set to
+   *NoAvailableLocatorsException.
+   * @throws RegionDestroyedException If region destroy is pending.
+   * @throws TimeoutException if operation timed out.
+   * @throws UnknownException For other exceptions.
+   *
+   * @see get
+   */
   virtual void getAll(const VectorOfCacheableKey& keys,
                       HashMapOfCacheablePtr values,
                       HashMapOfExceptionPtr exceptions,
@@ -1313,121 +1313,119 @@ class CPPCACHE_EXPORT Region : public std::enable_shared_from_this<Region> {
                       const UserDataPtr& aCallbackArgument = nullptr) = 0;
 
   /**
-  * Executes the query on the server based on the predicate.
-  * Valid only for a Native Client region.
-  *
-  * @param predicate The query predicate (just the WHERE clause) or the entire
-  * query to execute.
-  * @param timeout The time (in seconds) to wait for the query response,
-  * optional.
-  *        This should be less than or equal to 2^31/1000 i.e. 2147483.
-  *
-  * @throws IllegalArgumentException If predicate is empty or timeout
-  *         parameter is greater than 2^31/1000.
-  * @throws QueryException if some query error occurred at the server.
-  * @throws CacheServerException If an exception is received from the Java cache
-  * server.
-  * @throws NotConnectedException if a server connection error occurs.
-  *         For pools configured with locators, if no locators are available,
-  * the cause
-  *         of NotConnectedException is set to NoAvailableLocatorsException.
-  * @throws MessageExcepton If the message received from server could not be
-  *         handled. This will be the case when an unregistered typeId is
-  *         received in the reply or reply is not well formed.
-  *         More information can be found in the log.
-  * @throws TimeoutException if operation timed out
-  * @throws CacheClosedException if the cache has been closed
-  *
-  * @returns A smart pointer to the SelectResults which can either be a
-  * ResultSet or a StructSet.
-  */
+   * Executes the query on the server based on the predicate.
+   * Valid only for a Native Client region.
+   *
+   * @param predicate The query predicate (just the WHERE clause) or the entire
+   * query to execute.
+   * @param timeout The time (in seconds) to wait for the query response,
+   * optional.
+   *        This should be less than or equal to 2^31/1000 i.e. 2147483.
+   *
+   * @throws IllegalArgumentException If predicate is empty or timeout
+   *         parameter is greater than 2^31/1000.
+   * @throws QueryException if some query error occurred at the server.
+   * @throws CacheServerException If an exception is received from the Java
+   * cache server.
+   * @throws NotConnectedException if a server connection error occurs.
+   *         For pools configured with locators, if no locators are available,
+   * the cause
+   *         of NotConnectedException is set to NoAvailableLocatorsException.
+   * @throws MessageExcepton If the message received from server could not be
+   *         handled. This will be the case when an unregistered typeId is
+   *         received in the reply or reply is not well formed.
+   *         More information can be found in the log.
+   * @throws TimeoutException if operation timed out
+   * @throws CacheClosedException if the cache has been closed
+   *
+   * @returns A smart pointer to the SelectResults which can either be a
+   * ResultSet or a StructSet.
+   */
   virtual SelectResultsPtr query(
       const char* predicate,
       uint32_t timeout = DEFAULT_QUERY_RESPONSE_TIMEOUT) = 0;
 
   /**
-  * Executes the query on the server based on the predicate and returns whether
-  * any result exists.
-  * Valid only for a Native Client region.
-  * @param predicate The query predicate (just the WHERE clause) or the entire
-  * query to execute.
-  * @param timeout The time (in seconds) to wait for the response, optional.
-  *        This should be less than or equal to 2^31/1000 i.e. 2147483.
-  * @throws IllegalArgumentException If predicate is empty or timeout
-  *         parameter is greater than 2^31/1000.
-  * @throws QueryException if some query error occurred at the server.
-  * @throws NotConnectedException if a server connection error occurs.
-  *         For pools configured with locators, if no locators are available,
-  * the cause
-  *         of NotConnectedException is set to NoAvailableLocatorsException.
-  * @throws MessageExcepton If the message received from server could not be
-  *         handled. This will be the case when the reply is not well formed.
-  *         More information can be found in the log.
-  * @throws TimeoutException if operation timed out
-  * @throws CacheClosedException if the cache has been closed
-  * @returns true if the result size is non-zero, false otherwise.
-  */
+   * Executes the query on the server based on the predicate and returns whether
+   * any result exists.
+   * Valid only for a Native Client region.
+   * @param predicate The query predicate (just the WHERE clause) or the entire
+   * query to execute.
+   * @param timeout The time (in seconds) to wait for the response, optional.
+   *        This should be less than or equal to 2^31/1000 i.e. 2147483.
+   * @throws IllegalArgumentException If predicate is empty or timeout
+   *         parameter is greater than 2^31/1000.
+   * @throws QueryException if some query error occurred at the server.
+   * @throws NotConnectedException if a server connection error occurs.
+   *         For pools configured with locators, if no locators are available,
+   * the cause
+   *         of NotConnectedException is set to NoAvailableLocatorsException.
+   * @throws MessageExcepton If the message received from server could not be
+   *         handled. This will be the case when the reply is not well forme

<TRUNCATED>

Mime
View raw message