geode-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From jbarr...@apache.org
Subject [28/46] geode-native git commit: GEODE-2741: Remove custom shared pointer from cppcache
Date Wed, 17 May 2017 17:50:10 GMT
http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/clicache/src/Region.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/Region.cpp b/src/clicache/src/Region.cpp
index 917f182..6100412 100644
--- a/src/clicache/src/Region.cpp
+++ b/src/clicache/src/Region.cpp
@@ -51,7 +51,7 @@ namespace Apache
         apache::geode::client::UserDataPtr callbackptr(
           Serializable::GetUnmanagedValueGeneric<Object^>(callbackArg));
         apache::geode::client::CacheablePtr nativeptr(this->get(keyptr, callbackptr));
-        if (nativeptr == NULLPTR)
+        if (nativeptr == nullptr)
         {
           throw gcnew KeyNotFoundException("The given key was not present in the region.");
         }
@@ -111,7 +111,7 @@ namespace Apache
       {
         apache::geode::client::CacheableKeyPtr keyptr(Serializable::GetUnmanagedValueGeneric<TKey>(key));
         apache::geode::client::CacheablePtr nativeptr(this->get(keyptr));
-        if (nativeptr == NULLPTR)
+        if (nativeptr == nullptr)
         {
           throw gcnew KeyNotFoundException("The given key was not present in the region.");
         }
@@ -184,15 +184,15 @@ namespace Apache
       generic<class TKey, class TValue>
       bool Region<TKey, TValue>::AreValuesEqual(apache::geode::client::CacheablePtr& val1, apache::geode::client::CacheablePtr& val2)
       {
-        if (val1 == NULLPTR && val2 == NULLPTR)
+        if (val1 == nullptr && val2 == nullptr)
         {
           return true;
         }
-        else if ((val1 == NULLPTR && val2 != NULLPTR) || (val1 != NULLPTR && val2 == NULLPTR))
+        else if ((val1 == nullptr && val2 != nullptr) || (val1 != nullptr && val2 == nullptr))
         {
           return false;
         }
-        else if (val1 != NULLPTR && val2 != NULLPTR)
+        else if (val1 != nullptr && val2 != nullptr)
         {
           if (val1->classId() != val2->classId() || val1->typeId() != val2->typeId())
           {
@@ -221,7 +221,7 @@ namespace Apache
         apache::geode::client::CacheableKeyPtr keyptr(Serializable::GetUnmanagedValueGeneric<TKey>(keyValuePair.Key));
         apache::geode::client::CacheablePtr nativeptr(this->get(keyptr));
         //This means that key is not present.
-        if (nativeptr == NULLPTR) {
+        if (nativeptr == nullptr) {
           return false;
         }
         TValue value = Serializable::GetManagedValueGeneric<TValue>(nativeptr);
@@ -246,7 +246,7 @@ namespace Apache
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
           apache::geode::client::CacheableKeyPtr keyptr(Serializable::GetUnmanagedValueGeneric<TKey>(key));
         apache::geode::client::CacheablePtr nativeptr(this->get(keyptr));
-        if (nativeptr == NULLPTR) {
+        if (nativeptr == nullptr) {
           val = TValue();
           return false;
         }
@@ -540,11 +540,11 @@ namespace Apache
               Serializable::GetUnmanagedValueGeneric<TKey>(item));
           }
 
-          apache::geode::client::HashMapOfCacheablePtr valuesPtr(NULLPTR);
+          apache::geode::client::HashMapOfCacheablePtr valuesPtr(nullptr);
           if (values != nullptr) {
             valuesPtr = new apache::geode::client::HashMapOfCacheable();
           }
-          apache::geode::client::HashMapOfExceptionPtr exceptionsPtr(NULLPTR);
+          apache::geode::client::HashMapOfExceptionPtr exceptionsPtr(nullptr);
           if (exceptions != nullptr) {
             exceptionsPtr = new apache::geode::client::HashMapOfException();
           }
@@ -591,11 +591,11 @@ namespace Apache
               Serializable::GetUnmanagedValueGeneric<TKey>(item));
           }
 
-          apache::geode::client::HashMapOfCacheablePtr valuesPtr(NULLPTR);
+          apache::geode::client::HashMapOfCacheablePtr valuesPtr(nullptr);
           if (values != nullptr) {
             valuesPtr = new apache::geode::client::HashMapOfCacheable();
           }
-          apache::geode::client::HashMapOfExceptionPtr exceptionsPtr(NULLPTR);
+          apache::geode::client::HashMapOfExceptionPtr exceptionsPtr(nullptr);
           if (exceptions != nullptr) {
             exceptionsPtr = new apache::geode::client::HashMapOfException();
           }
@@ -677,7 +677,7 @@ namespace Apache
 
           apache::geode::client::RegionPtr& nativeptr(NativePtr->getParentRegion());
 
-        return Region::Create(nativeptr.ptr());
+        return Region::Create(nativeptr.get());
 
         _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
       }
@@ -689,7 +689,7 @@ namespace Apache
 
           apache::geode::client::RegionAttributesPtr& nativeptr(NativePtr->getAttributes());
 
-        return Apache::Geode::Client::RegionAttributes<TKey, TValue>::Create(nativeptr.ptr());
+        return Apache::Geode::Client::RegionAttributes<TKey, TValue>::Create(nativeptr.get());
 
         _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
       }
@@ -702,7 +702,7 @@ namespace Apache
           apache::geode::client::AttributesMutatorPtr& nativeptr(
           NativePtr->getAttributesMutator());
 
-        return Apache::Geode::Client::AttributesMutator<TKey, TValue>::Create(nativeptr.ptr());
+        return Apache::Geode::Client::AttributesMutator<TKey, TValue>::Create(nativeptr.get());
 
         _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
       }
@@ -713,7 +713,7 @@ namespace Apache
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
           apache::geode::client::CacheStatisticsPtr& nativeptr(NativePtr->getStatistics());
-        return Apache::Geode::Client::CacheStatistics::Create(nativeptr.ptr());
+        return Apache::Geode::Client::CacheStatistics::Create(nativeptr.get());
 
         _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
       }
@@ -726,7 +726,7 @@ namespace Apache
           ManagedString mg_path(path);
         apache::geode::client::RegionPtr& nativeptr(
           NativePtr->getSubregion(mg_path.CharPtr));
-        return Region::Create(nativeptr.ptr());
+        return Region::Create(nativeptr.get());
 
         _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
       }
@@ -743,8 +743,8 @@ namespace Apache
           GetNativePtrFromSBWrapGeneric<apache::geode::client::RegionAttributes>(attributes));
 
         apache::geode::client::RegionPtr& nativeptr(NativePtr->createSubregion(
-          mg_subregionName.CharPtr, p_attrs /*NULLPTR*/));
-        return Region::Create(nativeptr.ptr());
+          mg_subregionName.CharPtr, p_attrs /*nullptr*/));
+        return Region::Create(nativeptr.get());
 
         _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
 
@@ -763,7 +763,7 @@ namespace Apache
         for (System::Int32 index = 0; index < vsr.size(); index++)
         {
           apache::geode::client::RegionPtr& nativeptr(vsr[index]);
-          subRegions[index] = Region<TKey, TValue>::Create(nativeptr.ptr());
+          subRegions[index] = Region<TKey, TValue>::Create(nativeptr.get());
         }
         System::Collections::Generic::ICollection<IRegion<TKey, TValue>^>^ collection =
           (System::Collections::Generic::ICollection<IRegion<TKey, TValue>^>^)subRegions;
@@ -779,7 +779,7 @@ namespace Apache
 
           apache::geode::client::CacheableKeyPtr keyptr(Serializable::GetUnmanagedValueGeneric<TKey>(key));
         apache::geode::client::RegionEntryPtr& nativeptr(NativePtr->getEntry(keyptr));
-        return RegionEntry<TKey, TValue>::Create(nativeptr.ptr());
+        return RegionEntry<TKey, TValue>::Create(nativeptr.get());
 
         _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
       }
@@ -796,7 +796,7 @@ namespace Apache
         for (System::Int32 index = 0; index < vc.size(); index++)
         {
           apache::geode::client::RegionEntryPtr& nativeptr(vc[index]);
-          entryarr[index] = RegionEntry<TKey, TValue>::Create(nativeptr.ptr());
+          entryarr[index] = RegionEntry<TKey, TValue>::Create(nativeptr.get());
         }
         System::Collections::Generic::ICollection<RegionEntry<TKey, TValue>^>^ collection =
           (System::Collections::Generic::ICollection<RegionEntry<TKey, TValue>^>^)entryarr;
@@ -814,15 +814,15 @@ namespace Apache
 
           apache::geode::client::RegionServicePtr& nativeptr(NativePtr->getRegionService());
 
-        apache::geode::client::Cache* realCache = dynamic_cast<apache::geode::client::Cache*>(nativeptr.ptr());
+        apache::geode::client::Cache* realCache = dynamic_cast<apache::geode::client::Cache*>(nativeptr.get());
 
         if (realCache != NULL)
         {
-          return Apache::Geode::Client::Cache::Create(((apache::geode::client::CachePtr)nativeptr).ptr());
+          return Apache::Geode::Client::Cache::Create(((apache::geode::client::CachePtr)nativeptr).get());
         }
         else
         {
-          return Apache::Geode::Client::AuthenticatedCache::Create(nativeptr.ptr());
+          return Apache::Geode::Client::AuthenticatedCache::Create(nativeptr.get());
         }
 
         _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
@@ -989,8 +989,7 @@ namespace Apache
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
           if (resultKeys != nullptr) {
-            apache::geode::client::VectorOfCacheableKeyPtr mg_keys(
-              new apache::geode::client::VectorOfCacheableKey());
+            auto mg_keys = std::make_shared<apache::geode::client::VectorOfCacheableKey>();
 
             NativePtr->registerAllKeys(isDurable, mg_keys, getInitialValues, receiveValues);
 
@@ -1000,7 +999,7 @@ namespace Apache
             }
           }
           else {
-            NativePtr->registerAllKeys(isDurable, NULLPTR, getInitialValues, receiveValues);
+            NativePtr->registerAllKeys(isDurable, nullptr, getInitialValues, receiveValues);
           }
 
           _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
@@ -1097,8 +1096,7 @@ namespace Apache
 
           ManagedString mg_regex(regex);
         if (resultKeys != nullptr) {
-          apache::geode::client::VectorOfCacheableKeyPtr mg_keys(
-            new apache::geode::client::VectorOfCacheableKey());
+          auto mg_keys = std::make_shared<apache::geode::client::VectorOfCacheableKey>();
           NativePtr->registerRegex(mg_regex.CharPtr, isDurable,
                                     mg_keys, getInitialValues, receiveValues);
 
@@ -1109,7 +1107,7 @@ namespace Apache
         }
         else {
           NativePtr->registerRegex(mg_regex.CharPtr, isDurable,
-                                    NULLPTR, getInitialValues, receiveValues);
+                                    nullptr, getInitialValues, receiveValues);
         }
 
         _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
