geode-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From jbarr...@apache.org
Subject [09/46] geode-native git commit: GEODE-2741: Remove custom shared pointer from cppcache
Date Wed, 17 May 2017 17:49:51 GMT
http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/cppcache/src/LRUEntriesMap.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/LRUEntriesMap.cpp b/src/cppcache/src/LRUEntriesMap.cpp
index 4b30513..29a0aff 100644
--- a/src/cppcache/src/LRUEntriesMap.cpp
+++ b/src/cppcache/src/LRUEntriesMap.cpp
@@ -63,16 +63,14 @@ LRUEntriesMap::LRUEntriesMap(EntryFactory* entryFactory, RegionInternal* region,
                            concurrency),
       m_lruList(),
       m_limit(limit),
-      m_pmPtr(NULLPTR),
+      m_pmPtr(nullptr),
       m_validEntries(0),
       m_heapLRUEnabled(heapLRUEnabled) {
   m_currentMapSize = 0;
   m_action = NULL;
   m_evictionControllerPtr = NULL;
   // translate action type to an instance.
-  if (region == NULL) {
-    m_action = new TestMapAction(this);
-  } else {
+  if (region) {
     m_action = LRUAction::newLRUAction(lruAction, region, this);
     m_name = region->getName();
     CacheImpl* cImpl = region->getCacheImpl();
@@ -84,6 +82,8 @@ LRUEntriesMap::LRUEntriesMap(EntryFactory* entryFactory, RegionInternal* region,
                 m_name.c_str());
       }
     }
+  } else {
+    m_action = new TestMapAction(this);
   }
 }
 
@@ -131,7 +131,7 @@ GfErrType LRUEntriesMap::create(const CacheableKeyPtr& key,
     }
     CacheablePtr tmpValue;
     segmentRPtr->getEntry(key, mePtr, tmpValue);
