geode-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From jbarr...@apache.org
Subject [27/46] geode-native git commit: GEODE-2741: Remove custom shared pointer from cppcache
Date Wed, 17 May 2017 17:50:09 GMT
http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/cppcache/include/geode/CacheableBuiltins.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/geode/CacheableBuiltins.hpp b/src/cppcache/include/geode/CacheableBuiltins.hpp
index 610225e..3abbab3 100644
--- a/src/cppcache/include/geode/CacheableBuiltins.hpp
+++ b/src/cppcache/include/geode/CacheableBuiltins.hpp
@@ -139,10 +139,6 @@ class CacheableKeyType : public CacheableKey {
   virtual uint32_t objectSize() const { return sizeof(CacheableKeyType); }
 };
 
-// Forward declaration for SharedArrayPtr
-template <typename TObj, int8_t TYPEID>
-class SharedArrayPtr;
-
 /** Function to copy an array from source to destination. */
 template <typename TObj>
 inline void copyArray(TObj* dest, const TObj* src, int32_t length) {
@@ -201,6 +197,8 @@ class CacheableArrayType : public Cacheable {
 
   virtual ~CacheableArrayType() { GF_SAFE_DELETE_ARRAY(m_value); }
 
+  FRIEND_STD_SHARED_PTR(CacheableArrayType)
+
  private:
   // Private to disable copy constructor and assignment operator.
   CacheableArrayType(const CacheableArrayType& other)
@@ -271,52 +269,6 @@ class CacheableArrayType : public Cacheable {
   }
 };
 
-/**
- * Template class for CacheableArrayType SharedPtr's that adds [] operator
- */
-template <typename TObj, int8_t TYPEID>
-class SharedArrayPtr : public SharedPtr<CacheableArrayType<TObj, TYPEID> > {
- private:
-  typedef CacheableArrayType<TObj, TYPEID> TArray;
-
- public:
-  /** Default constructor. */
-  inline SharedArrayPtr() : SharedPtr<CacheableArrayType<TObj, TYPEID> >() {}
-
-  /** Constructor, given a pointer to array. */
-  inline SharedArrayPtr(const TArray* ptr)
-      : SharedPtr<CacheableArrayType<TObj, TYPEID> >(ptr) {}
-
-  /** Constructor, given a null SharedBase. */
-  inline SharedArrayPtr(const NullSharedBase* ptr)
-      : SharedPtr<CacheableArrayType<TObj, TYPEID> >(ptr) {}
-
-  /** Constructor, given another SharedArrayPtr. */
-  inline SharedArrayPtr(const SharedArrayPtr& other)
-      : SharedPtr<CacheableArrayType<TObj, TYPEID> >(other) {}
-
-  /** Constructor, given another kind of SharedArrayPtr. */
-  template <typename TOther, int8_t OTHERID>
-  inline SharedArrayPtr(const SharedArrayPtr<TOther, OTHERID>& other)
-      : SharedPtr<CacheableArrayType<TObj, TYPEID> >(other) {}
-
-  /** Constructor, given another SharedPtr. */
-  template <typename TOther>
-  inline SharedArrayPtr(const SharedPtr<TOther>& other)
-      : SharedPtr<CacheableArrayType<TObj, TYPEID> >(other) {}
-
-  /** Get the element at given index. */
-  inline TObj operator[](uint32_t index) const {
-    return SharedPtr<CacheableArrayType<TObj, TYPEID> >::ptr()->operator[](
-        index);
-  }
-
-  /** Deserialize self */
-  inline Serializable* fromData(DataInput& input) {
-    return SharedPtr<CacheableArrayType<TObj, TYPEID> >::ptr()->fromData(input);
-  }
-};
-
 /** Template class for container Cacheable types. */
 template <typename TBase, int8_t TYPEID>
 class CacheableContainerType : public Cacheable, public TBase {
@@ -368,7 +320,7 @@ class CacheableContainerType : public Cacheable, public TBase {
         sizeof(CacheableContainerType) +
         apache::geode::client::serializer::objectSize(*this));
   }
-};
+  };
 
 #ifdef _SOLARIS
 #define TEMPLATE_EXPORT template class
@@ -400,15 +352,16 @@ class CacheableContainerType : public Cacheable, public TBase {
    protected:                                                                  \
     inline k() : _##k() {}                                                     \
     inline k(const p value) : _##k(value) {}                                   \
+    FRIEND_STD_SHARED_PTR(k)                                                   \
                                                                                \
    public:                                                                     \
     /** Factory function registered with serialization registry. */            \
     static Serializable* createDeserializable() { return new k(); }            \
     /** Factory function to create a new default instance. */                  \
-    inline static k##Ptr create() { return k##Ptr(new k()); }                  \
+    inline static k##Ptr create() { return std::make_shared<k>(); }            \
     /** Factory function to create an instance with the given value. */        \
     inline static k##Ptr create(const p value) {                               \
-      return k##Ptr(new k(value));                                             \
+      return std::make_shared<k>(value);                                       \
     }                                                                          \
   };                                                                           \
   inline CacheableKeyPtr createKey(const p value) { return k::create(value); } \
@@ -435,18 +388,21 @@ class CacheableContainerType : public Cacheable, public TBase {
     c(const c& other);                                                         \
     c& operator=(const c& other);                                              \
                                                                                \
+    FRIEND_STD_SHARED_PTR(c)                                                   \
+                                                                               \
    public:                                                                     \
     /** Factory function registered with serialization registry. */            \
     static Serializable* createDeserializable() { return new c(); }            \
     /** Factory function to create a new default instance. */                  \
-    inline static c##Ptr create() { return c##Ptr(new c()); }                  \
+    inline static c##Ptr create() { return std::make_shared<c>(); }            \
     /** Factory function to create a cacheable array of given size. */         \
     inline static c##Ptr create(int32_t length) {                              \
-      return c##Ptr(new c(length));                                            \
+      return std::make_shared<c>(length);                                      \
     }                                                                          \
     /** Create a cacheable array copying from the given array. */              \
     inline static c##Ptr create(const p* value, int32_t length) {              \
-      return (value != NULL ? c##Ptr(new c(value, length, true)) : NULLPTR);   \
+      return nullptr == value ? nullptr                                        \
+                              : std::make_shared<c>(value, length, true);      \
     }                                                                          \
     /**                                                                      \ \
      * \                                                                       \
@@ -471,7 +427,7 @@ class CacheableContainerType : public Cacheable, public TBase {
      * \ \                                                                     \
      */                                                                        \
     inline static c##Ptr createNoCopy(p* value, int32_t length) {              \
-      return (value != NULL ? c##Ptr(new c(value, length)) : NULLPTR);         \
+      return nullptr == value ? nullptr : std::make_shared<c>(value, length);  \
     }                                                                          \
   };
 