@@ -1138,14 +1136,14 @@ namespace Apache
 
           apache::geode::client::SelectResultsPtr& nativeptr = NativePtr->query(
           mg_predicate.CharPtr, DEFAULT_QUERY_RESPONSE_TIMEOUT);
-        if (nativeptr.ptr() == NULL) return nullptr;
+        if (nativeptr.get() == NULL) return nullptr;
 
         apache::geode::client::ResultSet* resultptr = dynamic_cast<apache::geode::client::ResultSet*>(
-          nativeptr.ptr());
+          nativeptr.get());
         if (resultptr == NULL)
         {
           apache::geode::client::StructSet* structptr = dynamic_cast<apache::geode::client::StructSet*>(
-            nativeptr.ptr());
+            nativeptr.get());
           if (structptr == NULL)
           {
             return nullptr;
@@ -1170,14 +1168,14 @@ namespace Apache
 
           apache::geode::client::SelectResultsPtr& nativeptr = NativePtr->query(
           mg_predicate.CharPtr, timeout);
-        if (nativeptr.ptr() == NULL) return nullptr;
+        if (nativeptr.get() == NULL) return nullptr;
 
         apache::geode::client::ResultSet* resultptr = dynamic_cast<apache::geode::client::ResultSet*>(
-          nativeptr.ptr());
+          nativeptr.get());
         if (resultptr == NULL)
         {
           apache::geode::client::StructSet* structptr = dynamic_cast<apache::geode::client::StructSet*>(
-            nativeptr.ptr());
+            nativeptr.get());
           if (structptr == NULL)
           {
             return nullptr;

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/clicache/src/RegionAttributes.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/RegionAttributes.cpp b/src/clicache/src/RegionAttributes.cpp
index 558dc7c..fe4d12b 100644
--- a/src/clicache/src/RegionAttributes.cpp
+++ b/src/clicache/src/RegionAttributes.cpp
@@ -353,7 +353,7 @@ namespace Apache
       {
         apache::geode::client::PropertiesPtr& nativeptr(
           NativePtr->getPersistenceProperties());
-        return Properties<String^, String^>::Create<String^, String^>(nativeptr.ptr());
+        return Properties<String^, String^>::Create<String^, String^>(nativeptr.get());
       }
     }  // namespace Client
   }  // namespace Geode

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/clicache/src/RegionFactory.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/RegionFactory.cpp b/src/clicache/src/RegionFactory.cpp
index 08f2e2d..93a5e7a 100644
--- a/src/clicache/src/RegionFactory.cpp
+++ b/src/clicache/src/RegionFactory.cpp
@@ -135,7 +135,7 @@ namespace Apache
           PersistenceManagerGeneric<TKey, TValue>^ clg = gcnew PersistenceManagerGeneric<TKey, TValue>();
           clg->SetPersistenceManager(persistenceManager);
           persistenceManagerptr = new apache::geode::client::ManagedPersistenceManagerGeneric( /*clg,*/ persistenceManager);
-          ((apache::geode::client::ManagedPersistenceManagerGeneric*)persistenceManagerptr.ptr())->setptr(clg);
+          ((apache::geode::client::ManagedPersistenceManagerGeneric*)persistenceManagerptr.get())->setptr(clg);
         }
         apache::geode::client::PropertiesPtr configptr(GetNativePtr<apache::geode::client::Properties>( config ) );
         NativePtr->setPersistenceManager( persistenceManagerptr, configptr );
@@ -263,7 +263,7 @@ namespace Apache
           CacheLoaderGeneric<TKey, TValue>^ clg = gcnew CacheLoaderGeneric<TKey, TValue>();
           clg->SetCacheLoader(cacheLoader);
           loaderptr = new apache::geode::client::ManagedCacheLoaderGeneric( /*clg,*/ cacheLoader );
-          ((apache::geode::client::ManagedCacheLoaderGeneric*)loaderptr.ptr())->setptr(clg);
+          ((apache::geode::client::ManagedCacheLoaderGeneric*)loaderptr.get())->setptr(clg);
         }
         NativePtr->setCacheLoader( loaderptr );
         return this;
@@ -277,7 +277,7 @@ namespace Apache
           CacheWriterGeneric<TKey, TValue>^ cwg = gcnew CacheWriterGeneric<TKey, TValue>();
           cwg->SetCacheWriter(cacheWriter);
           writerptr = new apache::geode::client::ManagedCacheWriterGeneric( /*cwg,*/ cacheWriter );
-          ((apache::geode::client::ManagedCacheWriterGeneric*)writerptr.ptr())->setptr(cwg);
+          ((apache::geode::client::ManagedCacheWriterGeneric*)writerptr.get())->setptr(cwg);
         }
         NativePtr->setCacheWriter( writerptr );
         return this;
@@ -291,7 +291,7 @@ namespace Apache
           CacheListenerGeneric<TKey, TValue>^ clg = gcnew CacheListenerGeneric<TKey, TValue>();
           clg->SetCacheListener(cacheListener);
           listenerptr = new apache::geode::client::ManagedCacheListenerGeneric( /*clg,*/ cacheListener );
-          ((apache::geode::client::ManagedCacheListenerGeneric*)listenerptr.ptr())->setptr(clg);
+          ((apache::geode::client::ManagedCacheListenerGeneric*)listenerptr.get())->setptr(clg);
           /*
           listenerptr = new apache::geode::client::ManagedCacheListenerGeneric(
             (Client::ICacheListener<Object^, Object^>^)cacheListener);
@@ -312,13 +312,13 @@ namespace Apache
             FixedPartitionResolverGeneric<TKey, TValue>^ prg = gcnew FixedPartitionResolverGeneric<TKey, TValue>();
             prg->SetPartitionResolver(resolver);
             resolverptr = new apache::geode::client::ManagedFixedPartitionResolverGeneric( resolver ); 
-            ((apache::geode::client::ManagedFixedPartitionResolverGeneric*)resolverptr.ptr())->setptr(prg);
+            ((apache::geode::client::ManagedFixedPartitionResolverGeneric*)resolverptr.get())->setptr(prg);
           }
           else {            
             PartitionResolverGeneric<TKey, TValue>^ prg = gcnew PartitionResolverGeneric<TKey, TValue>();
             prg->SetPartitionResolver(partitionresolver);
             resolverptr = new apache::geode::client::ManagedPartitionResolverGeneric( partitionresolver );
-            ((apache::geode::client::ManagedPartitionResolverGeneric*)resolverptr.ptr())->setptr(prg);            
+            ((apache::geode::client::ManagedPartitionResolverGeneric*)resolverptr.get())->setptr(prg);            
           }         
         }
         NativePtr->setPartitionResolver( resolverptr );

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/clicache/src/ResultCollector.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/ResultCollector.cpp b/src/clicache/src/ResultCollector.cpp
index c5d8bf1..13220eb 100644
--- a/src/clicache/src/ResultCollector.cpp
+++ b/src/clicache/src/ResultCollector.cpp
@@ -37,7 +37,7 @@ namespace Apache
         _GF_MG_EXCEPTION_TRY2/* due to auto replace */
 
           apache::geode::client::Serializable * result = SafeGenericMSerializableConvert((IGeodeSerializable^)rs);
-        NativePtr->addResult( result==NULL ? (NULLPTR) : (apache::geode::client::CacheablePtr(result)) );
+        NativePtr->addResult( result==NULL ? (nullptr) : (apache::geode::client::CacheablePtr(result)) );
 
         _GF_MG_EXCEPTION_CATCH_ALL2/* due to auto replace */
       }

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/clicache/src/ResultSet.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/ResultSet.cpp b/src/clicache/src/ResultSet.cpp
index 9ddcf6f..d3a83e7 100644
--- a/src/clicache/src/ResultSet.cpp
+++ b/src/clicache/src/ResultSet.cpp
@@ -46,7 +46,7 @@ namespace Apache
       generic<class TResult>
       /*IGeodeSerializable^*/TResult ResultSet<TResult>::default::get( size_t index )
       {
-          //return SafeUMSerializableConvertGeneric(NativePtr->operator[](static_cast<System::Int32>(index)).ptr());
+          //return SafeUMSerializableConvertGeneric(NativePtr->operator[](static_cast<System::Int32>(index)).get());
            return (Serializable::GetManagedValueGeneric<TResult>(NativePtr->operator[](static_cast<System::Int32>(index))));
       }
 

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/clicache/src/Serializable.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/Serializable.cpp b/src/clicache/src/Serializable.cpp
index 0d27fbb..a6ca57c 100644
--- a/src/clicache/src/Serializable.cpp
+++ b/src/clicache/src/Serializable.cpp
@@ -227,7 +227,7 @@ namespace Apache
       IGeodeSerializable^ Serializable::GetPDXTypeById(const char* poolName, System::Int32 typeId)
       {
         SerializablePtr sPtr = apache::geode::client::SerializationRegistry::GetPDXTypeById(poolName, typeId);
-        return SafeUMSerializableConvertGeneric(sPtr.ptr());
+        return SafeUMSerializableConvertGeneric(sPtr.get());
       }
 
       int Serializable::GetEnumValue(Internal::EnumInfo^ ei)
@@ -239,7 +239,7 @@ namespace Apache
       Internal::EnumInfo^ Serializable::GetEnum(int val)
       {
         SerializablePtr sPtr = apache::geode::client::SerializationRegistry::GetEnum(val);
-        return (Internal::EnumInfo^)SafeUMSerializableConvertGeneric(sPtr.ptr());
+        return (Internal::EnumInfo^)SafeUMSerializableConvertGeneric(sPtr.get());
       }
 
       void Serializable::RegisterPdxType(PdxTypeFactoryMethod^ creationMethod)