-    if (mePtr == NULLPTR) {
+    if (mePtr == nullptr) {
       return err;
     }
     m_lruList.appendEntry(mePtr);
@@ -141,7 +141,7 @@ GfErrType LRUEntriesMap::create(const CacheableKeyPtr& key,
     int64_t newSize =
         static_cast<int64_t>(Utils::checkAndGetObjectSize(newValue));
     newSize += static_cast<int64_t>(Utils::checkAndGetObjectSize(key));
-    if (oldValue != NULLPTR) {
+    if (oldValue != nullptr) {
       newSize -= static_cast<int64_t>(oldValue->objectSize());
     } else {
       newSize -= static_cast<int64_t>(sizeof(void*));
@@ -165,7 +165,7 @@ GfErrType LRUEntriesMap::evictionHelper() {
   //  ACE_Guard< ACE_Recursive_Thread_Mutex > guard( m_mutex );
   MapEntryImplPtr lruEntryPtr;
   m_lruList.getLRUEntry(lruEntryPtr);
-  if (lruEntryPtr == NULLPTR) {
+  if (lruEntryPtr == nullptr) {
     err = GF_ENOENT;
     return err;
   }
@@ -225,7 +225,7 @@ GfErrType LRUEntriesMap::invalidate(const CacheableKeyPtr& key,
     // need to assess the effect of this; also assess the affect of above
     // mentioned race
     oldValue = m_pmPtr->read(key, persistenceInfo);
-    if (oldValue != NULLPTR) {
+    if (oldValue != nullptr) {
       m_pmPtr->destroy(key, persistenceInfo);
     }
   }
@@ -233,7 +233,7 @@ GfErrType LRUEntriesMap::invalidate(const CacheableKeyPtr& key,
     --m_validEntries;
     me->getLRUProperties().setEvicted();
     newSize = CacheableToken::invalid()->objectSize();
-    if (oldValue != NULLPTR) {
+    if (oldValue != nullptr) {
       newSize -= oldValue->objectSize();
     } else {
       newSize -= sizeof(void*);
@@ -292,7 +292,7 @@ GfErrType LRUEntriesMap::put(const CacheableKeyPtr& key,
       }
       void* persistenceInfo = me->getLRUProperties().getPersistenceInfo();
       oldValue = m_pmPtr->read(key, persistenceInfo);
-      if (oldValue != NULLPTR) {
+      if (oldValue != nullptr) {
         m_pmPtr->destroy(key, persistenceInfo);
       }
     }
@@ -315,7 +315,7 @@ GfErrType LRUEntriesMap::put(const CacheableKeyPtr& key,
       segmentRPtr->getEntry(key, mePtr, tmpValue);
       // mePtr cannot be null, we just put it...
       // must convert to an LRUMapEntryImplPtr...
-      GF_D_ASSERT(mePtr != NULLPTR);
+      GF_D_ASSERT(mePtr != nullptr);
       m_lruList.appendEntry(mePtr);
       me = mePtr;
     } else {
@@ -342,7 +342,7 @@ GfErrType LRUEntriesMap::put(const CacheableKeyPtr& key,
     if (isUpdate == false) {
       newSize += static_cast<int64_t>(Utils::checkAndGetObjectSize(key));
     } else {
-      if (oldValue != NULLPTR) {
+      if (oldValue != nullptr) {
         newSize -= static_cast<int64_t>(oldValue->objectSize());
       } else {
         newSize -= static_cast<int64_t>(sizeof(void*));
@@ -377,7 +377,7 @@ bool LRUEntriesMap::get(const CacheableKeyPtr& key, CacheablePtr& returnPtr,
     segmentLocked = true;
   }
   {
-    returnPtr = NULLPTR;
+    returnPtr = nullptr;
     MapEntryImplPtr mePtr;
     if (false == segmentRPtr->getEntry(key, mePtr, returnPtr)) {
       if (segmentLocked == true) segmentRPtr->release();
@@ -386,7 +386,7 @@ bool LRUEntriesMap::get(const CacheableKeyPtr& key, CacheablePtr& returnPtr,
     // segmentRPtr->get(key, returnPtr, mePtr);
     MapEntryImplPtr nodeToMark = mePtr;
     LRUEntryProperties& lruProps = nodeToMark->getLRUProperties();
-    if (returnPtr != NULLPTR && CacheableToken::isOverflowed(returnPtr)) {
+    if (returnPtr != nullptr && CacheableToken::isOverflowed(returnPtr)) {
       void* persistenceInfo = lruProps.getPersistenceInfo();
       CacheablePtr tmpObj;
       try {
@@ -396,8 +396,8 @@ bool LRUEntriesMap::get(const CacheableKeyPtr& key, CacheablePtr& returnPtr,
         if (segmentLocked == true) segmentRPtr->release();
         return false;
       }
-      (m_region->getRegionStats())->incRetrieves();
-      (m_region->getCacheImpl())->m_cacheStats->incRetrieves();
+      m_region->getRegionStats()->incRetrieves();
+      m_region->getCacheImpl()->m_cacheStats->incRetrieves();
 
       returnPtr = tmpObj;
 
@@ -415,7 +415,7 @@ bool LRUEntriesMap::get(const CacheableKeyPtr& key, CacheablePtr& returnPtr,
       doProcessLRU = true;
       if (m_evictionControllerPtr != NULL) {
         int64_t newSize = 0;
-        if (tmpObj != NULLPTR) {
+        if (tmpObj != nullptr) {
           newSize += static_cast<int64_t>(
               tmpObj->objectSize() - CacheableToken::invalid()->objectSize());
         } else {
@@ -453,7 +453,7 @@ GfErrType LRUEntriesMap::remove(const CacheableKeyPtr& key,
   if ((err = segmentRPtr->remove(key, result, me, updateCount, versionTag,
                                  afterRemote, isEntryFound)) == GF_NOERR) {
     // ACE_Guard<MapSegment> _guard(*segmentRPtr);
-    if (result != NULLPTR && me != NULLPTR) {
+    if (result != nullptr && me != nullptr) {
       LRUEntryProperties& lruProps = me->getLRUProperties();
       lruProps.setEvicted();
       if (isEntryFound) --m_size;
@@ -471,7 +471,7 @@ GfErrType LRUEntriesMap::remove(const CacheableKeyPtr& key,
         // need to assess the effect of this; also assess the affect of above
         // mentioned race
         result = m_pmPtr->read(key, persistenceInfo);
-        if (result != NULLPTR) {
+        if (result != nullptr) {
           m_pmPtr->destroy(key, persistenceInfo);
         }
       }
@@ -498,7 +498,7 @@ void LRUEntriesMap::updateMapSize(int64_t size) {
 }
 
 CacheablePtr LRUEntriesMap::getFromDisk(const CacheableKeyPtr& key,
-                                        MapEntryImpl* me) const {
+                                        MapEntryImplPtr& me) const {
   void* persistenceInfo = me->getLRUProperties().getPersistenceInfo();
   CacheablePtr tmpObj;
   try {
@@ -507,7 +507,7 @@ CacheablePtr LRUEntriesMap::getFromDisk(const CacheableKeyPtr& key,
     tmpObj = m_pmPtr->read(key, persistenceInfo);
   } catch (Exception& ex) {
     LOGERROR("read on the persistence layer failed - %s", ex.getMessage());
-    return NULLPTR;
+    return nullptr;
   }
   return tmpObj;
 }

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/cppcache/src/LRUEntriesMap.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/LRUEntriesMap.hpp b/src/cppcache/src/LRUEntriesMap.hpp
index 3efcbeb..a50658f 100644
--- a/src/cppcache/src/LRUEntriesMap.hpp
+++ b/src/cppcache/src/LRUEntriesMap.hpp
@@ -94,7 +94,7 @@ class CPPCACHE_EXPORT LRUEntriesMap : public ConcurrentEntriesMap,
   virtual bool get(const CacheableKeyPtr& key, CacheablePtr& returnPtr,
                    MapEntryImplPtr& me);
   virtual CacheablePtr getFromDisk(const CacheableKeyPtr& key,
-                                   MapEntryImpl* me) const;
+                                   MapEntryImplPtr& me) const;
   GfErrType processLRU();
   void processLRU(int32_t numEntriesToEvict);
   GfErrType evictionHelper();

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/cppcache/src/LRUList.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/LRUList.cpp b/src/cppcache/src/LRUList.cpp
index c752faa..c8d9fbd 100644
--- a/src/cppcache/src/LRUList.cpp
+++ b/src/cppcache/src/LRUList.cpp
@@ -24,7 +24,7 @@ using namespace apache::geode::client;
 
 template <typename TEntry, typename TCreateEntry>
 LRUList<TEntry, TCreateEntry>::LRUList() : m_headLock(), m_tailLock() {
-  LRUListEntryPtr headEntry(TCreateEntry::create(NULLPTR));
+  LRUListEntryPtr headEntry(TCreateEntry::create(nullptr));
   headEntry->getLRUProperties().setEvicted();  // create empty evicted entry.
   m_headNode = new LRUListNode(headEntry);
   m_tailNode = m_headNode;
@@ -68,7 +68,7 @@ void LRUList<TEntry, TCreateEntry>::getLRUEntry(LRUListEntryPtr& result) {
   while (true) {
     aNode = getHeadNode(isLast);
     if (aNode == NULL) {
-      result = NULLPTR;
+      result = nullptr;
       break;
     }
     aNode->getEntry(result);
@@ -88,7 +88,7 @@ void LRUList<TEntry, TCreateEntry>::getLRUEntry(LRUListEntryPtr& result) {
         break;  // found unused entry
       }
     } else {
-      result = NULLPTR;  // remove the reference to entry
+      result = nullptr;  // remove the reference to entry
       delete aNode;      // drop the entry to the floor ...
     }
   }

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/cppcache/src/LRULocalDestroyAction.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/LRULocalDestroyAction.cpp b/src/cppcache/src/LRULocalDestroyAction.cpp
index 633c5cc..e0cc06d 100644
--- a/src/cppcache/src/LRULocalDestroyAction.cpp
+++ b/src/cppcache/src/LRULocalDestroyAction.cpp
@@ -30,7 +30,7 @@ bool LRULocalDestroyAction::evict(const MapEntryImplPtr& mePtr) {
   LOGDEBUG("LRULocalDestroy: evicting entry with key [%s]",
            Utils::getCacheableKeyString(keyPtr)->asChar());
   GfErrType err = m_regionPtr->destroyNoThrow(
-      keyPtr, NULLPTR, -1, CacheEventFlags::EVICTION | CacheEventFlags::LOCAL,
+      keyPtr, nullptr, -1, CacheEventFlags::EVICTION | CacheEventFlags::LOCAL,
       versionTag);
   return (err == GF_NOERR);
 }

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/cppcache/src/LocalRegion.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/LocalRegion.cpp b/src/cppcache/src/LocalRegion.cpp
index 5e61580..6de7774 100644
--- a/src/cppcache/src/LocalRegion.cpp
+++ b/src/cppcache/src/LocalRegion.cpp
@@ -37,7 +37,7 @@
 using namespace apache::geode::client;
 
 LocalRegion::LocalRegion(const std::string& name, CacheImpl* cache,
-                         RegionInternal* rPtr,
+                         const RegionInternalPtr& rPtr,
                          const RegionAttributesPtr& attributes,
                          const CacheStatisticsPtr& stats, bool shared)
     : RegionInternal(attributes),
@@ -45,17 +45,17 @@ LocalRegion::LocalRegion(const std::string& name, CacheImpl* cache,
       m_parentRegion(rPtr),
       m_cacheImpl(cache),
       m_destroyPending(false),
-      m_listener(NULLPTR),
-      m_writer(NULLPTR),
-      m_loader(NULLPTR),
+      m_listener(nullptr),
+      m_writer(nullptr),
+      m_loader(nullptr),
       m_released(false),
       m_entries(NULL),
       m_cacheStatistics(stats),
       m_transactionEnabled(false),
       m_isPRSingleHopEnabled(false),
-      m_attachedPool(NULLPTR),
-      m_persistenceManager(NULLPTR) {
-  if (m_parentRegion != NULLPTR) {
+      m_attachedPool(nullptr),
+      m_persistenceManager(nullptr) {
+  if (m_parentRegion != nullptr) {
     ((m_fullPath = m_parentRegion->getFullPath()) += "/") += m_name;
   } else {
     (m_fullPath = "/") += m_name;
@@ -76,7 +76,7 @@ LocalRegion::LocalRegion(const std::string& name, CacheImpl* cache,
   cldptr = m_regionAttributes->getCacheLoader();
   m_loader = cldptr;
 
-  if (m_parentRegion != NULLPTR) {
+  if (m_parentRegion != nullptr) {
     ((m_fullPath = m_parentRegion->getFullPath()) += "/") += m_name;
   } else {
     (m_fullPath = "/") += m_name;
@@ -110,7 +110,7 @@ void LocalRegion::updateAccessAndModifiedTime(bool modified) {
       m_cacheStatistics->setLastModifiedTime(static_cast<uint32_t>(currTime));
     }
     // TODO:  should we really touch the parent region??
-    RegionInternal* ri = dynamic_cast<RegionInternal*>(m_parentRegion.ptr());
+    RegionInternal* ri = dynamic_cast<RegionInternal*>(m_parentRegion.get());
     if (ri != NULL) {
       ri->updateAccessAndModifiedTime(modified);
     }
@@ -164,17 +164,18 @@ void LocalRegion::tombstoneOperationNoThrow(
 
   if (!cachingEnabled) return;
 
-  if (tombstoneVersions.ptr() != NULL) {
+  if (tombstoneVersions.get() != NULL) {
     std::map<uint16_t, int64_t> gcVersions;
     for (HashMapT<CacheableKeyPtr, CacheablePtr>::Iterator itr =
              tombstoneVersions->begin();
          itr != tombstoneVersions->end(); ++itr) {
       try {
-        DSMemberForVersionStampPtr member =
-            dynCast<DSMemberForVersionStampPtr>(itr.first());
+        auto member =
+            std::dynamic_pointer_cast<DSMemberForVersionStamp>(itr.first());
         uint16_t memberId =
             getCacheImpl()->getMemberListForVersionStamp()->add(member);
-        int64_t version = (dynCast<CacheableInt64Ptr>(itr.second()))->value();
+        int64_t version =
+            (std::dynamic_pointer_cast<CacheableInt64>(itr.second()))->value();
         gcVersions[memberId] = version;
       } catch (const ClassCastException&) {
         LOGERROR(
@@ -240,9 +241,11 @@ RegionPtr LocalRegion::createSubregion(
         "LocalRegion::createSubregion: named region exists in the region");
   }
 
-  CacheStatisticsPtr csptr(new CacheStatistics);
-  RegionInternal* rPtr = m_cacheImpl->createRegion_internal(
-      subregionName, this, aRegionAttributes, csptr, false);
+  auto csptr = std::make_shared<CacheStatistics>();
+  RegionInternalPtr rPtr = m_cacheImpl->createRegion_internal(
+      subregionName,
+      std::static_pointer_cast<RegionInternal>(shared_from_this()),
+      aRegionAttributes, csptr, false);
   region_ptr = rPtr;
   if (!rPtr) {
     throw OutOfMemoryException("createSubregion: failed to create region");
@@ -251,7 +254,7 @@ RegionPtr LocalRegion::createSubregion(
   // Instantiate a PersistenceManager object if DiskPolicy is overflow
   if (aRegionAttributes->getDiskPolicy() == DiskPolicyType::OVERFLOWS) {
     PersistenceManagerPtr pmPtr = aRegionAttributes->getPersistenceManager();
-    if (pmPtr == NULLPTR) {
+    if (pmPtr == nullptr) {
       throw NullPointerException(
           "PersistenceManager could not be instantiated");
     }
@@ -285,14 +288,14 @@ RegionEntryPtr LocalRegion::getEntry(const CacheableKeyPtr& key) {
   RegionEntryPtr rptr;
   CacheablePtr valuePtr;
   getEntry(key, valuePtr);
-  if (valuePtr != NULLPTR) {
+  if (valuePtr != nullptr) {
     rptr = createRegionEntry(key, valuePtr);
   }
   return rptr;
 }
 
 void LocalRegion::getEntry(const CacheableKeyPtr& key, CacheablePtr& valuePtr) {
-  if (key == NULLPTR) {
+  if (key == nullptr) {
     throw IllegalArgumentException("LocalRegion::getEntry: null key");
   }
 
@@ -329,7 +332,7 @@ void LocalRegion::put(const CacheableKeyPtr& key, const CacheablePtr& value,
   Utils::updateStatOpTime(m_regionStats->getStat(),
                           RegionStatType::getInstance()->getPutTimeId(),
                           sampleStartNanos);
-  //  handleReplay(err, NULLPTR);
+  //  handleReplay(err, nullptr);
   GfErrTypeToException("Region::put", err);
 }
 
@@ -355,7 +358,7 @@ void LocalRegion::putAll(const HashMapOfCacheable& map, uint32_t timeout,
   Utils::updateStatOpTime(m_regionStats->getStat(),
                           RegionStatType::getInstance()->getPutAllTimeId(),
                           sampleStartNanos);
-  // handleReplay(err, NULLPTR);
+  // handleReplay(err, nullptr);
   GfErrTypeToException("Region::putAll", err);
 }
 
@@ -377,7 +380,7 @@ void LocalRegion::create(const CacheableKeyPtr& key, const CacheablePtr& value,
   VersionTagPtr versionTag;
   GfErrType err = createNoThrow(key, value, aCallbackArgument, -1,
                                 CacheEventFlags::NORMAL, versionTag);
-  // handleReplay(err, NULLPTR);
+  // handleReplay(err, nullptr);
   GfErrTypeToException("Region::create", err);
 }
 
@@ -395,7 +398,7 @@ void LocalRegion::invalidate(const CacheableKeyPtr& key,
   VersionTagPtr versionTag;
   GfErrType err = invalidateNoThrow(key, aCallbackArgument, -1,
                                     CacheEventFlags::NORMAL, versionTag);
-  //  handleReplay(err, NULLPTR);
+  //  handleReplay(err, nullptr);
   GfErrTypeToException("Region::invalidate", err);
 }
 
@@ -413,7 +416,7 @@ void LocalRegion::destroy(const CacheableKeyPtr& key,
 
   GfErrType err = destroyNoThrow(key, aCallbackArgument, -1,
                                  CacheEventFlags::NORMAL, versionTag);
-  // handleReplay(err, NULLPTR);
+  // handleReplay(err, nullptr);
   GfErrTypeToException("Region::destroy", err);
 }
 
@@ -532,7 +535,7 @@ void LocalRegion::getAll(const VectorOfCacheableKey& keys,
     throw IllegalArgumentException("Region::getAll: zero keys provided");
   }
   // check for the combination which will result in no action
-  if (values == NULLPTR &&
+  if (values == nullptr &&
       !(addToLocalCache && m_regionAttributes->getCachingEnabled())) {
     throw IllegalArgumentException(
         "Region::getAll: either output \"values\""
@@ -547,7 +550,7 @@ void LocalRegion::getAll(const VectorOfCacheableKey& keys,
   Utils::updateStatOpTime(m_regionStats->getStat(),
                           RegionStatType::getInstance()->getGetAllTimeId(),
                           sampleStartNanos);
-  // handleReplay(err, NULLPTR);
+  // handleReplay(err, nullptr);
   GfErrTypeToException("Region::getAll", err);
 }
 uint32_t LocalRegion::size_remote() {
@@ -572,10 +575,10 @@ uint32_t LocalRegion::size() {
 
 RegionServicePtr LocalRegion::getRegionService() const {
   CHECK_DESTROY_PENDING(TryReadGuard, LocalRegion::getRegionService);
-  return RegionServicePtr(m_cacheImpl->getCache());
+  return m_cacheImpl->getCache()->shared_from_this();
 }
 
-CacheImpl* LocalRegion::getCacheImpl() {
+CacheImpl* LocalRegion::getCacheImpl() const {
   CHECK_DESTROY_PENDING(TryReadGuard, LocalRegion::getCache);
   return m_cacheImpl;
 }
@@ -589,14 +592,14 @@ bool LocalRegion::containsValueForKey_remote(
   CacheablePtr valuePtr;
   MapEntryImplPtr mePtr;
   m_entries->getEntry(keyPtr, mePtr, valuePtr);
-  if (mePtr == NULLPTR) {
+  if (mePtr == nullptr) {
     return false;
   }
-  return (valuePtr != NULLPTR && !CacheableToken::isInvalid(valuePtr));
+  return (valuePtr != nullptr && !CacheableToken::isInvalid(valuePtr));
 }
 
 bool LocalRegion::containsValueForKey(const CacheableKeyPtr& keyPtr) const {
-  if (keyPtr == NULLPTR) {
+  if (keyPtr == nullptr) {
     throw IllegalArgumentException(
         "LocalRegion::containsValueForKey: "
         "key is null");
@@ -624,7 +627,7 @@ void LocalRegion::getInterestListRegex(VectorOfCacheableString& vregex) const {
 }
 
 bool LocalRegion::containsKey(const CacheableKeyPtr& keyPtr) const {
-  if (keyPtr == NULLPTR) {
+  if (keyPtr == nullptr) {
     throw IllegalArgumentException(
         "LocalRegion::containsKey: "
         "key is null");
@@ -644,7 +647,8 @@ void LocalRegion::setPersistenceManager(PersistenceManagerPtr& pmPtr) {
 
 void LocalRegion::setRegionExpiryTask() {
   if (regionExpiryEnabled()) {
-    RegionInternalPtr rptr(this);
+    RegionInternalPtr rptr =
+        std::static_pointer_cast<RegionInternal>(shared_from_this());
     uint32_t duration = getRegionExpiryDuration();
     RegionExpiryHandler* handler =
         new RegionExpiryHandler(rptr, getRegionExpiryAction(), duration);
@@ -663,7 +667,8 @@ void LocalRegion::registerEntryExpiryTask(MapEntryImplPtr& entry) {
   // the entry will register the expiry task for that entry
   ExpEntryProperties& expProps = entry->getExpProperties();
   expProps.initStartTime();
-  RegionInternalPtr rptr(this);
+  RegionInternalPtr rptr =
+      std::static_pointer_cast<RegionInternal>(shared_from_this());
   uint32_t duration = getEntryExpiryDuration();
   EntryExpiryHandler* handler =
       new EntryExpiryHandler(rptr, entry, getEntryExpirationAction(), duration);
@@ -686,9 +691,9 @@ LocalRegion::~LocalRegion() {
   if (!m_destroyPending) {
     release(false);
   }
-  m_listener = NULLPTR;
-  m_writer = NULLPTR;
-  m_loader = NULLPTR;
+  m_listener = nullptr;
+  m_writer = nullptr;
+  m_loader = nullptr;
 
   GF_SAFE_DELETE(m_entries);
   GF_SAFE_DELETE(m_regionStats);
@@ -709,11 +714,11 @@ void LocalRegion::release(bool invokeCallbacks) {
   }
   if (invokeCallbacks) {
     try {
-      if (m_loader != NULLPTR) {
-        m_loader->close(RegionPtr(this));
+      if (m_loader != nullptr) {
+        m_loader->close(shared_from_this());
       }
-      if (m_writer != NULLPTR) {
-        m_writer->close(RegionPtr(this));
+      if (m_writer != nullptr) {
+        m_writer->close(shared_from_this());
       }
       // TODO:  shouldn't listener also be here instead of
       // during CacheImpl.close()
@@ -724,9 +729,9 @@ void LocalRegion::release(bool invokeCallbacks) {
     }
   }
 
-  if (m_persistenceManager != NULLPTR) {
+  if (m_persistenceManager != nullptr) {
     m_persistenceManager->close();
-    m_persistenceManager = NULLPTR;
+    m_persistenceManager = nullptr;
   }
   if (m_entries != NULL && m_regionAttributes->getCachingEnabled()) {
     m_entries->close();
@@ -745,7 +750,7 @@ void LocalRegion::release(bool invokeCallbacks) {
 *@throw NotConnectedException, if not connected to geode system.
 */
 bool LocalRegion::containsKey_internal(const CacheableKeyPtr& keyPtr) const {
-  if (keyPtr == NULLPTR) {
+  if (keyPtr == nullptr) {
     throw IllegalArgumentException("Region::containsKey: key is null");
   }
   if (!m_regionAttributes->getCachingEnabled()) {
@@ -774,7 +779,7 @@ void LocalRegion::subregions_internal(const bool recursive,
   if (recursive == true) {
     // decend...
     for (int32_t i = 0; i < subRegions.size(); i++) {
-      dynamic_cast<LocalRegion*>(subRegions.at(i).ptr())
+      dynamic_cast<LocalRegion*>(subRegions.at(i).get())
           ->subregions_internal(true, sr);
     }
   }
@@ -785,7 +790,7 @@ GfErrType LocalRegion::getNoThrow(const CacheableKeyPtr& keyPtr,
                                   const UserDataPtr& aCallbackArgument) {
   CHECK_DESTROY_PENDING_NOTHROW(TryReadGuard);
   GfErrType err = GF_NOERR;
-  if (keyPtr == NULLPTR) {
+  if (keyPtr == nullptr) {
     return GF_CACHE_ILLEGAL_ARGUMENT_EXCEPTION;
   }
   TXState* txState = getTXState();
@@ -800,7 +805,7 @@ GfErrType LocalRegion::getNoThrow(const CacheableKeyPtr& keyPtr,
     }
     if (CacheableToken::isInvalid(value) ||
         CacheableToken::isTombstone(value)) {
-      value = NULLPTR;
+      value = nullptr;
     }
     return err;
   }
@@ -816,10 +821,10 @@ GfErrType LocalRegion::getNoThrow(const CacheableKeyPtr& keyPtr,
   bool isLoaderInvoked = false;
   bool isLocal = false;
   bool cachingEnabled = m_regionAttributes->getCachingEnabled();
-  CacheablePtr localValue = NULLPTR;
+  CacheablePtr localValue = nullptr;
   if (cachingEnabled) {
     isLocal = m_entries->get(keyPtr, value, me);
-    if (isLocal && (value != NULLPTR && !CacheableToken::isInvalid(value))) {
+    if (isLocal && (value != nullptr && !CacheableToken::isInvalid(value))) {
       m_regionStats->incHits();
       m_cacheImpl->m_cacheStats->incHits();
       updateAccessAndModifiedTimeForEntry(me, false);
@@ -827,7 +832,7 @@ GfErrType LocalRegion::getNoThrow(const CacheableKeyPtr& keyPtr,
       return err;  // found it in local cache...
     }
     localValue = value;
-    value = NULLPTR;
+    value = nullptr;
     // start tracking the entry
     if (!m_regionAttributes->getConcurrencyChecksEnabled()) {
       updateCount =
@@ -871,14 +876,14 @@ GfErrType LocalRegion::getNoThrow(const CacheableKeyPtr& keyPtr,
 
   // Its a cache missor it is invalid token then Check if we have a local
   // loader.
-  if ((value == NULLPTR || CacheableToken::isInvalid(value) ||
+  if ((value == nullptr || CacheableToken::isInvalid(value) ||
        CacheableToken::isTombstone(value)) &&
-      m_loader != NULLPTR) {
+      m_loader != nullptr) {
     try {
       isLoaderInvoked = true;
       /*Update the statistics*/
       int64_t sampleStartNanos = Utils::startStatOpTime();
-      value = m_loader->load(RegionPtr(this), keyPtr, aCallbackArgument);
+      value = m_loader->load(shared_from_this(), keyPtr, aCallbackArgument);
       Utils::updateStatOpTime(
           m_regionStats->getStat(),
           RegionStatType::getInstance()->getLoaderCallTimeId(),
@@ -899,10 +904,10 @@ GfErrType LocalRegion::getNoThrow(const CacheableKeyPtr& keyPtr,
 
   CacheablePtr oldValue;
   // Found it somehow, so store it.
-  if (value != NULLPTR /*&& value != CacheableToken::invalid( )*/ &&
+  if (value != nullptr /*&& value != CacheableToken::invalid( )*/ &&
       cachingEnabled &&
       !(CacheableToken::isTombstone(value) &&
-        (localValue == NULLPTR || CacheableToken::isInvalid(localValue)))) {
+        (localValue == nullptr || CacheableToken::isInvalid(localValue)))) {
     //  try to create the entry and if that returns an existing value
     // (e.g. from another thread or notification) then return that
     LOGDEBUG(
@@ -919,7 +924,7 @@ GfErrType LocalRegion::getNoThrow(const CacheableKeyPtr& keyPtr,
             Utils::getCacheableKeyString(keyPtr)->asChar());
         if (CacheableToken::isInvalid(value) ||
             CacheableToken::isTombstone(value)) {
-          value = NULLPTR;
+          value = nullptr;
         }
         // don't do anything and  exit
         return GF_NOERR;
@@ -928,7 +933,7 @@ GfErrType LocalRegion::getNoThrow(const CacheableKeyPtr& keyPtr,
       LOGDEBUG("Region::get: putLocal for key [%s] failed with error %d",
                Utils::getCacheableKeyString(keyPtr)->asChar(), err);
       err = GF_NOERR;
-      if (oldValue != NULLPTR && !CacheableToken::isInvalid(oldValue)) {
+      if (oldValue != nullptr && !CacheableToken::isInvalid(oldValue)) {
         LOGDEBUG("Region::get: returning updated value [%s] for key [%s]",
                  Utils::getCacheableString(oldValue)->asChar(),
                  Utils::getCacheableKeyString(keyPtr)->asChar());
@@ -940,14 +945,14 @@ GfErrType LocalRegion::getNoThrow(const CacheableKeyPtr& keyPtr,
   }
 
   if (CacheableToken::isInvalid(value) || CacheableToken::isTombstone(value)) {
-    value = NULLPTR;
+    value = nullptr;
   }
 
   // invokeCacheListenerForEntryEvent method has the check that if oldValue
   // is a CacheableToken then it sets it to NULL; also determines if it
   // should be AFTER_UPDATE or AFTER_CREATE depending on oldValue, so don't
   // check here.
-  if (isLoaderInvoked == false && err == GF_NOERR && value != NULLPTR) {
+  if (isLoaderInvoked == false && err == GF_NOERR && value != nullptr) {
     err = invokeCacheListenerForEntryEvent(
         keyPtr, oldValue, value, aCallbackArgument, CacheEventFlags::NORMAL,
         AFTER_UPDATE, isLocal);
@@ -972,17 +977,17 @@ GfErrType LocalRegion::getAllNoThrow(const VectorOfCacheableKey& keys,
     }
     //		if(!txState->isReplay())
     //		{
-    //			VectorOfCacheablePtr args(new VectorOfCacheable());
+    //			auto args = std::make_shared<VectorOfCacheable>();
     //			args->push_back(VectorOfCacheableKeyPtr(new
     // VectorOfCacheableKey(keys)));
     //			args->push_back(values);
     //			args->push_back(exceptions);
     //			args->push_back(CacheableBoolean::create(addToLocalCache));
     //			txState->recordTXOperation(GF_GET_ALL, getFullPath(),
-    // NULLPTR,
+    // nullptr,
     // args);
     //		}
-    err = getAllNoThrow_remote(&keys, values, exceptions, NULLPTR, false,
+    err = getAllNoThrow_remote(&keys, values, exceptions, nullptr, false,
                                aCallbackArgument);
     if (err == GF_NOERR) {
       txState->setDirty();
@@ -999,11 +1004,11 @@ GfErrType LocalRegion::getAllNoThrow(const VectorOfCacheableKey& keys,
   for (int32_t index = 0; index < keys.size(); ++index) {
     const CacheableKeyPtr& key = keys[index];
     MapEntryImplPtr me;
-    value = NULLPTR;
+    value = nullptr;
     m_regionStats->incGets();
     m_cacheImpl->m_cacheStats->incGets();
-    if (values != NULLPTR && cachingEnabled) {
-      if (m_entries->get(key, value, me) && value != NULLPTR &&
+    if (values != nullptr && cachingEnabled) {
+      if (m_entries->get(key, value, me) && value != nullptr &&
           !CacheableToken::isInvalid(value)) {
         m_regionStats->incHits();
         m_cacheImpl->m_cacheStats->incHits();
@@ -1011,10 +1016,10 @@ GfErrType LocalRegion::getAllNoThrow(const VectorOfCacheableKey& keys,
         regionAccessed = true;
         values->insert(key, value);
       } else {
-        value = NULLPTR;
+        value = nullptr;
       }
     }
-    if (value == NULLPTR) {
+    if (value == nullptr) {
       // Add to missed keys list.
       serverKeys.push_back(key);
 
@@ -1027,7 +1032,7 @@ GfErrType LocalRegion::getAllNoThrow(const VectorOfCacheableKey& keys,
     updateAccessAndModifiedTime(false);
   }
   if (serverKeys.size() > 0) {
-    err = getAllNoThrow_remote(&serverKeys, values, exceptions, NULLPTR,
+    err = getAllNoThrow_remote(&serverKeys, values, exceptions, nullptr,
                                addToLocalCache, aCallbackArgument);
   }
   m_regionStats->incGetAll();
@@ -1055,7 +1060,7 @@ class PutActions {
   inline static GfErrType checkArgs(const CacheableKeyPtr& key,
                                     const CacheablePtr& value,
                                     DataInput* delta = NULL) {
-    if (key == NULLPTR || (value == NULLPTR && delta == NULL)) {
+    if (key == nullptr || (value == nullptr && delta == NULL)) {
       return GF_CACHE_ILLEGAL_ARGUMENT_EXCEPTION;
     }
     return GF_NOERR;
@@ -1072,7 +1077,7 @@ class PutActions {
 
   inline static void logCacheWriterFailure(const CacheableKeyPtr& key,
                                            const CacheablePtr& oldValue) {
-    bool isUpdate = (oldValue != NULLPTR);
+    bool isUpdate = (oldValue != nullptr);
     LOGFINER("Cache writer vetoed %s for key %s",
              (isUpdate ? "update" : "create"),
              Utils::getCacheableKeyString(key)->asChar());
@@ -1084,7 +1089,7 @@ class PutActions {
                                 VersionTagPtr& versionTag) {
     //    	if(m_txState != NULL && !m_txState->isReplay())
     //    	{
-    //    		VectorOfCacheablePtr args(new VectorOfCacheable());
+    //    		auto args = std::make_shared<VectorOfCacheable>();
     //    		args->push_back(value);
     //    		args->push_back(aCallbackArgument);
     //    		m_txState->recordTXOperation(GF_PUT,
@@ -1101,7 +1106,7 @@ class PutActions {
                                const CacheEventFlags eventFlags,
                                int updateCount, VersionTagPtr versionTag,
                                DataInput* delta = NULL,
-                               EventIdPtr eventId = NULLPTR,
+                               EventIdPtr eventId = nullptr,
                                bool afterRemote = false) {
     return m_region.putLocal(name(), false, key, value, oldValue,
                              cachingEnabled, updateCount, 0, versionTag, delta,
@@ -1121,7 +1126,7 @@ class PutActionsTx : public PutActions {
   inline static GfErrType checkArgs(const CacheableKeyPtr& key,
                                     const CacheablePtr& value,
                                     DataInput* delta = NULL) {
-    if (key == NULLPTR) {
+    if (key == nullptr) {
       return GF_CACHE_ILLEGAL_ARGUMENT_EXCEPTION;
     }
     return GF_NOERR;
@@ -1146,7 +1151,7 @@ class CreateActions {
   inline static GfErrType checkArgs(const CacheableKeyPtr& key,
                                     const CacheablePtr& value,
                                     DataInput* delta) {
-    if (key == NULLPTR) {
+    if (key == nullptr) {
       return GF_CACHE_ILLEGAL_ARGUMENT_EXCEPTION;
     }
     return GF_NOERR;
@@ -1170,7 +1175,7 @@ class CreateActions {
     // propagate the create to remote server, if any
     //  	  if(m_txState != NULL && !m_txState->isReplay())
     //  	  {
-    //  		  VectorOfCacheablePtr args(new VectorOfCacheable());
+    //  		  auto args = std::make_shared<VectorOfCacheable>();
     //  		  args->push_back(value);
     //  		  args->push_back(aCallbackArgument);
     //  		  m_txState->recordTXOperation(GF_CREATE,
@@ -1186,7 +1191,7 @@ class CreateActions {
                                const CacheEventFlags eventFlags,
                                int updateCount, VersionTagPtr versionTag,
                                DataInput* delta = NULL,
-                               EventIdPtr eventId = NULLPTR,
+                               EventIdPtr eventId = nullptr,
                                bool afterRemote = false) {
     return m_region.putLocal(name(), true, key, value, oldValue, cachingEnabled,
                              updateCount, 0, versionTag);
@@ -1214,7 +1219,7 @@ class DestroyActions {
   inline static GfErrType checkArgs(const CacheableKeyPtr& key,
                                     const CacheablePtr& value,
                                     DataInput* delta) {
-    if (key == NULLPTR) {
+    if (key == nullptr) {
       return GF_CACHE_ILLEGAL_ARGUMENT_EXCEPTION;
     }
     return GF_NOERR;
@@ -1242,7 +1247,7 @@ class DestroyActions {
     // propagate the destroy to remote server, if any
     //    	if(m_txState != NULL && !m_txState->isReplay())
     //    	{
-    //    		VectorOfCacheablePtr args(new VectorOfCacheable());
+    //    		auto args = std::make_shared<VectorOfCacheable>();
     //    		args->push_back(aCallbackArgument);
     //    		m_txState->recordTXOperation(GF_DESTROY,
     //    m_region.getFullPath(), key, args);
@@ -1257,7 +1262,7 @@ class DestroyActions {
                                const CacheEventFlags eventFlags,
                                int updateCount, VersionTagPtr versionTag,
                                DataInput* delta = NULL,
-                               EventIdPtr eventId = NULLPTR,
+                               EventIdPtr eventId = nullptr,
                                bool afterRemote = false) {
     if (cachingEnabled) {
       MapEntryImplPtr entry;
@@ -1281,14 +1286,14 @@ class DestroyActions {
         }
         return err;
       }
-      if (oldValue != NULLPTR) {
+      if (oldValue != nullptr) {
         LOGDEBUG(
             "Region::destroy: region [%s] destroyed key [%s] having "
             "value [%s]",
             m_region.getFullPath(), Utils::getCacheableKeyString(key)->asChar(),
             Utils::getCacheableString(oldValue)->asChar());
         // any cleanup required for the entry (e.g. removing from LRU list)
-        if (entry != NULLPTR) {
+        if (entry != nullptr) {
           entry->cleanup(eventFlags);
         }
         // entry/region expiration
@@ -1331,7 +1336,7 @@ class RemoveActions {
   inline static GfErrType checkArgs(const CacheableKeyPtr& key,
                                     const CacheablePtr& value,
                                     DataInput* delta) {
-    if (key == NULLPTR) {
+    if (key == nullptr) {
       return GF_CACHE_ILLEGAL_ARGUMENT_EXCEPTION;
     }
     return GF_NOERR;
@@ -1364,7 +1369,7 @@ class RemoveActions {
       DataOutput out1;
       DataOutput out2;
 
-      if (valuePtr != NULLPTR && value != NULLPTR) {
+      if (valuePtr != nullptr && value != nullptr) {
         if (valuePtr->classId() != value->classId() ||
             valuePtr->typeId() != value->typeId()) {
           err = GF_ENOENT;
@@ -1381,7 +1386,7 @@ class RemoveActions {
           err = GF_ENOENT;
           return err;
         }
-      } else if ((valuePtr == NULLPTR || CacheableToken::isInvalid(valuePtr))) {
+      } else if ((valuePtr == nullptr || CacheableToken::isInvalid(valuePtr))) {
         //        	if(m_txState != NULL && !m_txState->isReplay())
         //        	{
         //        		VectorOfCacheablePtr args(new
@@ -1396,14 +1401,14 @@ class RemoveActions {
             key, value, aCallbackArgument, versionTag);
 
         return m_ServerResponse;
-      } else if (valuePtr != NULLPTR && value == NULLPTR) {
+      } else if (valuePtr != nullptr && value == nullptr) {
         err = GF_ENOENT;
         return err;
       }
     }
     //  	if(m_txState != NULL && !m_txState->isReplay())
     //  	{
-    //  		VectorOfCacheablePtr args(new VectorOfCacheable());
+    //  		auto args = std::make_shared<VectorOfCacheable>();
     //  		args->push_back(value);
     //  		args->push_back(aCallbackArgument);
     //  		m_txState->recordTXOperation(GF_REMOVE,
@@ -1426,7 +1431,7 @@ class RemoveActions {
                                const CacheEventFlags eventFlags,
                                int updateCount, VersionTagPtr versionTag,
                                DataInput* delta = NULL,
-                               EventIdPtr eventId = NULLPTR,
+                               EventIdPtr eventId = nullptr,
                                bool afterRemote = false) {
     CacheablePtr valuePtr;
     GfErrType err = GF_NOERR;
@@ -1434,7 +1439,7 @@ class RemoveActions {
       m_region.getEntry(key, valuePtr);
       DataOutput out1;
       DataOutput out2;
-      if (valuePtr != NULLPTR && value != NULLPTR) {
+      if (valuePtr != nullptr && value != nullptr) {
         if (valuePtr->classId() != value->classId() ||
             valuePtr->typeId() != value->typeId()) {
           err = GF_ENOENT;
@@ -1451,9 +1456,9 @@ class RemoveActions {
           err = GF_ENOENT;
           return err;
         }
-      } else if (value == NULLPTR && (!CacheableToken::isInvalid(valuePtr) ||
-                                      valuePtr == NULLPTR)) {
-        err = (m_ServerResponse == 0 && valuePtr == NULLPTR) ? GF_NOERR
+      } else if (value == nullptr && (!CacheableToken::isInvalid(valuePtr) ||
+                                      valuePtr == nullptr)) {
+        err = (m_ServerResponse == 0 && valuePtr == nullptr) ? GF_NOERR
                                                              : GF_ENOENT;
         if (updateCount >= 0 &&
             !m_region.getAttributes()
@@ -1466,7 +1471,7 @@ class RemoveActions {
           m_region.m_entries->removeTrackerForEntry(key);
         }
         return err;
-      } else if (valuePtr == NULLPTR && value != NULLPTR &&
+      } else if (valuePtr == nullptr && value != nullptr &&
                  m_ServerResponse != 0) {
         err = GF_ENOENT;
         return err;
@@ -1495,14 +1500,14 @@ class RemoveActions {
         }
         return err;
       }
-      if (oldValue != NULLPTR) {
+      if (oldValue != nullptr) {
         LOGDEBUG(
             "Region::remove: region [%s] removed key [%s] having "
             "value [%s]",
             m_region.getFullPath(), Utils::getCacheableKeyString(key)->asChar(),
             Utils::getCacheableString(oldValue)->asChar());
         // any cleanup required for the entry (e.g. removing from LRU list)
-        if (entry != NULLPTR) {
+        if (entry != nullptr) {
           entry->cleanup(eventFlags);
         }
         // entry/region expiration
@@ -1550,7 +1555,7 @@ class InvalidateActions {
   inline static GfErrType checkArgs(const CacheableKeyPtr& key,
                                     const CacheablePtr& value,
                                     DataInput* delta = NULL) {
-    if (key == NULLPTR) {
+    if (key == nullptr) {
       return GF_CACHE_ILLEGAL_ARGUMENT_EXCEPTION;
     }
     return GF_NOERR;
@@ -1567,7 +1572,7 @@ class InvalidateActions {
 
   inline static void logCacheWriterFailure(const CacheableKeyPtr& key,
                                            const CacheablePtr& oldValue) {
-    bool isUpdate = (oldValue != NULLPTR);
+    bool isUpdate = (oldValue != nullptr);
     LOGFINER("Cache writer vetoed %s for key %s",
              (isUpdate ? "update" : "invalidate"),
              Utils::getCacheableKeyString(key)->asChar());
@@ -1579,7 +1584,7 @@ class InvalidateActions {
                                 VersionTagPtr& versionTag) {
     //    	if(m_txState != NULL && !m_txState->isReplay())
     //    	{
-    //    		VectorOfCacheablePtr args(new VectorOfCacheable());
+    //    		auto args = std::make_shared<VectorOfCacheable>();
     //    		args->push_back(aCallbackArgument);
     //    		m_txState->recordTXOperation(GF_INVALIDATE,
     //    m_region.getFullPath(), key, args);
@@ -1595,7 +1600,7 @@ class InvalidateActions {
                                const CacheEventFlags eventFlags,
                                int updateCount, VersionTagPtr versionTag,
                                DataInput* delta = NULL,
-                               EventIdPtr eventId = NULLPTR,
+                               EventIdPtr eventId = nullptr,
                                bool afterRemote = false) {
     return m_region.invalidateLocal(name(), key, value, eventFlags, versionTag);
   }
@@ -1645,7 +1650,7 @@ GfErrType LocalRegion::updateNoThrow(const CacheableKeyPtr& key,
 
   //  do not invoke the writer in case of notification/eviction
   // or expiration
-  if (m_writer != NULLPTR && eventFlags.invokeCacheWriter()) {
+  if (m_writer != nullptr && eventFlags.invokeCacheWriter()) {
     action.getCallbackOldValue(cachingEnabled, key, entry, oldValue);
     // invokeCacheWriterForEntryEvent method has the check that if oldValue
     // is a CacheableToken then it sets it to NULL; also determines if it
@@ -1671,7 +1676,7 @@ GfErrType LocalRegion::updateNoThrow(const CacheableKeyPtr& key,
       if ((updateCount = m_entries->addTrackerForEntry(
                key, oldValue, TAction::s_addIfAbsent, TAction::s_failIfPresent,
                true)) < 0) {
-        if (oldValue != NULLPTR) {
+        if (oldValue != nullptr) {
           // fail for "create" when entry exists
           return GF_CACHE_ENTRY_EXISTS;
         }
@@ -1715,9 +1720,9 @@ GfErrType LocalRegion::updateNoThrow(const CacheableKeyPtr& key,
       CacheablePtr& newValue1 = const_cast<CacheablePtr&>(value);
       VersionTagPtr versionTag1;
       err = getNoThrow_FullObject(eventId, newValue1, versionTag1);
-      if (err == GF_NOERR && newValue1 != NULLPTR) {
+      if (err == GF_NOERR && newValue1 != nullptr) {
         err = m_entries->put(key, newValue1, entry, oldValue, updateCount, 0,
-                             versionTag1 != NULLPTR ? versionTag1 : versionTag);
+                             versionTag1 != nullptr ? versionTag1 : versionTag);
         if (err == GF_CACHE_CONCURRENT_MODIFICATION_EXCEPTION) {
           LOGDEBUG(
               "Region::localUpdate: updateNoThrow<%s> for key [%s] failed because the cache already contains \
@@ -1846,7 +1851,7 @@ GfErrType LocalRegion::destroyNoThrow(const CacheableKeyPtr& key,
                                       const CacheEventFlags eventFlags,
                                       VersionTagPtr versionTag) {
   CacheablePtr oldValue;
-  return updateNoThrow<DestroyActions>(key, NULLPTR, aCallbackArgument,
+  return updateNoThrow<DestroyActions>(key, nullptr, aCallbackArgument,
                                        oldValue, updateCount, eventFlags,
                                        versionTag);
 }
@@ -1857,7 +1862,7 @@ GfErrType LocalRegion::destroyNoThrowTX(const CacheableKeyPtr& key,
                                         const CacheEventFlags eventFlags,
                                         VersionTagPtr versionTag) {
   CacheablePtr oldValue;
-  return updateNoThrowTX<DestroyActions>(key, NULLPTR, aCallbackArgument,
+  return updateNoThrowTX<DestroyActions>(key, nullptr, aCallbackArgument,
                                          oldValue, updateCount, eventFlags,
                                          versionTag);
 }
@@ -1879,7 +1884,7 @@ GfErrType LocalRegion::removeNoThrowEx(const CacheableKeyPtr& key,
                                        const CacheEventFlags eventFlags,
                                        VersionTagPtr versionTag) {
   CacheablePtr oldValue;
-  return updateNoThrow<RemoveActionsEx>(key, NULLPTR, aCallbackArgument,
+  return updateNoThrow<RemoveActionsEx>(key, nullptr, aCallbackArgument,
                                         oldValue, updateCount, eventFlags,
                                         versionTag);
 }
@@ -1890,7 +1895,7 @@ GfErrType LocalRegion::invalidateNoThrow(const CacheableKeyPtr& key,
                                          const CacheEventFlags eventFlags,
                                          VersionTagPtr versionTag) {
   CacheablePtr oldValue;
-  return updateNoThrow<InvalidateActions>(key, NULLPTR, aCallbackArgument,
+  return updateNoThrow<InvalidateActions>(key, nullptr, aCallbackArgument,
                                           oldValue, updateCount, eventFlags,
                                           versionTag);
 }
@@ -1901,7 +1906,7 @@ GfErrType LocalRegion::invalidateNoThrowTX(const CacheableKeyPtr& key,
                                            const CacheEventFlags eventFlags,
                                            VersionTagPtr versionTag) {
   CacheablePtr oldValue;
-  return updateNoThrowTX<InvalidateActions>(key, NULLPTR, aCallbackArgument,
+  return updateNoThrowTX<InvalidateActions>(key, nullptr, aCallbackArgument,
                                             oldValue, updateCount, eventFlags,
                                             versionTag);
 }
@@ -1921,10 +1926,10 @@ GfErrType LocalRegion::putAllNoThrow(const HashMapOfCacheable& map,
     }
     // if(!txState->isReplay())
     //{
-    //	VectorOfCacheablePtr args(new VectorOfCacheable());
+    //	auto args = std::make_shared<VectorOfCacheable>();
     //	args->push_back(HashMapOfCacheablePtr(new HashMapOfCacheable(map)));
     //	args->push_back(CacheableInt32::create(timeout));
-    //	txState->recordTXOperation(GF_PUT_ALL, getFullPath(), NULLPTR, args);
+    //	txState->recordTXOperation(GF_PUT_ALL, getFullPath(), nullptr, args);
     //}
     err = putAllNoThrow_remote(map, /*versionTag*/ versionedObjPartListPtr,
                                timeout, aCallbackArgument);
@@ -1960,7 +1965,7 @@ GfErrType LocalRegion::putAllNoThrow(const HashMapOfCacheable& map,
     }
   } _removeTracking(oldValueMap, *this);
 
-  if (cachingEnabled || m_writer != NULLPTR) {
+  if (cachingEnabled || m_writer != nullptr) {
     CacheablePtr oldValue;
     for (HashMapOfCacheable::Iterator iter = map.begin(); iter != map.end();
          ++iter) {
@@ -1972,7 +1977,7 @@ GfErrType LocalRegion::putAllNoThrow(const HashMapOfCacheable& map,
         oldValueMap.insert(
             std::make_pair(key, std::make_pair(oldValue, updateCount)));
       }
-      if (m_writer != NULLPTR) {
+      if (m_writer != nullptr) {
         // invokeCacheWriterForEntryEvent method has the check that if oldValue
         // is a CacheableToken then it sets it to NULL; also determines if it
         // should be BEFORE_UPDATE or BEFORE_CREATE depending on oldValue
@@ -2000,11 +2005,11 @@ GfErrType LocalRegion::putAllNoThrow(const HashMapOfCacheable& map,
       for (int keyIndex = 0;
            keyIndex < versionedObjPartListPtr->getSucceededKeys()->size();
            keyIndex++) {
-        const CacheablePtr valPtr =
+        const CacheableKeyPtr valPtr =
             versionedObjPartListPtr->getSucceededKeys()->at(keyIndex);
         HashMapOfCacheable::Iterator mapIter = map.find(valPtr);
-        CacheableKeyPtr key = NULLPTR;
-        CacheablePtr value = NULLPTR;
+        CacheableKeyPtr key = nullptr;
+        CacheablePtr value = nullptr;
 
         if (mapIter != map.end()) {
           key = mapIter.first();
@@ -2016,8 +2021,8 @@ GfErrType LocalRegion::putAllNoThrow(const HashMapOfCacheable& map,
               "usermap");
         }
 
-        if (versionedObjPartListPtr != NULLPTR &&
-            versionedObjPartListPtr.ptr() != NULL) {
+        if (versionedObjPartListPtr != nullptr &&
+            versionedObjPartListPtr.get() != NULL) {
           LOGDEBUG("versionedObjPartListPtr->getVersionedTagptr().size() = %d ",
                    versionedObjPartListPtr->getVersionedTagptr().size());
           if (versionedObjPartListPtr->getVersionedTagptr().size() > 0) {
@@ -2055,8 +2060,8 @@ GfErrType LocalRegion::putAllNoThrow(const HashMapOfCacheable& map,
         const CacheablePtr& value = iter.second();
         std::pair<CacheablePtr, int>& p = oldValueMap[key];
 
-        if (versionedObjPartListPtr != NULLPTR &&
-            versionedObjPartListPtr.ptr() != NULL) {
+        if (versionedObjPartListPtr != nullptr &&
+            versionedObjPartListPtr.get() != NULL) {
           LOGDEBUG("versionedObjPartListPtr->getVersionedTagptr().size() = %d ",
                    versionedObjPartListPtr->getVersionedTagptr().size());
           if (versionedObjPartListPtr->getVersionedTagptr().size() > 0) {
@@ -2120,21 +2125,21 @@ GfErrType LocalRegion::removeAllNoThrow(const VectorOfCacheableKey& keys,
   if (cachingEnabled) {
     VectorOfCacheableKey* keysPtr;
     if (m_isPRSingleHopEnabled) {
-      keysPtr = versionedObjPartListPtr->getSucceededKeys().ptr();
+      keysPtr = versionedObjPartListPtr->getSucceededKeys().get();
     } else {
       keysPtr = const_cast<VectorOfCacheableKey*>(&keys);
     }
 
     for (int keyIndex = 0; keyIndex < keysPtr->size(); keyIndex++) {
       CacheableKeyPtr key = keysPtr->at(keyIndex);
-      if (versionedObjPartListPtr != NULLPTR &&
-          versionedObjPartListPtr.ptr() != NULL) {
+      if (versionedObjPartListPtr != nullptr &&
+          versionedObjPartListPtr.get() != NULL) {
         LOGDEBUG("versionedObjPartListPtr->getVersionedTagptr().size() = %d ",
                  versionedObjPartListPtr->getVersionedTagptr().size());
         if (versionedObjPartListPtr->getVersionedTagptr().size() > 0) {
           versionTag = versionedObjPartListPtr->getVersionedTagptr()[keyIndex];
         }
-        if (versionTag == NULLPTR) {
+        if (versionTag == nullptr) {
           LOGDEBUG(
               "RemoveAll hits EntryNotFoundException at server side for key "
               "[%s], not to destroy it from local cache.",
@@ -2208,7 +2213,7 @@ GfErrType LocalRegion::invalidateLocal(const char* name,
                                        const CacheablePtr& value,
                                        const CacheEventFlags eventFlags,
                                        VersionTagPtr versionTag) {
-  if (keyPtr == NULLPTR) {
+  if (keyPtr == nullptr) {
     return GF_CACHE_ILLEGAL_ARGUMENT_EXCEPTION;
   }
   CHECK_DESTROY_PENDING_NOTHROW(TryReadGuard);
@@ -2306,7 +2311,7 @@ GfErrType LocalRegion::invalidateRegionNoThrow(
     for (MapOfRegionWithLock::iterator p = m_subRegions.begin();
          p != m_subRegions.end(); ++p) {
       RegionInternal* subRegion =
-          dynamic_cast<RegionInternal*>((*p).int_id_.ptr());
+          dynamic_cast<RegionInternal*>((*p).int_id_.get());
       if (subRegion != NULL) {
         err = subRegion->invalidateRegionNoThrow(aCallbackArgument, eventFlags);
         if (err != GF_NOERR) {
@@ -2385,7 +2390,7 @@ GfErrType LocalRegion::destroyRegionNoThrow(
       // TODO: remove unnecessary dynamic_cast by having m_subRegions hold
       // RegionInternal and invoke the destroy method in that
       RegionInternal* subRegion =
-          dynamic_cast<RegionInternal*>((*p).int_id_.ptr());
+          dynamic_cast<RegionInternal*>((*p).int_id_.get());
       if (subRegion != NULL) {
         //  for subregions never remove from parent since that will cause
         // the region to be destroyed and SEGV; unbind_all takes care of that
@@ -2423,10 +2428,10 @@ GfErrType LocalRegion::destroyRegionNoThrow(
   GF_D_ASSERT(m_destroyPending);
 
   if (removeFromParent) {
-    if (m_parentRegion == NULLPTR) {
+    if (m_parentRegion == nullptr) {
       m_cacheImpl->removeRegion(m_name.c_str());
     } else {
-      LocalRegion* parent = dynamic_cast<LocalRegion*>(m_parentRegion.ptr());
+      LocalRegion* parent = dynamic_cast<LocalRegion*>(m_parentRegion.get());
       if (parent != NULL) {
         parent->removeRegion(m_name);
         if (!eventFlags.isEvictOrExpire()) {
@@ -2464,10 +2469,10 @@ GfErrType LocalRegion::putLocal(const char* name, bool isCreate,
         CacheablePtr& newValue1 = const_cast<CacheablePtr&>(value);
         VersionTagPtr versionTag1;
         err = getNoThrow_FullObject(eventId, newValue1, versionTag1);
-        if (err == GF_NOERR && newValue1 != NULLPTR) {
+        if (err == GF_NOERR && newValue1 != nullptr) {
           err = m_entries->put(
               key, newValue1, entry, oldValue, updateCount, destroyTracker,
-              versionTag1 != NULLPTR ? versionTag1 : versionTag, isUpdate);
+              versionTag1 != nullptr ? versionTag1 : versionTag, isUpdate);
         }
       }
       if (delta != NULL &&
@@ -2527,7 +2532,7 @@ void LocalRegion::entries_internal(VectorOfRegionEntry& me,
     MapOfRegionGuard guard(m_subRegions.mutex());
     for (MapOfRegionWithLock::iterator p = m_subRegions.begin();
          p != m_subRegions.end(); ++p) {
-      dynamic_cast<LocalRegion*>((*p).int_id_.ptr())
+      dynamic_cast<LocalRegion*>((*p).int_id_.get())
           ->entries_internal(me, true);
     }
   }
@@ -2546,11 +2551,11 @@ bool LocalRegion::invokeCacheWriterForEntryEvent(
     CacheEventFlags eventFlags, EntryEventType type) {
   // Check if we have a local cache writer. If so, invoke and return.
   bool bCacheWriterReturn = true;
-  if (m_writer != NULLPTR) {
-    if (oldValue != NULLPTR && CacheableToken::isInvalid(oldValue)) {
-      oldValue = NULLPTR;
+  if (m_writer != nullptr) {
+    if (oldValue != nullptr && CacheableToken::isInvalid(oldValue)) {
+      oldValue = nullptr;
     }
-    EntryEvent event(RegionPtr(this), key, oldValue, newValue,
+    EntryEvent event(shared_from_this(), key, oldValue, newValue,
                      aCallbackArgument, eventFlags.isNotification());
     const char* eventStr = "unknown";
     try {
@@ -2559,7 +2564,7 @@ bool LocalRegion::invokeCacheWriterForEntryEvent(
       int64_t sampleStartNanos = Utils::startStatOpTime();
       switch (type) {
         case BEFORE_UPDATE: {
-          if (oldValue != NULLPTR) {
+          if (oldValue != nullptr) {
             eventStr = "beforeUpdate";
             bCacheWriterReturn = m_writer->beforeUpdate(event);
             break;
@@ -2607,8 +2612,8 @@ bool LocalRegion::invokeCacheWriterForRegionEvent(
     RegionEventType type) {
   // Check if we have a local cache writer. If so, invoke and return.
   bool bCacheWriterReturn = true;
-  if (m_writer != NULLPTR) {
-    RegionEvent event(RegionPtr(this), aCallbackArgument,
+  if (m_writer != nullptr) {
+    RegionEvent event(shared_from_this(), aCallbackArgument,
                       eventFlags.isNotification());
     const char* eventStr = "unknown";
     try {
@@ -2657,11 +2662,11 @@ GfErrType LocalRegion::invokeCacheListenerForEntryEvent(
   GfErrType err = GF_NOERR;
 
   // Check if we have a local cache listener. If so, invoke and return.
-  if (m_listener != NULLPTR) {
-    if (oldValue != NULLPTR && CacheableToken::isInvalid(oldValue)) {
-      oldValue = NULLPTR;
+  if (m_listener != nullptr) {
+    if (oldValue != nullptr && CacheableToken::isInvalid(oldValue)) {
+      oldValue = nullptr;
     }
-    EntryEvent event(RegionPtr(this), key, oldValue, newValue,
+    EntryEvent event(shared_from_this(), key, oldValue, newValue,
                      aCallbackArgument, eventFlags.isNotification());
     const char* eventStr = "unknown";
     try {
@@ -2672,7 +2677,7 @@ GfErrType LocalRegion::invokeCacheListenerForEntryEvent(
         case AFTER_UPDATE: {
           //  when CREATE is received from server for notification
           // then force an afterUpdate even if key is not present in cache.
-          if (oldValue != NULLPTR || eventFlags.isNotificationUpdate() ||
+          if (oldValue != nullptr || eventFlags.isNotificationUpdate() ||
               isLocal) {
             eventStr = "afterUpdate";
             m_listener->afterUpdate(event);
@@ -2728,8 +2733,8 @@ GfErrType LocalRegion::invokeCacheListenerForRegionEvent(
   GfErrType err = GF_NOERR;
 
   // Check if we have a local cache listener. If so, invoke and return.
-  if (m_listener != NULLPTR) {
-    RegionEvent event(RegionPtr(this), aCallbackArgument,
+  if (m_listener != nullptr) {
+    RegionEvent event(shared_from_this(), aCallbackArgument,
                       eventFlags.isNotification());
     const char* eventStr = "unknown";
     try {
@@ -2743,7 +2748,7 @@ GfErrType LocalRegion::invokeCacheListenerForRegionEvent(
           m_cacheImpl->m_cacheStats->incListenerCalls();
           if (eventFlags.isCacheClose()) {
             eventStr = "close";
-            m_listener->close(RegionPtr(this));
+            m_listener->close(shared_from_this());
             m_cacheImpl->m_cacheStats->incListenerCalls();
           }
           break;
@@ -2788,7 +2793,7 @@ GfErrType LocalRegion::invokeCacheListenerForRegionEvent(
 void LocalRegion::updateAccessAndModifiedTimeForEntry(MapEntryImplPtr& ptr,
                                                       bool modified) {
   // locking is not required since setters use atomic operations
-  if (ptr != NULLPTR && entryExpiryEnabled()) {
+  if (ptr != nullptr && entryExpiryEnabled()) {
     ExpEntryProperties& expProps = ptr->getExpProperties();
     uint32_t currTime = static_cast<uint32_t>(ACE_OS::gettimeofday().sec());
     CacheableStringPtr keyStr;
@@ -3116,10 +3121,10 @@ void LocalRegion::evict(int32_t percentage) {
   }
 }
 void LocalRegion::invokeAfterAllEndPointDisconnected() {
-  if (m_listener != NULLPTR) {
+  if (m_listener != nullptr) {
     int64_t sampleStartNanos = Utils::startStatOpTime();
     try {
-      m_listener->afterRegionDisconnected(RegionPtr(this));
+      m_listener->afterRegionDisconnected(shared_from_this());
     } catch (const Exception& ex) {
       LOGERROR("Exception in CacheListener::afterRegionDisconnected: %s: %s",
                ex.getName(), ex.getMessage());

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/cppcache/src/LocalRegion.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/LocalRegion.hpp b/src/cppcache/src/LocalRegion.hpp
index 0d0fa58..c3c6b05 100644
--- a/src/cppcache/src/LocalRegion.hpp
+++ b/src/cppcache/src/LocalRegion.hpp
@@ -119,6 +119,8 @@ typedef std::unordered_map<CacheableKeyPtr, std::pair<CacheablePtr, int> >
 * is used to concatenate all the region names together from the root, starting
 * with the root's subregions.
 */
+typedef SharedPtr<LocalRegion> LocalRegionPtr;
+
 class CPPCACHE_EXPORT LocalRegion : public RegionInternal {
   /**
    * @brief Public Methods for Region
@@ -127,7 +129,8 @@ class CPPCACHE_EXPORT LocalRegion : public RegionInternal {
   /**
   * @brief constructor/destructor
   */
-  LocalRegion(const std::string& name, CacheImpl* cache, RegionInternal* rPtr,
+  LocalRegion(const std::string& name, CacheImpl* cache,
+              const RegionInternalPtr& rPtr,
               const RegionAttributesPtr& attributes,
               const CacheStatisticsPtr& stats, bool shared = false);
   virtual ~LocalRegion();
@@ -137,19 +140,21 @@ class CPPCACHE_EXPORT LocalRegion : public RegionInternal {
   RegionPtr getParentRegion() const;
   RegionAttributesPtr getAttributes() const { return m_regionAttributes; }
   AttributesMutatorPtr getAttributesMutator() const {
-    return AttributesMutatorPtr(new AttributesMutator(RegionPtr(this)));
+    return std::make_shared<AttributesMutator>(
+        std::const_pointer_cast<LocalRegion>(
+            std::static_pointer_cast<const LocalRegion>(shared_from_this())));
   }
   void updateAccessAndModifiedTime(bool modified);
   CacheStatisticsPtr getStatistics() const;
-  virtual void clear(const UserDataPtr& aCallbackArgument = NULLPTR);
-  virtual void localClear(const UserDataPtr& aCallbackArgument = NULLPTR);
+  virtual void clear(const UserDataPtr& aCallbackArgument = nullptr);
+  virtual void localClear(const UserDataPtr& aCallbackArgument = nullptr);
   GfErrType localClearNoThrow(
-      const UserDataPtr& aCallbackArgument = NULLPTR,
+      const UserDataPtr& aCallbackArgument = nullptr,
       const CacheEventFlags eventFlags = CacheEventFlags::NORMAL);
-  void invalidateRegion(const UserDataPtr& aCallbackArgument = NULLPTR);
-  void localInvalidateRegion(const UserDataPtr& aCallbackArgument = NULLPTR);
-  void destroyRegion(const UserDataPtr& aCallbackArgument = NULLPTR);
-  void localDestroyRegion(const UserDataPtr& aCallbackArgument = NULLPTR);
+  void invalidateRegion(const UserDataPtr& aCallbackArgument = nullptr);
+  void localInvalidateRegion(const UserDataPtr& aCallbackArgument = nullptr);
+  void destroyRegion(const UserDataPtr& aCallbackArgument = nullptr);
+  void localDestroyRegion(const UserDataPtr& aCallbackArgument = nullptr);
   RegionPtr getSubregion(const char* path);
   RegionPtr createSubregion(const char* subregionName,
                             const RegionAttributesPtr& aRegionAttributes);
@@ -159,41 +164,41 @@ class CPPCACHE_EXPORT LocalRegion : public RegionInternal {
   CacheablePtr get(const CacheableKeyPtr& key,
                    const UserDataPtr& aCallbackArgument);
   void put(const CacheableKeyPtr& key, const CacheablePtr& value,
-           const UserDataPtr& aCallbackArgument = NULLPTR);
+           const UserDataPtr& aCallbackArgument = nullptr);
   void localPut(const CacheableKeyPtr& key, const CacheablePtr& value,
-                const UserDataPtr& aCallbackArgument = NULLPTR);
+                const UserDataPtr& aCallbackArgument = nullptr);
   void create(const CacheableKeyPtr& key, const CacheablePtr& value,
-              const UserDataPtr& aCallbackArgument = NULLPTR);
+              const UserDataPtr& aCallbackArgument = nullptr);
   void localCreate(const CacheableKeyPtr& key, const CacheablePtr& value,
-                   const UserDataPtr& aCallbackArgument = NULLPTR);
+                   const UserDataPtr& aCallbackArgument = nullptr);
   void invalidate(const CacheableKeyPtr& key,
-                  const UserDataPtr& aCallbackArgument = NULLPTR);
+                  const UserDataPtr& aCallbackArgument = nullptr);
   void localInvalidate(const CacheableKeyPtr& key,
-                       const UserDataPtr& aCallbackArgument = NULLPTR);
+                       const UserDataPtr& aCallbackArgument = nullptr);
   void destroy(const CacheableKeyPtr& key,
-               const UserDataPtr& aCallbackArgument = NULLPTR);
+               const UserDataPtr& aCallbackArgument = nullptr);
   void localDestroy(const CacheableKeyPtr& key,
-                    const UserDataPtr& aCallbackArgument = NULLPTR);
+                    const UserDataPtr& aCallbackArgument = nullptr);
   bool remove(const CacheableKeyPtr& key, const CacheablePtr& value,
-              const UserDataPtr& aCallbackArgument = NULLPTR);
+              const UserDataPtr& aCallbackArgument = nullptr);
   bool removeEx(const CacheableKeyPtr& key,
-                const UserDataPtr& aCallbackArgument = NULLPTR);
+                const UserDataPtr& aCallbackArgument = nullptr);
   bool localRemove(const CacheableKeyPtr& key, const CacheablePtr& value,
-                   const UserDataPtr& aCallbackArgument = NULLPTR);
+                   const UserDataPtr& aCallbackArgument = nullptr);
   bool localRemoveEx(const CacheableKeyPtr& key,
-                     const UserDataPtr& aCallbackArgument = NULLPTR);
+                     const UserDataPtr& aCallbackArgument = nullptr);
   void keys(VectorOfCacheableKey& v);
   void serverKeys(VectorOfCacheableKey& v);
   void values(VectorOfCacheable& vc);
   void entries(VectorOfRegionEntry& me, bool recursive);
   void getAll(const VectorOfCacheableKey& keys, HashMapOfCacheablePtr values,
               HashMapOfExceptionPtr exceptions, bool addToLocalCache,
-              const UserDataPtr& aCallbackArgument = NULLPTR);
+              const UserDataPtr& aCallbackArgument = nullptr);
   void putAll(const HashMapOfCacheable& map,
               uint32_t timeout = DEFAULT_RESPONSE_TIMEOUT,
-              const UserDataPtr& aCallbackArgument = NULLPTR);
+              const UserDataPtr& aCallbackArgument = nullptr);
   void removeAll(const VectorOfCacheableKey& keys,
-                 const UserDataPtr& aCallbackArgument = NULLPTR);
+                 const UserDataPtr& aCallbackArgument = nullptr);
   uint32_t size();
   virtual uint32_t size_remote();
   RegionServicePtr getRegionService() const;
@@ -215,7 +220,7 @@ class CPPCACHE_EXPORT LocalRegion : public RegionInternal {
   virtual GfErrType getAllNoThrow(
       const VectorOfCacheableKey& keys, const HashMapOfCacheablePtr& values,
       const HashMapOfExceptionPtr& exceptions, bool addToLocalCache,
-      const UserDataPtr& aCallbackArgument = NULLPTR);
+      const UserDataPtr& aCallbackArgument = nullptr);
   virtual GfErrType putNoThrow(const CacheableKeyPtr& key,
                                const CacheablePtr& value,
                                const UserDataPtr& aCallbackArgument,
@@ -223,7 +228,7 @@ class CPPCACHE_EXPORT LocalRegion : public RegionInternal {
                                const CacheEventFlags eventFlags,
                                VersionTagPtr versionTag,
                                DataInput* delta = NULL,
-                               EventIdPtr eventId = NULLPTR);
+                               EventIdPtr eventId = nullptr);
   virtual GfErrType putNoThrowTX(const CacheableKeyPtr& key,
                                  const CacheablePtr& value,
                                  const UserDataPtr& aCallbackArgument,
@@ -231,7 +236,7 @@ class CPPCACHE_EXPORT LocalRegion : public RegionInternal {
                                  const CacheEventFlags eventFlags,
                                  VersionTagPtr versionTag,
                                  DataInput* delta = NULL,
-                                 EventIdPtr eventId = NULLPTR);
+                                 EventIdPtr eventId = nullptr);
   virtual GfErrType createNoThrow(const CacheableKeyPtr& key,
                                   const CacheablePtr& value,
                                   const UserDataPtr& aCallbackArgument,
@@ -262,10 +267,10 @@ class CPPCACHE_EXPORT LocalRegion : public RegionInternal {
   virtual GfErrType putAllNoThrow(
       const HashMapOfCacheable& map,
       uint32_t timeout = DEFAULT_RESPONSE_TIMEOUT,
-      const UserDataPtr& aCallbackArgument = NULLPTR);
+      const UserDataPtr& aCallbackArgument = nullptr);
   virtual GfErrType removeAllNoThrow(
       const VectorOfCacheableKey& keys,
-      const UserDataPtr& aCallbackArgument = NULLPTR);
+      const UserDataPtr& aCallbackArgument = nullptr);
   virtual GfErrType invalidateNoThrow(const CacheableKeyPtr& keyPtr,
                                       const UserDataPtr& aCallbackArgument,
                                       int updateCount,
@@ -292,7 +297,7 @@ class CPPCACHE_EXPORT LocalRegion : public RegionInternal {
                      const CacheablePtr& valuePtr, CacheablePtr& oldValue,
                      bool cachingEnabled, int updateCount, int destroyTracker,
                      VersionTagPtr versionTag, DataInput* delta = NULL,
-                     EventIdPtr eventId = NULLPTR);
+                     EventIdPtr eventId = nullptr);
   GfErrType invalidateLocal(const char* name, const CacheableKeyPtr& keyPtr,
                             const CacheablePtr& value,
                             const CacheEventFlags eventFlags,
@@ -315,7 +320,7 @@ class CPPCACHE_EXPORT LocalRegion : public RegionInternal {
   RegionStats* getRegionStats() { return m_regionStats; }
   inline bool cacheEnabled() { return m_regionAttributes->getCachingEnabled(); }
   inline bool cachelessWithListener() {
-    return !m_regionAttributes->getCachingEnabled() && (m_listener != NULLPTR);
+    return !m_regionAttributes->getCachingEnabled() && (m_listener != nullptr);
   }
   virtual bool isDestroyed() const { return m_destroyPending; }
   /* above public methods are inherited from RegionInternal */
@@ -329,7 +334,7 @@ class CPPCACHE_EXPORT LocalRegion : public RegionInternal {
   virtual void adjustCacheWriter(const CacheWriterPtr& aWriter);
   virtual void adjustCacheWriter(const char* libpath,
                                  const char* factoryFuncName);
-  virtual CacheImpl* getCacheImpl();
+  virtual CacheImpl* getCacheImpl() const;
   virtual void evict(int32_t percentage);
 
   virtual void acquireGlobals(bool isFailover){};
@@ -408,7 +413,7 @@ class CPPCACHE_EXPORT LocalRegion : public RegionInternal {
                           CacheablePtr& oldValue, int updateCount,
                           const CacheEventFlags eventFlags,
                           VersionTagPtr versionTag, DataInput* delta = NULL,
-                          EventIdPtr eventId = NULLPTR);
+                          EventIdPtr eventId = nullptr);
 
   template <typename TAction>
   GfErrType updateNoThrowTX(const CacheableKeyPtr& key,
@@ -417,7 +422,7 @@ class CPPCACHE_EXPORT LocalRegion : public RegionInternal {
                             CacheablePtr& oldValue, int updateCount,
                             const CacheEventFlags eventFlags,
                             VersionTagPtr versionTag, DataInput* delta = NULL,
-                            EventIdPtr eventId = NULLPTR);
+                            EventIdPtr eventId = nullptr);
 
   /* protected attributes */
   std::string m_name;

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/cppcache/src/MapEntry.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/MapEntry.cpp b/src/cppcache/src/MapEntry.cpp
index 98e5ba0..4222c80 100644
--- a/src/cppcache/src/MapEntry.cpp
+++ b/src/cppcache/src/MapEntry.cpp
@@ -20,7 +20,7 @@
 using namespace apache::geode::client;
 
 EntryFactory* EntryFactory::singleton = NULL;
-MapEntryPtr MapEntry::MapEntry_NullPointer(NULLPTR);
+MapEntryPtr MapEntry::MapEntry_NullPointer(nullptr);
 
 /**
  * @brief called when library is initialized... see CppCacheLibrary.

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/cppcache/src/MapEntry.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/MapEntry.hpp b/src/cppcache/src/MapEntry.hpp
index 4e05652..e177298 100644
--- a/src/cppcache/src/MapEntry.hpp
+++ b/src/cppcache/src/MapEntry.hpp
@@ -112,7 +112,7 @@ class CPPCACHE_EXPORT MapEntry : public SharedBase {
   virtual void getKey(CacheableKeyPtr& result) const = 0;
   virtual void getValue(CacheablePtr& result) const = 0;
   virtual void setValue(const CacheablePtr& value) = 0;
-  virtual MapEntryImpl* getImplPtr() = 0;
+  virtual MapEntryImplPtr getImplPtr() = 0;
 
   virtual LRUEntryProperties& getLRUProperties() = 0;
   virtual ExpEntryProperties& getExpProperties() = 0;
@@ -185,16 +185,17 @@ class CPPCACHE_EXPORT MapEntry : public SharedBase {
  * @brief Hold region mapped entry value. subclass will hold lru flags.
  * Another holds expiration timestamps.
  */
-class MapEntryImpl : public MapEntry {
+class MapEntryImpl : public MapEntry,
+                     public std::enable_shared_from_this<MapEntryImpl> {
  public:
   virtual ~MapEntryImpl() {}
 
   inline void getKeyI(CacheableKeyPtr& result) const { result = m_key; }
 
   inline void getValueI(CacheablePtr& result) const {
-    // If value is destroyed, then this returns NULLPTR
+    // If value is destroyed, then this returns nullptr
     if (CacheableToken::isDestroyed(m_value)) {
-      result = NULLPTR;
+      result = nullptr;
     } else {
       result = m_value;
     }
@@ -208,7 +209,7 @@ class MapEntryImpl : public MapEntry {
 
   virtual void setValue(const CacheablePtr& value) { setValueI(value); }
 
-  virtual MapEntryImpl* getImplPtr() { return this; }
+  virtual MapEntryImplPtr getImplPtr() { return shared_from_this(); }
 
   virtual LRUEntryProperties& getLRUProperties() {
     throw FatalInternalException(
@@ -231,7 +232,7 @@ class MapEntryImpl : public MapEntry {
 
  protected:
   inline explicit MapEntryImpl(bool noInit)
-      : MapEntry(true), m_value(true), m_key(true) {}
+      : MapEntry(true), m_value(nullptr), m_key(nullptr) {}
 
   inline MapEntryImpl(const CacheableKeyPtr& key) : MapEntry(), m_key(key) {}
 

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/cppcache/src/MapEntryT.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/MapEntryT.hpp b/src/cppcache/src/MapEntryT.hpp
index 474abdc..86db403 100644
--- a/src/cppcache/src/MapEntryT.hpp
+++ b/src/cppcache/src/MapEntryT.hpp
@@ -112,10 +112,8 @@ class MapEntryT : public TBase {
 
   virtual int getUpdateCount() const { return UPDATE_COUNT; }
 
-  inline static MapEntryT* create(const CacheableKeyPtr& key) {
-    MapEntryT* entry;
-    GF_NEW(entry, MapEntryT(key));
-    return entry;
+  inline static std::shared_ptr<MapEntryT> create(const CacheableKeyPtr& key) {
+    return std::make_shared<MapEntryT>(key);
   }
 
  protected:
@@ -125,6 +123,8 @@ class MapEntryT : public TBase {
   // disabled
   MapEntryT(const MapEntryT&);
   MapEntryT& operator=(const MapEntryT&);
+
+  FRIEND_STD_SHARED_PTR(MapEntryT)
 };
 
 // specialization of MapEntryT to terminate the recursive template definition
@@ -148,7 +148,8 @@ class MapEntryT<TBase, NUM_TRACKERS, GF_UPDATE_MAX> : public TBase {
 
   virtual int incrementUpdateCount(MapEntryPtr& newEntry) {
     // fallback to TrackedMapEntry
-    GF_NEW(newEntry, TrackedMapEntry(this, NUM_TRACKERS, GF_UPDATE_MAX + 1));
+    newEntry = std::make_shared<TrackedMapEntry>(
+        this->shared_from_this(), NUM_TRACKERS, GF_UPDATE_MAX + 1);
     return (GF_UPDATE_MAX + 1);
   }
 
@@ -173,7 +174,8 @@ class MapEntryT<TBase, GF_TRACK_MAX, UPDATE_COUNT> : public TBase {
 
   virtual int addTracker(MapEntryPtr& newEntry) {
     // fallback to TrackedMapEntry
-    GF_NEW(newEntry, TrackedMapEntry(this, GF_TRACK_MAX + 1, UPDATE_COUNT));
+    newEntry = std::make_shared<TrackedMapEntry>(
+        this->shared_from_this(), GF_TRACK_MAX + 1, UPDATE_COUNT);
     return UPDATE_COUNT;
   }
 
@@ -208,7 +210,8 @@ class MapEntryT<TBase, GF_TRACK_MAX, GF_UPDATE_MAX> : public TBase {
 
   virtual int addTracker(MapEntryPtr& newEntry) {
     // fallback to TrackedMapEntry
-    GF_NEW(newEntry, TrackedMapEntry(this, GF_TRACK_MAX + 1, GF_UPDATE_MAX));
+    newEntry = std::make_shared<TrackedMapEntry>(
+        this->shared_from_this(), GF_TRACK_MAX + 1, GF_UPDATE_MAX);
     return GF_UPDATE_MAX;
   }
 
@@ -220,7 +223,8 @@ class MapEntryT<TBase, GF_TRACK_MAX, GF_UPDATE_MAX> : public TBase {
 
   virtual int incrementUpdateCount(MapEntryPtr& newEntry) {
     // fallback to TrackedMapEntry
-    GF_NEW(newEntry, TrackedMapEntry(this, GF_TRACK_MAX, GF_UPDATE_MAX + 1));
+    newEntry = std::make_shared<TrackedMapEntry>(
+        this->shared_from_this(), GF_TRACK_MAX, GF_UPDATE_MAX + 1);
     return (GF_UPDATE_MAX + 1);
   }
 


Mime
View raw message