http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/cppcache/src/ProxyRemoteQueryService.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/ProxyRemoteQueryService.cpp 
b/src/cppcache/src/ProxyRemoteQueryService.cpp
index d1adc86..da66e0b 100644
--- a/src/cppcache/src/ProxyRemoteQueryService.cpp
+++ b/src/cppcache/src/ProxyRemoteQueryService.cpp
@@ -19,21 +19,19 @@
 #include <geode/PoolManager.hpp>
 #include "CqQueryImpl.hpp"
 
-ProxyRemoteQueryService::ProxyRemoteQueryService(ProxyCache* cptr) {
-  ProxyCachePtr pcp(cptr);
-  m_proxyCache = pcp;
-}
+ProxyRemoteQueryService::ProxyRemoteQueryService(ProxyCachePtr cptr)
+    : m_proxyCache(cptr) {}
 
 QueryPtr ProxyRemoteQueryService::newQuery(const char* querystring) {
   if (!m_proxyCache->isClosed()) {
-    PoolPtr userAttachedPool = m_proxyCache->m_userAttributes->getPool();
-    PoolPtr pool = PoolManager::find(userAttachedPool->getName());
-    if (pool != NULLPTR && pool.ptr() == userAttachedPool.ptr() &&
+    auto userAttachedPool = m_proxyCache->m_userAttributes->getPool();
+    auto pool = PoolManager::find(userAttachedPool->getName());
+    if (pool != nullptr && pool.get() == userAttachedPool.get() &&
         !pool->isDestroyed()) {
       GuardUserAttribures gua(m_proxyCache);
-      ThinClientPoolDMPtr pooDM(static_cast<ThinClientPoolDM*>(pool.ptr()));
-      if (!pooDM->isDestroyed()) {
-        return pooDM->getQueryServiceWithoutCheck()->newQuery(querystring);
+      auto poolDM = std::static_pointer_cast<ThinClientPoolDM>(pool);
+      if (!poolDM->isDestroyed()) {
+        return poolDM->getQueryServiceWithoutCheck()->newQuery(querystring);
       }
     }
     throw IllegalStateException("Pool has been closed.");
@@ -54,14 +52,14 @@ CqQueryPtr ProxyRemoteQueryService::newCq(const char* 
querystr,
                                           CqAttributesPtr& cqAttr,
                                           bool isDurable) {
   if (!m_proxyCache->isClosed()) {
-    PoolPtr userAttachedPool = m_proxyCache->m_userAttributes->getPool();
-    PoolPtr pool = PoolManager::find(userAttachedPool->getName());
-    if (pool != NULLPTR && pool.ptr() == userAttachedPool.ptr() &&
+    auto userAttachedPool = m_proxyCache->m_userAttributes->getPool();
+    auto pool = PoolManager::find(userAttachedPool->getName());
+    if (pool != nullptr && pool.get() == userAttachedPool.get() &&
         !pool->isDestroyed()) {
       GuardUserAttribures gua(m_proxyCache);
-      ThinClientPoolDMPtr pooDM(static_cast<ThinClientPoolDM*>(pool.ptr()));
+      auto pooDM = std::static_pointer_cast<ThinClientPoolDM>(pool);
       if (!pooDM->isDestroyed()) {
-        CqQueryPtr cqQuery = pooDM->getQueryServiceWithoutCheck()->newCq(
+        auto cqQuery = pooDM->getQueryServiceWithoutCheck()->newCq(
             querystr, cqAttr, isDurable);
         addCqQuery(cqQuery);
         return cqQuery;
@@ -82,14 +80,14 @@ CqQueryPtr ProxyRemoteQueryService::newCq(const char* name,
                                           CqAttributesPtr& cqAttr,
                                           bool isDurable) {
   if (!m_proxyCache->isClosed()) {
-    PoolPtr userAttachedPool = m_proxyCache->m_userAttributes->getPool();
-    PoolPtr pool = PoolManager::find(userAttachedPool->getName());
-    if (pool != NULLPTR && pool.ptr() == userAttachedPool.ptr() &&
+    auto userAttachedPool = m_proxyCache->m_userAttributes->getPool();
+    auto pool = PoolManager::find(userAttachedPool->getName());
+    if (pool != nullptr && pool.get() == userAttachedPool.get() &&
         !pool->isDestroyed()) {
       GuardUserAttribures gua(m_proxyCache);
-      ThinClientPoolDMPtr pooDM(static_cast<ThinClientPoolDM*>(pool.ptr()));
-      if (!pooDM->isDestroyed()) {
-        CqQueryPtr cqQuery = pooDM->getQueryServiceWithoutCheck()->newCq(
+      auto poolDM = std::static_pointer_cast<ThinClientPoolDM>(pool);
+      if (!poolDM->isDestroyed()) {
+        auto cqQuery = poolDM->getQueryServiceWithoutCheck()->newCq(
             name, querystr, cqAttr, isDurable);
         addCqQuery(cqQuery);
         return cqQuery;
@@ -105,14 +103,14 @@ void ProxyRemoteQueryService::closeCqs() { 
closeCqs(false); }
 void ProxyRemoteQueryService::closeCqs(bool keepAlive) {
   ACE_Guard<ACE_Recursive_Thread_Mutex> guard(m_cqQueryListLock);
 
-  for (int32_t i = 0; i < m_cqQueries.size(); i++) {
-    std::string cqName = m_cqQueries[i]->getName();
+  for (auto& q : m_cqQueries) {
+    std::string cqName = q->getName();
     try {
-      if (!(m_cqQueries[i]->isDurable() && keepAlive)) {
-        m_cqQueries[i]->close();
+      if (!(q->isDurable() && keepAlive)) {
+        q->close();
       } else {
         // need to just cleanup client side data structure
-        CqQueryImpl* cqImpl = static_cast<CqQueryImpl*>(m_cqQueries[i].ptr());
+        auto cqImpl = std::static_pointer_cast<CqQueryImpl>(q);
         cqImpl->close(false);
       }
     } catch (QueryException& qe) {
@@ -127,24 +125,21 @@ void ProxyRemoteQueryService::closeCqs(bool keepAlive) {
   }
 }
 
-void ProxyRemoteQueryService::getCqs(VectorOfCqQuery& vec) {
+void ProxyRemoteQueryService::getCqs(query_container_type& vec) {
   ACE_Guard<ACE_Recursive_Thread_Mutex> guard(m_cqQueryListLock);
-
-  for (int32_t i = 0; i < m_cqQueries.size(); i++) {
-    vec.push_back(m_cqQueries[i]);
-  }
+  vec = m_cqQueries;
 }
 
 CqQueryPtr ProxyRemoteQueryService::getCq(const char* name) {
   if (!m_proxyCache->isClosed()) {
-    PoolPtr userAttachedPool = m_proxyCache->m_userAttributes->getPool();
-    PoolPtr pool = PoolManager::find(userAttachedPool->getName());
-    if (pool != NULLPTR && pool.ptr() == userAttachedPool.ptr() &&
+    auto userAttachedPool = m_proxyCache->m_userAttributes->getPool();
+    auto pool = PoolManager::find(userAttachedPool->getName());
+    if (pool != nullptr && pool.get() == userAttachedPool.get() &&
         !pool->isDestroyed()) {
       GuardUserAttribures gua(m_proxyCache);
-      ThinClientPoolDMPtr pooDM(static_cast<ThinClientPoolDM*>(pool.ptr()));
-      if (!pooDM->isDestroyed()) {
-        return pooDM->getQueryServiceWithoutCheck()->getCq(name);
+      auto poolDM = std::static_pointer_cast<ThinClientPoolDM>(pool);
+      if (!poolDM->isDestroyed()) {
+        return poolDM->getQueryServiceWithoutCheck()->getCq(name);
       }
     }
     throw IllegalStateException("Pool has been closed.");
@@ -155,10 +150,10 @@ CqQueryPtr ProxyRemoteQueryService::getCq(const char* 
name) {
 void ProxyRemoteQueryService::executeCqs() {
   ACE_Guard<ACE_Recursive_Thread_Mutex> guard(m_cqQueryListLock);
 
-  for (int32_t i = 0; i < m_cqQueries.size(); i++) {
-    std::string cqName = m_cqQueries[i]->getName();
+  for (auto& q : m_cqQueries) {
+    std::string cqName = q->getName();
     try {
-      m_cqQueries[i]->execute();
+      q->execute();
     } catch (QueryException& qe) {
       Log::fine(("Failed to excecue the CQ, CqName : " + cqName + " Error : " +
                  qe.getMessage())
@@ -174,10 +169,10 @@ void ProxyRemoteQueryService::executeCqs() {
 void ProxyRemoteQueryService::stopCqs() {
   ACE_Guard<ACE_Recursive_Thread_Mutex> guard(m_cqQueryListLock);
 
-  for (int32_t i = 0; i < m_cqQueries.size(); i++) {
-    std::string cqName = m_cqQueries[i]->getName();
+  for (auto& q : m_cqQueries) {
+    std::string cqName = q->getName();
     try {
-      m_cqQueries[i]->stop();
+      q->stop();
     } catch (QueryException& qe) {
       Log::fine(("Failed to stop the CQ, CqName : " + cqName + " Error : " +
                  qe.getMessage())
@@ -192,10 +187,10 @@ void ProxyRemoteQueryService::stopCqs() {
 
 CqServiceStatisticsPtr ProxyRemoteQueryService::getCqServiceStatistics() {
   unSupportedException("getCqServiceStatistics()");
-  return NULLPTR;
+  return nullptr;
 }
 
 CacheableArrayListPtr ProxyRemoteQueryService::getAllDurableCqsFromServer() {
   unSupportedException("getAllDurableCqsFromServer()");
-  return NULLPTR;
+  return nullptr;
 }

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/cppcache/src/ProxyRemoteQueryService.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/ProxyRemoteQueryService.hpp 
b/src/cppcache/src/ProxyRemoteQueryService.hpp
index 7eb3cbf..dcc36b6 100644
--- a/src/cppcache/src/ProxyRemoteQueryService.hpp
+++ b/src/cppcache/src/ProxyRemoteQueryService.hpp
@@ -38,7 +38,7 @@ class ThinClientPoolDM;
 
 class CPPCACHE_EXPORT ProxyRemoteQueryService : public QueryService {
  public:
-  ProxyRemoteQueryService(ProxyCache* cptr);
+  ProxyRemoteQueryService(ProxyCachePtr cptr);
 
   QueryPtr newQuery(const char* querystring);
 
@@ -48,7 +48,7 @@ class CPPCACHE_EXPORT ProxyRemoteQueryService : public 
QueryService {
   virtual CqQueryPtr newCq(const char* name, const char* querystr,
                            CqAttributesPtr& cqAttr, bool isDurable = false);
   virtual void closeCqs();
-  virtual void getCqs(VectorOfCqQuery& vec);
+  virtual void getCqs(query_container_type& vec);
   virtual CqQueryPtr getCq(const char* name);
   virtual void executeCqs();
   virtual void stopCqs();
@@ -62,7 +62,7 @@ class CPPCACHE_EXPORT ProxyRemoteQueryService : public 
QueryService {
 
   QueryServicePtr m_realQueryService;
   ProxyCachePtr m_proxyCache;
-  VectorOfCqQuery m_cqQueries;
+  query_container_type m_cqQueries;
   // lock for cqQuery list;
   ACE_Recursive_Thread_Mutex m_cqQueryListLock;
   friend class ProxyCache;

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/cppcache/src/PutAllPartialResult.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/PutAllPartialResult.cpp 
b/src/cppcache/src/PutAllPartialResult.cpp
index 4ca4b68..24929b6 100644
--- a/src/cppcache/src/PutAllPartialResult.cpp
+++ b/src/cppcache/src/PutAllPartialResult.cpp
@@ -22,7 +22,7 @@ namespace client {
 
 PutAllPartialResult::PutAllPartialResult(
     int totalMapSize, ACE_Recursive_Thread_Mutex& responseLock) {
-  m_succeededKeys = new VersionedCacheableObjectPartList(
+  m_succeededKeys = std::make_shared<VersionedCacheableObjectPartList>(
       new VectorOfCacheableKey(), responseLock);
   m_totalMapSize = totalMapSize;
 }

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/cppcache/src/PutAllPartialResult.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/PutAllPartialResult.hpp 
b/src/cppcache/src/PutAllPartialResult.hpp
index 6b44b7b..6240b09 100644
--- a/src/cppcache/src/PutAllPartialResult.hpp
+++ b/src/cppcache/src/PutAllPartialResult.hpp
@@ -57,11 +57,11 @@ class PutAllPartialResult : public Serializable {
   void addKeys(VectorOfCacheableKeyPtr m_keys);
 
   void saveFailedKey(CacheableKeyPtr key, ExceptionPtr cause) {
-    if (key == NULLPTR) {
+    if (key == nullptr) {
       return;
     }
     // TODO:: Do we need to handle server cancelException.
-    if (m_firstFailedKey == NULLPTR /*|| cause instanceof CaccelException */) {
+    if (m_firstFailedKey == nullptr /*|| cause instanceof CaccelException */) {
       m_firstFailedKey = key;
       m_firstCauseOfFailure = cause;
     }
@@ -73,14 +73,14 @@ class PutAllPartialResult : public Serializable {
   CacheableKeyPtr getFirstFailedKey() { return m_firstFailedKey; }
 
   // Returns there's failedKeys
-  bool hasFailure() { return m_firstFailedKey != NULLPTR; }
+  bool hasFailure() { return m_firstFailedKey != nullptr; }
 
   // Returns there's saved succeed keys
   bool hasSucceededKeys();
 
   virtual CacheableStringPtr toString() const {
     char msgStr1[1024];
-    if (m_firstFailedKey != NULLPTR) {
+    if (m_firstFailedKey != nullptr) {
       ACE_OS::snprintf(msgStr1, 1024, "[ Key =%s ]",
                        m_firstFailedKey->toString()->asChar());
     }

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/cppcache/src/PutAllPartialResultServerException.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/PutAllPartialResultServerException.cpp 
b/src/cppcache/src/PutAllPartialResultServerException.cpp
index b0c9a2a..1585e70 100644
--- a/src/cppcache/src/PutAllPartialResultServerException.cpp
+++ b/src/cppcache/src/PutAllPartialResultServerException.cpp
@@ -29,7 +29,7 @@ 
PutAllPartialResultServerException::PutAllPartialResultServerException(
 PutAllPartialResultServerException::PutAllPartialResultServerException() {
   LOGDEBUG("Partial keys are processed in putAll");
   ACE_Recursive_Thread_Mutex responseLock;
-  m_result = new PutAllPartialResult(-1, responseLock);
+  m_result = std::make_shared<PutAllPartialResult>(-1, responseLock);
 }
 
 void PutAllPartialResultServerException::consolidate(

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/cppcache/src/RegionAttributes.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/RegionAttributes.cpp 
b/src/cppcache/src/RegionAttributes.cpp
index 6b6cecd..6eee620 100644
--- a/src/cppcache/src/RegionAttributes.cpp
+++ b/src/cppcache/src/RegionAttributes.cpp
@@ -35,10 +35,10 @@ RegionAttributes::RegionAttributes()
       m_entryTimeToLiveExpirationAction(ExpirationAction::INVALIDATE),
       m_entryIdleTimeoutExpirationAction(ExpirationAction::INVALIDATE),
       m_lruEvictionAction(ExpirationAction::LOCAL_DESTROY),
-      m_cacheWriter(NULLPTR),
-      m_cacheLoader(NULLPTR),
-      m_cacheListener(NULLPTR),
-      m_partitionResolver(NULLPTR),
+      m_cacheWriter(nullptr),
+      m_cacheLoader(nullptr),
+      m_cacheListener(nullptr),
+      m_partitionResolver(nullptr),
       m_lruEntriesLimit(0),
       m_caching(true),
       m_maxValueDistLimit(100 * 1024),
@@ -62,8 +62,8 @@ RegionAttributes::RegionAttributes()
       m_clientNotificationEnabled(false),
       m_persistenceLibrary(NULL),
       m_persistenceFactory(NULL),
-      m_persistenceProperties(NULLPTR),
-      m_persistenceManager(NULLPTR),
+      m_persistenceProperties(nullptr),
+      m_persistenceManager(nullptr),
       m_poolName(NULL),
       m_isClonable(false),
       m_isConcurrencyChecksEnabled(true) {}
@@ -240,98 +240,98 @@ void* getFactoryFunc(const char* lib, const char* 
funcName) {
 }  // namespace apache
 
 CacheLoaderPtr RegionAttributes::getCacheLoader() {
-  if ((m_cacheLoader == NULLPTR) && (m_cacheLoaderLibrary != NULL)) {
+  if ((m_cacheLoader == nullptr) && (m_cacheLoaderLibrary != NULL)) {
     if (CacheXmlParser::managedCacheLoaderFn != NULL &&
         strchr(m_cacheLoaderFactory, '.') != NULL) {
       // this is a managed library
-      m_cacheLoader = (*CacheXmlParser::managedCacheLoaderFn)(
-          m_cacheLoaderLibrary, m_cacheLoaderFactory);
+      m_cacheLoader.reset((*CacheXmlParser::managedCacheLoaderFn)(
+          m_cacheLoaderLibrary, m_cacheLoaderFactory));
     } else {
       CacheLoader* (*funcptr)();
       funcptr = reinterpret_cast<CacheLoader* (*)()>(
           apache::geode::client::impl::getFactoryFunc(m_cacheLoaderLibrary,
                                                       m_cacheLoaderFactory));
-      m_cacheLoader = funcptr();
+      m_cacheLoader.reset(funcptr());
     }
   }
   return m_cacheLoader;
 }
 
 CacheWriterPtr RegionAttributes::getCacheWriter() {
-  if ((m_cacheWriter == NULLPTR) && (m_cacheWriterLibrary != NULL)) {
+  if ((m_cacheWriter == nullptr) && (m_cacheWriterLibrary != NULL)) {
     if (CacheXmlParser::managedCacheWriterFn != NULL &&
         strchr(m_cacheWriterFactory, '.') != NULL) {
       // this is a managed library
-      m_cacheWriter = (*CacheXmlParser::managedCacheWriterFn)(
-          m_cacheWriterLibrary, m_cacheWriterFactory);
+      m_cacheWriter.reset((*CacheXmlParser::managedCacheWriterFn)(
+          m_cacheWriterLibrary, m_cacheWriterFactory));
     } else {
       CacheWriter* (*funcptr)();
       funcptr = reinterpret_cast<CacheWriter* (*)()>(
           apache::geode::client::impl::getFactoryFunc(m_cacheWriterLibrary,
                                                       m_cacheWriterFactory));
-      m_cacheWriter = funcptr();
+      m_cacheWriter.reset(funcptr());
     }
   }
   return m_cacheWriter;
 }
 
 CacheListenerPtr RegionAttributes::getCacheListener() {
-  if ((m_cacheListener == NULLPTR) && (m_cacheListenerLibrary != NULL)) {
+  if ((m_cacheListener == nullptr) && (m_cacheListenerLibrary != NULL)) {
     if (CacheXmlParser::managedCacheListenerFn != NULL &&
         strchr(m_cacheListenerFactory, '.') != NULL) {
       // LOGDEBUG( "RegionAttributes::getCacheListener: Trying to create
       // instance from managed library." );
       // this is a managed library
-      m_cacheListener = (*CacheXmlParser::managedCacheListenerFn)(
-          m_cacheListenerLibrary, m_cacheListenerFactory);
+      m_cacheListener.reset((*CacheXmlParser::managedCacheListenerFn)(
+          m_cacheListenerLibrary, m_cacheListenerFactory));
     } else {
       CacheListener* (*funcptr)();
       funcptr = reinterpret_cast<CacheListener* (*)()>(
           apache::geode::client::impl::getFactoryFunc(m_cacheListenerLibrary,
                                                       m_cacheListenerFactory));
-      m_cacheListener = funcptr();
+      m_cacheListener.reset(funcptr());
     }
   }
   return m_cacheListener;
 }
 
 PartitionResolverPtr RegionAttributes::getPartitionResolver() {
-  if ((m_partitionResolver == NULLPTR) &&
+  if ((m_partitionResolver == nullptr) &&
       (m_partitionResolverLibrary != NULL)) {
     if (CacheXmlParser::managedPartitionResolverFn != NULL &&
         strchr(m_partitionResolverFactory, '.') != NULL) {
       // LOGDEBUG( "RegionAttributes::getCacheListener: Trying to create
       // instance from managed library." );
       // this is a managed library
-      m_partitionResolver = (*CacheXmlParser::managedPartitionResolverFn)(
-          m_partitionResolverLibrary, m_partitionResolverFactory);
+      m_partitionResolver.reset((*CacheXmlParser::managedPartitionResolverFn)(
+          m_partitionResolverLibrary, m_partitionResolverFactory));
     } else {
       PartitionResolver* (*funcptr)();
       funcptr = reinterpret_cast<PartitionResolver* (*)()>(
           apache::geode::client::impl::getFactoryFunc(
               m_partitionResolverLibrary, m_partitionResolverFactory));
-      m_partitionResolver = funcptr();
+      m_partitionResolver.reset(funcptr());
     }
   }
   return m_partitionResolver;
 }
 
 PersistenceManagerPtr RegionAttributes::getPersistenceManager() {
-  if ((m_persistenceManager == NULLPTR) && (m_persistenceLibrary != NULL)) {
+  if ((m_persistenceManager == nullptr) && (m_persistenceLibrary != NULL)) {
     if (CacheXmlParser::managedPartitionResolverFn != NULL &&
         strchr(m_persistenceFactory, '.') != NULL) {
       LOGDEBUG(
           "RegionAttributes::getPersistenceManager: Trying to create instance "
           "from managed library.");
       // this is a managed library
-      m_persistenceManager = (*CacheXmlParser::managedPersistenceManagerFn)(
-          m_persistenceLibrary, m_persistenceFactory);
+      
m_persistenceManager.reset((*CacheXmlParser::managedPersistenceManagerFn)(
+          m_persistenceLibrary, m_persistenceFactory));
     } else {
       PersistenceManager* (*funcptr)();
       funcptr = reinterpret_cast<PersistenceManager* (*)()>(
           apache::geode::client::impl::getFactoryFunc(m_persistenceLibrary,
                                                       m_persistenceFactory));
-      m_persistenceManager = funcptr();
+      m_persistenceManager.reset(funcptr());
     }
   }
   return m_persistenceManager;
@@ -653,27 +653,27 @@ bool RegionAttributes::operator!=(const RegionAttributes& 
other) const {
 /* Throws IllegalStateException when attributes targetted for use on a server 
do
  * not meet requirements. */
 void RegionAttributes::validateSerializableAttributes() {
-  if (m_cacheLoader != NULLPTR) {
+  if (m_cacheLoader != nullptr) {
     throw IllegalStateException(
         "CacheLoader must be set with setCacheLoader(library, factory) in "
         "members of type SERVER");
   }
-  if (m_cacheWriter != NULLPTR) {
+  if (m_cacheWriter != nullptr) {
     throw IllegalStateException(
         "CacheWriter must be set with setCacheWriter(library, factory) in "
         "members of type SERVER");
   }
-  if (m_cacheListener != NULLPTR) {
+  if (m_cacheListener != nullptr) {
     throw IllegalStateException(
         "CacheListener must be set with setCacheListener(library, factory) in "
         "members of type SERVER");
   }
-  if (m_partitionResolver != NULLPTR) {
+  if (m_partitionResolver != nullptr) {
     throw IllegalStateException(
         "PartitionResolver must be set with setPartitionResolver(library, "
         "factory) in members of type SERVER");
   }
-  if (m_persistenceManager != NULLPTR) {
+  if (m_persistenceManager != nullptr) {
     throw IllegalStateException(
         "persistenceManager must be set with setPersistenceManager(library, "
         "factory,config) in members of type SERVER");

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/cppcache/src/RegionCommit.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/RegionCommit.cpp 
b/src/cppcache/src/RegionCommit.cpp
index ca60857..62e26c8 100644
--- a/src/cppcache/src/RegionCommit.cpp
+++ b/src/cppcache/src/RegionCommit.cpp
@@ -27,14 +27,6 @@ namespace apache {
 namespace geode {
 namespace client {
 
-RegionCommit::RegionCommit() {
-  // TODO Auto-generated constructor stub
-}
-
-RegionCommit::~RegionCommit() {
-  // TODO Auto-generated destructor stub
-}
-
 void RegionCommit::fromData(DataInput& input) {
   input.readObject(m_regionPath);
   input.readObject(m_parentRegionPath);
@@ -48,7 +40,7 @@ void RegionCommit::fromData(DataInput& input) {
     input.readObject(dsMember);
     uint16_t memId = CacheImpl::getMemberListForVersionStamp()->add(dsMember);
     for (int i = 0; i < size; i++) {
-      FarSideEntryOpPtr entryOp(new FarSideEntryOp(this));
+      auto entryOp = std::make_shared<FarSideEntryOp>(this);
       entryOp->fromData(input, largeModCount, memId);
       m_farSideEntryOps.push_back(entryOp);
     }
@@ -56,22 +48,19 @@ void RegionCommit::fromData(DataInput& input) {
 }
 
 void RegionCommit::apply(Cache* cache) {
-  for (VectorOfSharedBase::Iterator iter = m_farSideEntryOps.begin();
-       m_farSideEntryOps.end() != iter; iter++) {
-    FarSideEntryOpPtr entryOp = staticCast<FarSideEntryOpPtr>(*iter);
-    RegionPtr region = cache->getRegion(m_regionPath->asChar());
-    if (region == NULLPTR && m_parentRegionPath != NULLPTR) {
+  for (auto& entryOp : m_farSideEntryOps) {
+    auto region = cache->getRegion(m_regionPath->asChar());
+    if (region == nullptr && m_parentRegionPath != nullptr) {
       region = cache->getRegion(m_parentRegionPath->asChar());
     }
-    entryOp->apply(region);
+    std::static_pointer_cast<FarSideEntryOp>(entryOp)->apply(region);
   }
 }
 
 void RegionCommit::fillEvents(Cache* cache,
                               std::vector<FarSideEntryOpPtr>& ops) {
-  for (VectorOfSharedBase::Iterator iter = m_farSideEntryOps.begin();
-       m_farSideEntryOps.end() != iter; iter++) {
-    ops.push_back(*iter);
+  for (auto& entryOp : m_farSideEntryOps) {
+    ops.push_back(std::static_pointer_cast<FarSideEntryOp>(entryOp));
   }
 }
 }  // namespace client

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/cppcache/src/RegionCommit.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/RegionCommit.hpp 
b/src/cppcache/src/RegionCommit.hpp
index 541614d..2de98b3 100644
--- a/src/cppcache/src/RegionCommit.hpp
+++ b/src/cppcache/src/RegionCommit.hpp
@@ -43,8 +43,8 @@ _GF_PTR_DEF_(RegionCommit, RegionCommitPtr);
 
 class RegionCommit : public apache::geode::client::SharedBase {
  public:
-  RegionCommit();
-  virtual ~RegionCommit();
+  RegionCommit(){};
+  virtual ~RegionCommit(){};
 
   void fromData(DataInput& input);
   void apply(Cache* cache);

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/cppcache/src/RegionEntry.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/RegionEntry.cpp b/src/cppcache/src/RegionEntry.cpp
index 96cfbf2..fbf6246 100644
--- a/src/cppcache/src/RegionEntry.cpp
+++ b/src/cppcache/src/RegionEntry.cpp
@@ -21,15 +21,15 @@
 
 using namespace apache::geode::client;
 
-RegionEntry::RegionEntry(const RegionPtr& region, const CacheableKeyPtr& key,
+RegionEntry::RegionEntry(Region* region, const CacheableKeyPtr& key,
                          const CacheablePtr& value)
     : m_region(region), m_key(key), m_value(value), m_destroyed(false) {}
 RegionEntry::~RegionEntry() {}
 CacheableKeyPtr RegionEntry::getKey() { return m_key; }
 CacheablePtr RegionEntry::getValue() {
-  return CacheableToken::isInvalid(m_value) ? NULLPTR : m_value;
+  return CacheableToken::isInvalid(m_value) ? nullptr : m_value;
 }
-void RegionEntry::getRegion(RegionPtr& region) { region = m_region; }
+void RegionEntry::getRegion(Region* region) { region = m_region; }
 void RegionEntry::getStatistics(CacheStatisticsPtr& csptr) {
   csptr = m_statistics;
 }

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/cppcache/src/RegionExpiryHandler.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/RegionExpiryHandler.cpp 
b/src/cppcache/src/RegionExpiryHandler.cpp
index 3def51b..66e74c5 100644
--- a/src/cppcache/src/RegionExpiryHandler.cpp
+++ b/src/cppcache/src/RegionExpiryHandler.cpp
@@ -89,7 +89,7 @@ void RegionExpiryHandler::DoTheExpirationAction() {
           "RegionExpiryHandler::DoTheExpirationAction INVALIDATE "
           "region [%s]",
           m_regionPtr->getFullPath());
-      m_regionPtr->invalidateRegionNoThrow(NULLPTR,
+      m_regionPtr->invalidateRegionNoThrow(nullptr,
                                            CacheEventFlags::EXPIRATION);
       break;
     }
@@ -99,7 +99,7 @@ void RegionExpiryHandler::DoTheExpirationAction() {
           "region [%s]",
           m_regionPtr->getFullPath());
       m_regionPtr->invalidateRegionNoThrow(
-          NULLPTR, CacheEventFlags::EXPIRATION | CacheEventFlags::LOCAL);
+          nullptr, CacheEventFlags::EXPIRATION | CacheEventFlags::LOCAL);
       break;
     }
     case ExpirationAction::DESTROY: {
@@ -107,7 +107,7 @@ void RegionExpiryHandler::DoTheExpirationAction() {
           "RegionExpiryHandler::DoTheExpirationAction DESTROY "
           "region [%s]",
           m_regionPtr->getFullPath());
-      m_regionPtr->destroyRegionNoThrow(NULLPTR, true,
+      m_regionPtr->destroyRegionNoThrow(nullptr, true,
                                         CacheEventFlags::EXPIRATION);
       break;
     }
@@ -117,7 +117,7 @@ void RegionExpiryHandler::DoTheExpirationAction() {
           "region [%s]",
           m_regionPtr->getFullPath());
       m_regionPtr->destroyRegionNoThrow(
-          NULLPTR, true, CacheEventFlags::EXPIRATION | CacheEventFlags::LOCAL);
+          nullptr, true, CacheEventFlags::EXPIRATION | CacheEventFlags::LOCAL);
       break;
     }
     default: {

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/cppcache/src/RegionFactory.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/RegionFactory.cpp 
b/src/cppcache/src/RegionFactory.cpp
index c94255d..cd40cef 100644
--- a/src/cppcache/src/RegionFactory.cpp
+++ b/src/cppcache/src/RegionFactory.cpp
@@ -37,22 +37,22 @@ namespace client {
 
 RegionFactory::RegionFactory(RegionShortcut preDefinedRegion) {
   m_preDefinedRegion = preDefinedRegion;
-  AttributesFactoryPtr afPtr(new AttributesFactory());
-  m_attributeFactory = afPtr;
+  m_attributeFactory = std::make_shared<AttributesFactory>();
+  ;
   setRegionShortcut();
 }
 
 RegionFactory::~RegionFactory() {}
 
 RegionPtr RegionFactory::create(const char* name) {
-  RegionPtr retRegionPtr = NULLPTR;
+  RegionPtr retRegionPtr = nullptr;
   RegionAttributesPtr regAttr = m_attributeFactory->createRegionAttributes();
 
   // assuming pool name is not DEFAULT_POOL_NAME
   if (regAttr->getPoolName() != NULL && strlen(regAttr->getPoolName()) > 0) {
     // poolname is set
     CachePtr cache = CacheFactory::getAnyInstance();
-    CacheImpl* cacheImpl = CacheRegionHelper::getCacheImpl(cache.ptr());
+    CacheImpl* cacheImpl = CacheRegionHelper::getCacheImpl(cache.get());
     cacheImpl->createRegion(name, regAttr, retRegionPtr);
   } else {
     // need to look default Pool
@@ -60,7 +60,7 @@ RegionPtr RegionFactory::create(const char* name) {
     // if local region no need to create default pool
     if (m_preDefinedRegion != LOCAL) {
       PoolPtr pool = CacheFactory::createOrGetDefaultPool();
-      if (pool == NULLPTR) {
+      if (pool == nullptr) {
         throw IllegalStateException("Pool is not defined create region.");
       }
       m_attributeFactory->setPoolName(pool->getName());
@@ -68,7 +68,7 @@ RegionPtr RegionFactory::create(const char* name) {
 
     regAttr = m_attributeFactory->createRegionAttributes();
     CachePtr cache = CacheFactory::getAnyInstance();
-    CacheImpl* cacheImpl = CacheRegionHelper::getCacheImpl(cache.ptr());
+    CacheImpl* cacheImpl = CacheRegionHelper::getCacheImpl(cache.get());
     cacheImpl->createRegion(name, regAttr, retRegionPtr);
   }
 
@@ -82,82 +82,70 @@ void RegionFactory::setRegionShortcut() {
 RegionFactoryPtr RegionFactory::setCacheLoader(
     const CacheLoaderPtr& cacheLoader) {
   m_attributeFactory->setCacheLoader(cacheLoader);
-  RegionFactoryPtr rfPtr(this);
-  return rfPtr;
+  return shared_from_this();
 }
 
 RegionFactoryPtr RegionFactory::setCacheWriter(
     const CacheWriterPtr& cacheWriter) {
   m_attributeFactory->setCacheWriter(cacheWriter);
-  RegionFactoryPtr rfPtr(this);
-  return rfPtr;
+  return shared_from_this();
 }
 RegionFactoryPtr RegionFactory::setCacheListener(
     const CacheListenerPtr& aListener) {
   m_attributeFactory->setCacheListener(aListener);
-  RegionFactoryPtr rfPtr(this);
-  return rfPtr;
+  return shared_from_this();
 }
 RegionFactoryPtr RegionFactory::setPartitionResolver(
     const PartitionResolverPtr& aResolver) {
   m_attributeFactory->setPartitionResolver(aResolver);
-  RegionFactoryPtr rfPtr(this);
-  return rfPtr;
+  return shared_from_this();
 }
 
 RegionFactoryPtr RegionFactory::setCacheLoader(const char* lib,
                                                const char* func) {
   m_attributeFactory->setCacheLoader(lib, func);
-  RegionFactoryPtr rfPtr(this);
-  return rfPtr;
+  return shared_from_this();
 }
 
 RegionFactoryPtr RegionFactory::setCacheWriter(const char* lib,
                                                const char* func) {
   m_attributeFactory->setCacheWriter(lib, func);
-  RegionFactoryPtr rfPtr(this);
-  return rfPtr;
+  return shared_from_this();
 }
 
 RegionFactoryPtr RegionFactory::setCacheListener(const char* lib,
                                                  const char* func) {
   m_attributeFactory->setCacheListener(lib, func);
-  RegionFactoryPtr rfPtr(this);
-  return rfPtr;
+  return shared_from_this();
 }
 
 RegionFactoryPtr RegionFactory::setPartitionResolver(const char* lib,
                                                      const char* func) {
   m_attributeFactory->setPartitionResolver(lib, func);
-  RegionFactoryPtr rfPtr(this);
-  return rfPtr;
+  return shared_from_this();
 }
 
 RegionFactoryPtr RegionFactory::setEntryIdleTimeout(
     ExpirationAction::Action action, int idleTimeout) {
   m_attributeFactory->setEntryIdleTimeout(action, idleTimeout);
-  RegionFactoryPtr rfPtr(this);
-  return rfPtr;
+  return shared_from_this();
 }
 
 RegionFactoryPtr RegionFactory::setEntryTimeToLive(
     ExpirationAction::Action action, int timeToLive) {
   m_attributeFactory->setEntryTimeToLive(action, timeToLive);
-  RegionFactoryPtr rfPtr(this);
-  return rfPtr;
+  return shared_from_this();
 }
 
 RegionFactoryPtr RegionFactory::setRegionIdleTimeout(
     ExpirationAction::Action action, int idleTimeout) {
   m_attributeFactory->setRegionIdleTimeout(action, idleTimeout);
-  RegionFactoryPtr rfPtr(this);
-  return rfPtr;
+  return shared_from_this();
 }
 RegionFactoryPtr RegionFactory::setRegionTimeToLive(
     ExpirationAction::Action action, int timeToLive) {
   m_attributeFactory->setRegionTimeToLive(action, timeToLive);
-  RegionFactoryPtr rfPtr(this);
-  return rfPtr;
+  return shared_from_this();
 }
 
 RegionFactoryPtr RegionFactory::setInitialCapacity(int initialCapacity) {
@@ -167,71 +155,60 @@ RegionFactoryPtr RegionFactory::setInitialCapacity(int 
initialCapacity) {
     throw IllegalArgumentException(excpStr);
   }
   m_attributeFactory->setInitialCapacity(initialCapacity);
-  RegionFactoryPtr rfPtr(this);
-  return rfPtr;
+  return shared_from_this();
 }
 
 RegionFactoryPtr RegionFactory::setLoadFactor(float loadFactor) {
   m_attributeFactory->setLoadFactor(loadFactor);
-  RegionFactoryPtr rfPtr(this);
-  return rfPtr;
+  return shared_from_this();
 }
 
 RegionFactoryPtr RegionFactory::setConcurrencyLevel(uint8_t concurrencyLevel) {
   m_attributeFactory->setConcurrencyLevel(concurrencyLevel);
-  RegionFactoryPtr rfPtr(this);
-  return rfPtr;
+  return shared_from_this();
 }
 RegionFactoryPtr RegionFactory::setConcurrencyChecksEnabled(bool enable) {
   m_attributeFactory->setConcurrencyChecksEnabled(enable);
-  RegionFactoryPtr rfPtr(this);
-  return rfPtr;
+  return shared_from_this();
 }
 RegionFactoryPtr RegionFactory::setLruEntriesLimit(
     const uint32_t entriesLimit) {
   m_attributeFactory->setLruEntriesLimit(entriesLimit);
-  RegionFactoryPtr rfPtr(this);
-  return rfPtr;
+  return shared_from_this();
 }
 
 RegionFactoryPtr RegionFactory::setDiskPolicy(
     const DiskPolicyType::PolicyType diskPolicy) {
   m_attributeFactory->setDiskPolicy(diskPolicy);
-  RegionFactoryPtr rfPtr(this);
-  return rfPtr;
+  return shared_from_this();
 }
 
 RegionFactoryPtr RegionFactory::setCachingEnabled(bool cachingEnabled) {
   m_attributeFactory->setCachingEnabled(cachingEnabled);
-  RegionFactoryPtr rfPtr(this);
-  return rfPtr;
+  return shared_from_this();
 }
 
 RegionFactoryPtr RegionFactory::setPersistenceManager(
     const PersistenceManagerPtr& persistenceManager,
     const PropertiesPtr& config) {
   m_attributeFactory->setPersistenceManager(persistenceManager, config);
-  RegionFactoryPtr rfPtr(this);
-  return rfPtr;
+  return shared_from_this();
 }
 
 RegionFactoryPtr RegionFactory::setPersistenceManager(
     const char* lib, const char* func, const PropertiesPtr& config) {
   m_attributeFactory->setPersistenceManager(lib, func, config);
-  RegionFactoryPtr rfPtr(this);
-  return rfPtr;
+  return shared_from_this();
 }
 
 RegionFactoryPtr RegionFactory::setPoolName(const char* name) {
   m_attributeFactory->setPoolName(name);
-  RegionFactoryPtr rfPtr(this);
-  return rfPtr;
+  return shared_from_this();
 }
 
 RegionFactoryPtr RegionFactory::setCloningEnabled(bool isClonable) {
   m_attributeFactory->setCloningEnabled(isClonable);
-  RegionFactoryPtr rfPtr(this);
-  return rfPtr;
+  return shared_from_this();
 }
 }  // namespace client
 }  // namespace geode

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/cppcache/src/RegionInternal.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/RegionInternal.cpp 
b/src/cppcache/src/RegionInternal.cpp
index d81ac75..512cf1d 100644
--- a/src/cppcache/src/RegionInternal.cpp
+++ b/src/cppcache/src/RegionInternal.cpp
@@ -105,129 +105,129 @@ TombstoneListPtr RegionInternal::getTombstoneList() {
 
 RegionEntryPtr RegionInternal::createRegionEntry(const CacheableKeyPtr& key,
                                                  const CacheablePtr& value) {
-  return RegionEntryPtr(new RegionEntry(RegionPtr(this), key, value));
+  return RegionEntryPtr(new RegionEntry(this, key, value));
 }
 
 void RegionInternal::setLruEntriesLimit(uint32_t limit) {
-  if (m_regionAttributes != NULLPTR) {
+  if (m_regionAttributes != nullptr) {
     m_regionAttributes->m_lruEntriesLimit = limit;
   }
 }
 
 void RegionInternal::setRegionTimeToLiveExpirationAction(
     ExpirationAction::Action action) {
-  if (m_regionAttributes != NULLPTR) {
+  if (m_regionAttributes != nullptr) {
     m_regionAttributes->m_regionTimeToLiveExpirationAction = action;
   }
 }
 
 void RegionInternal::setRegionIdleTimeoutExpirationAction(
     ExpirationAction::Action action) {
-  if (m_regionAttributes != NULLPTR) {
+  if (m_regionAttributes != nullptr) {
     m_regionAttributes->m_regionIdleTimeoutExpirationAction = action;
   }
 }
 
 void RegionInternal::setEntryTimeToLiveExpirationAction(
     ExpirationAction::Action action) {
-  if (m_regionAttributes != NULLPTR) {
+  if (m_regionAttributes != nullptr) {
     m_regionAttributes->m_entryTimeToLiveExpirationAction = action;
   }
 }
 
 void RegionInternal::setEntryIdleTimeoutExpirationAction(
     ExpirationAction::Action action) {
-  if (m_regionAttributes != NULLPTR) {
+  if (m_regionAttributes != nullptr) {
     m_regionAttributes->m_entryIdleTimeoutExpirationAction = action;
   }
 }
 
 void RegionInternal::setRegionTimeToLive(int32_t duration) {
-  if (m_regionAttributes != NULLPTR) {
+  if (m_regionAttributes != nullptr) {
     m_regionAttributes->m_regionTimeToLive = duration;
   }
 }
 
 void RegionInternal::setRegionIdleTimeout(int32_t duration) {
-  if (m_regionAttributes != NULLPTR) {
+  if (m_regionAttributes != nullptr) {
     m_regionAttributes->m_regionIdleTimeout = duration;
   }
 }
 
 void RegionInternal::setEntryTimeToLive(int32_t duration) {
-  if (m_regionAttributes != NULLPTR) {
+  if (m_regionAttributes != nullptr) {
     m_regionAttributes->m_entryTimeToLive = duration;
   }
 }
 
 void RegionInternal::setEntryIdleTimeout(int32_t duration) {
-  if (m_regionAttributes != NULLPTR) {
+  if (m_regionAttributes != nullptr) {
     m_regionAttributes->m_entryIdleTimeout = duration;
   }
 }
 
 void RegionInternal::setCacheListener(const CacheListenerPtr& aListener) {
-  if (m_regionAttributes != NULLPTR) {
+  if (m_regionAttributes != nullptr) {
     m_regionAttributes->m_cacheListener = aListener;
   }
 }
 
 void RegionInternal::setCacheListener(const char* libpath,
                                       const char* factoryFuncName) {
-  if (m_regionAttributes != NULLPTR) {
+  if (m_regionAttributes != nullptr) {
     m_regionAttributes->setCacheListener(libpath, factoryFuncName);
   }
 }
 
 void RegionInternal::setPartitionResolver(
     const PartitionResolverPtr& aResolver) {
-  if (m_regionAttributes != NULLPTR) {
+  if (m_regionAttributes != nullptr) {
     m_regionAttributes->m_partitionResolver = aResolver;
   }
 }
 
 void RegionInternal::setPartitionResolver(const char* libpath,
                                           const char* factoryFuncName) {
-  if (m_regionAttributes != NULLPTR) {
+  if (m_regionAttributes != nullptr) {
     m_regionAttributes->setPartitionResolver(libpath, factoryFuncName);
   }
 }
 
 void RegionInternal::setCacheLoader(const CacheLoaderPtr& aLoader) {
-  if (m_regionAttributes != NULLPTR) {
+  if (m_regionAttributes != nullptr) {
     m_regionAttributes->m_cacheLoader = aLoader;
   }
 }
 
 void RegionInternal::setCacheLoader(const char* libpath,
                                     const char* factoryFuncName) {
-  if (m_regionAttributes != NULLPTR) {
+  if (m_regionAttributes != nullptr) {
     m_regionAttributes->setCacheLoader(libpath, factoryFuncName);
   }
 }
 
 void RegionInternal::setCacheWriter(const CacheWriterPtr& aWriter) {
-  if (m_regionAttributes != NULLPTR) {
+  if (m_regionAttributes != nullptr) {
     m_regionAttributes->m_cacheWriter = aWriter;
   }
 }
 
 void RegionInternal::setCacheWriter(const char* libpath,
                                     const char* factoryFuncName) {
-  if (m_regionAttributes != NULLPTR) {
+  if (m_regionAttributes != nullptr) {
     m_regionAttributes->setCacheWriter(libpath, factoryFuncName);
   }
 }
 
 void RegionInternal::setEndpoints(const char* endpoints) {
-  if (m_regionAttributes != NULLPTR) {
+  if (m_regionAttributes != nullptr) {
     m_regionAttributes->setEndpoints(endpoints);
   }
 }
 
 void RegionInternal::setClientNotificationEnabled(
     bool clientNotificationEnabled) {
-  if (m_regionAttributes != NULLPTR) {
+  if (m_regionAttributes != nullptr) {
     m_regionAttributes->m_clientNotificationEnabled = 
clientNotificationEnabled;
   }
 }

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/cppcache/src/RegionInternal.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/RegionInternal.hpp 
b/src/cppcache/src/RegionInternal.hpp
index fcadee8..8478a29 100644
--- a/src/cppcache/src/RegionInternal.hpp
+++ b/src/cppcache/src/RegionInternal.hpp
@@ -135,13 +135,13 @@ class RegionInternal : public Region {
                             bool receiveValues = true);
   virtual void unregisterKeys(const VectorOfCacheableKey& keys);
   virtual void registerAllKeys(bool isDurable = false,
-                               VectorOfCacheableKeyPtr resultKeys = NULLPTR,
+                               VectorOfCacheableKeyPtr resultKeys = nullptr,
                                bool getInitialValues = false,
                                bool receiveValues = true);
   virtual void unregisterAllKeys();
 
   virtual void registerRegex(const char* regex, bool isDurable = false,
-                             VectorOfCacheableKeyPtr resultKeys = NULLPTR,
+                             VectorOfCacheableKeyPtr resultKeys = nullptr,
                              bool getInitialValues = false,
                              bool receiveValues = true);
   virtual void unregisterRegex(const char* regex);
@@ -172,7 +172,7 @@ class RegionInternal : public Region {
                                const CacheEventFlags eventFlags,
                                VersionTagPtr versionTag,
                                DataInput* delta = NULL,
-                               EventIdPtr eventId = NULLPTR) = 0;
+                               EventIdPtr eventId = nullptr) = 0;
   virtual GfErrType createNoThrow(const CacheableKeyPtr& key,
                                   const CacheablePtr& value,
                                   const UserDataPtr& aCallbackArgument,
@@ -227,7 +227,7 @@ class RegionInternal : public Region {
   virtual bool cacheEnabled() = 0;
   virtual bool isDestroyed() const = 0;
   virtual void evict(int32_t percentage) = 0;
-  virtual CacheImpl* getCacheImpl() = 0;
+  virtual CacheImpl* getCacheImpl() const = 0;
   virtual TombstoneListPtr getTombstoneList();
 
   // KN: added now.

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/cppcache/src/RegionXmlCreation.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/RegionXmlCreation.cpp 
b/src/cppcache/src/RegionXmlCreation.cpp
index b9b4aba..3c937e2 100644
--- a/src/cppcache/src/RegionXmlCreation.cpp
+++ b/src/cppcache/src/RegionXmlCreation.cpp
@@ -43,17 +43,17 @@ void RegionXmlCreation::fillIn(RegionPtr regionPtr) {
 
 void RegionXmlCreation::createRoot(Cache* cache) {
   GF_D_ASSERT(this->isRoot);
-  RegionPtr rootRegPtr = NULLPTR;
+  RegionPtr rootRegPtr = nullptr;
 
   if (Cache_CreatedFromCacheFactory) {
-    //  if(cache->m_cacheImpl->getDefaultPool() == NULLPTR)
+    //  if(cache->m_cacheImpl->getDefaultPool() == nullptr)
     {
       // we may need to initialize default pool
       if (regAttrs->getEndpoints() == NULL) {
         if (regAttrs->getPoolName() == NULL) {
           PoolPtr pool = CacheFactory::createOrGetDefaultPool();
 
-          if (pool == NULLPTR) {
+          if (pool == nullptr) {
             throw IllegalStateException("Pool is not defined create region.");
           }
           regAttrs->setPoolName(pool->getName());
@@ -69,14 +69,14 @@ void RegionXmlCreation::createRoot(Cache* cache) {
 
 void RegionXmlCreation::create(RegionPtr parent) {
   GF_D_ASSERT(!(this->isRoot));
-  RegionPtr subRegPtr = NULLPTR;
+  RegionPtr subRegPtr = nullptr;
 
   subRegPtr = parent->createSubregion(regionName.c_str(), regAttrs);
   fillIn(subRegPtr);
 }
 
 RegionXmlCreation::RegionXmlCreation(char* name, bool isRootRegion)
-    : regAttrs(NULLPTR) {
+    : regAttrs(nullptr) {
   std::string tempName(name);
   regionName = tempName;
   isRoot = isRootRegion;

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/cppcache/src/RemoteQuery.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/RemoteQuery.cpp b/src/cppcache/src/RemoteQuery.cpp
index cf617ce..3fbb411 100644
--- a/src/cppcache/src/RemoteQuery.cpp
+++ b/src/cppcache/src/RemoteQuery.cpp
@@ -39,16 +39,16 @@ RemoteQuery::RemoteQuery(const char* querystr,
 
 SelectResultsPtr RemoteQuery::execute(uint32_t timeout) {
   GuardUserAttribures gua;
-  if (m_proxyCache != NULLPTR) {
+  if (m_proxyCache != nullptr) {
     gua.setProxyCache(m_proxyCache);
   }
-  return execute(timeout, "Query::execute", m_tccdm, NULLPTR);
+  return execute(timeout, "Query::execute", m_tccdm, nullptr);
 }
 
 SelectResultsPtr RemoteQuery::execute(CacheableVectorPtr paramList,
                                       uint32_t timeout) {
   GuardUserAttribures gua;
-  if (m_proxyCache != NULLPTR) {
+  if (m_proxyCache != nullptr) {
     gua.setProxyCache(m_proxyCache);
   }
   return execute(timeout, "Query::execute", m_tccdm, paramList);
@@ -88,7 +88,7 @@ SelectResultsPtr RemoteQuery::execute(uint32_t timeout, const 
char* func,
   if (sizeOfFieldNamesVec == 0) {
     LOGFINEST("%s: creating ResultSet for query: %s", func,
               m_queryString.c_str());
-    sr = new ResultSetImpl(values);
+    sr = std::make_shared<ResultSetImpl>(values);
   } else {
     if (values->size() % fieldNameVec.size() != 0) {
       char exMsg[1024];
@@ -100,7 +100,7 @@ SelectResultsPtr RemoteQuery::execute(uint32_t timeout, 
const char* func,
     } else {
       LOGFINEST("%s: creating StructSet for query: %s", func,
                 m_queryString.c_str());
-      sr = new StructSetImpl(values, fieldNameVec);
+      sr = std::make_shared<StructSetImpl>(values, fieldNameVec);
     }
   }
 
@@ -127,10 +127,10 @@ GfErrType RemoteQuery::executeNoThrow(uint32_t timeout, 
TcrMessageReply& reply,
   }
   LOGDEBUG("%s: creating QUERY TcrMessage for query: %s", func,
            m_queryString.c_str());
-  if (paramList != NULLPTR) {
+  if (paramList != nullptr) {
     // QUERY_WITH_PARAMETERS
     TcrMessageQueryWithParameters msg(
-        m_queryString, NULLPTR, paramList,
+        m_queryString, nullptr, paramList,
         static_cast<int>(timeout * 1000) /* in milli second */, tcdm);
     msg.setTimeout(timeout);
     reply.setTimeout(timeout);

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/cppcache/src/RemoteQuery.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/RemoteQuery.hpp b/src/cppcache/src/RemoteQuery.hpp
index b9daad7..3a44ce3 100644
--- a/src/cppcache/src/RemoteQuery.hpp
+++ b/src/cppcache/src/RemoteQuery.hpp
@@ -51,7 +51,7 @@ class CPPCACHE_EXPORT RemoteQuery : public Query {
 
  public:
   RemoteQuery(const char* querystr, const RemoteQueryServicePtr& queryService,
-              ThinClientBaseDM* tccdmptr, ProxyCachePtr proxyCache = NULLPTR);
+              ThinClientBaseDM* tccdmptr, ProxyCachePtr proxyCache = nullptr);
 
   //@TODO check the return type, is it ok. second option could be to pass
   // SelectResults by reference as a parameter.
@@ -59,7 +59,7 @@ class CPPCACHE_EXPORT RemoteQuery : public Query {
 
   //@TODO check the return type, is it ok. second option could be to pass
   // SelectResults by reference as a parameter.
-  SelectResultsPtr execute(CacheableVectorPtr paramList = NULLPTR,
+  SelectResultsPtr execute(CacheableVectorPtr paramList = nullptr,
                            uint32_t timeout = DEFAULT_QUERY_RESPONSE_TIMEOUT);
 
   // executes a query using a given distribution manager

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/cppcache/src/RemoteQueryService.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/RemoteQueryService.cpp 
b/src/cppcache/src/RemoteQueryService.cpp
index 791f13d..9240243 100644
--- a/src/cppcache/src/RemoteQueryService.cpp
+++ b/src/cppcache/src/RemoteQueryService.cpp
@@ -26,7 +26,7 @@ using namespace apache::geode::client;
 
 RemoteQueryService::RemoteQueryService(CacheImpl* cptr,
                                        ThinClientPoolDM* poolDM)
-    : m_invalid(true), m_cqService(NULLPTR) {
+    : m_invalid(true), m_cqService(nullptr) {
   if (poolDM) {
     m_tccdm = poolDM;
   } else {
@@ -62,8 +62,7 @@ QueryPtr RemoteQueryService::newQuery(const char* 
querystring) {
           "QueryService::newQuery: Cache has been closed.");
     }
     LOGDEBUG("RemoteQueryService: creating a new query: %s", querystring);
-    return QueryPtr(
-        new RemoteQuery(querystring, RemoteQueryServicePtr(this), m_tccdm));
+    return QueryPtr(new RemoteQuery(querystring, shared_from_this(), m_tccdm));
   } else {
     UserAttributesPtr ua =
         
TSSUserAttributesWrapper::s_geodeTSSUserAttributes->getUserAttributes();
@@ -74,18 +73,18 @@ QueryPtr RemoteQueryService::newQuery(const char* 
querystring) {
           "QueryService::newQuery: Cache has been closed.");
     }
     LOGDEBUG("RemoteQueryService: creating a new query: %s", querystring);
-    return QueryPtr(new RemoteQuery(querystring, RemoteQueryServicePtr(this),
-                                    m_tccdm, ua->getProxyCache()));
+    return QueryPtr(new RemoteQuery(querystring, shared_from_this(), m_tccdm,
+                                    ua->getProxyCache()));
   }
 }
 
 void RemoteQueryService::close() {
   LOGFINEST("RemoteQueryService::close: starting close");
   TryWriteGuard guard(m_rwLock, m_invalid);
-  if (m_cqService != NULLPTR) {
+  if (m_cqService != nullptr) {
     LOGFINEST("RemoteQueryService::close: starting CQ service close");
     m_cqService->closeCqService();
-    m_cqService = NULLPTR;
+    m_cqService = nullptr;
     LOGFINEST("RemoteQueryService::close: completed CQ service close");
   }
   if (dynamic_cast<ThinClientCacheDistributionManager*>(m_tccdm)) {
@@ -113,7 +112,7 @@ GfErrType RemoteQueryService::executeAllCqs(TcrEndpoint* 
endpoint) {
     return GF_NOERR;
   }
 
-  if (m_cqService == NULLPTR) {
+  if (m_cqService == nullptr) {
     LOGFINE(
         "RemoteQueryService: no cq to execute after failover to endpoint[%s]",
         endpoint->name().c_str());
@@ -134,7 +133,7 @@ void RemoteQueryService::executeAllCqs(bool failover) {
     return;
   }
   /*if cq has not been started, then failover will not start it.*/
-  if (m_cqService != NULLPTR) {
+  if (m_cqService != nullptr) {
     LOGFINE("RemoteQueryService: execute all cqs after failover");
     m_cqService->executeAllClientCqs(failover);
   } else {
@@ -178,19 +177,19 @@ void RemoteQueryService::closeCqs() {
     return;
   }
   // If cqService has not started, then no cq exists
-  if (m_cqService != NULLPTR) {
+  if (m_cqService != nullptr) {
     m_cqService->closeAllCqs();
   }
 }
 
-void RemoteQueryService::getCqs(VectorOfCqQuery& vec) {
+void RemoteQueryService::getCqs(CqService::query_container_type& vec) {
   TryReadGuard guard(m_rwLock, m_invalid);
 
   if (m_invalid) {
     throw CacheClosedException("QueryService::getCqs: Cache has been closed.");
   }
   // If cqService has not started, then no cq exists
-  if (m_cqService != NULLPTR) {
+  if (m_cqService != nullptr) {
     m_cqService->getAllCqs(vec);
   }
 }
@@ -202,11 +201,11 @@ CqQueryPtr RemoteQueryService::getCq(const char* name) {
     throw CacheClosedException("QueryService::getCq: Cache has been closed.");
   }
   // If cqService has not started, then no cq exists
-  if (m_cqService != NULLPTR) {
+  if (m_cqService != nullptr) {
     std::string nm(name);
     return m_cqService->getCq(nm);
   }
-  return NULLPTR;
+  return nullptr;
 }
 
 void RemoteQueryService::executeCqs() {
@@ -217,7 +216,7 @@ void RemoteQueryService::executeCqs() {
         "QueryService::executeCqs: Cache has been closed.");
   }
   // If cqService has not started, then no cq exists
-  if (m_cqService != NULLPTR) {
+  if (m_cqService != nullptr) {
     m_cqService->executeAllClientCqs();
   }
 }
@@ -230,7 +229,7 @@ void RemoteQueryService::stopCqs() {
     return;
   }
   // If cqService has not started, then no cq exists
-  if (m_cqService != NULLPTR) {
+  if (m_cqService != nullptr) {
     m_cqService->stopAllClientCqs();
   }
 }
@@ -243,11 +242,10 @@ CqServiceStatisticsPtr 
RemoteQueryService::getCqServiceStatistics() {
         "QueryService::getCqServiceStatistics: Cache has been closed.");
   }
   // If cqService has not started, then no cq exists
-  if (m_cqService != NULLPTR) {
+  if (m_cqService != nullptr) {
     return m_cqService->getCqServiceStatistics();
   }
-  CqServiceStatisticsPtr ptr(new CqServiceVsdStats());
-  return ptr;
+  return std::make_shared<CqServiceVsdStats>();
 }
 
 void RemoteQueryService::receiveNotification(TcrMessage* msg) {
@@ -258,7 +256,7 @@ void RemoteQueryService::receiveNotification(TcrMessage* 
msg) {
       return;
     }
     /*if cq has not been started, then  no cq exists */
-    if (m_cqService == NULLPTR) {
+    if (m_cqService == nullptr) {
       return;
     }
     if (!m_cqService->checkAndAcquireLock()) {
@@ -276,16 +274,16 @@ CacheableArrayListPtr 
RemoteQueryService::getAllDurableCqsFromServer() {
         "QueryService::getAllDurableCqsFromServer: Cache has been closed.");
   }
   // If cqService has not started, then no cq exists
-  if (m_cqService != NULLPTR) {
+  if (m_cqService != nullptr) {
     return m_cqService->getAllDurableCqsFromServer();
   } else {
-    return NULLPTR;
+    return nullptr;
   }
 }
 
 void RemoteQueryService::invokeCqConnectedListeners(ThinClientPoolDM* pool,
                                                     bool connected) {
-  if (m_cqService == NULLPTR) {
+  if (m_cqService == nullptr) {
     return;
   }
   std::string poolName;

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/cppcache/src/RemoteQueryService.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/RemoteQueryService.hpp 
b/src/cppcache/src/RemoteQueryService.hpp
index 3c14c5b..c5bf8fb 100644
--- a/src/cppcache/src/RemoteQueryService.hpp
+++ b/src/cppcache/src/RemoteQueryService.hpp
@@ -35,9 +35,11 @@ namespace client {
 class CacheImpl;
 class ThinClientPoolDM;
 typedef std::map<std::string, bool> CqPoolsConnected;
-class CPPCACHE_EXPORT RemoteQueryService : public QueryService {
+class CPPCACHE_EXPORT RemoteQueryService
+    : public QueryService,
+      public std::enable_shared_from_this<RemoteQueryService> {
  public:
-  RemoteQueryService(CacheImpl* cptr, ThinClientPoolDM* poolDM = NULL);
+  RemoteQueryService(CacheImpl* cptr, ThinClientPoolDM* poolDM = nullptr);
 
   void init();
 
@@ -54,7 +56,7 @@ class CPPCACHE_EXPORT RemoteQueryService : public 
QueryService {
   virtual CqQueryPtr newCq(const char* name, const char* querystr,
                            CqAttributesPtr& cqAttr, bool isDurable = false);
   virtual void closeCqs();
-  virtual void getCqs(VectorOfCqQuery& vec);
+  virtual void getCqs(QueryService::query_container_type& vec);
   virtual CqQueryPtr getCq(const char* name);
   virtual void executeCqs();
   virtual void stopCqs();
@@ -69,9 +71,9 @@ class CPPCACHE_EXPORT RemoteQueryService : public 
QueryService {
   void invokeCqConnectedListeners(ThinClientPoolDM* pool, bool connected);
   // For Lazy Cq Start-no use, no start
   inline void initCqService() {
-    if (m_cqService == NULLPTR) {
+    if (m_cqService == nullptr) {
       LOGFINE("RemoteQueryService: starting cq service");
-      m_cqService = new CqService(m_tccdm);
+      m_cqService = std::make_shared<CqService>(m_tccdm);
       LOGFINE("RemoteQueryService: started cq service");
     }
   }

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/cppcache/src/ResultSetImpl.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/ResultSetImpl.cpp 
b/src/cppcache/src/ResultSetImpl.cpp
index 63610bf..2e8df44 100644
--- a/src/cppcache/src/ResultSetImpl.cpp
+++ b/src/cppcache/src/ResultSetImpl.cpp
@@ -42,7 +42,7 @@ const SerializablePtr ResultSetImpl::operator[](int32_t 
index) const {
 }
 
 SelectResultsIterator ResultSetImpl::getIterator() {
-  return SelectResultsIterator(m_resultSetVector, SelectResultsPtr(this));
+  return SelectResultsIterator(m_resultSetVector, shared_from_this());
 }
 
 SelectResults::Iterator ResultSetImpl::begin() const {

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/cppcache/src/ResultSetImpl.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/ResultSetImpl.hpp 
b/src/cppcache/src/ResultSetImpl.hpp
index ff3891d..5eba661 100644
--- a/src/cppcache/src/ResultSetImpl.hpp
+++ b/src/cppcache/src/ResultSetImpl.hpp
@@ -36,7 +36,9 @@ namespace apache {
 namespace geode {
 namespace client {
 
-class CPPCACHE_EXPORT ResultSetImpl : public ResultSet {
+class CPPCACHE_EXPORT ResultSetImpl
+    : public ResultSet,
+      public std::enable_shared_from_this<ResultSetImpl> {
  public:
   ResultSetImpl(const CacheableVectorPtr& response);
 

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/cppcache/src/SelectResultsIterator.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/SelectResultsIterator.cpp 
b/src/cppcache/src/SelectResultsIterator.cpp
index 69a0a46..12c9cce 100644
--- a/src/cppcache/src/SelectResultsIterator.cpp
+++ b/src/cppcache/src/SelectResultsIterator.cpp
@@ -34,7 +34,7 @@ bool SelectResultsIterator::hasNext() const {
 }
 
 const SerializablePtr SelectResultsIterator::next() {
-  if (!hasNext()) return NULLPTR;
+  if (!hasNext()) return nullptr;
 
   return m_vectorSR->operator[](m_nextIndex++);
 }
@@ -49,7 +49,7 @@ bool SelectResultsIterator::moveNext() {
 }
 
 const SerializablePtr SelectResultsIterator::current() const {
-  if (m_nextIndex == 0 || m_nextIndex > m_vectorSR->size()) return NULLPTR;
+  if (m_nextIndex == 0 || m_nextIndex > m_vectorSR->size()) return nullptr;
 
   return m_vectorSR->operator[](m_nextIndex - 1);
 }

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/cppcache/src/SerializationRegistry.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/SerializationRegistry.cpp 
b/src/cppcache/src/SerializationRegistry.cpp
index e7f7c27..b9ff536 100644
--- a/src/cppcache/src/SerializationRegistry.cpp
+++ b/src/cppcache/src/SerializationRegistry.cpp
@@ -339,7 +339,7 @@ TheTypeMap::TheTypeMap() {
 
 typedef ACE_Singleton<TheTypeMap, ACE_Thread_Mutex> theTypeMap;
 
-PdxSerializerPtr SerializationRegistry::m_pdxSerializer = NULLPTR;
+PdxSerializerPtr SerializationRegistry::m_pdxSerializer = nullptr;
 
 /** This starts at reading the typeid.. assumes the length has been read. */
 SerializablePtr SerializationRegistry::deserialize(DataInput& input,
@@ -353,7 +353,7 @@ SerializablePtr 
SerializationRegistry::deserialize(DataInput& input,
   LOGDEBUG("SerializationRegistry::deserialize typeid = %d currentTypeId= %d ",
            typeId, currentTypeId);
   if (compId == GeodeTypeIds::NullObj) {
-    return NULLPTR;
+    return nullptr;
   } else if (compId == GeodeTypeIds::CacheableNullString) {
     return SerializablePtr(CacheableString::createDeserializable());
   } else if (compId == GeodeTypeIdsImpl::CacheableUserData) {
@@ -414,7 +414,11 @@ SerializablePtr 
SerializationRegistry::deserialize(DataInput& input,
   }
   SerializablePtr obj(createType());
   // This assignment allows the fromData method to return a different object.
-  return SerializablePtr(obj->fromData(input));
+  auto tmp = obj->fromData(input);
+  if (obj.get() == tmp) {
+    return obj;
+  }
+  return tmp->shared_from_this();
 }
 
 void SerializationRegistry::addType(TypeFactoryMethod func) {
@@ -453,12 +457,12 @@ void SerializationRegistry::init() {
 }
 
 PdxSerializablePtr SerializationRegistry::getPdxType(char* className) {
-  TypeFactoryMethodPdx objectType = NULL;
+  TypeFactoryMethodPdx objectType = nullptr;
   theTypeMap::instance()->findPdxType(className, objectType);
   PdxSerializablePtr pdxObj;
-  if (objectType == NULL) {
+  if (nullptr == objectType) {
     try {
-      pdxObj = new PdxWrapper((const char*)className);
+      pdxObj = std::make_shared<PdxWrapper>((const char*)className);
     } catch (const Exception&) {
       LOGERROR(
           "Unregistered class %s during PDX deserialization: Did the "
@@ -468,7 +472,7 @@ PdxSerializablePtr SerializationRegistry::getPdxType(char* 
className) {
           "Unregistered class or serializer in PDX deserialization");
     }
   } else {
-    pdxObj = objectType();
+    pdxObj.reset(objectType());
   }
   return pdxObj;
 }
@@ -483,7 +487,7 @@ PdxSerializerPtr SerializationRegistry::getPdxSerializer() {
 
 int32_t SerializationRegistry::GetPDXIdForType(const char* poolName,
                                                SerializablePtr pdxType) {
-  PoolPtr pool = NULLPTR;
+  PoolPtr pool = nullptr;
 
   if (poolName == NULL) {
     const HashMapOfPools& pools = PoolManager::getAll();
@@ -499,16 +503,16 @@ int32_t SerializationRegistry::GetPDXIdForType(const 
char* poolName,
     pool = PoolManager::find(poolName);
   }
 
-  if (pool == NULLPTR) {
+  if (pool == nullptr) {
     throw IllegalStateException("Pool not found, Pdx operation failed");
   }
 
-  return static_cast<ThinClientPoolDM*>(pool.ptr())->GetPDXIdForType(pdxType);
+  return static_cast<ThinClientPoolDM*>(pool.get())->GetPDXIdForType(pdxType);
 }
 
 SerializablePtr SerializationRegistry::GetPDXTypeById(const char* poolName,
                                                       int32_t typeId) {
-  PoolPtr pool = NULLPTR;
+  PoolPtr pool = nullptr;
 
   if (poolName == NULL) {
     const HashMapOfPools& pools = PoolManager::getAll();
@@ -521,38 +525,37 @@ SerializablePtr 
SerializationRegistry::GetPDXTypeById(const char* poolName,
     pool = PoolManager::find(poolName);
   }
 
-  if (pool == NULLPTR) {
+  if (pool == nullptr) {
     throw IllegalStateException("Pool not found, Pdx operation failed");
   }
 
-  return static_cast<ThinClientPoolDM*>(pool.ptr())->GetPDXTypeById(typeId);
+  return static_cast<ThinClientPoolDM*>(pool.get())->GetPDXTypeById(typeId);
 }
 
 int32_t SerializationRegistry::GetEnumValue(SerializablePtr enumInfo) {
   PoolPtr pool = getPool();
-  if (pool == NULLPTR) {
+  if (pool == nullptr) {
     throw IllegalStateException("Pool not found, Pdx operation failed");
   }
 
-  return static_cast<ThinClientPoolDM*>(pool.ptr())->GetEnumValue(enumInfo);
+  return static_cast<ThinClientPoolDM*>(pool.get())->GetEnumValue(enumInfo);
 }
 SerializablePtr SerializationRegistry::GetEnum(int32_t val) {
   PoolPtr pool = getPool();
-  if (pool == NULLPTR) {
+  if (pool == nullptr) {
     throw IllegalStateException("Pool not found, Pdx operation failed");
   }
 
-  return static_cast<ThinClientPoolDM*>(pool.ptr())->GetEnum(val);
+  return static_cast<ThinClientPoolDM*>(pool.get())->GetEnum(val);
 }
 
 PoolPtr SerializationRegistry::getPool() {
-  PoolPtr pool = NULLPTR;
+  PoolPtr pool = nullptr;
   const HashMapOfPools& pools = PoolManager::getAll();
   if (pools.size() > 0) {
     for (HashMapOfPools::Iterator iter = pools.begin(); iter != pools.end();
          ++iter) {
-      PoolPtr currPool(iter.second());
-      pool = currPool;
+      pool = iter.second();
       break;
     }
   }

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/cppcache/src/SerializationRegistry.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/SerializationRegistry.hpp 
b/src/cppcache/src/SerializationRegistry.hpp
index 85783f7..211c35e 100644
--- a/src/cppcache/src/SerializationRegistry.hpp
+++ b/src/cppcache/src/SerializationRegistry.hpp
@@ -107,7 +107,7 @@ class CPPCACHE_EXPORT SerializationRegistry {
   }
 
   inline static void serialize(const SerializablePtr& obj, DataOutput& output) 
{
-    serialize(obj.ptr(), output);
+    serialize(obj.get(), output);
   }
 
   /**

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/cppcache/src/ServerLocation.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/ServerLocation.cpp 
b/src/cppcache/src/ServerLocation.cpp
index e35c9c6..fbb1c2e 100644
--- a/src/cppcache/src/ServerLocation.cpp
+++ b/src/cppcache/src/ServerLocation.cpp
@@ -22,7 +22,7 @@ namespace apache {
 namespace geode {
 namespace client {
 void ServerLocation::makeEpString() {
-  if (m_serverName != NULLPTR) {
+  if (m_serverName != nullptr) {
     char epstring[1024] = {0};
     ACE_OS::snprintf(epstring, 1024, "%s:%d", m_serverName->asChar(), m_port);
     m_epString = epstring;

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/cppcache/src/ServerLocation.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/ServerLocation.hpp 
b/src/cppcache/src/ServerLocation.hpp
index 417020a..aea711e 100644
--- a/src/cppcache/src/ServerLocation.hpp
+++ b/src/cppcache/src/ServerLocation.hpp
@@ -45,7 +45,7 @@ class CPPCACHE_EXPORT ServerLocation : public Serializable {
   }
   ServerLocation()
       : Serializable(),
-        m_serverName(NULLPTR),
+        m_serverName(nullptr),
         m_port(-1)  // Default constructor for deserialiozation.
   {}
 
@@ -62,7 +62,7 @@ class CPPCACHE_EXPORT ServerLocation : public Serializable {
   }
 
   std::string getServerName() const {
-    if (m_serverName != NULLPTR) {
+    if (m_serverName != nullptr) {
       return m_serverName->asChar();
     }
     return "";
@@ -70,7 +70,7 @@ class CPPCACHE_EXPORT ServerLocation : public Serializable {
   void setServername(CacheableStringPtr sn) { m_serverName = sn; }
   int getPort() const { return m_port; }
   void toData(DataOutput& output) const {
-    if (m_serverName != NULLPTR) {
+    if (m_serverName != nullptr) {
       // output.writeObject( m_serverName );
       output.writeNativeString(m_serverName->asChar());  // changed
     }
@@ -84,7 +84,7 @@ class CPPCACHE_EXPORT ServerLocation : public Serializable {
     return this;
   }
   uint32_t objectSize() const {
-    if (m_serverName != NULLPTR) {
+    if (m_serverName != nullptr) {
       return static_cast<uint32_t>(sizeof(int)) +
              (m_serverName->length()) * static_cast<uint32_t>(sizeof(char));
     }
@@ -132,7 +132,7 @@ class CPPCACHE_EXPORT ServerLocation : public Serializable {
     /*char server1[256];
     char server2[256];
     size_t len = 0;
-     if (m_serverName != NULLPTR && rhs.getServerName( ).c_str() != NULL) {
+     if (m_serverName != nullptr && rhs.getServerName( ).c_str() != NULL) {
       ACE_INET_Addr addr1( m_port, m_serverName->asChar() );
       len = strlen(addr1.get_host_addr());
       memcpy(server1, addr1.get_host_addr(), len);
@@ -149,7 +149,7 @@ class CPPCACHE_EXPORT ServerLocation : public Serializable {
   }
 
   inline bool isValid() const {
-    if (m_serverName == NULLPTR) return false;
+    if (m_serverName == nullptr) return false;
     return m_serverName->length() > 0 && m_port >= 0;
   }
 

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/cppcache/src/SharedBase.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/SharedBase.cpp b/src/cppcache/src/SharedBase.cpp
deleted file mode 100644
index 976942d..0000000
--- a/src/cppcache/src/SharedBase.cpp
+++ /dev/null
@@ -1,39 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <geode/SharedBase.hpp>
-#include <HostAsm.hpp>
-
-#include <typeinfo>
-
-namespace apache {
-namespace geode {
-namespace client {
-
-void SharedBase::preserveSB() const { HostAsm::atomicAdd(m_refCount, 1); }
-
-void SharedBase::releaseSB() const {
-  if (HostAsm::atomicAdd(m_refCount, -1) == 0) {
-    delete this;
-  }
-}
-
-// dummy instance to use for NULLPTR
-const NullSharedBase* const NullSharedBase::s_instancePtr = NULL;
-}  // namespace client
-}  // namespace geode
-}  // namespace apache

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/cppcache/src/Struct.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/Struct.cpp b/src/cppcache/src/Struct.cpp
index d046e22..314b5ee 100644
--- a/src/cppcache/src/Struct.cpp
+++ b/src/cppcache/src/Struct.cpp
@@ -112,7 +112,7 @@ const char* Struct::getFieldName(int32_t index) {
 
 const SerializablePtr Struct::operator[](int32_t index) const {
   if (index >= m_fieldValues.size()) {
-    return NULLPTR;
+    return nullptr;
   }
 
   return m_fieldValues[index];

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/cppcache/src/StructSetImpl.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/StructSetImpl.cpp 
b/src/cppcache/src/StructSetImpl.cpp
index 6c09a24..3c8ce0f 100644
--- a/src/cppcache/src/StructSetImpl.cpp
+++ b/src/cppcache/src/StructSetImpl.cpp
@@ -47,7 +47,7 @@ StructSetImpl::StructSetImpl(
     for (size_t i = 0; i < numOfFields; i++) {
       tmpVec.push_back(response->operator[](valStoredCnt++));
     }
-    StructPtr siPtr(new Struct(this, tmpVec));
+    auto siPtr = std::make_shared<Struct>(this, tmpVec);
     m_structVector->push_back(siPtr);
   }
 }
@@ -65,7 +65,7 @@ const SerializablePtr StructSetImpl::operator[](int32_t 
index) const {
 }
 
 SelectResultsIterator StructSetImpl::getIterator() {
-  return SelectResultsIterator(m_structVector, SelectResultsPtr(this));
+  return SelectResultsIterator(m_structVector, shared_from_this());
 }
 
 int32_t StructSetImpl::getFieldIndex(const char* fieldname) {

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/cppcache/src/StructSetImpl.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/StructSetImpl.hpp 
b/src/cppcache/src/StructSetImpl.hpp
index 5c7eb0c..28f5368 100644
--- a/src/cppcache/src/StructSetImpl.hpp
+++ b/src/cppcache/src/StructSetImpl.hpp
@@ -40,7 +40,9 @@ namespace apache {
 namespace geode {
 namespace client {
 
-class CPPCACHE_EXPORT StructSetImpl : public StructSet {
+class CPPCACHE_EXPORT StructSetImpl
+    : public StructSet,
+      public std::enable_shared_from_this<StructSetImpl> {
  public:
   StructSetImpl(const CacheableVectorPtr& values,
                 const std::vector<CacheableStringPtr>& fieldNames);

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/cppcache/src/SystemProperties.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/SystemProperties.cpp 
b/src/cppcache/src/SystemProperties.cpp
index a1b2185..e17c1e5 100644
--- a/src/cppcache/src/SystemProperties.cpp
+++ b/src/cppcache/src/SystemProperties.cpp
@@ -202,11 +202,11 @@ SystemProperties::SystemProperties(const PropertiesPtr& 
propertiesPtr,
       m_redundancyMonitorInterval(DefaultRedundancyMonitorInterval),
       m_notifyAckInterval(DefaultNotifyAckInterval),
       m_notifyDupCheckLife(DefaultNotifyDupCheckLife),
-      m_AuthIniLoaderLibrary(NULLPTR),
-      m_AuthIniLoaderFactory(NULLPTR),
-      m_securityClientDhAlgo(NULLPTR),
-      m_securityClientKsPath(NULLPTR),
-      m_authInitializer(NULLPTR),
+      m_AuthIniLoaderLibrary(nullptr),
+      m_AuthIniLoaderFactory(nullptr),
+      m_securityClientDhAlgo(nullptr),
+      m_securityClientKsPath(nullptr),
+      m_authInitializer(nullptr),
       m_durableClientId(NULL),
       m_durableTimeout(DefaultDurableTimeout),
       m_connectTimeout(DefaultConnectTimeout),
@@ -252,7 +252,7 @@ SystemProperties::SystemProperties(const PropertiesPtr& 
propertiesPtr,
     void visit(CacheableKeyPtr& key, CacheablePtr& value) {
       CacheableStringPtr prop = key->toString();
       CacheableStringPtr val;
-      if (value != NULLPTR) {
+      if (value != nullptr) {
         val = value->toString();
       }
       m_sysProps->processProperty(prop->asChar(), val->asChar());
@@ -283,7 +283,7 @@ SystemProperties::SystemProperties(const PropertiesPtr& 
propertiesPtr,
   givenConfigPtr->foreach (processPropsVisitor);
 
   // Now consume any properties provided by the Properties object in code.
-  if (propertiesPtr != NULLPTR) {
+  if (propertiesPtr != nullptr) {
     propertiesPtr->foreach (processPropsVisitor);
   }
 
@@ -925,25 +925,25 @@ void SystemProperties::logSettings() {
 }
 
 AuthInitializePtr SystemProperties::getAuthLoader() {
-  if ((m_authInitializer == NULLPTR) && (m_AuthIniLoaderLibrary != NULLPTR &&
-                                         m_AuthIniLoaderFactory != NULLPTR)) {
+  if ((m_authInitializer == nullptr) && (m_AuthIniLoaderLibrary != nullptr &&
+                                         m_AuthIniLoaderFactory != nullptr)) {
     if (managedAuthInitializeFn != NULL &&
         strchr(m_AuthIniLoaderFactory->asChar(), '.') != NULL) {
       // this is a managed library
-      m_authInitializer = (*managedAuthInitializeFn)(
-          m_AuthIniLoaderLibrary->asChar(), m_AuthIniLoaderFactory->asChar());
+      m_authInitializer.reset((*managedAuthInitializeFn)(
+          m_AuthIniLoaderLibrary->asChar(), m_AuthIniLoaderFactory->asChar()));
     } else {
       AuthInitialize* (*funcptr)();
       funcptr = reinterpret_cast<AuthInitialize* (*)()>(getFactoryFunc(
           m_AuthIniLoaderLibrary->asChar(), m_AuthIniLoaderFactory->asChar()));
       if (funcptr == NULL) {
         LOGERROR("Failed to acquire handle to AuthInitialize library");
-        return NULLPTR;
+        return nullptr;
       }
       AuthInitialize* p = funcptr();
-      m_authInitializer = p;
+      m_authInitializer.reset(p);
     }
-  } else if (m_authInitializer == NULLPTR) {
+  } else if (m_authInitializer == nullptr) {
     LOGFINE("No AuthInitialize library or factory configured");
   }
   return m_authInitializer;

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/cppcache/src/TXCleaner.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/TXCleaner.cpp b/src/cppcache/src/TXCleaner.cpp
index 3c9a0fc..7073e90 100644
--- a/src/cppcache/src/TXCleaner.cpp
+++ b/src/cppcache/src/TXCleaner.cpp
@@ -42,7 +42,7 @@ TXCleaner::~TXCleaner() {
   }
 }
 void TXCleaner::clean() {
-  if (m_txState != NULL && m_txState->getTransactionId().ptr() != NULL) {
+  if (m_txState != NULL && m_txState->getTransactionId().get() != NULL) {
     m_cacheTxMgr->removeTx(m_txState->getTransactionId()->getId());
   }
   if (m_txStateWrapper != NULL && m_txState != NULL) {

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/cppcache/src/TXCommitMessage.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/TXCommitMessage.cpp 
b/src/cppcache/src/TXCommitMessage.cpp
index 03f92e7..ba7e15b 100644
--- a/src/cppcache/src/TXCommitMessage.cpp
+++ b/src/cppcache/src/TXCommitMessage.cpp
@@ -88,7 +88,7 @@ m_processorId = -1;
   int32_t regionSize;
   input.readInt(&regionSize);
   for (int32_t i = 0; i < regionSize; i++) {
-    RegionCommitPtr rc(new RegionCommit(/*this*/));
+    auto rc = std::make_shared<RegionCommit>();
     rc->fromData(input);
     m_regions.push_back(rc);
   }
@@ -164,7 +164,7 @@ Serializable* TXCommitMessage::create() { return new 
TXCommitMessage(); }
 void TXCommitMessage::apply(Cache* cache) {
   for (VectorOfSharedBase::Iterator iter = m_regions.begin();
        m_regions.end() != iter; iter++) {
-    RegionCommitPtr regionCommit = staticCast<RegionCommitPtr>(*iter);
+    RegionCommitPtr regionCommit = 
std::static_pointer_cast<GF_UNWRAP_SP(RegionCommitPtr)>(*iter);
     regionCommit->apply(cache);
   }
 }
@@ -177,7 +177,7 @@ VectorOfEntryEvent TXCommitMessage::getEvents(Cache* cache)
 m_regions.end() != iter; iter++)
         {
                 RegionCommitPtr regionCommit =
-staticCast<RegionCommitPtr>(*iter);
+std::static_pointer_cast<GF_UNWRAP_SP(RegionCommitPtr)>(*iter);
                 regionCommit->fillEvents(cache, ops);
         }
 

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/cppcache/src/TXState.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/TXState.cpp b/src/cppcache/src/TXState.cpp
index 2249b7b..89f327a 100644
--- a/src/cppcache/src/TXState.cpp
+++ b/src/cppcache/src/TXState.cpp
@@ -60,7 +60,7 @@ CacheablePtr TXState::replay(bool isRollback) {
   GfErrTypeThrowException("Replay is unsupported", GF_NOTSUP);
   int retryAttempts = 3;
 
-  CacheablePtr result = NULLPTR;
+  CacheablePtr result = nullptr;
 
   ReplayControl replayControl(this);
   m_dirty = false;
@@ -84,7 +84,7 @@ CacheablePtr TXState::replay(bool isRollback) {
       for (VectorOfSharedBase::Iterator iter = m_operations.begin();
            m_operations.end() != iter; iter++) {
         TransactionalOperationPtr operation =
-            staticCast<TransactionalOperationPtr>(*iter);
+            
std::static_pointer_cast<GF_UNWRAP_SP(TransactionalOperationPtr)>(*iter);
         result = operation->replay(m_cache);
       }
 
@@ -103,7 +103,7 @@ CacheablePtr TXState::replay(bool isRollback) {
   GfErrTypeThrowException(
       "Unable to reestablish transaction context on servers", GF_EUNDEF);
 
-  return NULLPTR;
+  return nullptr;
 }
 
 void TXState::releaseStickyConnection() {

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/cppcache/src/TcrChunkedContext.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/TcrChunkedContext.hpp 
b/src/cppcache/src/TcrChunkedContext.hpp
index 3f3d760..c1c12a3 100644
--- a/src/cppcache/src/TcrChunkedContext.hpp
+++ b/src/cppcache/src/TcrChunkedContext.hpp
@@ -58,7 +58,7 @@ class TcrChunkedResult : public SharedBase {
  public:
   inline TcrChunkedResult()
       : m_finalizeSema(NULL),
-        m_ex(NULLPTR),
+        m_ex(nullptr),
         m_inSameThread(false),
         appDomainContext(createAppDomainContext()),
         m_dsmemId(0) {}
@@ -117,9 +117,9 @@ class TcrChunkedResult : public SharedBase {
 
   // getters/setters for the exception, if any, during chunk processing
 
-  inline bool exceptionOccurred() const { return (m_ex != NULLPTR); }
+  inline bool exceptionOccurred() const { return (m_ex != nullptr); }
 
-  inline void setException(Exception& ex) { m_ex = ex.clone(); }
+  inline void setException(Exception& ex) { m_ex.reset(ex.clone()); }
 
   inline ExceptionPtr& getException() { return m_ex; }
 };

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/cppcache/src/TcrConnection.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/TcrConnection.cpp 
b/src/cppcache/src/TcrConnection.cpp
index 874ba42..865203e 100644
--- a/src/cppcache/src/TcrConnection.cpp
+++ b/src/cppcache/src/TcrConnection.cpp
@@ -198,7 +198,7 @@ bool TcrConnection::InitTcrConnection(
     LOGDEBUG("TcrConnection this->m_endpointObj->isMultiUserMode() = %d ",
              this->m_endpointObj->isMultiUserMode());
     if (this->m_endpointObj->isMultiUserMode()) {
-      if (dhalgo != NULLPTR && dhalgo->length() > 0) isDhOn = true;
+      if (dhalgo != nullptr && dhalgo->length() > 0) isDhOn = true;
     }
   }
 
@@ -233,7 +233,7 @@ bool TcrConnection::InitTcrConnection(
       LOGFINER("TcrConnection: about to invoke authloader");
       PropertiesPtr tmpSecurityProperties =
           tmpSystemProperties->getSecurityProperties();
-      if (tmpSecurityProperties == NULLPTR) {
+      if (tmpSecurityProperties == nullptr) {
         LOGWARN("TcrConnection: security properties not found.");
       }
       // AuthInitializePtr authInitialize =
@@ -242,7 +242,7 @@ bool TcrConnection::InitTcrConnection(
       if (isClientNotification) {
         AuthInitializePtr authInitialize =
             DistributedSystem::m_impl->getAuthLoader();
-        if (authInitialize != NULLPTR) {
+        if (authInitialize != nullptr) {
           LOGFINER(
               "TcrConnection: acquired handle to authLoader, "
               "invoking getCredentials");
@@ -266,7 +266,7 @@ bool TcrConnection::InitTcrConnection(
       if (isDhOn) {
         CacheableStringPtr ksPath =
             tmpSecurityProperties->find("security-client-kspath");
-        requireServerAuth = (ksPath != NULLPTR && ksPath->length() > 0);
+        requireServerAuth = (ksPath != nullptr && ksPath->length() > 0);
         handShakeMsg.writeBoolean(requireServerAuth);
         LOGFINE(
             "HandShake: Server authentication using RSA signature %s required",
@@ -323,9 +323,9 @@ bool TcrConnection::InitTcrConnection(
   if (error == CONN_NOERR) {
     CacheableBytesPtr acceptanceCode = readHandshakeData(1, connectTimeout);
 
-    LOGDEBUG(" Handshake: Got Accept Code %d", acceptanceCode[0]);
+    LOGDEBUG(" Handshake: Got Accept Code %d", (*acceptanceCode)[0]);
     /* adongre */
-    if (acceptanceCode[0] == REPLY_SSL_ENABLED &&
+    if ((*acceptanceCode)[0] == REPLY_SSL_ENABLED &&
         !tmpSystemProperties->sslEnabled()) {
       LOGERROR("SSL is enabled on server, enable SSL in client as well");
       AuthenticationRequiredException ex(
@@ -335,7 +335,7 @@ bool TcrConnection::InitTcrConnection(
     }
 
     // if diffie-hellman based credential encryption is enabled
-    if (isDhOn && acceptanceCode[0] == REPLY_OK) {
+    if (isDhOn && (*acceptanceCode)[0] == REPLY_OK) {
       // read the server's DH public key
       CacheableBytesPtr pubKeyBytes = readHandshakeByteArray(connectTimeout);
       LOGDEBUG(" Handshake: Got pubKeySize %d", pubKeyBytes->length());
@@ -387,7 +387,7 @@ bool TcrConnection::InitTcrConnection(
 
       if (error == CONN_NOERR) {
         acceptanceCode = readHandshakeData(1, connectTimeout);
-        LOGDEBUG("Handshake: Got acceptanceCode Finally %d", 
acceptanceCode[0]);
+        LOGDEBUG("Handshake: Got acceptanceCode Finally %d", 
(*acceptanceCode)[0]);
       } else {
         int32_t lastError = ACE_OS::last_error();
         LOGERROR("Handshake failed, errno: %d, server may not be running",
@@ -409,9 +409,9 @@ bool TcrConnection::InitTcrConnection(
 
     //  TESTING: Durable clients - set server queue status.
     // 0 - Non-Redundant , 1- Redundant , 2- Primary
-    if (serverQueueStatus[0] == 1) {
+    if ((*serverQueueStatus)[0] == 1) {
       m_hasServerQueue = REDUNDANT_SERVER;
-    } else if (serverQueueStatus[0] == 2) {
+    } else if ((*serverQueueStatus)[0] == 2) {
       m_hasServerQueue = PRIMARY_SERVER;
     } else {
       m_hasServerQueue = NON_REDUNDANT_SERVER;
@@ -443,16 +443,16 @@ bool TcrConnection::InitTcrConnection(
     if (!isClientNotification) {
       // Read and ignore the DistributedMember object
       CacheableBytesPtr arrayLenHeader = readHandshakeData(1, connectTimeout);
-      int32_t recvMsgLen = static_cast<int32_t>(arrayLenHeader[0]);
+      int32_t recvMsgLen = static_cast<int32_t>((*arrayLenHeader)[0]);
       // now check for array length headers - since GFE 5.7
-      if (static_cast<int8_t>(arrayLenHeader[0]) == -2) {
+      if (static_cast<int8_t>((*arrayLenHeader)[0]) == -2) {
         CacheableBytesPtr recvMsgLenBytes =
             readHandshakeData(2, connectTimeout);
         DataInput dI2(recvMsgLenBytes->value(), recvMsgLenBytes->length());
         int16_t recvMsgLenShort = 0;
         dI2.readInt(&recvMsgLenShort);
         recvMsgLen = recvMsgLenShort;
-      } else if (static_cast<int8_t>(arrayLenHeader[0]) == -3) {
+      } else if (static_cast<int8_t>((*arrayLenHeader)[0]) == -3) {
         CacheableBytesPtr recvMsgLenBytes =
             readHandshakeData(4, connectTimeout);
         DataInput dI2(recvMsgLenBytes->value(), recvMsgLenBytes->length());
@@ -488,11 +488,11 @@ bool TcrConnection::InitTcrConnection(
       ThinClientBaseDM::setDeltaEnabledOnServer(isDeltaEnabledOnServer);
     }
 
-    switch (acceptanceCode[0]) {
+    switch ((*acceptanceCode)[0]) {
       case REPLY_OK:
       case SUCCESSFUL_SERVER_TO_CLIENT:
-        LOGFINER("Handshake reply: %u,%u,%u", acceptanceCode[0],
-                 serverQueueStatus[0], recvMsgLen2);
+        LOGFINER("Handshake reply: %u,%u,%u", (*acceptanceCode)[0],
+                 (*serverQueueStatus)[0], recvMsgLen2);
         if (isClientNotification) readHandshakeInstantiatorMsg(connectTimeout);
         break;
       case REPLY_AUTHENTICATION_FAILED: {
@@ -532,7 +532,7 @@ bool TcrConnection::InitTcrConnection(
         LOGERROR(
             "Unknown error[%d] received from server [%s] in handshake: "
             "%s",
-            acceptanceCode[0], m_endpointObj->name().c_str(),
+            (*acceptanceCode)[0], m_endpointObj->name().c_str(),
             recvMessage->value());
         MessageException ex(
             "TcrConnection::TcrConnection: Unknown error"
@@ -1231,7 +1231,7 @@ CacheableBytesPtr 
TcrConnection::readHandshakeData(int32_t msgLength,
     return 
CacheableBytes::createNoCopy(reinterpret_cast<uint8_t*>(recvMessage),
                                         msgLength + 1);
   }
-  return NULLPTR;
+  return nullptr;
 }
 
 // read just the bytes without the trailing null terminator
@@ -1247,7 +1247,7 @@ CacheableBytesPtr 
TcrConnection::readHandshakeRawData(int32_t msgLength,
     msgLength = 0;
   }
   if (msgLength == 0) {
-    return NULLPTR;
+    return nullptr;
   }
   char* recvMessage;
   GF_NEW(recvMessage, char[msgLength]);
@@ -1267,7 +1267,7 @@ CacheableBytesPtr 
TcrConnection::readHandshakeRawData(int32_t msgLength,
                            "Handshake failure"));
     }
     // not expected to be reached
-    return NULLPTR;
+    return nullptr;
   } else {
     return 
CacheableBytes::createNoCopy(reinterpret_cast<uint8_t*>(recvMessage),
                                         msgLength);
@@ -1424,7 +1424,7 @@ CacheableStringPtr 
TcrConnection::readHandshakeString(uint32_t connectTimeout) {
   uint32_t length = 0;
   switch (static_cast<int8_t>(cstypeid)) {
     case GeodeTypeIds::CacheableNullString: {
-      return NULLPTR;
+      return nullptr;
       break;
     }
     case GF_STRING: {
@@ -1446,7 +1446,7 @@ CacheableStringPtr 
TcrConnection::readHandshakeString(uint32_t connectTimeout) {
   LOGDEBUG(" Received string len %d", length);
 
   if (length == 0) {
-    return NULLPTR;
+    return nullptr;
   }
 
   char* recvMessage;
@@ -1471,7 +1471,7 @@ CacheableStringPtr 
TcrConnection::readHandshakeString(uint32_t connectTimeout) {
                            "Handshake failure reading string bytes"));
     }
     // not expected to be reached
-    return NULLPTR;
+    return nullptr;
   } else {
     LOGDEBUG(" Received string data [%s]", recvMessage);
     CacheableStringPtr retval =

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/cppcache/src/TcrConnectionManager.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/TcrConnectionManager.cpp 
b/src/cppcache/src/TcrConnectionManager.cpp
index 67d7d01..f46e2d0 100644
--- a/src/cppcache/src/TcrConnectionManager.cpp
+++ b/src/cppcache/src/TcrConnectionManager.cpp
@@ -84,7 +84,7 @@ void TcrConnectionManager::init(bool isPool) {
   const char *endpoints;
   m_redundancyManager->m_HAenabled = false;
 
-  if (cacheAttributes != NULLPTR &&
+  if (cacheAttributes != nullptr &&
       (cacheAttributes->getRedundancyLevel() > 0 || m_isDurable) &&
       (endpoints = cacheAttributes->getEndpoints()) != NULL &&
       strcmp(endpoints, "none") != 0) {
@@ -158,7 +158,7 @@ void TcrConnectionManager::close() {
   }
 
   CacheAttributesPtr cacheAttributes = m_cache->getAttributes();
-  if (cacheAttributes != NULLPTR &&
+  if (cacheAttributes != nullptr &&
       (cacheAttributes->getRedundancyLevel() > 0 || m_isDurable)) {
     if (m_servermonitorTaskId > 0) {
       CacheImpl::expiryTaskManager->cancelTask(m_servermonitorTaskId);

Reply via email to