@@ -611,7 +611,7 @@ namespace Apache
       generic<class TValue>
         TValue Serializable::GetManagedValueGeneric(apache::geode::client::SerializablePtr val)
         {
-          if (val == NULLPTR)
+          if (val == nullptr)
           {
             return TValue();
           }
@@ -689,7 +689,7 @@ namespace Apache
           {
             //TODO::
             Apache::Geode::Client::CacheableDate^ ret = static_cast<Apache::Geode::Client::CacheableDate ^>
-              (SafeGenericUMSerializableConvert<Apache::Geode::Client::CacheableDate^>(val.ptr()));
+              (SafeGenericUMSerializableConvert<Apache::Geode::Client::CacheableDate^>(val.get()));
 
             System::DateTime dt(ret->Value.Ticks);
             return safe_cast<TValue>(dt);
@@ -699,13 +699,13 @@ namespace Apache
           case apache::geode::client::GeodeTypeIdsImpl::CacheableUserData4:
           {
             //TODO::split 
-            IGeodeSerializable^ ret = SafeUMSerializableConvertGeneric(val.ptr());
+            IGeodeSerializable^ ret = SafeUMSerializableConvertGeneric(val.get());
             return safe_cast<TValue>(ret);
             //return TValue();
           }
           case apache::geode::client::GeodeTypeIdsImpl::PDX:
           {
-            IPdxSerializable^ ret = SafeUMSerializablePDXConvert(val.ptr());
+            IPdxSerializable^ ret = SafeUMSerializablePDXConvert(val.get());
 
             PdxWrapper^ pdxWrapper = dynamic_cast<PdxWrapper^>(ret);
 
@@ -719,49 +719,49 @@ namespace Apache
           case apache::geode::client::GeodeTypeIds::CacheableBytes:
           {
             Apache::Geode::Client::CacheableBytes^ ret = safe_cast<Apache::Geode::Client::CacheableBytes ^>
-              (SafeGenericUMSerializableConvert<Apache::Geode::Client::CacheableBytes^>(val.ptr()));
+              (SafeGenericUMSerializableConvert<Apache::Geode::Client::CacheableBytes^>(val.get()));
 
             return safe_cast<TValue>(ret->Value);
           }
           case apache::geode::client::GeodeTypeIds::CacheableDoubleArray:
           {
             Apache::Geode::Client::CacheableDoubleArray^ ret = safe_cast<Apache::Geode::Client::CacheableDoubleArray ^>
-              (SafeGenericUMSerializableConvert<Apache::Geode::Client::CacheableDoubleArray^>(val.ptr()));
+              (SafeGenericUMSerializableConvert<Apache::Geode::Client::CacheableDoubleArray^>(val.get()));
 
             return safe_cast<TValue>(ret->Value);
           }
           case apache::geode::client::GeodeTypeIds::CacheableFloatArray:
           {
             Apache::Geode::Client::CacheableFloatArray^ ret = safe_cast<Apache::Geode::Client::CacheableFloatArray^>
-              (SafeGenericUMSerializableConvert<Apache::Geode::Client::CacheableFloatArray^>(val.ptr()));
+              (SafeGenericUMSerializableConvert<Apache::Geode::Client::CacheableFloatArray^>(val.get()));
 
             return safe_cast<TValue>(ret->Value);
           }
           case apache::geode::client::GeodeTypeIds::CacheableInt16Array:
           {
             Apache::Geode::Client::CacheableInt16Array^ ret = safe_cast<Apache::Geode::Client::CacheableInt16Array^>
-              (SafeGenericUMSerializableConvert<Apache::Geode::Client::CacheableInt16Array^>(val.ptr()));
+              (SafeGenericUMSerializableConvert<Apache::Geode::Client::CacheableInt16Array^>(val.get()));
 
             return safe_cast<TValue>(ret->Value);
           }
           case apache::geode::client::GeodeTypeIds::CacheableInt32Array:
           {
             Apache::Geode::Client::CacheableInt32Array^ ret = safe_cast<Apache::Geode::Client::CacheableInt32Array^>
-              (SafeGenericUMSerializableConvert<Apache::Geode::Client::CacheableInt32Array^>(val.ptr()));
+              (SafeGenericUMSerializableConvert<Apache::Geode::Client::CacheableInt32Array^>(val.get()));
 
             return safe_cast<TValue>(ret->Value);
           }
           case apache::geode::client::GeodeTypeIds::CacheableInt64Array:
           {
             Apache::Geode::Client::CacheableInt64Array^ ret = safe_cast<Apache::Geode::Client::CacheableInt64Array^>
-              (SafeGenericUMSerializableConvert<Apache::Geode::Client::CacheableInt64Array^>(val.ptr()));
+              (SafeGenericUMSerializableConvert<Apache::Geode::Client::CacheableInt64Array^>(val.get()));
 
             return safe_cast<TValue>(ret->Value);
           }
           case apache::geode::client::GeodeTypeIds::CacheableStringArray:
           {
             Apache::Geode::Client::CacheableStringArray^ ret = safe_cast<Apache::Geode::Client::CacheableStringArray^>
-              (SafeGenericUMSerializableConvert<Apache::Geode::Client::CacheableStringArray^>(val.ptr()));
+              (SafeGenericUMSerializableConvert<Apache::Geode::Client::CacheableStringArray^>(val.get()));
 
             /* array<String^>^ str = gcnew array<String^>(ret->GetValues()->Length);
              for(int i=0; i<ret->GetValues()->Length; i++ ) {
@@ -773,100 +773,100 @@ namespace Apache
           case apache::geode::client::GeodeTypeIds::CacheableArrayList://Ilist generic
           {
             Apache::Geode::Client::CacheableArrayList^ ret = safe_cast<Apache::Geode::Client::CacheableArrayList^>
-              (SafeGenericUMSerializableConvert<Apache::Geode::Client::CacheableArrayList^>(val.ptr()));
+              (SafeGenericUMSerializableConvert<Apache::Geode::Client::CacheableArrayList^>(val.get()));
 
             return safe_cast<TValue>(ret->Value);
           }
           case apache::geode::client::GeodeTypeIds::CacheableLinkedList://LinkedList generic
           {
             Apache::Geode::Client::CacheableLinkedList^ ret = safe_cast<Apache::Geode::Client::CacheableLinkedList^>
-              (SafeGenericUMSerializableConvert<Apache::Geode::Client::CacheableLinkedList^>(val.ptr()));
+              (SafeGenericUMSerializableConvert<Apache::Geode::Client::CacheableLinkedList^>(val.get()));
 
             return safe_cast<TValue>(ret->Value);
           }
           case apache::geode::client::GeodeTypeIds::CacheableHashTable://collection::hashtable
           {
             Apache::Geode::Client::CacheableHashTable^ ret = safe_cast<Apache::Geode::Client::CacheableHashTable^>
-              (SafeGenericUMSerializableConvert<Apache::Geode::Client::CacheableHashTable^>(val.ptr()));
+              (SafeGenericUMSerializableConvert<Apache::Geode::Client::CacheableHashTable^>(val.get()));
 
             return safe_cast<TValue>(ret->Value);
           }
           case apache::geode::client::GeodeTypeIds::CacheableHashMap://generic dictionary
           {
             Apache::Geode::Client::CacheableHashMap^ ret = safe_cast<Apache::Geode::Client::CacheableHashMap^>
-              (SafeGenericUMSerializableConvert<Apache::Geode::Client::CacheableHashMap^>(val.ptr()));
+              (SafeGenericUMSerializableConvert<Apache::Geode::Client::CacheableHashMap^>(val.get()));
 
             return safe_cast<TValue>(ret->Value);
           }
           case apache::geode::client::GeodeTypeIds::CacheableIdentityHashMap:
           {
             Apache::Geode::Client::CacheableIdentityHashMap^ ret = static_cast<Apache::Geode::Client::CacheableIdentityHashMap^>
-              (SafeGenericUMSerializableConvert<Apache::Geode::Client::CacheableIdentityHashMap^>(val.ptr()));
+              (SafeGenericUMSerializableConvert<Apache::Geode::Client::CacheableIdentityHashMap^>(val.get()));
             return safe_cast<TValue>(ret->Value);
           }
           case apache::geode::client::GeodeTypeIds::CacheableHashSet://no need of it, default case should work
           {
             Apache::Geode::Client::CacheableHashSet^ ret = static_cast<Apache::Geode::Client::CacheableHashSet^>
-              (SafeGenericUMSerializableConvert<Apache::Geode::Client::CacheableHashSet^>(val.ptr()));
+              (SafeGenericUMSerializableConvert<Apache::Geode::Client::CacheableHashSet^>(val.get()));
             return safe_cast<TValue>(ret);
           }
           case apache::geode::client::GeodeTypeIds::CacheableLinkedHashSet://no need of it, default case should work
           {
             Apache::Geode::Client::CacheableLinkedHashSet^ ret = static_cast<Apache::Geode::Client::CacheableLinkedHashSet^>
-              (SafeGenericUMSerializableConvert<Apache::Geode::Client::CacheableLinkedHashSet^>(val.ptr()));
+              (SafeGenericUMSerializableConvert<Apache::Geode::Client::CacheableLinkedHashSet^>(val.get()));
             return safe_cast<TValue>(ret);
           }
           case apache::geode::client::GeodeTypeIds::CacheableFileName:
           {
             Apache::Geode::Client::CacheableFileName^ ret = static_cast<Apache::Geode::Client::CacheableFileName^>
-              (SafeGenericUMSerializableConvert<Apache::Geode::Client::CacheableFileName^>(val.ptr()));
+              (SafeGenericUMSerializableConvert<Apache::Geode::Client::CacheableFileName^>(val.get()));
             return safe_cast<TValue>(ret);
           }
           case apache::geode::client::GeodeTypeIds::CacheableObjectArray:
           {
             Apache::Geode::Client::CacheableObjectArray^ ret = static_cast<Apache::Geode::Client::CacheableObjectArray^>
-              (SafeGenericUMSerializableConvert<Apache::Geode::Client::CacheableObjectArray^>(val.ptr()));
+              (SafeGenericUMSerializableConvert<Apache::Geode::Client::CacheableObjectArray^>(val.get()));
             return safe_cast<TValue>(ret);
           }
           case apache::geode::client::GeodeTypeIds::CacheableVector://collection::arraylist
           {
             Apache::Geode::Client::CacheableVector^ ret = static_cast<Apache::Geode::Client::CacheableVector^>
-              (SafeGenericUMSerializableConvert<Apache::Geode::Client::CacheableVector^>(val.ptr()));
+              (SafeGenericUMSerializableConvert<Apache::Geode::Client::CacheableVector^>(val.get()));
             return safe_cast<TValue>(ret->Value);
           }
           case apache::geode::client::GeodeTypeIds::CacheableUndefined:
           {
             Apache::Geode::Client::CacheableUndefined^ ret = static_cast<Apache::Geode::Client::CacheableUndefined^>
-              (SafeGenericUMSerializableConvert<Apache::Geode::Client::CacheableUndefined^>(val.ptr()));
+              (SafeGenericUMSerializableConvert<Apache::Geode::Client::CacheableUndefined^>(val.get()));
             return safe_cast<TValue>(ret);
           }
           case apache::geode::client::GeodeTypeIds::Struct:
           {
-            return safe_cast<TValue>(Apache::Geode::Client::Struct::Create(val.ptr()));
+            return safe_cast<TValue>(Apache::Geode::Client::Struct::Create(val.get()));
           }
           case apache::geode::client::GeodeTypeIds::CacheableStack:
           {
             Apache::Geode::Client::CacheableStack^ ret = static_cast<Apache::Geode::Client::CacheableStack^>
-              (SafeGenericUMSerializableConvert<Apache::Geode::Client::CacheableStack^>(val.ptr()));
+              (SafeGenericUMSerializableConvert<Apache::Geode::Client::CacheableStack^>(val.get()));
             return safe_cast<TValue>(ret->Value);
           }
           case 7: //GeodeClassIds::CacheableManagedObject
           {
             Apache::Geode::Client::CacheableObject^ ret = static_cast<Apache::Geode::Client::CacheableObject^>
-              (SafeGenericUMSerializableConvert<Apache::Geode::Client::CacheableObject^>(val.ptr()));
+              (SafeGenericUMSerializableConvert<Apache::Geode::Client::CacheableObject^>(val.get()));
             return safe_cast<TValue>(ret);
           }
           case 8://GeodeClassIds::CacheableManagedObjectXml
           {
             Apache::Geode::Client::CacheableObjectXml^ ret = static_cast<Apache::Geode::Client::CacheableObjectXml^>
-              (SafeGenericUMSerializableConvert<Apache::Geode::Client::CacheableObjectXml^>(val.ptr()));
+              (SafeGenericUMSerializableConvert<Apache::Geode::Client::CacheableObjectXml^>(val.get()));
             return safe_cast<TValue>(ret);
           }
           /*  TODO: replace with IDictionary<K, V>
         case apache::geode::client::GeodeTypeIds::Properties:
         {
         Apache::Geode::Client::Properties^ ret = safe_cast<Apache::Geode::Client::Properties^>
-        ( SafeGenericUMSerializableConvert<Apache::Geode::Client::Properties^>(val.ptr()));
+        ( SafeGenericUMSerializableConvert<Apache::Geode::Client::Properties^>(val.get()));
 
         return safe_cast<TValue>(ret);
         }*/
@@ -874,21 +874,21 @@ namespace Apache
           case apache::geode::client::GeodeTypeIds::BooleanArray:
           {
             Apache::Geode::Client::BooleanArray^ ret = safe_cast<Apache::Geode::Client::BooleanArray^>
-              (SafeGenericUMSerializableConvert<Apache::Geode::Client::BooleanArray^>(val.ptr()));
+              (SafeGenericUMSerializableConvert<Apache::Geode::Client::BooleanArray^>(val.get()));
 
             return safe_cast<TValue>(ret->Value);
           }
           case apache::geode::client::GeodeTypeIds::CharArray:
           {
             Apache::Geode::Client::CharArray^ ret = safe_cast<Apache::Geode::Client::CharArray^>
-              (SafeGenericUMSerializableConvert<Apache::Geode::Client::CharArray^>(val.ptr()));
+              (SafeGenericUMSerializableConvert<Apache::Geode::Client::CharArray^>(val.get()));
 
             return safe_cast<TValue>(ret->Value);
           }
           case 0://UserFunctionExecutionException unregistered
           {
             Apache::Geode::Client::UserFunctionExecutionException^ ret = static_cast<Apache::Geode::Client::UserFunctionExecutionException^>
-              (SafeGenericUMSerializableConvert<Apache::Geode::Client::UserFunctionExecutionException^>(val.ptr()));
+              (SafeGenericUMSerializableConvert<Apache::Geode::Client::UserFunctionExecutionException^>(val.get()));
             return safe_cast<TValue>(ret);
           }
           default:
@@ -905,7 +905,7 @@ namespace Apache
               //System::Type^ managedType = key->GetType();
               return GetUnmanagedValueGeneric(key->GetType(), key);
             }
-            return NULLPTR;
+            return nullptr;
           }
 
           generic<class TKey>
@@ -916,7 +916,7 @@ namespace Apache
                 //System::Type^ managedType = key->GetType();
                 return GetUnmanagedValueGeneric(key->GetType(), key, isAciiChar);
               }
-              return NULLPTR;
+              return nullptr;
             }
 
             void Serializable::RegisterPdxSerializer(IPdxSerializer^ pdxSerializer)