@@ -482,21 +438,25 @@ class CacheableContainerType : public Cacheable, public TBase {
   typedef SharedPtr<c> c##Ptr;
 
 // use a class instead of typedef for bug #283
-#define _GF_CACHEABLE_CONTAINER_TYPE_(p, c)                                   \
-  class CPPCACHE_EXPORT c : public _##c {                                     \
-   protected:                                                                 \
-    inline c() : _##c() {}                                                    \
-    inline c(const int32_t n) : _##c(n) {}                                    \
-                                                                              \
-   public:                                                                    \
-    /** Iterator for this type. */                                            \
-    typedef p::Iterator Iterator;                                             \
-    /** Factory function registered with serialization registry. */           \
-    static Serializable* createDeserializable() { return new c(); }           \
-    /** Factory function to create a default instance. */                     \
-    inline static c##Ptr create() { return c##Ptr(new c()); }                 \
-    /** Factory function to create an instance with the given size. */        \
-    inline static c##Ptr create(const int32_t n) { return c##Ptr(new c(n)); } \
+#define _GF_CACHEABLE_CONTAINER_TYPE_(p, c)                            \
+  class CPPCACHE_EXPORT c : public _##c {                              \
+   protected:                                                          \
+    inline c() : _##c() {}                                             \
+    inline c(const int32_t n) : _##c(n) {}                             \
+                                                                       \
+    FRIEND_STD_SHARED_PTR(c)                                           \
+                                                                       \
+   public:                                                             \
+    /** Iterator for this type. */                                     \
+    typedef p::Iterator Iterator;                                      \
+    /** Factory function registered with serialization registry. */    \
+    static Serializable* createDeserializable() { return new c(); }    \
+    /** Factory function to create a default instance. */              \
+    inline static c##Ptr create() { return std::make_shared<c>(); }    \
+    /** Factory function to create an instance with the given size. */ \
+    inline static c##Ptr create(const int32_t n) {                     \
+      return std::make_shared<c>(n);                                   \
+    }                                                                  \
   };
 
 // Instantiations for the built-in CacheableKeys

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/cppcache/include/geode/CacheableDate.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/geode/CacheableDate.hpp b/src/cppcache/include/geode/CacheableDate.hpp
index 1eed4dc..3af1884 100644
--- a/src/cppcache/include/geode/CacheableDate.hpp
+++ b/src/cppcache/include/geode/CacheableDate.hpp
@@ -131,20 +131,18 @@ class CPPCACHE_EXPORT CacheableDate : public CacheableKey {
   /**
    * Factory method for creating an instance of CacheableDate
    */
-  static CacheableDatePtr create() {
-    return CacheableDatePtr(new CacheableDate());
-  }
+  static CacheableDatePtr create() { return std::make_shared<CacheableDate>(); }
 
   static CacheableDatePtr create(const time_t& value) {
-    return CacheableDatePtr(new CacheableDate(value));
+    return std::make_shared<CacheableDate>(value);
   }
 
   static CacheableDatePtr create(const time_point& value) {
-    return CacheableDatePtr(new CacheableDate(value));
+    return std::make_shared<CacheableDate>(value);
   }
 
   static CacheableDatePtr create(const duration& value) {
-    return CacheableDatePtr(new CacheableDate(value));
+    return std::make_shared<CacheableDate>(value);
   }
 
   virtual CacheableStringPtr toString() const;
@@ -173,14 +171,16 @@ class CPPCACHE_EXPORT CacheableDate : public CacheableKey {
   // never implemented.
   void operator=(const CacheableDate& other);
   CacheableDate(const CacheableDate& other);
+
+  FRIEND_STD_SHARED_PTR(CacheableDate)
 };
 
 inline CacheableKeyPtr createKey(const CacheableDate::time_point& value) {
-  return CacheableKeyPtr(CacheableDate::create(value));
+  return CacheableDate::create(value);
 }
 
 inline CacheablePtr createValue(const CacheableDate::time_point& value) {
-  return CacheablePtr(CacheableDate::create(value));
+  return CacheableDate::create(value);
 }
 
 }  // namespace client

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/cppcache/include/geode/CacheableEnum.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/geode/CacheableEnum.hpp b/src/cppcache/include/geode/CacheableEnum.hpp
index 50817f4..1967fe9 100644
--- a/src/cppcache/include/geode/CacheableEnum.hpp
+++ b/src/cppcache/include/geode/CacheableEnum.hpp
@@ -110,8 +110,7 @@ class CPPCACHE_EXPORT CacheableEnum : public CacheableKey {
   */
   static CacheableEnumPtr create(const char* enumClassName,
                                  const char* enumName, int32_t ordinal) {
-    CacheableEnumPtr str(new CacheableEnum(enumClassName, enumName, ordinal));
-    return str;
+    return std::make_shared<CacheableEnum>(enumClassName, enumName, ordinal);
   }
 
   /**@return enum class name. */
@@ -138,6 +137,8 @@ class CPPCACHE_EXPORT CacheableEnum : public CacheableKey {
   // never implemented.
   void operator=(const CacheableEnum& other);
   CacheableEnum(const CacheableEnum& other);
+  
+  FRIEND_STD_SHARED_PTR(CacheableEnum)
 };
 }  // namespace client
 }  // namespace geode

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/cppcache/include/geode/CacheableFileName.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/geode/CacheableFileName.hpp b/src/cppcache/include/geode/CacheableFileName.hpp
index e17bd23..70ae217 100644
--- a/src/cppcache/include/geode/CacheableFileName.hpp
+++ b/src/cppcache/include/geode/CacheableFileName.hpp
@@ -75,9 +75,9 @@ class CPPCACHE_EXPORT CacheableFileName : public CacheableString {
    * C string optionally given the length.
    */
   static CacheableFileNamePtr create(const char* value, int32_t len = 0) {
-    CacheableFileNamePtr str = NULLPTR;
+    CacheableFileNamePtr str = nullptr;
     if (value != NULL) {
-      str = new CacheableFileName();
+      str = std::make_shared<CacheableFileName>();
       str->initString(value, len);
     }
     return str;
@@ -88,9 +88,9 @@ class CPPCACHE_EXPORT CacheableFileName : public CacheableString {
    * wide-character C string optionally given the length.
    */
   static CacheableFileNamePtr create(const wchar_t* value, int32_t len = 0) {
-    CacheableFileNamePtr str = NULLPTR;
+    CacheableFileNamePtr str = nullptr;
     if (value != NULL) {
-      str = new CacheableFileName();
+      str = std::make_shared<CacheableFileName>();
       str->initString(value, len);
     }
     return str;
@@ -103,6 +103,8 @@ class CPPCACHE_EXPORT CacheableFileName : public CacheableString {
   virtual int32_t hashcode() const;
 
  protected:
+  FRIEND_STD_SHARED_PTR(CacheableFileName)
+
   /** Default constructor. */
   inline CacheableFileName() : CacheableString(), m_hashcode(0) {}
 

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/cppcache/include/geode/CacheableKey.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/geode/CacheableKey.hpp b/src/cppcache/include/geode/CacheableKey.hpp
index e8cfc36..ae5e1e3 100644
--- a/src/cppcache/include/geode/CacheableKey.hpp
+++ b/src/cppcache/include/geode/CacheableKey.hpp
@@ -41,6 +41,8 @@ class CPPCACHE_EXPORT CacheableKey : public Cacheable {
   /** Destructor */
   virtual ~CacheableKey() {}
 
+  FRIEND_STD_SHARED_PTR(CacheableKey)
+
  public:
   /** return true if this key matches other. */
   virtual bool operator==(const CacheableKey& other) const = 0;

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/cppcache/include/geode/CacheableObjectArray.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/geode/CacheableObjectArray.hpp b/src/cppcache/include/geode/CacheableObjectArray.hpp
index 50a161b..b97ac25 100644
--- a/src/cppcache/include/geode/CacheableObjectArray.hpp
+++ b/src/cppcache/include/geode/CacheableObjectArray.hpp
@@ -75,7 +75,7 @@ class CPPCACHE_EXPORT CacheableObjectArray : public Cacheable,
    * Factory method for creating the default instance of CacheableObjectArray.
    */
   inline static CacheableObjectArrayPtr create() {
-    return CacheableObjectArrayPtr(new CacheableObjectArray());
+    return std::make_shared<CacheableObjectArray>();
   }
 
   /**
@@ -83,7 +83,7 @@ class CPPCACHE_EXPORT CacheableObjectArray : public Cacheable,
    * given size.
    */
   inline static CacheableObjectArrayPtr create(int32_t n) {
-    return CacheableObjectArrayPtr(new CacheableObjectArray(n));
+    return std::make_shared<CacheableObjectArray>(n);
   }
 
   virtual uint32_t objectSize() const;
@@ -98,6 +98,8 @@ class CPPCACHE_EXPORT CacheableObjectArray : public Cacheable,
   // never implemented.
   CacheableObjectArray& operator=(const CacheableObjectArray& other);
   CacheableObjectArray(const CacheableObjectArray& other);
+
+  FRIEND_STD_SHARED_PTR(CacheableObjectArray)
 };
 }  // namespace client
 }  // namespace geode

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/cppcache/include/geode/CacheableString.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/geode/CacheableString.hpp b/src/cppcache/include/geode/CacheableString.hpp
index dc1a926..9a754b9 100644
--- a/src/cppcache/include/geode/CacheableString.hpp
+++ b/src/cppcache/include/geode/CacheableString.hpp
@@ -49,6 +49,8 @@ class CPPCACHE_EXPORT CacheableString : public CacheableKey {
   uint32_t m_len;
   mutable int m_hashcode;
 
+  FRIEND_STD_SHARED_PTR(CacheableString)
+
  public:
   /**
    *@brief serialize this object
@@ -111,11 +113,12 @@ class CPPCACHE_EXPORT CacheableString : public CacheableKey {
    * This should be used only for ASCII strings.
    */
   static CacheableStringPtr create(const char* value, int32_t len = 0) {
-    CacheableStringPtr str = NULLPTR;
-    if (value != NULL) {
-      str = new CacheableString();
-      str->initString(value, len);
+    if (nullptr == value) {
+      return nullptr;
     }
+
+    CacheableStringPtr str = std::make_shared<CacheableString>();
+    str->initString(value, len);
     return str;
   }
 
@@ -130,11 +133,12 @@ class CPPCACHE_EXPORT CacheableString : public CacheableKey {
    * CAUTION: use this only when you really know what you are doing.
    */
   static CacheableStringPtr createNoCopy(char* value, int32_t len = 0) {
-    CacheableStringPtr str = NULLPTR;
-    if (value != NULL) {
-      str = new CacheableString();
-      str->initStringNoCopy(value, len);
+    if (nullptr == value) {
+      return nullptr;
     }
+
+    CacheableStringPtr str = std::make_shared<CacheableString>();
+    str->initStringNoCopy(value, len);
     return str;
   }
 
@@ -145,11 +149,12 @@ class CPPCACHE_EXPORT CacheableString : public CacheableKey {
    * This should be used for non-ASCII strings.
    */
   static CacheableStringPtr create(const wchar_t* value, int32_t len = 0) {
-    CacheableStringPtr str = NULLPTR;
-    if (value != NULL) {
-      str = new CacheableString();
-      str->initString(value, len);
+    if (nullptr == value) {
+      return nullptr;
     }
+
+    CacheableStringPtr str = std::make_shared<CacheableString>();
+    str->initString(value, len);
     return str;
   }
 
@@ -164,11 +169,12 @@ class CPPCACHE_EXPORT CacheableString : public CacheableKey {
    * CAUTION: use this only when you really know what you are doing.
    */
   static CacheableStringPtr createNoCopy(wchar_t* value, int32_t len = 0) {
-    CacheableStringPtr str = NULLPTR;
-    if (value != NULL) {
-      str = new CacheableString();
-      str->initStringNoCopy(value, len);
+    if (nullptr == value) {
+      return nullptr;
     }
+
+    CacheableStringPtr str = std::make_shared<CacheableString>();
+    str->initStringNoCopy(value, len);
     return str;
   }
 
@@ -235,7 +241,9 @@ class CPPCACHE_EXPORT CacheableString : public CacheableKey {
   const char* toString() { return reinterpret_cast<const char*>(m_str); }
 
   virtual CacheableStringPtr toString() const {
-    return CacheableStringPtr(this);
+    // TODO this cast seems odd
+    return std::const_pointer_cast<CacheableString>(
+        std::static_pointer_cast<const CacheableString>(shared_from_this()));
   }
 
   /** get the name of the class of this object for logging purpose */
@@ -282,26 +290,22 @@ class CPPCACHE_EXPORT CacheableString : public CacheableKey {
 
 /** overload of apache::geode::client::createKeyArr to pass char* */
 inline CacheableKeyPtr createKeyArr(const char* value) {
-  return (value != NULL ? CacheableKeyPtr(CacheableString::create(value).ptr())
-                        : NULLPTR);
+  return CacheableString::create(value);
 }
 
 /** overload of apache::geode::client::createKeyArr to pass wchar_t* */
 inline CacheableKeyPtr createKeyArr(const wchar_t* value) {
-  return (value != NULL ? CacheableKeyPtr(CacheableString::create(value).ptr())
-                        : NULLPTR);
+  return CacheableString::create(value);
 }
 
 /** overload of apache::geode::client::createValueArr to pass char* */
 inline CacheablePtr createValueArr(const char* value) {
-  return (value != NULL ? CacheablePtr(CacheableString::create(value).ptr())
-                        : NULLPTR);
+  return CacheableString::create(value);
 }
 
 /** overload of apache::geode::client::createValueArr to pass wchar_t* */
 inline CacheablePtr createValueArr(const wchar_t* value) {
-  return (value != NULL ? CacheablePtr(CacheableString::create(value).ptr())
-                        : NULLPTR);
+  return CacheableString::create(value);
 }
 }  // namespace client
 }  // namespace geode

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/cppcache/include/geode/CacheableUndefined.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/geode/CacheableUndefined.hpp b/src/cppcache/include/geode/CacheableUndefined.hpp
index 706c9b4..40b5d5a 100644
--- a/src/cppcache/include/geode/CacheableUndefined.hpp
+++ b/src/cppcache/include/geode/CacheableUndefined.hpp
@@ -77,7 +77,7 @@ class CPPCACHE_EXPORT CacheableUndefined : public Cacheable {
    * Factory method for creating the default instance of CacheableUndefined.
    */
   inline static CacheableUndefinedPtr create() {
-    return CacheableUndefinedPtr(new CacheableUndefined());
+    return std::make_shared<CacheableUndefined>();
   }
 
   virtual uint32_t objectSize() const;
@@ -90,6 +90,8 @@ class CPPCACHE_EXPORT CacheableUndefined : public Cacheable {
   // never implemented.
   CacheableUndefined& operator=(const CacheableUndefined& other);
   CacheableUndefined(const CacheableUndefined& other);
+
+  FRIEND_STD_SHARED_PTR(CacheableUndefined)
 };
 }  // namespace client
 }  // namespace geode

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/cppcache/include/geode/CqAttributes.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/geode/CqAttributes.hpp b/src/cppcache/include/geode/CqAttributes.hpp
index d63af8a..97bf72c 100644
--- a/src/cppcache/include/geode/CqAttributes.hpp
+++ b/src/cppcache/include/geode/CqAttributes.hpp
@@ -22,7 +22,7 @@
 
 #include "geode_globals.hpp"
 #include "geode_types.hpp"
-#include "VectorT.hpp"
+#include <vector>
 
 #include "CqListener.hpp"
 /**
@@ -49,13 +49,15 @@ namespace client {
  */
 class CPPCACHE_EXPORT CqAttributes : virtual public SharedBase {
  public:
+  typedef std::vector<std::shared_ptr<CqListener>> listener_container_type;
+
   /**
    * Get the CqListeners set with the CQ.
    * Returns all the Listeners associated with this CQ.
    * @see CqListener
-   * @return VectorOfCqListener of CqListnerPtr
+   * @param[out] std::vector<CqListenerPtr> of CqListnerPtr
    */
-  virtual void getCqListeners(VectorOfCqListener& vl) = 0;
+  virtual void getCqListeners(listener_container_type& vl) = 0;
 };
 }  // namespace client
 }  // namespace geode

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/cppcache/include/geode/CqAttributesFactory.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/geode/CqAttributesFactory.hpp b/src/cppcache/include/geode/CqAttributesFactory.hpp
index 5594135..e0d51d6 100644
--- a/src/cppcache/include/geode/CqAttributesFactory.hpp
+++ b/src/cppcache/include/geode/CqAttributesFactory.hpp
@@ -70,12 +70,12 @@ class CPPCACHE_EXPORT CqAttributesFactory : public SharedBase {
    *          the <code>CqAttributes</code> used to initialize this
    *          AttributesFactory
    */
-  CqAttributesFactory(CqAttributesPtr& cqAttributes);
+  CqAttributesFactory(const CqAttributesPtr& cqAttributes);
 
   /**
    * Adds a CQ listener to the end of the list of cq listeners on this factory.
    * @param cqListener the CqListener to add to the factory.
-   * @throws IllegalArgumentException if <code>cqListener</code> is NULLPTR
+   * @throws IllegalArgumentException if <code>cqListener</code> is nullptr
    */
   void addCqListener(const CqListenerPtr& cqListener);
 
@@ -86,9 +86,9 @@ class CPPCACHE_EXPORT CqAttributesFactory : public SharedBase {
    * factory.
    * @throws IllegalArgumentException if the <code>cqListeners</code> array has
    * a
-   * NULLPTR element
+   * nullptr element
    */
-  void initCqListeners(VectorOfCqListener& cqListeners);
+  void initCqListeners(const std::vector<CqListenerPtr>& cqListeners);
 
   /**
    * Creates a <code>CqAttributes</code> with the current settings.

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/cppcache/include/geode/CqAttributesMutator.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/geode/CqAttributesMutator.hpp b/src/cppcache/include/geode/CqAttributesMutator.hpp
index 2157760..97cec1a 100644
--- a/src/cppcache/include/geode/CqAttributesMutator.hpp
+++ b/src/cppcache/include/geode/CqAttributesMutator.hpp
@@ -45,7 +45,7 @@ class CPPCACHE_EXPORT CqAttributesMutator : virtual public SharedBase {
   /**
    * Adds a CQ listener to the end of the list of CQ listeners on this CqQuery.
    * @param aListener the user defined CQ listener to add to the CqQuery.
-   * @throws IllegalArgumentException if <code>aListener</code> is NULLPTR
+   * @throws IllegalArgumentException if <code>aListener</code> is nullptr
    */
   virtual void addCqListener(const CqListenerPtr& aListener) = 0;
 
@@ -55,7 +55,7 @@ class CPPCACHE_EXPORT CqAttributesMutator : virtual public SharedBase {
    * If the specified listener has been added then will
    * be called on it; otherwise does nothing.
    * @param aListener the CQ listener to remove from the CqQuery.
-   * @throws IllegalArgumentException if <code>aListener</code> is NULLPTR
+   * @throws IllegalArgumentException if <code>aListener</code> is nullptr
    */
   virtual void removeCqListener(const CqListenerPtr& aListener) = 0;
 
@@ -66,9 +66,10 @@ class CPPCACHE_EXPORT CqAttributesMutator : virtual public SharedBase {
    * @param newListeners a possibly empty array of listeners to add
    * to this CqQuery.
    * @throws IllegalArgumentException if the <code>newListeners</code> array
-   * has a NULLPTR element
+   * has a nullptr element
    */
-  virtual void setCqListeners(VectorOfCqListener& newListeners) = 0;
+  virtual void setCqListeners(
+      const std::vector<CqListenerPtr>& newListeners) = 0;
 };
 }  // namespace client
 }  // namespace geode

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/cppcache/include/geode/CqEvent.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/geode/CqEvent.hpp b/src/cppcache/include/geode/CqEvent.hpp
index 8577cbd..283e0f3 100644
--- a/src/cppcache/include/geode/CqEvent.hpp
+++ b/src/cppcache/include/geode/CqEvent.hpp
@@ -79,14 +79,14 @@ class CPPCACHE_EXPORT CqEvent {
   /**
    * Get the key relating to the event.
    * In case of REGION_CLEAR and REGION_INVALIDATE operation, the key will be
-   * NULLPTR.
+   * nullptr.
    * @return Object key.
    */
   virtual CacheableKeyPtr getKey() const = 0;
 
   /**
    * Get the new value of the modification.
-   * If there is no new value returns NULLPTR, this will happen during delete
+   * If there is no new value returns nullptr, this will happen during delete
    * operation.
    * @return Object new/modified value.
    */

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/cppcache/include/geode/CqListener.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/geode/CqListener.hpp b/src/cppcache/include/geode/CqListener.hpp
index c4304dd..8396a36 100644
--- a/src/cppcache/include/geode/CqListener.hpp
+++ b/src/cppcache/include/geode/CqListener.hpp
@@ -57,7 +57,7 @@ class CPPCACHE_EXPORT CqListener : public SharedBase {
    * The error can appear while applying query condition on the event.
    * e.g if the event doesn't has attributes as specified in the CQ query.
    * This event does contain an error. The newValue may or may not be
-   * available, and will be NULLPTR if not available.
+   * available, and will be nullptr if not available.
    */
   virtual void onError(const CqEvent& aCqEvent);
 

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/cppcache/include/geode/DataInput.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/geode/DataInput.hpp b/src/cppcache/include/geode/DataInput.hpp
index b9e6919..8886539 100644
--- a/src/cppcache/include/geode/DataInput.hpp
+++ b/src/cppcache/include/geode/DataInput.hpp
@@ -600,9 +600,9 @@ class CPPCACHE_EXPORT DataInput {
     SerializablePtr sPtr;
     readObjectInternal(sPtr);
     if (throwOnError) {
-      ptr = dynCast<SharedPtr<PTR> >(sPtr);
+      ptr = std::dynamic_pointer_cast<PTR>(sPtr);
     } else {
-      ptr = staticCast<SharedPtr<PTR> >(sPtr);
+      ptr = std::static_pointer_cast<PTR>(sPtr);
     }
   }
 
@@ -629,7 +629,7 @@ class CPPCACHE_EXPORT DataInput {
     read(&typeId);
     int64_t compId = typeId;
     if (compId == GeodeTypeIds::NullObj) {
-      csPtr = NULLPTR;
+      csPtr = nullptr;
     } else if (compId == GeodeTypeIds::CacheableNullString) {
       csPtr = CacheableStringPtr(dynamic_cast<CacheableString*>(
           CacheableString::createDeserializable()));
@@ -637,25 +637,25 @@ class CPPCACHE_EXPORT DataInput {
                apache::geode::client::GeodeTypeIds::CacheableASCIIString) {
       csPtr = CacheableStringPtr(dynamic_cast<CacheableString*>(
           CacheableString::createDeserializable()));
-      csPtr.ptr()->fromData(*this);
+      csPtr->fromData(*this);
     } else if (compId ==
                apache::geode::client::GeodeTypeIds::CacheableASCIIStringHuge) {
       csPtr = CacheableStringPtr(dynamic_cast<CacheableString*>(
           CacheableString::createDeserializableHuge()));
-      csPtr.ptr()->fromData(*this);
+      csPtr->fromData(*this);
     } else if (compId == apache::geode::client::GeodeTypeIds::CacheableString) {
       csPtr = CacheableStringPtr(dynamic_cast<CacheableString*>(
           CacheableString::createUTFDeserializable()));
-      csPtr.ptr()->fromData(*this);
+      csPtr->fromData(*this);
     } else if (compId ==
                apache::geode::client::GeodeTypeIds::CacheableStringHuge) {
       csPtr = CacheableStringPtr(dynamic_cast<CacheableString*>(
           CacheableString::createUTFDeserializableHuge()));
-      csPtr.ptr()->fromData(*this);
+      csPtr->fromData(*this);
     } else {
       LOGDEBUG("In readNativeString something is wrong while expecting string");
       rewindCursor(1);
-      csPtr = NULLPTR;
+      csPtr = nullptr;
       return false;
     }
     return true;

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/cppcache/include/geode/DataOutput.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/geode/DataOutput.hpp b/src/cppcache/include/geode/DataOutput.hpp
index dee5a1d..0e4f55d 100644
--- a/src/cppcache/include/geode/DataOutput.hpp
+++ b/src/cppcache/include/geode/DataOutput.hpp
@@ -580,7 +580,7 @@ class CPPCACHE_EXPORT DataOutput {
    */
   template <class PTR>
   void writeObject(const SharedPtr<PTR>& objptr, bool isDelta = false) {
-    writeObjectInternal(objptr.ptr(), isDelta);
+    writeObjectInternal(objptr.get(), isDelta);
   }
 
   /**

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/cppcache/include/geode/DistributedSystem.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/geode/DistributedSystem.hpp b/src/cppcache/include/geode/DistributedSystem.hpp
index c6d46af..1f02c76 100644
--- a/src/cppcache/include/geode/DistributedSystem.hpp
+++ b/src/cppcache/include/geode/DistributedSystem.hpp
@@ -64,7 +64,7 @@ class CPPCACHE_EXPORT DistributedSystem : public SharedBase {
    *for this process
    **/
   static DistributedSystemPtr connect(const char* name,
-                                      const PropertiesPtr& configPtr = NULLPTR);
+                                      const PropertiesPtr& configPtr = nullptr);
 
   /**
    *@brief disconnect from the distributed system

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/cppcache/include/geode/EntryEvent.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/geode/EntryEvent.hpp b/src/cppcache/include/geode/EntryEvent.hpp
index 724494d..bd7192c 100644
--- a/src/cppcache/include/geode/EntryEvent.hpp
+++ b/src/cppcache/include/geode/EntryEvent.hpp
@@ -63,13 +63,13 @@ class CPPCACHE_EXPORT EntryEvent : public apache::geode::client::SharedBase {
   inline CacheableKeyPtr getKey() const { return m_key; }
 
   /** If the prior state of the entry was invalid, or non-existent/destroyed,
-   * then the old value will be NULLPTR.
+   * then the old value will be nullptr.
    * @return the old value in the cache.
    */
   inline CacheablePtr getOldValue() const { return m_oldValue; }
 
   /** If the event is a destroy or invalidate operation, then the new value
-   * will be NULLPTR.
+   * will be nullptr.
    * @return the updated value from this event
    */
   inline CacheablePtr getNewValue() const { return m_newValue; }

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/cppcache/include/geode/Exception.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/geode/Exception.hpp b/src/cppcache/include/geode/Exception.hpp
index 7d6bab8..508bd8e 100644
--- a/src/cppcache/include/geode/Exception.hpp
+++ b/src/cppcache/include/geode/Exception.hpp
@@ -56,7 +56,7 @@ class CPPCACHE_EXPORT Exception : public SharedBase {
    *               retrieved using <code>getCause</code>
    **/
   Exception(const char* msg1, const char* msg2 = NULL, bool forceTrace = false,
-            const ExceptionPtr& cause = NULLPTR);
+            const ExceptionPtr& cause = nullptr);
 
   /** Creates an exception as a copy of the given other exception.
    * @param  other the original exception.

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/cppcache/include/geode/ExceptionTypes.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/geode/ExceptionTypes.hpp b/src/cppcache/include/geode/ExceptionTypes.hpp
index a4ad190..18a2d69 100644
--- a/src/cppcache/include/geode/ExceptionTypes.hpp
+++ b/src/cppcache/include/geode/ExceptionTypes.hpp
@@ -38,7 +38,7 @@ namespace client {
   class CPPCACHE_EXPORT x : public apache::geode::client::Exception {     \
    public:                                                                \
     x(const char* msg1, const char* msg2 = NULL, bool forceStack = false, \
-      const ExceptionPtr& cause = NULLPTR)                                \
+      const ExceptionPtr& cause = nullptr)                                \
         : Exception(msg1, msg2, forceStack, cause) {}                     \
     x(const x& other) : Exception(other) {}                               \
     virtual Exception* clone() const {                                    \

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/cppcache/include/geode/Execution.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/geode/Execution.hpp b/src/cppcache/include/geode/Execution.hpp
index d303bd2..5b6ab97 100644
--- a/src/cppcache/include/geode/Execution.hpp
+++ b/src/cppcache/include/geode/Execution.hpp
@@ -57,7 +57,7 @@ class CPPCACHE_EXPORT Execution : public SharedBase {
    * @param routingObj Set defining the data filter to be used for executing the
    * function
    * @return an Execution with the filter
-   * @throws IllegalArgumentException if filter passed is NULLPTR.
+   * @throws IllegalArgumentException if filter passed is nullptr.
    * @throws UnsupportedOperationException if not called after
    *    FunctionService::onRegion(Region).
    */
@@ -66,7 +66,7 @@ class CPPCACHE_EXPORT Execution : public SharedBase {
    * Specifies the user data passed to the function when it is executed.
    * @param args user data passed to the function execution
    * @return an Execution with args
-   * @throws IllegalArgumentException if the input parameter is NULLPTR
+   * @throws IllegalArgumentException if the input parameter is nullptr
    *
    */
   virtual ExecutionPtr withArgs(CacheablePtr args) = 0;
@@ -74,7 +74,7 @@ class CPPCACHE_EXPORT Execution : public SharedBase {
    * Specifies the {@link ResultCollector} that will receive the results after
    * the function has been executed.
    * @return an Execution with a collector
-   * @throws IllegalArgumentException if {@link ResultCollector} is NULLPTR
+   * @throws IllegalArgumentException if {@link ResultCollector} is nullptr
    * @see ResultCollector
    */
   virtual ExecutionPtr withCollector(ResultCollectorPtr rs) = 0;

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/cppcache/include/geode/FunctionService.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/geode/FunctionService.hpp b/src/cppcache/include/geode/FunctionService.hpp
index 72afe56..9000935 100644
--- a/src/cppcache/include/geode/FunctionService.hpp
+++ b/src/cppcache/include/geode/FunctionService.hpp
@@ -67,7 +67,7 @@ class CPPCACHE_EXPORT FunctionService : public SharedBase {
    *
    * @return Execution
    * @throws NullPointerException
-   *                 if the region passed in is NULLPTR
+   *                 if the region passed in is nullptr
    */
   static ExecutionPtr onRegion(RegionPtr region);
 
@@ -80,7 +80,7 @@ class CPPCACHE_EXPORT FunctionService : public SharedBase {
    * @param pool from which to chose a server for execution
    * @return Execution
    * @throws NullPointerException
-   *                 if Pool instance passed in is NULLPTR
+   *                 if Pool instance passed in is nullptr
    * @throws UnsupportedOperationException
    *                 if Pool is in multiusersecure Mode
    */
@@ -98,7 +98,7 @@ class CPPCACHE_EXPORT FunctionService : public SharedBase {
    *        cache from which to chose a server for execution
    * @return Execution
    * @throws NullPointerException
-   *                 if Pool instance passed in is NULLPTR
+   *                 if Pool instance passed in is nullptr
    * @throws UnsupportedOperationException
    *                 if Pool is in multiusersecure Mode
    */
@@ -120,7 +120,7 @@ class CPPCACHE_EXPORT FunctionService : public SharedBase {
    * @param pool the set of servers to execute the function
    * @return Execution
    * @throws NullPointerException
-   *                 if Pool instance passed in is NULLPTR
+   *                 if Pool instance passed in is nullptr
    * @throws UnsupportedOperationException
    *                 if Pool is in multiusersecure Mode
    */
@@ -138,7 +138,7 @@ class CPPCACHE_EXPORT FunctionService : public SharedBase {
   *        the {@link Cache} where function need to execute.
   * @return Execution
   * @throws NullPointerException
-  *                 if Pool instance passed in is NULLPTR
+  *                 if Pool instance passed in is nullptr
   * @throws UnsupportedOperationException
   *                 if Pool is in multiusersecure Mode
   */

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/cppcache/include/geode/HashFunction.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/geode/HashFunction.hpp b/src/cppcache/include/geode/HashFunction.hpp
index 2cff44a..d7c85b7 100644
--- a/src/cppcache/include/geode/HashFunction.hpp
+++ b/src/cppcache/include/geode/HashFunction.hpp
@@ -72,7 +72,7 @@ inline int32_t hashFunction(const TKEY& k) {
 
 template <typename TKEY>
 inline bool equalToFunction(const TKEY& x, const TKEY& y) {
-  return (*x.ptr() == *y.ptr());
+  return (*x.get() == *y.get());
 }
 }  // namespace client
 }  // namespace geode

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/cppcache/include/geode/HashMapOfSharedBase.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/geode/HashMapOfSharedBase.hpp b/src/cppcache/include/geode/HashMapOfSharedBase.hpp
index 1329d95..cef8b0f 100644
--- a/src/cppcache/include/geode/HashMapOfSharedBase.hpp
+++ b/src/cppcache/include/geode/HashMapOfSharedBase.hpp
@@ -151,7 +151,7 @@ class CPPCACHE_EXPORT HashMapOfSharedBase {
   /** Copy constructor. */
   HashMapOfSharedBase(const HashMapOfSharedBase& other);
 
-  /** Destructor, sets all SharedPtr elements to NULLPTR. */
+  /** Destructor, sets all SharedPtr elements to nullptr. */
   ~HashMapOfSharedBase();
 };
 }  // namespace client

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/cppcache/include/geode/HashMapT.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/geode/HashMapT.hpp b/src/cppcache/include/geode/HashMapT.hpp
index 2a3c645..e39086f 100644
--- a/src/cppcache/include/geode/HashMapT.hpp
+++ b/src/cppcache/include/geode/HashMapT.hpp
@@ -50,10 +50,12 @@ class HashMapT {
     Iterator();
 
    public:
-    inline const TKEY first() const { return staticCast<TKEY>(m_iter.first()); }
+    inline const TKEY first() const {
+      return std::static_pointer_cast<GF_UNWRAP_SP(TKEY)>(m_iter.first());
+    }
 
     inline const TVAL second() const {
-      return staticCast<TVAL>(m_iter.second());
+      return std::static_pointer_cast<GF_UNWRAP_SP(TVAL)>(m_iter.second());
     }
 
     inline Iterator& operator++() {
@@ -75,12 +77,14 @@ class HashMapT {
   };
 
   static int32_t hasher(const SharedBasePtr& p) {
-    return apache::geode::client::hashFunction<TKEY>(staticCast<TKEY>(p));
+    return apache::geode::client::hashFunction<TKEY>(
+        std::static_pointer_cast<GF_UNWRAP_SP(TKEY)>(p));
   }
 
   static bool equal_to(const SharedBasePtr& x, const SharedBasePtr& y) {
-    return apache::geode::client::equalToFunction<TKEY>(staticCast<TKEY>(x),
-                                                        staticCast<TKEY>(y));
+    return apache::geode::client::equalToFunction<TKEY>(
+        std::static_pointer_cast<GF_UNWRAP_SP(TKEY)>(x),
+        std::static_pointer_cast<GF_UNWRAP_SP(TKEY)>(y));
   }
 
   /** Returns the size of the hash map. */
@@ -133,7 +137,9 @@ class HashMapT {
   /** Returns a copy of the object that is associated
    * with a particular key.
    */
-  inline TVAL operator[](const TKEY& k) { return staticCast<TVAL>(m_map[k]); }
+  inline TVAL operator[](const TKEY& k) {
+    return std::static_pointer_cast<GF_UNWRAP_SP(TVAL)>(m_map[k]);
+  }
 
   /** Get an iterator pointing to the start of hash_map. */
   inline Iterator begin() const { return Iterator(m_map.begin()); }

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/cppcache/include/geode/HashSetOfSharedBase.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/geode/HashSetOfSharedBase.hpp b/src/cppcache/include/geode/HashSetOfSharedBase.hpp
index a8675af..127fb86 100644
--- a/src/cppcache/include/geode/HashSetOfSharedBase.hpp
+++ b/src/cppcache/include/geode/HashSetOfSharedBase.hpp
@@ -143,7 +143,7 @@ class CPPCACHE_EXPORT HashSetOfSharedBase {
   /** Copy constructor. */
   HashSetOfSharedBase(const HashSetOfSharedBase& other);
 
-  /** Destructor, sets all SharedPtr elements to NULLPTR. */
+  /** Destructor, sets all SharedPtr elements to nullptr. */
   ~HashSetOfSharedBase();
 };
 }  // namespace client

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/cppcache/include/geode/HashSetT.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/geode/HashSetT.hpp b/src/cppcache/include/geode/HashSetT.hpp
index fa7e75c..7abcbfe 100644
--- a/src/cppcache/include/geode/HashSetT.hpp
+++ b/src/cppcache/include/geode/HashSetT.hpp
@@ -49,7 +49,7 @@ class HashSetT {
     Iterator();
 
    public:
-    inline const TKEY operator*() const { return staticCast<TKEY>(*m_iter); }
+    inline const TKEY operator*() const { return std::static_pointer_cast<GF_UNWRAP_SP(TKEY)>(*m_iter); }
 
     inline bool isEnd() const { return m_iter.isEnd(); }
 
@@ -74,12 +74,12 @@ class HashSetT {
   };
 
   inline static int32_t hasher(const SharedBasePtr& p) {
-    return apache::geode::client::hashFunction<TKEY>(staticCast<TKEY>(p));
+    return apache::geode::client::hashFunction<TKEY>(std::static_pointer_cast<GF_UNWRAP_SP(TKEY)>(p));
   }
 
   inline static bool equal_to(const SharedBasePtr& x, const SharedBasePtr& y) {
-    return apache::geode::client::equalToFunction<TKEY>(staticCast<TKEY>(x),
-                                                        staticCast<TKEY>(y));
+    return apache::geode::client::equalToFunction<TKEY>(std::static_pointer_cast<GF_UNWRAP_SP(TKEY)>(x),
+                                                        std::static_pointer_cast<GF_UNWRAP_SP(TKEY)>(y));
   }
 
   /** Returns the size of the hash set. */

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/cppcache/include/geode/PdxInstanceFactory.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/geode/PdxInstanceFactory.hpp b/src/cppcache/include/geode/PdxInstanceFactory.hpp
index c8a66cc..348e53b 100644
--- a/src/cppcache/include/geode/PdxInstanceFactory.hpp
+++ b/src/cppcache/include/geode/PdxInstanceFactory.hpp
@@ -68,7 +68,7 @@ class CPPCACHE_EXPORT PdxInstanceFactory : public SharedBase {
   * @return the created Pdxinstance
   * @throws IllegalStateException if called more than once
   */
-  virtual PdxInstancePtr create() = 0;
+  virtual std::unique_ptr<PdxInstance> create() = 0;
 
   /**
   * Writes the named field with the given value to the serialized form.

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/cppcache/include/geode/PdxWrapper.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/geode/PdxWrapper.hpp b/src/cppcache/include/geode/PdxWrapper.hpp
index 16a98c3..5028016 100644
--- a/src/cppcache/include/geode/PdxWrapper.hpp
+++ b/src/cppcache/include/geode/PdxWrapper.hpp
@@ -31,8 +31,7 @@ class CPPCACHE_EXPORT PdxWrapper : public PdxSerializable {
   /**
    * The PdxWrapper class allows domain classes to be used in Region operations.
    * A user domain object should be wrapped in an instance of a PdxWrapper with
-* a
-* PdxSerializer registered that can handle the user domain class.
+   * a PdxSerializer registered that can handle the user domain class.
    */
 
  public:
@@ -119,6 +118,8 @@ class CPPCACHE_EXPORT PdxWrapper : public PdxSerializable {
   PdxWrapper();
   PdxWrapper(const char* className);
 
+  FRIEND_STD_SHARED_PTR(PdxWrapper)
+
   void* m_userObject;
   PdxSerializerPtr m_serializer;
   UserDeallocator m_deallocator;

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/cppcache/include/geode/Pool.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/geode/Pool.hpp b/src/cppcache/include/geode/Pool.hpp
index 9cb1336..3e4342c 100644
--- a/src/cppcache/include/geode/Pool.hpp
+++ b/src/cppcache/include/geode/Pool.hpp
@@ -49,7 +49,8 @@ class PoolAttributes;
  *
  *
  */
-class CPPCACHE_EXPORT Pool : public SharedBase {
+class CPPCACHE_EXPORT Pool : public SharedBase,
+                             public std::enable_shared_from_this<Pool> {
  public:
   /**
    * Gets the name of the connection pool

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/cppcache/include/geode/PoolManager.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/geode/PoolManager.hpp b/src/cppcache/include/geode/PoolManager.hpp
index 127436d..968f9dd 100644
--- a/src/cppcache/include/geode/PoolManager.hpp
+++ b/src/cppcache/include/geode/PoolManager.hpp
@@ -65,9 +65,9 @@ class CPPCACHE_EXPORT PoolManager {
 
   /**
    * Find by name an existing connection pool returning
-   * the existing pool or <code>NULLPTR</code> if it does not exist.
+   * the existing pool or <code>nullptr</code> if it does not exist.
    * @param name is the name of the connection pool
-   * @return the existing connection pool or <code>NULLPTR</code> if it does not
+   * @return the existing connection pool or <code>nullptr</code> if it does not
    * exist.
    */
   static PoolPtr find(const char* name);
@@ -75,7 +75,7 @@ class CPPCACHE_EXPORT PoolManager {
   /**
    * Find the pool used by the given region.
    * @param region is the region that is using the pool.
-   * @return the pool used by that region or <code> NULLPTR </code> if the
+   * @return the pool used by that region or <code> nullptr </code> if the
    * region does
    * not have a pool.
    */

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/cppcache/include/geode/Properties.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/geode/Properties.hpp b/src/cppcache/include/geode/Properties.hpp
index 7ddd703..e0f7861 100644
--- a/src/cppcache/include/geode/Properties.hpp
+++ b/src/cppcache/include/geode/Properties.hpp
@@ -52,16 +52,16 @@ class CPPCACHE_EXPORT Properties : public Serializable {
   };
 
   /**
-   * Return the value for the given key, or NULLPTR if not found.
+   * Return the value for the given key, or nullptr if not found.
    *
    * @throws NullPointerException if the key is null
    */
   CacheableStringPtr find(const char* key);
   /**
    * Return the value for the given <code>CacheableKey</code>,
-   * or NULLPTR if not found.
+   * or nullptr if not found.
    *
-   * @throws NullPointerException if the key is NULLPTR
+   * @throws NullPointerException if the key is nullptr
    */
   CacheablePtr find(const CacheableKeyPtr& key);
 
@@ -82,7 +82,7 @@ class CPPCACHE_EXPORT Properties : public Serializable {
   /**
    * Add or update Cacheable value for CacheableKey
    *
-   * @throws NullPointerException if the key is NULLPTR
+   * @throws NullPointerException if the key is nullptr
    */
   void insert(const CacheableKeyPtr& key, const CacheablePtr& value);
 
@@ -96,7 +96,7 @@ class CPPCACHE_EXPORT Properties : public Serializable {
   /**
    * Remove the <code>CacheableKey</code> from the collection.
    *
-   * @throws NullPointerException if the key is NULLPTR
+   * @throws NullPointerException if the key is nullptr
    */
   void remove(const CacheableKeyPtr& key);
 

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/cppcache/include/geode/QueryService.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/geode/QueryService.hpp b/src/cppcache/include/geode/QueryService.hpp
index d47f065..5065c9f 100644
--- a/src/cppcache/include/geode/QueryService.hpp
+++ b/src/cppcache/include/geode/QueryService.hpp
@@ -45,6 +45,8 @@ namespace client {
  */
 class CPPCACHE_EXPORT QueryService : public SharedBase {
  public:
+  typedef std::vector<CqQueryPtr> query_container_type;
+
   /**
    * Get a new Query with the specified query string.
    *
@@ -68,7 +70,7 @@ class CPPCACHE_EXPORT QueryService : public SharedBase {
    * @throws CqExistsException if a CQ by this name already exists on this
    * client
    * @throws IllegalArgumentException if queryString is null, or cqAttr is
-   * NULLPTR
+   * nullptr
    * @throws IllegalStateException if this method is called from a cache
    *         server
    * @throws QueryInvalidException if there is a syntax error in the query
@@ -102,7 +104,7 @@ class CPPCACHE_EXPORT QueryService : public SharedBase {
    * @throws CqExistsException if a CQ by this name already exists on this
    * client
    * @throws IllegalArgumentException if queryString is null, or cqAttr is
-   * NULLPTR
+   * nullptr
    * @throws IllegalStateException if this method is called from a cache
    *         server
    * @throws QueryInvalidException if there is a syntax error in the query
@@ -134,11 +136,11 @@ class CPPCACHE_EXPORT QueryService : public SharedBase {
    * Retrieve  all registered CQs
    * @endnativeclient
    */
-  virtual void getCqs(VectorOfCqQuery& vec) = 0;
+  virtual void getCqs(query_container_type& vec) = 0;
   /**
    * @nativeclient
    * Retrieve a CqQuery by name.
-   * @return the CqQuery or NULLPTR if not found
+   * @return the CqQuery or nullptr if not found
    * @endnativeclient
    */
   virtual CqQueryPtr getCq(const char* name) = 0;

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/cppcache/include/geode/Region.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/geode/Region.hpp b/src/cppcache/include/geode/Region.hpp
index 827a9c1..5f8a31d 100644
--- a/src/cppcache/include/geode/Region.hpp
+++ b/src/cppcache/include/geode/Region.hpp
@@ -84,7 +84,8 @@ namespace client {
 *
 * @see RegionAttributes
 */
-class CPPCACHE_EXPORT Region : public SharedBase {
+class CPPCACHE_EXPORT Region : public std::enable_shared_from_this<Region>,
+                               public SharedBase {
   /** @brief Public Methods
   */
  public:
@@ -97,7 +98,7 @@ class CPPCACHE_EXPORT Region : public SharedBase {
   */
   virtual const char* getFullPath() const = 0;
 
-  /** Returns the parent region, or NULLPTR if a root region.
+  /** Returns the parent region, or nullptr if a root region.
   * @throws RegionDestroyedException
   */
   virtual RegionPtr getParentRegion() const = 0;
@@ -124,7 +125,7 @@ class CPPCACHE_EXPORT Region : public SharedBase {
   *
   * @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.
+  *        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
@@ -134,7 +135,7 @@ class CPPCACHE_EXPORT Region : public SharedBase {
   * This operation is not distributed.
   */
   virtual void invalidateRegion(
-      const UserDataPtr& aCallbackArgument = NULLPTR) = 0;
+      const UserDataPtr& aCallbackArgument = nullptr) = 0;
 
   /** Invalidates this region. The invalidation will cascade to
   * all the subregions and cached entries. After
@@ -146,7 +147,7 @@ class CPPCACHE_EXPORT Region : public SharedBase {
   *
   * @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.
+  *        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
@@ -156,7 +157,7 @@ class CPPCACHE_EXPORT Region : public SharedBase {
 
   */
   virtual void localInvalidateRegion(
-      const UserDataPtr& aCallbackArgument = NULLPTR) = 0;
+      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.
@@ -172,7 +173,7 @@ class CPPCACHE_EXPORT Region : public SharedBase {
   *
   * @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.
+  *        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
@@ -196,7 +197,7 @@ class CPPCACHE_EXPORT Region : public SharedBase {
   * @see  invalidateRegion
   */
   virtual void destroyRegion(
-      const UserDataPtr& aCallbackArgument = NULLPTR) = 0;
+      const UserDataPtr& aCallbackArgument = nullptr) = 0;
   /**
    * Removes all entries from this region and provides a user-defined parameter
    * object to any <code>CacheWriter</code> or <code>CacheListener</code>
@@ -204,7 +205,7 @@ class CPPCACHE_EXPORT Region : public SharedBase {
    * @see CacheListener#afterRegionClear
    * @see CacheWriter#beforeRegionClear
    */
-  virtual void clear(const UserDataPtr& aCallbackArgument = NULLPTR) = 0;
+  virtual void clear(const UserDataPtr& aCallbackArgument = nullptr) = 0;
   /**
    * Removes all entries from this region and provides a user-defined parameter
    * object to any <code>CacheWriter</code> or <code>CacheListener</code>
@@ -212,7 +213,7 @@ class CPPCACHE_EXPORT Region : public SharedBase {
    * @see CacheListener#afterRegionClear
    * @see CacheWriter#beforeRegionClear
    */
-  virtual void localClear(const UserDataPtr& aCallbackArgument = NULLPTR) = 0;
+  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.
@@ -224,7 +225,7 @@ class CPPCACHE_EXPORT Region : public SharedBase {
   *
   * @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.
+  *        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
@@ -234,9 +235,9 @@ class CPPCACHE_EXPORT Region : public SharedBase {
   * @see  localInvalidateRegion
   */
   virtual void localDestroyRegion(
-      const UserDataPtr& aCallbackArgument = NULLPTR) = 0;
+      const UserDataPtr& aCallbackArgument = nullptr) = 0;
 
-  /** Returns the subregion identified by the path, NULLPTR if no such subregion
+  /** Returns the subregion identified by the path, nullptr if no such subregion
    */
   virtual RegionPtr getSubregion(const char* path) = 0;
 
@@ -285,7 +286,7 @@ class CPPCACHE_EXPORT Region : public SharedBase {
   * @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
+  * @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
@@ -307,12 +308,12 @@ class CPPCACHE_EXPORT Region : public SharedBase {
   *region
   **/
   virtual CacheablePtr get(const CacheableKeyPtr& key,
-                           const UserDataPtr& aCallbackArgument = NULLPTR) = 0;
+                           const UserDataPtr& aCallbackArgument = nullptr) = 0;
 
   /** Convenience method allowing key to be a const char* */
   template <class KEYTYPE>
   inline CacheablePtr get(const KEYTYPE& key,
-                          const UserDataPtr& callbackArg = NULLPTR) {
+                          const UserDataPtr& callbackArg = nullptr) {
     return get(createKey(key), callbackArg);
   }
 
@@ -339,7 +340,7 @@ class CPPCACHE_EXPORT Region : public SharedBase {
   * @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 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
@@ -360,26 +361,26 @@ class CPPCACHE_EXPORT Region : public SharedBase {
   * @throws OutOfMemoryException if  not enoough memory for the value
   */
   virtual void put(const CacheableKeyPtr& key, const CacheablePtr& value,
-                   const UserDataPtr& aCallbackArgument = NULLPTR) = 0;
+                   const UserDataPtr& aCallbackArgument = nullptr) = 0;
 
   /** Convenience method allowing both key and value to be a const char* */
   template <class KEYTYPE, class VALUETYPE>
   inline void put(const KEYTYPE& key, const VALUETYPE& value,
-                  const UserDataPtr& arg = NULLPTR) {
+                  const UserDataPtr& arg = nullptr) {
     put(createKey(key), createValue(value), arg);
   }
 
   /** Convenience method allowing key to be a const char* */
   template <class KEYTYPE>
   inline void put(const KEYTYPE& key, const CacheablePtr& value,
-                  const UserDataPtr& arg = NULLPTR) {
+                  const UserDataPtr& arg = nullptr) {
     put(createKey(key), value, arg);
   }
 
   /** Convenience method allowing value to be a const char* */
   template <class VALUETYPE>
   inline void put(const CacheableKeyPtr& key, const VALUETYPE& value,
-                  const UserDataPtr& arg = NULLPTR) {
+                  const UserDataPtr& arg = nullptr) {
     put(key, createValue(value), arg);
   }
 
@@ -399,14 +400,14 @@ class CPPCACHE_EXPORT Region : public SharedBase {
    * @since 8.1
    * @param aCallbackArgument an argument that is passed to the callback
    * functions.
-   * It is ignored if NULLPTR. It must be serializable if this operation is
+   * It is ignored if nullptr. It must be serializable if this operation is
    * distributed.
    * @throws IllegalArgumentException If timeout
    *         parameter is greater than 2^31/1000, ie 2147483.
    */
   virtual void putAll(const HashMapOfCacheable& map,
                       uint32_t timeout = DEFAULT_RESPONSE_TIMEOUT,
-                      const UserDataPtr& aCallbackArgument = NULLPTR) = 0;
+                      const UserDataPtr& aCallbackArgument = nullptr) = 0;
 
   /**
    * Places a new value into an entry in this region with the specified key
@@ -426,33 +427,33 @@ class CPPCACHE_EXPORT Region : public SharedBase {
    * @param aCallbackArgument an argument that is passed to the callback
    * functions
    *
-   * @throws IllegalArgumentException if key or value is NULLPTR
+   * @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 OutOfMemoryException if not enoough memory for the value
    */
   virtual void localPut(const CacheableKeyPtr& key, const CacheablePtr& value,
-                        const UserDataPtr& aCallbackArgument = NULLPTR) = 0;
+                        const UserDataPtr& aCallbackArgument = nullptr) = 0;
 
   /** Convenience method allowing both key and value to be a const char* */
   template <class KEYTYPE, class VALUETYPE>
   inline void localPut(const KEYTYPE& key, const VALUETYPE& value,
-                       const UserDataPtr& arg = NULLPTR) {
+                       const UserDataPtr& arg = nullptr) {
     localPut(createKey(key), createValue(value), arg);
   }
 
   /** Convenience method allowing key to be a const char* */
   template <class KEYTYPE>
   inline void localPut(const KEYTYPE& key, const CacheablePtr& value,
-                       const UserDataPtr& arg = NULLPTR) {
+                       const UserDataPtr& arg = nullptr) {
     localPut(createKey(key), value, arg);
   }
 
   /** Convenience method allowing value to be a const char* */
   template <class VALUETYPE>
   inline void localPut(const CacheableKeyPtr& key, const VALUETYPE& value,
-                       const UserDataPtr& arg = NULLPTR) {
+                       const UserDataPtr& arg = nullptr) {
     localPut(key, createValue(value), arg);
   }
 
@@ -474,12 +475,12 @@ class CPPCACHE_EXPORT Region : public SharedBase {
   *
   * @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
+  * @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
+  *        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
+  * @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
@@ -503,26 +504,26 @@ class CPPCACHE_EXPORT Region : public SharedBase {
   * @throws EntryExistsException if an entry with this key already exists
   */
   virtual void create(const CacheableKeyPtr& key, const CacheablePtr& value,
-                      const UserDataPtr& aCallbackArgument = NULLPTR) = 0;
+                      const UserDataPtr& aCallbackArgument = nullptr) = 0;
 
   /** Convenience method allowing both key and value to be a const char* */
   template <class KEYTYPE, class VALUETYPE>
   inline void create(const KEYTYPE& key, const VALUETYPE& value,
-                     const UserDataPtr& arg = NULLPTR) {
+                     const UserDataPtr& arg = nullptr) {
     create(createKey(key), createValue(value), arg);
   }
 
   /** Convenience method allowing key to be a const char* */
   template <class KEYTYPE>
   inline void create(const KEYTYPE& key, const CacheablePtr& value,
-                     const UserDataPtr& arg = NULLPTR) {
+                     const UserDataPtr& arg = nullptr) {
     create(createKey(key), value, arg);
   }
 
   /** Convenience method allowing value to be a const char* */
   template <class VALUETYPE>
   inline void create(const CacheableKeyPtr& key, const VALUETYPE& value,
-                     const UserDataPtr& arg = NULLPTR) {
+                     const UserDataPtr& arg = nullptr) {
     create(key, createValue(value), arg);
   }
 
@@ -537,14 +538,14 @@ class CPPCACHE_EXPORT Region : public SharedBase {
    *
    * @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
+   * @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
+   *        triggered by this method. Can be nullptr. Should be serializable if
    *        passed to remote callback events
    *
-   * @throws IllegalArgumentException if key or value is NULLPTR
+   * @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 is no longer valid
@@ -553,26 +554,26 @@ class CPPCACHE_EXPORT Region : public SharedBase {
    */
   virtual void localCreate(const CacheableKeyPtr& key,
                            const CacheablePtr& value,
-                           const UserDataPtr& aCallbackArgument = NULLPTR) = 0;
+                           const UserDataPtr& aCallbackArgument = nullptr) = 0;
 
   /** Convenience method allowing both key and value to be a const char* */
   template <class KEYTYPE, class VALUETYPE>
   inline void localCreate(const KEYTYPE& key, const VALUETYPE& value,
-                          const UserDataPtr& arg = NULLPTR) {
+                          const UserDataPtr& arg = nullptr) {
     localCreate(createKey(key), createValue(value), arg);
   }
 
   /** Convenience method allowing key to be a const char* */
   template <class KEYTYPE>
   inline void localCreate(const KEYTYPE& key, const CacheablePtr& value,
-                          const UserDataPtr& arg = NULLPTR) {
+                          const UserDataPtr& arg = nullptr) {
     localCreate(createKey(key), value, arg);
   }
 
   /** Convenience method allowing value to be a const char* */
   template <class VALUETYPE>
   inline void localCreate(const CacheableKeyPtr& key, const VALUETYPE& value,
-                          const UserDataPtr& arg = NULLPTR) {
+                          const UserDataPtr& arg = nullptr) {
     localCreate(key, createValue(value), arg);
   }
 
@@ -588,9 +589,9 @@ class CPPCACHE_EXPORT Region : public SharedBase {
   *
   * @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
+  *        triggered by this method. Can be nullptr. Should be serializable if
   *        passed to remote callback events
-  * @throws IllegalArgumentException if key is NULLPTR
+  * @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
@@ -599,11 +600,11 @@ class CPPCACHE_EXPORT Region : public SharedBase {
   * @see CacheListener::afterInvalidate
   */
   virtual void invalidate(const CacheableKeyPtr& key,
-                          const UserDataPtr& aCallbackArgument = NULLPTR) = 0;
+                          const UserDataPtr& aCallbackArgument = nullptr) = 0;
 
   /** Convenience method allowing key to be a const char* */
   template <class KEYTYPE>
-  inline void invalidate(const KEYTYPE& key, const UserDataPtr& arg = NULLPTR) {
+  inline void invalidate(const KEYTYPE& key, const UserDataPtr& arg = nullptr) {
     invalidate(createKey(key), arg);
   }
 
@@ -617,9 +618,9 @@ class CPPCACHE_EXPORT Region : public SharedBase {
   *
   * @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
+  *        triggered by this method. Can be nullptr. Should be serializable if
   *        passed to remote callback events
-  * @throws IllegalArgumentException if key is NULLPTR
+  * @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
@@ -629,12 +630,12 @@ class CPPCACHE_EXPORT Region : public SharedBase {
   */
   virtual void localInvalidate(
       const CacheableKeyPtr& key,
-      const UserDataPtr& aCallbackArgument = NULLPTR) = 0;
+      const UserDataPtr& aCallbackArgument = nullptr) = 0;
 
   /** Convenience method allowing key to be a const char* */
   template <class KEYTYPE>
   inline void localInvalidate(const KEYTYPE& key,
-                              const UserDataPtr& arg = NULLPTR) {
+                              const UserDataPtr& arg = nullptr) {
     localInvalidate(createKey(key), arg);
   }
 
@@ -657,8 +658,8 @@ class CPPCACHE_EXPORT Region : public SharedBase {
   * @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
+  *        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
@@ -683,11 +684,11 @@ class CPPCACHE_EXPORT Region : public SharedBase {
   * @see CacheWriter::beforeDestroy
   */
   virtual void destroy(const CacheableKeyPtr& key,
-                       const UserDataPtr& aCallbackArgument = NULLPTR) = 0;
+                       const UserDataPtr& aCallbackArgument = nullptr) = 0;
 
   /** Convenience method allowing key to be a const char* */
   template <class KEYTYPE>
-  inline void destroy(const KEYTYPE& key, const UserDataPtr& arg = NULLPTR) {
+  inline void destroy(const KEYTYPE& key, const UserDataPtr& arg = nullptr) {
     destroy(createKey(key), arg);
   }
 
@@ -705,8 +706,8 @@ class CPPCACHE_EXPORT Region : public SharedBase {
    *
    * @param key the key of the entry to destroy.
    * @param aCallbackArgument the callback for user to pass in, default is
-   * NULLPTR.
-   * @throws IllegalArgumentException if key is NULLPTR
+   * nullptr.
+   * @throws IllegalArgumentException if key is nullptr
    * @throws CacheWriterException if CacheWriter aborts the operation
    * @throws CacheListenerException if CacheListener throws an exception
    * @throws EntryNotFoundException if the entry does not exist in this region
@@ -716,12 +717,12 @@ class CPPCACHE_EXPORT Region : public SharedBase {
    * @see CacheWriter::beforeDestroy
    */
   virtual void localDestroy(const CacheableKeyPtr& key,
-                            const UserDataPtr& aCallbackArgument = NULLPTR) = 0;
+                            const UserDataPtr& aCallbackArgument = nullptr) = 0;
 
   /** Convenience method allowing key to be a const char* */
   template <class KEYTYPE>
   inline void localDestroy(const KEYTYPE& key,
-                           const UserDataPtr& arg = NULLPTR) {
+                           const UserDataPtr& arg = nullptr) {
     localDestroy(createKey(key), arg);
   }
 
@@ -744,11 +745,11 @@ class CPPCACHE_EXPORT Region : public SharedBase {
   * <p>
   *
   * @param key the key of the entry to remove
-  * @param value the value of the key to remove, it can be NULLPTR.
+  * @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
+  *        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
@@ -774,26 +775,26 @@ class CPPCACHE_EXPORT Region : public SharedBase {
   * @see CacheWriter::beforeDestroy
   */
   virtual bool remove(const CacheableKeyPtr& key, const CacheablePtr& value,
-                      const UserDataPtr& aCallbackArgument = NULLPTR) = 0;
+                      const UserDataPtr& aCallbackArgument = nullptr) = 0;
 
   /** Convenience method allowing both key and value to be a const char* */
   template <class KEYTYPE, class VALUETYPE>
   inline bool remove(const KEYTYPE& key, const VALUETYPE& value,
-                     const UserDataPtr& arg = NULLPTR) {
+                     const UserDataPtr& arg = nullptr) {
     return remove(createKey(key), createValue(value), arg);
   }
 
   /** Convenience method allowing key to be a const char* */
   template <class KEYTYPE>
   inline bool remove(const KEYTYPE& key, const CacheablePtr& value,
-                     const UserDataPtr& arg = NULLPTR) {
+                     const UserDataPtr& arg = nullptr) {
     return remove(createKey(key), value, arg);
   }
 
   /** Convenience method allowing value to be a const char* */
   template <class VALUETYPE>
   inline bool remove(const CacheableKeyPtr& key, const VALUETYPE& value,
-                     const UserDataPtr& arg = NULLPTR) {
+                     const UserDataPtr& arg = nullptr) {
     return remove(key, createValue(value), arg);
   }
 
@@ -825,8 +826,8 @@ class CPPCACHE_EXPORT Region : public SharedBase {
   * @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
+  *        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
@@ -852,11 +853,11 @@ class CPPCACHE_EXPORT Region : public SharedBase {
   * @see CacheWriter::beforeDestroy
   */
   virtual bool removeEx(const CacheableKeyPtr& key,
-                        const UserDataPtr& aCallbackArgument = NULLPTR) = 0;
+                        const UserDataPtr& aCallbackArgument = nullptr) = 0;
 
   /** Convenience method allowing key to be a const char* */
   template <class KEYTYPE>
-  inline bool removeEx(const KEYTYPE& key, const UserDataPtr& arg = NULLPTR) {
+  inline bool removeEx(const KEYTYPE& key, const UserDataPtr& arg = nullptr) {
     return removeEx(createKey(key), arg);
   }
 
@@ -877,8 +878,8 @@ class CPPCACHE_EXPORT Region : public SharedBase {
   * @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
+  * 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
@@ -889,26 +890,26 @@ class CPPCACHE_EXPORT Region : public SharedBase {
   */
   virtual bool localRemove(const CacheableKeyPtr& key,
                            const CacheablePtr& value,
-                           const UserDataPtr& aCallbackArgument = NULLPTR) = 0;
+                           const UserDataPtr& aCallbackArgument = nullptr) = 0;
 
   /** Convenience method allowing both key and value to be a const char* */
   template <class KEYTYPE, class VALUETYPE>
   inline bool localRemove(const KEYTYPE& key, const VALUETYPE& value,
-                          const UserDataPtr& arg = NULLPTR) {
+                          const UserDataPtr& arg = nullptr) {
     return localRemove(createKey(key), createValue(value), arg);
   }
 
   /** Convenience method allowing key to be a const char* */
   template <class KEYTYPE>
   inline bool localRemove(const KEYTYPE& key, const CacheablePtr& value,
-                          const UserDataPtr& arg = NULLPTR) {
+                          const UserDataPtr& arg = nullptr) {
     return localRemove(createKey(key), value, arg);
   }
 
   /** Convenience method allowing value to be a const char* */
   template <class VALUETYPE>
   inline bool localRemove(const CacheableKeyPtr& key, const VALUETYPE& value,
-                          const UserDataPtr& arg = NULLPTR) {
+                          const UserDataPtr& arg = nullptr) {
     return localRemove(key, createValue(value), arg);
   }
 
@@ -927,8 +928,8 @@ class CPPCACHE_EXPORT Region : public SharedBase {
   *
   * @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
+  * 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
@@ -940,12 +941,12 @@ class CPPCACHE_EXPORT Region : public SharedBase {
 
   virtual bool localRemoveEx(
       const CacheableKeyPtr& key,
-      const UserDataPtr& aCallbackArgument = NULLPTR) = 0;
+      const UserDataPtr& aCallbackArgument = nullptr) = 0;
 
   /** Convenience method allowing key to be a const char* */
   template <class KEYTYPE>
   inline bool localRemoveEx(const KEYTYPE& key,
-                            const UserDataPtr& arg = NULLPTR) {
+                            const UserDataPtr& arg = nullptr) {
     return localRemoveEx(createKey(key), arg);
   }
 
@@ -1127,7 +1128,7 @@ class CPPCACHE_EXPORT Region : public SharedBase {
   * ( {@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
+  * @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
@@ -1157,7 +1158,7 @@ class CPPCACHE_EXPORT Region : public SharedBase {
   * @throws TimeoutException if operation timed out
   */
   virtual void registerAllKeys(bool isDurable = false,
-                               VectorOfCacheableKeyPtr resultKeys = NULLPTR,
+                               VectorOfCacheableKeyPtr resultKeys = nullptr,
                                bool getInitialValues = false,
                                bool receiveValues = true) = 0;
 
@@ -1193,7 +1194,7 @@ class CPPCACHE_EXPORT Region : public SharedBase {
   *
   * @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
+  * @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
@@ -1229,7 +1230,7 @@ class CPPCACHE_EXPORT Region : public SharedBase {
   * @throws TimeoutException if operation timed out
   */
   virtual void registerRegex(const char* regex, bool isDurable = false,
-                             VectorOfCacheableKeyPtr resultKeys = NULLPTR,
+                             VectorOfCacheableKeyPtr resultKeys = nullptr,
                              bool getInitialValues = false,
                              bool receiveValues = true) = 0;
 
@@ -1276,21 +1277,21 @@ class CPPCACHE_EXPORT Region : public SharedBase {
   *
   * @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
+  *   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.
+  *   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.
+  * 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
+  *   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
@@ -1310,7 +1311,7 @@ class CPPCACHE_EXPORT Region : public SharedBase {
                       HashMapOfCacheablePtr values,
                       HashMapOfExceptionPtr exceptions,
                       bool addToLocalCache = false,
-                      const UserDataPtr& aCallbackArgument = NULLPTR) = 0;
+                      const UserDataPtr& aCallbackArgument = nullptr) = 0;
 
   /**
   * Executes the query on the server based on the predicate.
@@ -1394,7 +1395,7 @@ class CPPCACHE_EXPORT Region : public SharedBase {
   * @throws TimeoutException if operation timed out
   * @throws CacheClosedException if the cache has been closed
   * @returns A smart pointer to the single ResultSet or StructSet item, or
-  * NULLPTR of no results are available.
+  * nullptr of no results are available.
   */
   virtual SerializablePtr selectValue(
       const char* predicate,
@@ -1413,7 +1414,7 @@ class CPPCACHE_EXPORT Region : public SharedBase {
   * @param keys the keys to remove from this region.
   * @param aCallbackArgument an argument that is passed to the callback
   * functions.
-  *  It is ignored if NULLPTR. It must be serializable if this operation is
+  *  It is ignored if nullptr. It must be serializable if this operation is
   * distributed.
   * @throws IllegalArgumentException If the array of keys is empty.
   * @throws CacheServerException If an exception is received from the Java
@@ -1429,7 +1430,7 @@ class CPPCACHE_EXPORT Region : public SharedBase {
   * @see destroy
   */
   virtual void removeAll(const VectorOfCacheableKey& keys,
-                         const UserDataPtr& aCallbackArgument = NULLPTR) = 0;
+                         const UserDataPtr& aCallbackArgument = nullptr) = 0;
 
   /**
    * Get the size of region. For native client regions, this will give the
@@ -1443,6 +1444,8 @@ class CPPCACHE_EXPORT Region : public SharedBase {
   Region();
   virtual ~Region();
 
+  FRIEND_STD_SHARED_PTR(Region)
+
  private:
   // Disallow copy constructor and assignment operator.
   Region(const Region&);


Mime
View raw message