@@ -1271,7 +1271,7 @@ namespace Apache
 
                 String^ Serializable::GetString(apache::geode::client::CacheableStringPtr cStr)//apache::geode::client::CacheableString*
                 {
-                  if (cStr == NULLPTR) {
+                  if (cStr == nullptr) {
                     return nullptr;
                   }
                   else if (cStr->isWideString()) {
@@ -1287,7 +1287,7 @@ namespace Apache
                 //byte
                 Byte Serializable::getByte(apache::geode::client::SerializablePtr nativeptr)
                 {
-                  apache::geode::client::CacheableByte* ci = static_cast<apache::geode::client::CacheableByte*>(nativeptr.ptr());
+                  apache::geode::client::CacheableByte* ci = static_cast<apache::geode::client::CacheableByte*>(nativeptr.get());
                   return ci->value();
                 }
 
@@ -1299,7 +1299,7 @@ namespace Apache
                 //boolean
                 bool Serializable::getBoolean(apache::geode::client::SerializablePtr nativeptr)
                 {
-                  apache::geode::client::CacheableBoolean* ci = static_cast<apache::geode::client::CacheableBoolean*>(nativeptr.ptr());
+                  apache::geode::client::CacheableBoolean* ci = static_cast<apache::geode::client::CacheableBoolean*>(nativeptr.get());
                   return ci->value();
                 }
 
@@ -1311,7 +1311,7 @@ namespace Apache
                 //widechar
                 Char Serializable::getChar(apache::geode::client::SerializablePtr nativeptr)
                 {
-                  apache::geode::client::CacheableWideChar* ci = static_cast<apache::geode::client::CacheableWideChar*>(nativeptr.ptr());
+                  apache::geode::client::CacheableWideChar* ci = static_cast<apache::geode::client::CacheableWideChar*>(nativeptr.get());
                   return ci->value();
                 }
 
@@ -1323,7 +1323,7 @@ namespace Apache
                 //double
                 double Serializable::getDouble(apache::geode::client::SerializablePtr nativeptr)
                 {
-                  apache::geode::client::CacheableDouble* ci = static_cast<apache::geode::client::CacheableDouble*>(nativeptr.ptr());
+                  apache::geode::client::CacheableDouble* ci = static_cast<apache::geode::client::CacheableDouble*>(nativeptr.get());
                   return ci->value();
                 }
 
@@ -1335,7 +1335,7 @@ namespace Apache
                 //float
                 float Serializable::getFloat(apache::geode::client::SerializablePtr nativeptr)
                 {
-                  apache::geode::client::CacheableFloat* ci = static_cast<apache::geode::client::CacheableFloat*>(nativeptr.ptr());
+                  apache::geode::client::CacheableFloat* ci = static_cast<apache::geode::client::CacheableFloat*>(nativeptr.get());
                   return ci->value();
                 }
 
@@ -1347,7 +1347,7 @@ namespace Apache
                 //int16
                 System::Int16 Serializable::getInt16(apache::geode::client::SerializablePtr nativeptr)
                 {
-                  apache::geode::client::CacheableInt16* ci = static_cast<apache::geode::client::CacheableInt16*>(nativeptr.ptr());
+                  apache::geode::client::CacheableInt16* ci = static_cast<apache::geode::client::CacheableInt16*>(nativeptr.get());
                   return ci->value();
                 }
 
@@ -1359,7 +1359,7 @@ namespace Apache
                 //int32
                 System::Int32 Serializable::getInt32(apache::geode::client::SerializablePtr nativeptr)
                 {
-                  apache::geode::client::CacheableInt32* ci = static_cast<apache::geode::client::CacheableInt32*>(nativeptr.ptr());
+                  apache::geode::client::CacheableInt32* ci = static_cast<apache::geode::client::CacheableInt32*>(nativeptr.get());
                   return ci->value();
                 }
 
@@ -1371,7 +1371,7 @@ namespace Apache
                 //int64
                 System::Int64 Serializable::getInt64(apache::geode::client::SerializablePtr nativeptr)
                 {
-                  apache::geode::client::CacheableInt64* ci = static_cast<apache::geode::client::CacheableInt64*>(nativeptr.ptr());
+                  apache::geode::client::CacheableInt64* ci = static_cast<apache::geode::client::CacheableInt64*>(nativeptr.get());
                   return ci->value();
                 }
 
@@ -1383,7 +1383,7 @@ namespace Apache
                 //cacheable ascii string
                 String^ Serializable::getASCIIString(apache::geode::client::SerializablePtr nativeptr)
                 {
-                  //apache::geode::client::CacheableString* ci = static_cast<apache::geode::client::CacheableString*>(nativeptr.ptr());          
+                  //apache::geode::client::CacheableString* ci = static_cast<apache::geode::client::CacheableString*>(nativeptr.get());          
                   //return GetString(ci);
                   return GetString(nativeptr->toString());
                 }
@@ -1401,7 +1401,7 @@ namespace Apache
                 //cacheable ascii string huge
                 String^ Serializable::getASCIIStringHuge(apache::geode::client::SerializablePtr nativeptr)
                 {
-                  //apache::geode::client::CacheableString* ci = static_cast<apache::geode::client::CacheableString*>(nativeptr.ptr());          
+                  //apache::geode::client::CacheableString* ci = static_cast<apache::geode::client::CacheableString*>(nativeptr.get());          
                   //return GetString(ci);
                   return GetString(nativeptr->toString());
                 }
@@ -1414,7 +1414,7 @@ namespace Apache
                 //cacheable string
                 String^ Serializable::getUTFString(apache::geode::client::SerializablePtr nativeptr)
                 {
-                  //apache::geode::client::CacheableString* ci = static_cast<apache::geode::client::CacheableString*>(nativeptr.ptr());          
+                  //apache::geode::client::CacheableString* ci = static_cast<apache::geode::client::CacheableString*>(nativeptr.get());          
                   //return GetString(ci);
                   return GetString(nativeptr->toString());
                 }
@@ -1427,7 +1427,7 @@ namespace Apache
                 //cacheable string huge
                 String^ Serializable::getUTFStringHuge(apache::geode::client::SerializablePtr nativeptr)
                 {
-                  //apache::geode::client::CacheableString* ci = static_cast<apache::geode::client::CacheableString*>(nativeptr.ptr());
+                  //apache::geode::client::CacheableString* ci = static_cast<apache::geode::client::CacheableString*>(nativeptr.get());
                   //return GetString(ci);
                   return GetString(nativeptr->toString());
                 }
@@ -1476,7 +1476,7 @@ namespace Apache
                 /*
                  static String^ GetString(apache::geode::client::CacheableStringPtr cStr)//apache::geode::client::CacheableString*
                  {
-                 if (cStr == NULLPTR) {
+                 if (cStr == nullptr) {
                  return nullptr;
                  }
                  else if (cStr->isWideString()) {

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/clicache/src/Serializable.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/Serializable.hpp b/src/clicache/src/Serializable.hpp
index c7f5b44..9c5dc4d 100644
--- a/src/clicache/src/Serializable.hpp
+++ b/src/clicache/src/Serializable.hpp
@@ -390,7 +390,7 @@ namespace Apache
        /*
         static String^ GetString(apache::geode::client::CacheableStringPtr cStr)//apache::geode::client::CacheableString*
         {
-          if (cStr == NULLPTR) {
+          if (cStr == nullptr) {
             return nullptr;
           }
           else if (cStr->isWideString()) {

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/clicache/src/Struct.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/Struct.cpp b/src/clicache/src/Struct.cpp
index 297ca6a..6613ec0 100644
--- a/src/clicache/src/Struct.cpp
+++ b/src/clicache/src/Struct.cpp
@@ -34,7 +34,7 @@ namespace Apache
       Object^ Struct::default::get( size_t index )
       {
        /*   return SafeUMSerializableConvertGeneric(static_cast<apache::geode::client::Struct*>(
-            NativePtr())->operator[](static_cast<System::Int32>(index)).ptr());*/
+            NativePtr())->operator[](static_cast<System::Int32>(index)).get());*/
           return (Serializable::GetManagedValueGeneric<Object^>(static_cast<apache::geode::client::Struct*>(
             NativePtr())->operator[](static_cast<System::Int32>(index))));
       }
@@ -43,7 +43,7 @@ namespace Apache
       {
         ManagedString mg_fieldName( fieldName );
         /*return SafeUMSerializableConvertGeneric(static_cast<apache::geode::client::Struct*>(
-            NativePtr())->operator[](mg_fieldName.CharPtr).ptr());*/
+            NativePtr())->operator[](mg_fieldName.CharPtr).get());*/
 
         return (Serializable::GetManagedValueGeneric</*TResult*/Object^>(static_cast<apache::geode::client::Struct*>(
             NativePtr())->operator[](mg_fieldName.CharPtr)));
@@ -52,7 +52,7 @@ namespace Apache
       StructSet<Object^>^ Struct::Set::get( )
       {
         return StructSet</*TResult*/Object^>::Create(static_cast<apache::geode::client::Struct*>(
-          NativePtr())->getStructSet().ptr());
+          NativePtr())->getStructSet().get());
       }
 
       
@@ -69,7 +69,7 @@ namespace Apache
       Object^ Struct/*<TResult>*/::Next( )
       {
         /*return SafeUMSerializableConvertGeneric(static_cast<apache::geode::client::Struct*>(
-          NativePtr())->next().ptr());*/
+          NativePtr())->next().get());*/
         return (Serializable::GetManagedValueGeneric</*TResult*/Object^>(static_cast<apache::geode::client::Struct*>(
           NativePtr())->next()));
     }  // namespace Client

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/clicache/src/StructSet.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/StructSet.cpp b/src/clicache/src/StructSet.cpp
index 1922ffe..4810d6b 100644
--- a/src/clicache/src/StructSet.cpp
+++ b/src/clicache/src/StructSet.cpp
@@ -45,7 +45,7 @@ namespace Apache
       generic<class TResult>
       /*Apache::Geode::Client::IGeodeSerializable^*/ TResult StructSet<TResult>::default::get( size_t index )
       {
-        //return SafeUMSerializableConvertGeneric((NativePtr->operator[](static_cast<System::Int32>(index))).ptr());
+        //return SafeUMSerializableConvertGeneric((NativePtr->operator[](static_cast<System::Int32>(index))).get());
         return Serializable::GetManagedValueGeneric<TResult>((NativePtr->operator[](static_cast<System::Int32>(index))));
       }
 

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/clicache/src/impl/CacheLoader.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/impl/CacheLoader.hpp b/src/clicache/src/impl/CacheLoader.hpp
index ecb9c52..45f1506 100644
--- a/src/clicache/src/impl/CacheLoader.hpp
+++ b/src/clicache/src/impl/CacheLoader.hpp
@@ -63,7 +63,7 @@ namespace Apache
           virtual apache::geode::client::CacheablePtr load( const apache::geode::client::RegionPtr& region,
             const apache::geode::client::CacheableKeyPtr& key, const apache::geode::client::UserDataPtr& helper )
           {
-            IRegion<TKey, TValue>^ gregion = Region<TKey, TValue>::Create(region.ptr());
+            IRegion<TKey, TValue>^ gregion = Region<TKey, TValue>::Create(region.get());
 
             TKey gkey = Serializable::GetManagedValueGeneric<TKey>(key);
 
@@ -75,7 +75,7 @@ namespace Apache
 
           virtual void close( const apache::geode::client::RegionPtr& region )
           {
-            IRegion<TKey, TValue>^ gregion = Region<TKey, TValue>::Create(region.ptr());
+            IRegion<TKey, TValue>^ gregion = Region<TKey, TValue>::Create(region.get());
             m_loader->Close(gregion);
           }
       };

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/clicache/src/impl/ManagedAuthInitialize.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/impl/ManagedAuthInitialize.cpp b/src/clicache/src/impl/ManagedAuthInitialize.cpp
index 69b1a62..67fef16 100644
--- a/src/clicache/src/impl/ManagedAuthInitialize.cpp
+++ b/src/clicache/src/impl/ManagedAuthInitialize.cpp
@@ -175,7 +175,7 @@ namespace apache
       {
         try {
           Apache::Geode::Client::Properties<String^, String^>^ mprops =
-            Apache::Geode::Client::Properties<String^, String^>::Create<String^, String^>(securityprops.ptr());
+            Apache::Geode::Client::Properties<String^, String^>::Create<String^, String^>(securityprops.get());
           String^ mg_server = Apache::Geode::Client::ManagedString::Get(server);
 
           return PropertiesPtr(m_getCredentials->Invoke(mprops, mg_server)->NativePtr());
@@ -186,7 +186,7 @@ namespace apache
         catch (System::Exception^ ex) {
           Apache::Geode::Client::GeodeException::ThrowNative(ex);
         }
-        return NULLPTR;
+        return nullptr;
       }
 
       void ManagedAuthInitializeGeneric::close()

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/clicache/src/impl/ManagedCacheListener.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/impl/ManagedCacheListener.cpp b/src/clicache/src/impl/ManagedCacheListener.cpp
index bb637cd..56292ba 100644
--- a/src/clicache/src/impl/ManagedCacheListener.cpp
+++ b/src/clicache/src/impl/ManagedCacheListener.cpp
@@ -331,7 +331,7 @@ namespace apache
       {
         try {
           Apache::Geode::Client::IRegion<Object^, Object^>^ mregion =
-            Apache::Geode::Client::Region<Object^, Object^>::Create(region.ptr());
+            Apache::Geode::Client::Region<Object^, Object^>::Create(region.get());
 
           m_managedptr->Close(mregion);
         }
@@ -346,7 +346,7 @@ namespace apache
       {
         try {
           Apache::Geode::Client::IRegion<Object^, Object^>^ mregion =
-            Apache::Geode::Client::Region<Object^, Object^>::Create(region.ptr());
+            Apache::Geode::Client::Region<Object^, Object^>::Create(region.get());
           m_managedptr->AfterRegionDisconnected(mregion);
         }
         catch (Apache::Geode::Client::GeodeException^ ex) {

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/clicache/src/impl/ManagedCacheLoader.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/impl/ManagedCacheLoader.cpp b/src/clicache/src/impl/ManagedCacheLoader.cpp
index 1119a35..cba68db 100644
--- a/src/clicache/src/impl/ManagedCacheLoader.cpp
+++ b/src/clicache/src/impl/ManagedCacheLoader.cpp
@@ -224,7 +224,7 @@ namespace apache
 
           ICacheableKey^ mkey = SafeGenericUMKeyConvert( key.ptr( ) );
 
-          IGeodeSerializable^ mcallbackArg = SafeGenericUMSerializableConvert(aCallbackArgument.ptr());
+          IGeodeSerializable^ mcallbackArg = SafeGenericUMSerializableConvert(aCallbackArgument.get());
           */
 
           /*
@@ -239,7 +239,7 @@ namespace apache
         catch (System::Exception^ ex) {
           Apache::Geode::Client::GeodeException::ThrowNative(ex);
         }
-        return NULLPTR;
+        return nullptr;
       }
 
       void ManagedCacheLoaderGeneric::close(const RegionPtr& region)

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/clicache/src/impl/ManagedCacheWriter.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/impl/ManagedCacheWriter.cpp b/src/clicache/src/impl/ManagedCacheWriter.cpp
index b5cee21..e9077ae 100644
--- a/src/clicache/src/impl/ManagedCacheWriter.cpp
+++ b/src/clicache/src/impl/ManagedCacheWriter.cpp
@@ -298,7 +298,7 @@ namespace apache
       {
         try {
           Apache::Geode::Client::IRegion<Object^, Object^>^ mregion =
-            Apache::Geode::Client::Region<Object^, Object^>::Create(rp.ptr());
+            Apache::Geode::Client::Region<Object^, Object^>::Create(rp.get());
 
           m_managedptr->Close(reinterpret_cast<Apache::Geode::Client::Region<Object^, Object^>^>(mregion));
         }

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/clicache/src/impl/ManagedCacheableDelta.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/impl/ManagedCacheableDelta.cpp b/src/clicache/src/impl/ManagedCacheableDelta.cpp
index 259198b..fb58f5a 100644
--- a/src/clicache/src/impl/ManagedCacheableDelta.cpp
+++ b/src/clicache/src/impl/ManagedCacheableDelta.cpp
@@ -213,7 +213,7 @@ namespace apache
         catch (System::Exception^ ex) {
           Apache::Geode::Client::GeodeException::ThrowNative(ex);
         }
-        return NULLPTR;
+        return nullptr;
       }
 
       bool ManagedCacheableDeltaGeneric::operator ==(const apache::geode::client::CacheableKey& other) const
@@ -240,7 +240,7 @@ namespace apache
       bool ManagedCacheableDeltaGeneric::operator == (const ManagedCacheableDeltaGeneric& other) const
       {
         try {
-          return m_managedptr->Equals(other.ptr());
+          return m_managedptr->Equals(other.get());
         }
         catch (Apache::Geode::Client::GeodeException^ ex) {
           ex->ThrowNative();

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/clicache/src/impl/ManagedCacheableDeltaBytes.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/impl/ManagedCacheableDeltaBytes.cpp b/src/clicache/src/impl/ManagedCacheableDeltaBytes.cpp
index 8734ac5..494671d 100644
--- a/src/clicache/src/impl/ManagedCacheableDeltaBytes.cpp
+++ b/src/clicache/src/impl/ManagedCacheableDeltaBytes.cpp
@@ -230,7 +230,7 @@ namespace apache
         catch (System::Exception^ ex) {
           Apache::Geode::Client::GeodeException::ThrowNative(ex);
         }
-        return NULLPTR;
+        return nullptr;
       }
 
       Apache::Geode::Client::IGeodeDelta^
@@ -288,10 +288,10 @@ namespace apache
           Apache::Geode::Client::IGeodeSerializable^ obj =
             Apache::Geode::Client::Serializable::GetTypeFactoryMethodGeneric(m_classId)();
           obj->FromData(%mg_input);
-          bool ret = obj->Equals(other.ptr());
+          bool ret = obj->Equals(other.get());
           Apache::Geode::Client::Log::Debug("ManagedCacheableDeltaBytesGeneric::equal return VAL = " + ret);
           return ret;
-          //return obj->Equals(other.ptr());
+          //return obj->Equals(other.get());
         }
         catch (Apache::Geode::Client::GeodeException^ ex) {
           ex->ThrowNative();

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/clicache/src/impl/ManagedCacheableKey.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/impl/ManagedCacheableKey.cpp b/src/clicache/src/impl/ManagedCacheableKey.cpp
index 9305e7b..e990c20 100644
--- a/src/clicache/src/impl/ManagedCacheableKey.cpp
+++ b/src/clicache/src/impl/ManagedCacheableKey.cpp
@@ -160,7 +160,7 @@ namespace apache
         catch (System::Exception^ ex) {
           Apache::Geode::Client::GeodeException::ThrowNative(ex);
         }
-        return NULLPTR;
+        return nullptr;
       }
 
       bool ManagedCacheableKeyGeneric::operator ==(const apache::geode::client::CacheableKey& other) const
@@ -191,7 +191,7 @@ namespace apache
         try {
           return static_cast<Apache::Geode::Client::ICacheableKey^>(
             (Apache::Geode::Client::IGeodeSerializable^)(Apache::Geode::Client::IGeodeSerializable^)m_managedptr)->Equals(
-            static_cast<Apache::Geode::Client::ICacheableKey^>(other.ptr()));
+            static_cast<Apache::Geode::Client::ICacheableKey^>(other.get()));
         }
         catch (Apache::Geode::Client::GeodeException^ ex) {
           ex->ThrowNative();

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/clicache/src/impl/ManagedCacheableKeyBytes.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/impl/ManagedCacheableKeyBytes.cpp b/src/clicache/src/impl/ManagedCacheableKeyBytes.cpp
index 02f27e2..d8c5b56 100644
--- a/src/clicache/src/impl/ManagedCacheableKeyBytes.cpp
+++ b/src/clicache/src/impl/ManagedCacheableKeyBytes.cpp
@@ -173,7 +173,7 @@ namespace apache
         catch (System::Exception^ ex) {
           Apache::Geode::Client::GeodeException::ThrowNative(ex);
         }
-        return NULLPTR;
+        return nullptr;
       }
 
       bool ManagedCacheableKeyBytesGeneric::operator ==(const apache::geode::client::CacheableKey& other) const
@@ -214,10 +214,10 @@ namespace apache
           Apache::Geode::Client::IGeodeSerializable^ obj =
             Apache::Geode::Client::Serializable::GetTypeFactoryMethodGeneric(m_classId)();
           obj->FromData(%mg_input);
-          bool ret = obj->Equals(other.ptr());
+          bool ret = obj->Equals(other.get());
           Apache::Geode::Client::Log::Debug("ManagedCacheableKeyBytesGeneric::equal return VAL = " + ret);
           return ret;
-          //return obj->Equals(other.ptr());
+          //return obj->Equals(other.get());
         }
         catch (Apache::Geode::Client::GeodeException^ ex) {
           ex->ThrowNative();

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/clicache/src/impl/ManagedCqStatusListener.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/impl/ManagedCqStatusListener.hpp b/src/clicache/src/impl/ManagedCqStatusListener.hpp
index b0f5591..344e0c6 100644
--- a/src/clicache/src/impl/ManagedCqStatusListener.hpp
+++ b/src/clicache/src/impl/ManagedCqStatusListener.hpp
@@ -82,7 +82,7 @@ namespace apache {
         /// The error can appear while applying query condition on the event.
         /// e.g if the event doesn't has attributes as specified in the CQ query.
         /// This event does contain an error. The newValue may or may not be 
-        /// available, and will be NULLPTR if not available.
+        /// available, and will be nullptr if not available.
         /// </summary>
         virtual void onError(const apache::geode::client::CqEvent& ev);
 

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/clicache/src/impl/ManagedFixedPartitionResolver.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/impl/ManagedFixedPartitionResolver.cpp b/src/clicache/src/impl/ManagedFixedPartitionResolver.cpp
index 23310f5..26f3f3b 100644
--- a/src/clicache/src/impl/ManagedFixedPartitionResolver.cpp
+++ b/src/clicache/src/impl/ManagedFixedPartitionResolver.cpp
@@ -225,7 +225,7 @@ namespace apache
         catch (System::Exception^ ex) {
           Apache::Geode::Client::GeodeException::ThrowNative(ex);
         }
-        return NULLPTR;
+        return nullptr;
       }
 
       const char* ManagedFixedPartitionResolverGeneric::getName()

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/clicache/src/impl/ManagedPartitionResolver.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/impl/ManagedPartitionResolver.cpp b/src/clicache/src/impl/ManagedPartitionResolver.cpp
index 5958ce5..51279c5 100644
--- a/src/clicache/src/impl/ManagedPartitionResolver.cpp
+++ b/src/clicache/src/impl/ManagedPartitionResolver.cpp
@@ -229,7 +229,7 @@ namespace apache
         catch (System::Exception^ ex) {
           Apache::Geode::Client::GeodeException::ThrowNative(ex);
         }
-        return NULLPTR;
+        return nullptr;
       }
 
       const char* ManagedPartitionResolverGeneric::getName()

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/clicache/src/impl/ManagedResultCollector.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/impl/ManagedResultCollector.cpp b/src/clicache/src/impl/ManagedResultCollector.cpp
index 8874eec..2ac9e0a 100644
--- a/src/clicache/src/impl/ManagedResultCollector.cpp
+++ b/src/clicache/src/impl/ManagedResultCollector.cpp
@@ -149,7 +149,7 @@ namespace apache
       void ManagedResultCollectorGeneric::addResult(CacheablePtr& result)
       {
         try {
-          //Apache::Geode::Client::IGeodeSerializable^ res = SafeUMSerializableConvertGeneric(result.ptr());
+          //Apache::Geode::Client::IGeodeSerializable^ res = SafeUMSerializableConvertGeneric(result.get());
           Object^ rs = Apache::Geode::Client::Serializable::GetManagedValueGeneric<Object^>(result);
           m_managedptr->AddResult(rs);
           //m_managedptr->AddResult( SafeUMSerializableConvert( result.ptr( ) ) );
@@ -190,7 +190,7 @@ namespace apache
           ex_str += mg_exStr.CharPtr;
           throw apache::geode::client::IllegalArgumentException(ex_str.c_str());
         }
-        return NULLPTR;
+        return nullptr;
       }
       void ManagedResultCollectorGeneric::endResults()
       {

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/clicache/src/impl/ManagedTransactionListener.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/impl/ManagedTransactionListener.cpp b/src/clicache/src/impl/ManagedTransactionListener.cpp
index be829bd..99a683b 100644
--- a/src/clicache/src/impl/ManagedTransactionListener.cpp
+++ b/src/clicache/src/impl/ManagedTransactionListener.cpp
@@ -204,7 +204,7 @@ namespace apache
       {
         try {
           Apache::Geode::Client::Log::Error("ManagedTransactionListenerGeneric::afterCommit in");
-          Apache::Geode::Client::TransactionEvent  mevent(te.ptr());
+          Apache::Geode::Client::TransactionEvent  mevent(te.get());
           m_managedptr->AfterCommit(%mevent);
           Apache::Geode::Client::Log::Error("ManagedTransactionListenerGeneric::afterCommit in");
 
@@ -219,7 +219,7 @@ namespace apache
       void ManagedTransactionListenerGeneric::afterFailedCommit(apache::geode::client::TransactionEventPtr& te)
       {
         try {
-          Apache::Geode::Client::TransactionEvent mevent(te.ptr());
+          Apache::Geode::Client::TransactionEvent mevent(te.get());
           m_managedptr->AfterFailedCommit(%mevent);
         }
         catch (Apache::Geode::Client::GeodeException^ ex) {
@@ -232,7 +232,7 @@ namespace apache
       void ManagedTransactionListenerGeneric::afterRollback(apache::geode::client::TransactionEventPtr& te)
       {
         try {
-          Apache::Geode::Client::TransactionEvent mevent(te.ptr());
+          Apache::Geode::Client::TransactionEvent mevent(te.get());
           m_managedptr->AfterRollback(%mevent);
         }
         catch (Apache::Geode::Client::GeodeException^ ex) {

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/clicache/src/impl/ManagedTransactionWriter.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/impl/ManagedTransactionWriter.cpp b/src/clicache/src/impl/ManagedTransactionWriter.cpp
index f319667..bde9cbe 100644
--- a/src/clicache/src/impl/ManagedTransactionWriter.cpp
+++ b/src/clicache/src/impl/ManagedTransactionWriter.cpp
@@ -204,7 +204,7 @@ namespace apache
       void ManagedTransactionWriterGeneric::beforeCommit(apache::geode::client::TransactionEventPtr& te)
       {
         try {
-          Apache::Geode::Client::TransactionEvent  mevent(te.ptr());
+          Apache::Geode::Client::TransactionEvent  mevent(te.get());
           m_managedptr->BeforeCommit(%mevent);
         }
         catch (Apache::Geode::Client::GeodeException^ ex) {

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/clicache/src/impl/ManagedVisitor.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/impl/ManagedVisitor.cpp b/src/clicache/src/impl/ManagedVisitor.cpp
index 101f11e..3ab01a1 100644
--- a/src/clicache/src/impl/ManagedVisitor.cpp
+++ b/src/clicache/src/impl/ManagedVisitor.cpp
@@ -34,8 +34,8 @@ namespace apache
       {
         using namespace Apache::Geode::Client;
         try {
-          ICacheableKey^ mg_key(SafeGenericUMKeyConvert<ICacheableKey^>(key.ptr()));
-          IGeodeSerializable^ mg_value(SafeUMSerializableConvertGeneric(value.ptr()));
+          ICacheableKey^ mg_key(SafeGenericUMKeyConvert<ICacheableKey^>(key.get()));
+          IGeodeSerializable^ mg_value(SafeUMSerializableConvertGeneric(value.get()));
 
           m_visitor->Invoke(mg_key, (Apache::Geode::Client::IGeodeSerializable^)mg_value);
         }

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/clicache/src/impl/PdxHelper.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/impl/PdxHelper.cpp b/src/clicache/src/impl/PdxHelper.cpp
index 769710d..03929b2 100644
--- a/src/clicache/src/impl/PdxHelper.cpp
+++ b/src/clicache/src/impl/PdxHelper.cpp
@@ -45,7 +45,7 @@ namespace Apache
         CacheImpl* getCacheImpl()
         {
           CachePtr cache = CacheFactory::getAnyInstance();
-          if (cache == NULLPTR)
+          if (cache == nullptr)
           {
             throw gcnew IllegalStateException("cache has not been created yet.");;
           }
@@ -53,7 +53,7 @@ namespace Apache
           {
             throw gcnew IllegalStateException("cache has been closed. ");
           }      
-          return CacheRegionHelper::getCacheImpl(cache.ptr());
+          return CacheRegionHelper::getCacheImpl(cache.get());
         }
         
         void PdxHelper::SerializePdx(DataOutput^ dataOutput, IPdxSerializable^ pdxObject)

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/clicache/src/impl/PdxInstanceImpl.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/impl/PdxInstanceImpl.cpp b/src/clicache/src/impl/PdxInstanceImpl.cpp
index e4c181e..57027df 100755
--- a/src/clicache/src/impl/PdxInstanceImpl.cpp
+++ b/src/clicache/src/impl/PdxInstanceImpl.cpp
@@ -86,7 +86,7 @@ namespace Apache
           //dataInput->ResetPdx(0);
 
           CachePtr cache = CacheFactory::getAnyInstance();
-          if (cache == NULLPTR)
+          if (cache == nullptr)
           {
             throw gcnew IllegalStateException("cache has not been created yet.");;
           }
@@ -94,7 +94,7 @@ namespace Apache
           {
             throw gcnew IllegalStateException("cache has been closed. ");
           }
-          CacheImpl* cacheImpl = CacheRegionHelper::getCacheImpl(cache.ptr());
+          CacheImpl* cacheImpl = CacheRegionHelper::getCacheImpl(cache.get());
           if (cacheImpl != NULL) {
             Utils::updateStatOpTime(cacheImpl->m_cacheStats->getStat(),
                                     cacheImpl->m_cacheStats->getPdxInstanceDeserializationTimeId(),

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/clicache/src/impl/PdxManagedCacheableKey.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/impl/PdxManagedCacheableKey.cpp b/src/clicache/src/impl/PdxManagedCacheableKey.cpp
index 646329e..003a3f4 100644
--- a/src/clicache/src/impl/PdxManagedCacheableKey.cpp
+++ b/src/clicache/src/impl/PdxManagedCacheableKey.cpp
@@ -153,7 +153,7 @@ namespace apache
         catch (System::Exception^ ex) {
           Apache::Geode::Client::GeodeException::ThrowNative(ex);
         }
-        return NULLPTR;
+        return nullptr;
       }
 
       bool PdxManagedCacheableKey::operator ==(const apache::geode::client::CacheableKey& other) const
@@ -180,7 +180,7 @@ namespace apache
       bool PdxManagedCacheableKey::operator ==(const PdxManagedCacheableKey& other) const
       {
         try {
-          return ((Apache::Geode::Client::IPdxSerializable^)m_managedptr)->Equals((other.ptr()));
+          return ((Apache::Geode::Client::IPdxSerializable^)m_managedptr)->Equals((other.get()));
         }
         catch (Apache::Geode::Client::GeodeException^ ex) {
           ex->ThrowNative();
@@ -295,7 +295,7 @@ namespace apache
         catch (System::Exception^ ex) {
           Apache::Geode::Client::GeodeException::ThrowNative(ex);
         }
-        return NULLPTR;
+        return nullptr;
       }
     }  // namespace client
   }  // namespace geode

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/clicache/src/impl/PdxManagedCacheableKeyBytes.cpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/impl/PdxManagedCacheableKeyBytes.cpp b/src/clicache/src/impl/PdxManagedCacheableKeyBytes.cpp
index 3f619e3..5cc34de 100644
--- a/src/clicache/src/impl/PdxManagedCacheableKeyBytes.cpp
+++ b/src/clicache/src/impl/PdxManagedCacheableKeyBytes.cpp
@@ -176,7 +176,7 @@ namespace apache
         catch (System::Exception^ ex) {
           Apache::Geode::Client::GeodeException::ThrowNative(ex);
         }
-        return NULLPTR;
+        return nullptr;
       }
 
       bool PdxManagedCacheableKeyBytes::operator ==(const apache::geode::client::CacheableKey& other) const
@@ -219,10 +219,10 @@ namespace apache
             Apache::Geode::Client::Serializable::GetTypeFactoryMethodGeneric(m_classId)();
             obj->FromData(%mg_input);*/
           Apache::Geode::Client::IPdxSerializable^ obj = getManagedObject();
-          bool ret = obj->Equals(other.ptr());
+          bool ret = obj->Equals(other.get());
           // Apache::Geode::Client::Log::Debug("PdxManagedCacheableKeyBytes::equal return VAL = " + ret);
           return ret;
-          //return obj->Equals(other.ptr());
+          //return obj->Equals(other.get());
         }
         catch (Apache::Geode::Client::GeodeException^ ex) {
           ex->ThrowNative();
@@ -364,7 +364,7 @@ namespace apache
         catch (System::Exception^ ex) {
           Apache::Geode::Client::GeodeException::ThrowNative(ex);
         }
-        return NULLPTR;
+        return nullptr;
       }
 
     }  // namespace client

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/clicache/src/impl/PersistenceManagerProxy.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/impl/PersistenceManagerProxy.hpp b/src/clicache/src/impl/PersistenceManagerProxy.hpp
index 80a5452..fbbbb5e 100644
--- a/src/clicache/src/impl/PersistenceManagerProxy.hpp
+++ b/src/clicache/src/impl/PersistenceManagerProxy.hpp
@@ -64,8 +64,8 @@ namespace Apache
 
             virtual void init(const RegionPtr& region, PropertiesPtr& diskProperties)
             {
-              IRegion<TKey, TValue>^ gRegion = Region<TKey, TValue>::Create(region.ptr());
-              Properties<String^, String^>^ gProps = Properties<String^, String^>::Create<String^, String^>(diskProperties.ptr());
+              IRegion<TKey, TValue>^ gRegion = Region<TKey, TValue>::Create(region.get());
+              Properties<String^, String^>^ gProps = Properties<String^, String^>::Create<String^, String^>(diskProperties.get());
               m_persistenceManager->Init(gRegion, gProps);
             }
             

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/clicache/src/impl/SafeConvert.hpp
----------------------------------------------------------------------
diff --git a/src/clicache/src/impl/SafeConvert.hpp b/src/clicache/src/impl/SafeConvert.hpp
index 007a8a7..8f8d091 100644
--- a/src/clicache/src/impl/SafeConvert.hpp
+++ b/src/clicache/src/impl/SafeConvert.hpp
@@ -394,7 +394,7 @@ namespace Apache
       inline static apache::geode::client::CacheableKey* SafeGenericMKeyConvert( TKey mg_obj )
       {
         if (mg_obj == nullptr) return NULL;
-        apache::geode::client::CacheableKey* obj = Apache::Geode::Client::Serializable::GetUnmanagedValueGeneric<TKey>( mg_obj ).ptr();
+        apache::geode::client::CacheableKey* obj = Apache::Geode::Client::Serializable::GetUnmanagedValueGeneric<TKey>( mg_obj ).get();
         if (obj != nullptr)
         {
           return obj;

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/cppcache/include/geode/AttributesFactory.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/geode/AttributesFactory.hpp b/src/cppcache/include/geode/AttributesFactory.hpp
index 2775ea5..8ccb973 100644
--- a/src/cppcache/include/geode/AttributesFactory.hpp
+++ b/src/cppcache/include/geode/AttributesFactory.hpp
@@ -60,18 +60,18 @@ namespace client {
  * <h3>Attributes</h3>
  * <h4>Callbacks</h4>
  * <dl>
- * <dt>{@link CacheLoader} [<em>default:</em> NULLPTR]</dt>
+ * <dt>{@link CacheLoader} [<em>default:</em> nullptr]</dt>
  *     <dd>User-implemented plug-in for loading data on cache misses.<br>
  *        {@link #setCacheLoader} {@link RegionAttributes#getCacheLoader}
  *        {@link AttributesMutator#setCacheLoader}</dd>
  *
- * <dt>{@link CacheWriter} [<em>default:</em> NULLPTR]</dt>
+ * <dt>{@link CacheWriter} [<em>default:</em> nullptr]</dt>
  *     <dd>User-implemented plug-in for intercepting cache modifications, e.g.
  *         for writing to an external data source.<br>
  *         {@link #setCacheWriter} {@link RegionAttributes#getCacheWriter}
  *         {@link AttributesMutator#setCacheWriter}</dd>
  *
- * <dt>{@link CacheListener} [<em>default:</em> NULLPTR]</dt>
+ * <dt>{@link CacheListener} [<em>default:</em> nullptr]</dt>
  *     <dd>User-implemented plug-in for receiving and handling cache related
  * events.<br>
  *         {@link #setCacheListener} {@link RegionAttributes#getCacheListener}
@@ -179,23 +179,23 @@ class CPPCACHE_EXPORT AttributesFactory : public SharedBase {
   // CALLBACKS
 
   /** Sets the cache loader for the next <code>RegionAttributes</code> created.
-   * @param cacheLoader the cache loader or NULLPTR if no loader
+   * @param cacheLoader the cache loader or nullptr if no loader
    */
   void setCacheLoader(const CacheLoaderPtr& cacheLoader);
 
   /** Sets the cache writer for the next <code>RegionAttributes</code> created.
-   * @param cacheWriter the cache writer or NULLPTR if no cache writer
+   * @param cacheWriter the cache writer or nullptr if no cache writer
    */
   void setCacheWriter(const CacheWriterPtr& cacheWriter);
 
   /** Sets the CacheListener for the next <code>RegionAttributes</code> created.
-   * @param aListener a user defined CacheListener, NULLPTR if no listener
+   * @param aListener a user defined CacheListener, nullptr if no listener
    */
   void setCacheListener(const CacheListenerPtr& aListener);
 
   /** Sets the PartitionResolver for the next <code>RegionAttributes</code>
    * created.
-   * @param aResolver a user defined PartitionResolver, NULLPTR if no resolver
+   * @param aResolver a user defined PartitionResolver, nullptr if no resolver
    */
   void setPartitionResolver(const PartitionResolverPtr& aResolver);
 
@@ -265,15 +265,15 @@ class CPPCACHE_EXPORT AttributesFactory : public SharedBase {
    * this must be used to set the PersistenceManager.
    */
   void setPersistenceManager(const char* libpath, const char* factoryFuncName,
-                             const PropertiesPtr& config = NULLPTR);
+                             const PropertiesPtr& config = nullptr);
 
   /** Sets the PersistenceManager for the next <code>RegionAttributes</code>
   * created.
-  * @param persistenceManager a user defined PersistenceManager, NULLPTR if no
+  * @param persistenceManager a user defined PersistenceManager, nullptr if no
   * resolver
   */
   void setPersistenceManager(const PersistenceManagerPtr& persistenceManager,
-                             const PropertiesPtr& config = NULLPTR);
+                             const PropertiesPtr& config = nullptr);
 
  public:
   // DISTRIBUTION ATTRIBUTES
@@ -369,7 +369,7 @@ class CPPCACHE_EXPORT AttributesFactory : public SharedBase {
    * @throws IllegalStateException if the current settings violate the
    * compatibility rules
    */
-  RegionAttributesPtr createRegionAttributes();
+  std::unique_ptr<RegionAttributes> createRegionAttributes();
 
  private:
   RegionAttributes m_regionAttributes;

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/cppcache/include/geode/Cache.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/geode/Cache.hpp b/src/cppcache/include/geode/Cache.hpp
index e29c9f2..569c85a 100644
--- a/src/cppcache/include/geode/Cache.hpp
+++ b/src/cppcache/include/geode/Cache.hpp
@@ -42,6 +42,7 @@ namespace client {
 class CacheFactory;
 class CacheRegionHelper;
 class Pool;
+class CacheImpl;
 
 /**
  * @class Cache Cache.hpp
@@ -56,7 +57,8 @@ class Pool;
  * <p>A cache can have multiple root regions, each with a different name.
  *
  */
-class CPPCACHE_EXPORT Cache : public GeodeCache {
+class CPPCACHE_EXPORT Cache : public GeodeCache,
+                              public std::enable_shared_from_this<Cache> {
   /**
    * @brief public methods
    */
@@ -131,7 +133,7 @@ class CPPCACHE_EXPORT Cache : public GeodeCache {
    * Cache#createAuthenticatedView(PropertiesPtr).
    *
    * @param path the region's name, such as <code>AuthRegion</code>.
-   * @returns region, or NULLPTR if no such region exists.
+   * @returns region, or nullptr if no such region exists.
    */
   virtual RegionPtr getRegion(const char* path);
 
@@ -228,14 +230,12 @@ class CPPCACHE_EXPORT Cache : public GeodeCache {
   /**
    * @brief constructors
    */
-  Cache(const char* name, DistributedSystemPtr sys, bool ignorePdxUnreadFields,
-        bool readPdxSerialized);
   Cache(const char* name, DistributedSystemPtr sys, const char* id_data,
         bool ignorePdxUnreadFields, bool readPdxSerialized);
-  CacheImpl* m_cacheImpl;
+  std::unique_ptr<CacheImpl> m_cacheImpl;
 
  protected:
-  Cache() { m_cacheImpl = NULL; }
+  Cache();
 
   static bool isPoolInMultiuserMode(RegionPtr regionPtr);
 
@@ -245,6 +245,8 @@ class CPPCACHE_EXPORT Cache : public GeodeCache {
   friend class FunctionService;
   friend class CacheXmlCreation;
   friend class RegionXmlCreation;
+
+  FRIEND_STD_SHARED_PTR(Cache)
 };
 }  // namespace client
 }  // namespace geode

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/cppcache/include/geode/CacheFactory.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/geode/CacheFactory.hpp b/src/cppcache/include/geode/CacheFactory.hpp
index c58cd73..5d519bb 100644
--- a/src/cppcache/include/geode/CacheFactory.hpp
+++ b/src/cppcache/include/geode/CacheFactory.hpp
@@ -45,7 +45,9 @@ class CppCacheLibrary;
  * For the default values for the pool attributes see {@link PoolFactory}.
  * To create additional {@link Pool}s see {@link PoolManager}
  */
-class CPPCACHE_EXPORT CacheFactory : public SharedBase {
+class CPPCACHE_EXPORT CacheFactory
+    : public SharedBase,
+      public std::enable_shared_from_this<CacheFactory> {
  public:
   /**
    * To create the instance of {@link CacheFactory}
@@ -53,7 +55,7 @@ class CPPCACHE_EXPORT CacheFactory : public SharedBase {
    *        Properties which are applicable at client level.
    */
   static CacheFactoryPtr createCacheFactory(
-      const PropertiesPtr& dsProps = NULLPTR);
+      const PropertiesPtr& dsProps = nullptr);
 
   /**
    * To create the instance of {@link Cache}.
@@ -466,9 +468,9 @@ class CPPCACHE_EXPORT CacheFactory : public SharedBase {
 
   PoolFactoryPtr getPoolFactory();
 
-  CachePtr create(const char* name, DistributedSystemPtr system = NULLPTR,
+  CachePtr create(const char* name, DistributedSystemPtr system = nullptr,
                   const char* cacheXml = 0,
-                  const CacheAttributesPtr& attrs = NULLPTR);
+                  const CacheAttributesPtr& attrs = nullptr);
 
   static void create_(const char* name, DistributedSystemPtr& system,
                       const char* id_data, CachePtr& cptr,
@@ -477,8 +479,14 @@ class CPPCACHE_EXPORT CacheFactory : public SharedBase {
   // no instances allowed
   CacheFactory();
   CacheFactory(const PropertiesPtr dsProps);
+
+ public:
+  // TODO shared_ptr - this should be private, fix friend
   ~CacheFactory();
 
+ private:
+  FRIEND_STD_SHARED_PTR(CacheFactory)
+
   PoolPtr determineDefaultPool(CachePtr cachePtr);
 
   static CachePtr getAnyInstance(bool throwException);

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/cppcache/include/geode/CacheListener.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/geode/CacheListener.hpp b/src/cppcache/include/geode/CacheListener.hpp
index 14f7789..87ff012 100644
--- a/src/cppcache/include/geode/CacheListener.hpp
+++ b/src/cppcache/include/geode/CacheListener.hpp
@@ -87,7 +87,7 @@ class CPPCACHE_EXPORT CacheListener : public SharedBase {
 
   /** Handles the event of a new key being added to a region. The entry
    * did not previously exist in this region in the local cache (even with a
-   * NULLPTR value).
+   * nullptr value).
    *
    * @param event denotes the event object associated with the entry creation
    * This function does not throw any exception.
@@ -101,7 +101,7 @@ class CPPCACHE_EXPORT CacheListener : public SharedBase {
    * entry
    * previously existed in this region in the local cache, but its previous
    * value
-   * may have been NULLPTR.
+   * may have been nullptr.
    *
    * @param event EntryEvent denotes the event object associated with updating
    * the entry

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/cppcache/include/geode/CacheLoader.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/geode/CacheLoader.hpp b/src/cppcache/include/geode/CacheLoader.hpp
index 71c9042..b205f79 100644
--- a/src/cppcache/include/geode/CacheLoader.hpp
+++ b/src/cppcache/include/geode/CacheLoader.hpp
@@ -44,7 +44,7 @@ namespace client {
  * Allows data to be loaded from a 3rd party data source and placed
  * into the region
  * When {@link Region::get} is called for a region
- * entry that has a <code>NULLPTR</code> value, the
+ * entry that has a <code>nullptr</code> value, the
  * {@link CacheLoader::load} method of the
  * region's cache loader is invoked.  The <code>load</code> method
  * creates the value for the desired key by performing an operation such
@@ -62,8 +62,8 @@ class CPPCACHE_EXPORT CacheLoader : public SharedBase {
    * by the invocation of {@link Region::get} that triggered this load.
    * @param rp a Region Pointer for which this is called.
    * @param key the key for the cacheable
-   * @param helper any related user data, or NULLPTR
-   * @return the value supplied for this key, or NULLPTR if no value can be
+   * @param helper any related user data, or nullptr
+   * @return the value supplied for this key, or nullptr if no value can be
    * supplied.
    *
    *@see Region::get .

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/cppcache/include/geode/CacheWriter.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/include/geode/CacheWriter.hpp b/src/cppcache/include/geode/CacheWriter.hpp
index b520a34..457ef24 100644
--- a/src/cppcache/include/geode/CacheWriter.hpp
+++ b/src/cppcache/include/geode/CacheWriter.hpp
@@ -94,7 +94,7 @@ class CPPCACHE_EXPORT CacheWriter : public SharedBase {
    * <code>put</code>
    * or a <code>get</code> that causes the loader to update an existing entry.
    * The entry previously existed in the cache where the operation was
-   * initiated, although the old value may have been NULLPTR. The entry being
+   * initiated, although the old value may have been nullptr. The entry being
    * updated may or may not exist in the local cache where the CacheWriter is
    * installed.
    *

http://git-wip-us.apache.org/repos/asf/geode-native/blob/c0098121/src/cppcache/include/geode/Cacheable.inl
----------------------------------------------------------------------
diff --git a/src/cppcache/include/geode/Cacheable.inl b/src/cppcache/include/geode/Cacheable.inl
index 4f7d61f..cfde539 100644
--- a/src/cppcache/include/geode/Cacheable.inl
+++ b/src/cppcache/include/geode/Cacheable.inl
@@ -39,7 +39,7 @@ inline CacheablePtr Cacheable::create( const PRIM value )
 template <typename TVALUE>
 inline CacheablePtr createValue( const SharedPtr< TVALUE >& value )
 {
-  return CacheablePtr( value );
+  return std::dynamic_pointer_cast<Cacheable>(value);
 }
 
 template <typename TVALUE>


Mime
View raw message